ether82563.c 38 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720
  1. /*
  2. * Intel Gigabit Ethernet PCI-Express Controllers.
  3. * 8256[36], 8257[12], 82573[ev]
  4. * 82575eb
  5. * Pretty basic, does not use many of the chip smarts.
  6. * The interrupt mitigation tuning for each chip variant
  7. * is probably different. The reset/initialisation
  8. * sequence needs straightened out. Doubt the PHY code
  9. * for the 82575eb is right.
  10. */
  11. #include "u.h"
  12. #include "../port/lib.h"
  13. #include "mem.h"
  14. #include "dat.h"
  15. #include "fns.h"
  16. #include "io.h"
  17. #include "../port/error.h"
  18. #include "../port/netif.h"
  19. #include "etherif.h"
  20. /*
  21. * these are in the order they appear in the manual, not numeric order.
  22. * It was too hard to find them in the book. Ref 21489, rev 2.6
  23. */
  24. enum {
  25. /* General */
  26. Ctrl = 0x0000, /* Device Control */
  27. Status = 0x0008, /* Device Status */
  28. Eec = 0x0010, /* EEPROM/Flash Control/Data */
  29. Eerd = 0x0014, /* EEPROM Read */
  30. Ctrlext = 0x0018, /* Extended Device Control */
  31. Fla = 0x001c, /* Flash Access */
  32. Mdic = 0x0020, /* MDI Control */
  33. Seresctl = 0x0024, /* Serdes ana */
  34. Fcal = 0x0028, /* Flow Control Address Low */
  35. Fcah = 0x002C, /* Flow Control Address High */
  36. Fct = 0x0030, /* Flow Control Type */
  37. Kumctrlsta = 0x0034, /* MAC-PHY Interface */
  38. Vet = 0x0038, /* VLAN EtherType */
  39. Fcttv = 0x0170, /* Flow Control Transmit Timer Value */
  40. Txcw = 0x0178, /* Transmit Configuration Word */
  41. Rxcw = 0x0180, /* Receive Configuration Word */
  42. Ledctl = 0x0E00, /* LED control */
  43. Pba = 0x1000, /* Packet Buffer Allocation */
  44. Pbs = 0x1008, /* Packet Buffer Size */
  45. /* Interrupt */
  46. Icr = 0x00C0, /* Interrupt Cause Read */
  47. Itr = 0x00c4, /* Interrupt Throttling Rate */
  48. Ics = 0x00C8, /* Interrupt Cause Set */
  49. Ims = 0x00D0, /* Interrupt Mask Set/Read */
  50. Imc = 0x00D8, /* Interrupt mask Clear */
  51. Iam = 0x00E0, /* Interrupt acknowledge Auto Mask */
  52. /* Receive */
  53. Rctl = 0x0100, /* Control */
  54. Ert = 0x2008, /* Early Receive Threshold (573[EVL] only) */
  55. Fcrtl = 0x2160, /* Flow Control RX Threshold Low */
  56. Fcrth = 0x2168, /* Flow Control Rx Threshold High */
  57. Psrctl = 0x2170, /* Packet Split Receive Control */
  58. Rdbal = 0x2800, /* Rdesc Base Address Low Queue 0 */
  59. Rdbah = 0x2804, /* Rdesc Base Address High Queue 0 */
  60. Rdlen = 0x2808, /* Descriptor Length Queue 0 */
  61. Rdh = 0x2810, /* Descriptor Head Queue 0 */
  62. Rdt = 0x2818, /* Descriptor Tail Queue 0 */
  63. Rdtr = 0x2820, /* Descriptor Timer Ring */
  64. Rxdctl = 0x2828, /* Descriptor Control */
  65. Radv = 0x282C, /* Interrupt Absolute Delay Timer */
  66. Rdbal1 = 0x2900, /* Rdesc Base Address Low Queue 1 */
  67. Rdbah1 = 0x2804, /* Rdesc Base Address High Queue 1 */
  68. Rdlen1 = 0x2908, /* Descriptor Length Queue 1 */
  69. Rdh1 = 0x2910, /* Descriptor Head Queue 1 */
  70. Rdt1 = 0x2918, /* Descriptor Tail Queue 1 */
  71. Rxdctl1 = 0x2928, /* Descriptor Control Queue 1 */
  72. Rsrpd = 0x2c00, /* Small Packet Detect */
  73. Raid = 0x2c08, /* ACK interrupt delay */
  74. Cpuvec = 0x2c10, /* CPU Vector */
  75. Rxcsum = 0x5000, /* Checksum Control */
  76. Rfctl = 0x5008, /* Filter Control */
  77. Mta = 0x5200, /* Multicast Table Array */
  78. Ral = 0x5400, /* Receive Address Low */
  79. Rah = 0x5404, /* Receive Address High */
  80. Vfta = 0x5600, /* VLAN Filter Table Array */
  81. Mrqc = 0x5818, /* Multiple Receive Queues Command */
  82. Rssim = 0x5864, /* RSS Interrupt Mask */
  83. Rssir = 0x5868, /* RSS Interrupt Request */
  84. Reta = 0x5c00, /* Redirection Table */
  85. Rssrk = 0x5c80, /* RSS Random Key */
  86. /* Transmit */
  87. Tctl = 0x0400, /* Transmit Control */
  88. Tipg = 0x0410, /* Transmit IPG */
  89. Tkabgtxd = 0x3004, /* glci afe band gap transmit ref data, or something */
  90. Tdbal = 0x3800, /* Tdesc Base Address Low */
  91. Tdbah = 0x3804, /* Tdesc Base Address High */
  92. Tdlen = 0x3808, /* Descriptor Length */
  93. Tdh = 0x3810, /* Descriptor Head */
  94. Tdt = 0x3818, /* Descriptor Tail */
  95. Tidv = 0x3820, /* Interrupt Delay Value */
  96. Txdctl = 0x3828, /* Descriptor Control */
  97. Tadv = 0x382C, /* Interrupt Absolute Delay Timer */
  98. Tarc0 = 0x3840, /* Arbitration Counter Queue 0 */
  99. Tdbal1 = 0x3900, /* Descriptor Base Low Queue 1 */
  100. Tdbah1 = 0x3904, /* Descriptor Base High Queue 1 */
  101. Tdlen1 = 0x3908, /* Descriptor Length Queue 1 */
  102. Tdh1 = 0x3910, /* Descriptor Head Queue 1 */
  103. Tdt1 = 0x3918, /* Descriptor Tail Queue 1 */
  104. Txdctl1 = 0x3928, /* Descriptor Control 1 */
  105. Tarc1 = 0x3940, /* Arbitration Counter Queue 1 */
  106. /* Statistics */
  107. Statistics = 0x4000, /* Start of Statistics Area */
  108. Gorcl = 0x88/4, /* Good Octets Received Count */
  109. Gotcl = 0x90/4, /* Good Octets Transmitted Count */
  110. Torl = 0xC0/4, /* Total Octets Received */
  111. Totl = 0xC8/4, /* Total Octets Transmitted */
  112. Nstatistics = 0x124/4,
  113. };
  114. enum { /* Ctrl */
  115. GIOmd = 1<<2, /* BIO master disable */
  116. Lrst = 1<<3, /* link reset */
  117. Slu = 1<<6, /* Set Link Up */
  118. SspeedMASK = 3<<8, /* Speed Selection */
  119. SspeedSHIFT = 8,
  120. Sspeed10 = 0x00000000, /* 10Mb/s */
  121. Sspeed100 = 0x00000100, /* 100Mb/s */
  122. Sspeed1000 = 0x00000200, /* 1000Mb/s */
  123. Frcspd = 1<<11, /* Force Speed */
  124. Frcdplx = 1<<12, /* Force Duplex */
  125. SwdpinsloMASK = 0x003C0000, /* Software Defined Pins - lo nibble */
  126. SwdpinsloSHIFT = 18,
  127. SwdpioloMASK = 0x03C00000, /* Software Defined Pins - I or O */
  128. SwdpioloSHIFT = 22,
  129. Devrst = 1<<26, /* Device Reset */
  130. Rfce = 1<<27, /* Receive Flow Control Enable */
  131. Tfce = 1<<28, /* Transmit Flow Control Enable */
  132. Vme = 1<<30, /* VLAN Mode Enable */
  133. Phyrst = 1<<31, /* Phy Reset */
  134. };
  135. enum { /* Status */
  136. Lu = 1<<1, /* Link Up */
  137. Lanid = 3<<2, /* mask for Lan ID. */
  138. Txoff = 1<<4, /* Transmission Paused */
  139. Tbimode = 1<<5, /* TBI Mode Indication */
  140. Phyra = 1<<10, /* PHY Reset Asserted */
  141. GIOme = 1<<19, /* GIO Master Enable Status */
  142. };
  143. enum { /* Eerd */
  144. EEstart = 1<<0, /* Start Read */
  145. EEdone = 1<<1, /* Read done */
  146. };
  147. enum { /* Ctrlext */
  148. Asdchk = 1<<12, /* ASD Check */
  149. Eerst = 1<<13, /* EEPROM Reset */
  150. Spdbyps = 1<<15, /* Speed Select Bypass */
  151. };
  152. enum { /* EEPROM content offsets */
  153. Ea = 0x00, /* Ethernet Address */
  154. Cf = 0x03, /* Compatibility Field */
  155. Icw1 = 0x0A, /* Initialization Control Word 1 */
  156. Sid = 0x0B, /* Subsystem ID */
  157. Svid = 0x0C, /* Subsystem Vendor ID */
  158. Did = 0x0D, /* Device ID */
  159. Vid = 0x0E, /* Vendor ID */
  160. Icw2 = 0x0F, /* Initialization Control Word 2 */
  161. };
  162. enum { /* Mdic */
  163. MDIdMASK = 0x0000FFFF, /* Data */
  164. MDIdSHIFT = 0,
  165. MDIrMASK = 0x001F0000, /* PHY Register Address */
  166. MDIrSHIFT = 16,
  167. MDIpMASK = 0x03E00000, /* PHY Address */
  168. MDIpSHIFT = 21,
  169. MDIwop = 0x04000000, /* Write Operation */
  170. MDIrop = 0x08000000, /* Read Operation */
  171. MDIready = 0x10000000, /* End of Transaction */
  172. MDIie = 0x20000000, /* Interrupt Enable */
  173. MDIe = 0x40000000, /* Error */
  174. };
  175. enum { /* phy interface registers */
  176. Phyctl = 0, /* phy ctl */
  177. Physsr = 17, /* phy secondary status */
  178. Phyier = 18, /* 82573 phy interrupt enable */
  179. Phyisr = 19, /* 82563 phy interrupt status */
  180. Phylhr = 19, /* 8257[12] link health */
  181. Rtlink = 1<<10, /* realtime link status */
  182. Phyan = 1<<11, /* phy has auto-negotiated */
  183. /* Phyctl bits */
  184. Ran = 1<<9, /* restart auto-negotiation */
  185. Ean = 1<<12, /* enable auto-negotiation */
  186. /* 82573 Phyier bits */
  187. Lscie = 1<<10, /* link status changed ie */
  188. Ancie = 1<<11, /* auto-negotiation complete ie */
  189. Spdie = 1<<14, /* speed changed ie */
  190. Panie = 1<<15, /* phy auto-negotiation error ie */
  191. /* Phylhr/Phyisr bits */
  192. Anf = 1<<6, /* lhr: auto-negotiation fault */
  193. Ane = 1<<15, /* isr: auto-negotiation error */
  194. };
  195. enum { /* Icr, Ics, Ims, Imc */
  196. Txdw = 0x00000001, /* Transmit Descriptor Written Back */
  197. Txqe = 0x00000002, /* Transmit Queue Empty */
  198. Lsc = 0x00000004, /* Link Status Change */
  199. Rxseq = 0x00000008, /* Receive Sequence Error */
  200. Rxdmt0 = 0x00000010, /* Rdesc Minimum Threshold Reached */
  201. Rxo = 0x00000040, /* Receiver Overrun */
  202. Rxt0 = 0x00000080, /* Receiver Timer Interrupt */
  203. Mdac = 0x00000200, /* MDIO Access Completed */
  204. Rxcfg = 0x00000400, /* Receiving /C/ ordered sets */
  205. Gpi0 = 0x00000800, /* General Purpose Interrupts */
  206. Gpi1 = 0x00001000,
  207. Gpi2 = 0x00002000,
  208. Gpi3 = 0x00004000,
  209. Ack = 0x00020000, /* Receive ACK frame */
  210. };
  211. enum { /* Txcw */
  212. TxcwFd = 0x00000020, /* Full Duplex */
  213. TxcwHd = 0x00000040, /* Half Duplex */
  214. TxcwPauseMASK = 0x00000180, /* Pause */
  215. TxcwPauseSHIFT = 7,
  216. TxcwPs = 1<<TxcwPauseSHIFT, /* Pause Supported */
  217. TxcwAs = 2<<TxcwPauseSHIFT, /* Asymmetric FC desired */
  218. TxcwRfiMASK = 0x00003000, /* Remote Fault Indication */
  219. TxcwRfiSHIFT = 12,
  220. TxcwNpr = 0x00008000, /* Next Page Request */
  221. TxcwConfig = 0x40000000, /* Transmit Config Control */
  222. TxcwAne = 0x80000000, /* Auto-Negotiation Enable */
  223. };
  224. enum { /* Rctl */
  225. Rrst = 0x00000001, /* Receiver Software Reset */
  226. Ren = 0x00000002, /* Receiver Enable */
  227. Sbp = 0x00000004, /* Store Bad Packets */
  228. Upe = 0x00000008, /* Unicast Promiscuous Enable */
  229. Mpe = 0x00000010, /* Multicast Promiscuous Enable */
  230. Lpe = 0x00000020, /* Long Packet Reception Enable */
  231. LbmMASK = 0x000000C0, /* Loopback Mode */
  232. LbmOFF = 0x00000000, /* No Loopback */
  233. LbmTBI = 0x00000040, /* TBI Loopback */
  234. LbmMII = 0x00000080, /* GMII/MII Loopback */
  235. LbmXCVR = 0x000000C0, /* Transceiver Loopback */
  236. RdtmsMASK = 0x00000300, /* Rdesc Minimum Threshold Size */
  237. RdtmsHALF = 0x00000000, /* Threshold is 1/2 Rdlen */
  238. RdtmsQUARTER = 0x00000100, /* Threshold is 1/4 Rdlen */
  239. RdtmsEIGHTH = 0x00000200, /* Threshold is 1/8 Rdlen */
  240. MoMASK = 0x00003000, /* Multicast Offset */
  241. Bam = 0x00008000, /* Broadcast Accept Mode */
  242. BsizeMASK = 0x00030000, /* Receive Buffer Size */
  243. Bsize16384 = 0x00010000, /* Bsex = 1 */
  244. Bsize8192 = 0x00020000, /* Bsex = 1 */
  245. Bsize2048 = 0x00000000,
  246. Bsize1024 = 0x00010000,
  247. Bsize512 = 0x00020000,
  248. Bsize256 = 0x00030000,
  249. BsizeFlex = 0x08000000, /* Flexible Bsize in 1KB increments */
  250. Vfe = 0x00040000, /* VLAN Filter Enable */
  251. Cfien = 0x00080000, /* Canonical Form Indicator Enable */
  252. Cfi = 0x00100000, /* Canonical Form Indicator value */
  253. Dpf = 0x00400000, /* Discard Pause Frames */
  254. Pmcf = 0x00800000, /* Pass MAC Control Frames */
  255. Bsex = 0x02000000, /* Buffer Size Extension */
  256. Secrc = 0x04000000, /* Strip CRC from incoming packet */
  257. };
  258. enum { /* Tctl */
  259. Trst = 0x00000001, /* Transmitter Software Reset */
  260. Ten = 0x00000002, /* Transmit Enable */
  261. Psp = 0x00000008, /* Pad Short Packets */
  262. Mulr = 0x10000000, /* Allow multiple concurrent requests */
  263. CtMASK = 0x00000FF0, /* Collision Threshold */
  264. CtSHIFT = 4,
  265. ColdMASK = 0x003FF000, /* Collision Distance */
  266. ColdSHIFT = 12,
  267. Swxoff = 0x00400000, /* Sofware XOFF Transmission */
  268. Pbe = 0x00800000, /* Packet Burst Enable */
  269. Rtlc = 0x01000000, /* Re-transmit on Late Collision */
  270. Nrtu = 0x02000000, /* No Re-transmit on Underrrun */
  271. };
  272. enum { /* [RT]xdctl */
  273. PthreshMASK = 0x0000003F, /* Prefetch Threshold */
  274. PthreshSHIFT = 0,
  275. HthreshMASK = 0x00003F00, /* Host Threshold */
  276. HthreshSHIFT = 8,
  277. WthreshMASK = 0x003F0000, /* Writeback Threshold */
  278. WthreshSHIFT = 16,
  279. Gran = 0x01000000, /* Granularity */
  280. Qenable = 0x02000000, /* Queue Enable (82575) */
  281. };
  282. enum { /* Rxcsum */
  283. PcssMASK = 0x00FF, /* Packet Checksum Start */
  284. PcssSHIFT = 0,
  285. Ipofl = 0x0100, /* IP Checksum Off-load Enable */
  286. Tuofl = 0x0200, /* TCP/UDP Checksum Off-load Enable */
  287. };
  288. enum { /* Receive Delay Timer Ring */
  289. DelayMASK = 0xFFFF, /* delay timer in 1.024nS increments */
  290. DelaySHIFT = 0,
  291. Fpd = 0x80000000, /* Flush partial Descriptor Block */
  292. };
  293. typedef struct Rd { /* Receive Descriptor */
  294. u32int addr[2];
  295. u16int length;
  296. u16int checksum;
  297. u8int status;
  298. u8int errors;
  299. u16int special;
  300. } Rd;
  301. enum { /* Rd status */
  302. Rdd = 0x01, /* Descriptor Done */
  303. Reop = 0x02, /* End of Packet */
  304. Ixsm = 0x04, /* Ignore Checksum Indication */
  305. Vp = 0x08, /* Packet is 802.1Q (matched VET) */
  306. Tcpcs = 0x20, /* TCP Checksum Calculated on Packet */
  307. Ipcs = 0x40, /* IP Checksum Calculated on Packet */
  308. Pif = 0x80, /* Passed in-exact filter */
  309. };
  310. enum { /* Rd errors */
  311. Ce = 0x01, /* CRC Error or Alignment Error */
  312. Se = 0x02, /* Symbol Error */
  313. Seq = 0x04, /* Sequence Error */
  314. Cxe = 0x10, /* Carrier Extension Error */
  315. Tcpe = 0x20, /* TCP/UDP Checksum Error */
  316. Ipe = 0x40, /* IP Checksum Error */
  317. Rxe = 0x80, /* RX Data Error */
  318. };
  319. typedef struct { /* Transmit Descriptor */
  320. u32int addr[2]; /* Data */
  321. u32int control;
  322. u32int status;
  323. } Td;
  324. enum { /* Tdesc control */
  325. LenMASK = 0x000FFFFF, /* Data/Packet Length Field */
  326. LenSHIFT = 0,
  327. DtypeCD = 0x00000000, /* Data Type 'Context Descriptor' */
  328. DtypeDD = 0x00100000, /* Data Type 'Data Descriptor' */
  329. PtypeTCP = 0x01000000, /* TCP/UDP Packet Type (CD) */
  330. Teop = 0x01000000, /* End of Packet (DD) */
  331. PtypeIP = 0x02000000, /* IP Packet Type (CD) */
  332. Ifcs = 0x02000000, /* Insert FCS (DD) */
  333. Tse = 0x04000000, /* TCP Segmentation Enable */
  334. Rs = 0x08000000, /* Report Status */
  335. Rps = 0x10000000, /* Report Status Sent */
  336. Dext = 0x20000000, /* Descriptor Extension */
  337. Vle = 0x40000000, /* VLAN Packet Enable */
  338. Ide = 0x80000000, /* Interrupt Delay Enable */
  339. };
  340. enum { /* Tdesc status */
  341. Tdd = 0x0001, /* Descriptor Done */
  342. Ec = 0x0002, /* Excess Collisions */
  343. Lc = 0x0004, /* Late Collision */
  344. Tu = 0x0008, /* Transmit Underrun */
  345. CssMASK = 0xFF00, /* Checksum Start Field */
  346. CssSHIFT = 8,
  347. };
  348. typedef struct {
  349. u16int *reg;
  350. u32int *reg32;
  351. int sz;
  352. } Flash;
  353. enum {
  354. /* 16 and 32-bit flash registers for ich flash parts */
  355. Bfpr = 0x00/4, /* flash base 0:12; lim 16:28 */
  356. Fsts = 0x04/2, /* flash status; Hsfsts */
  357. Fctl = 0x06/2, /* flash control; Hsfctl */
  358. Faddr = 0x08/4, /* flash address to r/w */
  359. Fdata = 0x10/4, /* data @ address */
  360. /* status register */
  361. Fdone = 1<<0, /* flash cycle done */
  362. Fcerr = 1<<1, /* cycle error; write 1 to clear */
  363. Ael = 1<<2, /* direct access error log; 1 to clear */
  364. Scip = 1<<5, /* spi cycle in progress */
  365. Fvalid = 1<<14, /* flash descriptor valid */
  366. /* control register */
  367. Fgo = 1<<0, /* start cycle */
  368. Flcycle = 1<<1, /* two bits: r=0; w=2 */
  369. Fdbc = 1<<8, /* bytes to read; 5 bits */
  370. };
  371. enum {
  372. Nrd = 256, /* power of two */
  373. Ntd = 128, /* power of two */
  374. Nrb = 512, /* private receive buffers per Ctlr */
  375. };
  376. enum {
  377. Iany,
  378. i82563,
  379. i82566,
  380. i82571,
  381. i82572,
  382. i82573,
  383. i82575,
  384. };
  385. static int rbtab[] = {
  386. 0,
  387. 9014,
  388. 1514,
  389. 9234,
  390. 9234,
  391. 8192, /* terrible performance above 8k */
  392. 1514,
  393. };
  394. static char *tname[] = {
  395. "any",
  396. "i82563",
  397. "i82566",
  398. "i82571",
  399. "i82572",
  400. "i82573",
  401. "i82575",
  402. };
  403. typedef struct Ctlr Ctlr;
  404. struct Ctlr {
  405. int port;
  406. Pcidev *pcidev;
  407. Ctlr *next;
  408. int active;
  409. int type;
  410. ushort eeprom[0x40];
  411. QLock alock; /* attach */
  412. int attached;
  413. int nrd;
  414. int ntd;
  415. int nrb; /* how many this Ctlr has in the pool */
  416. unsigned rbsz; /* unsigned for % and / by 1024 */
  417. int *nic;
  418. Lock imlock;
  419. int im; /* interrupt mask */
  420. Rendez lrendez;
  421. int lim;
  422. QLock slock;
  423. uint statistics[Nstatistics];
  424. uint lsleep;
  425. uint lintr;
  426. uint rsleep;
  427. uint rintr;
  428. uint txdw;
  429. uint tintr;
  430. uint ixsm;
  431. uint ipcs;
  432. uint tcpcs;
  433. uint speeds[4];
  434. uchar ra[Eaddrlen]; /* receive address */
  435. ulong mta[128]; /* multicast table array */
  436. Rendez rrendez;
  437. int rim;
  438. int rdfree;
  439. Rd *rdba; /* receive descriptor base address */
  440. Block **rb; /* receive buffers */
  441. int rdh; /* receive descriptor head */
  442. int rdt; /* receive descriptor tail */
  443. int rdtr; /* receive delay timer ring value */
  444. int radv; /* receive interrupt absolute delay timer */
  445. Rendez trendez;
  446. QLock tlock;
  447. int tbusy;
  448. Td *tdba; /* transmit descriptor base address */
  449. Block **tb; /* transmit buffers */
  450. int tdh; /* transmit descriptor head */
  451. int tdt; /* transmit descriptor tail */
  452. int fcrtl;
  453. int fcrth;
  454. uint pba; /* packet buffer allocation */
  455. };
  456. #define csr32r(c, r) (*((c)->nic+((r)/4)))
  457. #define csr32w(c, r, v) (*((c)->nic+((r)/4)) = (v))
  458. static Ctlr* i82563ctlrhead;
  459. static Ctlr* i82563ctlrtail;
  460. static Lock i82563rblock; /* free receive Blocks */
  461. static Block* i82563rbpool;
  462. static char* statistics[] = {
  463. "CRC Error",
  464. "Alignment Error",
  465. "Symbol Error",
  466. "RX Error",
  467. "Missed Packets",
  468. "Single Collision",
  469. "Excessive Collisions",
  470. "Multiple Collision",
  471. "Late Collisions",
  472. nil,
  473. "Collision",
  474. "Transmit Underrun",
  475. "Defer",
  476. "Transmit - No CRS",
  477. "Sequence Error",
  478. "Carrier Extension Error",
  479. "Receive Error Length",
  480. nil,
  481. "XON Received",
  482. "XON Transmitted",
  483. "XOFF Received",
  484. "XOFF Transmitted",
  485. "FC Received Unsupported",
  486. "Packets Received (64 Bytes)",
  487. "Packets Received (65-127 Bytes)",
  488. "Packets Received (128-255 Bytes)",
  489. "Packets Received (256-511 Bytes)",
  490. "Packets Received (512-1023 Bytes)",
  491. "Packets Received (1024-mtu Bytes)",
  492. "Good Packets Received",
  493. "Broadcast Packets Received",
  494. "Multicast Packets Received",
  495. "Good Packets Transmitted",
  496. nil,
  497. "Good Octets Received",
  498. nil,
  499. "Good Octets Transmitted",
  500. nil,
  501. nil,
  502. nil,
  503. "Receive No Buffers",
  504. "Receive Undersize",
  505. "Receive Fragment",
  506. "Receive Oversize",
  507. "Receive Jabber",
  508. "Management Packets Rx",
  509. "Management Packets Drop",
  510. "Management Packets Tx",
  511. "Total Octets Received",
  512. nil,
  513. "Total Octets Transmitted",
  514. nil,
  515. "Total Packets Received",
  516. "Total Packets Transmitted",
  517. "Packets Transmitted (64 Bytes)",
  518. "Packets Transmitted (65-127 Bytes)",
  519. "Packets Transmitted (128-255 Bytes)",
  520. "Packets Transmitted (256-511 Bytes)",
  521. "Packets Transmitted (512-1023 Bytes)",
  522. "Packets Transmitted (1024-mtu Bytes)",
  523. "Multicast Packets Transmitted",
  524. "Broadcast Packets Transmitted",
  525. "TCP Segmentation Context Transmitted",
  526. "TCP Segmentation Context Fail",
  527. "Interrupt Assertion",
  528. "Interrupt Rx Pkt Timer",
  529. "Interrupt Rx Abs Timer",
  530. "Interrupt Tx Pkt Timer",
  531. "Interrupt Tx Abs Timer",
  532. "Interrupt Tx Queue Empty",
  533. "Interrupt Tx Desc Low",
  534. "Interrupt Rx Min",
  535. "Interrupt Rx Overrun",
  536. };
  537. static long
  538. i82563ifstat(Ether* edev, void* a, long n, ulong offset)
  539. {
  540. Ctlr *ctlr;
  541. char *s, *p, *e, *stat;
  542. int i, r;
  543. uvlong tuvl, ruvl;
  544. ctlr = edev->ctlr;
  545. qlock(&ctlr->slock);
  546. p = s = malloc(2*READSTR);
  547. e = p + 2*READSTR;
  548. for(i = 0; i < Nstatistics; i++){
  549. r = csr32r(ctlr, Statistics + i*4);
  550. if((stat = statistics[i]) == nil)
  551. continue;
  552. switch(i){
  553. case Gorcl:
  554. case Gotcl:
  555. case Torl:
  556. case Totl:
  557. ruvl = r;
  558. ruvl += (uvlong)csr32r(ctlr, Statistics+(i+1)*4) << 32;
  559. tuvl = ruvl;
  560. tuvl += ctlr->statistics[i];
  561. tuvl += (uvlong)ctlr->statistics[i+1] << 32;
  562. if(tuvl == 0)
  563. continue;
  564. ctlr->statistics[i] = tuvl;
  565. ctlr->statistics[i+1] = tuvl >> 32;
  566. p = seprint(p, e, "%s: %llud %llud\n", stat, tuvl, ruvl);
  567. i++;
  568. break;
  569. default:
  570. ctlr->statistics[i] += r;
  571. if(ctlr->statistics[i] == 0)
  572. continue;
  573. p = seprint(p, e, "%s: %ud %ud\n", stat,
  574. ctlr->statistics[i], r);
  575. break;
  576. }
  577. }
  578. p = seprint(p, e, "lintr: %ud %ud\n", ctlr->lintr, ctlr->lsleep);
  579. p = seprint(p, e, "rintr: %ud %ud\n", ctlr->rintr, ctlr->rsleep);
  580. p = seprint(p, e, "tintr: %ud %ud\n", ctlr->tintr, ctlr->txdw);
  581. p = seprint(p, e, "ixcs: %ud %ud %ud\n", ctlr->ixsm, ctlr->ipcs, ctlr->tcpcs);
  582. p = seprint(p, e, "rdtr: %ud\n", ctlr->rdtr);
  583. p = seprint(p, e, "radv: %ud\n", ctlr->radv);
  584. p = seprint(p, e, "ctrl: %.8ux\n", csr32r(ctlr, Ctrl));
  585. p = seprint(p, e, "ctrlext: %.8ux\n", csr32r(ctlr, Ctrlext));
  586. p = seprint(p, e, "status: %.8ux\n", csr32r(ctlr, Status));
  587. p = seprint(p, e, "txcw: %.8ux\n", csr32r(ctlr, Txcw));
  588. p = seprint(p, e, "txdctl: %.8ux\n", csr32r(ctlr, Txdctl));
  589. p = seprint(p, e, "pba: %.8ux\n", ctlr->pba);
  590. p = seprint(p, e, "speeds: 10:%ud 100:%ud 1000:%ud ?:%ud\n",
  591. ctlr->speeds[0], ctlr->speeds[1], ctlr->speeds[2], ctlr->speeds[3]);
  592. p = seprint(p, e, "type: %s\n", tname[ctlr->type]);
  593. // p = seprint(p, e, "eeprom:");
  594. // for(i = 0; i < 0x40; i++){
  595. // if(i && ((i & 7) == 0))
  596. // p = seprint(p, e, "\n ");
  597. // p = seprint(p, e, " %4.4ux", ctlr->eeprom[i]);
  598. // }
  599. // p = seprint(p, e, "\n");
  600. USED(p);
  601. n = readstr(offset, a, n, s);
  602. free(s);
  603. qunlock(&ctlr->slock);
  604. return n;
  605. }
  606. enum {
  607. CMrdtr,
  608. CMradv,
  609. };
  610. static Cmdtab i82563ctlmsg[] = {
  611. CMrdtr, "rdtr", 2,
  612. CMradv, "radv", 2,
  613. };
  614. static long
  615. i82563ctl(Ether* edev, void* buf, long n)
  616. {
  617. ulong v;
  618. char *p;
  619. Ctlr *ctlr;
  620. Cmdbuf *cb;
  621. Cmdtab *ct;
  622. if((ctlr = edev->ctlr) == nil)
  623. error(Enonexist);
  624. cb = parsecmd(buf, n);
  625. if(waserror()){
  626. free(cb);
  627. nexterror();
  628. }
  629. ct = lookupcmd(cb, i82563ctlmsg, nelem(i82563ctlmsg));
  630. switch(ct->index){
  631. case CMrdtr:
  632. v = strtoul(cb->f[1], &p, 0);
  633. if(p == cb->f[1] || v > 0xFFFF)
  634. error(Ebadarg);
  635. ctlr->rdtr = v;
  636. csr32w(ctlr, Rdtr, v);
  637. break;
  638. case CMradv:
  639. v = strtoul(cb->f[1], &p, 0);
  640. if(p == cb->f[1] || v > 0xFFFF)
  641. error(Ebadarg);
  642. ctlr->radv = v;
  643. csr32w(ctlr, Radv, v);
  644. }
  645. free(cb);
  646. poperror();
  647. return n;
  648. }
  649. static void
  650. i82563promiscuous(void* arg, int on)
  651. {
  652. int rctl;
  653. Ctlr *ctlr;
  654. Ether *edev;
  655. edev = arg;
  656. ctlr = edev->ctlr;
  657. rctl = csr32r(ctlr, Rctl);
  658. rctl &= ~MoMASK;
  659. if(on)
  660. rctl |= Upe|Mpe;
  661. else
  662. rctl &= ~(Upe|Mpe);
  663. csr32w(ctlr, Rctl, rctl);
  664. }
  665. static void
  666. i82563multicast(void* arg, uchar* addr, int on)
  667. {
  668. int bit, x;
  669. Ctlr *ctlr;
  670. Ether *edev;
  671. edev = arg;
  672. ctlr = edev->ctlr;
  673. x = addr[5]>>1;
  674. if(ctlr->type == i82566)
  675. x &= 31;
  676. bit = ((addr[5] & 1)<<4)|(addr[4]>>4);
  677. /*
  678. * multiple ether addresses can hash to the same filter bit,
  679. * so it's never safe to clear a filter bit.
  680. * if we want to clear filter bits, we need to keep track of
  681. * all the multicast addresses in use, clear all the filter bits,
  682. * then set the ones corresponding to in-use addresses.
  683. */
  684. if(on)
  685. ctlr->mta[x] |= 1<<bit;
  686. // else
  687. // ctlr->mta[x] &= ~(1<<bit);
  688. csr32w(ctlr, Mta+x*4, ctlr->mta[x]);
  689. }
  690. static Block*
  691. i82563rballoc(void)
  692. {
  693. Block *bp;
  694. ilock(&i82563rblock);
  695. if((bp = i82563rbpool) != nil){
  696. i82563rbpool = bp->next;
  697. bp->next = nil;
  698. _xinc(&bp->ref); /* prevent bp from being freed */
  699. }
  700. iunlock(&i82563rblock);
  701. return bp;
  702. }
  703. static void
  704. i82563rbfree(Block* b)
  705. {
  706. b->rp = b->wp = (uchar*)PGROUND((uintptr)b->base);
  707. ilock(&i82563rblock);
  708. b->next = i82563rbpool;
  709. i82563rbpool = b;
  710. iunlock(&i82563rblock);
  711. }
  712. static void
  713. i82563im(Ctlr* ctlr, int im)
  714. {
  715. ilock(&ctlr->imlock);
  716. ctlr->im |= im;
  717. csr32w(ctlr, Ims, ctlr->im);
  718. iunlock(&ctlr->imlock);
  719. }
  720. static void
  721. i82563txinit(Ctlr* ctlr)
  722. {
  723. int i, r;
  724. Block *bp;
  725. csr32w(ctlr, Tctl, 0x0F<<CtSHIFT | Psp | 66<<ColdSHIFT | Mulr);
  726. csr32w(ctlr, Tipg, 6<<20 | 8<<10 | 8); /* yb sez: 0x702008 */
  727. csr32w(ctlr, Tdbal, PCIWADDR(ctlr->tdba));
  728. csr32w(ctlr, Tdbah, 0);
  729. csr32w(ctlr, Tdlen, ctlr->ntd * sizeof(Td));
  730. ctlr->tdh = PREV(0, ctlr->ntd);
  731. csr32w(ctlr, Tdh, 0);
  732. ctlr->tdt = 0;
  733. csr32w(ctlr, Tdt, 0);
  734. for(i = 0; i < ctlr->ntd; i++){
  735. if((bp = ctlr->tb[i]) != nil){
  736. ctlr->tb[i] = nil;
  737. freeb(bp);
  738. }
  739. memset(&ctlr->tdba[i], 0, sizeof(Td));
  740. }
  741. csr32w(ctlr, Tidv, 128);
  742. r = csr32r(ctlr, Txdctl);
  743. r &= ~(WthreshMASK|PthreshSHIFT);
  744. r |= 4<<WthreshSHIFT | 4<<PthreshSHIFT;
  745. if(ctlr->type == i82575)
  746. r |= Qenable;
  747. csr32w(ctlr, Tadv, 64);
  748. csr32w(ctlr, Txdctl, r);
  749. r = csr32r(ctlr, Tctl);
  750. r |= Ten;
  751. csr32w(ctlr, Tctl, r);
  752. // if(ctlr->type == i82671)
  753. // csr32w(ctlr, Tarc0, csr32r(ctlr, Tarc0) | 7<<24); /* yb sez? */
  754. }
  755. #define Next(x, m) (((x)+1) & (m))
  756. static int
  757. i82563cleanup(Ctlr *c)
  758. {
  759. Block *b;
  760. int tdh, m, n;
  761. tdh = c->tdh;
  762. m = c->ntd-1;
  763. while(c->tdba[n = Next(tdh, m)].status & Tdd){
  764. tdh = n;
  765. if((b = c->tb[tdh]) != nil){
  766. c->tb[tdh] = nil;
  767. freeb(b);
  768. }else
  769. iprint("82563 tx underrun!\n");
  770. c->tdba[tdh].status = 0;
  771. }
  772. return c->tdh = tdh;
  773. }
  774. static void
  775. i82563transmit(Ether* edev)
  776. {
  777. Td *td;
  778. Block *bp;
  779. Ctlr *ctlr;
  780. int tdh, tdt, m;
  781. ctlr = edev->ctlr;
  782. qlock(&ctlr->tlock);
  783. /*
  784. * Free any completed packets
  785. */
  786. tdh = i82563cleanup(ctlr);
  787. /*
  788. * Try to fill the ring back up.
  789. */
  790. tdt = ctlr->tdt;
  791. m = ctlr->ntd-1;
  792. for(;;){
  793. if(Next(tdt, m) == tdh){
  794. ctlr->txdw++;
  795. i82563im(ctlr, Txdw);
  796. break;
  797. }
  798. if((bp = qget(edev->oq)) == nil)
  799. break;
  800. td = &ctlr->tdba[tdt];
  801. td->addr[0] = PCIWADDR(bp->rp);
  802. td->control = Ide|Rs|Ifcs|Teop|BLEN(bp);
  803. ctlr->tb[tdt] = bp;
  804. tdt = Next(tdt, m);
  805. }
  806. if(ctlr->tdt != tdt){
  807. ctlr->tdt = tdt;
  808. csr32w(ctlr, Tdt, tdt);
  809. }
  810. qunlock(&ctlr->tlock);
  811. }
  812. static void
  813. i82563replenish(Ctlr* ctlr)
  814. {
  815. Rd *rd;
  816. int rdt, m;
  817. Block *bp;
  818. rdt = ctlr->rdt;
  819. m = ctlr->nrd-1;
  820. while(Next(rdt, m) != ctlr->rdh){
  821. rd = &ctlr->rdba[rdt];
  822. if(ctlr->rb[rdt] != nil){
  823. iprint("82563: tx overrun\n");
  824. break;
  825. }
  826. bp = i82563rballoc();
  827. if(bp == nil){
  828. iprint("82563: no available buffers\n");
  829. break;
  830. }
  831. ctlr->rb[rdt] = bp;
  832. rd->addr[0] = PCIWADDR(bp->rp);
  833. // rd->addr[1] = 0;
  834. rd->status = 0;
  835. ctlr->rdfree++;
  836. rdt = Next(rdt, m);
  837. }
  838. ctlr->rdt = rdt;
  839. csr32w(ctlr, Rdt, rdt);
  840. }
  841. static void
  842. i82563rxinit(Ctlr* ctlr)
  843. {
  844. Block *bp;
  845. int i, r, rctl;
  846. if(ctlr->rbsz <= 2048)
  847. rctl = Dpf|Bsize2048|Bam|RdtmsHALF;
  848. else if(ctlr->rbsz <= 8192)
  849. rctl = Lpe|Dpf|Bsize8192|Bsex|Bam|RdtmsHALF|Secrc;
  850. else if(ctlr->rbsz <= 12*1024){
  851. i = ctlr->rbsz / 1024;
  852. if(ctlr->rbsz % 1024)
  853. i++;
  854. rctl = Lpe|Dpf|BsizeFlex*i|Bam|RdtmsHALF|Secrc;
  855. }
  856. else
  857. rctl = Lpe|Dpf|Bsize16384|Bsex|Bam|RdtmsHALF|Secrc;
  858. if(ctlr->type == i82575){
  859. /*
  860. * Setting Qenable in Rxdctl does not
  861. * appear to stick unless Ren is on.
  862. */
  863. csr32w(ctlr, Rctl, Ren|rctl);
  864. r = csr32r(ctlr, Rxdctl);
  865. r |= Qenable;
  866. csr32w(ctlr, Rxdctl, r);
  867. }
  868. csr32w(ctlr, Rctl, rctl);
  869. if(ctlr->type == i82573)
  870. csr32w(ctlr, Ert, 1024/8);
  871. if(ctlr->type == i82566)
  872. csr32w(ctlr, Pbs, 16);
  873. csr32w(ctlr, Rdbal, PCIWADDR(ctlr->rdba));
  874. csr32w(ctlr, Rdbah, 0);
  875. csr32w(ctlr, Rdlen, ctlr->nrd * sizeof(Rd));
  876. ctlr->rdh = 0;
  877. csr32w(ctlr, Rdh, 0);
  878. ctlr->rdt = 0;
  879. csr32w(ctlr, Rdt, 0);
  880. ctlr->rdtr = 25;
  881. ctlr->radv = 500;
  882. csr32w(ctlr, Rdtr, ctlr->rdtr);
  883. csr32w(ctlr, Radv, ctlr->radv);
  884. for(i = 0; i < ctlr->nrd; i++){
  885. if((bp = ctlr->rb[i]) != nil){
  886. ctlr->rb[i] = nil;
  887. freeb(bp);
  888. }
  889. }
  890. i82563replenish(ctlr);
  891. if(ctlr->type != i82575){
  892. /*
  893. * See comment above for Qenable.
  894. * Could shuffle the code?
  895. */
  896. r = csr32r(ctlr, Rxdctl);
  897. r &= ~(WthreshSHIFT|PthreshSHIFT);
  898. r |= (2<<WthreshSHIFT)|(2<<PthreshSHIFT);
  899. csr32w(ctlr, Rxdctl, r);
  900. }
  901. /*
  902. * Enable checksum offload.
  903. */
  904. csr32w(ctlr, Rxcsum, Tuofl | Ipofl | ETHERHDRSIZE<<PcssSHIFT);
  905. }
  906. static int
  907. i82563rim(void* ctlr)
  908. {
  909. return ((Ctlr*)ctlr)->rim != 0;
  910. }
  911. static void
  912. i82563rproc(void* arg)
  913. {
  914. Rd *rd;
  915. Block *bp;
  916. Ctlr *ctlr;
  917. int r, m, rdh, rim;
  918. Ether *edev;
  919. edev = arg;
  920. ctlr = edev->ctlr;
  921. i82563rxinit(ctlr);
  922. r = csr32r(ctlr, Rctl);
  923. r |= Ren;
  924. csr32w(ctlr, Rctl, r);
  925. m = ctlr->nrd-1;
  926. for(;;){
  927. i82563im(ctlr, Rxt0|Rxo|Rxdmt0|Rxseq|Ack);
  928. ctlr->rsleep++;
  929. // coherence();
  930. sleep(&ctlr->rrendez, i82563rim, ctlr);
  931. rdh = ctlr->rdh;
  932. for(;;){
  933. rd = &ctlr->rdba[rdh];
  934. rim = ctlr->rim;
  935. ctlr->rim = 0;
  936. if(!(rd->status & Rdd))
  937. break;
  938. /*
  939. * Accept eop packets with no errors.
  940. * With no errors and the Ixsm bit set,
  941. * the descriptor status Tpcs and Ipcs bits give
  942. * an indication of whether the checksums were
  943. * calculated and valid.
  944. */
  945. bp = ctlr->rb[rdh];
  946. if((rd->status & Reop) && rd->errors == 0){
  947. bp->wp += rd->length;
  948. bp->lim = bp->wp; /* lie like a dog. */
  949. if(!(rd->status & Ixsm)){
  950. ctlr->ixsm++;
  951. if(rd->status & Ipcs){
  952. /*
  953. * IP checksum calculated
  954. * (and valid as errors == 0).
  955. */
  956. ctlr->ipcs++;
  957. bp->flag |= Bipck;
  958. }
  959. if(rd->status & Tcpcs){
  960. /*
  961. * TCP/UDP checksum calculated
  962. * (and valid as errors == 0).
  963. */
  964. ctlr->tcpcs++;
  965. bp->flag |= Btcpck|Budpck;
  966. }
  967. bp->checksum = rd->checksum;
  968. bp->flag |= Bpktck;
  969. }
  970. etheriq(edev, bp, 1);
  971. } else
  972. freeb(bp);
  973. ctlr->rb[rdh] = nil;
  974. rd->status = 0;
  975. ctlr->rdfree--;
  976. ctlr->rdh = rdh = Next(rdh, m);
  977. if(ctlr->nrd-ctlr->rdfree >= 32 || (rim & Rxdmt0))
  978. i82563replenish(ctlr);
  979. }
  980. }
  981. }
  982. static int
  983. i82563lim(void* c)
  984. {
  985. return ((Ctlr*)c)->lim != 0;
  986. }
  987. static int speedtab[] = {
  988. 10, 100, 1000, 0
  989. };
  990. static uint
  991. phyread(Ctlr *c, int reg)
  992. {
  993. uint phy, i;
  994. csr32w(c, Mdic, MDIrop | 1<<MDIpSHIFT | reg<<MDIrSHIFT);
  995. phy = 0;
  996. for(i = 0; i < 64; i++){
  997. phy = csr32r(c, Mdic);
  998. if(phy & (MDIe|MDIready))
  999. break;
  1000. microdelay(1);
  1001. }
  1002. if((phy & (MDIe|MDIready)) != MDIready)
  1003. return ~0;
  1004. return phy & 0xffff;
  1005. }
  1006. static uint
  1007. phywrite(Ctlr *c, int reg, ushort val)
  1008. {
  1009. uint phy, i;
  1010. csr32w(c, Mdic, MDIwop | 1<<MDIpSHIFT | reg<<MDIrSHIFT | val);
  1011. phy = 0;
  1012. for(i = 0; i < 64; i++){
  1013. phy = csr32r(c, Mdic);
  1014. if(phy & (MDIe|MDIready))
  1015. break;
  1016. microdelay(1);
  1017. }
  1018. if((phy & (MDIe|MDIready)) != MDIready)
  1019. return ~0;
  1020. return 0;
  1021. }
  1022. /*
  1023. * watch for changes of link state
  1024. */
  1025. static void
  1026. i82563lproc(void *v)
  1027. {
  1028. uint phy, i, a;
  1029. Ctlr *c;
  1030. Ether *e;
  1031. e = v;
  1032. c = e->ctlr;
  1033. if(c->type == i82573 && (phy = phyread(c, Phyier)) != ~0)
  1034. phywrite(c, Phyier, phy | Lscie | Ancie | Spdie | Panie);
  1035. for(;;){
  1036. phy = phyread(c, Physsr);
  1037. if(phy == ~0)
  1038. goto next;
  1039. i = (phy>>14) & 3;
  1040. switch(c->type){
  1041. case i82563:
  1042. a = phyread(c, Phyisr) & Ane;
  1043. break;
  1044. case i82571:
  1045. case i82572:
  1046. a = phyread(c, Phylhr) & Anf;
  1047. i = (i-1) & 3;
  1048. break;
  1049. default:
  1050. a = 0;
  1051. break;
  1052. }
  1053. if(a)
  1054. phywrite(c, Phyctl, phyread(c, Phyctl) | Ran | Ean);
  1055. e->link = (phy & Rtlink) != 0;
  1056. if(e->link){
  1057. c->speeds[i]++;
  1058. e->mbps = speedtab[i];
  1059. }
  1060. next:
  1061. c->lim = 0;
  1062. i82563im(c, Lsc);
  1063. c->lsleep++;
  1064. sleep(&c->lrendez, i82563lim, c);
  1065. }
  1066. }
  1067. static void
  1068. i82563tproc(void *v)
  1069. {
  1070. Ether *e;
  1071. Ctlr *c;
  1072. e = v;
  1073. c = e->ctlr;
  1074. for(;;){
  1075. sleep(&c->trendez, return0, 0);
  1076. i82563transmit(e);
  1077. }
  1078. }
  1079. static void
  1080. i82563attach(Ether* edev)
  1081. {
  1082. Block *bp;
  1083. Ctlr *ctlr;
  1084. char name[KNAMELEN];
  1085. ctlr = edev->ctlr;
  1086. qlock(&ctlr->alock);
  1087. if(ctlr->attached){
  1088. qunlock(&ctlr->alock);
  1089. return;
  1090. }
  1091. ctlr->nrd = Nrd;
  1092. ctlr->ntd = Ntd;
  1093. if(waserror()){
  1094. while(ctlr->nrb > 0){
  1095. bp = i82563rballoc();
  1096. bp->free = nil;
  1097. freeb(bp);
  1098. ctlr->nrb--;
  1099. }
  1100. free(ctlr->tb);
  1101. ctlr->tb = nil;
  1102. free(ctlr->rb);
  1103. ctlr->rb = nil;
  1104. free(ctlr->tdba);
  1105. ctlr->tdba = nil;
  1106. free(ctlr->rdba);
  1107. ctlr->rdba = nil;
  1108. qunlock(&ctlr->alock);
  1109. nexterror();
  1110. }
  1111. if((ctlr->rdba = mallocalign(ctlr->nrd*sizeof(Rd), 128, 0, 0)) == nil)
  1112. error(Enomem);
  1113. if((ctlr->tdba = mallocalign(ctlr->ntd*sizeof(Td), 128, 0, 0)) == nil)
  1114. error(Enomem);
  1115. if((ctlr->rb = malloc(ctlr->nrd*sizeof(Block*))) == nil)
  1116. error(Enomem);
  1117. if((ctlr->tb = malloc(ctlr->ntd*sizeof(Block*))) == nil)
  1118. error(Enomem);
  1119. for(ctlr->nrb = 0; ctlr->nrb < Nrb; ctlr->nrb++){
  1120. if((bp = allocb(ctlr->rbsz + BY2PG)) == nil)
  1121. break;
  1122. bp->free = i82563rbfree;
  1123. freeb(bp);
  1124. }
  1125. ctlr->attached = 1;
  1126. snprint(name, sizeof name, "#l%dl", edev->ctlrno);
  1127. kproc(name, i82563lproc, edev);
  1128. snprint(name, sizeof name, "#l%dr", edev->ctlrno);
  1129. kproc(name, i82563rproc, edev);
  1130. snprint(name, sizeof name, "#l%dt", edev->ctlrno);
  1131. kproc(name, i82563tproc, edev);
  1132. i82563txinit(ctlr);
  1133. qunlock(&ctlr->alock);
  1134. poperror();
  1135. }
  1136. static void
  1137. i82563interrupt(Ureg*, void* arg)
  1138. {
  1139. Ctlr *ctlr;
  1140. Ether *edev;
  1141. int icr, im;
  1142. edev = arg;
  1143. ctlr = edev->ctlr;
  1144. ilock(&ctlr->imlock);
  1145. csr32w(ctlr, Imc, ~0);
  1146. im = ctlr->im;
  1147. for(icr = csr32r(ctlr, Icr); icr & ctlr->im; icr = csr32r(ctlr, Icr)){
  1148. if(icr & Lsc){
  1149. im &= ~Lsc;
  1150. ctlr->lim = icr & Lsc;
  1151. wakeup(&ctlr->lrendez);
  1152. ctlr->lintr++;
  1153. }
  1154. if(icr & (Rxt0|Rxo|Rxdmt0|Rxseq|Ack)){
  1155. ctlr->rim = icr & (Rxt0|Rxo|Rxdmt0|Rxseq|Ack);
  1156. im &= ~(Rxt0|Rxo|Rxdmt0|Rxseq|Ack);
  1157. wakeup(&ctlr->rrendez);
  1158. ctlr->rintr++;
  1159. }
  1160. if(icr & Txdw){
  1161. im &= ~Txdw;
  1162. ctlr->tintr++;
  1163. wakeup(&ctlr->trendez);
  1164. }
  1165. }
  1166. ctlr->im = im;
  1167. csr32w(ctlr, Ims, im);
  1168. iunlock(&ctlr->imlock);
  1169. }
  1170. static int
  1171. i82563detach(Ctlr* ctlr)
  1172. {
  1173. int r, timeo;
  1174. /*
  1175. * Perform a device reset to get the chip back to the
  1176. * power-on state, followed by an EEPROM reset to read
  1177. * the defaults for some internal registers.
  1178. */
  1179. csr32w(ctlr, Imc, ~0);
  1180. csr32w(ctlr, Rctl, 0);
  1181. csr32w(ctlr, Tctl, 0);
  1182. delay(10);
  1183. r = csr32r(ctlr, Ctrl);
  1184. if(ctlr->type == i82566)
  1185. r |= Phyrst;
  1186. csr32w(ctlr, Ctrl, Devrst | r);
  1187. delay(1);
  1188. for(timeo = 0; timeo < 1000; timeo++){
  1189. if(!(csr32r(ctlr, Ctrl) & Devrst))
  1190. break;
  1191. delay(1);
  1192. }
  1193. if(csr32r(ctlr, Ctrl) & Devrst)
  1194. return -1;
  1195. r = csr32r(ctlr, Ctrlext);
  1196. csr32w(ctlr, Ctrlext, r|Eerst);
  1197. delay(1);
  1198. for(timeo = 0; timeo < 1000; timeo++){
  1199. if(!(csr32r(ctlr, Ctrlext) & Eerst))
  1200. break;
  1201. delay(1);
  1202. }
  1203. if(csr32r(ctlr, Ctrlext) & Eerst)
  1204. return -1;
  1205. csr32w(ctlr, Imc, ~0);
  1206. delay(1);
  1207. for(timeo = 0; timeo < 1000; timeo++){
  1208. if(!csr32r(ctlr, Icr))
  1209. break;
  1210. delay(1);
  1211. }
  1212. if(csr32r(ctlr, Icr))
  1213. return -1;
  1214. /*
  1215. * Balance Rx/Tx packet buffer.
  1216. * No need to set PBA register unless using jumbo, defaults to 32KB
  1217. * for receive. If it is changed, then have to do a MAC reset,
  1218. * and need to do that at the the right time as it will wipe stuff.
  1219. */
  1220. if(ctlr->rbsz > 8192 && (ctlr->type == i82563 || ctlr->type == i82571 ||
  1221. ctlr->type == i82572)){
  1222. ctlr->pba = csr32r(ctlr, Pba);
  1223. r = ctlr->pba >> 16;
  1224. r += ctlr->pba & 0xffff;
  1225. r >>= 1;
  1226. csr32w(ctlr, Pba, r);
  1227. } else if(ctlr->type == i82573 && ctlr->rbsz > 1514)
  1228. csr32w(ctlr, Pba, 14);
  1229. ctlr->pba = csr32r(ctlr, Pba);
  1230. r = csr32r(ctlr, Ctrl);
  1231. csr32w(ctlr, Ctrl, Slu|r);
  1232. return 0;
  1233. }
  1234. static void
  1235. i82563shutdown(Ether* ether)
  1236. {
  1237. i82563detach(ether->ctlr);
  1238. }
  1239. static ushort
  1240. eeread(Ctlr *ctlr, int adr)
  1241. {
  1242. csr32w(ctlr, Eerd, EEstart | adr << 2);
  1243. while ((csr32r(ctlr, Eerd) & EEdone) == 0)
  1244. ;
  1245. return csr32r(ctlr, Eerd) >> 16;
  1246. }
  1247. static int
  1248. eeload(Ctlr *ctlr)
  1249. {
  1250. ushort sum;
  1251. int data, adr;
  1252. sum = 0;
  1253. for (adr = 0; adr < 0x40; adr++) {
  1254. data = eeread(ctlr, adr);
  1255. ctlr->eeprom[adr] = data;
  1256. sum += data;
  1257. }
  1258. return sum;
  1259. }
  1260. static int
  1261. fcycle(Ctlr *, Flash *f)
  1262. {
  1263. ushort s, i;
  1264. s = f->reg[Fsts];
  1265. if((s&Fvalid) == 0)
  1266. return -1;
  1267. f->reg[Fsts] |= Fcerr | Ael;
  1268. for(i = 0; i < 10; i++){
  1269. if((s&Scip) == 0)
  1270. return 0;
  1271. delay(1);
  1272. s = f->reg[Fsts];
  1273. }
  1274. return -1;
  1275. }
  1276. static int
  1277. fread(Ctlr *c, Flash *f, int ladr)
  1278. {
  1279. ushort s;
  1280. delay(1);
  1281. if(fcycle(c, f) == -1)
  1282. return -1;
  1283. f->reg[Fsts] |= Fdone;
  1284. f->reg32[Faddr] = ladr;
  1285. /* setup flash control register */
  1286. s = f->reg[Fctl];
  1287. s &= ~(0x1f << 8);
  1288. s |= (2-1) << 8; /* 2 bytes */
  1289. s &= ~(2*Flcycle); /* read */
  1290. f->reg[Fctl] = s | Fgo;
  1291. while((f->reg[Fsts] & Fdone) == 0)
  1292. ;
  1293. if(f->reg[Fsts] & (Fcerr|Ael))
  1294. return -1;
  1295. return f->reg32[Fdata] & 0xffff;
  1296. }
  1297. static int
  1298. fload(Ctlr *c)
  1299. {
  1300. ulong data, io, r, adr;
  1301. ushort sum;
  1302. Flash f;
  1303. io = c->pcidev->mem[1].bar & ~0x0f;
  1304. f.reg = vmap(io, c->pcidev->mem[1].size);
  1305. if(f.reg == nil)
  1306. return -1;
  1307. f.reg32 = (void*)f.reg;
  1308. f.sz = f.reg32[Bfpr];
  1309. r = f.sz & 0x1fff;
  1310. if(csr32r(c, Eec) & (1<<22))
  1311. ++r;
  1312. r <<= 12;
  1313. sum = 0;
  1314. for (adr = 0; adr < 0x40; adr++) {
  1315. data = fread(c, &f, r + adr*2);
  1316. if(data == -1)
  1317. break;
  1318. c->eeprom[adr] = data;
  1319. sum += data;
  1320. }
  1321. vunmap(f.reg, c->pcidev->mem[1].size);
  1322. return sum;
  1323. }
  1324. static int
  1325. i82563reset(Ctlr *ctlr)
  1326. {
  1327. int i, r;
  1328. if(i82563detach(ctlr))
  1329. return -1;
  1330. if(ctlr->type == i82566)
  1331. r = fload(ctlr);
  1332. else
  1333. r = eeload(ctlr);
  1334. if (r != 0 && r != 0xBABA){
  1335. print("%s: bad EEPROM checksum - %#.4ux\n",
  1336. tname[ctlr->type], r);
  1337. return -1;
  1338. }
  1339. for(i = 0; i < Eaddrlen/2; i++){
  1340. ctlr->ra[2*i] = ctlr->eeprom[Ea+i];
  1341. ctlr->ra[2*i+1] = ctlr->eeprom[Ea+i] >> 8;
  1342. }
  1343. r = (csr32r(ctlr, Status) & Lanid) >> 2;
  1344. ctlr->ra[5] += r; /* ea ctlr[1] = ea ctlr[0]+1 */
  1345. r = ctlr->ra[3]<<24 | ctlr->ra[2]<<16 | ctlr->ra[1]<<8 | ctlr->ra[0];
  1346. csr32w(ctlr, Ral, r);
  1347. r = 0x80000000 | ctlr->ra[5]<<8 | ctlr->ra[4];
  1348. csr32w(ctlr, Rah, r);
  1349. for(i = 1; i < 16; i++){
  1350. csr32w(ctlr, Ral+i*8, 0);
  1351. csr32w(ctlr, Rah+i*8, 0);
  1352. }
  1353. memset(ctlr->mta, 0, sizeof(ctlr->mta));
  1354. for(i = 0; i < 128; i++)
  1355. csr32w(ctlr, Mta + i*4, 0);
  1356. /*
  1357. * Does autonegotiation affect this manual setting?
  1358. * The correct values here should depend on the PBA value
  1359. * and maximum frame length, no?
  1360. * ctlr->fcrt[lh] are never set, so default to 0.
  1361. */
  1362. csr32w(ctlr, Fcal, 0x00C28001);
  1363. csr32w(ctlr, Fcah, 0x0100);
  1364. csr32w(ctlr, Fct, 0x8808);
  1365. csr32w(ctlr, Fcttv, 0x0100);
  1366. csr32w(ctlr, Fcrtl, ctlr->fcrtl);
  1367. csr32w(ctlr, Fcrth, ctlr->fcrth);
  1368. return 0;
  1369. }
  1370. static void
  1371. i82563pci(void)
  1372. {
  1373. int type;
  1374. ulong io;
  1375. void *mem;
  1376. Pcidev *p;
  1377. Ctlr *ctlr;
  1378. p = nil;
  1379. while(p = pcimatch(p, 0x8086, 0)){
  1380. switch(p->did){
  1381. default:
  1382. continue;
  1383. case 0x1096:
  1384. case 0x10ba:
  1385. type = i82563;
  1386. break;
  1387. case 0x1049: /* mm */
  1388. case 0x104a: /* dm */
  1389. case 0x104d: /* v */
  1390. case 0x10bd: /* dm */
  1391. type = i82566;
  1392. break;
  1393. case 0x10a4:
  1394. case 0x105e:
  1395. type = i82571;
  1396. break;
  1397. case 0x10b9: /* sic, 82572 */
  1398. type = i82572;
  1399. break;
  1400. case 0x108b: /* e */
  1401. case 0x108c: /* e (iamt) */
  1402. case 0x109a: /* l */
  1403. type = i82573;
  1404. break;
  1405. case 0x10a7: /* 82575eb */
  1406. type = i82575;
  1407. break;
  1408. }
  1409. io = p->mem[0].bar & ~0x0F;
  1410. mem = vmap(io, p->mem[0].size);
  1411. if(mem == nil){
  1412. print("%s: can't map %.8lux\n", tname[type], io);
  1413. continue;
  1414. }
  1415. ctlr = malloc(sizeof(Ctlr));
  1416. ctlr->port = io;
  1417. ctlr->pcidev = p;
  1418. ctlr->type = type;
  1419. ctlr->rbsz = rbtab[type];
  1420. ctlr->nic = mem;
  1421. if(i82563reset(ctlr)){
  1422. vunmap(mem, p->mem[0].size);
  1423. free(ctlr);
  1424. continue;
  1425. }
  1426. pcisetbme(p);
  1427. if(i82563ctlrhead != nil)
  1428. i82563ctlrtail->next = ctlr;
  1429. else
  1430. i82563ctlrhead = ctlr;
  1431. i82563ctlrtail = ctlr;
  1432. }
  1433. }
  1434. static int
  1435. pnp(Ether* edev, int type)
  1436. {
  1437. Ctlr *ctlr;
  1438. static int done;
  1439. if(!done) {
  1440. i82563pci();
  1441. done = 1;
  1442. }
  1443. /*
  1444. * Any adapter matches if no edev->port is supplied,
  1445. * otherwise the ports must match.
  1446. */
  1447. for(ctlr = i82563ctlrhead; ctlr != nil; ctlr = ctlr->next){
  1448. if(ctlr->active)
  1449. continue;
  1450. if(type != Iany && ctlr->type != type)
  1451. continue;
  1452. if(edev->port == 0 || edev->port == ctlr->port){
  1453. ctlr->active = 1;
  1454. break;
  1455. }
  1456. }
  1457. if(ctlr == nil)
  1458. return -1;
  1459. edev->ctlr = ctlr;
  1460. edev->port = ctlr->port;
  1461. edev->irq = ctlr->pcidev->intl;
  1462. edev->tbdf = ctlr->pcidev->tbdf;
  1463. edev->mbps = 1000;
  1464. edev->maxmtu = ctlr->rbsz;
  1465. memmove(edev->ea, ctlr->ra, Eaddrlen);
  1466. /*
  1467. * Linkage to the generic ethernet driver.
  1468. */
  1469. edev->attach = i82563attach;
  1470. edev->transmit = i82563transmit;
  1471. edev->interrupt = i82563interrupt;
  1472. edev->ifstat = i82563ifstat;
  1473. edev->ctl = i82563ctl;
  1474. edev->arg = edev;
  1475. edev->promiscuous = i82563promiscuous;
  1476. edev->shutdown = i82563shutdown;
  1477. edev->multicast = i82563multicast;
  1478. return 0;
  1479. }
  1480. static int
  1481. anypnp(Ether *e)
  1482. {
  1483. return pnp(e, Iany);
  1484. }
  1485. static int
  1486. i82563pnp(Ether *e)
  1487. {
  1488. return pnp(e, i82563);
  1489. }
  1490. static int
  1491. i82566pnp(Ether *e)
  1492. {
  1493. return pnp(e, i82566);
  1494. }
  1495. static int
  1496. i82571pnp(Ether *e)
  1497. {
  1498. return pnp(e, i82571);
  1499. }
  1500. static int
  1501. i82572pnp(Ether *e)
  1502. {
  1503. return pnp(e, i82572);
  1504. }
  1505. static int
  1506. i82573pnp(Ether *e)
  1507. {
  1508. return pnp(e, i82573);
  1509. }
  1510. static int
  1511. i82575pnp(Ether *e)
  1512. {
  1513. return pnp(e, i82575);
  1514. }
  1515. void
  1516. ether82563link(void)
  1517. {
  1518. /* recognise lots of model numbers for debugging assistance */
  1519. addethercard("i82563", i82563pnp);
  1520. addethercard("i82566", i82566pnp);
  1521. addethercard("i82571", i82571pnp);
  1522. addethercard("i82572", i82572pnp);
  1523. addethercard("i82573", i82573pnp);
  1524. addethercard("i82575", i82575pnp);
  1525. addethercard("igbepcie", anypnp);
  1526. }