ether82563.c 32 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394
  1. /*
  2. * Intel 82563 Gigabit Ethernet Controller
  3. */
  4. #include "u.h"
  5. #include "../port/lib.h"
  6. #include "mem.h"
  7. #include "dat.h"
  8. #include "fns.h"
  9. #include "io.h"
  10. #include "../port/error.h"
  11. #include "../port/netif.h"
  12. #include "etherif.h"
  13. /*
  14. * these are in the order they appear in the manual, not numeric order.
  15. * It was too hard to find them in the book. Ref 21489, rev 2.6
  16. */
  17. enum {
  18. /* General */
  19. Ctrl = 0x00000000, /* Device Control */
  20. Status = 0x00000008, /* Device Status */
  21. Eec = 0x00000010, /* EEPROM/Flash Control/Data */
  22. Eerd = 0x00000014, /* EEPROM Read */
  23. Ctrlext = 0x00000018, /* Extended Device Control */
  24. Fla = 0x0000001c, /* Flash Access */
  25. Mdic = 0x00000020, /* MDI Control */
  26. Seresctl = 0x00000024, /* Serdes ana */
  27. Fcal = 0x00000028, /* Flow Control Address Low */
  28. Fcah = 0x0000002C, /* Flow Control Address High */
  29. Fct = 0x00000030, /* Flow Control Type */
  30. Kumctrlsta = 0x00000034, /* Kumeran Controll and Status Register */
  31. Vet = 0x00000038, /* VLAN EtherType */
  32. Fcttv = 0x00000170, /* Flow Control Transmit Timer Value */
  33. Txcw = 0x00000178, /* Transmit Configuration Word */
  34. Rxcw = 0x00000180, /* Receive Configuration Word */
  35. Ledctl = 0x00000E00, /* LED control */
  36. Pba = 0x00001000, /* Packet Buffer Allocation */
  37. /* Interrupt */
  38. Icr = 0x000000C0, /* Interrupt Cause Read */
  39. Ics = 0x000000C8, /* Interrupt Cause Set */
  40. Ims = 0x000000D0, /* Interrupt Mask Set/Read */
  41. Imc = 0x000000D8, /* Interrupt mask Clear */
  42. Iam = 0x000000E0, /* Interrupt acknowledge Auto Mask */
  43. /* Receive */
  44. Rctl = 0x00000100, /* Control */
  45. Ert = 0x00002008, /* Early Receive Threshold (573[EVL] only) */
  46. Fcrtl = 0x00002160, /* Flow Control RX Threshold Low */
  47. Fcrth = 0x00002168, /* Flow Control Rx Threshold High */
  48. Psrctl = 0x00002170, /* Packet Split Receive Control */
  49. Rdbal = 0x00002800, /* Rdesc Base Address Low Queue 0 */
  50. Rdbah = 0x00002804, /* Rdesc Base Address High Queue 0 */
  51. Rdlen = 0x00002808, /* Descriptor Length Queue 0 */
  52. Rdh = 0x00002810, /* Descriptor Head Queue 0 */
  53. Rdt = 0x00002818, /* Descriptor Tail Queue 0 */
  54. Rdtr = 0x00002820, /* Descriptor Timer Ring */
  55. Rxdctl = 0x00002828, /* Descriptor Control */
  56. Radv = 0x0000282C, /* Interrupt Absolute Delay Timer */
  57. Rdbal1 = 0x00002900, /* Rdesc Base Address Low Queue 1 */
  58. Rdbah1 = 0x00002804, /* Rdesc Base Address High Queue 1 */
  59. Rdlen1 = 0x00002908, /* Descriptor Length Queue 1 */
  60. Rdh1 = 0x00002910, /* Descriptor Head Queue 1 */
  61. Rdt1 = 0x00002918, /* Descriptor Tail Queue 1 */
  62. Rxdctl1 = 0x00002928, /* Descriptor Control Queue 1 */
  63. Rsrpd = 0x00002c00, /* Small Packet Detect */
  64. Raid = 0x00002c08, /* ACK interrupt delay */
  65. Cpuvec = 0x00002c10, /* CPU Vector */
  66. Rxcsum = 0x00005000, /* Checksum Control */
  67. Rfctl = 0x00005008, /* Filter Control */
  68. Mta = 0x00005200, /* Multicast Table Array */
  69. Ral = 0x00005400, /* Address Low */
  70. Rah = 0x00005404, /* Address High */
  71. Vfta = 0x00005600, /* VLAN Filter Table Array */
  72. Mrqc = 0x00005818, /* Multiple Receive Queues Command */
  73. Rssim = 0x00005864, /* RSS Interrupt Mask */
  74. Rssir = 0x00005868, /* RSS Interrupt Request */
  75. Reta = 0x00005c00, /* Redirection Table */
  76. Rssrk = 0x00005c80, /* RSS Random Key */
  77. /* Transmit */
  78. Tctl = 0x00000400, /* Control */
  79. Tipg = 0x00000410, /* IPG */
  80. Tdbal = 0x00003800, /* Tdesc Base Address Low */
  81. Tdbah = 0x00003804, /* Tdesc Base Address High */
  82. Tdlen = 0x00003808, /* Descriptor Length */
  83. Tdh = 0x00003810, /* Descriptor Head */
  84. Tdt = 0x00003818, /* Descriptor Tail */
  85. Tidv = 0x00003820, /* Interrupt Delay Value */
  86. Txdctl = 0x00003828, /* Descriptor Control */
  87. Tadv = 0x0000382C, /* Interrupt Absolute Delay Timer */
  88. Tarc0 = 0x00003840, /* Arbitration Counter Queue 0 */
  89. Tdbal1 = 0x00003900, /* Descriptor Base Low Queue 1 */
  90. Tdbah1 = 0x00003904, /* Descriptor Base High Queue 1 */
  91. Tdlen1 = 0x00003908, /* Descriptor Length Queue 1 */
  92. Tdh1 = 0x00003910, /* Descriptor Head Queue 1 */
  93. Tdt1 = 0x00003918, /* Descriptor Tail Queue 1 */
  94. Txdctl1 = 0x00003928, /* Descriptor Control 1 */
  95. Tarc1 = 0x00003940, /* Arbitration Counter Queue 1 */
  96. /* Statistics */
  97. Statistics = 0x00004000, /* Start of Statistics Area */
  98. Gorcl = 0x88/4, /* Good Octets Received Count */
  99. Gotcl = 0x90/4, /* Good Octets Transmitted Count */
  100. Torl = 0xC0/4, /* Total Octets Received */
  101. Totl = 0xC8/4, /* Total Octets Transmitted */
  102. Nstatistics = 64,
  103. };
  104. enum { /* Ctrl */
  105. GIOmd = (1<<2), /* BIO master disable */
  106. Lrst = (1<<3), /* link reset */
  107. Slu = (1<<6), /* Set Link Up */
  108. SspeedMASK = (3<<8), /* Speed Selection */
  109. SspeedSHIFT = 8,
  110. Sspeed10 = 0x00000000, /* 10Mb/s */
  111. Sspeed100 = 0x00000100, /* 100Mb/s */
  112. Sspeed1000 = 0x00000200, /* 1000Mb/s */
  113. Frcspd = (1<<11), /* Force Speed */
  114. Frcdplx = (1<<12), /* Force Duplex */
  115. SwdpinsloMASK = 0x003C0000, /* Software Defined Pins - lo nibble */
  116. SwdpinsloSHIFT = 18,
  117. SwdpioloMASK = 0x03C00000, /* Software Defined Pins - I or O */
  118. SwdpioloSHIFT = 22,
  119. Devrst = (1<<26), /* Device Reset */
  120. Rfce = (1<<27), /* Receive Flow Control Enable */
  121. Tfce = (1<<28), /* Transmit Flow Control Enable */
  122. Vme = (1<<30), /* VLAN Mode Enable */
  123. Phy_rst = (1<<31), /* Phy Reset */
  124. };
  125. enum { /* Status */
  126. Lu = (1<<1), /* Link Up */
  127. Lanid = (3<<2), /* mask for Lan ID.
  128. Txoff = (1<<4), /* Transmission Paused */
  129. Tbimode = (1<<5), /* TBI Mode Indication */
  130. SpeedMASK = 0x000000C0,
  131. Speed10 = 0x00000000, /* 10Mb/s */
  132. Speed100 = 0x00000040, /* 100Mb/s */
  133. Speed1000 = 0x00000080, /* 1000Mb/s */
  134. Phyra = (1<<10), /* PHY Reset Asserted */
  135. GIOme = (1<<19), /* GIO Master Enable Status */
  136. };
  137. enum { /* Ctrl and Status */
  138. Fd = 0x00000001, /* Full-Duplex */
  139. AsdvMASK = 0x00000300,
  140. Asdv10 = 0x00000000, /* 10Mb/s */
  141. Asdv100 = 0x00000100, /* 100Mb/s */
  142. Asdv1000 = 0x00000200, /* 1000Mb/s */
  143. };
  144. enum { /* Eec */
  145. Sk = (1<<0), /* Clock input to the EEPROM */
  146. Cs = (1<<1), /* Chip Select */
  147. Di = (1<<2), /* Data Input to the EEPROM */
  148. Do = (1<<3), /* Data Output from the EEPROM */
  149. Areq = (1<<6), /* EEPROM Access Request */
  150. Agnt = (1<<7), /* EEPROM Access Grant */
  151. };
  152. enum { /* Eerd */
  153. ee_start = (1<<0), /* Start Read */
  154. ee_done = (1<<1), /* Read done */
  155. ee_addr = (0xfff8<<2), /* Read address [15:2] */
  156. ee_data = (0xffff<<16), /* Read Data; Data returned from eeprom/nvm */
  157. };
  158. enum { /* Ctrlext */
  159. Asdchk = (1<<12), /* ASD Check */
  160. Eerst = (1<<13), /* EEPROM Reset */
  161. Spdbyps = (1<<15), /* Speed Select Bypass */
  162. };
  163. enum { /* EEPROM content offsets */
  164. Ea = 0x00, /* Ethernet Address */
  165. Cf = 0x03, /* Compatibility Field */
  166. Icw1 = 0x0A, /* Initialization Control Word 1 */
  167. Sid = 0x0B, /* Subsystem ID */
  168. Svid = 0x0C, /* Subsystem Vendor ID */
  169. Did = 0x0D, /* Device ID */
  170. Vid = 0x0E, /* Vendor ID */
  171. Icw2 = 0x0F, /* Initialization Control Word 2 */
  172. };
  173. enum { /* Mdic */
  174. MDIdMASK = 0x0000FFFF, /* Data */
  175. MDIdSHIFT = 0,
  176. MDIrMASK = 0x001F0000, /* PHY Register Address */
  177. MDIrSHIFT = 16,
  178. MDIpMASK = 0x03E00000, /* PHY Address */
  179. MDIpSHIFT = 21,
  180. MDIwop = 0x04000000, /* Write Operation */
  181. MDIrop = 0x08000000, /* Read Operation */
  182. MDIready = 0x10000000, /* End of Transaction */
  183. MDIie = 0x20000000, /* Interrupt Enable */
  184. MDIe = 0x40000000, /* Error */
  185. };
  186. enum { /* Icr, Ics, Ims, Imc */
  187. Txdw = 0x00000001, /* Transmit Descriptor Written Back */
  188. Txqe = 0x00000002, /* Transmit Queue Empty */
  189. Lsc = 0x00000004, /* Link Status Change */
  190. Rxseq = 0x00000008, /* Receive Sequence Error */
  191. Rxdmt0 = 0x00000010, /* Rdesc Minimum Threshold Reached */
  192. Rxo = 0x00000040, /* Receiver Overrun */
  193. Rxt0 = 0x00000080, /* Receiver Timer Interrupt */
  194. Mdac = 0x00000200, /* MDIO Access Completed */
  195. Rxcfg = 0x00000400, /* Receiving /C/ ordered sets */
  196. Gpi0 = 0x00000800, /* General Purpose Interrupts */
  197. Gpi1 = 0x00001000,
  198. Gpi2 = 0x00002000,
  199. Gpi3 = 0x00004000,
  200. };
  201. enum { /* Txcw */
  202. TxcwFd = 0x00000020, /* Full Duplex */
  203. TxcwHd = 0x00000040, /* Half Duplex */
  204. TxcwPauseMASK = 0x00000180, /* Pause */
  205. TxcwPauseSHIFT = 7,
  206. TxcwPs = (1<<TxcwPauseSHIFT), /* Pause Supported */
  207. TxcwAs = (2<<TxcwPauseSHIFT), /* Asymmetric FC desired */
  208. TxcwRfiMASK = 0x00003000, /* Remote Fault Indication */
  209. TxcwRfiSHIFT = 12,
  210. TxcwNpr = 0x00008000, /* Next Page Request */
  211. TxcwConfig = 0x40000000, /* Transmit COnfig Control */
  212. TxcwAne = 0x80000000, /* Auto-Negotiation Enable */
  213. };
  214. enum { /* Rctl */
  215. Rrst = 0x00000001, /* Receiver Software Reset */
  216. Ren = 0x00000002, /* Receiver Enable */
  217. Sbp = 0x00000004, /* Store Bad Packets */
  218. Upe = 0x00000008, /* Unicast Promiscuous Enable */
  219. Mpe = 0x00000010, /* Multicast Promiscuous Enable */
  220. Lpe = 0x00000020, /* Long Packet Reception Enable */
  221. LbmMASK = 0x000000C0, /* Loopback Mode */
  222. LbmOFF = 0x00000000, /* No Loopback */
  223. LbmTBI = 0x00000040, /* TBI Loopback */
  224. LbmMII = 0x00000080, /* GMII/MII Loopback */
  225. LbmXCVR = 0x000000C0, /* Transceiver Loopback */
  226. RdtmsMASK = 0x00000300, /* Rdesc Minimum Threshold Size */
  227. RdtmsHALF = 0x00000000, /* Threshold is 1/2 Rdlen */
  228. RdtmsQUARTER = 0x00000100, /* Threshold is 1/4 Rdlen */
  229. RdtmsEIGHTH = 0x00000200, /* Threshold is 1/8 Rdlen */
  230. MoMASK = 0x00003000, /* Multicast Offset */
  231. Bam = 0x00008000, /* Broadcast Accept Mode */
  232. BsizeMASK = 0x00030000, /* Receive Buffer Size */
  233. Bsize8192 = 0x00020000, /* Bsex = 1 */
  234. Bsize2048 = 0x00000000,
  235. Bsize1024 = 0x00010000,
  236. Bsize512 = 0x00020000,
  237. Bsize256 = 0x00030000,
  238. Vfe = 0x00040000, /* VLAN Filter Enable */
  239. Cfien = 0x00080000, /* Canonical Form Indicator Enable */
  240. Cfi = 0x00100000, /* Canonical Form Indicator value */
  241. Dpf = 0x00400000, /* Discard Pause Frames */
  242. Pmcf = 0x00800000, /* Pass MAC Control Frames */
  243. Bsex = 0x02000000, /* Buffer Size Extension */
  244. Secrc = 0x04000000, /* Strip CRC from incoming packet */
  245. };
  246. enum { /* Tctl */
  247. Trst = 0x00000001, /* Transmitter Software Reset */
  248. Ten = 0x00000002, /* Transmit Enable */
  249. Psp = 0x00000008, /* Pad Short Packets */
  250. CtMASK = 0x00000FF0, /* Collision Threshold */
  251. CtSHIFT = 4,
  252. ColdMASK = 0x003FF000, /* Collision Distance */
  253. ColdSHIFT = 12,
  254. Swxoff = 0x00400000, /* Sofware XOFF Transmission */
  255. Pbe = 0x00800000, /* Packet Burst Enable */
  256. Rtlc = 0x01000000, /* Re-transmit on Late Collision */
  257. Nrtu = 0x02000000, /* No Re-transmit on Underrrun */
  258. };
  259. enum { /* [RT]xdctl */
  260. PthreshMASK = 0x0000003F, /* Prefetch Threshold */
  261. PthreshSHIFT = 0,
  262. HthreshMASK = 0x00003F00, /* Host Threshold */
  263. HthreshSHIFT = 8,
  264. WthreshMASK = 0x003F0000, /* Writebacj Threshold */
  265. WthreshSHIFT = 16,
  266. Gran = 0x01000000, /* Granularity */
  267. };
  268. enum { /* Rxcsum */
  269. PcssMASK = 0x000000FF, /* Packet Checksum Start */
  270. PcssSHIFT = 0,
  271. Ipofl = 0x00000100, /* IP Checksum Off-load Enable */
  272. Tuofl = 0x00000200, /* TCP/UDP Checksum Off-load Enable */
  273. };
  274. enum { /* Receive Delay Timer Ring */
  275. DelayMASK = 0x0000FFFF, /* delay timer in 1.024nS increments */
  276. DelaySHIFT = 0,
  277. Fpd = 0x80000000, /* Flush partial Descriptor Block */
  278. };
  279. typedef struct Rd { /* Receive Descriptor */
  280. uint addr[2];
  281. ushort length;
  282. ushort checksum;
  283. uchar status;
  284. uchar errors;
  285. ushort special;
  286. } Rd;
  287. enum { /* Rd status */
  288. Rdd = 0x01, /* Descriptor Done */
  289. Reop = 0x02, /* End of Packet */
  290. Ixsm = 0x04, /* Ignore Checksum Indication */
  291. Vp = 0x08, /* Packet is 802.1Q (matched VET) */
  292. Tcpcs = 0x20, /* TCP Checksum Calculated on Packet */
  293. Ipcs = 0x40, /* IP Checksum Calculated on Packet */
  294. Pif = 0x80, /* Passed in-exact filter */
  295. };
  296. enum { /* Rd errors */
  297. Ce = 0x01, /* CRC Error or Alignment Error */
  298. Se = 0x02, /* Symbol Error */
  299. Seq = 0x04, /* Sequence Error */
  300. Cxe = 0x10, /* Carrier Extension Error */
  301. Tcpe = 0x20, /* TCP/UDP Checksum Error */
  302. Ipe = 0x40, /* IP Checksum Error */
  303. Rxe = 0x80, /* RX Data Error */
  304. };
  305. typedef struct Td Td;
  306. struct Td { /* Transmit Descriptor */
  307. uint addr[2]; /* Data */
  308. uint control;
  309. uint status;
  310. };
  311. enum { /* Tdesc control */
  312. LenMASK = 0x000FFFFF, /* Data/Packet Length Field */
  313. LenSHIFT = 0,
  314. DtypeCD = 0x00000000, /* Data Type 'Context Descriptor' */
  315. DtypeDD = 0x00100000, /* Data Type 'Data Descriptor' */
  316. PtypeTCP = 0x01000000, /* TCP/UDP Packet Type (CD) */
  317. Teop = 0x01000000, /* End of Packet (DD) */
  318. PtypeIP = 0x02000000, /* IP Packet Type (CD) */
  319. Ifcs = 0x02000000, /* Insert FCS (DD) */
  320. Tse = 0x04000000, /* TCP Segmentation Enable */
  321. Rs = 0x08000000, /* Report Status */
  322. Rps = 0x10000000, /* Report Status Sent */
  323. Dext = 0x20000000, /* Descriptor Extension */
  324. Vle = 0x40000000, /* VLAN Packet Enable */
  325. Ide = 0x80000000, /* Interrupt Delay Enable */
  326. };
  327. enum { /* Tdesc status */
  328. Tdd = 0x00000001, /* Descriptor Done */
  329. Ec = 0x00000002, /* Excess Collisions */
  330. Lc = 0x00000004, /* Late Collision */
  331. Tu = 0x00000008, /* Transmit Underrun */
  332. CssMASK = 0x0000FF00, /* Checksum Start Field */
  333. CssSHIFT = 8,
  334. };
  335. enum {
  336. Nrd = 256, /* multiple of 8 */
  337. Ntd = 64, /* multiple of 8 */
  338. Nrb = 1024, /* private receive buffers per Ctlr */
  339. Rbsz = 8192,
  340. };
  341. typedef struct Ctlr Ctlr;
  342. struct Ctlr {
  343. int port;
  344. Pcidev* pcidev;
  345. Ctlr* next;
  346. int active;
  347. int started;
  348. int id;
  349. int cls;
  350. ushort eeprom[0x40];
  351. QLock alock; /* attach */
  352. void* alloc; /* receive/transmit descriptors */
  353. int nrd;
  354. int ntd;
  355. int nrb; /* how many this Ctlr has in the pool */
  356. int* nic;
  357. Lock imlock;
  358. int im; /* interrupt mask */
  359. Rendez lrendez;
  360. int lim;
  361. int link;
  362. QLock slock;
  363. uint statistics[Nstatistics];
  364. uint lsleep;
  365. uint lintr;
  366. uint rsleep;
  367. uint rintr;
  368. uint txdw;
  369. uint tintr;
  370. uint ixsm;
  371. uint ipcs;
  372. uint tcpcs;
  373. uchar ra[Eaddrlen]; /* receive address */
  374. ulong mta[128]; /* multicast table array */
  375. Rendez rrendez;
  376. int rim;
  377. int rdfree;
  378. Rd* rdba; /* receive descriptor base address */
  379. Block** rb; /* receive buffers */
  380. int rdh; /* receive descriptor head */
  381. int rdt; /* receive descriptor tail */
  382. int rdtr; /* receive delay timer ring value */
  383. int radv; /* receive interrupt absolute delay timer */
  384. Lock tlock;
  385. int tbusy;
  386. int tdfree;
  387. Td* tdba; /* transmit descriptor base address */
  388. Block** tb; /* transmit buffers */
  389. int tdh; /* transmit descriptor head */
  390. int tdt; /* transmit descriptor tail */
  391. int txcw;
  392. int fcrtl;
  393. int fcrth;
  394. };
  395. enum{
  396. Easize = 6,
  397. Maxmac = 16,
  398. };
  399. #define csr32r(c, r) (*((c)->nic+((r)/4)))
  400. #define csr32w(c, r, v) (*((c)->nic+((r)/4)) = (v))
  401. static Ctlr* i82563ctlrhead;
  402. static Ctlr* i82563ctlrtail;
  403. static Lock i82563rblock; /* free receive Blocks */
  404. static Block* i82563rbpool;
  405. static char* statistics[Nstatistics] = {
  406. "CRC Error",
  407. "Alignment Error",
  408. "Symbol Error",
  409. "RX Error",
  410. "Missed Packets",
  411. "Single Collision",
  412. "Excessive Collisions",
  413. "Multiple Collision",
  414. "Late Collisions",
  415. nil,
  416. "Collision",
  417. "Transmit Underrun",
  418. "Defer",
  419. "Transmit - No CRS",
  420. "Sequence Error",
  421. "Carrier Extension Error",
  422. "Receive Error Length",
  423. nil,
  424. "XON Received",
  425. "XON Transmitted",
  426. "XOFF Received",
  427. "XOFF Transmitted",
  428. "FC Received Unsupported",
  429. "Packets Received (64 Bytes)",
  430. "Packets Received (65-127 Bytes)",
  431. "Packets Received (128-255 Bytes)",
  432. "Packets Received (256-511 Bytes)",
  433. "Packets Received (512-1023 Bytes)",
  434. "Packets Received (1024-1522 Bytes)",
  435. "Good Packets Received",
  436. "Broadcast Packets Received",
  437. "Multicast Packets Received",
  438. "Good Packets Transmitted",
  439. nil,
  440. "Good Octets Received",
  441. nil,
  442. "Good Octets Transmitted",
  443. nil,
  444. nil,
  445. nil,
  446. "Receive No Buffers",
  447. "Receive Undersize",
  448. "Receive Fragment",
  449. "Receive Oversize",
  450. "Receive Jabber",
  451. nil,
  452. nil,
  453. nil,
  454. "Total Octets Received",
  455. nil,
  456. "Total Octets Transmitted",
  457. nil,
  458. "Total Packets Received",
  459. "Total Packets Transmitted",
  460. "Packets Transmitted (64 Bytes)",
  461. "Packets Transmitted (65-127 Bytes)",
  462. "Packets Transmitted (128-255 Bytes)",
  463. "Packets Transmitted (256-511 Bytes)",
  464. "Packets Transmitted (512-1023 Bytes)",
  465. "Packets Transmitted (1024-1522 Bytes)",
  466. "Multicast Packets Transmitted",
  467. "Broadcast Packets Transmitted",
  468. "TCP Segmentation Context Transmitted",
  469. "TCP Segmentation Context Fail",
  470. };
  471. static long
  472. i82563ifstat(Ether* edev, void* a, long n, ulong offset)
  473. {
  474. Ctlr *ctlr;
  475. char *p, *s;
  476. int i, l, r;
  477. uvlong tuvl, ruvl;
  478. ctlr = edev->ctlr;
  479. qlock(&ctlr->slock);
  480. p = malloc(2*READSTR);
  481. l = 0;
  482. for(i = 0; i < Nstatistics; i++){
  483. r = csr32r(ctlr, Statistics+i*4);
  484. if((s = statistics[i]) == nil)
  485. continue;
  486. switch(i){
  487. case Gorcl:
  488. case Gotcl:
  489. case Torl:
  490. case Totl:
  491. ruvl = r;
  492. ruvl += ((uvlong)csr32r(ctlr, Statistics+(i+1)*4))<<32;
  493. tuvl = ruvl;
  494. tuvl += ctlr->statistics[i];
  495. tuvl += ((uvlong)ctlr->statistics[i+1])<<32;
  496. if(tuvl == 0)
  497. continue;
  498. ctlr->statistics[i] = tuvl;
  499. ctlr->statistics[i+1] = tuvl>>32;
  500. l += snprint(p+l, 2*READSTR-l, "%s: %llud %llud\n",
  501. s, tuvl, ruvl);
  502. i++;
  503. break;
  504. default:
  505. ctlr->statistics[i] += r;
  506. if(ctlr->statistics[i] == 0)
  507. continue;
  508. l += snprint(p+l, 2*READSTR-l, "%s: %ud %ud\n",
  509. s, ctlr->statistics[i], r);
  510. break;
  511. }
  512. }
  513. l += snprint(p+l, 2*READSTR-l, "lintr: %ud %ud\n",
  514. ctlr->lintr, ctlr->lsleep);
  515. l += snprint(p+l, 2*READSTR-l, "rintr: %ud %ud\n",
  516. ctlr->rintr, ctlr->rsleep);
  517. l += snprint(p+l, 2*READSTR-l, "tintr: %ud %ud\n",
  518. ctlr->tintr, ctlr->txdw);
  519. l += snprint(p+l, 2*READSTR-l, "ixcs: %ud %ud %ud\n",
  520. ctlr->ixsm, ctlr->ipcs, ctlr->tcpcs);
  521. l += snprint(p+l, 2*READSTR-l, "rdtr: %ud\n", ctlr->rdtr);
  522. l += snprint(p+l, 2*READSTR-l, "radv: %ud\n", ctlr->radv);
  523. l += snprint(p+l, 2*READSTR-l, "Ctrlext: %08x\n", csr32r(ctlr, Ctrlext));
  524. l += snprint(p+l, 2*READSTR-l, "eeprom:");
  525. for(i = 0; i < 0x40; i++){
  526. if(i && ((i & 0x07) == 0))
  527. l += snprint(p+l, 2*READSTR-l, "\n ");
  528. l += snprint(p+l, 2*READSTR-l, " %4.4uX", ctlr->eeprom[i]);
  529. }
  530. snprint(p+l, 2*READSTR-l, "\n");
  531. n = readstr(offset, a, n, p);
  532. free(p);
  533. qunlock(&ctlr->slock);
  534. return n;
  535. }
  536. enum {
  537. CMrdtr,
  538. CMradv,
  539. };
  540. static Cmdtab i82563ctlmsg[] = {
  541. CMrdtr, "rdtr", 2,
  542. CMradv, "radv", 2,
  543. };
  544. static long
  545. i82563ctl(Ether* edev, void* buf, long n)
  546. {
  547. int v;
  548. char *p;
  549. Ctlr *ctlr;
  550. Cmdbuf *cb;
  551. Cmdtab *ct;
  552. if((ctlr = edev->ctlr) == nil)
  553. error(Enonexist);
  554. cb = parsecmd(buf, n);
  555. if(waserror()){
  556. free(cb);
  557. nexterror();
  558. }
  559. ct = lookupcmd(cb, i82563ctlmsg, nelem(i82563ctlmsg));
  560. switch(ct->index){
  561. case CMrdtr:
  562. v = strtol(cb->f[1], &p, 0);
  563. if(v < 0 || p == cb->f[1] || v > 0xFFFF)
  564. error(Ebadarg);
  565. ctlr->rdtr = v;
  566. csr32w(ctlr, Rdtr, Fpd|v);
  567. break;
  568. case CMradv:
  569. v = strtol(cb->f[1], &p, 0);
  570. if(v < 0 || p == cb->f[1] || v > 0xFFFF)
  571. error(Ebadarg);
  572. ctlr->radv = v;
  573. csr32w(ctlr, Radv, v);
  574. }
  575. free(cb);
  576. poperror();
  577. return n;
  578. }
  579. static void
  580. i82563promiscuous(void* arg, int on)
  581. {
  582. int rctl;
  583. Ctlr *ctlr;
  584. Ether *edev;
  585. edev = arg;
  586. ctlr = edev->ctlr;
  587. rctl = csr32r(ctlr, Rctl);
  588. rctl &= ~MoMASK;
  589. if(on)
  590. rctl |= Upe|Mpe;
  591. else
  592. rctl &= ~(Upe|Mpe);
  593. csr32w(ctlr, Rctl, rctl);
  594. }
  595. static void
  596. i82563multicast(void* arg, uchar* addr, int on)
  597. {
  598. int bit, x;
  599. Ctlr *ctlr;
  600. Ether *edev;
  601. edev = arg;
  602. ctlr = edev->ctlr;
  603. x = addr[5]>>1;
  604. bit = ((addr[5] & 1)<<4)|(addr[4]>>4);
  605. if(on)
  606. ctlr->mta[x] |= 1<<bit;
  607. else
  608. ctlr->mta[x] &= ~(1<<bit);
  609. csr32w(ctlr, Mta+x*4, ctlr->mta[x]);
  610. }
  611. static Block*
  612. i82563rballoc(void)
  613. {
  614. Block *bp;
  615. ilock(&i82563rblock);
  616. if((bp = i82563rbpool) != nil){
  617. i82563rbpool = bp->next;
  618. bp->next = nil;
  619. }
  620. iunlock(&i82563rblock);
  621. return bp;
  622. }
  623. static void
  624. i82563rbfree(Block* bp)
  625. {
  626. bp->rp = bp->lim - Rbsz;
  627. bp->wp = bp->rp;
  628. ilock(&i82563rblock);
  629. bp->next = i82563rbpool;
  630. i82563rbpool = bp;
  631. iunlock(&i82563rblock);
  632. }
  633. static void
  634. i82563im(Ctlr* ctlr, int im)
  635. {
  636. ilock(&ctlr->imlock);
  637. ctlr->im |= im;
  638. csr32w(ctlr, Ims, ctlr->im);
  639. iunlock(&ctlr->imlock);
  640. }
  641. static void
  642. i82563txinit(Ctlr* ctlr)
  643. {
  644. int i, r;
  645. Block *bp;
  646. csr32w(ctlr, Tctl, (0x0F<<CtSHIFT)|Psp|(66<<ColdSHIFT));
  647. csr32w(ctlr, Tipg, (6<<20)|(8<<10)|8);
  648. csr32w(ctlr, Tdbal, PCIWADDR(ctlr->tdba));
  649. csr32w(ctlr, Tdbah, 0);
  650. csr32w(ctlr, Tdlen, ctlr->ntd*sizeof(Td));
  651. ctlr->tdh = PREV(0, ctlr->ntd);
  652. csr32w(ctlr, Tdh, 0);
  653. ctlr->tdt = 0;
  654. csr32w(ctlr, Tdt, 0);
  655. for(i = 0; i < ctlr->ntd; i++){
  656. if((bp = ctlr->tb[i]) != nil){
  657. ctlr->tb[i] = nil;
  658. freeb(bp);
  659. }
  660. memset(&ctlr->tdba[i], 0, sizeof(Td));
  661. }
  662. ctlr->tdfree = ctlr->ntd;
  663. csr32w(ctlr, Tidv, 128);
  664. r = csr32r(ctlr, Txdctl);
  665. r &= ~WthreshMASK;
  666. r |= Gran|(4<<WthreshSHIFT);
  667. csr32w(ctlr, Tadv, 64);
  668. csr32w(ctlr, Txdctl, r);
  669. r = csr32r(ctlr, Tctl);
  670. r |= Ten;
  671. csr32w(ctlr, Tctl, r);
  672. }
  673. static void
  674. i82563transmit(Ether* edev)
  675. {
  676. Td *td;
  677. Block *bp;
  678. Ctlr *ctlr;
  679. int tdh, tdt, ctdh;
  680. ctlr = edev->ctlr;
  681. ilock(&ctlr->tlock);
  682. /*
  683. * Free any completed packets
  684. */
  685. tdh = ctlr->tdh;
  686. ctdh = csr32r(ctlr, Tdh);
  687. while(NEXT(tdh, ctlr->ntd) != ctdh){
  688. if((bp = ctlr->tb[tdh]) != nil){
  689. ctlr->tb[tdh] = nil;
  690. freeb(bp);
  691. }
  692. memset(&ctlr->tdba[tdh], 0, sizeof(Td));
  693. tdh = NEXT(tdh, ctlr->ntd);
  694. }
  695. ctlr->tdh = tdh;
  696. /*
  697. * Try to fill the ring back up.
  698. */
  699. tdt = ctlr->tdt;
  700. while(NEXT(tdt, ctlr->ntd) != tdh){
  701. if((bp = qget(edev->oq)) == nil)
  702. break;
  703. td = &ctlr->tdba[tdt];
  704. td->addr[0] = PCIWADDR(bp->rp);
  705. td->control = ((BLEN(bp) & LenMASK)<<LenSHIFT);
  706. td->control |= Ifcs|Teop|DtypeDD;
  707. ctlr->tb[tdt] = bp;
  708. tdt = NEXT(tdt, ctlr->ntd);
  709. ctlr->tdt = tdt;
  710. if(NEXT(tdt, ctlr->ntd) == tdh){
  711. td->control |= Rs;
  712. ctlr->txdw++;
  713. i82563im(ctlr, Txdw);
  714. break;
  715. }
  716. }
  717. csr32w(ctlr, Tdt, tdt);
  718. iunlock(&ctlr->tlock);
  719. }
  720. static void
  721. i82563replenish(Ctlr* ctlr)
  722. {
  723. Rd *rd;
  724. int rdt;
  725. Block *bp;
  726. rdt = ctlr->rdt;
  727. while(NEXT(rdt, ctlr->nrd) != ctlr->rdh){
  728. rd = &ctlr->rdba[rdt];
  729. if(ctlr->rb[rdt] == nil){
  730. bp = i82563rballoc();
  731. if(bp == nil){
  732. iprint("no available buffers\n");
  733. break;
  734. }
  735. ctlr->rb[rdt] = bp;
  736. rd->addr[0] = PCIWADDR(bp->rp);
  737. rd->addr[1] = 0;
  738. }
  739. rd->status = 0;
  740. rdt = NEXT(rdt, ctlr->nrd);
  741. ctlr->rdfree++;
  742. }
  743. ctlr->rdt = rdt;
  744. csr32w(ctlr, Rdt, rdt);
  745. }
  746. static void
  747. i82563rxinit(Ctlr* ctlr)
  748. {
  749. int i;
  750. Block *bp;
  751. // csr32w(ctlr, Rctl, Dpf|Bsize2048|Bam|RdtmsHALF);
  752. // csr32w(ctlr, Rctl, Lpe|Dpf|Bsize16384|Bam|RdtmsHALF|Bsex|Secrc);
  753. csr32w(ctlr, Rctl, Lpe|Dpf|Bsize8192|Bam|RdtmsHALF|Bsex|Secrc);
  754. csr32w(ctlr, Rdbal, PCIWADDR(ctlr->rdba));
  755. csr32w(ctlr, Rdbah, 0);
  756. csr32w(ctlr, Rdlen, ctlr->nrd*sizeof(Rd));
  757. ctlr->rdh = 0;
  758. csr32w(ctlr, Rdh, 0);
  759. ctlr->rdt = 0;
  760. csr32w(ctlr, Rdt, 0);
  761. ctlr->rdtr = 0;
  762. ctlr->radv = 0;
  763. csr32w(ctlr, Rdtr, Fpd|0);
  764. csr32w(ctlr, Radv, 0);
  765. for(i = 0; i < ctlr->nrd; i++){
  766. if((bp = ctlr->rb[i]) != nil){
  767. ctlr->rb[i] = nil;
  768. freeb(bp);
  769. }
  770. }
  771. i82563replenish(ctlr);
  772. csr32w(ctlr, Radv, 64);
  773. // csr32w(ctlr, Rxdctl, (8<<WthreshSHIFT)|(8<<HthreshSHIFT)|4);
  774. // csr32w(ctlr, Rxdctl, (0<<WthreshSHIFT)|(0<<HthreshSHIFT)|0);
  775. csr32w(ctlr, Rxdctl, (1<<16)|(1<<24));
  776. /*
  777. * Enable checksum offload.
  778. */
  779. csr32w(ctlr, Rxcsum, Tuofl|Ipofl|(ETHERHDRSIZE<<PcssSHIFT));
  780. }
  781. static void
  782. i82563rcv(Ether *edev)
  783. {
  784. Rd *rd;
  785. Block *bp;
  786. int rdh;
  787. Ctlr *ctlr;
  788. ctlr = edev->ctlr;
  789. rdh = ctlr->rdh;
  790. for(;;){
  791. rd = &ctlr->rdba[rdh];
  792. if(!(rd->status & Rdd))
  793. break;
  794. /*
  795. * Accept eop packets with no errors.
  796. * With no errors and the Ixsm bit set,
  797. * the descriptor status Tpcs and Ipcs bits give
  798. * an indication of whether the checksums were
  799. * calculated and valid.
  800. */
  801. if (bp = ctlr->rb[rdh]) {
  802. if((rd->status & Reop) && rd->errors == 0){
  803. bp->wp += rd->length;
  804. bp->next = nil;
  805. if(!(rd->status & Ixsm)){
  806. ctlr->ixsm++;
  807. if(rd->status & Ipcs){
  808. /*
  809. * IP checksum calculated
  810. * (and valid as errors == 0).
  811. */
  812. ctlr->ipcs++;
  813. bp->flag |= Bipck;
  814. }
  815. if(rd->status & Tcpcs){
  816. /*
  817. * TCP/UDP checksum calculated
  818. * (and valid as errors == 0).
  819. */
  820. ctlr->tcpcs++;
  821. bp->flag |= Btcpck|Budpck;
  822. }
  823. bp->checksum = rd->checksum;
  824. bp->flag |= Bpktck;
  825. }
  826. etheriq(edev, bp, 1);
  827. } else
  828. freeb(bp);
  829. ctlr->rb[rdh] = nil;
  830. }
  831. memset(rd, 0, sizeof(Rd));
  832. ctlr->rdfree--;
  833. ctlr->rdh = rdh = NEXT(rdh, ctlr->nrd);
  834. coherence();
  835. if(ctlr->rdfree < (ctlr->nrd/4)*3 || (ctlr->rim & Rxdmt0))
  836. i82563replenish(ctlr);
  837. }
  838. }
  839. static int
  840. i82563rim(void* ctlr)
  841. {
  842. return ((Ctlr*)ctlr)->rim != 0;
  843. }
  844. static void
  845. i82563rproc(void* arg)
  846. {
  847. Rd *rd;
  848. Block *bp;
  849. Ctlr *ctlr;
  850. int r, rdh, rim;
  851. Ether *edev;
  852. edev = arg;
  853. ctlr = edev->ctlr;
  854. i82563rxinit(ctlr);
  855. r = csr32r(ctlr, Rctl);
  856. r |= Ren;
  857. csr32w(ctlr, Rctl, r);
  858. for(;;){
  859. i82563im(ctlr, Rxt0|Rxo|Rxdmt0|Rxseq);
  860. ctlr->rsleep++;
  861. coherence();
  862. sleep(&ctlr->rrendez, i82563rim, ctlr);
  863. rdh = ctlr->rdh;
  864. for(;;){
  865. rd = &ctlr->rdba[rdh];
  866. rim = ctlr->rim;
  867. ctlr->rim = 0;
  868. if(!(rd->status & Rdd))
  869. break;
  870. /*
  871. * Accept eop packets with no errors.
  872. * With no errors and the Ixsm bit set,
  873. * the descriptor status Tpcs and Ipcs bits give
  874. * an indication of whether the checksums were
  875. * calculated and valid.
  876. */
  877. if (bp = ctlr->rb[rdh]) {
  878. if((rd->status & Reop) && rd->errors == 0){
  879. bp->wp += rd->length;
  880. bp->next = nil;
  881. if(!(rd->status & Ixsm)){
  882. ctlr->ixsm++;
  883. if(rd->status & Ipcs){
  884. /*
  885. * IP checksum calculated
  886. * (and valid as errors == 0).
  887. */
  888. ctlr->ipcs++;
  889. bp->flag |= Bipck;
  890. }
  891. if(rd->status & Tcpcs){
  892. /*
  893. * TCP/UDP checksum calculated
  894. * (and valid as errors == 0).
  895. */
  896. ctlr->tcpcs++;
  897. bp->flag |= Btcpck|Budpck;
  898. }
  899. bp->checksum = rd->checksum;
  900. bp->flag |= Bpktck;
  901. }
  902. etheriq(edev, bp, 1);
  903. } else
  904. freeb(bp);
  905. ctlr->rb[rdh] = nil;
  906. }
  907. memset(rd, 0, sizeof(Rd));
  908. ctlr->rdfree--;
  909. ctlr->rdh = rdh = NEXT(rdh, ctlr->nrd);
  910. coherence();
  911. if(ctlr->rdfree < (ctlr->nrd/4)*3 || (rim & Rxdmt0))
  912. i82563replenish(ctlr);
  913. }
  914. }
  915. }
  916. static void
  917. i82563attach(Ether* edev)
  918. {
  919. Block *bp, *fbp;
  920. Ctlr *ctlr;
  921. char name[KNAMELEN];
  922. ctlr = edev->ctlr;
  923. qlock(&ctlr->alock);
  924. if(ctlr->alloc != nil){
  925. qunlock(&ctlr->alock);
  926. return;
  927. }
  928. ctlr->nrd = ROUND(Nrd, 8);
  929. ctlr->ntd = ROUND(Ntd, 8);
  930. ctlr->alloc = malloc(ctlr->nrd*sizeof(Rd)+ctlr->ntd*sizeof(Td) + 255);
  931. if(ctlr->alloc == nil){
  932. qunlock(&ctlr->alock);
  933. return;
  934. }
  935. ctlr->rdba = (Rd*)ROUNDUP((ulong)ctlr->alloc, 256);
  936. ctlr->tdba = (Td*)(ctlr->rdba+ctlr->nrd);
  937. ctlr->rb = malloc(ctlr->nrd*sizeof(Block*));
  938. ctlr->tb = malloc(ctlr->ntd*sizeof(Block*));
  939. if(waserror()){
  940. while(ctlr->nrb > 0){
  941. bp = i82563rballoc();
  942. bp->free = nil;
  943. freeb(bp);
  944. ctlr->nrb--;
  945. }
  946. free(ctlr->tb);
  947. ctlr->tb = nil;
  948. free(ctlr->rb);
  949. ctlr->rb = nil;
  950. free(ctlr->alloc);
  951. ctlr->alloc = nil;
  952. qunlock(&ctlr->alock);
  953. nexterror();
  954. }
  955. fbp = nil;
  956. for(ctlr->nrb = 0; ctlr->nrb < Nrb; ){
  957. if((bp = allocb(Rbsz)) == nil)
  958. break;
  959. if (((ulong)bp->base ^ (ulong)bp->lim) & ~0xffff) {
  960. bp->next = fbp;
  961. fbp = bp;
  962. continue;
  963. }
  964. bp->free = i82563rbfree;
  965. freeb(bp);
  966. ctlr->nrb++;
  967. }
  968. freeblist(fbp);
  969. snprint(name, KNAMELEN, "#l%drproc", edev->ctlrno);
  970. kproc(name, i82563rproc, edev);
  971. i82563txinit(ctlr);
  972. qunlock(&ctlr->alock);
  973. poperror();
  974. }
  975. static void
  976. i82563interrupt(Ureg*, void* arg)
  977. {
  978. Ctlr *ctlr;
  979. Ether *edev;
  980. int icr, im, txdw;
  981. edev = arg;
  982. ctlr = edev->ctlr;
  983. ilock(&ctlr->imlock);
  984. csr32w(ctlr, Imc, ~0);
  985. im = ctlr->im;
  986. txdw = 0;
  987. while(icr = csr32r(ctlr, Icr) & ctlr->im){
  988. if(icr & Lsc){
  989. im &= ~Lsc;
  990. ctlr->lim = icr & Lsc;
  991. wakeup(&ctlr->lrendez);
  992. ctlr->lintr++;
  993. }
  994. if(icr & (Rxt0|Rxo|Rxdmt0|Rxseq)){
  995. ctlr->rim = icr & (Rxt0|Rxo|Rxdmt0|Rxseq);
  996. im &= ~(Rxt0|Rxo|Rxdmt0|Rxseq);
  997. wakeup(&ctlr->rrendez);
  998. // i82563rcv(edev);
  999. ctlr->rintr++;
  1000. }
  1001. if(icr & Txdw){
  1002. im &= ~Txdw;
  1003. txdw++;
  1004. ctlr->tintr++;
  1005. }
  1006. }
  1007. ctlr->im = im;
  1008. csr32w(ctlr, Ims, im);
  1009. iunlock(&ctlr->imlock);
  1010. if(txdw)
  1011. i82563transmit(edev);
  1012. }
  1013. static int
  1014. i82563detach(Ctlr* ctlr)
  1015. {
  1016. int r, timeo;
  1017. /*
  1018. * Perform a device reset to get the chip back to the
  1019. * power-on state, followed by an EEPROM reset to read
  1020. * the defaults for some internal registers.
  1021. */
  1022. csr32w(ctlr, Imc, ~0);
  1023. csr32w(ctlr, Rctl, 0);
  1024. csr32w(ctlr, Tctl, 0);
  1025. delay(10);
  1026. csr32w(ctlr, Ctrl, Devrst);
  1027. delay(1);
  1028. for(timeo = 0; timeo < 1000; timeo++){
  1029. if(!(csr32r(ctlr, Ctrl) & Devrst))
  1030. break;
  1031. delay(1);
  1032. }
  1033. if(csr32r(ctlr, Ctrl) & Devrst)
  1034. return -1;
  1035. r = csr32r(ctlr, Ctrlext);
  1036. csr32w(ctlr, Ctrlext, r|Eerst);
  1037. delay(1);
  1038. for(timeo = 0; timeo < 1000; timeo++){
  1039. if(!(csr32r(ctlr, Ctrlext) & Eerst))
  1040. break;
  1041. delay(1);
  1042. }
  1043. if(csr32r(ctlr, Ctrlext) & Eerst)
  1044. return -1;
  1045. csr32w(ctlr, Imc, ~0);
  1046. delay(1);
  1047. for(timeo = 0; timeo < 1000; timeo++){
  1048. if(!csr32r(ctlr, Icr))
  1049. break;
  1050. delay(1);
  1051. }
  1052. if(csr32r(ctlr, Icr))
  1053. return -1;
  1054. return 0;
  1055. }
  1056. static void
  1057. i82563shutdown(Ether* ether)
  1058. {
  1059. i82563detach(ether->ctlr);
  1060. }
  1061. static ushort
  1062. eeread(Ctlr* ctlr, int adr)
  1063. {
  1064. csr32w(ctlr, Eerd, ee_start | adr << 2);
  1065. while ((csr32r(ctlr, Eerd) & ee_done) == 0)
  1066. ;
  1067. return csr32r(ctlr, Eerd) >> 16;
  1068. }
  1069. static int
  1070. eeload(Ctlr* ctlr)
  1071. {
  1072. ushort sum;
  1073. int data, adr;
  1074. sum = 0;
  1075. for (adr = 0; adr < 0x40; adr++) {
  1076. data = eeread(ctlr, adr);
  1077. ctlr->eeprom[adr] = data;
  1078. sum += data;
  1079. }
  1080. return sum;
  1081. }
  1082. /*
  1083. * kind of unnecessary;
  1084. * but just in case they add 4 or 16 macs to the same ctlr.
  1085. */
  1086. static uchar*
  1087. etheradd(uchar *u, uint n)
  1088. {
  1089. int i;
  1090. uint j;
  1091. for(i = 5; n != 0 && i >= 0; i--){
  1092. j = n+u[i];
  1093. u[i] = j;
  1094. n = j>>8;
  1095. }
  1096. return u;
  1097. }
  1098. typedef struct {
  1099. uchar ea[Easize];
  1100. int n;
  1101. } Basetab;
  1102. static Basetab btab[Maxmac];
  1103. static int nbase;
  1104. int
  1105. nthether(uchar *ea)
  1106. {
  1107. int i;
  1108. for(i = 0; i < nelem(btab); i++)
  1109. if(btab[i].n == 0 || memcmp(btab[i].ea, ea, Easize) == 0) {
  1110. memmove(btab[i].ea, ea, Easize);
  1111. return btab[i].n++;
  1112. }
  1113. return -1;
  1114. }
  1115. static int
  1116. i82563reset(Ctlr* ctlr)
  1117. {
  1118. int i, r;
  1119. if(i82563detach(ctlr))
  1120. return -1;
  1121. r = eeload(ctlr);
  1122. if (r != 0 && r != 0xBABA){
  1123. print("i82563: bad EEPROM checksum - 0x%4.4uX\n", r);
  1124. return -1;
  1125. }
  1126. for(i = Ea; i < Eaddrlen/2; i++){
  1127. ctlr->ra[2*i] = ctlr->eeprom[i];
  1128. ctlr->ra[2*i+1] = ctlr->eeprom[i]>>8;
  1129. }
  1130. etheradd(ctlr->ra, nthether(ctlr->ra));
  1131. r = (ctlr->ra[3]<<24)|(ctlr->ra[2]<<16)|(ctlr->ra[1]<<8)|ctlr->ra[0];
  1132. csr32w(ctlr, Ral, r);
  1133. r = 0x80000000|(ctlr->ra[5]<<8)|ctlr->ra[4];
  1134. csr32w(ctlr, Rah, r);
  1135. for(i = 1; i < 16; i++){
  1136. csr32w(ctlr, Ral+i*8, 0);
  1137. csr32w(ctlr, Rah+i*8, 0);
  1138. }
  1139. memset(ctlr->mta, 0, sizeof(ctlr->mta));
  1140. for(i = 0; i < 128; i++)
  1141. csr32w(ctlr, Mta+i*4, 0);
  1142. csr32w(ctlr, Fcal, 0x00C28001);
  1143. csr32w(ctlr, Fcah, 0x00000100);
  1144. csr32w(ctlr, Fct, 0x00008808);
  1145. csr32w(ctlr, Fcttv, 0x00000100);
  1146. csr32w(ctlr, Fcrtl, ctlr->fcrtl);
  1147. csr32w(ctlr, Fcrth, ctlr->fcrth);
  1148. return 0;
  1149. }
  1150. static void
  1151. i82563pci(void)
  1152. {
  1153. int cls;
  1154. Pcidev *p;
  1155. Ctlr *ctlr;
  1156. ulong io;
  1157. void *mem;
  1158. p = nil;
  1159. while(p = pcimatch(p, 0, 0)){
  1160. if(p->ccrb != Pcibcnet || p->ccru != 0)
  1161. continue;
  1162. if (p->vid != 0x8086 || p->did != 0x1096)
  1163. continue;
  1164. io = p->mem[0].bar & ~0x0F;
  1165. mem = vmap(io, p->mem[0].size);
  1166. if(mem == nil){
  1167. print("i82563: can't map %8.8luX\n", p->mem[0].bar);
  1168. continue;
  1169. }
  1170. cls = pcicfgr8(p, PciCLS);
  1171. switch(cls){
  1172. default:
  1173. print("i82563: unexpected CLS - %d\n", cls*4);
  1174. break;
  1175. case 0x00:
  1176. case 0xFF:
  1177. print("i82563: unusable CLS\n");
  1178. continue;
  1179. case 0x08:
  1180. case 0x10:
  1181. break;
  1182. }
  1183. ctlr = malloc(sizeof(Ctlr));
  1184. ctlr->port = io;
  1185. ctlr->pcidev = p;
  1186. ctlr->id = (p->did<<16)|p->vid;
  1187. ctlr->cls = cls*4;
  1188. ctlr->nic = mem;
  1189. if(i82563reset(ctlr)){
  1190. free(ctlr);
  1191. continue;
  1192. }
  1193. pcisetbme(p);
  1194. if(i82563ctlrhead != nil)
  1195. i82563ctlrtail->next = ctlr;
  1196. else
  1197. i82563ctlrhead = ctlr;
  1198. i82563ctlrtail = ctlr;
  1199. }
  1200. }
  1201. static int
  1202. i82563pnp(Ether* edev)
  1203. {
  1204. Ctlr *ctlr;
  1205. if(i82563ctlrhead == nil)
  1206. i82563pci();
  1207. /*
  1208. * Any adapter matches if no edev->port is supplied,
  1209. * otherwise the ports must match.
  1210. */
  1211. for(ctlr = i82563ctlrhead; ctlr != nil; ctlr = ctlr->next)
  1212. if(ctlr->active)
  1213. continue;
  1214. else if(edev->port == 0 || edev->port == ctlr->port){
  1215. ctlr->active = 1;
  1216. break;
  1217. }
  1218. if(ctlr == nil)
  1219. return -1;
  1220. edev->ctlr = ctlr;
  1221. edev->port = ctlr->port;
  1222. edev->irq = ctlr->pcidev->intl;
  1223. edev->tbdf = ctlr->pcidev->tbdf;
  1224. edev->mbps = 1000;
  1225. edev->maxmtu = Rbsz;
  1226. memmove(edev->ea, ctlr->ra, Eaddrlen);
  1227. /*
  1228. * Linkage to the generic ethernet driver.
  1229. */
  1230. edev->attach = i82563attach;
  1231. edev->transmit = i82563transmit;
  1232. edev->interrupt = i82563interrupt;
  1233. edev->ifstat = i82563ifstat;
  1234. edev->ctl = i82563ctl;
  1235. edev->arg = edev;
  1236. edev->promiscuous = i82563promiscuous;
  1237. edev->shutdown = i82563shutdown;
  1238. edev->multicast = i82563multicast;
  1239. return 0;
  1240. }
  1241. void
  1242. ether82563link(void)
  1243. {
  1244. addethercard("i82563", i82563pnp);
  1245. }