etherigbe.c 40 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741
  1. /*
  2. * bootstrap driver for
  3. * Intel RS-82543GC Gigabit Ethernet PCI Controllers
  4. * as found on the Intel PRO/1000[FT] Server Adapter.
  5. * The older non-[FT] cards use the 82542 (LSI L2A1157) chip; no attempt
  6. * is made to handle the older chip although it should be possible.
  7. *
  8. * updated just enough to cope with the
  9. * Intel 8254[0347]NN Gigabit Ethernet Controller
  10. * as found on the Intel PRO/1000 series of adapters:
  11. * 82540EM Intel PRO/1000 MT
  12. * 82543GC Intel PRO/1000 T
  13. * 82544EI Intel PRO/1000 XT
  14. * 82547EI built-in
  15. *
  16. * The datasheet is not very clear about running on a big-endian system
  17. * and this driver assumes little-endian throughout.
  18. * To do:
  19. * GMII/MII
  20. * check recovery from receive no buffers condition
  21. * automatic ett adjustment
  22. */
  23. #include "u.h"
  24. #include "lib.h"
  25. #include "mem.h"
  26. #include "dat.h"
  27. #include "fns.h"
  28. #include "io.h"
  29. #include "etherif.h"
  30. #include "ethermii.h"
  31. enum {
  32. Debug = 0, /* mostly for X60 debugging */
  33. };
  34. enum {
  35. i82542 = (0x1000<<16)|0x8086,
  36. i82543gc = (0x1004<<16)|0x8086,
  37. i82544ei = (0x1008<<16)|0x8086,
  38. i82540em = (0x100E<<16)|0x8086,
  39. i82546eb = (0x1010<<16)|0x8086,
  40. i82547ei = (0x1019<<16)|0x8086,
  41. i82540eplp = (0x101E<<16)|0x8086,
  42. i82547gi = (0x1075<<16)|0x8086,
  43. i82541gi = (0x1076<<16)|0x8086,
  44. i82541gi2 = (0x1077<<16)|0x8086,
  45. i82546gb = (0x1079<<16)|0x8086,
  46. i82541pi = (0x107c<<16)|0x8086,
  47. };
  48. /* compatibility with cpu kernels */
  49. #define iallocb allocb
  50. #ifndef CACHELINESZ
  51. #define CACHELINESZ 32 /* pentium & later */
  52. #endif
  53. /* from pci.c */
  54. enum
  55. { /* command register (pcidev->pcr) */
  56. IOen = (1<<0),
  57. MEMen = (1<<1),
  58. MASen = (1<<2),
  59. MemWrInv = (1<<4),
  60. PErrEn = (1<<6),
  61. SErrEn = (1<<8),
  62. };
  63. enum {
  64. Ctrl = 0x00000000, /* Device Control */
  65. Status = 0x00000008, /* Device Status */
  66. Eecd = 0x00000010, /* EEPROM/Flash Control/Data */
  67. Ctrlext = 0x00000018, /* Extended Device Control */
  68. Mdic = 0x00000020, /* MDI Control */
  69. Fcal = 0x00000028, /* Flow Control Address Low */
  70. Fcah = 0x0000002C, /* Flow Control Address High */
  71. Fct = 0x00000030, /* Flow Control Type */
  72. Icr = 0x000000C0, /* Interrupt Cause Read */
  73. Ics = 0x000000C8, /* Interrupt Cause Set */
  74. Ims = 0x000000D0, /* Interrupt Mask Set/Read */
  75. Imc = 0x000000D8, /* Interrupt mask Clear */
  76. Rctl = 0x00000100, /* Receive Control */
  77. Fcttv = 0x00000170, /* Flow Control Transmit Timer Value */
  78. Txcw = 0x00000178, /* Transmit Configuration Word */
  79. Tctl = 0x00000400, /* Transmit Control */
  80. Tipg = 0x00000410, /* Transmit IPG */
  81. Tbt = 0x00000448, /* Transmit Burst Timer */
  82. Ait = 0x00000458, /* Adaptive IFS Throttle */
  83. Fcrtl = 0x00002160, /* Flow Control RX Threshold Low */
  84. Fcrth = 0x00002168, /* Flow Control Rx Threshold High */
  85. Rdbal = 0x00002800, /* Rdesc Base Address Low */
  86. Rdbah = 0x00002804, /* Rdesc Base Address High */
  87. Rdlen = 0x00002808, /* Receive Descriptor Length */
  88. Rdh = 0x00002810, /* Receive Descriptor Head */
  89. Rdt = 0x00002818, /* Receive Descriptor Tail */
  90. Rdtr = 0x00002820, /* Receive Descriptor Timer Ring */
  91. Rxdctl = 0x00002828, /* Receive Descriptor Control */
  92. Radv = 0x0000282C, /* Receive Interrupt Absolute Delay Timer */
  93. Txdmac = 0x00003000, /* Transfer DMA Control */
  94. Ett = 0x00003008, /* Early Transmit Control */
  95. Tdbal = 0x00003800, /* Tdesc Base Address Low */
  96. Tdbah = 0x00003804, /* Tdesc Base Address High */
  97. Tdlen = 0x00003808, /* Transmit Descriptor Length */
  98. Tdh = 0x00003810, /* Transmit Descriptor Head */
  99. Tdt = 0x00003818, /* Transmit Descriptor Tail */
  100. Tidv = 0x00003820, /* Transmit Interrupt Delay Value */
  101. Txdctl = 0x00003828, /* Transmit Descriptor Control */
  102. Tadv = 0x0000382C, /* Transmit Interrupt Absolute Delay Timer */
  103. Statistics = 0x00004000, /* Start of Statistics Area */
  104. Gorcl = 0x88/4, /* Good Octets Received Count */
  105. Gotcl = 0x90/4, /* Good Octets Transmitted Count */
  106. Torl = 0xC0/4, /* Total Octets Received */
  107. Totl = 0xC8/4, /* Total Octets Transmitted */
  108. Nstatistics = 64,
  109. Rxcsum = 0x00005000, /* Receive Checksum Control */
  110. Mta = 0x00005200, /* Multicast Table Array */
  111. Ral = 0x00005400, /* Receive Address Low */
  112. Rah = 0x00005404, /* Receive Address High */
  113. Manc = 0x00005820, /* Management Control */
  114. };
  115. enum { /* Ctrl */
  116. Bem = 0x00000002, /* Big Endian Mode */
  117. Prior = 0x00000004, /* Priority on the PCI bus */
  118. Lrst = 0x00000008, /* Link Reset */
  119. Asde = 0x00000020, /* Auto-Speed Detection Enable */
  120. Slu = 0x00000040, /* Set Link Up */
  121. Ilos = 0x00000080, /* Invert Loss of Signal (LOS) */
  122. SspeedMASK = 0x00000300, /* Speed Selection */
  123. SspeedSHIFT = 8,
  124. Sspeed10 = 0x00000000, /* 10Mb/s */
  125. Sspeed100 = 0x00000100, /* 100Mb/s */
  126. Sspeed1000 = 0x00000200, /* 1000Mb/s */
  127. Frcspd = 0x00000800, /* Force Speed */
  128. Frcdplx = 0x00001000, /* Force Duplex */
  129. SwdpinsloMASK = 0x003C0000, /* Software Defined Pins - lo nibble */
  130. SwdpinsloSHIFT = 18,
  131. SwdpioloMASK = 0x03C00000, /* Software Defined Pins - I or O */
  132. SwdpioloSHIFT = 22,
  133. Devrst = 0x04000000, /* Device Reset */
  134. Rfce = 0x08000000, /* Receive Flow Control Enable */
  135. Tfce = 0x10000000, /* Transmit Flow Control Enable */
  136. Vme = 0x40000000, /* VLAN Mode Enable */
  137. };
  138. /*
  139. * can't find Tckok nor Rbcok in any Intel docs,
  140. * but even 82543gc docs define Lanid.
  141. */
  142. enum { /* Status */
  143. Lu = 0x00000002, /* Link Up */
  144. Lanid = 0x0000000C, /* mask for Lan ID. (function id) */
  145. // Tckok = 0x00000004, /* Transmit clock is running */
  146. // Rbcok = 0x00000008, /* Receive clock is running */
  147. Txoff = 0x00000010, /* Transmission Paused */
  148. Tbimode = 0x00000020, /* TBI Mode Indication */
  149. SpeedMASK = 0x000000C0,
  150. Speed10 = 0x00000000, /* 10Mb/s */
  151. Speed100 = 0x00000040, /* 100Mb/s */
  152. Speed1000 = 0x00000080, /* 1000Mb/s */
  153. Mtxckok = 0x00000400, /* MTX clock is running */
  154. Pci66 = 0x00000800, /* PCI Bus speed indication */
  155. Bus64 = 0x00001000, /* PCI Bus width indication */
  156. };
  157. enum { /* Ctrl and Status */
  158. Fd = 0x00000001, /* Full-Duplex */
  159. AsdvMASK = 0x00000300,
  160. Asdv10 = 0x00000000, /* 10Mb/s */
  161. Asdv100 = 0x00000100, /* 100Mb/s */
  162. Asdv1000 = 0x00000200, /* 1000Mb/s */
  163. };
  164. enum { /* Eecd */
  165. Sk = 0x00000001, /* Clock input to the EEPROM */
  166. Cs = 0x00000002, /* Chip Select */
  167. Di = 0x00000004, /* Data Input to the EEPROM */
  168. Do = 0x00000008, /* Data Output from the EEPROM */
  169. Areq = 0x00000040, /* EEPROM Access Request */
  170. Agnt = 0x00000080, /* EEPROM Access Grant */
  171. Eepresent = 0x00000100, /* EEPROM Present */
  172. Eesz256 = 0x00000200, /* EEPROM is 256 words not 64 */
  173. Eeszaddr = 0x00000400, /* EEPROM size for 8254[17] */
  174. Spi = 0x00002000, /* EEPROM is SPI not Microwire */
  175. };
  176. enum { /* Ctrlext */
  177. Gpien = 0x0000000F, /* General Purpose Interrupt Enables */
  178. SwdpinshiMASK = 0x000000F0, /* Software Defined Pins - hi nibble */
  179. SwdpinshiSHIFT = 4,
  180. SwdpiohiMASK = 0x00000F00, /* Software Defined Pins - I or O */
  181. SwdpiohiSHIFT = 8,
  182. Asdchk = 0x00001000, /* ASD Check */
  183. Eerst = 0x00002000, /* EEPROM Reset */
  184. Ips = 0x00004000, /* Invert Power State */
  185. Spdbyps = 0x00008000, /* Speed Select Bypass */
  186. };
  187. enum { /* EEPROM content offsets */
  188. Ea = 0x00, /* Ethernet Address */
  189. Cf = 0x03, /* Compatibility Field */
  190. Pba = 0x08, /* Printed Board Assembly number */
  191. Icw1 = 0x0A, /* Initialization Control Word 1 */
  192. Sid = 0x0B, /* Subsystem ID */
  193. Svid = 0x0C, /* Subsystem Vendor ID */
  194. Did = 0x0D, /* Device ID */
  195. Vid = 0x0E, /* Vendor ID */
  196. Icw2 = 0x0F, /* Initialization Control Word 2 */
  197. };
  198. enum { /* Mdic */
  199. MDIdMASK = 0x0000FFFF, /* Data */
  200. MDIdSHIFT = 0,
  201. MDIrMASK = 0x001F0000, /* PHY Register Address */
  202. MDIrSHIFT = 16,
  203. MDIpMASK = 0x03E00000, /* PHY Address */
  204. MDIpSHIFT = 21,
  205. MDIwop = 0x04000000, /* Write Operation */
  206. MDIrop = 0x08000000, /* Read Operation */
  207. MDIready = 0x10000000, /* End of Transaction */
  208. MDIie = 0x20000000, /* Interrupt Enable */
  209. MDIe = 0x40000000, /* Error */
  210. };
  211. enum { /* Icr, Ics, Ims, Imc */
  212. Txdw = 0x00000001, /* Transmit Descriptor Written Back */
  213. Txqe = 0x00000002, /* Transmit Queue Empty */
  214. Lsc = 0x00000004, /* Link Status Change */
  215. Rxseq = 0x00000008, /* Receive Sequence Error */
  216. Rxdmt0 = 0x00000010, /* Rdesc Minimum Threshold Reached */
  217. Rxo = 0x00000040, /* Receiver Overrun */
  218. Rxt0 = 0x00000080, /* Receiver Timer Interrupt */
  219. Mdac = 0x00000200, /* MDIO Access Completed */
  220. Rxcfg = 0x00000400, /* Receiving /C/ ordered sets */
  221. Gpi0 = 0x00000800, /* General Purpose Interrupts */
  222. Gpi1 = 0x00001000,
  223. Gpi2 = 0x00002000,
  224. Gpi3 = 0x00004000,
  225. };
  226. /*
  227. * The Mdic register isn't implemented on the 82543GC,
  228. * the software defined pins are used instead.
  229. * These definitions work for the Intel PRO/1000 T Server Adapter.
  230. * The direction pin bits are read from the EEPROM.
  231. */
  232. enum {
  233. Mdd = ((1<<2)<<SwdpinsloSHIFT), /* data */
  234. Mddo = ((1<<2)<<SwdpioloSHIFT), /* pin direction */
  235. Mdc = ((1<<3)<<SwdpinsloSHIFT), /* clock */
  236. Mdco = ((1<<3)<<SwdpioloSHIFT), /* pin direction */
  237. Mdr = ((1<<0)<<SwdpinshiSHIFT), /* reset */
  238. Mdro = ((1<<0)<<SwdpiohiSHIFT), /* pin direction */
  239. };
  240. enum { /* Txcw */
  241. TxcwFd = 0x00000020, /* Full Duplex */
  242. TxcwHd = 0x00000040, /* Half Duplex */
  243. TxcwPauseMASK = 0x00000180, /* Pause */
  244. TxcwPauseSHIFT = 7,
  245. TxcwPs = (1<<TxcwPauseSHIFT), /* Pause Supported */
  246. TxcwAs = (2<<TxcwPauseSHIFT), /* Asymmetric FC desired */
  247. TxcwRfiMASK = 0x00003000, /* Remote Fault Indication */
  248. TxcwRfiSHIFT = 12,
  249. TxcwNpr = 0x00008000, /* Next Page Request */
  250. TxcwConfig = 0x40000000, /* Transmit COnfig Control */
  251. TxcwAne = 0x80000000, /* Auto-Negotiation Enable */
  252. };
  253. enum { /* Rctl */
  254. Rrst = 0x00000001, /* Receiver Software Reset */
  255. Ren = 0x00000002, /* Receiver Enable */
  256. Sbp = 0x00000004, /* Store Bad Packets */
  257. Upe = 0x00000008, /* Unicast Promiscuous Enable */
  258. Mpe = 0x00000010, /* Multicast Promiscuous Enable */
  259. Lpe = 0x00000020, /* Long Packet Reception Enable */
  260. LbmMASK = 0x000000C0, /* Loopback Mode */
  261. LbmOFF = 0x00000000, /* No Loopback */
  262. LbmTBI = 0x00000040, /* TBI Loopback */
  263. LbmMII = 0x00000080, /* GMII/MII Loopback */
  264. LbmXCVR = 0x000000C0, /* Transceiver Loopback */
  265. RdtmsMASK = 0x00000300, /* Rdesc Minimum Threshold Size */
  266. RdtmsHALF = 0x00000000, /* Threshold is 1/2 Rdlen */
  267. RdtmsQUARTER = 0x00000100, /* Threshold is 1/4 Rdlen */
  268. RdtmsEIGHTH = 0x00000200, /* Threshold is 1/8 Rdlen */
  269. MoMASK = 0x00003000, /* Multicast Offset */
  270. Bam = 0x00008000, /* Broadcast Accept Mode */
  271. BsizeMASK = 0x00030000, /* Receive Buffer Size */
  272. Bsize2048 = 0x00000000,
  273. Bsize1024 = 0x00010000,
  274. Bsize512 = 0x00020000,
  275. Bsize256 = 0x00030000,
  276. Vfe = 0x00040000, /* VLAN Filter Enable */
  277. Cfien = 0x00080000, /* Canonical Form Indicator Enable */
  278. Cfi = 0x00100000, /* Canonical Form Indicator value */
  279. Dpf = 0x00400000, /* Discard Pause Frames */
  280. Pmcf = 0x00800000, /* Pass MAC Control Frames */
  281. Bsex = 0x02000000, /* Buffer Size Extension */
  282. Secrc = 0x04000000, /* Strip CRC from incoming packet */
  283. };
  284. enum { /* Tctl */
  285. Trst = 0x00000001, /* Transmitter Software Reset */
  286. Ten = 0x00000002, /* Transmit Enable */
  287. Psp = 0x00000008, /* Pad Short Packets */
  288. CtMASK = 0x00000FF0, /* Collision Threshold */
  289. CtSHIFT = 4,
  290. ColdMASK = 0x003FF000, /* Collision Distance */
  291. ColdSHIFT = 12,
  292. Swxoff = 0x00400000, /* Sofware XOFF Transmission */
  293. Pbe = 0x00800000, /* Packet Burst Enable */
  294. Rtlc = 0x01000000, /* Re-transmit on Late Collision */
  295. Nrtu = 0x02000000, /* No Re-transmit on Underrrun */
  296. };
  297. enum { /* [RT]xdctl */
  298. PthreshMASK = 0x0000003F, /* Prefetch Threshold */
  299. PthreshSHIFT = 0,
  300. HthreshMASK = 0x00003F00, /* Host Threshold */
  301. HthreshSHIFT = 8,
  302. WthreshMASK = 0x003F0000, /* Writebacj Threshold */
  303. WthreshSHIFT = 16,
  304. Gran = 0x01000000, /* Granularity */
  305. };
  306. enum { /* Rxcsum */
  307. PcssMASK = 0x000000FF, /* Packet Checksum Start */
  308. PcssSHIFT = 0,
  309. Ipofl = 0x00000100, /* IP Checksum Off-load Enable */
  310. Tuofl = 0x00000200, /* TCP/UDP Checksum Off-load Enable */
  311. };
  312. enum { /* Manc */
  313. Arpen = 0x00002000, /* Enable ARP Request Filtering */
  314. };
  315. typedef struct Rdesc { /* Receive Descriptor */
  316. uint addr[2];
  317. ushort length;
  318. ushort checksum;
  319. uchar status;
  320. uchar errors;
  321. ushort special;
  322. } Rdesc;
  323. enum { /* Rdesc status */
  324. Rdd = 0x01, /* Descriptor Done */
  325. Reop = 0x02, /* End of Packet */
  326. Ixsm = 0x04, /* Ignore Checksum Indication */
  327. Vp = 0x08, /* Packet is 802.1Q (matched VET) */
  328. Tcpcs = 0x20, /* TCP Checksum Calculated on Packet */
  329. Ipcs = 0x40, /* IP Checksum Calculated on Packet */
  330. Pif = 0x80, /* Passed in-exact filter */
  331. };
  332. enum { /* Rdesc errors */
  333. Ce = 0x01, /* CRC Error or Alignment Error */
  334. Se = 0x02, /* Symbol Error */
  335. Seq = 0x04, /* Sequence Error */
  336. Cxe = 0x10, /* Carrier Extension Error */
  337. Tcpe = 0x20, /* TCP/UDP Checksum Error */
  338. Ipe = 0x40, /* IP Checksum Error */
  339. Rxe = 0x80, /* RX Data Error */
  340. };
  341. typedef struct Tdesc { /* Legacy+Normal Transmit Descriptor */
  342. uint addr[2];
  343. uint control; /* varies with descriptor type */
  344. uint status; /* varies with descriptor type */
  345. } Tdesc;
  346. enum { /* Tdesc control */
  347. LenMASK = 0x000FFFFF, /* Data/Packet Length Field */
  348. LenSHIFT = 0,
  349. DtypeCD = 0x00000000, /* Data Type 'Context Descriptor' */
  350. DtypeDD = 0x00100000, /* Data Type 'Data Descriptor' */
  351. PtypeTCP = 0x01000000, /* TCP/UDP Packet Type (CD) */
  352. Teop = 0x01000000, /* End of Packet (DD) */
  353. PtypeIP = 0x02000000, /* IP Packet Type (CD) */
  354. Ifcs = 0x02000000, /* Insert FCS (DD) */
  355. Tse = 0x04000000, /* TCP Segmentation Enable */
  356. Rs = 0x08000000, /* Report Status */
  357. Rps = 0x10000000, /* Report Status Sent */
  358. Dext = 0x20000000, /* Descriptor Extension */
  359. Vle = 0x40000000, /* VLAN Packet Enable */
  360. Ide = 0x80000000, /* Interrupt Delay Enable */
  361. };
  362. enum { /* Tdesc status */
  363. Tdd = 0x00000001, /* Descriptor Done */
  364. Ec = 0x00000002, /* Excess Collisions */
  365. Lc = 0x00000004, /* Late Collision */
  366. Tu = 0x00000008, /* Transmit Underrun */
  367. CssMASK = 0x0000FF00, /* Checksum Start Field */
  368. CssSHIFT = 8,
  369. };
  370. enum {
  371. Nrdesc = 32, /* multiple of 8 */
  372. Ntdesc = 8, /* multiple of 8 */
  373. };
  374. typedef struct Ctlr Ctlr;
  375. typedef struct Ctlr {
  376. int port;
  377. Pcidev* pcidev;
  378. Ctlr* next;
  379. int active;
  380. int id;
  381. int cls;
  382. ushort eeprom[0x40];
  383. int* nic;
  384. Lock imlock;
  385. int im; /* interrupt mask */
  386. Mii* mii;
  387. Lock slock;
  388. uint statistics[Nstatistics];
  389. uchar ra[Eaddrlen]; /* receive address */
  390. ulong mta[128]; /* multicast table array */
  391. Rdesc* rdba; /* receive descriptor base address */
  392. Block** rb; /* receive buffers */
  393. int rdh; /* receive descriptor head */
  394. int rdt; /* receive descriptor tail */
  395. Tdesc* tdba; /* transmit descriptor base address */
  396. Lock tdlock;
  397. Block** tb; /* transmit buffers */
  398. int tdh; /* transmit descriptor head */
  399. int tdt; /* transmit descriptor tail */
  400. int ett; /* early transmit threshold */
  401. int txcw;
  402. int fcrtl;
  403. int fcrth;
  404. /* bootstrap goo */
  405. Block* bqhead; /* transmission queue */
  406. Block* bqtail;
  407. } Ctlr;
  408. static Ctlr* ctlrhead;
  409. static Ctlr* ctlrtail;
  410. #define csr32r(c, r) (*((c)->nic+((r)/4)))
  411. #define csr32w(c, r, v) (*((c)->nic+((r)/4)) = (v))
  412. static void
  413. igbeim(Ctlr* ctlr, int im)
  414. {
  415. ilock(&ctlr->imlock);
  416. ctlr->im |= im;
  417. csr32w(ctlr, Ims, ctlr->im);
  418. iunlock(&ctlr->imlock);
  419. }
  420. static void
  421. igbeattach(Ether* edev)
  422. {
  423. int ctl;
  424. Ctlr *ctlr;
  425. /*
  426. * To do here:
  427. * one-time stuff;
  428. * start off a kproc for link status change:
  429. * adjust queue length depending on speed;
  430. * flow control.
  431. * more needed here...
  432. */
  433. ctlr = edev->ctlr;
  434. igbeim(ctlr, 0);
  435. ctl = csr32r(ctlr, Rctl)|Ren;
  436. csr32w(ctlr, Rctl, ctl);
  437. ctl = csr32r(ctlr, Tctl)|Ten;
  438. csr32w(ctlr, Tctl, ctl);
  439. }
  440. static char* statistics[Nstatistics] = {
  441. "CRC Error",
  442. "Alignment Error",
  443. "Symbol Error",
  444. "RX Error",
  445. "Missed Packets",
  446. "Single Collision",
  447. "Excessive Collisions",
  448. "Multiple Collision",
  449. "Late Collisions",
  450. nil,
  451. "Collision",
  452. "Transmit Underrun",
  453. "Defer",
  454. "Transmit - No CRS",
  455. "Sequence Error",
  456. "Carrier Extension Error",
  457. "Receive Error Length",
  458. nil,
  459. "XON Received",
  460. "XON Transmitted",
  461. "XOFF Received",
  462. "XOFF Transmitted",
  463. "FC Received Unsupported",
  464. "Packets Received (64 Bytes)",
  465. "Packets Received (65-127 Bytes)",
  466. "Packets Received (128-255 Bytes)",
  467. "Packets Received (256-511 Bytes)",
  468. "Packets Received (512-1023 Bytes)",
  469. "Packets Received (1024-1522 Bytes)",
  470. "Good Packets Received",
  471. "Broadcast Packets Received",
  472. "Multicast Packets Received",
  473. "Good Packets Transmitted",
  474. nil,
  475. "Good Octets Received",
  476. nil,
  477. "Good Octets Transmitted",
  478. nil,
  479. nil,
  480. nil,
  481. "Receive No Buffers",
  482. "Receive Undersize",
  483. "Receive Fragment",
  484. "Receive Oversize",
  485. "Receive Jabber",
  486. nil,
  487. nil,
  488. nil,
  489. "Total Octets Received",
  490. nil,
  491. "Total Octets Transmitted",
  492. nil,
  493. "Total Packets Received",
  494. "Total Packets Transmitted",
  495. "Packets Transmitted (64 Bytes)",
  496. "Packets Transmitted (65-127 Bytes)",
  497. "Packets Transmitted (128-255 Bytes)",
  498. "Packets Transmitted (256-511 Bytes)",
  499. "Packets Transmitted (512-1023 Bytes)",
  500. "Packets Transmitted (1024-1522 Bytes)",
  501. "Multicast Packets Transmitted",
  502. "Broadcast Packets Transmitted",
  503. "TCP Segmentation Context Transmitted",
  504. "TCP Segmentation Context Fail",
  505. };
  506. static void
  507. txstart(Ether *edev)
  508. {
  509. int tdh, tdt, len, olen;
  510. Ctlr *ctlr = edev->ctlr;
  511. Block *bp;
  512. Tdesc *tdesc;
  513. /*
  514. * Try to fill the ring back up, moving buffers from the transmit q.
  515. */
  516. tdh = PREV(ctlr->tdh, Ntdesc);
  517. for(tdt = ctlr->tdt; tdt != tdh; tdt = NEXT(tdt, Ntdesc)){
  518. /* pull off the head of the transmission queue */
  519. if((bp = ctlr->bqhead) == nil) /* was qget(edev->oq) */
  520. break;
  521. ctlr->bqhead = bp->next;
  522. if (ctlr->bqtail == bp)
  523. ctlr->bqtail = nil;
  524. len = olen = BLEN(bp);
  525. /*
  526. * if packet is too short, make it longer rather than relying
  527. * on ethernet interface to pad it and complain so the caller
  528. * will get fixed. I don't think Psp is working right, or it's
  529. * getting cleared.
  530. */
  531. if (len < ETHERMINTU) {
  532. if (bp->rp + ETHERMINTU <= bp->lim)
  533. bp->wp = bp->rp + ETHERMINTU;
  534. else
  535. bp->wp = bp->lim;
  536. len = BLEN(bp);
  537. print("txstart: extended short pkt %d -> %d bytes\n",
  538. olen, len);
  539. }
  540. /* set up a descriptor for it */
  541. tdesc = &ctlr->tdba[tdt];
  542. tdesc->addr[0] = PCIWADDR(bp->rp);
  543. tdesc->addr[1] = 0;
  544. tdesc->control = /* Ide| */ Rs|Dext|Ifcs|Teop|DtypeDD|len;
  545. tdesc->status = 0;
  546. ctlr->tb[tdt] = bp;
  547. }
  548. ctlr->tdt = tdt;
  549. csr32w(ctlr, Tdt, tdt);
  550. igbeim(ctlr, Txdw);
  551. }
  552. static Block *
  553. fromringbuf(Ether *ether)
  554. {
  555. RingBuf *tb = &ether->tb[ether->ti];
  556. Block *bp = allocb(tb->len);
  557. memmove(bp->wp, tb->pkt, tb->len);
  558. memmove(bp->wp+Eaddrlen, ether->ea, Eaddrlen);
  559. bp->wp += tb->len;
  560. return bp;
  561. }
  562. static void
  563. igbetransmit(Ether* edev)
  564. {
  565. Block *bp;
  566. Ctlr *ctlr;
  567. Tdesc *tdesc;
  568. RingBuf *tb;
  569. int tdh;
  570. /*
  571. * For now there are no smarts here. Tuning comes later.
  572. */
  573. ctlr = edev->ctlr;
  574. ilock(&ctlr->tdlock);
  575. /*
  576. * Free any completed packets
  577. * - try to get the soft tdh to catch the tdt;
  578. * - if the packet had an underrun bump the threshold
  579. * - the Tu bit doesn't seem to ever be set, perhaps
  580. * because Rs mode is used?
  581. */
  582. tdh = ctlr->tdh;
  583. for(;;){
  584. tdesc = &ctlr->tdba[tdh];
  585. if(!(tdesc->status & Tdd))
  586. break;
  587. if(tdesc->status & Tu){
  588. ctlr->ett++;
  589. csr32w(ctlr, Ett, ctlr->ett);
  590. }
  591. tdesc->status = 0;
  592. if(ctlr->tb[tdh] != nil){
  593. freeb(ctlr->tb[tdh]);
  594. ctlr->tb[tdh] = nil;
  595. }
  596. tdh = NEXT(tdh, Ntdesc);
  597. }
  598. ctlr->tdh = tdh;
  599. /* copy packets from the software RingBuf to the transmission q */
  600. /* from boot ether83815.c */
  601. while((tb = &edev->tb[edev->ti])->owner == Interface){
  602. bp = fromringbuf(edev);
  603. /* put the buffer on the transmit queue */
  604. if(ctlr->bqhead)
  605. ctlr->bqtail->next = bp;
  606. else
  607. ctlr->bqhead = bp;
  608. ctlr->bqtail = bp;
  609. txstart(edev); /* kick transmitter */
  610. tb->owner = Host; /* give descriptor back */
  611. edev->ti = NEXT(edev->ti, edev->ntb);
  612. }
  613. iunlock(&ctlr->tdlock);
  614. }
  615. static void
  616. igbereplenish(Ctlr* ctlr)
  617. {
  618. int rdt;
  619. Block *bp;
  620. Rdesc *rdesc;
  621. rdt = ctlr->rdt;
  622. while(NEXT(rdt, Nrdesc) != ctlr->rdh){
  623. rdesc = &ctlr->rdba[rdt];
  624. if(ctlr->rb[rdt] != nil){
  625. /* nothing to do */
  626. }
  627. else if((bp = iallocb(2048)) != nil){
  628. ctlr->rb[rdt] = bp;
  629. rdesc->addr[0] = PCIWADDR(bp->rp);
  630. rdesc->addr[1] = 0;
  631. }
  632. else
  633. break;
  634. rdesc->status = 0;
  635. rdt = NEXT(rdt, Nrdesc);
  636. }
  637. ctlr->rdt = rdt;
  638. csr32w(ctlr, Rdt, rdt);
  639. }
  640. static void
  641. toringbuf(Ether *ether, Block *bp)
  642. {
  643. RingBuf *rb = &ether->rb[ether->ri];
  644. if (rb->owner == Interface) {
  645. rb->len = BLEN(bp);
  646. memmove(rb->pkt, bp->rp, rb->len);
  647. rb->owner = Host;
  648. ether->ri = NEXT(ether->ri, ether->nrb);
  649. }
  650. /* else no one is expecting packets from the network */
  651. }
  652. static void
  653. igbeinterrupt(Ureg*, void* arg)
  654. {
  655. Block *bp;
  656. Ctlr *ctlr;
  657. Ether *edev;
  658. Rdesc *rdesc;
  659. int icr, im, rdh, txdw = 0;
  660. edev = arg;
  661. ctlr = edev->ctlr;
  662. ilock(&ctlr->imlock);
  663. csr32w(ctlr, Imc, ~0);
  664. im = ctlr->im;
  665. for(icr = csr32r(ctlr, Icr); icr & ctlr->im; icr = csr32r(ctlr, Icr)){
  666. /*
  667. * Link status changed.
  668. */
  669. if(icr & (Rxseq|Lsc)){
  670. /*
  671. * should be more here...
  672. */
  673. }
  674. /*
  675. * Process any received packets.
  676. */
  677. rdh = ctlr->rdh;
  678. for(;;){
  679. rdesc = &ctlr->rdba[rdh];
  680. if(!(rdesc->status & Rdd))
  681. break;
  682. if ((rdesc->status & Reop) && rdesc->errors == 0) {
  683. bp = ctlr->rb[rdh];
  684. ctlr->rb[rdh] = nil;
  685. /*
  686. * it appears that the original 82543 needed
  687. * to have the Ethernet CRC excluded, but that
  688. * the newer chips do not?
  689. */
  690. bp->wp += rdesc->length /* -4 */;
  691. toringbuf(edev, bp);
  692. freeb(bp);
  693. } else if ((rdesc->status & Reop) && rdesc->errors)
  694. print("igbe: input packet error 0x%ux\n",
  695. rdesc->errors);
  696. rdesc->status = 0;
  697. rdh = NEXT(rdh, Nrdesc);
  698. }
  699. ctlr->rdh = rdh;
  700. if(icr & Rxdmt0)
  701. igbereplenish(ctlr);
  702. if(icr & Txdw){
  703. im &= ~Txdw;
  704. txdw++;
  705. }
  706. }
  707. ctlr->im = im;
  708. csr32w(ctlr, Ims, im);
  709. iunlock(&ctlr->imlock);
  710. if(txdw)
  711. igbetransmit(edev);
  712. }
  713. static int
  714. igbeinit(Ether* edev)
  715. {
  716. int csr, i, r, ctrl;
  717. MiiPhy *phy;
  718. Ctlr *ctlr;
  719. ctlr = edev->ctlr;
  720. /*
  721. * Set up the receive addresses.
  722. * There are 16 addresses. The first should be the MAC address.
  723. * The others are cleared and not marked valid (MS bit of Rah).
  724. */
  725. csr = (edev->ea[3]<<24)|(edev->ea[2]<<16)|(edev->ea[1]<<8)|edev->ea[0];
  726. csr32w(ctlr, Ral, csr);
  727. csr = 0x80000000|(edev->ea[5]<<8)|edev->ea[4];
  728. csr32w(ctlr, Rah, csr);
  729. for(i = 1; i < 16; i++){
  730. csr32w(ctlr, Ral+i*8, 0);
  731. csr32w(ctlr, Rah+i*8, 0);
  732. }
  733. /*
  734. * Clear the Multicast Table Array.
  735. * It's a 4096 bit vector accessed as 128 32-bit registers.
  736. */
  737. for(i = 0; i < 128; i++)
  738. csr32w(ctlr, Mta+i*4, 0);
  739. /*
  740. * Receive initialisation.
  741. * Mostly defaults from the datasheet, will
  742. * need some tuning for performance:
  743. * Rctl descriptor mimimum threshold size
  744. * discard pause frames
  745. * strip CRC
  746. * Rdtr interrupt delay
  747. * Rxdctl all the thresholds
  748. */
  749. csr32w(ctlr, Rctl, 0);
  750. /*
  751. * Allocate the descriptor ring and load its
  752. * address and length into the NIC.
  753. */
  754. ctlr->rdba = xspanalloc(Nrdesc*sizeof(Rdesc), 128 /* was 16 */, 0);
  755. csr32w(ctlr, Rdbal, PCIWADDR(ctlr->rdba));
  756. csr32w(ctlr, Rdbah, 0);
  757. csr32w(ctlr, Rdlen, Nrdesc*sizeof(Rdesc));
  758. /*
  759. * Initialise the ring head and tail pointers and
  760. * populate the ring with Blocks.
  761. * The datasheet says the tail pointer is set to beyond the last
  762. * descriptor hardware can process, which implies the initial
  763. * condition is Rdh == Rdt. However, experience shows Rdt must
  764. * always be 'behind' Rdh; the replenish routine ensures this.
  765. */
  766. ctlr->rdh = 0;
  767. csr32w(ctlr, Rdh, ctlr->rdh);
  768. ctlr->rdt = 0;
  769. csr32w(ctlr, Rdt, ctlr->rdt);
  770. ctlr->rb = malloc(sizeof(Block*)*Nrdesc);
  771. igbereplenish(ctlr);
  772. /*
  773. * Set up Rctl but don't enable receiver (yet).
  774. */
  775. csr32w(ctlr, Rdtr, 0);
  776. switch(ctlr->id){
  777. case i82540em:
  778. case i82540eplp:
  779. case i82541gi:
  780. case i82541gi2:
  781. case i82541pi:
  782. case i82546gb:
  783. case i82546eb:
  784. case i82547gi:
  785. csr32w(ctlr, Radv, 64);
  786. break;
  787. }
  788. csr32w(ctlr, Rxdctl, (8<<WthreshSHIFT)|(8<<HthreshSHIFT)|4);
  789. /*
  790. * Enable checksum offload.
  791. */
  792. csr32w(ctlr, Rxcsum, Tuofl|Ipofl|(ETHERHDRSIZE<<PcssSHIFT));
  793. csr32w(ctlr, Rctl, Dpf|Bsize2048|Bam|RdtmsHALF);
  794. igbeim(ctlr, Rxt0|Rxo|Rxdmt0|Rxseq);
  795. /*
  796. * Transmit initialisation.
  797. * Mostly defaults from the datasheet, will
  798. * need some tuning for performance. The normal mode will
  799. * be full-duplex and things to tune for half-duplex are
  800. * Tctl re-transmit on late collision
  801. * Tipg all IPG times
  802. * Tbt burst timer
  803. * Ait adaptive IFS throttle
  804. * and in general
  805. * Txdmac packet prefetching
  806. * Ett transmit early threshold
  807. * Tidv interrupt delay value
  808. * Txdctl all the thresholds
  809. */
  810. csr32w(ctlr, Tctl, (0x0F<<CtSHIFT)|Psp|(66<<ColdSHIFT)); /* Fd */
  811. switch(ctlr->id){
  812. default:
  813. r = 6;
  814. break;
  815. case i82543gc:
  816. case i82544ei:
  817. case i82547ei:
  818. case i82540em:
  819. case i82540eplp:
  820. case i82541gi:
  821. case i82541gi2:
  822. case i82541pi:
  823. case i82546gb:
  824. case i82546eb:
  825. case i82547gi:
  826. r = 8;
  827. break;
  828. }
  829. csr32w(ctlr, Tipg, (6<<20)|(8<<10)|r);
  830. csr32w(ctlr, Ait, 0);
  831. csr32w(ctlr, Txdmac, 0);
  832. csr32w(ctlr, Tidv, 128);
  833. /*
  834. * Allocate the descriptor ring and load its
  835. * address and length into the NIC.
  836. */
  837. ctlr->tdba = xspanalloc(Ntdesc*sizeof(Tdesc), 128 /* was 16 */, 0);
  838. csr32w(ctlr, Tdbal, PCIWADDR(ctlr->tdba));
  839. csr32w(ctlr, Tdbah, 0);
  840. csr32w(ctlr, Tdlen, Ntdesc*sizeof(Tdesc));
  841. /*
  842. * Initialise the ring head and tail pointers.
  843. */
  844. ctlr->tdh = 0;
  845. csr32w(ctlr, Tdh, ctlr->tdh);
  846. ctlr->tdt = 0;
  847. csr32w(ctlr, Tdt, ctlr->tdt);
  848. ctlr->tb = malloc(sizeof(Block*)*Ntdesc);
  849. // ctlr->im |= Txqe|Txdw;
  850. r = (4<<WthreshSHIFT)|(4<<HthreshSHIFT)|(8<<PthreshSHIFT);
  851. switch(ctlr->id){
  852. default:
  853. break;
  854. case i82540em:
  855. case i82540eplp:
  856. case i82547gi:
  857. case i82541pi:
  858. case i82546gb:
  859. case i82546eb:
  860. case i82541gi:
  861. case i82541gi2:
  862. r = csr32r(ctlr, Txdctl);
  863. r &= ~WthreshMASK;
  864. r |= Gran|(4<<WthreshSHIFT);
  865. csr32w(ctlr, Tadv, 64);
  866. break;
  867. }
  868. csr32w(ctlr, Txdctl, r);
  869. r = csr32r(ctlr, Tctl);
  870. r |= Ten;
  871. csr32w(ctlr, Tctl, r);
  872. if(ctlr->mii == nil || ctlr->mii->curphy == nil) {
  873. print("igbe: no mii (yet)\n");
  874. return 0;
  875. }
  876. /* wait for the link to come up */
  877. if (miistatus(ctlr->mii) < 0)
  878. return -1;
  879. print("igbe: phy: ");
  880. phy = ctlr->mii->curphy;
  881. if (phy->fd)
  882. print("full duplex");
  883. else
  884. print("half duplex");
  885. print(", %d Mb/s\n", phy->speed);
  886. /*
  887. * Flow control.
  888. */
  889. ctrl = csr32r(ctlr, Ctrl);
  890. if(phy->rfc)
  891. ctrl |= Rfce;
  892. if(phy->tfc)
  893. ctrl |= Tfce;
  894. csr32w(ctlr, Ctrl, ctrl);
  895. return 0;
  896. }
  897. static int
  898. i82543mdior(Ctlr* ctlr, int n)
  899. {
  900. int ctrl, data, i, r;
  901. /*
  902. * Read n bits from the Management Data I/O Interface.
  903. */
  904. ctrl = csr32r(ctlr, Ctrl);
  905. r = (ctrl & ~Mddo)|Mdco;
  906. data = 0;
  907. for(i = n-1; i >= 0; i--){
  908. if(csr32r(ctlr, Ctrl) & Mdd)
  909. data |= (1<<i);
  910. csr32w(ctlr, Ctrl, Mdc|r);
  911. csr32w(ctlr, Ctrl, r);
  912. }
  913. csr32w(ctlr, Ctrl, ctrl);
  914. return data;
  915. }
  916. static int
  917. i82543mdiow(Ctlr* ctlr, int bits, int n)
  918. {
  919. int ctrl, i, r;
  920. /*
  921. * Write n bits to the Management Data I/O Interface.
  922. */
  923. ctrl = csr32r(ctlr, Ctrl);
  924. r = Mdco|Mddo|ctrl;
  925. for(i = n-1; i >= 0; i--){
  926. if(bits & (1<<i))
  927. r |= Mdd;
  928. else
  929. r &= ~Mdd;
  930. csr32w(ctlr, Ctrl, Mdc|r);
  931. csr32w(ctlr, Ctrl, r);
  932. }
  933. csr32w(ctlr, Ctrl, ctrl);
  934. return 0;
  935. }
  936. static int
  937. i82543miimir(Mii* mii, int pa, int ra)
  938. {
  939. int data;
  940. Ctlr *ctlr;
  941. ctlr = mii->ctlr;
  942. /*
  943. * MII Management Interface Read.
  944. *
  945. * Preamble;
  946. * ST+OP+PHYAD+REGAD;
  947. * TA + 16 data bits.
  948. */
  949. i82543mdiow(ctlr, 0xFFFFFFFF, 32);
  950. i82543mdiow(ctlr, 0x1800|(pa<<5)|ra, 14);
  951. data = i82543mdior(ctlr, 18);
  952. if(data & 0x10000)
  953. return -1;
  954. return data & 0xFFFF;
  955. }
  956. static int
  957. i82543miimiw(Mii* mii, int pa, int ra, int data)
  958. {
  959. Ctlr *ctlr;
  960. ctlr = mii->ctlr;
  961. /*
  962. * MII Management Interface Write.
  963. *
  964. * Preamble;
  965. * ST+OP+PHYAD+REGAD+TA + 16 data bits;
  966. * Z.
  967. */
  968. i82543mdiow(ctlr, 0xFFFFFFFF, 32);
  969. data &= 0xFFFF;
  970. data |= (0x05<<(5+5+2+16))|(pa<<(5+2+16))|(ra<<(2+16))|(0x02<<16);
  971. i82543mdiow(ctlr, data, 32);
  972. return 0;
  973. }
  974. static int
  975. igbemiimir(Mii* mii, int pa, int ra)
  976. {
  977. Ctlr *ctlr;
  978. int mdic, timo;
  979. ctlr = mii->ctlr;
  980. csr32w(ctlr, Mdic, MDIrop|(pa<<MDIpSHIFT)|(ra<<MDIrSHIFT));
  981. mdic = 0;
  982. for(timo = 64; timo; timo--){
  983. mdic = csr32r(ctlr, Mdic);
  984. if(mdic & (MDIe|MDIready))
  985. break;
  986. microdelay(1);
  987. }
  988. if((mdic & (MDIe|MDIready)) == MDIready)
  989. return mdic & 0xFFFF;
  990. return -1;
  991. }
  992. static int
  993. igbemiimiw(Mii* mii, int pa, int ra, int data)
  994. {
  995. Ctlr *ctlr;
  996. int mdic, timo;
  997. ctlr = mii->ctlr;
  998. data &= MDIdMASK;
  999. csr32w(ctlr, Mdic, MDIwop|(pa<<MDIpSHIFT)|(ra<<MDIrSHIFT)|data);
  1000. mdic = 0;
  1001. for(timo = 64; timo; timo--){
  1002. mdic = csr32r(ctlr, Mdic);
  1003. if(mdic & (MDIe|MDIready))
  1004. break;
  1005. microdelay(1);
  1006. }
  1007. if((mdic & (MDIe|MDIready)) == MDIready)
  1008. return 0;
  1009. return -1;
  1010. }
  1011. static int
  1012. igbemii(Ctlr* ctlr)
  1013. {
  1014. MiiPhy *phy = (MiiPhy *)1;
  1015. int ctrl, p, r;
  1016. USED(phy);
  1017. r = csr32r(ctlr, Status);
  1018. if(r & Tbimode)
  1019. return -1;
  1020. if((ctlr->mii = malloc(sizeof(Mii))) == nil)
  1021. return -1;
  1022. ctlr->mii->ctlr = ctlr;
  1023. ctrl = csr32r(ctlr, Ctrl);
  1024. ctrl |= Slu;
  1025. switch(ctlr->id){
  1026. case i82543gc:
  1027. ctrl |= Frcdplx|Frcspd;
  1028. csr32w(ctlr, Ctrl, ctrl);
  1029. /*
  1030. * The reset pin direction (Mdro) should already
  1031. * be set from the EEPROM load.
  1032. * If it's not set this configuration is unexpected
  1033. * so bail.
  1034. */
  1035. r = csr32r(ctlr, Ctrlext);
  1036. if(!(r & Mdro))
  1037. return -1;
  1038. csr32w(ctlr, Ctrlext, r);
  1039. delay(20);
  1040. r = csr32r(ctlr, Ctrlext);
  1041. r &= ~Mdr;
  1042. csr32w(ctlr, Ctrlext, r);
  1043. delay(20);
  1044. r = csr32r(ctlr, Ctrlext);
  1045. r |= Mdr;
  1046. csr32w(ctlr, Ctrlext, r);
  1047. delay(20);
  1048. ctlr->mii->mir = i82543miimir;
  1049. ctlr->mii->miw = i82543miimiw;
  1050. break;
  1051. case i82544ei:
  1052. case i82547ei:
  1053. case i82540em:
  1054. case i82540eplp:
  1055. case i82547gi:
  1056. case i82541gi:
  1057. case i82541gi2:
  1058. case i82541pi:
  1059. case i82546gb:
  1060. case i82546eb:
  1061. ctrl &= ~(Frcdplx|Frcspd);
  1062. csr32w(ctlr, Ctrl, ctrl);
  1063. ctlr->mii->mir = igbemiimir;
  1064. ctlr->mii->miw = igbemiimiw;
  1065. break;
  1066. default:
  1067. free(ctlr->mii);
  1068. ctlr->mii = nil;
  1069. return -1;
  1070. }
  1071. if(mii(ctlr->mii, ~0) == 0 || (phy = ctlr->mii->curphy) == nil){
  1072. if (0)
  1073. print("phy trouble: phy = 0x%lux\n", (ulong)phy);
  1074. free(ctlr->mii);
  1075. ctlr->mii = nil;
  1076. return -1;
  1077. }
  1078. if (Debug)
  1079. print("oui %X phyno %d\n", phy->oui, phy->phyno);
  1080. else
  1081. USED(phy);
  1082. /*
  1083. * 8254X-specific PHY registers not in 802.3:
  1084. * 0x10 PHY specific control
  1085. * 0x14 extended PHY specific control
  1086. * Set appropriate values then reset the PHY to have
  1087. * changes noted.
  1088. */
  1089. switch(ctlr->id){
  1090. case i82547gi:
  1091. case i82541gi:
  1092. case i82541gi2:
  1093. case i82541pi:
  1094. case i82546gb:
  1095. case i82546eb:
  1096. break;
  1097. default:
  1098. r = miimir(ctlr->mii, 16);
  1099. r |= 0x0800; /* assert CRS on Tx */
  1100. r |= 0x0060; /* auto-crossover all speeds */
  1101. r |= 0x0002; /* polarity reversal enabled */
  1102. miimiw(ctlr->mii, 16, r);
  1103. r = miimir(ctlr->mii, 20);
  1104. r |= 0x0070; /* +25MHz clock */
  1105. r &= ~0x0F00;
  1106. r |= 0x0100; /* 1x downshift */
  1107. miimiw(ctlr->mii, 20, r);
  1108. miireset(ctlr->mii);
  1109. break;
  1110. }
  1111. p = 0;
  1112. if(ctlr->txcw & TxcwPs)
  1113. p |= AnaP;
  1114. if(ctlr->txcw & TxcwAs)
  1115. p |= AnaAP;
  1116. miiane(ctlr->mii, ~0, p, ~0);
  1117. return 0;
  1118. }
  1119. static int
  1120. at93c46io(Ctlr* ctlr, char* op, int data)
  1121. {
  1122. char *lp, *p;
  1123. int i, loop, eecd, r;
  1124. eecd = csr32r(ctlr, Eecd);
  1125. r = 0;
  1126. loop = -1;
  1127. lp = nil;
  1128. for(p = op; *p != '\0'; p++){
  1129. switch(*p){
  1130. default:
  1131. return -1;
  1132. case ' ':
  1133. continue;
  1134. case ':': /* start of loop */
  1135. loop = strtol(p+1, &lp, 0)-1;
  1136. lp--;
  1137. if(p == lp)
  1138. loop = 7;
  1139. p = lp;
  1140. continue;
  1141. case ';': /* end of loop */
  1142. if(lp == nil)
  1143. return -1;
  1144. loop--;
  1145. if(loop >= 0)
  1146. p = lp;
  1147. else
  1148. lp = nil;
  1149. continue;
  1150. case 'C': /* assert clock */
  1151. eecd |= Sk;
  1152. break;
  1153. case 'c': /* deassert clock */
  1154. eecd &= ~Sk;
  1155. break;
  1156. case 'D': /* next bit in 'data' byte */
  1157. if(loop < 0)
  1158. return -1;
  1159. if(data & (1<<loop))
  1160. eecd |= Di;
  1161. else
  1162. eecd &= ~Di;
  1163. break;
  1164. case 'O': /* collect data output */
  1165. i = (csr32r(ctlr, Eecd) & Do) != 0;
  1166. if(loop >= 0)
  1167. r |= (i<<loop);
  1168. else
  1169. r = i;
  1170. continue;
  1171. case 'I': /* assert data input */
  1172. eecd |= Di;
  1173. break;
  1174. case 'i': /* deassert data input */
  1175. eecd &= ~Di;
  1176. break;
  1177. case 'S': /* enable chip select */
  1178. eecd |= Cs;
  1179. break;
  1180. case 's': /* disable chip select */
  1181. eecd &= ~Cs;
  1182. break;
  1183. }
  1184. csr32w(ctlr, Eecd, eecd);
  1185. microdelay(50);
  1186. }
  1187. if(loop >= 0)
  1188. return -1;
  1189. return r;
  1190. }
  1191. static int
  1192. at93c46r(Ctlr* ctlr)
  1193. {
  1194. ushort sum;
  1195. char rop[20];
  1196. int addr, areq, bits, data, eecd, i;
  1197. eecd = csr32r(ctlr, Eecd);
  1198. if(eecd & Spi){
  1199. print("igbe: SPI EEPROM access not implemented\n");
  1200. return 0;
  1201. }
  1202. if(eecd & (Eeszaddr|Eesz256))
  1203. bits = 8;
  1204. else
  1205. bits = 6;
  1206. sum = 0;
  1207. switch(ctlr->id){
  1208. default:
  1209. areq = 0;
  1210. break;
  1211. case i82540em:
  1212. case i82540eplp:
  1213. case i82541gi:
  1214. case i82541gi2:
  1215. case i82541pi:
  1216. case i82547gi:
  1217. case i82546gb:
  1218. case i82546eb:
  1219. areq = 1;
  1220. csr32w(ctlr, Eecd, eecd|Areq);
  1221. for(i = 0; i < 1000; i++){
  1222. if((eecd = csr32r(ctlr, Eecd)) & Agnt)
  1223. break;
  1224. microdelay(5);
  1225. }
  1226. if(!(eecd & Agnt)){
  1227. print("igbe: not granted EEPROM access\n");
  1228. goto release;
  1229. }
  1230. break;
  1231. }
  1232. snprint(rop, sizeof(rop), "S :%dDCc;", bits+3);
  1233. for(addr = 0; addr < 0x40; addr++){
  1234. /*
  1235. * Read a word at address 'addr' from the Atmel AT93C46
  1236. * 3-Wire Serial EEPROM or compatible. The EEPROM access is
  1237. * controlled by 4 bits in Eecd. See the AT93C46 datasheet
  1238. * for protocol details.
  1239. */
  1240. if(at93c46io(ctlr, rop, (0x06<<bits)|addr) != 0){
  1241. print("igbe: can't set EEPROM address 0x%2.2X\n", addr);
  1242. goto release;
  1243. }
  1244. data = at93c46io(ctlr, ":16COc;", 0);
  1245. at93c46io(ctlr, "sic", 0);
  1246. ctlr->eeprom[addr] = data;
  1247. sum += data;
  1248. if (Debug) {
  1249. if(addr && ((addr & 0x07) == 0))
  1250. print("\n");
  1251. print(" %4.4ux", data);
  1252. }
  1253. }
  1254. if (Debug)
  1255. print("\n");
  1256. release:
  1257. if(areq)
  1258. csr32w(ctlr, Eecd, eecd & ~Areq);
  1259. return sum;
  1260. }
  1261. static void
  1262. detach(Ctlr *ctlr)
  1263. {
  1264. int r;
  1265. /*
  1266. * Perform a device reset to get the chip back to the
  1267. * power-on state, followed by an EEPROM reset to read
  1268. * the defaults for some internal registers.
  1269. */
  1270. csr32w(ctlr, Imc, ~0);
  1271. csr32w(ctlr, Rctl, 0);
  1272. csr32w(ctlr, Tctl, 0);
  1273. delay(20);
  1274. csr32w(ctlr, Ctrl, Devrst);
  1275. /* apparently needed on multi-GHz processors to avoid infinite loops */
  1276. delay(1);
  1277. while(csr32r(ctlr, Ctrl) & Devrst)
  1278. ;
  1279. csr32w(ctlr, Ctrlext, Eerst | csr32r(ctlr, Ctrlext));
  1280. delay(1);
  1281. while(csr32r(ctlr, Ctrlext) & Eerst)
  1282. ;
  1283. switch(ctlr->id){
  1284. default:
  1285. break;
  1286. case i82540em:
  1287. case i82540eplp:
  1288. case i82541gi:
  1289. case i82541gi2:
  1290. case i82541pi:
  1291. case i82547gi:
  1292. case i82546gb:
  1293. case i82546eb:
  1294. r = csr32r(ctlr, Manc);
  1295. r &= ~Arpen;
  1296. csr32w(ctlr, Manc, r);
  1297. break;
  1298. }
  1299. csr32w(ctlr, Imc, ~0);
  1300. delay(1);
  1301. while(csr32r(ctlr, Icr))
  1302. ;
  1303. }
  1304. static void
  1305. igbedetach(Ether *edev)
  1306. {
  1307. detach(edev->ctlr);
  1308. }
  1309. static void
  1310. igbeshutdown(Ether* ether)
  1311. {
  1312. print("igbeshutdown\n");
  1313. igbedetach(ether);
  1314. }
  1315. static int
  1316. igbereset(Ctlr* ctlr)
  1317. {
  1318. int ctrl, i, pause, r, swdpio, txcw;
  1319. detach(ctlr);
  1320. /*
  1321. * Read the EEPROM, validate the checksum
  1322. * then get the device back to a power-on state.
  1323. */
  1324. r = at93c46r(ctlr);
  1325. /* zero return means no SPI EEPROM access */
  1326. if (r != 0 && r != 0xBABA){
  1327. print("igbe: bad EEPROM checksum - 0x%4.4uX\n", r);
  1328. return -1;
  1329. }
  1330. /*
  1331. * Snarf and set up the receive addresses.
  1332. * There are 16 addresses. The first should be the MAC address.
  1333. * The others are cleared and not marked valid (MS bit of Rah).
  1334. */
  1335. if ((ctlr->id == i82546gb || ctlr->id == i82546eb) &&
  1336. BUSFNO(ctlr->pcidev->tbdf) == 1)
  1337. ctlr->eeprom[Ea+2] += 0x100; /* second interface */
  1338. for(i = Ea; i < Eaddrlen/2; i++){
  1339. ctlr->ra[2*i] = ctlr->eeprom[i];
  1340. ctlr->ra[2*i+1] = ctlr->eeprom[i]>>8;
  1341. }
  1342. /* lan id seems to vary on 82543gc; don't use it */
  1343. if (ctlr->id != i82543gc) {
  1344. r = (csr32r(ctlr, Status) & Lanid) >> 2;
  1345. ctlr->ra[5] += r; /* ea ctlr[1] = ea ctlr[0]+1 */
  1346. }
  1347. r = (ctlr->ra[3]<<24)|(ctlr->ra[2]<<16)|(ctlr->ra[1]<<8)|ctlr->ra[0];
  1348. csr32w(ctlr, Ral, r);
  1349. r = 0x80000000|(ctlr->ra[5]<<8)|ctlr->ra[4];
  1350. csr32w(ctlr, Rah, r);
  1351. for(i = 1; i < 16; i++){
  1352. csr32w(ctlr, Ral+i*8, 0);
  1353. csr32w(ctlr, Rah+i*8, 0);
  1354. }
  1355. /*
  1356. * Clear the Multicast Table Array.
  1357. * It's a 4096 bit vector accessed as 128 32-bit registers.
  1358. */
  1359. memset(ctlr->mta, 0, sizeof(ctlr->mta));
  1360. for(i = 0; i < 128; i++)
  1361. csr32w(ctlr, Mta+i*4, 0);
  1362. /*
  1363. * Just in case the Eerst didn't load the defaults
  1364. * (doesn't appear to fully on the 8243GC), do it manually.
  1365. */
  1366. if (ctlr->id == i82543gc) {
  1367. txcw = csr32r(ctlr, Txcw);
  1368. txcw &= ~(TxcwAne|TxcwPauseMASK|TxcwFd);
  1369. ctrl = csr32r(ctlr, Ctrl);
  1370. ctrl &= ~(SwdpioloMASK|Frcspd|Ilos|Lrst|Fd);
  1371. if(ctlr->eeprom[Icw1] & 0x0400){
  1372. ctrl |= Fd;
  1373. txcw |= TxcwFd;
  1374. }
  1375. if(ctlr->eeprom[Icw1] & 0x0200)
  1376. ctrl |= Lrst;
  1377. if(ctlr->eeprom[Icw1] & 0x0010)
  1378. ctrl |= Ilos;
  1379. if(ctlr->eeprom[Icw1] & 0x0800)
  1380. ctrl |= Frcspd;
  1381. swdpio = (ctlr->eeprom[Icw1] & 0x01E0)>>5;
  1382. ctrl |= swdpio<<SwdpioloSHIFT;
  1383. csr32w(ctlr, Ctrl, ctrl);
  1384. ctrl = csr32r(ctlr, Ctrlext);
  1385. ctrl &= ~(Ips|SwdpiohiMASK);
  1386. swdpio = (ctlr->eeprom[Icw2] & 0x00F0)>>4;
  1387. if(ctlr->eeprom[Icw1] & 0x1000)
  1388. ctrl |= Ips;
  1389. ctrl |= swdpio<<SwdpiohiSHIFT;
  1390. csr32w(ctlr, Ctrlext, ctrl);
  1391. if(ctlr->eeprom[Icw2] & 0x0800)
  1392. txcw |= TxcwAne;
  1393. pause = (ctlr->eeprom[Icw2] & 0x3000)>>12;
  1394. txcw |= pause<<TxcwPauseSHIFT;
  1395. switch(pause){
  1396. default:
  1397. ctlr->fcrtl = 0x00002000;
  1398. ctlr->fcrth = 0x00004000;
  1399. txcw |= TxcwAs|TxcwPs;
  1400. break;
  1401. case 0:
  1402. ctlr->fcrtl = 0x00002000;
  1403. ctlr->fcrth = 0x00004000;
  1404. break;
  1405. case 2:
  1406. ctlr->fcrtl = 0;
  1407. ctlr->fcrth = 0;
  1408. txcw |= TxcwAs;
  1409. break;
  1410. }
  1411. ctlr->txcw = txcw;
  1412. csr32w(ctlr, Txcw, txcw);
  1413. }
  1414. /*
  1415. * Flow control - values from the datasheet.
  1416. */
  1417. csr32w(ctlr, Fcal, 0x00C28001);
  1418. csr32w(ctlr, Fcah, 0x00000100);
  1419. csr32w(ctlr, Fct, 0x00008808);
  1420. csr32w(ctlr, Fcttv, 0x00000100);
  1421. csr32w(ctlr, Fcrtl, ctlr->fcrtl);
  1422. csr32w(ctlr, Fcrth, ctlr->fcrth);
  1423. ilock(&ctlr->imlock);
  1424. csr32w(ctlr, Imc, ~0);
  1425. ctlr->im = 0; /* was = Lsc, which hangs some controllers */
  1426. csr32w(ctlr, Ims, ctlr->im);
  1427. iunlock(&ctlr->imlock);
  1428. if(!(csr32r(ctlr, Status) & Tbimode) && igbemii(ctlr) < 0) {
  1429. print("igbe: igbemii failed\n");
  1430. return -1;
  1431. }
  1432. return 0;
  1433. }
  1434. static void
  1435. igbepci(void)
  1436. {
  1437. int port, cls;
  1438. Pcidev *p;
  1439. Ctlr *ctlr;
  1440. static int first = 1;
  1441. if (first)
  1442. first = 0;
  1443. else
  1444. return;
  1445. p = nil;
  1446. while(p = pcimatch(p, 0, 0)){
  1447. if(p->ccrb != 0x02 || p->ccru != 0)
  1448. continue;
  1449. switch((p->did<<16)|p->vid){
  1450. case i82542:
  1451. default:
  1452. continue;
  1453. case (0x1001<<16)|0x8086: /* Intel PRO/1000 F */
  1454. break;
  1455. case i82543gc:
  1456. case i82544ei:
  1457. case i82547ei:
  1458. case i82540em:
  1459. case i82540eplp:
  1460. case i82547gi:
  1461. case i82541gi:
  1462. case i82541gi2:
  1463. case i82541pi:
  1464. case i82546gb:
  1465. case i82546eb:
  1466. break;
  1467. }
  1468. /* the 82547EI is on the CSA bus, whatever that is */
  1469. port = upamalloc(p->mem[0].bar & ~0x0F, p->mem[0].size, 0);
  1470. if(port == 0){
  1471. print("igbe: can't map %d @ 0x%8.8luX\n",
  1472. p->mem[0].size, p->mem[0].bar);
  1473. continue;
  1474. }
  1475. /*
  1476. * from etherga620.c:
  1477. * If PCI Write-and-Invalidate is enabled set the max write DMA
  1478. * value to the host cache-line size (32 on Pentium or later).
  1479. */
  1480. if(p->pcr & MemWrInv){
  1481. cls = pcicfgr8(p, PciCLS) * 4;
  1482. if(cls != CACHELINESZ)
  1483. pcicfgw8(p, PciCLS, CACHELINESZ/4);
  1484. }
  1485. cls = pcicfgr8(p, PciCLS);
  1486. switch(cls){
  1487. default:
  1488. print("igbe: unexpected CLS - %d bytes\n",
  1489. cls*sizeof(long));
  1490. break;
  1491. case 0x00:
  1492. case 0xFF:
  1493. /* alphapc 164lx returns 0 */
  1494. print("igbe: unusable PciCLS: %d, using %d longs\n",
  1495. cls, CACHELINESZ/sizeof(long));
  1496. cls = CACHELINESZ/sizeof(long);
  1497. pcicfgw8(p, PciCLS, cls);
  1498. break;
  1499. case 0x08:
  1500. case 0x10:
  1501. break;
  1502. }
  1503. ctlr = malloc(sizeof(Ctlr));
  1504. ctlr->port = port;
  1505. ctlr->pcidev = p;
  1506. ctlr->id = (p->did<<16)|p->vid;
  1507. ctlr->cls = cls*4;
  1508. ctlr->nic = KADDR(ctlr->port);
  1509. if (Debug)
  1510. print("status0 %8.8uX\n", csr32r(ctlr, Status));
  1511. if(igbereset(ctlr)){
  1512. free(ctlr);
  1513. continue;
  1514. }
  1515. if (Debug)
  1516. print("status1 %8.8uX\n", csr32r(ctlr, Status));
  1517. pcisetbme(p);
  1518. if(ctlrhead != nil)
  1519. ctlrtail->next = ctlr;
  1520. else
  1521. ctlrhead = ctlr;
  1522. ctlrtail = ctlr;
  1523. }
  1524. }
  1525. int
  1526. igbepnp(Ether* edev)
  1527. {
  1528. int i;
  1529. Ctlr *ctlr;
  1530. uchar ea[Eaddrlen];
  1531. if(ctlrhead == nil)
  1532. igbepci();
  1533. /*
  1534. * Any adapter matches if no edev->port is supplied,
  1535. * otherwise the ports must match.
  1536. */
  1537. for(ctlr = ctlrhead; ctlr != nil; ctlr = ctlr->next){
  1538. if(ctlr->active)
  1539. continue;
  1540. if(edev->port == 0 || edev->port == ctlr->port){
  1541. ctlr->active = 1;
  1542. break;
  1543. }
  1544. }
  1545. if(ctlr == nil)
  1546. return -1;
  1547. edev->ctlr = ctlr;
  1548. edev->port = ctlr->port;
  1549. edev->irq = ctlr->pcidev->intl;
  1550. edev->tbdf = ctlr->pcidev->tbdf;
  1551. // edev->mbps = 1000;
  1552. /*
  1553. * Check if the adapter's station address is to be overridden.
  1554. * If not, read it from the EEPROM and set in ether->ea prior to
  1555. * loading the station address in the hardware.
  1556. */
  1557. memset(ea, 0, Eaddrlen);
  1558. if(memcmp(ea, edev->ea, Eaddrlen) == 0){
  1559. for(i = 0; i < Eaddrlen/2; i++){
  1560. edev->ea[2*i] = ctlr->eeprom[i];
  1561. edev->ea[2*i+1] = ctlr->eeprom[i]>>8;
  1562. }
  1563. }
  1564. igbeinit(edev);
  1565. /*
  1566. * Linkage to the generic ethernet driver.
  1567. */
  1568. edev->attach = igbeattach;
  1569. edev->transmit = igbetransmit;
  1570. edev->interrupt = igbeinterrupt;
  1571. edev->detach = igbedetach;
  1572. return 0;
  1573. }