ether82543gc.c 32 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367
  1. /*
  2. * Intel RS-82543GC Gigabit Ethernet Controller
  3. * as found on the Intel PRO/1000[FT] Server Adapter.
  4. * The older non-[FT] cards use the 82542 (LSI L2A1157) chip; no attempt
  5. * is made to handle the older chip although it should be possible.
  6. * The datasheet is not very clear about running on a big-endian system
  7. * and this driver assumes little-endian throughout.
  8. * To do:
  9. * GMII/MII
  10. * receive tuning
  11. * transmit tuning
  12. */
  13. #include "u.h"
  14. #include "../port/lib.h"
  15. #include "mem.h"
  16. #include "dat.h"
  17. #include "fns.h"
  18. #include "io.h"
  19. #include "../port/error.h"
  20. #include "../port/netif.h"
  21. #include "etherif.h"
  22. enum {
  23. Ctrl = 0x00000000, /* Device Control */
  24. Status = 0x00000008, /* Device Status */
  25. Eecd = 0x00000010, /* EEPROM/Flash Control/Data */
  26. Ctrlext = 0x00000018, /* Extended Device Control */
  27. Mdic = 0x00000020, /* MDI Control */
  28. Fcal = 0x00000028, /* Flow Control Address Low */
  29. Fcah = 0x0000002C, /* Flow Control Address High */
  30. Fct = 0x00000030, /* Flow Control Type */
  31. Icr = 0x000000C0, /* Interrupt Cause Read */
  32. Ics = 0x000000C8, /* Interrupt Cause Set */
  33. Ims = 0x000000D0, /* Interrupt Mask Set/Read */
  34. Imc = 0x000000D8, /* Interrupt mask Clear */
  35. Rctl = 0x00000100, /* Receive Control */
  36. Fcttv = 0x00000170, /* Flow Control Transmit Timer Value */
  37. Txcw = 0x00000178, /* Transmit configuration word reg. */
  38. Rxcw = 0x00000180, /* Receive configuration word reg. */
  39. Tctl = 0x00000400, /* Transmit Control */
  40. Tipg = 0x00000410, /* Transmit IPG */
  41. Tbt = 0x00000448, /* Transmit Burst Timer */
  42. Ait = 0x00000458, /* Adaptive IFS Throttle */
  43. Fcrtl = 0x00002160, /* Flow Control RX Threshold Low */
  44. Fcrth = 0x00002168, /* Flow Control Rx Threshold High */
  45. Rdfh = 0x00002410, /* Receive data fifo head */
  46. Rdft = 0x00002418, /* Receive data fifo tail */
  47. Rdfhs = 0x00002420, /* Receive data fifo head saved */
  48. Rdfts = 0x00002428, /* Receive data fifo tail saved */
  49. Rdfpc = 0x00002430, /* Receive data fifo packet count */
  50. Rdbal = 0x00002800, /* Rdesc Base Address Low */
  51. Rdbah = 0x00002804, /* Rdesc Base Address High */
  52. Rdlen = 0x00002808, /* Receive Descriptor Length */
  53. Rdh = 0x00002810, /* Receive Descriptor Head */
  54. Rdt = 0x00002818, /* Receive Descriptor Tail */
  55. Rdtr = 0x00002820, /* Receive Descriptor Timer Ring */
  56. Rxdctl = 0x00002828, /* Receive Descriptor Control */
  57. Txdmac = 0x00003000, /* Transfer DMA Control */
  58. Ett = 0x00003008, /* Early Transmit Control */
  59. Tdfh = 0x00003410, /* Transmit data fifo head */
  60. Tdft = 0x00003418, /* Transmit data fifo tail */
  61. Tdfhs = 0x00003420, /* Transmit data Fifo Head saved */
  62. Tdfts = 0x00003428, /* Transmit data fifo tail saved */
  63. Tdfpc = 0x00003430, /* Trasnmit data Fifo packet count */
  64. Tdbal = 0x00003800, /* Tdesc Base Address Low */
  65. Tdbah = 0x00003804, /* Tdesc Base Address High */
  66. Tdlen = 0x00003808, /* Transmit Descriptor Length */
  67. Tdh = 0x00003810, /* Transmit Descriptor Head */
  68. Tdt = 0x00003818, /* Transmit Descriptor Tail */
  69. Tidv = 0x00003820, /* Transmit Interrupt Delay Value */
  70. Txdctl = 0x00003828, /* Transmit Descriptor Control */
  71. Statistics = 0x00004000, /* Start of Statistics Area */
  72. Gorcl = 0x88/4, /* Good Octets Received Count */
  73. Gotcl = 0x90/4, /* Good Octets Transmitted Count */
  74. Torl = 0xC0/4, /* Total Octets Received */
  75. Totl = 0xC8/4, /* Total Octets Transmitted */
  76. Nstatistics = 64,
  77. Rxcsum = 0x00005000, /* Receive Checksum Control */
  78. Mta = 0x00005200, /* Multicast Table Array */
  79. Ral = 0x00005400, /* Receive Address Low */
  80. Rah = 0x00005404, /* Receive Address High */
  81. };
  82. enum { /* Ctrl */
  83. Bem = 0x00000002, /* Big Endian Mode */
  84. Prior = 0x00000004, /* Priority on the PCI bus */
  85. Lrst = 0x00000008, /* Link Reset */
  86. Asde = 0x00000020, /* Auto-Speed Detection Enable */
  87. Slu = 0x00000040, /* Set Link Up */
  88. Ilos = 0x00000080, /* Invert Loss of Signal (LOS) */
  89. Frcspd = 0x00000800, /* Force Speed */
  90. Frcdplx = 0x00001000, /* Force Duplex */
  91. Swdpinslo = 0x003C0000, /* Software Defined Pins - lo nibble */
  92. Swdpin0 = 0x00040000,
  93. Swdpin1 = 0x00080000,
  94. Swdpin2 = 0x00100000,
  95. Swdpin3 = 0x00200000,
  96. Swdpiolo = 0x03C00000, /* Software Defined I/O Pins */
  97. Swdpio0 = 0x00400000,
  98. Swdpio1 = 0x00800000,
  99. Swdpio2 = 0x01000000,
  100. Swdpio3 = 0x02000000,
  101. Devrst = 0x04000000, /* Device Reset */
  102. Rfce = 0x08000000, /* Receive Flow Control Enable */
  103. Tfce = 0x10000000, /* Transmit Flow Control Enable */
  104. Vme = 0x40000000, /* VLAN Mode Enable */
  105. };
  106. enum { /* Status */
  107. Lu = 0x00000002, /* Link Up */
  108. Tckok = 0x00000004, /* Transmit clock is running */
  109. Rbcok = 0x00000008, /* Receive clock is running */
  110. Txoff = 0x00000010, /* Transmission Paused */
  111. Tbimode = 0x00000020, /* TBI Mode Indication */
  112. SpeedMASK = 0x000000C0,
  113. Speed10 = 0x00000000, /* 10Mb/s */
  114. Speed100 = 0x00000040, /* 100Mb/s */
  115. Speed1000 = 0x00000080, /* 1000Mb/s */
  116. Mtxckok = 0x00000400, /* MTX clock is running */
  117. Pci66 = 0x00000800, /* PCI Bus speed indication */
  118. Bus64 = 0x00001000, /* PCI Bus width indication */
  119. };
  120. enum { /* Ctrl and Status */
  121. Fd = 0x00000001, /* Full-Duplex */
  122. AsdvMASK = 0x00000300,
  123. Asdv10 = 0x00000000, /* 10Mb/s */
  124. Asdv100 = 0x00000100, /* 100Mb/s */
  125. Asdv1000 = 0x00000200, /* 1000Mb/s */
  126. };
  127. enum { /* Eecd */
  128. Sk = 0x00000001, /* Clock input to the EEPROM */
  129. Cs = 0x00000002, /* Chip Select */
  130. Di = 0x00000004, /* Data Input to the EEPROM */
  131. Do = 0x00000008, /* Data Output from the EEPROM */
  132. };
  133. enum { /* Ctrlext */
  134. Gpien = 0x0000000F, /* General Purpose Interrupt Enables */
  135. Swdpinshi = 0x000000F0, /* Software Defined Pins - hi nibble */
  136. Swdpiohi = 0x00000F00, /* Software Defined Pins - I or O */
  137. Asdchk = 0x00001000, /* ASD Check */
  138. Eerst = 0x00002000, /* EEPROM Reset */
  139. Ips = 0x00004000, /* Invert Power State */
  140. Spdbyps = 0x00008000, /* Speed Select Bypass */
  141. };
  142. enum { /* EEPROM content offsets */
  143. Ea = 0x00, /* Ethernet Address */
  144. Cf = 0x03, /* Compatibility Field */
  145. Pba = 0x08, /* Printed Board Assembly number */
  146. Icw1 = 0x0A, /* Initialization Control Word 1 */
  147. Sid = 0x0B, /* Subsystem ID */
  148. Svid = 0x0C, /* Subsystem Vendor ID */
  149. Did = 0x0D, /* Device ID */
  150. Vid = 0x0E, /* Vendor ID */
  151. Icw2 = 0x0F, /* Initialization Control Word 2 */
  152. };
  153. enum { /* Mdic */
  154. MDIdMASK = 0x0000FFFF, /* Data */
  155. MDIdSHIFT = 0,
  156. MDIrMASK = 0x001F0000, /* PHY Register Address */
  157. MDIrSHIFT = 16,
  158. MDIpMASK = 0x03E00000, /* PHY Address */
  159. MDIpSHIFT = 21,
  160. MDIwop = 0x04000000, /* Write Operation */
  161. MDIrop = 0x08000000, /* Read Operation */
  162. MDIready = 0x10000000, /* End of Transaction */
  163. MDIie = 0x20000000, /* Interrupt Enable */
  164. MDIe = 0x40000000, /* Error */
  165. };
  166. enum { /* Icr, Ics, Ims, Imc */
  167. Txdw = 0x00000001, /* Transmit Descriptor Written Back */
  168. Txqe = 0x00000002, /* Transmit Queue Empty */
  169. Lsc = 0x00000004, /* Link Status Change */
  170. Rxseq = 0x00000008, /* Receive Sequence Error */
  171. Rxdmt0 = 0x00000010, /* Rdesc Minimum Threshold Reached */
  172. Rxo = 0x00000040, /* Receiver Overrun */
  173. Rxt0 = 0x00000080, /* Receiver Timer Interrupt */
  174. Mdac = 0x00000200, /* MDIO Access Completed */
  175. Rxcfg = 0x00000400, /* Receiving /C/ ordered sets */
  176. Gpi0 = 0x00000800, /* General Purpose Interrupts */
  177. Gpi1 = 0x00001000,
  178. Gpi2 = 0x00002000,
  179. Gpi3 = 0x00004000,
  180. };
  181. enum { /* Txcw */
  182. Ane = 0x80000000, /* Autonegotiate enable */
  183. Np = 0x00008000, /* Next Page */
  184. As = 0x00000100, /* Asymmetric Flow control desired */
  185. Ps = 0x00000080, /* Pause supported */
  186. Hd = 0x00000040, /* Half duplex supported */
  187. TxcwFd = 0x00000020, /* Full Duplex supported */
  188. };
  189. enum { /* Rxcw */
  190. Rxword = 0x0000FFFF, /* Data from auto-negotiation process */
  191. Rxnocarrier = 0x04000000, /* Carrier Sense indication */
  192. Rxinvalid = 0x08000000, /* Invalid Symbol during configuration */
  193. Rxchange = 0x10000000, /* Change to the Rxword indication */
  194. Rxconfig = 0x20000000, /* /C/ order set reception indication */
  195. Rxsync = 0x40000000, /* Lost bit synchronization indication */
  196. Anc = 0x80000000, /* Auto Negotiation Complete */
  197. };
  198. enum { /* Rctl */
  199. Rrst = 0x00000001, /* Receiver Software Reset */
  200. Ren = 0x00000002, /* Receiver Enable */
  201. Sbp = 0x00000004, /* Store Bad Packets */
  202. Upe = 0x00000008, /* Unicast Promiscuous Enable */
  203. Mpe = 0x00000010, /* Multicast Promiscuous Enable */
  204. Lpe = 0x00000020, /* Long Packet Reception Enable */
  205. LbmMASK = 0x000000C0, /* Loopback Mode */
  206. LbmOFF = 0x00000000, /* No Loopback */
  207. LbmTBI = 0x00000040, /* TBI Loopback */
  208. LbmMII = 0x00000080, /* GMII/MII Loopback */
  209. LbmXCVR = 0x000000C0, /* Transceiver Loopback */
  210. RdtmsMASK = 0x00000300, /* Rdesc Minimum Threshold Size */
  211. RdtmsHALF = 0x00000000, /* Threshold is 1/2 Rdlen */
  212. RdtmsQUARTER = 0x00000100, /* Threshold is 1/4 Rdlen */
  213. RdtmsEIGHTH = 0x00000200, /* Threshold is 1/8 Rdlen */
  214. MoMASK = 0x00003000, /* Multicast Offset */
  215. Bam = 0x00008000, /* Broadcast Accept Mode */
  216. BsizeMASK = 0x00030000, /* Receive Buffer Size */
  217. Bsize2048 = 0x00000000, /* Bsex = 0 */
  218. Bsize1024 = 0x00010000, /* Bsex = 0 */
  219. Bsize512 = 0x00020000, /* Bsex = 0 */
  220. Bsize256 = 0x00030000, /* Bsex = 0 */
  221. Bsize16384 = 0x00010000, /* Bsex = 1 */
  222. Vfe = 0x00040000, /* VLAN Filter Enable */
  223. Cfien = 0x00080000, /* Canonical Form Indicator Enable */
  224. Cfi = 0x00100000, /* Canonical Form Indicator value */
  225. Dpf = 0x00400000, /* Discard Pause Frames */
  226. Pmcf = 0x00800000, /* Pass MAC Control Frames */
  227. Bsex = 0x02000000, /* Buffer Size Extension */
  228. Secrc = 0x04000000, /* Strip CRC from incoming packet */
  229. };
  230. enum { /* Tctl */
  231. Trst = 0x00000001, /* Transmitter Software Reset */
  232. Ten = 0x00000002, /* Transmit Enable */
  233. Psp = 0x00000008, /* Pad Short Packets */
  234. CtMASK = 0x00000FF0, /* Collision Threshold */
  235. CtSHIFT = 4,
  236. ColdMASK = 0x003FF000, /* Collision Distance */
  237. ColdSHIFT = 12,
  238. Swxoff = 0x00400000, /* Sofware XOFF Transmission */
  239. Pbe = 0x00800000, /* Packet Burst Enable */
  240. Rtlc = 0x01000000, /* Re-transmit on Late Collision */
  241. Nrtu = 0x02000000, /* No Re-transmit on Underrrun */
  242. };
  243. enum { /* [RT]xdctl */
  244. PthreshMASK = 0x0000003F, /* Prefetch Threshold */
  245. PthreshSHIFT = 0,
  246. HthreshMASK = 0x00003F00, /* Host Threshold */
  247. HthreshSHIFT = 8,
  248. WthreshMASK = 0x003F0000, /* Writeback Threshold */
  249. WthreshSHIFT = 16,
  250. Gran = 0x00000000, /* Granularity */
  251. RxGran = 0x01000000, /* Granularity */
  252. };
  253. enum { /* Rxcsum */
  254. PcssMASK = 0x000000FF, /* Packet Checksum Start */
  255. PcssSHIFT = 0,
  256. Ipofl = 0x00000100, /* IP Checksum Off-load Enable */
  257. Tuofl = 0x00000200, /* TCP/UDP Checksum Off-load Enable */
  258. };
  259. enum { /* Receive Delay Timer Ring */
  260. Fpd = 0x80000000, /* Flush partial Descriptor Block */
  261. };
  262. typedef struct Rdesc { /* Receive Descriptor */
  263. uint addr[2];
  264. ushort length;
  265. ushort checksum;
  266. uchar status;
  267. uchar errors;
  268. ushort special;
  269. } Rdesc;
  270. enum { /* Rdesc status */
  271. Rdd = 0x01, /* Descriptor Done */
  272. Reop = 0x02, /* End of Packet */
  273. Ixsm = 0x04, /* Ignore Checksum Indication */
  274. Vp = 0x08, /* Packet is 802.1Q (matched VET) */
  275. Tcpcs = 0x20, /* TCP Checksum Calculated on Packet */
  276. Ipcs = 0x40, /* IP Checksum Calculated on Packet */
  277. Pif = 0x80, /* Passed in-exact filter */
  278. };
  279. enum { /* Rdesc errors */
  280. Ce = 0x01, /* CRC Error or Alignment Error */
  281. Se = 0x02, /* Symbol Error */
  282. Seq = 0x04, /* Sequence Error */
  283. Cxe = 0x10, /* Carrier Extension Error */
  284. Tcpe = 0x20, /* TCP/UDP Checksum Error */
  285. Ipe = 0x40, /* IP Checksum Error */
  286. Rxe = 0x80, /* RX Data Error */
  287. };
  288. typedef struct Tdesc { /* Legacy+Normal Transmit Descriptor */
  289. uint addr[2];
  290. uint control; /* varies with descriptor type */
  291. uint status; /* varies with descriptor type */
  292. } Tdesc;
  293. enum { /* Tdesc control */
  294. CsoMASK = 0x00000F00, /* Checksum Offset */
  295. CsoSHIFT = 16,
  296. Teop = 0x01000000, /* End of Packet */
  297. Ifcs = 0x02000000, /* Insert FCS */
  298. Ic = 0x04000000, /* Insert Checksum (Dext == 0) */
  299. Tse = 0x04000000, /* TCP Segmentaion Enable (Dext == 1) */
  300. Rs = 0x08000000, /* Report Status */
  301. Rps = 0x10000000, /* Report Status Sent */
  302. Dext = 0x20000000, /* Extension (!legacy) */
  303. Vle = 0x40000000, /* VLAN Packet Enable */
  304. Ide = 0x80000000, /* Interrupt Delay Enable */
  305. };
  306. enum { /* Tdesc status */
  307. Tdd = 0x00000001, /* Descriptor Done */
  308. Ec = 0x00000002, /* Excess Collisions */
  309. Lc = 0x00000004, /* Late Collision */
  310. Tu = 0x00000008, /* Transmit Underrun */
  311. CssMASK = 0x0000FF00, /* Checksum Start Field */
  312. CssSHIFT = 8,
  313. };
  314. enum {
  315. Nrdesc = 256, /* multiple of 8 */
  316. Ntdesc = 256, /* multiple of 8 */
  317. Nblocks = 4098, /* total number of blocks to use */
  318. SBLOCKSIZE = 2048,
  319. JBLOCKSIZE = 16384,
  320. NORMAL = 1,
  321. JUMBO = 2,
  322. };
  323. typedef struct Ctlr Ctlr;
  324. typedef struct Ctlr {
  325. int port;
  326. Pcidev* pcidev;
  327. Ctlr* next;
  328. int active;
  329. int started;
  330. int id;
  331. ushort eeprom[0x40];
  332. int* nic;
  333. int im; /* interrupt mask */
  334. Lock slock;
  335. uint statistics[Nstatistics];
  336. Lock rdlock;
  337. Rdesc* rdba; /* receive descriptor base address */
  338. Block* rb[Nrdesc]; /* receive buffers */
  339. int rdh; /* receive descriptor head */
  340. int rdt; /* receive descriptor tail */
  341. Block** freehead; /* points to long or short head */
  342. Lock tdlock;
  343. Tdesc* tdba; /* transmit descriptor base address */
  344. Block* tb[Ntdesc]; /* transmit buffers */
  345. int tdh; /* transmit descriptor head */
  346. int tdt; /* transmit descriptor tail */
  347. int txstalled; /* count of times unable to send */
  348. int txcw;
  349. int fcrtl;
  350. int fcrth;
  351. ulong multimask[128]; /* bit mask for multicast addresses */
  352. } Ctlr;
  353. static Ctlr* gc82543ctlrhead;
  354. static Ctlr* gc82543ctlrtail;
  355. static Lock freelistlock;
  356. static Block* freeShortHead;
  357. static Block* freeJumboHead;
  358. #define csr32r(c, r) (*((c)->nic+((r)/4)))
  359. #define csr32w(c, r, v) (*((c)->nic+((r)/4)) = (v))
  360. static void gc82543watchdog(void* arg);
  361. static void
  362. gc82543attach(Ether* edev)
  363. {
  364. int ctl;
  365. Ctlr *ctlr;
  366. char name[KNAMELEN];
  367. /*
  368. * To do here:
  369. * one-time stuff;
  370. * adjust queue length depending on speed;
  371. * flow control.
  372. * more needed here...
  373. */
  374. ctlr = edev->ctlr;
  375. lock(&ctlr->slock);
  376. if(ctlr->started == 0){
  377. ctlr->started = 1;
  378. snprint(name, KNAMELEN, "#l%d82543", edev->ctlrno);
  379. kproc(name, gc82543watchdog, edev);
  380. }
  381. unlock(&ctlr->slock);
  382. ctl = csr32r(ctlr, Rctl)|Ren;
  383. csr32w(ctlr, Rctl, ctl);
  384. ctl = csr32r(ctlr, Tctl)|Ten;
  385. csr32w(ctlr, Tctl, ctl);
  386. csr32w(ctlr, Ims, ctlr->im);
  387. }
  388. static char* statistics[Nstatistics] = {
  389. "CRC Error",
  390. "Alignment Error",
  391. "Symbol Error",
  392. "RX Error",
  393. "Missed Packets",
  394. "Single Collision",
  395. "Excessive Collisions",
  396. "Multiple Collision",
  397. "Late Collisions",
  398. nil,
  399. "Collision",
  400. "Transmit Underrun",
  401. "Defer",
  402. "Transmit - No CRS",
  403. "Sequence Error",
  404. "Carrier Extension Error",
  405. "Receive Error Length",
  406. nil,
  407. "XON Received",
  408. "XON Transmitted",
  409. "XOFF Received",
  410. "XOFF Transmitted",
  411. "FC Received Unsupported",
  412. "Packets Received (64 Bytes)",
  413. "Packets Received (65-127 Bytes)",
  414. "Packets Received (128-255 Bytes)",
  415. "Packets Received (256-511 Bytes)",
  416. "Packets Received (512-1023 Bytes)",
  417. "Packets Received (1024-1522 Bytes)",
  418. "Good Packets Received",
  419. "Broadcast Packets Received",
  420. "Multicast Packets Received",
  421. "Good Packets Transmitted",
  422. nil,
  423. "Good Octets Received",
  424. nil,
  425. "Good Octets Transmitted",
  426. nil,
  427. nil,
  428. nil,
  429. "Receive No Buffers",
  430. "Receive Undersize",
  431. "Receive Fragment",
  432. "Receive Oversize",
  433. "Receive Jabber",
  434. nil,
  435. nil,
  436. nil,
  437. "Total Octets Received",
  438. nil,
  439. "Total Octets Transmitted",
  440. nil,
  441. "Total Packets Received",
  442. "Total Packets Transmitted",
  443. "Packets Transmitted (64 Bytes)",
  444. "Packets Transmitted (65-127 Bytes)",
  445. "Packets Transmitted (128-255 Bytes)",
  446. "Packets Transmitted (256-511 Bytes)",
  447. "Packets Transmitted (512-1023 Bytes)",
  448. "Packets Transmitted (1024-1522 Bytes)",
  449. "Multicast Packets Transmitted",
  450. "Broadcast Packets Transmitted",
  451. "TCP Segmentation Context Transmitted",
  452. "TCP Segmentation Context Fail",
  453. };
  454. static long
  455. gc82543ifstat(Ether* edev, void* a, long n, ulong offset)
  456. {
  457. Ctlr *ctlr;
  458. char *p, *s;
  459. int i, l, r;
  460. uvlong tuvl, ruvl;
  461. ctlr = edev->ctlr;
  462. lock(&ctlr->slock);
  463. p = malloc(2*READSTR);
  464. l = 0;
  465. for(i = 0; i < Nstatistics; i++){
  466. r = csr32r(ctlr, Statistics+i*4);
  467. if((s = statistics[i]) == nil)
  468. continue;
  469. switch(i){
  470. case Gorcl:
  471. case Gotcl:
  472. case Torl:
  473. case Totl:
  474. ruvl = r;
  475. ruvl += ((uvlong)csr32r(ctlr, Statistics+(i+1)*4))<<32;
  476. tuvl = ruvl;
  477. tuvl += ctlr->statistics[i];
  478. tuvl += ((uvlong)ctlr->statistics[i+1])<<32;
  479. if(tuvl == 0)
  480. continue;
  481. ctlr->statistics[i] = tuvl;
  482. ctlr->statistics[i+1] = tuvl>>32;
  483. l += snprint(p+l, 2*READSTR-l, "%s: %llud %llud\n",
  484. s, tuvl, ruvl);
  485. i++;
  486. break;
  487. default:
  488. ctlr->statistics[i] += r;
  489. if(ctlr->statistics[i] == 0)
  490. continue;
  491. l += snprint(p+l, 2*READSTR-l, "%s: %ud %ud\n",
  492. s, ctlr->statistics[i], r);
  493. break;
  494. }
  495. }
  496. l += snprint(p+l, 2*READSTR-l, "eeprom:");
  497. for(i = 0; i < 0x40; i++){
  498. if(i && ((i & 0x07) == 0))
  499. l += snprint(p+l, 2*READSTR-l, "\n ");
  500. l += snprint(p+l, 2*READSTR-l, " %4.4uX", ctlr->eeprom[i]);
  501. }
  502. snprint(p+l, 2*READSTR-l, "\ntxstalled %d\n", ctlr->txstalled);
  503. n = readstr(offset, a, n, p);
  504. free(p);
  505. unlock(&ctlr->slock);
  506. return n;
  507. }
  508. static void
  509. gc82543promiscuous(void* arg, int on)
  510. {
  511. int rctl;
  512. Ctlr *ctlr;
  513. Ether *edev;
  514. edev = arg;
  515. ctlr = edev->ctlr;
  516. rctl = csr32r(ctlr, Rctl);
  517. rctl &= ~MoMASK; /* make sure we're using bits 47:36 */
  518. if(on)
  519. rctl |= Upe|Mpe;
  520. else
  521. rctl &= ~(Upe|Mpe);
  522. csr32w(ctlr, Rctl, rctl);
  523. }
  524. static void
  525. gc82543multicast(void* arg, uchar* addr, int on)
  526. {
  527. int bit, x;
  528. Ctlr *ctlr;
  529. Ether *edev;
  530. edev = arg;
  531. ctlr = edev->ctlr;
  532. x = addr[5]>>1;
  533. bit = ((addr[5] & 1)<<4)|(addr[4]>>4);
  534. if(on)
  535. ctlr->multimask[x] |= 1<<bit;
  536. else
  537. ctlr->multimask[x] &= ~(1<<bit);
  538. csr32w(ctlr, Mta+x*4, ctlr->multimask[x]);
  539. }
  540. static long
  541. gc82543ctl(Ether* edev, void* buf, long n)
  542. {
  543. Cmdbuf *cb;
  544. Ctlr *ctlr;
  545. int ctrl, i, r;
  546. ctlr = edev->ctlr;
  547. if(ctlr == nil)
  548. error(Enonexist);
  549. lock(&ctlr->slock);
  550. r = 0;
  551. cb = parsecmd(buf, n);
  552. if(cb->nf < 2)
  553. r = -1;
  554. else if(cistrcmp(cb->f[0], "auto") == 0){
  555. ctrl = csr32r(ctlr, Ctrl);
  556. if(cistrcmp(cb->f[1], "off") == 0){
  557. csr32w(ctlr, Txcw, ctlr->txcw & ~Ane);
  558. ctrl |= (Slu|Fd);
  559. if(ctlr->txcw & As)
  560. ctrl |= Rfce;
  561. if(ctlr->txcw & Ps)
  562. ctrl |= Tfce;
  563. csr32w(ctlr, Ctrl, ctrl);
  564. }
  565. else if(cistrcmp(cb->f[1], "on") == 0){
  566. csr32w(ctlr, Txcw, ctlr->txcw);
  567. ctrl &= ~(Slu|Fd);
  568. csr32w(ctlr, Ctrl, ctrl);
  569. }
  570. else
  571. r = -1;
  572. }
  573. else if(cistrcmp(cb->f[0], "clear") == 0){
  574. if(cistrcmp(cb->f[1], "stats") == 0){
  575. for(i = 0; i < Nstatistics; i++)
  576. ctlr->statistics[i] = 0;
  577. }
  578. else
  579. r = -1;
  580. }
  581. else
  582. r = -1;
  583. unlock(&ctlr->slock);
  584. free(cb);
  585. return (r == 0) ? n : r;
  586. }
  587. static void
  588. gc82543txinit(Ctlr* ctlr)
  589. {
  590. int i;
  591. int tdsize;
  592. Block *bp, **bpp;
  593. tdsize = ROUND(Ntdesc*sizeof(Tdesc), 4096);
  594. if(ctlr->tdba == nil)
  595. ctlr->tdba = xspanalloc(tdsize, 32, 0);
  596. for(i = 0; i < Ntdesc; i++){
  597. bpp = &ctlr->tb[i];
  598. bp = *bpp;
  599. if(bp != nil){
  600. *bpp = nil;
  601. freeb(bp);
  602. }
  603. memset(&ctlr->tdba[i], 0, sizeof(Tdesc));
  604. }
  605. csr32w(ctlr, Tdbal, PCIWADDR(ctlr->tdba));
  606. csr32w(ctlr, Tdbah, 0);
  607. csr32w(ctlr, Tdlen, Ntdesc*sizeof(Tdesc));
  608. /*
  609. * set the ring head and tail pointers.
  610. */
  611. ctlr->tdh = 0;
  612. csr32w(ctlr, Tdh, ctlr->tdh);
  613. ctlr->tdt = 0;
  614. csr32w(ctlr, Tdt, ctlr->tdt);
  615. csr32w(ctlr, Tipg, (6<<20)|(8<<10)|6);
  616. csr32w(ctlr, Tidv, 128);
  617. csr32w(ctlr, Ait, 0);
  618. csr32w(ctlr, Txdmac, 0);
  619. csr32w(ctlr, Txdctl, Gran|(4<<WthreshSHIFT)|(1<<HthreshSHIFT)|16);
  620. csr32w(ctlr, Tctl, (0x0F<<CtSHIFT)|Psp|(6<<ColdSHIFT));
  621. ctlr->im |= Txdw;
  622. }
  623. static void
  624. gc82543transmit(Ether* edev)
  625. {
  626. Block *bp, **bpp;
  627. Ctlr *ctlr;
  628. Tdesc *tdesc;
  629. int tdh, tdt, s;
  630. ctlr = edev->ctlr;
  631. ilock(&ctlr->tdlock);
  632. tdh = ctlr->tdh;
  633. for(;;){
  634. /*
  635. * Free any completed packets
  636. */
  637. tdesc = &ctlr->tdba[tdh];
  638. if(!(tdesc->status & Tdd))
  639. break;
  640. memset(tdesc, 0, sizeof(Tdesc));
  641. bpp = &ctlr->tb[tdh];
  642. bp = *bpp;
  643. if(bp != nil){
  644. *bpp = nil;
  645. freeb(bp);
  646. }
  647. tdh = NEXT(tdh, Ntdesc);
  648. }
  649. ctlr->tdh = tdh;
  650. s = csr32r(ctlr, Status);
  651. /*
  652. * Try to fill the ring back up
  653. * but only if link is up and transmission isn't paused.
  654. */
  655. if((s & (Txoff|Lu)) == Lu){
  656. tdt = ctlr->tdt;
  657. while(NEXT(tdt, Ntdesc) != tdh){
  658. if((bp = qget(edev->oq)) == nil)
  659. break;
  660. tdesc = &ctlr->tdba[tdt];
  661. tdesc->addr[0] = PCIWADDR(bp->rp);
  662. tdesc->control = Ide|Rs|Ifcs|Teop|BLEN(bp);
  663. ctlr->tb[tdt] = bp;
  664. tdt = NEXT(tdt, Ntdesc);
  665. }
  666. if(tdt != ctlr->tdt){
  667. ctlr->tdt = tdt;
  668. csr32w(ctlr, Tdt, tdt);
  669. }
  670. }
  671. else
  672. ctlr->txstalled++;
  673. iunlock(&ctlr->tdlock);
  674. }
  675. static Block *
  676. gc82543allocb(Ctlr* ctlr)
  677. {
  678. Block *bp;
  679. ilock(&freelistlock);
  680. if((bp = *(ctlr->freehead)) != nil){
  681. *(ctlr->freehead) = bp->next;
  682. bp->next = nil;
  683. }
  684. iunlock(&freelistlock);
  685. return bp;
  686. }
  687. static void
  688. gc82543replenish(Ctlr* ctlr)
  689. {
  690. int rdt;
  691. Block *bp;
  692. Rdesc *rdesc;
  693. ilock(&ctlr->rdlock);
  694. rdt = ctlr->rdt;
  695. while(NEXT(rdt, Nrdesc) != ctlr->rdh){
  696. rdesc = &ctlr->rdba[rdt];
  697. if(ctlr->rb[rdt] == nil){
  698. bp = gc82543allocb(ctlr);
  699. if(bp == nil){
  700. iprint("no available buffers\n");
  701. break;
  702. }
  703. ctlr->rb[rdt] = bp;
  704. rdesc->addr[0] = PCIWADDR(bp->rp);
  705. rdesc->addr[1] = 0;
  706. }
  707. coherence();
  708. rdesc->status = 0;
  709. rdt = NEXT(rdt, Nrdesc);
  710. }
  711. ctlr->rdt = rdt;
  712. csr32w(ctlr, Rdt, rdt);
  713. iunlock(&ctlr->rdlock);
  714. }
  715. static void
  716. gc82543rxinit(Ctlr* ctlr)
  717. {
  718. int rdsize, i;
  719. csr32w(ctlr, Rctl, Dpf|Bsize2048|Bam|RdtmsHALF);
  720. /*
  721. * Allocate the descriptor ring and load its
  722. * address and length into the NIC.
  723. */
  724. rdsize = ROUND(Nrdesc*sizeof(Rdesc), 4096);
  725. if(ctlr->rdba == nil)
  726. ctlr->rdba = xspanalloc(rdsize, 32, 0);
  727. memset(ctlr->rdba, 0, rdsize);
  728. ctlr->rdh = 0;
  729. ctlr->rdt = 0;
  730. csr32w(ctlr, Rdtr, Fpd|64);
  731. csr32w(ctlr, Rdbal, PCIWADDR(ctlr->rdba));
  732. csr32w(ctlr, Rdbah, 0);
  733. csr32w(ctlr, Rdlen, Nrdesc*sizeof(Rdesc));
  734. csr32w(ctlr, Rdh, 0);
  735. csr32w(ctlr, Rdt, 0);
  736. for(i = 0; i < Nrdesc; i++){
  737. if(ctlr->rb[i] != nil){
  738. freeb(ctlr->rb[i]);
  739. ctlr->rb[i] = nil;
  740. }
  741. }
  742. gc82543replenish(ctlr);
  743. csr32w(ctlr, Rxdctl, RxGran|(8<<WthreshSHIFT)|(4<<HthreshSHIFT)|1);
  744. ctlr->im |= Rxt0|Rxo|Rxdmt0|Rxseq;
  745. }
  746. static void
  747. gc82543recv(Ether* edev, int icr)
  748. {
  749. Block *bp;
  750. Ctlr *ctlr;
  751. Rdesc *rdesc;
  752. int rdh;
  753. ctlr = edev->ctlr;
  754. rdh = ctlr->rdh;
  755. for(;;){
  756. rdesc = &ctlr->rdba[rdh];
  757. if(!(rdesc->status & Rdd))
  758. break;
  759. if((rdesc->status & Reop) && rdesc->errors == 0){
  760. bp = ctlr->rb[rdh];
  761. ctlr->rb[rdh] = nil;
  762. bp->wp += rdesc->length;
  763. bp->next = nil;
  764. etheriq(edev, bp, 1);
  765. }
  766. if(ctlr->rb[rdh] != nil){
  767. /* either non eop packet, or error */
  768. freeb(ctlr->rb[rdh]);
  769. ctlr->rb[rdh] = nil;
  770. }
  771. memset(rdesc, 0, sizeof(Rdesc));
  772. coherence();
  773. rdh = NEXT(rdh, Nrdesc);
  774. }
  775. ctlr->rdh = rdh;
  776. if(icr & Rxdmt0)
  777. gc82543replenish(ctlr);
  778. }
  779. static void
  780. freegc82543short(Block *bp)
  781. {
  782. ilock(&freelistlock);
  783. /* reset read/write pointer to proper positions */
  784. bp->rp = bp->lim - ROUND(SBLOCKSIZE, BLOCKALIGN);
  785. bp->wp = bp->rp;
  786. bp->next = freeShortHead;
  787. freeShortHead = bp;
  788. iunlock(&freelistlock);
  789. }
  790. static void
  791. freegc82532jumbo(Block *bp)
  792. {
  793. ilock(&freelistlock);
  794. /* reset read/write pointer to proper positions */
  795. bp->rp = bp->lim - ROUND(JBLOCKSIZE, BLOCKALIGN);
  796. bp->wp = bp->rp;
  797. bp->next = freeJumboHead;
  798. freeJumboHead = bp;
  799. iunlock(&freelistlock);
  800. }
  801. static void
  802. linkintr(Ctlr* ctlr)
  803. {
  804. int ctrl;
  805. ctrl = csr32r(ctlr, Ctrl);
  806. if((ctrl & Swdpin1) ||
  807. ((csr32r(ctlr, Rxcw) & Rxconfig) && !(csr32r(ctlr, Txcw) & Ane))){
  808. csr32w(ctlr, Txcw, ctlr->txcw);
  809. ctrl &= ~(Slu|Fd|Frcdplx);
  810. csr32w(ctlr, Ctrl, ctrl);
  811. }
  812. }
  813. static void
  814. gc82543interrupt(Ureg*, void* arg)
  815. {
  816. Ctlr *ctlr;
  817. Ether *edev;
  818. int icr;
  819. edev = arg;
  820. ctlr = edev->ctlr;
  821. while((icr = csr32r(ctlr, Icr) & ctlr->im) != 0){
  822. /*
  823. * Link status changed.
  824. */
  825. if(icr & (Lsc|Rxseq))
  826. linkintr(ctlr);
  827. /*
  828. * Process recv buffers.
  829. */
  830. gc82543recv(edev, icr);
  831. /*
  832. * Refill transmit ring and free packets.
  833. */
  834. gc82543transmit(edev);
  835. }
  836. }
  837. static int
  838. gc82543init(Ether* edev)
  839. {
  840. int csr, i;
  841. Block *bp;
  842. Ctlr *ctlr;
  843. ctlr = edev->ctlr;
  844. /*
  845. * Allocate private buffer pool to use for receiving packets.
  846. */
  847. ilock(&freelistlock);
  848. if (ctlr->freehead == nil){
  849. for(i = 0; i < Nblocks; i++){
  850. bp = iallocb(SBLOCKSIZE);
  851. if(bp != nil){
  852. bp->next = freeShortHead;
  853. bp->free = freegc82543short;
  854. freeShortHead = bp;
  855. }
  856. else{
  857. print("82543gc: no memory\n");
  858. break;
  859. }
  860. }
  861. ctlr->freehead = &freeShortHead;
  862. }
  863. iunlock(&freelistlock);
  864. /*
  865. * Set up the receive addresses.
  866. * There are 16 addresses. The first should be the MAC address.
  867. * The others are cleared and not marked valid (MS bit of Rah).
  868. */
  869. csr = (edev->ea[3]<<24)|(edev->ea[2]<<16)|(edev->ea[1]<<8)|edev->ea[0];
  870. csr32w(ctlr, Ral, csr);
  871. csr = 0x80000000|(edev->ea[5]<<8)|edev->ea[4];
  872. csr32w(ctlr, Rah, csr);
  873. for(i = 1; i < 16; i++){
  874. csr32w(ctlr, Ral+i*8, 0);
  875. csr32w(ctlr, Rah+i*8, 0);
  876. }
  877. /*
  878. * Clear the Multicast Table Array.
  879. * It's a 4096 bit vector accessed as 128 32-bit registers.
  880. */
  881. for(i = 0; i < 128; i++)
  882. csr32w(ctlr, Mta+i*4, 0);
  883. gc82543txinit(ctlr);
  884. gc82543rxinit(ctlr);
  885. return 0;
  886. }
  887. static int
  888. at93c46io(Ctlr* ctlr, char* op, int data)
  889. {
  890. char *lp, *p;
  891. int i, loop, eecd, r;
  892. eecd = csr32r(ctlr, Eecd);
  893. r = 0;
  894. loop = -1;
  895. lp = nil;
  896. for(p = op; *p != '\0'; p++){
  897. switch(*p){
  898. default:
  899. return -1;
  900. case ' ':
  901. continue;
  902. case ':': /* start of loop */
  903. if(lp != nil){
  904. if(p != (lp+1) || loop != 7)
  905. return -1;
  906. lp = p;
  907. loop = 15;
  908. continue;
  909. }
  910. lp = p;
  911. loop = 7;
  912. continue;
  913. case ';': /* end of loop */
  914. if(lp == nil)
  915. return -1;
  916. loop--;
  917. if(loop >= 0)
  918. p = lp;
  919. else
  920. lp = nil;
  921. continue;
  922. case 'C': /* assert clock */
  923. eecd |= Sk;
  924. break;
  925. case 'c': /* deassert clock */
  926. eecd &= ~Sk;
  927. break;
  928. case 'D': /* next bit in 'data' byte */
  929. if(loop < 0)
  930. return -1;
  931. if(data & (1<<loop))
  932. eecd |= Di;
  933. else
  934. eecd &= ~Di;
  935. break;
  936. case 'O': /* collect data output */
  937. i = (csr32r(ctlr, Eecd) & Do) != 0;
  938. if(loop >= 0)
  939. r |= (i<<loop);
  940. else
  941. r = i;
  942. continue;
  943. case 'I': /* assert data input */
  944. eecd |= Di;
  945. break;
  946. case 'i': /* deassert data input */
  947. eecd &= ~Di;
  948. break;
  949. case 'S': /* enable chip select */
  950. eecd |= Cs;
  951. break;
  952. case 's': /* disable chip select */
  953. eecd &= ~Cs;
  954. break;
  955. }
  956. csr32w(ctlr, Eecd, eecd);
  957. microdelay(1);
  958. }
  959. if(loop >= 0)
  960. return -1;
  961. return r;
  962. }
  963. static int
  964. at93c46r(Ctlr* ctlr)
  965. {
  966. ushort sum;
  967. int addr, data;
  968. sum = 0;
  969. for(addr = 0; addr < 0x40; addr++){
  970. /*
  971. * Read a word at address 'addr' from the Atmel AT93C46
  972. * 3-Wire Serial EEPROM or compatible. The EEPROM access is
  973. * controlled by 4 bits in Eecd. See the AT93C46 datasheet
  974. * for protocol details.
  975. */
  976. if(at93c46io(ctlr, "S ICc :DCc;", (0x02<<6)|addr) != 0)
  977. break;
  978. data = at93c46io(ctlr, "::COc;", 0);
  979. at93c46io(ctlr, "sic", 0);
  980. ctlr->eeprom[addr] = data;
  981. sum += data;
  982. }
  983. return sum;
  984. }
  985. static void
  986. gc82543detach(Ctlr* ctlr)
  987. {
  988. /*
  989. * Perform a device reset to get the chip back to the
  990. * power-on state, followed by an EEPROM reset to read
  991. * the defaults for some internal registers.
  992. */
  993. csr32w(ctlr, Imc, ~0);
  994. csr32w(ctlr, Rctl, 0);
  995. csr32w(ctlr, Tctl, 0);
  996. delay(10);
  997. csr32w(ctlr, Ctrl, Devrst);
  998. while(csr32r(ctlr, Ctrl) & Devrst)
  999. ;
  1000. csr32w(ctlr, Ctrlext, Eerst);
  1001. while(csr32r(ctlr, Ctrlext) & Eerst)
  1002. ;
  1003. csr32w(ctlr, Imc, ~0);
  1004. while(csr32r(ctlr, Icr))
  1005. ;
  1006. }
  1007. static void
  1008. gc82543checklink(Ctlr* ctlr)
  1009. {
  1010. int ctrl, status, rxcw;
  1011. ctrl = csr32r(ctlr, Ctrl);
  1012. status = csr32r(ctlr, Status);
  1013. rxcw = csr32r(ctlr, Rxcw);
  1014. if(!(status & Lu)){
  1015. if(!(ctrl & (Swdpin1|Slu)) && !(rxcw & Rxconfig)){
  1016. csr32w(ctlr, Txcw, ctlr->txcw & ~Ane);
  1017. ctrl |= (Slu|Fd);
  1018. if(ctlr->txcw & As)
  1019. ctrl |= Rfce;
  1020. if(ctlr->txcw & Ps)
  1021. ctrl |= Tfce;
  1022. csr32w(ctlr, Ctrl, ctrl);
  1023. }
  1024. }
  1025. else if((ctrl & Slu) && (rxcw & Rxconfig)){
  1026. csr32w(ctlr, Txcw, ctlr->txcw);
  1027. ctrl &= ~(Slu|Fd);
  1028. csr32w(ctlr, Ctrl, ctrl);
  1029. }
  1030. }
  1031. static void
  1032. gc82543shutdown(Ether* ether)
  1033. {
  1034. gc82543detach(ether->ctlr);
  1035. }
  1036. static int
  1037. gc82543reset(Ctlr* ctlr)
  1038. {
  1039. int ctl;
  1040. int te;
  1041. /*
  1042. * Read the EEPROM, validate the checksum
  1043. * then get the device back to a power-on state.
  1044. */
  1045. if(at93c46r(ctlr) != 0xBABA)
  1046. return -1;
  1047. gc82543detach(ctlr);
  1048. te = ctlr->eeprom[Icw2];
  1049. if((te & 0x3000) == 0){
  1050. ctlr->fcrtl = 0x00002000;
  1051. ctlr->fcrth = 0x00004000;
  1052. ctlr->txcw = Ane|TxcwFd;
  1053. }
  1054. else if((te & 0x3000) == 0x2000){
  1055. ctlr->fcrtl = 0;
  1056. ctlr->fcrth = 0;
  1057. ctlr->txcw = Ane|TxcwFd|As;
  1058. }
  1059. else{
  1060. ctlr->fcrtl = 0x00002000;
  1061. ctlr->fcrth = 0x00004000;
  1062. ctlr->txcw = Ane|TxcwFd|As|Ps;
  1063. }
  1064. csr32w(ctlr, Txcw, ctlr->txcw);
  1065. csr32w(ctlr, Ctrlext, (te & 0x00f0)<<4);
  1066. csr32w(ctlr, Tctl, csr32r(ctlr, Tctl)|(64<<ColdSHIFT));
  1067. te = ctlr->eeprom[Icw1];
  1068. ctl = ((te & 0x01E0)<<17)|(te & 0x0010)<<3;
  1069. csr32w(ctlr, Ctrl, ctl);
  1070. delay(10);
  1071. /*
  1072. * Flow control - values from the datasheet.
  1073. */
  1074. csr32w(ctlr, Fcal, 0x00C28001);
  1075. csr32w(ctlr, Fcah, 0x00000100);
  1076. csr32w(ctlr, Fct, 0x00008808);
  1077. csr32w(ctlr, Fcttv, 0x00000100);
  1078. csr32w(ctlr, Fcrtl, ctlr->fcrtl);
  1079. csr32w(ctlr, Fcrth, ctlr->fcrth);
  1080. ctlr->im = Lsc;
  1081. gc82543checklink(ctlr);
  1082. return 0;
  1083. }
  1084. static void
  1085. gc82543watchdog(void* arg)
  1086. {
  1087. Ether *edev;
  1088. Ctlr *ctlr;
  1089. edev = arg;
  1090. for(;;){
  1091. tsleep(&up->sleep, return0, 0, 1000);
  1092. ctlr = edev->ctlr;
  1093. if(ctlr == nil){
  1094. print("%s: exiting\n", up->text);
  1095. pexit("disabled", 0);
  1096. }
  1097. gc82543checklink(ctlr);
  1098. gc82543replenish(ctlr);
  1099. }
  1100. }
  1101. static void
  1102. gc82543pci(void)
  1103. {
  1104. int port, cls;
  1105. Pcidev *p;
  1106. Ctlr *ctlr;
  1107. p = nil;
  1108. while(p = pcimatch(p, 0, 0)){
  1109. if(p->ccrb != 0x02 || p->ccru != 0)
  1110. continue;
  1111. switch((p->did<<16)|p->vid){
  1112. case (0x1000<<16)|0x8086: /* LSI L2A1157 (82542) */
  1113. case (0x1004<<16)|0x8086: /* Intel PRO/1000 T */
  1114. case (0x1008<<16)|0x8086: /* Intel PRO/1000 XT */
  1115. default:
  1116. continue;
  1117. case (0x1001<<16)|0x8086: /* Intel PRO/1000 F */
  1118. break;
  1119. }
  1120. port = upamalloc(p->mem[0].bar & ~0x0F, p->mem[0].size, 0);
  1121. if(port == 0){
  1122. print("gc82543: can't map %8.8luX\n", p->mem[0].bar);
  1123. continue;
  1124. }
  1125. cls = pcicfgr8(p, PciCLS);
  1126. switch(cls){
  1127. case 0x00:
  1128. case 0xFF:
  1129. print("82543gc: unusable cache line size\n");
  1130. continue;
  1131. case 0x08:
  1132. break;
  1133. default:
  1134. print("82543gc: cache line size %d, expected 32\n",
  1135. cls*4);
  1136. }
  1137. ctlr = malloc(sizeof(Ctlr));
  1138. ctlr->port = port;
  1139. ctlr->pcidev = p;
  1140. ctlr->id = (p->did<<16)|p->vid;
  1141. ctlr->nic = KADDR(ctlr->port);
  1142. if(gc82543reset(ctlr)){
  1143. free(ctlr);
  1144. continue;
  1145. }
  1146. if(gc82543ctlrhead != nil)
  1147. gc82543ctlrtail->next = ctlr;
  1148. else
  1149. gc82543ctlrhead = ctlr;
  1150. gc82543ctlrtail = ctlr;
  1151. }
  1152. }
  1153. static int
  1154. gc82543pnp(Ether* edev)
  1155. {
  1156. int i;
  1157. Ctlr *ctlr;
  1158. uchar ea[Eaddrlen];
  1159. if(gc82543ctlrhead == nil)
  1160. gc82543pci();
  1161. /*
  1162. * Any adapter matches if no edev->port is supplied,
  1163. * otherwise the ports must match.
  1164. */
  1165. for(ctlr = gc82543ctlrhead; ctlr != nil; ctlr = ctlr->next){
  1166. if(ctlr->active)
  1167. continue;
  1168. if(edev->port == 0 || edev->port == ctlr->port){
  1169. ctlr->active = 1;
  1170. break;
  1171. }
  1172. }
  1173. if(ctlr == nil)
  1174. return -1;
  1175. edev->ctlr = ctlr;
  1176. edev->port = ctlr->port;
  1177. edev->irq = ctlr->pcidev->intl;
  1178. edev->tbdf = ctlr->pcidev->tbdf;
  1179. edev->mbps = 1000;
  1180. /*
  1181. * Check if the adapter's station address is to be overridden.
  1182. * If not, read it from the EEPROM and set in ether->ea prior to
  1183. * loading the station address in the hardware.
  1184. */
  1185. memset(ea, 0, Eaddrlen);
  1186. if(memcmp(ea, edev->ea, Eaddrlen) == 0){
  1187. for(i = Ea; i < Eaddrlen/2; i++){
  1188. edev->ea[2*i] = ctlr->eeprom[i];
  1189. edev->ea[2*i+1] = ctlr->eeprom[i]>>8;
  1190. }
  1191. }
  1192. gc82543init(edev);
  1193. /*
  1194. * Linkage to the generic ethernet driver.
  1195. */
  1196. edev->attach = gc82543attach;
  1197. edev->transmit = gc82543transmit;
  1198. edev->interrupt = gc82543interrupt;
  1199. edev->ifstat = gc82543ifstat;
  1200. edev->shutdown = gc82543shutdown;
  1201. edev->ctl = gc82543ctl;
  1202. edev->arg = edev;
  1203. edev->promiscuous = gc82543promiscuous;
  1204. edev->multicast = gc82543multicast;
  1205. return 0;
  1206. }
  1207. void
  1208. ether82543gclink(void)
  1209. {
  1210. addethercard("82543GC", gc82543pnp);
  1211. }