netxen_nic_ethtool.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901
  1. /*
  2. * Copyright (C) 2003 - 2006 NetXen, Inc.
  3. * All rights reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License
  7. * as published by the Free Software Foundation; either version 2
  8. * of the License, or (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful, but
  11. * WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the Free Software
  17. * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18. * MA 02111-1307, USA.
  19. *
  20. * The full GNU General Public License is included in this distribution
  21. * in the file called LICENSE.
  22. *
  23. * Contact Information:
  24. * info@netxen.com
  25. * NetXen,
  26. * 3965 Freedom Circle, Fourth floor,
  27. * Santa Clara, CA 95054
  28. *
  29. *
  30. * ethtool support for netxen nic
  31. *
  32. */
  33. #include <linux/types.h>
  34. #include <linux/delay.h>
  35. #include <asm/uaccess.h>
  36. #include <linux/pci.h>
  37. #include <asm/io.h>
  38. #include <linux/netdevice.h>
  39. #include <linux/ethtool.h>
  40. #include "netxen_nic.h"
  41. #include "netxen_nic_hw.h"
  42. #include "netxen_nic_phan_reg.h"
  43. struct netxen_nic_stats {
  44. char stat_string[ETH_GSTRING_LEN];
  45. int sizeof_stat;
  46. int stat_offset;
  47. };
  48. #define NETXEN_NIC_STAT(m) sizeof(((struct netxen_adapter *)0)->m), \
  49. offsetof(struct netxen_adapter, m)
  50. #define NETXEN_NIC_PORT_WINDOW 0x10000
  51. #define NETXEN_NIC_INVALID_DATA 0xDEADBEEF
  52. static const struct netxen_nic_stats netxen_nic_gstrings_stats[] = {
  53. {"rcvd_bad_skb", NETXEN_NIC_STAT(stats.rcvdbadskb)},
  54. {"xmit_called", NETXEN_NIC_STAT(stats.xmitcalled)},
  55. {"xmited_frames", NETXEN_NIC_STAT(stats.xmitedframes)},
  56. {"xmit_finished", NETXEN_NIC_STAT(stats.xmitfinished)},
  57. {"bad_skb_len", NETXEN_NIC_STAT(stats.badskblen)},
  58. {"no_cmd_desc", NETXEN_NIC_STAT(stats.nocmddescriptor)},
  59. {"polled", NETXEN_NIC_STAT(stats.polled)},
  60. {"tx_dropped", NETXEN_NIC_STAT(stats.txdropped)},
  61. {"csummed", NETXEN_NIC_STAT(stats.csummed)},
  62. {"no_rcv", NETXEN_NIC_STAT(stats.no_rcv)},
  63. {"rx_bytes", NETXEN_NIC_STAT(stats.rxbytes)},
  64. {"tx_bytes", NETXEN_NIC_STAT(stats.txbytes)},
  65. };
  66. #define NETXEN_NIC_STATS_LEN ARRAY_SIZE(netxen_nic_gstrings_stats)
  67. static const char netxen_nic_gstrings_test[][ETH_GSTRING_LEN] = {
  68. "Register_Test_on_offline",
  69. "Link_Test_on_offline"
  70. };
  71. #define NETXEN_NIC_TEST_LEN ARRAY_SIZE(netxen_nic_gstrings_test)
  72. #define NETXEN_NIC_REGS_COUNT 42
  73. #define NETXEN_NIC_REGS_LEN (NETXEN_NIC_REGS_COUNT * sizeof(__le32))
  74. #define NETXEN_MAX_EEPROM_LEN 1024
  75. static int netxen_nic_get_eeprom_len(struct net_device *dev)
  76. {
  77. return NETXEN_FLASH_TOTAL_SIZE;
  78. }
  79. static void
  80. netxen_nic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
  81. {
  82. struct netxen_adapter *adapter = netdev_priv(dev);
  83. unsigned long flags;
  84. u32 fw_major = 0;
  85. u32 fw_minor = 0;
  86. u32 fw_build = 0;
  87. strncpy(drvinfo->driver, netxen_nic_driver_name, 32);
  88. strncpy(drvinfo->version, NETXEN_NIC_LINUX_VERSIONID, 32);
  89. write_lock_irqsave(&adapter->adapter_lock, flags);
  90. fw_major = adapter->pci_read_normalize(adapter,
  91. NETXEN_FW_VERSION_MAJOR);
  92. fw_minor = adapter->pci_read_normalize(adapter,
  93. NETXEN_FW_VERSION_MINOR);
  94. fw_build = adapter->pci_read_normalize(adapter,
  95. NETXEN_FW_VERSION_SUB);
  96. write_unlock_irqrestore(&adapter->adapter_lock, flags);
  97. sprintf(drvinfo->fw_version, "%d.%d.%d", fw_major, fw_minor, fw_build);
  98. strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);
  99. drvinfo->regdump_len = NETXEN_NIC_REGS_LEN;
  100. drvinfo->eedump_len = netxen_nic_get_eeprom_len(dev);
  101. }
  102. static int
  103. netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
  104. {
  105. struct netxen_adapter *adapter = netdev_priv(dev);
  106. struct netxen_board_info *boardinfo = &adapter->ahw.boardcfg;
  107. /* read which mode */
  108. if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
  109. ecmd->supported = (SUPPORTED_10baseT_Half |
  110. SUPPORTED_10baseT_Full |
  111. SUPPORTED_100baseT_Half |
  112. SUPPORTED_100baseT_Full |
  113. SUPPORTED_1000baseT_Half |
  114. SUPPORTED_1000baseT_Full);
  115. ecmd->advertising = (ADVERTISED_100baseT_Half |
  116. ADVERTISED_100baseT_Full |
  117. ADVERTISED_1000baseT_Half |
  118. ADVERTISED_1000baseT_Full);
  119. ecmd->port = PORT_TP;
  120. ecmd->speed = adapter->link_speed;
  121. ecmd->duplex = adapter->link_duplex;
  122. ecmd->autoneg = adapter->link_autoneg;
  123. } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
  124. u32 val;
  125. adapter->hw_read_wx(adapter, NETXEN_PORT_MODE_ADDR, &val, 4);
  126. if (val == NETXEN_PORT_MODE_802_3_AP) {
  127. ecmd->supported = SUPPORTED_1000baseT_Full;
  128. ecmd->advertising = ADVERTISED_1000baseT_Full;
  129. } else {
  130. ecmd->supported = SUPPORTED_10000baseT_Full;
  131. ecmd->advertising = ADVERTISED_10000baseT_Full;
  132. }
  133. ecmd->port = PORT_TP;
  134. if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
  135. u16 pcifn = adapter->ahw.pci_func;
  136. adapter->hw_read_wx(adapter,
  137. P3_LINK_SPEED_REG(pcifn), &val, 4);
  138. ecmd->speed = P3_LINK_SPEED_MHZ *
  139. P3_LINK_SPEED_VAL(pcifn, val);
  140. } else
  141. ecmd->speed = SPEED_10000;
  142. ecmd->duplex = DUPLEX_FULL;
  143. ecmd->autoneg = AUTONEG_DISABLE;
  144. } else
  145. return -EIO;
  146. ecmd->phy_address = adapter->physical_port;
  147. ecmd->transceiver = XCVR_EXTERNAL;
  148. switch ((netxen_brdtype_t) boardinfo->board_type) {
  149. case NETXEN_BRDTYPE_P2_SB35_4G:
  150. case NETXEN_BRDTYPE_P2_SB31_2G:
  151. case NETXEN_BRDTYPE_P3_REF_QG:
  152. case NETXEN_BRDTYPE_P3_4_GB:
  153. case NETXEN_BRDTYPE_P3_4_GB_MM:
  154. ecmd->supported |= SUPPORTED_Autoneg;
  155. ecmd->advertising |= ADVERTISED_Autoneg;
  156. case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
  157. case NETXEN_BRDTYPE_P3_10G_CX4:
  158. case NETXEN_BRDTYPE_P3_10G_CX4_LP:
  159. case NETXEN_BRDTYPE_P3_10000_BASE_T:
  160. ecmd->supported |= SUPPORTED_TP;
  161. ecmd->advertising |= ADVERTISED_TP;
  162. ecmd->port = PORT_TP;
  163. ecmd->autoneg = (boardinfo->board_type ==
  164. NETXEN_BRDTYPE_P2_SB31_10G_CX4) ?
  165. (AUTONEG_DISABLE) : (adapter->link_autoneg);
  166. break;
  167. case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
  168. case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
  169. case NETXEN_BRDTYPE_P3_IMEZ:
  170. case NETXEN_BRDTYPE_P3_XG_LOM:
  171. case NETXEN_BRDTYPE_P3_HMEZ:
  172. ecmd->supported |= SUPPORTED_MII;
  173. ecmd->advertising |= ADVERTISED_MII;
  174. ecmd->port = PORT_FIBRE;
  175. ecmd->autoneg = AUTONEG_DISABLE;
  176. break;
  177. case NETXEN_BRDTYPE_P3_10G_SFP_PLUS:
  178. case NETXEN_BRDTYPE_P3_10G_SFP_CT:
  179. case NETXEN_BRDTYPE_P3_10G_SFP_QT:
  180. ecmd->advertising |= ADVERTISED_TP;
  181. ecmd->supported |= SUPPORTED_TP;
  182. case NETXEN_BRDTYPE_P2_SB31_10G:
  183. case NETXEN_BRDTYPE_P3_10G_XFP:
  184. ecmd->supported |= SUPPORTED_FIBRE;
  185. ecmd->advertising |= ADVERTISED_FIBRE;
  186. ecmd->port = PORT_FIBRE;
  187. ecmd->autoneg = AUTONEG_DISABLE;
  188. break;
  189. case NETXEN_BRDTYPE_P3_10G_TP:
  190. if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
  191. ecmd->autoneg = AUTONEG_DISABLE;
  192. ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
  193. ecmd->advertising |=
  194. (ADVERTISED_FIBRE | ADVERTISED_TP);
  195. ecmd->port = PORT_FIBRE;
  196. } else {
  197. ecmd->autoneg = AUTONEG_ENABLE;
  198. ecmd->supported |= (SUPPORTED_TP |SUPPORTED_Autoneg);
  199. ecmd->advertising |=
  200. (ADVERTISED_TP | ADVERTISED_Autoneg);
  201. ecmd->port = PORT_TP;
  202. }
  203. break;
  204. default:
  205. printk(KERN_ERR "netxen-nic: Unsupported board model %d\n",
  206. (netxen_brdtype_t) boardinfo->board_type);
  207. return -EIO;
  208. }
  209. return 0;
  210. }
  211. static int
  212. netxen_nic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
  213. {
  214. struct netxen_adapter *adapter = netdev_priv(dev);
  215. __u32 status;
  216. /* read which mode */
  217. if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
  218. /* autonegotiation */
  219. if (adapter->phy_write
  220. && adapter->phy_write(adapter,
  221. NETXEN_NIU_GB_MII_MGMT_ADDR_AUTONEG,
  222. ecmd->autoneg) != 0)
  223. return -EIO;
  224. else
  225. adapter->link_autoneg = ecmd->autoneg;
  226. if (adapter->phy_read
  227. && adapter->phy_read(adapter,
  228. NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
  229. &status) != 0)
  230. return -EIO;
  231. /* speed */
  232. switch (ecmd->speed) {
  233. case SPEED_10:
  234. netxen_set_phy_speed(status, 0);
  235. break;
  236. case SPEED_100:
  237. netxen_set_phy_speed(status, 1);
  238. break;
  239. case SPEED_1000:
  240. netxen_set_phy_speed(status, 2);
  241. break;
  242. }
  243. /* set duplex mode */
  244. if (ecmd->duplex == DUPLEX_HALF)
  245. netxen_clear_phy_duplex(status);
  246. if (ecmd->duplex == DUPLEX_FULL)
  247. netxen_set_phy_duplex(status);
  248. if (adapter->phy_write
  249. && adapter->phy_write(adapter,
  250. NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
  251. *((int *)&status)) != 0)
  252. return -EIO;
  253. else {
  254. adapter->link_speed = ecmd->speed;
  255. adapter->link_duplex = ecmd->duplex;
  256. }
  257. } else
  258. return -EOPNOTSUPP;
  259. if (!netif_running(dev))
  260. return 0;
  261. dev->netdev_ops->ndo_stop(dev);
  262. return dev->netdev_ops->ndo_open(dev);
  263. }
  264. static int netxen_nic_get_regs_len(struct net_device *dev)
  265. {
  266. return NETXEN_NIC_REGS_LEN;
  267. }
  268. struct netxen_niu_regs {
  269. __u32 reg[NETXEN_NIC_REGS_COUNT];
  270. };
  271. static struct netxen_niu_regs niu_registers[] = {
  272. {
  273. /* GB Mode */
  274. {
  275. NETXEN_NIU_GB_SERDES_RESET,
  276. NETXEN_NIU_GB0_MII_MODE,
  277. NETXEN_NIU_GB1_MII_MODE,
  278. NETXEN_NIU_GB2_MII_MODE,
  279. NETXEN_NIU_GB3_MII_MODE,
  280. NETXEN_NIU_GB0_GMII_MODE,
  281. NETXEN_NIU_GB1_GMII_MODE,
  282. NETXEN_NIU_GB2_GMII_MODE,
  283. NETXEN_NIU_GB3_GMII_MODE,
  284. NETXEN_NIU_REMOTE_LOOPBACK,
  285. NETXEN_NIU_GB0_HALF_DUPLEX,
  286. NETXEN_NIU_GB1_HALF_DUPLEX,
  287. NETXEN_NIU_RESET_SYS_FIFOS,
  288. NETXEN_NIU_GB_CRC_DROP,
  289. NETXEN_NIU_GB_DROP_WRONGADDR,
  290. NETXEN_NIU_TEST_MUX_CTL,
  291. NETXEN_NIU_GB_MAC_CONFIG_0(0),
  292. NETXEN_NIU_GB_MAC_CONFIG_1(0),
  293. NETXEN_NIU_GB_HALF_DUPLEX_CTRL(0),
  294. NETXEN_NIU_GB_MAX_FRAME_SIZE(0),
  295. NETXEN_NIU_GB_TEST_REG(0),
  296. NETXEN_NIU_GB_MII_MGMT_CONFIG(0),
  297. NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
  298. NETXEN_NIU_GB_MII_MGMT_ADDR(0),
  299. NETXEN_NIU_GB_MII_MGMT_CTRL(0),
  300. NETXEN_NIU_GB_MII_MGMT_STATUS(0),
  301. NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
  302. NETXEN_NIU_GB_INTERFACE_CTRL(0),
  303. NETXEN_NIU_GB_INTERFACE_STATUS(0),
  304. NETXEN_NIU_GB_STATION_ADDR_0(0),
  305. NETXEN_NIU_GB_STATION_ADDR_1(0),
  306. -1,
  307. }
  308. },
  309. {
  310. /* XG Mode */
  311. {
  312. NETXEN_NIU_XG_SINGLE_TERM,
  313. NETXEN_NIU_XG_DRIVE_HI,
  314. NETXEN_NIU_XG_DRIVE_LO,
  315. NETXEN_NIU_XG_DTX,
  316. NETXEN_NIU_XG_DEQ,
  317. NETXEN_NIU_XG_WORD_ALIGN,
  318. NETXEN_NIU_XG_RESET,
  319. NETXEN_NIU_XG_POWER_DOWN,
  320. NETXEN_NIU_XG_RESET_PLL,
  321. NETXEN_NIU_XG_SERDES_LOOPBACK,
  322. NETXEN_NIU_XG_DO_BYTE_ALIGN,
  323. NETXEN_NIU_XG_TX_ENABLE,
  324. NETXEN_NIU_XG_RX_ENABLE,
  325. NETXEN_NIU_XG_STATUS,
  326. NETXEN_NIU_XG_PAUSE_THRESHOLD,
  327. NETXEN_NIU_XGE_CONFIG_0,
  328. NETXEN_NIU_XGE_CONFIG_1,
  329. NETXEN_NIU_XGE_IPG,
  330. NETXEN_NIU_XGE_STATION_ADDR_0_HI,
  331. NETXEN_NIU_XGE_STATION_ADDR_0_1,
  332. NETXEN_NIU_XGE_STATION_ADDR_1_LO,
  333. NETXEN_NIU_XGE_STATUS,
  334. NETXEN_NIU_XGE_MAX_FRAME_SIZE,
  335. NETXEN_NIU_XGE_PAUSE_FRAME_VALUE,
  336. NETXEN_NIU_XGE_TX_BYTE_CNT,
  337. NETXEN_NIU_XGE_TX_FRAME_CNT,
  338. NETXEN_NIU_XGE_RX_BYTE_CNT,
  339. NETXEN_NIU_XGE_RX_FRAME_CNT,
  340. NETXEN_NIU_XGE_AGGR_ERROR_CNT,
  341. NETXEN_NIU_XGE_MULTICAST_FRAME_CNT,
  342. NETXEN_NIU_XGE_UNICAST_FRAME_CNT,
  343. NETXEN_NIU_XGE_CRC_ERROR_CNT,
  344. NETXEN_NIU_XGE_OVERSIZE_FRAME_ERR,
  345. NETXEN_NIU_XGE_UNDERSIZE_FRAME_ERR,
  346. NETXEN_NIU_XGE_LOCAL_ERROR_CNT,
  347. NETXEN_NIU_XGE_REMOTE_ERROR_CNT,
  348. NETXEN_NIU_XGE_CONTROL_CHAR_CNT,
  349. NETXEN_NIU_XGE_PAUSE_FRAME_CNT,
  350. -1,
  351. }
  352. }
  353. };
  354. static void
  355. netxen_nic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
  356. {
  357. struct netxen_adapter *adapter = netdev_priv(dev);
  358. __u32 mode, *regs_buff = p;
  359. int i, window;
  360. memset(p, 0, NETXEN_NIC_REGS_LEN);
  361. regs->version = (1 << 24) | (adapter->ahw.revision_id << 16) |
  362. (adapter->pdev)->device;
  363. /* which mode */
  364. adapter->hw_read_wx(adapter, NETXEN_NIU_MODE, &regs_buff[0], 4);
  365. mode = regs_buff[0];
  366. /* Common registers to all the modes */
  367. adapter->hw_read_wx(adapter,
  368. NETXEN_NIU_STRAP_VALUE_SAVE_HIGHER, &regs_buff[2], 4);
  369. /* GB/XGB Mode */
  370. mode = (mode / 2) - 1;
  371. window = 0;
  372. if (mode <= 1) {
  373. for (i = 3; niu_registers[mode].reg[i - 3] != -1; i++) {
  374. /* GB: port specific registers */
  375. if (mode == 0 && i >= 19)
  376. window = adapter->physical_port *
  377. NETXEN_NIC_PORT_WINDOW;
  378. adapter->hw_read_wx(adapter,
  379. niu_registers[mode].reg[i - 3] + window,
  380. &regs_buff[i], 4);
  381. }
  382. }
  383. }
  384. static u32 netxen_nic_test_link(struct net_device *dev)
  385. {
  386. struct netxen_adapter *adapter = netdev_priv(dev);
  387. __u32 status;
  388. int val;
  389. /* read which mode */
  390. if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
  391. if (adapter->phy_read
  392. && adapter->phy_read(adapter,
  393. NETXEN_NIU_GB_MII_MGMT_ADDR_PHY_STATUS,
  394. &status) != 0)
  395. return -EIO;
  396. else {
  397. val = netxen_get_phy_link(status);
  398. return !val;
  399. }
  400. } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
  401. val = adapter->pci_read_normalize(adapter, CRB_XG_STATE);
  402. return (val == XG_LINK_UP) ? 0 : 1;
  403. }
  404. return -EIO;
  405. }
  406. static int
  407. netxen_nic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
  408. u8 * bytes)
  409. {
  410. struct netxen_adapter *adapter = netdev_priv(dev);
  411. int offset;
  412. int ret;
  413. if (eeprom->len == 0)
  414. return -EINVAL;
  415. eeprom->magic = (adapter->pdev)->vendor |
  416. ((adapter->pdev)->device << 16);
  417. offset = eeprom->offset;
  418. ret = netxen_rom_fast_read_words(adapter, offset, bytes,
  419. eeprom->len);
  420. if (ret < 0)
  421. return ret;
  422. return 0;
  423. }
  424. static void
  425. netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
  426. {
  427. struct netxen_adapter *adapter = netdev_priv(dev);
  428. int i;
  429. ring->rx_pending = 0;
  430. ring->rx_jumbo_pending = 0;
  431. for (i = 0; i < MAX_RCV_CTX; ++i) {
  432. ring->rx_pending += adapter->recv_ctx[i].
  433. rds_rings[RCV_DESC_NORMAL_CTXID].max_rx_desc_count;
  434. ring->rx_jumbo_pending += adapter->recv_ctx[i].
  435. rds_rings[RCV_DESC_JUMBO_CTXID].max_rx_desc_count;
  436. }
  437. ring->tx_pending = adapter->max_tx_desc_count;
  438. if (adapter->ahw.board_type == NETXEN_NIC_GBE)
  439. ring->rx_max_pending = MAX_RCV_DESCRIPTORS_1G;
  440. else
  441. ring->rx_max_pending = MAX_RCV_DESCRIPTORS_10G;
  442. ring->tx_max_pending = MAX_CMD_DESCRIPTORS_HOST;
  443. ring->rx_jumbo_max_pending = MAX_JUMBO_RCV_DESCRIPTORS;
  444. ring->rx_mini_max_pending = 0;
  445. ring->rx_mini_pending = 0;
  446. }
  447. static void
  448. netxen_nic_get_pauseparam(struct net_device *dev,
  449. struct ethtool_pauseparam *pause)
  450. {
  451. struct netxen_adapter *adapter = netdev_priv(dev);
  452. __u32 val;
  453. int port = adapter->physical_port;
  454. if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
  455. if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
  456. return;
  457. /* get flow control settings */
  458. netxen_nic_read_w0(adapter,NETXEN_NIU_GB_MAC_CONFIG_0(port),
  459. &val);
  460. pause->rx_pause = netxen_gb_get_rx_flowctl(val);
  461. netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
  462. switch (port) {
  463. case 0:
  464. pause->tx_pause = !(netxen_gb_get_gb0_mask(val));
  465. break;
  466. case 1:
  467. pause->tx_pause = !(netxen_gb_get_gb1_mask(val));
  468. break;
  469. case 2:
  470. pause->tx_pause = !(netxen_gb_get_gb2_mask(val));
  471. break;
  472. case 3:
  473. default:
  474. pause->tx_pause = !(netxen_gb_get_gb3_mask(val));
  475. break;
  476. }
  477. } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
  478. if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
  479. return;
  480. pause->rx_pause = 1;
  481. netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
  482. if (port == 0)
  483. pause->tx_pause = !(netxen_xg_get_xg0_mask(val));
  484. else
  485. pause->tx_pause = !(netxen_xg_get_xg1_mask(val));
  486. } else {
  487. printk(KERN_ERR"%s: Unknown board type: %x\n",
  488. netxen_nic_driver_name, adapter->ahw.board_type);
  489. }
  490. }
  491. static int
  492. netxen_nic_set_pauseparam(struct net_device *dev,
  493. struct ethtool_pauseparam *pause)
  494. {
  495. struct netxen_adapter *adapter = netdev_priv(dev);
  496. __u32 val;
  497. int port = adapter->physical_port;
  498. /* read mode */
  499. if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
  500. if ((port < 0) || (port > NETXEN_NIU_MAX_GBE_PORTS))
  501. return -EIO;
  502. /* set flow control */
  503. netxen_nic_read_w0(adapter,
  504. NETXEN_NIU_GB_MAC_CONFIG_0(port), &val);
  505. if (pause->rx_pause)
  506. netxen_gb_rx_flowctl(val);
  507. else
  508. netxen_gb_unset_rx_flowctl(val);
  509. netxen_nic_write_w0(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
  510. val);
  511. /* set autoneg */
  512. netxen_nic_read_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, &val);
  513. switch (port) {
  514. case 0:
  515. if (pause->tx_pause)
  516. netxen_gb_unset_gb0_mask(val);
  517. else
  518. netxen_gb_set_gb0_mask(val);
  519. break;
  520. case 1:
  521. if (pause->tx_pause)
  522. netxen_gb_unset_gb1_mask(val);
  523. else
  524. netxen_gb_set_gb1_mask(val);
  525. break;
  526. case 2:
  527. if (pause->tx_pause)
  528. netxen_gb_unset_gb2_mask(val);
  529. else
  530. netxen_gb_set_gb2_mask(val);
  531. break;
  532. case 3:
  533. default:
  534. if (pause->tx_pause)
  535. netxen_gb_unset_gb3_mask(val);
  536. else
  537. netxen_gb_set_gb3_mask(val);
  538. break;
  539. }
  540. netxen_nic_write_w0(adapter, NETXEN_NIU_GB_PAUSE_CTL, val);
  541. } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
  542. if ((port < 0) || (port > NETXEN_NIU_MAX_XG_PORTS))
  543. return -EIO;
  544. netxen_nic_read_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, &val);
  545. if (port == 0) {
  546. if (pause->tx_pause)
  547. netxen_xg_unset_xg0_mask(val);
  548. else
  549. netxen_xg_set_xg0_mask(val);
  550. } else {
  551. if (pause->tx_pause)
  552. netxen_xg_unset_xg1_mask(val);
  553. else
  554. netxen_xg_set_xg1_mask(val);
  555. }
  556. netxen_nic_write_w0(adapter, NETXEN_NIU_XG_PAUSE_CTL, val);
  557. } else {
  558. printk(KERN_ERR "%s: Unknown board type: %x\n",
  559. netxen_nic_driver_name,
  560. adapter->ahw.board_type);
  561. }
  562. return 0;
  563. }
  564. static int netxen_nic_reg_test(struct net_device *dev)
  565. {
  566. struct netxen_adapter *adapter = netdev_priv(dev);
  567. u32 data_read, data_written;
  568. netxen_nic_read_w0(adapter, NETXEN_PCIX_PH_REG(0), &data_read);
  569. if ((data_read & 0xffff) != PHAN_VENDOR_ID)
  570. return 1;
  571. data_written = (u32)0xa5a5a5a5;
  572. netxen_nic_reg_write(adapter, CRB_SCRATCHPAD_TEST, data_written);
  573. data_read = adapter->pci_read_normalize(adapter, CRB_SCRATCHPAD_TEST);
  574. if (data_written != data_read)
  575. return 1;
  576. return 0;
  577. }
  578. static int netxen_get_sset_count(struct net_device *dev, int sset)
  579. {
  580. switch (sset) {
  581. case ETH_SS_TEST:
  582. return NETXEN_NIC_TEST_LEN;
  583. case ETH_SS_STATS:
  584. return NETXEN_NIC_STATS_LEN;
  585. default:
  586. return -EOPNOTSUPP;
  587. }
  588. }
  589. static void
  590. netxen_nic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
  591. u64 * data)
  592. {
  593. memset(data, 0, sizeof(uint64_t) * NETXEN_NIC_TEST_LEN);
  594. if ((data[0] = netxen_nic_reg_test(dev)))
  595. eth_test->flags |= ETH_TEST_FL_FAILED;
  596. /* link test */
  597. if ((data[1] = (u64) netxen_nic_test_link(dev)))
  598. eth_test->flags |= ETH_TEST_FL_FAILED;
  599. }
  600. static void
  601. netxen_nic_get_strings(struct net_device *dev, u32 stringset, u8 * data)
  602. {
  603. int index;
  604. switch (stringset) {
  605. case ETH_SS_TEST:
  606. memcpy(data, *netxen_nic_gstrings_test,
  607. NETXEN_NIC_TEST_LEN * ETH_GSTRING_LEN);
  608. break;
  609. case ETH_SS_STATS:
  610. for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
  611. memcpy(data + index * ETH_GSTRING_LEN,
  612. netxen_nic_gstrings_stats[index].stat_string,
  613. ETH_GSTRING_LEN);
  614. }
  615. break;
  616. }
  617. }
  618. static void
  619. netxen_nic_get_ethtool_stats(struct net_device *dev,
  620. struct ethtool_stats *stats, u64 * data)
  621. {
  622. struct netxen_adapter *adapter = netdev_priv(dev);
  623. int index;
  624. for (index = 0; index < NETXEN_NIC_STATS_LEN; index++) {
  625. char *p =
  626. (char *)adapter +
  627. netxen_nic_gstrings_stats[index].stat_offset;
  628. data[index] =
  629. (netxen_nic_gstrings_stats[index].sizeof_stat ==
  630. sizeof(u64)) ? *(u64 *) p : *(u32 *) p;
  631. }
  632. }
  633. static u32 netxen_nic_get_rx_csum(struct net_device *dev)
  634. {
  635. struct netxen_adapter *adapter = netdev_priv(dev);
  636. return adapter->rx_csum;
  637. }
  638. static int netxen_nic_set_rx_csum(struct net_device *dev, u32 data)
  639. {
  640. struct netxen_adapter *adapter = netdev_priv(dev);
  641. adapter->rx_csum = !!data;
  642. return 0;
  643. }
  644. static u32 netxen_nic_get_tso(struct net_device *dev)
  645. {
  646. struct netxen_adapter *adapter = netdev_priv(dev);
  647. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  648. return (dev->features & (NETIF_F_TSO | NETIF_F_TSO6)) != 0;
  649. return (dev->features & NETIF_F_TSO) != 0;
  650. }
  651. static int netxen_nic_set_tso(struct net_device *dev, u32 data)
  652. {
  653. if (data) {
  654. struct netxen_adapter *adapter = netdev_priv(dev);
  655. dev->features |= NETIF_F_TSO;
  656. if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
  657. dev->features |= NETIF_F_TSO6;
  658. } else
  659. dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
  660. return 0;
  661. }
  662. static void
  663. netxen_nic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
  664. {
  665. struct netxen_adapter *adapter = netdev_priv(dev);
  666. u32 wol_cfg = 0;
  667. wol->supported = 0;
  668. wol->wolopts = 0;
  669. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  670. return;
  671. wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG_NV);
  672. if (wol_cfg & (1UL << adapter->portnum))
  673. wol->supported |= WAKE_MAGIC;
  674. wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG);
  675. if (wol_cfg & (1UL << adapter->portnum))
  676. wol->wolopts |= WAKE_MAGIC;
  677. }
  678. static int
  679. netxen_nic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
  680. {
  681. struct netxen_adapter *adapter = netdev_priv(dev);
  682. u32 wol_cfg = 0;
  683. if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
  684. return -EOPNOTSUPP;
  685. if (wol->wolopts & ~WAKE_MAGIC)
  686. return -EOPNOTSUPP;
  687. wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG_NV);
  688. if (!(wol_cfg & (1 << adapter->portnum)))
  689. return -EOPNOTSUPP;
  690. wol_cfg = netxen_nic_reg_read(adapter, NETXEN_WOL_CONFIG);
  691. if (wol->wolopts & WAKE_MAGIC)
  692. wol_cfg |= 1UL << adapter->portnum;
  693. else
  694. wol_cfg &= ~(1UL << adapter->portnum);
  695. netxen_nic_reg_write(adapter, NETXEN_WOL_CONFIG, wol_cfg);
  696. return 0;
  697. }
  698. /*
  699. * Set the coalescing parameters. Currently only normal is supported.
  700. * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the
  701. * firmware coalescing to default.
  702. */
  703. static int netxen_set_intr_coalesce(struct net_device *netdev,
  704. struct ethtool_coalesce *ethcoal)
  705. {
  706. struct netxen_adapter *adapter = netdev_priv(netdev);
  707. if (!NX_IS_REVISION_P3(adapter->ahw.revision_id))
  708. return -EINVAL;
  709. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  710. return -EINVAL;
  711. /*
  712. * Return Error if unsupported values or
  713. * unsupported parameters are set.
  714. */
  715. if (ethcoal->rx_coalesce_usecs > 0xffff ||
  716. ethcoal->rx_max_coalesced_frames > 0xffff ||
  717. ethcoal->tx_coalesce_usecs > 0xffff ||
  718. ethcoal->tx_max_coalesced_frames > 0xffff ||
  719. ethcoal->rx_coalesce_usecs_irq ||
  720. ethcoal->rx_max_coalesced_frames_irq ||
  721. ethcoal->tx_coalesce_usecs_irq ||
  722. ethcoal->tx_max_coalesced_frames_irq ||
  723. ethcoal->stats_block_coalesce_usecs ||
  724. ethcoal->use_adaptive_rx_coalesce ||
  725. ethcoal->use_adaptive_tx_coalesce ||
  726. ethcoal->pkt_rate_low ||
  727. ethcoal->rx_coalesce_usecs_low ||
  728. ethcoal->rx_max_coalesced_frames_low ||
  729. ethcoal->tx_coalesce_usecs_low ||
  730. ethcoal->tx_max_coalesced_frames_low ||
  731. ethcoal->pkt_rate_high ||
  732. ethcoal->rx_coalesce_usecs_high ||
  733. ethcoal->rx_max_coalesced_frames_high ||
  734. ethcoal->tx_coalesce_usecs_high ||
  735. ethcoal->tx_max_coalesced_frames_high)
  736. return -EINVAL;
  737. if (!ethcoal->rx_coalesce_usecs ||
  738. !ethcoal->rx_max_coalesced_frames) {
  739. adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
  740. adapter->coal.normal.data.rx_time_us =
  741. NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US;
  742. adapter->coal.normal.data.rx_packets =
  743. NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS;
  744. } else {
  745. adapter->coal.flags = 0;
  746. adapter->coal.normal.data.rx_time_us =
  747. ethcoal->rx_coalesce_usecs;
  748. adapter->coal.normal.data.rx_packets =
  749. ethcoal->rx_max_coalesced_frames;
  750. }
  751. adapter->coal.normal.data.tx_time_us = ethcoal->tx_coalesce_usecs;
  752. adapter->coal.normal.data.tx_packets =
  753. ethcoal->tx_max_coalesced_frames;
  754. netxen_config_intr_coalesce(adapter);
  755. return 0;
  756. }
  757. static int netxen_get_intr_coalesce(struct net_device *netdev,
  758. struct ethtool_coalesce *ethcoal)
  759. {
  760. struct netxen_adapter *adapter = netdev_priv(netdev);
  761. if (!NX_IS_REVISION_P3(adapter->ahw.revision_id))
  762. return -EINVAL;
  763. if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
  764. return -EINVAL;
  765. ethcoal->rx_coalesce_usecs = adapter->coal.normal.data.rx_time_us;
  766. ethcoal->tx_coalesce_usecs = adapter->coal.normal.data.tx_time_us;
  767. ethcoal->rx_max_coalesced_frames =
  768. adapter->coal.normal.data.rx_packets;
  769. ethcoal->tx_max_coalesced_frames =
  770. adapter->coal.normal.data.tx_packets;
  771. return 0;
  772. }
  773. struct ethtool_ops netxen_nic_ethtool_ops = {
  774. .get_settings = netxen_nic_get_settings,
  775. .set_settings = netxen_nic_set_settings,
  776. .get_drvinfo = netxen_nic_get_drvinfo,
  777. .get_regs_len = netxen_nic_get_regs_len,
  778. .get_regs = netxen_nic_get_regs,
  779. .get_link = ethtool_op_get_link,
  780. .get_eeprom_len = netxen_nic_get_eeprom_len,
  781. .get_eeprom = netxen_nic_get_eeprom,
  782. .get_ringparam = netxen_nic_get_ringparam,
  783. .get_pauseparam = netxen_nic_get_pauseparam,
  784. .set_pauseparam = netxen_nic_set_pauseparam,
  785. .set_tx_csum = ethtool_op_set_tx_csum,
  786. .set_sg = ethtool_op_set_sg,
  787. .get_tso = netxen_nic_get_tso,
  788. .set_tso = netxen_nic_set_tso,
  789. .get_wol = netxen_nic_get_wol,
  790. .set_wol = netxen_nic_set_wol,
  791. .self_test = netxen_nic_diag_test,
  792. .get_strings = netxen_nic_get_strings,
  793. .get_ethtool_stats = netxen_nic_get_ethtool_stats,
  794. .get_sset_count = netxen_get_sset_count,
  795. .get_rx_csum = netxen_nic_get_rx_csum,
  796. .set_rx_csum = netxen_nic_set_rx_csum,
  797. .get_coalesce = netxen_get_intr_coalesce,
  798. .set_coalesce = netxen_set_intr_coalesce,
  799. };