/drivers/net/ethernet/broadcom/tg3.c

http://github.com/mirrors/linux · C · 18321 lines · 13829 code · 3121 blank · 1371 comment · 3395 complexity · f576d86aef186712610d2eaffa15f544 MD5 · raw file

Large files are truncated click here to view the full file

  1. /*
  2. * tg3.c: Broadcom Tigon3 ethernet driver.
  3. *
  4. * Copyright (C) 2001, 2002, 2003, 2004 David S. Miller (davem@redhat.com)
  5. * Copyright (C) 2001, 2002, 2003 Jeff Garzik (jgarzik@pobox.com)
  6. * Copyright (C) 2004 Sun Microsystems Inc.
  7. * Copyright (C) 2005-2016 Broadcom Corporation.
  8. * Copyright (C) 2016-2017 Broadcom Limited.
  9. * Copyright (C) 2018 Broadcom. All Rights Reserved. The term "Broadcom"
  10. * refers to Broadcom Inc. and/or its subsidiaries.
  11. *
  12. * Firmware is:
  13. * Derived from proprietary unpublished source code,
  14. * Copyright (C) 2000-2016 Broadcom Corporation.
  15. * Copyright (C) 2016-2017 Broadcom Ltd.
  16. * Copyright (C) 2018 Broadcom. All Rights Reserved. The term "Broadcom"
  17. * refers to Broadcom Inc. and/or its subsidiaries.
  18. *
  19. * Permission is hereby granted for the distribution of this firmware
  20. * data in hexadecimal or equivalent format, provided this copyright
  21. * notice is accompanying it.
  22. */
  23. #include <linux/module.h>
  24. #include <linux/moduleparam.h>
  25. #include <linux/stringify.h>
  26. #include <linux/kernel.h>
  27. #include <linux/sched/signal.h>
  28. #include <linux/types.h>
  29. #include <linux/compiler.h>
  30. #include <linux/slab.h>
  31. #include <linux/delay.h>
  32. #include <linux/in.h>
  33. #include <linux/interrupt.h>
  34. #include <linux/ioport.h>
  35. #include <linux/pci.h>
  36. #include <linux/netdevice.h>
  37. #include <linux/etherdevice.h>
  38. #include <linux/skbuff.h>
  39. #include <linux/ethtool.h>
  40. #include <linux/mdio.h>
  41. #include <linux/mii.h>
  42. #include <linux/phy.h>
  43. #include <linux/brcmphy.h>
  44. #include <linux/if.h>
  45. #include <linux/if_vlan.h>
  46. #include <linux/ip.h>
  47. #include <linux/tcp.h>
  48. #include <linux/workqueue.h>
  49. #include <linux/prefetch.h>
  50. #include <linux/dma-mapping.h>
  51. #include <linux/firmware.h>
  52. #include <linux/ssb/ssb_driver_gige.h>
  53. #include <linux/hwmon.h>
  54. #include <linux/hwmon-sysfs.h>
  55. #include <linux/crc32poly.h>
  56. #include <net/checksum.h>
  57. #include <net/ip.h>
  58. #include <linux/io.h>
  59. #include <asm/byteorder.h>
  60. #include <linux/uaccess.h>
  61. #include <uapi/linux/net_tstamp.h>
  62. #include <linux/ptp_clock_kernel.h>
  63. #define BAR_0 0
  64. #define BAR_2 2
  65. #include "tg3.h"
  66. /* Functions & macros to verify TG3_FLAGS types */
  67. static inline int _tg3_flag(enum TG3_FLAGS flag, unsigned long *bits)
  68. {
  69. return test_bit(flag, bits);
  70. }
  71. static inline void _tg3_flag_set(enum TG3_FLAGS flag, unsigned long *bits)
  72. {
  73. set_bit(flag, bits);
  74. }
  75. static inline void _tg3_flag_clear(enum TG3_FLAGS flag, unsigned long *bits)
  76. {
  77. clear_bit(flag, bits);
  78. }
  79. #define tg3_flag(tp, flag) \
  80. _tg3_flag(TG3_FLAG_##flag, (tp)->tg3_flags)
  81. #define tg3_flag_set(tp, flag) \
  82. _tg3_flag_set(TG3_FLAG_##flag, (tp)->tg3_flags)
  83. #define tg3_flag_clear(tp, flag) \
  84. _tg3_flag_clear(TG3_FLAG_##flag, (tp)->tg3_flags)
  85. #define DRV_MODULE_NAME "tg3"
  86. /* DO NOT UPDATE TG3_*_NUM defines */
  87. #define TG3_MAJ_NUM 3
  88. #define TG3_MIN_NUM 137
  89. #define RESET_KIND_SHUTDOWN 0
  90. #define RESET_KIND_INIT 1
  91. #define RESET_KIND_SUSPEND 2
  92. #define TG3_DEF_RX_MODE 0
  93. #define TG3_DEF_TX_MODE 0
  94. #define TG3_DEF_MSG_ENABLE \
  95. (NETIF_MSG_DRV | \
  96. NETIF_MSG_PROBE | \
  97. NETIF_MSG_LINK | \
  98. NETIF_MSG_TIMER | \
  99. NETIF_MSG_IFDOWN | \
  100. NETIF_MSG_IFUP | \
  101. NETIF_MSG_RX_ERR | \
  102. NETIF_MSG_TX_ERR)
  103. #define TG3_GRC_LCLCTL_PWRSW_DELAY 100
  104. /* length of time before we decide the hardware is borked,
  105. * and dev->tx_timeout() should be called to fix the problem
  106. */
  107. #define TG3_TX_TIMEOUT (5 * HZ)
  108. /* hardware minimum and maximum for a single frame's data payload */
  109. #define TG3_MIN_MTU ETH_ZLEN
  110. #define TG3_MAX_MTU(tp) \
  111. (tg3_flag(tp, JUMBO_CAPABLE) ? 9000 : 1500)
  112. /* These numbers seem to be hard coded in the NIC firmware somehow.
  113. * You can't change the ring sizes, but you can change where you place
  114. * them in the NIC onboard memory.
  115. */
  116. #define TG3_RX_STD_RING_SIZE(tp) \
  117. (tg3_flag(tp, LRG_PROD_RING_CAP) ? \
  118. TG3_RX_STD_MAX_SIZE_5717 : TG3_RX_STD_MAX_SIZE_5700)
  119. #define TG3_DEF_RX_RING_PENDING 200
  120. #define TG3_RX_JMB_RING_SIZE(tp) \
  121. (tg3_flag(tp, LRG_PROD_RING_CAP) ? \
  122. TG3_RX_JMB_MAX_SIZE_5717 : TG3_RX_JMB_MAX_SIZE_5700)
  123. #define TG3_DEF_RX_JUMBO_RING_PENDING 100
  124. /* Do not place this n-ring entries value into the tp struct itself,
  125. * we really want to expose these constants to GCC so that modulo et
  126. * al. operations are done with shifts and masks instead of with
  127. * hw multiply/modulo instructions. Another solution would be to
  128. * replace things like '% foo' with '& (foo - 1)'.
  129. */
  130. #define TG3_TX_RING_SIZE 512
  131. #define TG3_DEF_TX_RING_PENDING (TG3_TX_RING_SIZE - 1)
  132. #define TG3_RX_STD_RING_BYTES(tp) \
  133. (sizeof(struct tg3_rx_buffer_desc) * TG3_RX_STD_RING_SIZE(tp))
  134. #define TG3_RX_JMB_RING_BYTES(tp) \
  135. (sizeof(struct tg3_ext_rx_buffer_desc) * TG3_RX_JMB_RING_SIZE(tp))
  136. #define TG3_RX_RCB_RING_BYTES(tp) \
  137. (sizeof(struct tg3_rx_buffer_desc) * (tp->rx_ret_ring_mask + 1))
  138. #define TG3_TX_RING_BYTES (sizeof(struct tg3_tx_buffer_desc) * \
  139. TG3_TX_RING_SIZE)
  140. #define NEXT_TX(N) (((N) + 1) & (TG3_TX_RING_SIZE - 1))
  141. #define TG3_DMA_BYTE_ENAB 64
  142. #define TG3_RX_STD_DMA_SZ 1536
  143. #define TG3_RX_JMB_DMA_SZ 9046
  144. #define TG3_RX_DMA_TO_MAP_SZ(x) ((x) + TG3_DMA_BYTE_ENAB)
  145. #define TG3_RX_STD_MAP_SZ TG3_RX_DMA_TO_MAP_SZ(TG3_RX_STD_DMA_SZ)
  146. #define TG3_RX_JMB_MAP_SZ TG3_RX_DMA_TO_MAP_SZ(TG3_RX_JMB_DMA_SZ)
  147. #define TG3_RX_STD_BUFF_RING_SIZE(tp) \
  148. (sizeof(struct ring_info) * TG3_RX_STD_RING_SIZE(tp))
  149. #define TG3_RX_JMB_BUFF_RING_SIZE(tp) \
  150. (sizeof(struct ring_info) * TG3_RX_JMB_RING_SIZE(tp))
  151. /* Due to a hardware bug, the 5701 can only DMA to memory addresses
  152. * that are at least dword aligned when used in PCIX mode. The driver
  153. * works around this bug by double copying the packet. This workaround
  154. * is built into the normal double copy length check for efficiency.
  155. *
  156. * However, the double copy is only necessary on those architectures
  157. * where unaligned memory accesses are inefficient. For those architectures
  158. * where unaligned memory accesses incur little penalty, we can reintegrate
  159. * the 5701 in the normal rx path. Doing so saves a device structure
  160. * dereference by hardcoding the double copy threshold in place.
  161. */
  162. #define TG3_RX_COPY_THRESHOLD 256
  163. #if NET_IP_ALIGN == 0 || defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
  164. #define TG3_RX_COPY_THRESH(tp) TG3_RX_COPY_THRESHOLD
  165. #else
  166. #define TG3_RX_COPY_THRESH(tp) ((tp)->rx_copy_thresh)
  167. #endif
  168. #if (NET_IP_ALIGN != 0)
  169. #define TG3_RX_OFFSET(tp) ((tp)->rx_offset)
  170. #else
  171. #define TG3_RX_OFFSET(tp) (NET_SKB_PAD)
  172. #endif
  173. /* minimum number of free TX descriptors required to wake up TX process */
  174. #define TG3_TX_WAKEUP_THRESH(tnapi) ((tnapi)->tx_pending / 4)
  175. #define TG3_TX_BD_DMA_MAX_2K 2048
  176. #define TG3_TX_BD_DMA_MAX_4K 4096
  177. #define TG3_RAW_IP_ALIGN 2
  178. #define TG3_MAX_UCAST_ADDR(tp) (tg3_flag((tp), ENABLE_ASF) ? 2 : 3)
  179. #define TG3_UCAST_ADDR_IDX(tp) (tg3_flag((tp), ENABLE_ASF) ? 2 : 1)
  180. #define TG3_FW_UPDATE_TIMEOUT_SEC 5
  181. #define TG3_FW_UPDATE_FREQ_SEC (TG3_FW_UPDATE_TIMEOUT_SEC / 2)
  182. #define FIRMWARE_TG3 "tigon/tg3.bin"
  183. #define FIRMWARE_TG357766 "tigon/tg357766.bin"
  184. #define FIRMWARE_TG3TSO "tigon/tg3_tso.bin"
  185. #define FIRMWARE_TG3TSO5 "tigon/tg3_tso5.bin"
  186. MODULE_AUTHOR("David S. Miller (davem@redhat.com) and Jeff Garzik (jgarzik@pobox.com)");
  187. MODULE_DESCRIPTION("Broadcom Tigon3 ethernet driver");
  188. MODULE_LICENSE("GPL");
  189. MODULE_FIRMWARE(FIRMWARE_TG3);
  190. MODULE_FIRMWARE(FIRMWARE_TG3TSO);
  191. MODULE_FIRMWARE(FIRMWARE_TG3TSO5);
  192. static int tg3_debug = -1; /* -1 == use TG3_DEF_MSG_ENABLE as value */
  193. module_param(tg3_debug, int, 0);
  194. MODULE_PARM_DESC(tg3_debug, "Tigon3 bitmapped debugging message enable value");
  195. #define TG3_DRV_DATA_FLAG_10_100_ONLY 0x0001
  196. #define TG3_DRV_DATA_FLAG_5705_10_100 0x0002
  197. static const struct pci_device_id tg3_pci_tbl[] = {
  198. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5700)},
  199. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5701)},
  200. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702)},
  201. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703)},
  202. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704)},
  203. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702FE)},
  204. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705)},
  205. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705_2)},
  206. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M)},
  207. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705M_2)},
  208. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702X)},
  209. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703X)},
  210. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S)},
  211. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702A3)},
  212. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5703A3)},
  213. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5782)},
  214. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5788)},
  215. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5789)},
  216. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901),
  217. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY |
  218. TG3_DRV_DATA_FLAG_5705_10_100},
  219. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5901_2),
  220. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY |
  221. TG3_DRV_DATA_FLAG_5705_10_100},
  222. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5704S_2)},
  223. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5705F),
  224. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY |
  225. TG3_DRV_DATA_FLAG_5705_10_100},
  226. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5721)},
  227. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5722)},
  228. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5750)},
  229. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751)},
  230. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751M)},
  231. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751F),
  232. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  233. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752)},
  234. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752M)},
  235. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753)},
  236. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753M)},
  237. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753F),
  238. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  239. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754)},
  240. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754M)},
  241. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755)},
  242. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755M)},
  243. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5756)},
  244. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5786)},
  245. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787)},
  246. {PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5787M,
  247. PCI_VENDOR_ID_LENOVO,
  248. TG3PCI_SUBDEVICE_ID_LENOVO_5787M),
  249. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  250. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787M)},
  251. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787F),
  252. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  253. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714)},
  254. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5714S)},
  255. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715)},
  256. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5715S)},
  257. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780)},
  258. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5780S)},
  259. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5781)},
  260. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906)},
  261. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5906M)},
  262. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5784)},
  263. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5764)},
  264. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5723)},
  265. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5761)},
  266. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5761E)},
  267. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5761S)},
  268. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5761SE)},
  269. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5785_G)},
  270. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5785_F)},
  271. {PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57780,
  272. PCI_VENDOR_ID_AI, TG3PCI_SUBDEVICE_ID_ACER_57780_A),
  273. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  274. {PCI_DEVICE_SUB(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57780,
  275. PCI_VENDOR_ID_AI, TG3PCI_SUBDEVICE_ID_ACER_57780_B),
  276. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  277. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57780)},
  278. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57760)},
  279. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57790),
  280. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  281. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57788)},
  282. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5717)},
  283. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5717_C)},
  284. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5718)},
  285. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57781)},
  286. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57785)},
  287. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57761)},
  288. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57765)},
  289. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57791),
  290. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  291. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57795),
  292. .driver_data = TG3_DRV_DATA_FLAG_10_100_ONLY},
  293. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5719)},
  294. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5720)},
  295. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57762)},
  296. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57766)},
  297. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5762)},
  298. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5725)},
  299. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5727)},
  300. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57764)},
  301. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57767)},
  302. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57787)},
  303. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57782)},
  304. {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57786)},
  305. {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9DXX)},
  306. {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9MXX)},
  307. {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1000)},
  308. {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1001)},
  309. {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1003)},
  310. {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC9100)},
  311. {PCI_DEVICE(PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_TIGON3)},
  312. {PCI_DEVICE(0x10cf, 0x11a2)}, /* Fujitsu 1000base-SX with BCM5703SKHB */
  313. {}
  314. };
  315. MODULE_DEVICE_TABLE(pci, tg3_pci_tbl);
  316. static const struct {
  317. const char string[ETH_GSTRING_LEN];
  318. } ethtool_stats_keys[] = {
  319. { "rx_octets" },
  320. { "rx_fragments" },
  321. { "rx_ucast_packets" },
  322. { "rx_mcast_packets" },
  323. { "rx_bcast_packets" },
  324. { "rx_fcs_errors" },
  325. { "rx_align_errors" },
  326. { "rx_xon_pause_rcvd" },
  327. { "rx_xoff_pause_rcvd" },
  328. { "rx_mac_ctrl_rcvd" },
  329. { "rx_xoff_entered" },
  330. { "rx_frame_too_long_errors" },
  331. { "rx_jabbers" },
  332. { "rx_undersize_packets" },
  333. { "rx_in_length_errors" },
  334. { "rx_out_length_errors" },
  335. { "rx_64_or_less_octet_packets" },
  336. { "rx_65_to_127_octet_packets" },
  337. { "rx_128_to_255_octet_packets" },
  338. { "rx_256_to_511_octet_packets" },
  339. { "rx_512_to_1023_octet_packets" },
  340. { "rx_1024_to_1522_octet_packets" },
  341. { "rx_1523_to_2047_octet_packets" },
  342. { "rx_2048_to_4095_octet_packets" },
  343. { "rx_4096_to_8191_octet_packets" },
  344. { "rx_8192_to_9022_octet_packets" },
  345. { "tx_octets" },
  346. { "tx_collisions" },
  347. { "tx_xon_sent" },
  348. { "tx_xoff_sent" },
  349. { "tx_flow_control" },
  350. { "tx_mac_errors" },
  351. { "tx_single_collisions" },
  352. { "tx_mult_collisions" },
  353. { "tx_deferred" },
  354. { "tx_excessive_collisions" },
  355. { "tx_late_collisions" },
  356. { "tx_collide_2times" },
  357. { "tx_collide_3times" },
  358. { "tx_collide_4times" },
  359. { "tx_collide_5times" },
  360. { "tx_collide_6times" },
  361. { "tx_collide_7times" },
  362. { "tx_collide_8times" },
  363. { "tx_collide_9times" },
  364. { "tx_collide_10times" },
  365. { "tx_collide_11times" },
  366. { "tx_collide_12times" },
  367. { "tx_collide_13times" },
  368. { "tx_collide_14times" },
  369. { "tx_collide_15times" },
  370. { "tx_ucast_packets" },
  371. { "tx_mcast_packets" },
  372. { "tx_bcast_packets" },
  373. { "tx_carrier_sense_errors" },
  374. { "tx_discards" },
  375. { "tx_errors" },
  376. { "dma_writeq_full" },
  377. { "dma_write_prioq_full" },
  378. { "rxbds_empty" },
  379. { "rx_discards" },
  380. { "rx_errors" },
  381. { "rx_threshold_hit" },
  382. { "dma_readq_full" },
  383. { "dma_read_prioq_full" },
  384. { "tx_comp_queue_full" },
  385. { "ring_set_send_prod_index" },
  386. { "ring_status_update" },
  387. { "nic_irqs" },
  388. { "nic_avoided_irqs" },
  389. { "nic_tx_threshold_hit" },
  390. { "mbuf_lwm_thresh_hit" },
  391. };
  392. #define TG3_NUM_STATS ARRAY_SIZE(ethtool_stats_keys)
  393. #define TG3_NVRAM_TEST 0
  394. #define TG3_LINK_TEST 1
  395. #define TG3_REGISTER_TEST 2
  396. #define TG3_MEMORY_TEST 3
  397. #define TG3_MAC_LOOPB_TEST 4
  398. #define TG3_PHY_LOOPB_TEST 5
  399. #define TG3_EXT_LOOPB_TEST 6
  400. #define TG3_INTERRUPT_TEST 7
  401. static const struct {
  402. const char string[ETH_GSTRING_LEN];
  403. } ethtool_test_keys[] = {
  404. [TG3_NVRAM_TEST] = { "nvram test (online) " },
  405. [TG3_LINK_TEST] = { "link test (online) " },
  406. [TG3_REGISTER_TEST] = { "register test (offline)" },
  407. [TG3_MEMORY_TEST] = { "memory test (offline)" },
  408. [TG3_MAC_LOOPB_TEST] = { "mac loopback test (offline)" },
  409. [TG3_PHY_LOOPB_TEST] = { "phy loopback test (offline)" },
  410. [TG3_EXT_LOOPB_TEST] = { "ext loopback test (offline)" },
  411. [TG3_INTERRUPT_TEST] = { "interrupt test (offline)" },
  412. };
  413. #define TG3_NUM_TEST ARRAY_SIZE(ethtool_test_keys)
  414. static void tg3_write32(struct tg3 *tp, u32 off, u32 val)
  415. {
  416. writel(val, tp->regs + off);
  417. }
  418. static u32 tg3_read32(struct tg3 *tp, u32 off)
  419. {
  420. return readl(tp->regs + off);
  421. }
  422. static void tg3_ape_write32(struct tg3 *tp, u32 off, u32 val)
  423. {
  424. writel(val, tp->aperegs + off);
  425. }
  426. static u32 tg3_ape_read32(struct tg3 *tp, u32 off)
  427. {
  428. return readl(tp->aperegs + off);
  429. }
  430. static void tg3_write_indirect_reg32(struct tg3 *tp, u32 off, u32 val)
  431. {
  432. unsigned long flags;
  433. spin_lock_irqsave(&tp->indirect_lock, flags);
  434. pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
  435. pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
  436. spin_unlock_irqrestore(&tp->indirect_lock, flags);
  437. }
  438. static void tg3_write_flush_reg32(struct tg3 *tp, u32 off, u32 val)
  439. {
  440. writel(val, tp->regs + off);
  441. readl(tp->regs + off);
  442. }
  443. static u32 tg3_read_indirect_reg32(struct tg3 *tp, u32 off)
  444. {
  445. unsigned long flags;
  446. u32 val;
  447. spin_lock_irqsave(&tp->indirect_lock, flags);
  448. pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off);
  449. pci_read_config_dword(tp->pdev, TG3PCI_REG_DATA, &val);
  450. spin_unlock_irqrestore(&tp->indirect_lock, flags);
  451. return val;
  452. }
  453. static void tg3_write_indirect_mbox(struct tg3 *tp, u32 off, u32 val)
  454. {
  455. unsigned long flags;
  456. if (off == (MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW)) {
  457. pci_write_config_dword(tp->pdev, TG3PCI_RCV_RET_RING_CON_IDX +
  458. TG3_64BIT_REG_LOW, val);
  459. return;
  460. }
  461. if (off == TG3_RX_STD_PROD_IDX_REG) {
  462. pci_write_config_dword(tp->pdev, TG3PCI_STD_RING_PROD_IDX +
  463. TG3_64BIT_REG_LOW, val);
  464. return;
  465. }
  466. spin_lock_irqsave(&tp->indirect_lock, flags);
  467. pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off + 0x5600);
  468. pci_write_config_dword(tp->pdev, TG3PCI_REG_DATA, val);
  469. spin_unlock_irqrestore(&tp->indirect_lock, flags);
  470. /* In indirect mode when disabling interrupts, we also need
  471. * to clear the interrupt bit in the GRC local ctrl register.
  472. */
  473. if ((off == (MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW)) &&
  474. (val == 0x1)) {
  475. pci_write_config_dword(tp->pdev, TG3PCI_MISC_LOCAL_CTRL,
  476. tp->grc_local_ctrl|GRC_LCLCTRL_CLEARINT);
  477. }
  478. }
  479. static u32 tg3_read_indirect_mbox(struct tg3 *tp, u32 off)
  480. {
  481. unsigned long flags;
  482. u32 val;
  483. spin_lock_irqsave(&tp->indirect_lock, flags);
  484. pci_write_config_dword(tp->pdev, TG3PCI_REG_BASE_ADDR, off + 0x5600);
  485. pci_read_config_dword(tp->pdev, TG3PCI_REG_DATA, &val);
  486. spin_unlock_irqrestore(&tp->indirect_lock, flags);
  487. return val;
  488. }
  489. /* usec_wait specifies the wait time in usec when writing to certain registers
  490. * where it is unsafe to read back the register without some delay.
  491. * GRC_LOCAL_CTRL is one example if the GPIOs are toggled to switch power.
  492. * TG3PCI_CLOCK_CTRL is another example if the clock frequencies are changed.
  493. */
  494. static void _tw32_flush(struct tg3 *tp, u32 off, u32 val, u32 usec_wait)
  495. {
  496. if (tg3_flag(tp, PCIX_TARGET_HWBUG) || tg3_flag(tp, ICH_WORKAROUND))
  497. /* Non-posted methods */
  498. tp->write32(tp, off, val);
  499. else {
  500. /* Posted method */
  501. tg3_write32(tp, off, val);
  502. if (usec_wait)
  503. udelay(usec_wait);
  504. tp->read32(tp, off);
  505. }
  506. /* Wait again after the read for the posted method to guarantee that
  507. * the wait time is met.
  508. */
  509. if (usec_wait)
  510. udelay(usec_wait);
  511. }
  512. static inline void tw32_mailbox_flush(struct tg3 *tp, u32 off, u32 val)
  513. {
  514. tp->write32_mbox(tp, off, val);
  515. if (tg3_flag(tp, FLUSH_POSTED_WRITES) ||
  516. (!tg3_flag(tp, MBOX_WRITE_REORDER) &&
  517. !tg3_flag(tp, ICH_WORKAROUND)))
  518. tp->read32_mbox(tp, off);
  519. }
  520. static void tg3_write32_tx_mbox(struct tg3 *tp, u32 off, u32 val)
  521. {
  522. void __iomem *mbox = tp->regs + off;
  523. writel(val, mbox);
  524. if (tg3_flag(tp, TXD_MBOX_HWBUG))
  525. writel(val, mbox);
  526. if (tg3_flag(tp, MBOX_WRITE_REORDER) ||
  527. tg3_flag(tp, FLUSH_POSTED_WRITES))
  528. readl(mbox);
  529. }
  530. static u32 tg3_read32_mbox_5906(struct tg3 *tp, u32 off)
  531. {
  532. return readl(tp->regs + off + GRCMBOX_BASE);
  533. }
  534. static void tg3_write32_mbox_5906(struct tg3 *tp, u32 off, u32 val)
  535. {
  536. writel(val, tp->regs + off + GRCMBOX_BASE);
  537. }
  538. #define tw32_mailbox(reg, val) tp->write32_mbox(tp, reg, val)
  539. #define tw32_mailbox_f(reg, val) tw32_mailbox_flush(tp, (reg), (val))
  540. #define tw32_rx_mbox(reg, val) tp->write32_rx_mbox(tp, reg, val)
  541. #define tw32_tx_mbox(reg, val) tp->write32_tx_mbox(tp, reg, val)
  542. #define tr32_mailbox(reg) tp->read32_mbox(tp, reg)
  543. #define tw32(reg, val) tp->write32(tp, reg, val)
  544. #define tw32_f(reg, val) _tw32_flush(tp, (reg), (val), 0)
  545. #define tw32_wait_f(reg, val, us) _tw32_flush(tp, (reg), (val), (us))
  546. #define tr32(reg) tp->read32(tp, reg)
  547. static void tg3_write_mem(struct tg3 *tp, u32 off, u32 val)
  548. {
  549. unsigned long flags;
  550. if (tg3_asic_rev(tp) == ASIC_REV_5906 &&
  551. (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC))
  552. return;
  553. spin_lock_irqsave(&tp->indirect_lock, flags);
  554. if (tg3_flag(tp, SRAM_USE_CONFIG)) {
  555. pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
  556. pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
  557. /* Always leave this as zero. */
  558. pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
  559. } else {
  560. tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, off);
  561. tw32_f(TG3PCI_MEM_WIN_DATA, val);
  562. /* Always leave this as zero. */
  563. tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, 0);
  564. }
  565. spin_unlock_irqrestore(&tp->indirect_lock, flags);
  566. }
  567. static void tg3_read_mem(struct tg3 *tp, u32 off, u32 *val)
  568. {
  569. unsigned long flags;
  570. if (tg3_asic_rev(tp) == ASIC_REV_5906 &&
  571. (off >= NIC_SRAM_STATS_BLK) && (off < NIC_SRAM_TX_BUFFER_DESC)) {
  572. *val = 0;
  573. return;
  574. }
  575. spin_lock_irqsave(&tp->indirect_lock, flags);
  576. if (tg3_flag(tp, SRAM_USE_CONFIG)) {
  577. pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, off);
  578. pci_read_config_dword(tp->pdev, TG3PCI_MEM_WIN_DATA, val);
  579. /* Always leave this as zero. */
  580. pci_write_config_dword(tp->pdev, TG3PCI_MEM_WIN_BASE_ADDR, 0);
  581. } else {
  582. tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, off);
  583. *val = tr32(TG3PCI_MEM_WIN_DATA);
  584. /* Always leave this as zero. */
  585. tw32_f(TG3PCI_MEM_WIN_BASE_ADDR, 0);
  586. }
  587. spin_unlock_irqrestore(&tp->indirect_lock, flags);
  588. }
  589. static void tg3_ape_lock_init(struct tg3 *tp)
  590. {
  591. int i;
  592. u32 regbase, bit;
  593. if (tg3_asic_rev(tp) == ASIC_REV_5761)
  594. regbase = TG3_APE_LOCK_GRANT;
  595. else
  596. regbase = TG3_APE_PER_LOCK_GRANT;
  597. /* Make sure the driver hasn't any stale locks. */
  598. for (i = TG3_APE_LOCK_PHY0; i <= TG3_APE_LOCK_GPIO; i++) {
  599. switch (i) {
  600. case TG3_APE_LOCK_PHY0:
  601. case TG3_APE_LOCK_PHY1:
  602. case TG3_APE_LOCK_PHY2:
  603. case TG3_APE_LOCK_PHY3:
  604. bit = APE_LOCK_GRANT_DRIVER;
  605. break;
  606. default:
  607. if (!tp->pci_fn)
  608. bit = APE_LOCK_GRANT_DRIVER;
  609. else
  610. bit = 1 << tp->pci_fn;
  611. }
  612. tg3_ape_write32(tp, regbase + 4 * i, bit);
  613. }
  614. }
  615. static int tg3_ape_lock(struct tg3 *tp, int locknum)
  616. {
  617. int i, off;
  618. int ret = 0;
  619. u32 status, req, gnt, bit;
  620. if (!tg3_flag(tp, ENABLE_APE))
  621. return 0;
  622. switch (locknum) {
  623. case TG3_APE_LOCK_GPIO:
  624. if (tg3_asic_rev(tp) == ASIC_REV_5761)
  625. return 0;
  626. /* fall through */
  627. case TG3_APE_LOCK_GRC:
  628. case TG3_APE_LOCK_MEM:
  629. if (!tp->pci_fn)
  630. bit = APE_LOCK_REQ_DRIVER;
  631. else
  632. bit = 1 << tp->pci_fn;
  633. break;
  634. case TG3_APE_LOCK_PHY0:
  635. case TG3_APE_LOCK_PHY1:
  636. case TG3_APE_LOCK_PHY2:
  637. case TG3_APE_LOCK_PHY3:
  638. bit = APE_LOCK_REQ_DRIVER;
  639. break;
  640. default:
  641. return -EINVAL;
  642. }
  643. if (tg3_asic_rev(tp) == ASIC_REV_5761) {
  644. req = TG3_APE_LOCK_REQ;
  645. gnt = TG3_APE_LOCK_GRANT;
  646. } else {
  647. req = TG3_APE_PER_LOCK_REQ;
  648. gnt = TG3_APE_PER_LOCK_GRANT;
  649. }
  650. off = 4 * locknum;
  651. tg3_ape_write32(tp, req + off, bit);
  652. /* Wait for up to 1 millisecond to acquire lock. */
  653. for (i = 0; i < 100; i++) {
  654. status = tg3_ape_read32(tp, gnt + off);
  655. if (status == bit)
  656. break;
  657. if (pci_channel_offline(tp->pdev))
  658. break;
  659. udelay(10);
  660. }
  661. if (status != bit) {
  662. /* Revoke the lock request. */
  663. tg3_ape_write32(tp, gnt + off, bit);
  664. ret = -EBUSY;
  665. }
  666. return ret;
  667. }
  668. static void tg3_ape_unlock(struct tg3 *tp, int locknum)
  669. {
  670. u32 gnt, bit;
  671. if (!tg3_flag(tp, ENABLE_APE))
  672. return;
  673. switch (locknum) {
  674. case TG3_APE_LOCK_GPIO:
  675. if (tg3_asic_rev(tp) == ASIC_REV_5761)
  676. return;
  677. /* fall through */
  678. case TG3_APE_LOCK_GRC:
  679. case TG3_APE_LOCK_MEM:
  680. if (!tp->pci_fn)
  681. bit = APE_LOCK_GRANT_DRIVER;
  682. else
  683. bit = 1 << tp->pci_fn;
  684. break;
  685. case TG3_APE_LOCK_PHY0:
  686. case TG3_APE_LOCK_PHY1:
  687. case TG3_APE_LOCK_PHY2:
  688. case TG3_APE_LOCK_PHY3:
  689. bit = APE_LOCK_GRANT_DRIVER;
  690. break;
  691. default:
  692. return;
  693. }
  694. if (tg3_asic_rev(tp) == ASIC_REV_5761)
  695. gnt = TG3_APE_LOCK_GRANT;
  696. else
  697. gnt = TG3_APE_PER_LOCK_GRANT;
  698. tg3_ape_write32(tp, gnt + 4 * locknum, bit);
  699. }
  700. static int tg3_ape_event_lock(struct tg3 *tp, u32 timeout_us)
  701. {
  702. u32 apedata;
  703. while (timeout_us) {
  704. if (tg3_ape_lock(tp, TG3_APE_LOCK_MEM))
  705. return -EBUSY;
  706. apedata = tg3_ape_read32(tp, TG3_APE_EVENT_STATUS);
  707. if (!(apedata & APE_EVENT_STATUS_EVENT_PENDING))
  708. break;
  709. tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
  710. udelay(10);
  711. timeout_us -= (timeout_us > 10) ? 10 : timeout_us;
  712. }
  713. return timeout_us ? 0 : -EBUSY;
  714. }
  715. #ifdef CONFIG_TIGON3_HWMON
  716. static int tg3_ape_wait_for_event(struct tg3 *tp, u32 timeout_us)
  717. {
  718. u32 i, apedata;
  719. for (i = 0; i < timeout_us / 10; i++) {
  720. apedata = tg3_ape_read32(tp, TG3_APE_EVENT_STATUS);
  721. if (!(apedata & APE_EVENT_STATUS_EVENT_PENDING))
  722. break;
  723. udelay(10);
  724. }
  725. return i == timeout_us / 10;
  726. }
  727. static int tg3_ape_scratchpad_read(struct tg3 *tp, u32 *data, u32 base_off,
  728. u32 len)
  729. {
  730. int err;
  731. u32 i, bufoff, msgoff, maxlen, apedata;
  732. if (!tg3_flag(tp, APE_HAS_NCSI))
  733. return 0;
  734. apedata = tg3_ape_read32(tp, TG3_APE_SEG_SIG);
  735. if (apedata != APE_SEG_SIG_MAGIC)
  736. return -ENODEV;
  737. apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
  738. if (!(apedata & APE_FW_STATUS_READY))
  739. return -EAGAIN;
  740. bufoff = tg3_ape_read32(tp, TG3_APE_SEG_MSG_BUF_OFF) +
  741. TG3_APE_SHMEM_BASE;
  742. msgoff = bufoff + 2 * sizeof(u32);
  743. maxlen = tg3_ape_read32(tp, TG3_APE_SEG_MSG_BUF_LEN);
  744. while (len) {
  745. u32 length;
  746. /* Cap xfer sizes to scratchpad limits. */
  747. length = (len > maxlen) ? maxlen : len;
  748. len -= length;
  749. apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
  750. if (!(apedata & APE_FW_STATUS_READY))
  751. return -EAGAIN;
  752. /* Wait for up to 1 msec for APE to service previous event. */
  753. err = tg3_ape_event_lock(tp, 1000);
  754. if (err)
  755. return err;
  756. apedata = APE_EVENT_STATUS_DRIVER_EVNT |
  757. APE_EVENT_STATUS_SCRTCHPD_READ |
  758. APE_EVENT_STATUS_EVENT_PENDING;
  759. tg3_ape_write32(tp, TG3_APE_EVENT_STATUS, apedata);
  760. tg3_ape_write32(tp, bufoff, base_off);
  761. tg3_ape_write32(tp, bufoff + sizeof(u32), length);
  762. tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
  763. tg3_ape_write32(tp, TG3_APE_EVENT, APE_EVENT_1);
  764. base_off += length;
  765. if (tg3_ape_wait_for_event(tp, 30000))
  766. return -EAGAIN;
  767. for (i = 0; length; i += 4, length -= 4) {
  768. u32 val = tg3_ape_read32(tp, msgoff + i);
  769. memcpy(data, &val, sizeof(u32));
  770. data++;
  771. }
  772. }
  773. return 0;
  774. }
  775. #endif
  776. static int tg3_ape_send_event(struct tg3 *tp, u32 event)
  777. {
  778. int err;
  779. u32 apedata;
  780. apedata = tg3_ape_read32(tp, TG3_APE_SEG_SIG);
  781. if (apedata != APE_SEG_SIG_MAGIC)
  782. return -EAGAIN;
  783. apedata = tg3_ape_read32(tp, TG3_APE_FW_STATUS);
  784. if (!(apedata & APE_FW_STATUS_READY))
  785. return -EAGAIN;
  786. /* Wait for up to 20 millisecond for APE to service previous event. */
  787. err = tg3_ape_event_lock(tp, 20000);
  788. if (err)
  789. return err;
  790. tg3_ape_write32(tp, TG3_APE_EVENT_STATUS,
  791. event | APE_EVENT_STATUS_EVENT_PENDING);
  792. tg3_ape_unlock(tp, TG3_APE_LOCK_MEM);
  793. tg3_ape_write32(tp, TG3_APE_EVENT, APE_EVENT_1);
  794. return 0;
  795. }
  796. static void tg3_ape_driver_state_change(struct tg3 *tp, int kind)
  797. {
  798. u32 event;
  799. u32 apedata;
  800. if (!tg3_flag(tp, ENABLE_APE))
  801. return;
  802. switch (kind) {
  803. case RESET_KIND_INIT:
  804. tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_COUNT, tp->ape_hb++);
  805. tg3_ape_write32(tp, TG3_APE_HOST_SEG_SIG,
  806. APE_HOST_SEG_SIG_MAGIC);
  807. tg3_ape_write32(tp, TG3_APE_HOST_SEG_LEN,
  808. APE_HOST_SEG_LEN_MAGIC);
  809. apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT);
  810. tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata);
  811. tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID,
  812. APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM));
  813. tg3_ape_write32(tp, TG3_APE_HOST_BEHAVIOR,
  814. APE_HOST_BEHAV_NO_PHYLOCK);
  815. tg3_ape_write32(tp, TG3_APE_HOST_DRVR_STATE,
  816. TG3_APE_HOST_DRVR_STATE_START);
  817. event = APE_EVENT_STATUS_STATE_START;
  818. break;
  819. case RESET_KIND_SHUTDOWN:
  820. if (device_may_wakeup(&tp->pdev->dev) &&
  821. tg3_flag(tp, WOL_ENABLE)) {
  822. tg3_ape_write32(tp, TG3_APE_HOST_WOL_SPEED,
  823. TG3_APE_HOST_WOL_SPEED_AUTO);
  824. apedata = TG3_APE_HOST_DRVR_STATE_WOL;
  825. } else
  826. apedata = TG3_APE_HOST_DRVR_STATE_UNLOAD;
  827. tg3_ape_write32(tp, TG3_APE_HOST_DRVR_STATE, apedata);
  828. event = APE_EVENT_STATUS_STATE_UNLOAD;
  829. break;
  830. default:
  831. return;
  832. }
  833. event |= APE_EVENT_STATUS_DRIVER_EVNT | APE_EVENT_STATUS_STATE_CHNGE;
  834. tg3_ape_send_event(tp, event);
  835. }
  836. static void tg3_send_ape_heartbeat(struct tg3 *tp,
  837. unsigned long interval)
  838. {
  839. /* Check if hb interval has exceeded */
  840. if (!tg3_flag(tp, ENABLE_APE) ||
  841. time_before(jiffies, tp->ape_hb_jiffies + interval))
  842. return;
  843. tg3_ape_write32(tp, TG3_APE_HOST_HEARTBEAT_COUNT, tp->ape_hb++);
  844. tp->ape_hb_jiffies = jiffies;
  845. }
  846. static void tg3_disable_ints(struct tg3 *tp)
  847. {
  848. int i;
  849. tw32(TG3PCI_MISC_HOST_CTRL,
  850. (tp->misc_host_ctrl | MISC_HOST_CTRL_MASK_PCI_INT));
  851. for (i = 0; i < tp->irq_max; i++)
  852. tw32_mailbox_f(tp->napi[i].int_mbox, 0x00000001);
  853. }
  854. static void tg3_enable_ints(struct tg3 *tp)
  855. {
  856. int i;
  857. tp->irq_sync = 0;
  858. wmb();
  859. tw32(TG3PCI_MISC_HOST_CTRL,
  860. (tp->misc_host_ctrl & ~MISC_HOST_CTRL_MASK_PCI_INT));
  861. tp->coal_now = tp->coalesce_mode | HOSTCC_MODE_ENABLE;
  862. for (i = 0; i < tp->irq_cnt; i++) {
  863. struct tg3_napi *tnapi = &tp->napi[i];
  864. tw32_mailbox_f(tnapi->int_mbox, tnapi->last_tag << 24);
  865. if (tg3_flag(tp, 1SHOT_MSI))
  866. tw32_mailbox_f(tnapi->int_mbox, tnapi->last_tag << 24);
  867. tp->coal_now |= tnapi->coal_now;
  868. }
  869. /* Force an initial interrupt */
  870. if (!tg3_flag(tp, TAGGED_STATUS) &&
  871. (tp->napi[0].hw_status->status & SD_STATUS_UPDATED))
  872. tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl | GRC_LCLCTRL_SETINT);
  873. else
  874. tw32(HOSTCC_MODE, tp->coal_now);
  875. tp->coal_now &= ~(tp->napi[0].coal_now | tp->napi[1].coal_now);
  876. }
  877. static inline unsigned int tg3_has_work(struct tg3_napi *tnapi)
  878. {
  879. struct tg3 *tp = tnapi->tp;
  880. struct tg3_hw_status *sblk = tnapi->hw_status;
  881. unsigned int work_exists = 0;
  882. /* check for phy events */
  883. if (!(tg3_flag(tp, USE_LINKCHG_REG) || tg3_flag(tp, POLL_SERDES))) {
  884. if (sblk->status & SD_STATUS_LINK_CHG)
  885. work_exists = 1;
  886. }
  887. /* check for TX work to do */
  888. if (sblk->idx[0].tx_consumer != tnapi->tx_cons)
  889. work_exists = 1;
  890. /* check for RX work to do */
  891. if (tnapi->rx_rcb_prod_idx &&
  892. *(tnapi->rx_rcb_prod_idx) != tnapi->rx_rcb_ptr)
  893. work_exists = 1;
  894. return work_exists;
  895. }
  896. /* tg3_int_reenable
  897. * similar to tg3_enable_ints, but it accurately determines whether there
  898. * is new work pending and can return without flushing the PIO write
  899. * which reenables interrupts
  900. */
  901. static void tg3_int_reenable(struct tg3_napi *tnapi)
  902. {
  903. struct tg3 *tp = tnapi->tp;
  904. tw32_mailbox(tnapi->int_mbox, tnapi->last_tag << 24);
  905. /* When doing tagged status, this work check is unnecessary.
  906. * The last_tag we write above tells the chip which piece of
  907. * work we've completed.
  908. */
  909. if (!tg3_flag(tp, TAGGED_STATUS) && tg3_has_work(tnapi))
  910. tw32(HOSTCC_MODE, tp->coalesce_mode |
  911. HOSTCC_MODE_ENABLE | tnapi->coal_now);
  912. }
  913. static void tg3_switch_clocks(struct tg3 *tp)
  914. {
  915. u32 clock_ctrl;
  916. u32 orig_clock_ctrl;
  917. if (tg3_flag(tp, CPMU_PRESENT) || tg3_flag(tp, 5780_CLASS))
  918. return;
  919. clock_ctrl = tr32(TG3PCI_CLOCK_CTRL);
  920. orig_clock_ctrl = clock_ctrl;
  921. clock_ctrl &= (CLOCK_CTRL_FORCE_CLKRUN |
  922. CLOCK_CTRL_CLKRUN_OENABLE |
  923. 0x1f);
  924. tp->pci_clock_ctrl = clock_ctrl;
  925. if (tg3_flag(tp, 5705_PLUS)) {
  926. if (orig_clock_ctrl & CLOCK_CTRL_625_CORE) {
  927. tw32_wait_f(TG3PCI_CLOCK_CTRL,
  928. clock_ctrl | CLOCK_CTRL_625_CORE, 40);
  929. }
  930. } else if ((orig_clock_ctrl & CLOCK_CTRL_44MHZ_CORE) != 0) {
  931. tw32_wait_f(TG3PCI_CLOCK_CTRL,
  932. clock_ctrl |
  933. (CLOCK_CTRL_44MHZ_CORE | CLOCK_CTRL_ALTCLK),
  934. 40);
  935. tw32_wait_f(TG3PCI_CLOCK_CTRL,
  936. clock_ctrl | (CLOCK_CTRL_ALTCLK),
  937. 40);
  938. }
  939. tw32_wait_f(TG3PCI_CLOCK_CTRL, clock_ctrl, 40);
  940. }
  941. #define PHY_BUSY_LOOPS 5000
  942. static int __tg3_readphy(struct tg3 *tp, unsigned int phy_addr, int reg,
  943. u32 *val)
  944. {
  945. u32 frame_val;
  946. unsigned int loops;
  947. int ret;
  948. if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
  949. tw32_f(MAC_MI_MODE,
  950. (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
  951. udelay(80);
  952. }
  953. tg3_ape_lock(tp, tp->phy_ape_lock);
  954. *val = 0x0;
  955. frame_val = ((phy_addr << MI_COM_PHY_ADDR_SHIFT) &
  956. MI_COM_PHY_ADDR_MASK);
  957. frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
  958. MI_COM_REG_ADDR_MASK);
  959. frame_val |= (MI_COM_CMD_READ | MI_COM_START);
  960. tw32_f(MAC_MI_COM, frame_val);
  961. loops = PHY_BUSY_LOOPS;
  962. while (loops != 0) {
  963. udelay(10);
  964. frame_val = tr32(MAC_MI_COM);
  965. if ((frame_val & MI_COM_BUSY) == 0) {
  966. udelay(5);
  967. frame_val = tr32(MAC_MI_COM);
  968. break;
  969. }
  970. loops -= 1;
  971. }
  972. ret = -EBUSY;
  973. if (loops != 0) {
  974. *val = frame_val & MI_COM_DATA_MASK;
  975. ret = 0;
  976. }
  977. if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
  978. tw32_f(MAC_MI_MODE, tp->mi_mode);
  979. udelay(80);
  980. }
  981. tg3_ape_unlock(tp, tp->phy_ape_lock);
  982. return ret;
  983. }
  984. static int tg3_readphy(struct tg3 *tp, int reg, u32 *val)
  985. {
  986. return __tg3_readphy(tp, tp->phy_addr, reg, val);
  987. }
  988. static int __tg3_writephy(struct tg3 *tp, unsigned int phy_addr, int reg,
  989. u32 val)
  990. {
  991. u32 frame_val;
  992. unsigned int loops;
  993. int ret;
  994. if ((tp->phy_flags & TG3_PHYFLG_IS_FET) &&
  995. (reg == MII_CTRL1000 || reg == MII_TG3_AUX_CTRL))
  996. return 0;
  997. if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
  998. tw32_f(MAC_MI_MODE,
  999. (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL));
  1000. udelay(80);
  1001. }
  1002. tg3_ape_lock(tp, tp->phy_ape_lock);
  1003. frame_val = ((phy_addr << MI_COM_PHY_ADDR_SHIFT) &
  1004. MI_COM_PHY_ADDR_MASK);
  1005. frame_val |= ((reg << MI_COM_REG_ADDR_SHIFT) &
  1006. MI_COM_REG_ADDR_MASK);
  1007. frame_val |= (val & MI_COM_DATA_MASK);
  1008. frame_val |= (MI_COM_CMD_WRITE | MI_COM_START);
  1009. tw32_f(MAC_MI_COM, frame_val);
  1010. loops = PHY_BUSY_LOOPS;
  1011. while (loops != 0) {
  1012. udelay(10);
  1013. frame_val = tr32(MAC_MI_COM);
  1014. if ((frame_val & MI_COM_BUSY) == 0) {
  1015. udelay(5);
  1016. frame_val = tr32(MAC_MI_COM);
  1017. break;
  1018. }
  1019. loops -= 1;
  1020. }
  1021. ret = -EBUSY;
  1022. if (loops != 0)
  1023. ret = 0;
  1024. if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) {
  1025. tw32_f(MAC_MI_MODE, tp->mi_mode);
  1026. udelay(80);
  1027. }
  1028. tg3_ape_unlock(tp, tp->phy_ape_lock);
  1029. return ret;
  1030. }
  1031. static int tg3_writephy(struct tg3 *tp, int reg, u32 val)
  1032. {
  1033. return __tg3_writephy(tp, tp->phy_addr, reg, val);
  1034. }
  1035. static int tg3_phy_cl45_write(struct tg3 *tp, u32 devad, u32 addr, u32 val)
  1036. {
  1037. int err;
  1038. err = tg3_writephy(tp, MII_TG3_MMD_CTRL, devad);
  1039. if (err)
  1040. goto done;
  1041. err = tg3_writephy(tp, MII_TG3_MMD_ADDRESS, addr);
  1042. if (err)
  1043. goto done;
  1044. err = tg3_writephy(tp, MII_TG3_MMD_CTRL,
  1045. MII_TG3_MMD_CTRL_DATA_NOINC | devad);
  1046. if (err)
  1047. goto done;
  1048. err = tg3_writephy(tp, MII_TG3_MMD_ADDRESS, val);
  1049. done:
  1050. return err;
  1051. }
  1052. static int tg3_phy_cl45_read(struct tg3 *tp, u32 devad, u32 addr, u32 *val)
  1053. {
  1054. int err;
  1055. err = tg3_writephy(tp, MII_TG3_MMD_CTRL, devad);
  1056. if (err)
  1057. goto done;
  1058. err = tg3_writephy(tp, MII_TG3_MMD_ADDRESS, addr);
  1059. if (err)
  1060. goto done;
  1061. err = tg3_writephy(tp, MII_TG3_MMD_CTRL,
  1062. MII_TG3_MMD_CTRL_DATA_NOINC | devad);
  1063. if (err)
  1064. goto done;
  1065. err = tg3_readphy(tp, MII_TG3_MMD_ADDRESS, val);
  1066. done:
  1067. return err;
  1068. }
  1069. static int tg3_phydsp_read(struct tg3 *tp, u32 reg, u32 *val)
  1070. {
  1071. int err;
  1072. err = tg3_writephy(tp, MII_TG3_DSP_ADDRESS, reg);
  1073. if (!err)
  1074. err = tg3_readphy(tp, MII_TG3_DSP_RW_PORT, val);
  1075. return err;
  1076. }
  1077. static int tg3_phydsp_write(struct tg3 *tp, u32 reg, u32 val)
  1078. {
  1079. int err;
  1080. err = tg3_writephy(tp, MII_TG3_DSP_ADDRESS, reg);
  1081. if (!err)
  1082. err = tg3_writephy(tp, MII_TG3_DSP_RW_PORT, val);
  1083. return err;
  1084. }
  1085. static int tg3_phy_auxctl_read(struct tg3 *tp, int reg, u32 *val)
  1086. {
  1087. int err;
  1088. err = tg3_writephy(tp, MII_TG3_AUX_CTRL,
  1089. (reg << MII_TG3_AUXCTL_MISC_RDSEL_SHIFT) |
  1090. MII_TG3_AUXCTL_SHDWSEL_MISC);
  1091. if (!err)
  1092. err = tg3_readphy(tp, MII_TG3_AUX_CTRL, val);
  1093. return err;
  1094. }
  1095. static int tg3_phy_auxctl_write(struct tg3 *tp, int reg, u32 set)
  1096. {
  1097. if (reg == MII_TG3_AUXCTL_SHDWSEL_MISC)
  1098. set |= MII_TG3_AUXCTL_MISC_WREN;
  1099. return tg3_writephy(tp, MII_TG3_AUX_CTRL, set | reg);
  1100. }
  1101. static int tg3_phy_toggle_auxctl_smdsp(struct tg3 *tp, bool enable)
  1102. {
  1103. u32 val;
  1104. int err;
  1105. err = tg3_phy_auxctl_read(tp, MII_TG3_AUXCTL_SHDWSEL_AUXCTL, &val);
  1106. if (err)
  1107. return err;
  1108. if (enable)
  1109. val |= MII_TG3_AUXCTL_ACTL_SMDSP_ENA;
  1110. else
  1111. val &= ~MII_TG3_AUXCTL_ACTL_SMDSP_ENA;
  1112. err = tg3_phy_auxctl_write((tp), MII_TG3_AUXCTL_SHDWSEL_AUXCTL,
  1113. val | MII_TG3_AUXCTL_ACTL_TX_6DB);
  1114. return err;
  1115. }
  1116. static int tg3_phy_shdw_write(struct tg3 *tp, int reg, u32 val)
  1117. {
  1118. return tg3_writephy(tp, MII_TG3_MISC_SHDW,
  1119. reg | val | MII_TG3_MISC_SHDW_WREN);
  1120. }
  1121. static int tg3_bmcr_reset(struct tg3 *tp)
  1122. {
  1123. u32 phy_control;
  1124. int limit, err;
  1125. /* OK, reset it, and poll the BMCR_RESET bit until it
  1126. * clears or we time out.
  1127. */
  1128. phy_control = BMCR_RESET;
  1129. err = tg3_writephy(tp, MII_BMCR, phy_control);
  1130. if (err != 0)
  1131. return -EBUSY;
  1132. limit = 5000;
  1133. while (limit--) {
  1134. err = tg3_readphy(tp, MII_BMCR, &phy_control);
  1135. if (err != 0)
  1136. return -EBUSY;
  1137. if ((phy_control & BMCR_RESET) == 0) {
  1138. udelay(40);
  1139. break;
  1140. }
  1141. udelay(10);
  1142. }
  1143. if (limit < 0)
  1144. return -EBUSY;
  1145. return 0;
  1146. }
  1147. static int tg3_mdio_read(struct mii_bus *bp, int mii_id, int reg)
  1148. {
  1149. struct tg3 *tp = bp->priv;
  1150. u32 val;
  1151. spin_lock_bh(&tp->lock);
  1152. if (__tg3_readphy(tp, mii_id, reg, &val))
  1153. val = -EIO;
  1154. spin_unlock_bh(&tp->lock);
  1155. return val;
  1156. }
  1157. static int tg3_mdio_write(struct mii_bus *bp, int mii_id, int reg, u16 val)
  1158. {
  1159. struct tg3 *tp = bp->priv;
  1160. u32 ret = 0;
  1161. spin_lock_bh(&tp->lock);
  1162. if (__tg3_writephy(tp, mii_id, reg, val))
  1163. ret = -EIO;
  1164. spin_unlock_bh(&tp->lock);
  1165. return ret;
  1166. }
  1167. static void tg3_mdio_config_5785(struct tg3 *tp)
  1168. {
  1169. u32 val;
  1170. struct phy_device *phydev;
  1171. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
  1172. switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) {
  1173. case PHY_ID_BCM50610:
  1174. case PHY_ID_BCM50610M:
  1175. val = MAC_PHYCFG2_50610_LED_MODES;
  1176. break;
  1177. case PHY_ID_BCMAC131:
  1178. val = MAC_PHYCFG2_AC131_LED_MODES;
  1179. break;
  1180. case PHY_ID_RTL8211C:
  1181. val = MAC_PHYCFG2_RTL8211C_LED_MODES;
  1182. break;
  1183. case PHY_ID_RTL8201E:
  1184. val = MAC_PHYCFG2_RTL8201E_LED_MODES;
  1185. break;
  1186. default:
  1187. return;
  1188. }
  1189. if (phydev->interface != PHY_INTERFACE_MODE_RGMII) {
  1190. tw32(MAC_PHYCFG2, val);
  1191. val = tr32(MAC_PHYCFG1);
  1192. val &= ~(MAC_PHYCFG1_RGMII_INT |
  1193. MAC_PHYCFG1_RXCLK_TO_MASK | MAC_PHYCFG1_TXCLK_TO_MASK);
  1194. val |= MAC_PHYCFG1_RXCLK_TIMEOUT | MAC_PHYCFG1_TXCLK_TIMEOUT;
  1195. tw32(MAC_PHYCFG1, val);
  1196. return;
  1197. }
  1198. if (!tg3_flag(tp, RGMII_INBAND_DISABLE))
  1199. val |= MAC_PHYCFG2_EMODE_MASK_MASK |
  1200. MAC_PHYCFG2_FMODE_MASK_MASK |
  1201. MAC_PHYCFG2_GMODE_MASK_MASK |
  1202. MAC_PHYCFG2_ACT_MASK_MASK |
  1203. MAC_PHYCFG2_QUAL_MASK_MASK |
  1204. MAC_PHYCFG2_INBAND_ENABLE;
  1205. tw32(MAC_PHYCFG2, val);
  1206. val = tr32(MAC_PHYCFG1);
  1207. val &= ~(MAC_PHYCFG1_RXCLK_TO_MASK | MAC_PHYCFG1_TXCLK_TO_MASK |
  1208. MAC_PHYCFG1_RGMII_EXT_RX_DEC | MAC_PHYCFG1_RGMII_SND_STAT_EN);
  1209. if (!tg3_flag(tp, RGMII_INBAND_DISABLE)) {
  1210. if (tg3_flag(tp, RGMII_EXT_IBND_RX_EN))
  1211. val |= MAC_PHYCFG1_RGMII_EXT_RX_DEC;
  1212. if (tg3_flag(tp, RGMII_EXT_IBND_TX_EN))
  1213. val |= MAC_PHYCFG1_RGMII_SND_STAT_EN;
  1214. }
  1215. val |= MAC_PHYCFG1_RXCLK_TIMEOUT | MAC_PHYCFG1_TXCLK_TIMEOUT |
  1216. MAC_PHYCFG1_RGMII_INT | MAC_PHYCFG1_TXC_DRV;
  1217. tw32(MAC_PHYCFG1, val);
  1218. val = tr32(MAC_EXT_RGMII_MODE);
  1219. val &= ~(MAC_RGMII_MODE_RX_INT_B |
  1220. MAC_RGMII_MODE_RX_QUALITY |
  1221. MAC_RGMII_MODE_RX_ACTIVITY |
  1222. MAC_RGMII_MODE_RX_ENG_DET |
  1223. MAC_RGMII_MODE_TX_ENABLE |
  1224. MAC_RGMII_MODE_TX_LOWPWR |
  1225. MAC_RGMII_MODE_TX_RESET);
  1226. if (!tg3_flag(tp, RGMII_INBAND_DISABLE)) {
  1227. if (tg3_flag(tp, RGMII_EXT_IBND_RX_EN))
  1228. val |= MAC_RGMII_MODE_RX_INT_B |
  1229. MAC_RGMII_MODE_RX_QUALITY |
  1230. MAC_RGMII_MODE_RX_ACTIVITY |
  1231. MAC_RGMII_MODE_RX_ENG_DET;
  1232. if (tg3_flag(tp, RGMII_EXT_IBND_TX_EN))
  1233. val |= MAC_RGMII_MODE_TX_ENABLE |
  1234. MAC_RGMII_MODE_TX_LOWPWR |
  1235. MAC_RGMII_MODE_TX_RESET;
  1236. }
  1237. tw32(MAC_EXT_RGMII_MODE, val);
  1238. }
  1239. static void tg3_mdio_start(struct tg3 *tp)
  1240. {
  1241. tp->mi_mode &= ~MAC_MI_MODE_AUTO_POLL;
  1242. tw32_f(MAC_MI_MODE, tp->mi_mode);
  1243. udelay(80);
  1244. if (tg3_flag(tp, MDIOBUS_INITED) &&
  1245. tg3_asic_rev(tp) == ASIC_REV_5785)
  1246. tg3_mdio_config_5785(tp);
  1247. }
  1248. static int tg3_mdio_init(struct tg3 *tp)
  1249. {
  1250. int i;
  1251. u32 reg;
  1252. struct phy_device *phydev;
  1253. if (tg3_flag(tp, 5717_PLUS)) {
  1254. u32 is_serdes;
  1255. tp->phy_addr = tp->pci_fn + 1;
  1256. if (tg3_chip_rev_id(tp) != CHIPREV_ID_5717_A0)
  1257. is_serdes = tr32(SG_DIG_STATUS) & SG_DIG_IS_SERDES;
  1258. else
  1259. is_serdes = tr32(TG3_CPMU_PHY_STRAP) &
  1260. TG3_CPMU_PHY_STRAP_IS_SERDES;
  1261. if (is_serdes)
  1262. tp->phy_addr += 7;
  1263. } else if (tg3_flag(tp, IS_SSB_CORE) && tg3_flag(tp, ROBOSWITCH)) {
  1264. int addr;
  1265. addr = ssb_gige_get_phyaddr(tp->pdev);
  1266. if (addr < 0)
  1267. return addr;
  1268. tp->phy_addr = addr;
  1269. } else
  1270. tp->phy_addr = TG3_PHY_MII_ADDR;
  1271. tg3_mdio_start(tp);
  1272. if (!tg3_flag(tp, USE_PHYLIB) || tg3_flag(tp, MDIOBUS_INITED))
  1273. return 0;
  1274. tp->mdio_bus = mdiobus_alloc();
  1275. if (tp->mdio_bus == NULL)
  1276. return -ENOMEM;
  1277. tp->mdio_bus->name = "tg3 mdio bus";
  1278. snprintf(tp->mdio_bus->id, MII_BUS_ID_SIZE, "%x",
  1279. (tp->pdev->bus->number << 8) | tp->pdev->devfn);
  1280. tp->mdio_bus->priv = tp;
  1281. tp->mdio_bus->parent = &tp->pdev->dev;
  1282. tp->mdio_bus->read = &tg3_mdio_read;
  1283. tp->mdio_bus->write = &tg3_mdio_write;
  1284. tp->mdio_bus->phy_mask = ~(1 << tp->phy_addr);
  1285. /* The bus registration will look for all the PHYs on the mdio bus.
  1286. * Unfortunately, it does not ensure the PHY is powered up before
  1287. * accessing the PHY ID registers. A chip reset is the
  1288. * quickest way to bring the device back to an operational state..
  1289. */
  1290. if (tg3_readphy(tp, MII_BMCR, &reg) || (reg & BMCR_PDOWN))
  1291. tg3_bmcr_reset(tp);
  1292. i = mdiobus_register(tp->mdio_bus);
  1293. if (i) {
  1294. dev_warn(&tp->pdev->dev, "mdiobus_reg failed (0x%x)\n", i);
  1295. mdiobus_free(tp->mdio_bus);
  1296. return i;
  1297. }
  1298. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr);
  1299. if (!phydev || !phydev->drv) {
  1300. dev_warn(&tp->pdev->dev, "No PHY devices\n");
  1301. mdiobus_unregister(tp->mdio_bus);
  1302. mdiobus_free(tp->mdio_bus);
  1303. return -ENODEV;
  1304. }
  1305. switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) {
  1306. case PHY_ID_BCM57780:
  1307. phydev->interface = PHY_INTERFACE_MODE_GMII;
  1308. phydev->dev_flags |= PHY_BRCM_AUTO_PWRDWN_ENABLE;
  1309. break;
  1310. case PHY_ID_BCM50610:
  1311. case PHY_ID_BCM50610M:
  1312. phydev->dev_flags |= PHY_BRCM_CLEAR_RGMII_MODE |
  1313. PHY_BRCM_RX_REFCLK_UNUSED |
  1314. PHY_BRCM_DIS_TXCRXC_NOENRGY |
  1315. PHY_BRCM_AUTO_PWRDWN_ENABLE;
  1316. if (tg3_flag(tp, RGMII_INBAND_DISABLE))
  1317. phydev->dev_flags |= PHY_BRCM_STD_IBND_DISABLE;
  1318. if (tg3_flag(tp, RGMII_EXT_IBND_RX_EN))
  1319. phydev->dev_flags |= PHY_BRCM_EXT_IBND_RX_ENABLE;
  1320. if (tg3_flag(tp, RGMII_EXT_IBND_TX_EN))
  1321. phydev->dev_flags |= PHY_BRCM_EXT_IBND_TX_ENABLE;
  1322. /* fall through */
  1323. case PHY_ID_RTL8211C:
  1324. phydev->interface = PHY_INTERFACE_MODE_RGMII;
  1325. break;
  1326. case PHY_ID_RTL8201E:
  1327. case PHY_ID_BCMAC131:
  1328. phydev->interface = PHY_INTERFACE_MODE_MII;
  1329. phydev->dev_flags |= PHY_BRCM_AUTO_PWRDWN_ENABLE;
  1330. tp->phy_flags |= TG3_PHYFLG_IS_FET;
  1331. break;
  1332. }
  1333. tg3_flag_set(tp, MDIOBUS_INITED);
  1334. if (tg3_asic_rev(tp) == ASIC_REV_5785)
  1335. tg3_mdio_config_5785(tp);
  1336. return 0;
  1337. }
  1338. static void tg3_mdio_fini(struct tg3 *tp)
  1339. {
  1340. if (tg3_flag(tp, MDIOBUS_INITED)) {
  1341. tg3_flag_clear(tp, MDIOBUS_INITED);
  1342. mdiobus_unregister(tp->mdio_bus);
  1343. mdiobus_free(tp->mdio_bus);
  1344. }
  1345. }
  1346. /* tp->lock is held. */
  1347. static inline void tg3_generate_fw_event(struct tg3 *tp)
  1348. {
  1349. u32 val;
  1350. val = tr32(GRC_RX_CPU_EVENT);
  1351. val |= GRC_RX_CPU_DRIVER_EVENT;
  1352. tw32_f(GRC_RX_CPU_EVENT, val);
  1353. tp->last_event_jiffies = jiffies;
  1354. }
  1355. #define TG3_FW_EVENT_TIMEOUT_USEC 2500
  1356. /* tp->lock is held. */
  1357. static void tg3_wait_for_event_ack(struct tg3 *tp)
  1358. {
  1359. int i;
  1360. unsigned int delay_cnt;
  1361. long time_remain;
  1362. /* If enough time has passed, no wait is necessary. */
  1363. time_remain = (long)(tp->last_event_jiffies + 1 +
  1364. usecs_to_jiffies(TG3_FW_EVENT_TIMEOUT_USEC)) -
  1365. (long)jiffies;
  1366. if (time_remain < 0)
  1367. return;
  1368. /* Check if we can shorten the wait time. */
  1369. delay_cnt = jiffies_to_usecs(time_remain);
  1370. if (delay_cnt > TG3_FW_EVENT_TIMEOUT_USEC)
  1371. delay_cnt = TG3_FW_EVENT_TIMEOUT_USEC;
  1372. delay_cnt = (delay_cnt >> 3) + 1;
  1373. for (i = 0; i < delay_cnt; i++) {
  1374. if (!(tr32(GRC_RX_CPU_EVENT) & GRC_RX_CPU_DRIVER_EVENT))
  1375. break;
  1376. if (pci_channel_offline(tp->pdev))
  1377. break;
  1378. udelay(8);
  1379. }
  1380. }
  1381. /* tp->lock is held. */
  1382. static void tg3_phy_gather_ump_data(struct tg3 *tp, u32 *data)
  1383. {
  1384. u32 reg, val;
  1385. val = 0;
  1386. if (!tg3_readphy(tp, MII_BMCR, &reg))
  1387. val = reg << 16;
  1388. if (!tg3_readphy(tp, MII_BMSR, &reg))
  1389. val |= (reg & 0xffff);
  1390. *data++ = val;
  1391. val = 0;
  1392. if (!tg3_readphy(tp, MII_ADVERTISE, &reg))
  1393. val = reg << 16;
  1394. if (!tg3_readphy(tp, MII_LPA, &reg))
  1395. val |= (reg & 0xffff);
  1396. *data++ = val;
  1397. val = 0;
  1398. if (!(tp->phy_flags & TG3_PHYFLG_MII_SERDES)) {
  1399. if (!tg3_readphy(tp, MII_CTRL1000, &reg))
  1400. val = reg << 16;
  1401. if (!tg3_readphy(tp, MII_STAT1000, &reg))
  1402. val |= (reg & 0xffff);
  1403. }
  1404. *data++ = val;
  1405. if (!tg3_readphy(tp, MII_PHYADDR, &reg))
  1406. val = reg << 16;
  1407. else
  1408. val = 0;
  1409. *data++ = val;
  1410. }
  1411. /* tp->lock is held. */
  1412. static void tg3_ump_link_report(struct tg3 *tp)
  1413. {
  1414. u32 data[4];
  1415. if (!tg3_flag(tp, 5780_CLASS) || !tg3_flag(tp, ENABLE_ASF))
  1416. return;
  1417. tg3_phy_gather_ump_data(tp, data);
  1418. tg3_wait_for_event_ack(tp);
  1419. tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_LINK_UPDATE);
  1420. tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 14);
  1421. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x0, data[0]);
  1422. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x4, data[1]);
  1423. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x8, data[2]);
  1424. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0xc, data[3]);
  1425. tg3_generate_fw_event(tp);
  1426. }
  1427. /* tp->lock is held. */
  1428. static void tg3_stop_fw(struct tg3 *tp)
  1429. {
  1430. if (tg3_flag(tp, ENABLE_ASF) && !tg3_flag(tp, ENABLE_APE)) {
  1431. /* Wait for RX cpu to ACK the previous event. */
  1432. tg3_wait_for_event_ack(tp);
  1433. tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_PAUSE_FW);
  1434. tg3_generate_fw_event(tp);
  1435. /* Wait for RX cpu to ACK this event. */
  1436. tg3_wait_for_event_ack(tp);
  1437. }
  1438. }
  1439. /* tp->lock is held. */
  1440. static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind)
  1441. {
  1442. tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX,
  1443. NIC_SRAM_FIRMWARE_MBOX_MAGIC1);
  1444. if (tg3_flag(tp, ASF_NEW_HANDSHAKE)) {
  1445. switch (kind) {
  1446. case RESET_KIND_INIT:
  1447. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1448. DRV_STATE_START);
  1449. break;
  1450. case RESET_KIND_SHUTDOWN:
  1451. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1452. DRV_STATE_UNLOAD);
  1453. break;
  1454. case RESET_KIND_SUSPEND:
  1455. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1456. DRV_STATE_SUSPEND);
  1457. break;
  1458. default:
  1459. break;
  1460. }
  1461. }
  1462. }
  1463. /* tp->lock is held. */
  1464. static void tg3_write_sig_post_reset(struct tg3 *tp, int kind)
  1465. {
  1466. if (tg3_flag(tp, ASF_NEW_HANDSHAKE)) {
  1467. switch (kind) {
  1468. case RESET_KIND_INIT:
  1469. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1470. DRV_STATE_START_DONE);
  1471. break;
  1472. case RESET_KIND_SHUTDOWN:
  1473. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1474. DRV_STATE_UNLOAD_DONE);
  1475. break;
  1476. default:
  1477. break;
  1478. }
  1479. }
  1480. }
  1481. /* tp->lock is held. */
  1482. static void tg3_write_sig_legacy(struct tg3 *tp, int kind)
  1483. {
  1484. if (tg3_flag(tp, ENABLE_ASF)) {
  1485. switch (kind) {
  1486. case RESET_KIND_INIT:
  1487. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1488. DRV_STATE_START);
  1489. break;
  1490. case RESET_KIND_SHUTDOWN:
  1491. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1492. DRV_STATE_UNLOAD);
  1493. break;
  1494. case RESET_KIND_SUSPEND:
  1495. tg3_write_mem(tp, NIC_SRAM_FW_DRV_STATE_MBOX,
  1496. DRV_STATE_SUSPEND);
  1497. break;
  1498. default:
  1499. break;
  1500. }
  1501. }
  1502. }
  1503. static int tg3_poll_fw(struct tg3 *tp)
  1504. {
  1505. int i;
  1506. u32 val;
  1507. if (tg3_flag(tp, NO_FWARE_REPORTED))
  1508. return 0;
  1509. if (tg3_flag(tp, IS_SSB_CORE)) {
  1510. /* We don'…