declance.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394
  1. /*
  2. * Lance ethernet driver for the MIPS processor based
  3. * DECstation family
  4. *
  5. *
  6. * adopted from sunlance.c by Richard van den Berg
  7. *
  8. * Copyright (C) 2002, 2003, 2005, 2006 Maciej W. Rozycki
  9. *
  10. * additional sources:
  11. * - PMAD-AA TURBOchannel Ethernet Module Functional Specification,
  12. * Revision 1.2
  13. *
  14. * History:
  15. *
  16. * v0.001: The kernel accepts the code and it shows the hardware address.
  17. *
  18. * v0.002: Removed most sparc stuff, left only some module and dma stuff.
  19. *
  20. * v0.003: Enhanced base address calculation from proposals by
  21. * Harald Koerfgen and Thomas Riemer.
  22. *
  23. * v0.004: lance-regs is pointing at the right addresses, added prom
  24. * check. First start of address mapping and DMA.
  25. *
  26. * v0.005: started to play around with LANCE-DMA. This driver will not
  27. * work for non IOASIC lances. HK
  28. *
  29. * v0.006: added pointer arrays to lance_private and setup routine for
  30. * them in dec_lance_init. HK
  31. *
  32. * v0.007: Big shit. The LANCE seems to use a different DMA mechanism to
  33. * access the init block. This looks like one (short) word at a
  34. * time, but the smallest amount the IOASIC can transfer is a
  35. * (long) word. So we have a 2-2 padding here. Changed
  36. * lance_init_block accordingly. The 16-16 padding for the buffers
  37. * seems to be correct. HK
  38. *
  39. * v0.008: mods to make PMAX_LANCE work. 01/09/1999 triemer
  40. *
  41. * v0.009: Module support fixes, multiple interfaces support, various
  42. * bits. macro
  43. *
  44. * v0.010: Fixes for the PMAD mapping of the LANCE buffer and for the
  45. * PMAX requirement to only use halfword accesses to the
  46. * buffer. macro
  47. *
  48. * v0.011: Converted the PMAD to the driver model. macro
  49. */
  50. #include <linux/crc32.h>
  51. #include <linux/delay.h>
  52. #include <linux/errno.h>
  53. #include <linux/if_ether.h>
  54. #include <linux/init.h>
  55. #include <linux/kernel.h>
  56. #include <linux/module.h>
  57. #include <linux/netdevice.h>
  58. #include <linux/etherdevice.h>
  59. #include <linux/spinlock.h>
  60. #include <linux/stddef.h>
  61. #include <linux/string.h>
  62. #include <linux/tc.h>
  63. #include <linux/types.h>
  64. #include <asm/addrspace.h>
  65. #include <asm/system.h>
  66. #include <asm/dec/interrupts.h>
  67. #include <asm/dec/ioasic.h>
  68. #include <asm/dec/ioasic_addrs.h>
  69. #include <asm/dec/kn01.h>
  70. #include <asm/dec/machtype.h>
  71. #include <asm/dec/system.h>
  72. static char version[] __devinitdata =
  73. "declance.c: v0.011 by Linux MIPS DECstation task force\n";
  74. MODULE_AUTHOR("Linux MIPS DECstation task force");
  75. MODULE_DESCRIPTION("DEC LANCE (DECstation onboard, PMAD-xx) driver");
  76. MODULE_LICENSE("GPL");
  77. #define __unused __attribute__ ((unused))
  78. /*
  79. * card types
  80. */
  81. #define ASIC_LANCE 1
  82. #define PMAD_LANCE 2
  83. #define PMAX_LANCE 3
  84. #define LE_CSR0 0
  85. #define LE_CSR1 1
  86. #define LE_CSR2 2
  87. #define LE_CSR3 3
  88. #define LE_MO_PROM 0x8000 /* Enable promiscuous mode */
  89. #define LE_C0_ERR 0x8000 /* Error: set if BAB, SQE, MISS or ME is set */
  90. #define LE_C0_BABL 0x4000 /* BAB: Babble: tx timeout. */
  91. #define LE_C0_CERR 0x2000 /* SQE: Signal quality error */
  92. #define LE_C0_MISS 0x1000 /* MISS: Missed a packet */
  93. #define LE_C0_MERR 0x0800 /* ME: Memory error */
  94. #define LE_C0_RINT 0x0400 /* Received interrupt */
  95. #define LE_C0_TINT 0x0200 /* Transmitter Interrupt */
  96. #define LE_C0_IDON 0x0100 /* IFIN: Init finished. */
  97. #define LE_C0_INTR 0x0080 /* Interrupt or error */
  98. #define LE_C0_INEA 0x0040 /* Interrupt enable */
  99. #define LE_C0_RXON 0x0020 /* Receiver on */
  100. #define LE_C0_TXON 0x0010 /* Transmitter on */
  101. #define LE_C0_TDMD 0x0008 /* Transmitter demand */
  102. #define LE_C0_STOP 0x0004 /* Stop the card */
  103. #define LE_C0_STRT 0x0002 /* Start the card */
  104. #define LE_C0_INIT 0x0001 /* Init the card */
  105. #define LE_C3_BSWP 0x4 /* SWAP */
  106. #define LE_C3_ACON 0x2 /* ALE Control */
  107. #define LE_C3_BCON 0x1 /* Byte control */
  108. /* Receive message descriptor 1 */
  109. #define LE_R1_OWN 0x8000 /* Who owns the entry */
  110. #define LE_R1_ERR 0x4000 /* Error: if FRA, OFL, CRC or BUF is set */
  111. #define LE_R1_FRA 0x2000 /* FRA: Frame error */
  112. #define LE_R1_OFL 0x1000 /* OFL: Frame overflow */
  113. #define LE_R1_CRC 0x0800 /* CRC error */
  114. #define LE_R1_BUF 0x0400 /* BUF: Buffer error */
  115. #define LE_R1_SOP 0x0200 /* Start of packet */
  116. #define LE_R1_EOP 0x0100 /* End of packet */
  117. #define LE_R1_POK 0x0300 /* Packet is complete: SOP + EOP */
  118. /* Transmit message descriptor 1 */
  119. #define LE_T1_OWN 0x8000 /* Lance owns the packet */
  120. #define LE_T1_ERR 0x4000 /* Error summary */
  121. #define LE_T1_EMORE 0x1000 /* Error: more than one retry needed */
  122. #define LE_T1_EONE 0x0800 /* Error: one retry needed */
  123. #define LE_T1_EDEF 0x0400 /* Error: deferred */
  124. #define LE_T1_SOP 0x0200 /* Start of packet */
  125. #define LE_T1_EOP 0x0100 /* End of packet */
  126. #define LE_T1_POK 0x0300 /* Packet is complete: SOP + EOP */
  127. #define LE_T3_BUF 0x8000 /* Buffer error */
  128. #define LE_T3_UFL 0x4000 /* Error underflow */
  129. #define LE_T3_LCOL 0x1000 /* Error late collision */
  130. #define LE_T3_CLOS 0x0800 /* Error carrier loss */
  131. #define LE_T3_RTY 0x0400 /* Error retry */
  132. #define LE_T3_TDR 0x03ff /* Time Domain Reflectometry counter */
  133. /* Define: 2^4 Tx buffers and 2^4 Rx buffers */
  134. #ifndef LANCE_LOG_TX_BUFFERS
  135. #define LANCE_LOG_TX_BUFFERS 4
  136. #define LANCE_LOG_RX_BUFFERS 4
  137. #endif
  138. #define TX_RING_SIZE (1 << (LANCE_LOG_TX_BUFFERS))
  139. #define TX_RING_MOD_MASK (TX_RING_SIZE - 1)
  140. #define RX_RING_SIZE (1 << (LANCE_LOG_RX_BUFFERS))
  141. #define RX_RING_MOD_MASK (RX_RING_SIZE - 1)
  142. #define PKT_BUF_SZ 1536
  143. #define RX_BUFF_SIZE PKT_BUF_SZ
  144. #define TX_BUFF_SIZE PKT_BUF_SZ
  145. #undef TEST_HITS
  146. #define ZERO 0
  147. /*
  148. * The DS2100/3100 have a linear 64 kB buffer which supports halfword
  149. * accesses only. Each halfword of the buffer is word-aligned in the
  150. * CPU address space.
  151. *
  152. * The PMAD-AA has a 128 kB buffer on-board.
  153. *
  154. * The IOASIC LANCE devices use a shared memory region. This region
  155. * as seen from the CPU is (max) 128 kB long and has to be on an 128 kB
  156. * boundary. The LANCE sees this as a 64 kB long continuous memory
  157. * region.
  158. *
  159. * The LANCE's DMA address is used as an index in this buffer and DMA
  160. * takes place in bursts of eight 16-bit words which are packed into
  161. * four 32-bit words by the IOASIC. This leads to a strange padding:
  162. * 16 bytes of valid data followed by a 16 byte gap :-(.
  163. */
  164. struct lance_rx_desc {
  165. unsigned short rmd0; /* low address of packet */
  166. unsigned short rmd1; /* high address of packet
  167. and descriptor bits */
  168. short length; /* 2s complement (negative!)
  169. of buffer length */
  170. unsigned short mblength; /* actual number of bytes received */
  171. };
  172. struct lance_tx_desc {
  173. unsigned short tmd0; /* low address of packet */
  174. unsigned short tmd1; /* high address of packet
  175. and descriptor bits */
  176. short length; /* 2s complement (negative!)
  177. of buffer length */
  178. unsigned short misc;
  179. };
  180. /* First part of the LANCE initialization block, described in databook. */
  181. struct lance_init_block {
  182. unsigned short mode; /* pre-set mode (reg. 15) */
  183. unsigned short phys_addr[3]; /* physical ethernet address */
  184. unsigned short filter[4]; /* multicast filter */
  185. /* Receive and transmit ring base, along with extra bits. */
  186. unsigned short rx_ptr; /* receive descriptor addr */
  187. unsigned short rx_len; /* receive len and high addr */
  188. unsigned short tx_ptr; /* transmit descriptor addr */
  189. unsigned short tx_len; /* transmit len and high addr */
  190. short gap[4];
  191. /* The buffer descriptors */
  192. struct lance_rx_desc brx_ring[RX_RING_SIZE];
  193. struct lance_tx_desc btx_ring[TX_RING_SIZE];
  194. };
  195. #define BUF_OFFSET_CPU sizeof(struct lance_init_block)
  196. #define BUF_OFFSET_LNC sizeof(struct lance_init_block)
  197. #define shift_off(off, type) \
  198. (type == ASIC_LANCE || type == PMAX_LANCE ? off << 1 : off)
  199. #define lib_off(rt, type) \
  200. shift_off(offsetof(struct lance_init_block, rt), type)
  201. #define lib_ptr(ib, rt, type) \
  202. ((volatile u16 *)((u8 *)(ib) + lib_off(rt, type)))
  203. #define rds_off(rt, type) \
  204. shift_off(offsetof(struct lance_rx_desc, rt), type)
  205. #define rds_ptr(rd, rt, type) \
  206. ((volatile u16 *)((u8 *)(rd) + rds_off(rt, type)))
  207. #define tds_off(rt, type) \
  208. shift_off(offsetof(struct lance_tx_desc, rt), type)
  209. #define tds_ptr(td, rt, type) \
  210. ((volatile u16 *)((u8 *)(td) + tds_off(rt, type)))
  211. struct lance_private {
  212. struct net_device *next;
  213. int type;
  214. int dma_irq;
  215. volatile struct lance_regs *ll;
  216. spinlock_t lock;
  217. int rx_new, tx_new;
  218. int rx_old, tx_old;
  219. struct net_device_stats stats;
  220. unsigned short busmaster_regval;
  221. struct timer_list multicast_timer;
  222. /* Pointers to the ring buffers as seen from the CPU */
  223. char *rx_buf_ptr_cpu[RX_RING_SIZE];
  224. char *tx_buf_ptr_cpu[TX_RING_SIZE];
  225. /* Pointers to the ring buffers as seen from the LANCE */
  226. uint rx_buf_ptr_lnc[RX_RING_SIZE];
  227. uint tx_buf_ptr_lnc[TX_RING_SIZE];
  228. };
  229. #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
  230. lp->tx_old+TX_RING_MOD_MASK-lp->tx_new:\
  231. lp->tx_old - lp->tx_new-1)
  232. /* The lance control ports are at an absolute address, machine and tc-slot
  233. * dependent.
  234. * DECstations do only 32-bit access and the LANCE uses 16 bit addresses,
  235. * so we have to give the structure an extra member making rap pointing
  236. * at the right address
  237. */
  238. struct lance_regs {
  239. volatile unsigned short rdp; /* register data port */
  240. unsigned short pad;
  241. volatile unsigned short rap; /* register address port */
  242. };
  243. int dec_lance_debug = 2;
  244. static struct tc_driver dec_lance_tc_driver;
  245. static struct net_device *root_lance_dev;
  246. static inline void writereg(volatile unsigned short *regptr, short value)
  247. {
  248. *regptr = value;
  249. iob();
  250. }
  251. /* Load the CSR registers */
  252. static void load_csrs(struct lance_private *lp)
  253. {
  254. volatile struct lance_regs *ll = lp->ll;
  255. uint leptr;
  256. /* The address space as seen from the LANCE
  257. * begins at address 0. HK
  258. */
  259. leptr = 0;
  260. writereg(&ll->rap, LE_CSR1);
  261. writereg(&ll->rdp, (leptr & 0xFFFF));
  262. writereg(&ll->rap, LE_CSR2);
  263. writereg(&ll->rdp, leptr >> 16);
  264. writereg(&ll->rap, LE_CSR3);
  265. writereg(&ll->rdp, lp->busmaster_regval);
  266. /* Point back to csr0 */
  267. writereg(&ll->rap, LE_CSR0);
  268. }
  269. /*
  270. * Our specialized copy routines
  271. *
  272. */
  273. static void cp_to_buf(const int type, void *to, const void *from, int len)
  274. {
  275. unsigned short *tp, *fp, clen;
  276. unsigned char *rtp, *rfp;
  277. if (type == PMAD_LANCE) {
  278. memcpy(to, from, len);
  279. } else if (type == PMAX_LANCE) {
  280. clen = len >> 1;
  281. tp = (unsigned short *) to;
  282. fp = (unsigned short *) from;
  283. while (clen--) {
  284. *tp++ = *fp++;
  285. tp++;
  286. }
  287. clen = len & 1;
  288. rtp = (unsigned char *) tp;
  289. rfp = (unsigned char *) fp;
  290. while (clen--) {
  291. *rtp++ = *rfp++;
  292. }
  293. } else {
  294. /*
  295. * copy 16 Byte chunks
  296. */
  297. clen = len >> 4;
  298. tp = (unsigned short *) to;
  299. fp = (unsigned short *) from;
  300. while (clen--) {
  301. *tp++ = *fp++;
  302. *tp++ = *fp++;
  303. *tp++ = *fp++;
  304. *tp++ = *fp++;
  305. *tp++ = *fp++;
  306. *tp++ = *fp++;
  307. *tp++ = *fp++;
  308. *tp++ = *fp++;
  309. tp += 8;
  310. }
  311. /*
  312. * do the rest, if any.
  313. */
  314. clen = len & 15;
  315. rtp = (unsigned char *) tp;
  316. rfp = (unsigned char *) fp;
  317. while (clen--) {
  318. *rtp++ = *rfp++;
  319. }
  320. }
  321. iob();
  322. }
  323. static void cp_from_buf(const int type, void *to, const void *from, int len)
  324. {
  325. unsigned short *tp, *fp, clen;
  326. unsigned char *rtp, *rfp;
  327. if (type == PMAD_LANCE) {
  328. memcpy(to, from, len);
  329. } else if (type == PMAX_LANCE) {
  330. clen = len >> 1;
  331. tp = (unsigned short *) to;
  332. fp = (unsigned short *) from;
  333. while (clen--) {
  334. *tp++ = *fp++;
  335. fp++;
  336. }
  337. clen = len & 1;
  338. rtp = (unsigned char *) tp;
  339. rfp = (unsigned char *) fp;
  340. while (clen--) {
  341. *rtp++ = *rfp++;
  342. }
  343. } else {
  344. /*
  345. * copy 16 Byte chunks
  346. */
  347. clen = len >> 4;
  348. tp = (unsigned short *) to;
  349. fp = (unsigned short *) from;
  350. while (clen--) {
  351. *tp++ = *fp++;
  352. *tp++ = *fp++;
  353. *tp++ = *fp++;
  354. *tp++ = *fp++;
  355. *tp++ = *fp++;
  356. *tp++ = *fp++;
  357. *tp++ = *fp++;
  358. *tp++ = *fp++;
  359. fp += 8;
  360. }
  361. /*
  362. * do the rest, if any.
  363. */
  364. clen = len & 15;
  365. rtp = (unsigned char *) tp;
  366. rfp = (unsigned char *) fp;
  367. while (clen--) {
  368. *rtp++ = *rfp++;
  369. }
  370. }
  371. }
  372. /* Setup the Lance Rx and Tx rings */
  373. static void lance_init_ring(struct net_device *dev)
  374. {
  375. struct lance_private *lp = netdev_priv(dev);
  376. volatile u16 *ib = (volatile u16 *)dev->mem_start;
  377. uint leptr;
  378. int i;
  379. /* Lock out other processes while setting up hardware */
  380. netif_stop_queue(dev);
  381. lp->rx_new = lp->tx_new = 0;
  382. lp->rx_old = lp->tx_old = 0;
  383. /* Copy the ethernet address to the lance init block.
  384. * XXX bit 0 of the physical address registers has to be zero
  385. */
  386. *lib_ptr(ib, phys_addr[0], lp->type) = (dev->dev_addr[1] << 8) |
  387. dev->dev_addr[0];
  388. *lib_ptr(ib, phys_addr[1], lp->type) = (dev->dev_addr[3] << 8) |
  389. dev->dev_addr[2];
  390. *lib_ptr(ib, phys_addr[2], lp->type) = (dev->dev_addr[5] << 8) |
  391. dev->dev_addr[4];
  392. /* Setup the initialization block */
  393. /* Setup rx descriptor pointer */
  394. leptr = offsetof(struct lance_init_block, brx_ring);
  395. *lib_ptr(ib, rx_len, lp->type) = (LANCE_LOG_RX_BUFFERS << 13) |
  396. (leptr >> 16);
  397. *lib_ptr(ib, rx_ptr, lp->type) = leptr;
  398. if (ZERO)
  399. printk("RX ptr: %8.8x(%8.8x)\n",
  400. leptr, lib_off(brx_ring, lp->type));
  401. /* Setup tx descriptor pointer */
  402. leptr = offsetof(struct lance_init_block, btx_ring);
  403. *lib_ptr(ib, tx_len, lp->type) = (LANCE_LOG_TX_BUFFERS << 13) |
  404. (leptr >> 16);
  405. *lib_ptr(ib, tx_ptr, lp->type) = leptr;
  406. if (ZERO)
  407. printk("TX ptr: %8.8x(%8.8x)\n",
  408. leptr, lib_off(btx_ring, lp->type));
  409. if (ZERO)
  410. printk("TX rings:\n");
  411. /* Setup the Tx ring entries */
  412. for (i = 0; i < TX_RING_SIZE; i++) {
  413. leptr = lp->tx_buf_ptr_lnc[i];
  414. *lib_ptr(ib, btx_ring[i].tmd0, lp->type) = leptr;
  415. *lib_ptr(ib, btx_ring[i].tmd1, lp->type) = (leptr >> 16) &
  416. 0xff;
  417. *lib_ptr(ib, btx_ring[i].length, lp->type) = 0xf000;
  418. /* The ones required by tmd2 */
  419. *lib_ptr(ib, btx_ring[i].misc, lp->type) = 0;
  420. if (i < 3 && ZERO)
  421. printk("%d: 0x%8.8x(0x%8.8x)\n",
  422. i, leptr, (uint)lp->tx_buf_ptr_cpu[i]);
  423. }
  424. /* Setup the Rx ring entries */
  425. if (ZERO)
  426. printk("RX rings:\n");
  427. for (i = 0; i < RX_RING_SIZE; i++) {
  428. leptr = lp->rx_buf_ptr_lnc[i];
  429. *lib_ptr(ib, brx_ring[i].rmd0, lp->type) = leptr;
  430. *lib_ptr(ib, brx_ring[i].rmd1, lp->type) = ((leptr >> 16) &
  431. 0xff) |
  432. LE_R1_OWN;
  433. *lib_ptr(ib, brx_ring[i].length, lp->type) = -RX_BUFF_SIZE |
  434. 0xf000;
  435. *lib_ptr(ib, brx_ring[i].mblength, lp->type) = 0;
  436. if (i < 3 && ZERO)
  437. printk("%d: 0x%8.8x(0x%8.8x)\n",
  438. i, leptr, (uint)lp->rx_buf_ptr_cpu[i]);
  439. }
  440. iob();
  441. }
  442. static int init_restart_lance(struct lance_private *lp)
  443. {
  444. volatile struct lance_regs *ll = lp->ll;
  445. int i;
  446. writereg(&ll->rap, LE_CSR0);
  447. writereg(&ll->rdp, LE_C0_INIT);
  448. /* Wait for the lance to complete initialization */
  449. for (i = 0; (i < 100) && !(ll->rdp & LE_C0_IDON); i++) {
  450. udelay(10);
  451. }
  452. if ((i == 100) || (ll->rdp & LE_C0_ERR)) {
  453. printk("LANCE unopened after %d ticks, csr0=%4.4x.\n",
  454. i, ll->rdp);
  455. return -1;
  456. }
  457. if ((ll->rdp & LE_C0_ERR)) {
  458. printk("LANCE unopened after %d ticks, csr0=%4.4x.\n",
  459. i, ll->rdp);
  460. return -1;
  461. }
  462. writereg(&ll->rdp, LE_C0_IDON);
  463. writereg(&ll->rdp, LE_C0_STRT);
  464. writereg(&ll->rdp, LE_C0_INEA);
  465. return 0;
  466. }
  467. static int lance_rx(struct net_device *dev)
  468. {
  469. struct lance_private *lp = netdev_priv(dev);
  470. volatile u16 *ib = (volatile u16 *)dev->mem_start;
  471. volatile u16 *rd;
  472. unsigned short bits;
  473. int entry, len;
  474. struct sk_buff *skb;
  475. #ifdef TEST_HITS
  476. {
  477. int i;
  478. printk("[");
  479. for (i = 0; i < RX_RING_SIZE; i++) {
  480. if (i == lp->rx_new)
  481. printk("%s", *lib_ptr(ib, brx_ring[i].rmd1,
  482. lp->type) &
  483. LE_R1_OWN ? "_" : "X");
  484. else
  485. printk("%s", *lib_ptr(ib, brx_ring[i].rmd1,
  486. lp->type) &
  487. LE_R1_OWN ? "." : "1");
  488. }
  489. printk("]");
  490. }
  491. #endif
  492. for (rd = lib_ptr(ib, brx_ring[lp->rx_new], lp->type);
  493. !((bits = *rds_ptr(rd, rmd1, lp->type)) & LE_R1_OWN);
  494. rd = lib_ptr(ib, brx_ring[lp->rx_new], lp->type)) {
  495. entry = lp->rx_new;
  496. /* We got an incomplete frame? */
  497. if ((bits & LE_R1_POK) != LE_R1_POK) {
  498. lp->stats.rx_over_errors++;
  499. lp->stats.rx_errors++;
  500. } else if (bits & LE_R1_ERR) {
  501. /* Count only the end frame as a rx error,
  502. * not the beginning
  503. */
  504. if (bits & LE_R1_BUF)
  505. lp->stats.rx_fifo_errors++;
  506. if (bits & LE_R1_CRC)
  507. lp->stats.rx_crc_errors++;
  508. if (bits & LE_R1_OFL)
  509. lp->stats.rx_over_errors++;
  510. if (bits & LE_R1_FRA)
  511. lp->stats.rx_frame_errors++;
  512. if (bits & LE_R1_EOP)
  513. lp->stats.rx_errors++;
  514. } else {
  515. len = (*rds_ptr(rd, mblength, lp->type) & 0xfff) - 4;
  516. skb = dev_alloc_skb(len + 2);
  517. if (skb == 0) {
  518. printk("%s: Memory squeeze, deferring packet.\n",
  519. dev->name);
  520. lp->stats.rx_dropped++;
  521. *rds_ptr(rd, mblength, lp->type) = 0;
  522. *rds_ptr(rd, rmd1, lp->type) =
  523. ((lp->rx_buf_ptr_lnc[entry] >> 16) &
  524. 0xff) | LE_R1_OWN;
  525. lp->rx_new = (entry + 1) & RX_RING_MOD_MASK;
  526. return 0;
  527. }
  528. lp->stats.rx_bytes += len;
  529. skb->dev = dev;
  530. skb_reserve(skb, 2); /* 16 byte align */
  531. skb_put(skb, len); /* make room */
  532. cp_from_buf(lp->type, skb->data,
  533. (char *)lp->rx_buf_ptr_cpu[entry], len);
  534. skb->protocol = eth_type_trans(skb, dev);
  535. netif_rx(skb);
  536. dev->last_rx = jiffies;
  537. lp->stats.rx_packets++;
  538. }
  539. /* Return the packet to the pool */
  540. *rds_ptr(rd, mblength, lp->type) = 0;
  541. *rds_ptr(rd, length, lp->type) = -RX_BUFF_SIZE | 0xf000;
  542. *rds_ptr(rd, rmd1, lp->type) =
  543. ((lp->rx_buf_ptr_lnc[entry] >> 16) & 0xff) | LE_R1_OWN;
  544. lp->rx_new = (entry + 1) & RX_RING_MOD_MASK;
  545. }
  546. return 0;
  547. }
  548. static void lance_tx(struct net_device *dev)
  549. {
  550. struct lance_private *lp = netdev_priv(dev);
  551. volatile u16 *ib = (volatile u16 *)dev->mem_start;
  552. volatile struct lance_regs *ll = lp->ll;
  553. volatile u16 *td;
  554. int i, j;
  555. int status;
  556. j = lp->tx_old;
  557. spin_lock(&lp->lock);
  558. for (i = j; i != lp->tx_new; i = j) {
  559. td = lib_ptr(ib, btx_ring[i], lp->type);
  560. /* If we hit a packet not owned by us, stop */
  561. if (*tds_ptr(td, tmd1, lp->type) & LE_T1_OWN)
  562. break;
  563. if (*tds_ptr(td, tmd1, lp->type) & LE_T1_ERR) {
  564. status = *tds_ptr(td, misc, lp->type);
  565. lp->stats.tx_errors++;
  566. if (status & LE_T3_RTY)
  567. lp->stats.tx_aborted_errors++;
  568. if (status & LE_T3_LCOL)
  569. lp->stats.tx_window_errors++;
  570. if (status & LE_T3_CLOS) {
  571. lp->stats.tx_carrier_errors++;
  572. printk("%s: Carrier Lost\n", dev->name);
  573. /* Stop the lance */
  574. writereg(&ll->rap, LE_CSR0);
  575. writereg(&ll->rdp, LE_C0_STOP);
  576. lance_init_ring(dev);
  577. load_csrs(lp);
  578. init_restart_lance(lp);
  579. goto out;
  580. }
  581. /* Buffer errors and underflows turn off the
  582. * transmitter, restart the adapter.
  583. */
  584. if (status & (LE_T3_BUF | LE_T3_UFL)) {
  585. lp->stats.tx_fifo_errors++;
  586. printk("%s: Tx: ERR_BUF|ERR_UFL, restarting\n",
  587. dev->name);
  588. /* Stop the lance */
  589. writereg(&ll->rap, LE_CSR0);
  590. writereg(&ll->rdp, LE_C0_STOP);
  591. lance_init_ring(dev);
  592. load_csrs(lp);
  593. init_restart_lance(lp);
  594. goto out;
  595. }
  596. } else if ((*tds_ptr(td, tmd1, lp->type) & LE_T1_POK) ==
  597. LE_T1_POK) {
  598. /*
  599. * So we don't count the packet more than once.
  600. */
  601. *tds_ptr(td, tmd1, lp->type) &= ~(LE_T1_POK);
  602. /* One collision before packet was sent. */
  603. if (*tds_ptr(td, tmd1, lp->type) & LE_T1_EONE)
  604. lp->stats.collisions++;
  605. /* More than one collision, be optimistic. */
  606. if (*tds_ptr(td, tmd1, lp->type) & LE_T1_EMORE)
  607. lp->stats.collisions += 2;
  608. lp->stats.tx_packets++;
  609. }
  610. j = (j + 1) & TX_RING_MOD_MASK;
  611. }
  612. lp->tx_old = j;
  613. out:
  614. if (netif_queue_stopped(dev) &&
  615. TX_BUFFS_AVAIL > 0)
  616. netif_wake_queue(dev);
  617. spin_unlock(&lp->lock);
  618. }
  619. static irqreturn_t lance_dma_merr_int(const int irq, void *dev_id)
  620. {
  621. struct net_device *dev = dev_id;
  622. printk("%s: DMA error\n", dev->name);
  623. return IRQ_HANDLED;
  624. }
  625. static irqreturn_t lance_interrupt(const int irq, void *dev_id)
  626. {
  627. struct net_device *dev = dev_id;
  628. struct lance_private *lp = netdev_priv(dev);
  629. volatile struct lance_regs *ll = lp->ll;
  630. int csr0;
  631. writereg(&ll->rap, LE_CSR0);
  632. csr0 = ll->rdp;
  633. /* Acknowledge all the interrupt sources ASAP */
  634. writereg(&ll->rdp, csr0 & (LE_C0_INTR | LE_C0_TINT | LE_C0_RINT));
  635. if ((csr0 & LE_C0_ERR)) {
  636. /* Clear the error condition */
  637. writereg(&ll->rdp, LE_C0_BABL | LE_C0_ERR | LE_C0_MISS |
  638. LE_C0_CERR | LE_C0_MERR);
  639. }
  640. if (csr0 & LE_C0_RINT)
  641. lance_rx(dev);
  642. if (csr0 & LE_C0_TINT)
  643. lance_tx(dev);
  644. if (csr0 & LE_C0_BABL)
  645. lp->stats.tx_errors++;
  646. if (csr0 & LE_C0_MISS)
  647. lp->stats.rx_errors++;
  648. if (csr0 & LE_C0_MERR) {
  649. printk("%s: Memory error, status %04x\n", dev->name, csr0);
  650. writereg(&ll->rdp, LE_C0_STOP);
  651. lance_init_ring(dev);
  652. load_csrs(lp);
  653. init_restart_lance(lp);
  654. netif_wake_queue(dev);
  655. }
  656. writereg(&ll->rdp, LE_C0_INEA);
  657. writereg(&ll->rdp, LE_C0_INEA);
  658. return IRQ_HANDLED;
  659. }
  660. struct net_device *last_dev = 0;
  661. static int lance_open(struct net_device *dev)
  662. {
  663. volatile u16 *ib = (volatile u16 *)dev->mem_start;
  664. struct lance_private *lp = netdev_priv(dev);
  665. volatile struct lance_regs *ll = lp->ll;
  666. int status = 0;
  667. last_dev = dev;
  668. /* Stop the Lance */
  669. writereg(&ll->rap, LE_CSR0);
  670. writereg(&ll->rdp, LE_C0_STOP);
  671. /* Set mode and clear multicast filter only at device open,
  672. * so that lance_init_ring() called at any error will not
  673. * forget multicast filters.
  674. *
  675. * BTW it is common bug in all lance drivers! --ANK
  676. */
  677. *lib_ptr(ib, mode, lp->type) = 0;
  678. *lib_ptr(ib, filter[0], lp->type) = 0;
  679. *lib_ptr(ib, filter[1], lp->type) = 0;
  680. *lib_ptr(ib, filter[2], lp->type) = 0;
  681. *lib_ptr(ib, filter[3], lp->type) = 0;
  682. lance_init_ring(dev);
  683. load_csrs(lp);
  684. netif_start_queue(dev);
  685. /* Associate IRQ with lance_interrupt */
  686. if (request_irq(dev->irq, &lance_interrupt, 0, "lance", dev)) {
  687. printk("%s: Can't get IRQ %d\n", dev->name, dev->irq);
  688. return -EAGAIN;
  689. }
  690. if (lp->dma_irq >= 0) {
  691. unsigned long flags;
  692. if (request_irq(lp->dma_irq, &lance_dma_merr_int, 0,
  693. "lance error", dev)) {
  694. free_irq(dev->irq, dev);
  695. printk("%s: Can't get DMA IRQ %d\n", dev->name,
  696. lp->dma_irq);
  697. return -EAGAIN;
  698. }
  699. spin_lock_irqsave(&ioasic_ssr_lock, flags);
  700. fast_mb();
  701. /* Enable I/O ASIC LANCE DMA. */
  702. ioasic_write(IO_REG_SSR,
  703. ioasic_read(IO_REG_SSR) | IO_SSR_LANCE_DMA_EN);
  704. fast_mb();
  705. spin_unlock_irqrestore(&ioasic_ssr_lock, flags);
  706. }
  707. status = init_restart_lance(lp);
  708. return status;
  709. }
  710. static int lance_close(struct net_device *dev)
  711. {
  712. struct lance_private *lp = netdev_priv(dev);
  713. volatile struct lance_regs *ll = lp->ll;
  714. netif_stop_queue(dev);
  715. del_timer_sync(&lp->multicast_timer);
  716. /* Stop the card */
  717. writereg(&ll->rap, LE_CSR0);
  718. writereg(&ll->rdp, LE_C0_STOP);
  719. if (lp->dma_irq >= 0) {
  720. unsigned long flags;
  721. spin_lock_irqsave(&ioasic_ssr_lock, flags);
  722. fast_mb();
  723. /* Disable I/O ASIC LANCE DMA. */
  724. ioasic_write(IO_REG_SSR,
  725. ioasic_read(IO_REG_SSR) & ~IO_SSR_LANCE_DMA_EN);
  726. fast_iob();
  727. spin_unlock_irqrestore(&ioasic_ssr_lock, flags);
  728. free_irq(lp->dma_irq, dev);
  729. }
  730. free_irq(dev->irq, dev);
  731. return 0;
  732. }
  733. static inline int lance_reset(struct net_device *dev)
  734. {
  735. struct lance_private *lp = netdev_priv(dev);
  736. volatile struct lance_regs *ll = lp->ll;
  737. int status;
  738. /* Stop the lance */
  739. writereg(&ll->rap, LE_CSR0);
  740. writereg(&ll->rdp, LE_C0_STOP);
  741. lance_init_ring(dev);
  742. load_csrs(lp);
  743. dev->trans_start = jiffies;
  744. status = init_restart_lance(lp);
  745. return status;
  746. }
  747. static void lance_tx_timeout(struct net_device *dev)
  748. {
  749. struct lance_private *lp = netdev_priv(dev);
  750. volatile struct lance_regs *ll = lp->ll;
  751. printk(KERN_ERR "%s: transmit timed out, status %04x, reset\n",
  752. dev->name, ll->rdp);
  753. lance_reset(dev);
  754. netif_wake_queue(dev);
  755. }
  756. static int lance_start_xmit(struct sk_buff *skb, struct net_device *dev)
  757. {
  758. struct lance_private *lp = netdev_priv(dev);
  759. volatile struct lance_regs *ll = lp->ll;
  760. volatile u16 *ib = (volatile u16 *)dev->mem_start;
  761. int entry, len;
  762. len = skb->len;
  763. if (len < ETH_ZLEN) {
  764. if (skb_padto(skb, ETH_ZLEN))
  765. return 0;
  766. len = ETH_ZLEN;
  767. }
  768. lp->stats.tx_bytes += len;
  769. entry = lp->tx_new;
  770. *lib_ptr(ib, btx_ring[entry].length, lp->type) = (-len);
  771. *lib_ptr(ib, btx_ring[entry].misc, lp->type) = 0;
  772. cp_to_buf(lp->type, (char *)lp->tx_buf_ptr_cpu[entry], skb->data, len);
  773. /* Now, give the packet to the lance */
  774. *lib_ptr(ib, btx_ring[entry].tmd1, lp->type) =
  775. ((lp->tx_buf_ptr_lnc[entry] >> 16) & 0xff) |
  776. (LE_T1_POK | LE_T1_OWN);
  777. lp->tx_new = (entry + 1) & TX_RING_MOD_MASK;
  778. if (TX_BUFFS_AVAIL <= 0)
  779. netif_stop_queue(dev);
  780. /* Kick the lance: transmit now */
  781. writereg(&ll->rdp, LE_C0_INEA | LE_C0_TDMD);
  782. spin_unlock_irq(&lp->lock);
  783. dev->trans_start = jiffies;
  784. dev_kfree_skb(skb);
  785. return 0;
  786. }
  787. static struct net_device_stats *lance_get_stats(struct net_device *dev)
  788. {
  789. struct lance_private *lp = netdev_priv(dev);
  790. return &lp->stats;
  791. }
  792. static void lance_load_multicast(struct net_device *dev)
  793. {
  794. struct lance_private *lp = netdev_priv(dev);
  795. volatile u16 *ib = (volatile u16 *)dev->mem_start;
  796. struct dev_mc_list *dmi = dev->mc_list;
  797. char *addrs;
  798. int i;
  799. u32 crc;
  800. /* set all multicast bits */
  801. if (dev->flags & IFF_ALLMULTI) {
  802. *lib_ptr(ib, filter[0], lp->type) = 0xffff;
  803. *lib_ptr(ib, filter[1], lp->type) = 0xffff;
  804. *lib_ptr(ib, filter[2], lp->type) = 0xffff;
  805. *lib_ptr(ib, filter[3], lp->type) = 0xffff;
  806. return;
  807. }
  808. /* clear the multicast filter */
  809. *lib_ptr(ib, filter[0], lp->type) = 0;
  810. *lib_ptr(ib, filter[1], lp->type) = 0;
  811. *lib_ptr(ib, filter[2], lp->type) = 0;
  812. *lib_ptr(ib, filter[3], lp->type) = 0;
  813. /* Add addresses */
  814. for (i = 0; i < dev->mc_count; i++) {
  815. addrs = dmi->dmi_addr;
  816. dmi = dmi->next;
  817. /* multicast address? */
  818. if (!(*addrs & 1))
  819. continue;
  820. crc = ether_crc_le(ETH_ALEN, addrs);
  821. crc = crc >> 26;
  822. *lib_ptr(ib, filter[crc >> 4], lp->type) |= 1 << (crc & 0xf);
  823. }
  824. return;
  825. }
  826. static void lance_set_multicast(struct net_device *dev)
  827. {
  828. struct lance_private *lp = netdev_priv(dev);
  829. volatile u16 *ib = (volatile u16 *)dev->mem_start;
  830. volatile struct lance_regs *ll = lp->ll;
  831. if (!netif_running(dev))
  832. return;
  833. if (lp->tx_old != lp->tx_new) {
  834. mod_timer(&lp->multicast_timer, jiffies + 4 * HZ/100);
  835. netif_wake_queue(dev);
  836. return;
  837. }
  838. netif_stop_queue(dev);
  839. writereg(&ll->rap, LE_CSR0);
  840. writereg(&ll->rdp, LE_C0_STOP);
  841. lance_init_ring(dev);
  842. if (dev->flags & IFF_PROMISC) {
  843. *lib_ptr(ib, mode, lp->type) |= LE_MO_PROM;
  844. } else {
  845. *lib_ptr(ib, mode, lp->type) &= ~LE_MO_PROM;
  846. lance_load_multicast(dev);
  847. }
  848. load_csrs(lp);
  849. init_restart_lance(lp);
  850. netif_wake_queue(dev);
  851. }
  852. static void lance_set_multicast_retry(unsigned long _opaque)
  853. {
  854. struct net_device *dev = (struct net_device *) _opaque;
  855. lance_set_multicast(dev);
  856. }
  857. static int __init dec_lance_probe(struct device *bdev, const int type)
  858. {
  859. static unsigned version_printed;
  860. static const char fmt[] = "declance%d";
  861. char name[10];
  862. struct net_device *dev;
  863. struct lance_private *lp;
  864. volatile struct lance_regs *ll;
  865. resource_size_t start = 0, len = 0;
  866. int i, ret;
  867. unsigned long esar_base;
  868. unsigned char *esar;
  869. if (dec_lance_debug && version_printed++ == 0)
  870. printk(version);
  871. if (bdev)
  872. snprintf(name, sizeof(name), "%s", bdev->bus_id);
  873. else {
  874. i = 0;
  875. dev = root_lance_dev;
  876. while (dev) {
  877. i++;
  878. lp = (struct lance_private *)dev->priv;
  879. dev = lp->next;
  880. }
  881. snprintf(name, sizeof(name), fmt, i);
  882. }
  883. dev = alloc_etherdev(sizeof(struct lance_private));
  884. if (!dev) {
  885. printk(KERN_ERR "%s: Unable to allocate etherdev, aborting.\n",
  886. name);
  887. ret = -ENOMEM;
  888. goto err_out;
  889. }
  890. /*
  891. * alloc_etherdev ensures the data structures used by the LANCE
  892. * are aligned.
  893. */
  894. lp = netdev_priv(dev);
  895. spin_lock_init(&lp->lock);
  896. lp->type = type;
  897. switch (type) {
  898. case ASIC_LANCE:
  899. dev->base_addr = CKSEG1ADDR(dec_kn_slot_base + IOASIC_LANCE);
  900. /* buffer space for the on-board LANCE shared memory */
  901. /*
  902. * FIXME: ugly hack!
  903. */
  904. dev->mem_start = CKSEG1ADDR(0x00020000);
  905. dev->mem_end = dev->mem_start + 0x00020000;
  906. dev->irq = dec_interrupt[DEC_IRQ_LANCE];
  907. esar_base = CKSEG1ADDR(dec_kn_slot_base + IOASIC_ESAR);
  908. /* Workaround crash with booting KN04 2.1k from Disk */
  909. memset((void *)dev->mem_start, 0,
  910. dev->mem_end - dev->mem_start);
  911. /*
  912. * setup the pointer arrays, this sucks [tm] :-(
  913. */
  914. for (i = 0; i < RX_RING_SIZE; i++) {
  915. lp->rx_buf_ptr_cpu[i] =
  916. (char *)(dev->mem_start + 2 * BUF_OFFSET_CPU +
  917. 2 * i * RX_BUFF_SIZE);
  918. lp->rx_buf_ptr_lnc[i] =
  919. (BUF_OFFSET_LNC + i * RX_BUFF_SIZE);
  920. }
  921. for (i = 0; i < TX_RING_SIZE; i++) {
  922. lp->tx_buf_ptr_cpu[i] =
  923. (char *)(dev->mem_start + 2 * BUF_OFFSET_CPU +
  924. 2 * RX_RING_SIZE * RX_BUFF_SIZE +
  925. 2 * i * TX_BUFF_SIZE);
  926. lp->tx_buf_ptr_lnc[i] =
  927. (BUF_OFFSET_LNC +
  928. RX_RING_SIZE * RX_BUFF_SIZE +
  929. i * TX_BUFF_SIZE);
  930. }
  931. /* Setup I/O ASIC LANCE DMA. */
  932. lp->dma_irq = dec_interrupt[DEC_IRQ_LANCE_MERR];
  933. ioasic_write(IO_REG_LANCE_DMA_P,
  934. CPHYSADDR(dev->mem_start) << 3);
  935. break;
  936. #ifdef CONFIG_TC
  937. case PMAD_LANCE:
  938. dev_set_drvdata(bdev, dev);
  939. start = to_tc_dev(bdev)->resource.start;
  940. len = to_tc_dev(bdev)->resource.end - start + 1;
  941. if (!request_mem_region(start, len, bdev->bus_id)) {
  942. printk(KERN_ERR
  943. "%s: Unable to reserve MMIO resource\n",
  944. bdev->bus_id);
  945. ret = -EBUSY;
  946. goto err_out_dev;
  947. }
  948. dev->mem_start = CKSEG1ADDR(start);
  949. dev->mem_end = dev->mem_start + 0x100000;
  950. dev->base_addr = dev->mem_start + 0x100000;
  951. dev->irq = to_tc_dev(bdev)->interrupt;
  952. esar_base = dev->mem_start + 0x1c0002;
  953. lp->dma_irq = -1;
  954. for (i = 0; i < RX_RING_SIZE; i++) {
  955. lp->rx_buf_ptr_cpu[i] =
  956. (char *)(dev->mem_start + BUF_OFFSET_CPU +
  957. i * RX_BUFF_SIZE);
  958. lp->rx_buf_ptr_lnc[i] =
  959. (BUF_OFFSET_LNC + i * RX_BUFF_SIZE);
  960. }
  961. for (i = 0; i < TX_RING_SIZE; i++) {
  962. lp->tx_buf_ptr_cpu[i] =
  963. (char *)(dev->mem_start + BUF_OFFSET_CPU +
  964. RX_RING_SIZE * RX_BUFF_SIZE +
  965. i * TX_BUFF_SIZE);
  966. lp->tx_buf_ptr_lnc[i] =
  967. (BUF_OFFSET_LNC +
  968. RX_RING_SIZE * RX_BUFF_SIZE +
  969. i * TX_BUFF_SIZE);
  970. }
  971. break;
  972. #endif
  973. case PMAX_LANCE:
  974. dev->irq = dec_interrupt[DEC_IRQ_LANCE];
  975. dev->base_addr = CKSEG1ADDR(KN01_SLOT_BASE + KN01_LANCE);
  976. dev->mem_start = CKSEG1ADDR(KN01_SLOT_BASE + KN01_LANCE_MEM);
  977. dev->mem_end = dev->mem_start + KN01_SLOT_SIZE;
  978. esar_base = CKSEG1ADDR(KN01_SLOT_BASE + KN01_ESAR + 1);
  979. lp->dma_irq = -1;
  980. /*
  981. * setup the pointer arrays, this sucks [tm] :-(
  982. */
  983. for (i = 0; i < RX_RING_SIZE; i++) {
  984. lp->rx_buf_ptr_cpu[i] =
  985. (char *)(dev->mem_start + 2 * BUF_OFFSET_CPU +
  986. 2 * i * RX_BUFF_SIZE);
  987. lp->rx_buf_ptr_lnc[i] =
  988. (BUF_OFFSET_LNC + i * RX_BUFF_SIZE);
  989. }
  990. for (i = 0; i < TX_RING_SIZE; i++) {
  991. lp->tx_buf_ptr_cpu[i] =
  992. (char *)(dev->mem_start + 2 * BUF_OFFSET_CPU +
  993. 2 * RX_RING_SIZE * RX_BUFF_SIZE +
  994. 2 * i * TX_BUFF_SIZE);
  995. lp->tx_buf_ptr_lnc[i] =
  996. (BUF_OFFSET_LNC +
  997. RX_RING_SIZE * RX_BUFF_SIZE +
  998. i * TX_BUFF_SIZE);
  999. }
  1000. break;
  1001. default:
  1002. printk(KERN_ERR "%s: declance_init called with unknown type\n",
  1003. name);
  1004. ret = -ENODEV;
  1005. goto err_out_dev;
  1006. }
  1007. ll = (struct lance_regs *) dev->base_addr;
  1008. esar = (unsigned char *) esar_base;
  1009. /* prom checks */
  1010. /* First, check for test pattern */
  1011. if (esar[0x60] != 0xff && esar[0x64] != 0x00 &&
  1012. esar[0x68] != 0x55 && esar[0x6c] != 0xaa) {
  1013. printk(KERN_ERR
  1014. "%s: Ethernet station address prom not found!\n",
  1015. name);
  1016. ret = -ENODEV;
  1017. goto err_out_resource;
  1018. }
  1019. /* Check the prom contents */
  1020. for (i = 0; i < 8; i++) {
  1021. if (esar[i * 4] != esar[0x3c - i * 4] &&
  1022. esar[i * 4] != esar[0x40 + i * 4] &&
  1023. esar[0x3c - i * 4] != esar[0x40 + i * 4]) {
  1024. printk(KERN_ERR "%s: Something is wrong with the "
  1025. "ethernet station address prom!\n", name);
  1026. ret = -ENODEV;
  1027. goto err_out_resource;
  1028. }
  1029. }
  1030. /* Copy the ethernet address to the device structure, later to the
  1031. * lance initialization block so the lance gets it every time it's
  1032. * (re)initialized.
  1033. */
  1034. switch (type) {
  1035. case ASIC_LANCE:
  1036. printk("%s: IOASIC onboard LANCE, addr = ", name);
  1037. break;
  1038. case PMAD_LANCE:
  1039. printk("%s: PMAD-AA, addr = ", name);
  1040. break;
  1041. case PMAX_LANCE:
  1042. printk("%s: PMAX onboard LANCE, addr = ", name);
  1043. break;
  1044. }
  1045. for (i = 0; i < 6; i++) {
  1046. dev->dev_addr[i] = esar[i * 4];
  1047. printk("%2.2x%c", dev->dev_addr[i], i == 5 ? ',' : ':');
  1048. }
  1049. printk(" irq = %d\n", dev->irq);
  1050. dev->open = &lance_open;
  1051. dev->stop = &lance_close;
  1052. dev->hard_start_xmit = &lance_start_xmit;
  1053. dev->tx_timeout = &lance_tx_timeout;
  1054. dev->watchdog_timeo = 5*HZ;
  1055. dev->get_stats = &lance_get_stats;
  1056. dev->set_multicast_list = &lance_set_multicast;
  1057. /* lp->ll is the location of the registers for lance card */
  1058. lp->ll = ll;
  1059. /* busmaster_regval (CSR3) should be zero according to the PMAD-AA
  1060. * specification.
  1061. */
  1062. lp->busmaster_regval = 0;
  1063. dev->dma = 0;
  1064. /* We cannot sleep if the chip is busy during a
  1065. * multicast list update event, because such events
  1066. * can occur from interrupts (ex. IPv6). So we
  1067. * use a timer to try again later when necessary. -DaveM
  1068. */
  1069. init_timer(&lp->multicast_timer);
  1070. lp->multicast_timer.data = (unsigned long) dev;
  1071. lp->multicast_timer.function = &lance_set_multicast_retry;
  1072. ret = register_netdev(dev);
  1073. if (ret) {
  1074. printk(KERN_ERR
  1075. "%s: Unable to register netdev, aborting.\n", name);
  1076. goto err_out_resource;
  1077. }
  1078. if (!bdev) {
  1079. lp->next = root_lance_dev;
  1080. root_lance_dev = dev;
  1081. }
  1082. printk("%s: registered as %s.\n", name, dev->name);
  1083. return 0;
  1084. err_out_resource:
  1085. if (bdev)
  1086. release_mem_region(start, len);
  1087. err_out_dev:
  1088. free_netdev(dev);
  1089. err_out:
  1090. return ret;
  1091. }
  1092. static void __exit dec_lance_remove(struct device *bdev)
  1093. {
  1094. struct net_device *dev = dev_get_drvdata(bdev);
  1095. resource_size_t start, len;
  1096. unregister_netdev(dev);
  1097. start = to_tc_dev(bdev)->resource.start;
  1098. len = to_tc_dev(bdev)->resource.end - start + 1;
  1099. release_mem_region(start, len);
  1100. free_netdev(dev);
  1101. }
  1102. /* Find all the lance cards on the system and initialize them */
  1103. static int __init dec_lance_platform_probe(void)
  1104. {
  1105. int count = 0;
  1106. if (dec_interrupt[DEC_IRQ_LANCE] >= 0) {
  1107. if (dec_interrupt[DEC_IRQ_LANCE_MERR] >= 0) {
  1108. if (dec_lance_probe(NULL, ASIC_LANCE) >= 0)
  1109. count++;
  1110. } else if (!TURBOCHANNEL) {
  1111. if (dec_lance_probe(NULL, PMAX_LANCE) >= 0)
  1112. count++;
  1113. }
  1114. }
  1115. return (count > 0) ? 0 : -ENODEV;
  1116. }
  1117. static void __exit dec_lance_platform_remove(void)
  1118. {
  1119. while (root_lance_dev) {
  1120. struct net_device *dev = root_lance_dev;
  1121. struct lance_private *lp = netdev_priv(dev);
  1122. unregister_netdev(dev);
  1123. root_lance_dev = lp->next;
  1124. free_netdev(dev);
  1125. }
  1126. }
  1127. #ifdef CONFIG_TC
  1128. static int __init dec_lance_tc_probe(struct device *dev);
  1129. static int __exit dec_lance_tc_remove(struct device *dev);
  1130. static const struct tc_device_id dec_lance_tc_table[] = {
  1131. { "DEC ", "PMAD-AA " },
  1132. { }
  1133. };
  1134. MODULE_DEVICE_TABLE(tc, dec_lance_tc_table);
  1135. static struct tc_driver dec_lance_tc_driver = {
  1136. .id_table = dec_lance_tc_table,
  1137. .driver = {
  1138. .name = "declance",
  1139. .bus = &tc_bus_type,
  1140. .probe = dec_lance_tc_probe,
  1141. .remove = __exit_p(dec_lance_tc_remove),
  1142. },
  1143. };
  1144. static int __init dec_lance_tc_probe(struct device *dev)
  1145. {
  1146. int status = dec_lance_probe(dev, PMAD_LANCE);
  1147. if (!status)
  1148. get_device(dev);
  1149. return status;
  1150. }
  1151. static int __exit dec_lance_tc_remove(struct device *dev)
  1152. {
  1153. put_device(dev);
  1154. dec_lance_remove(dev);
  1155. return 0;
  1156. }
  1157. #endif
  1158. static int __init dec_lance_init(void)
  1159. {
  1160. int status;
  1161. status = tc_register_driver(&dec_lance_tc_driver);
  1162. if (!status)
  1163. dec_lance_platform_probe();
  1164. return status;
  1165. }
  1166. static void __exit dec_lance_exit(void)
  1167. {
  1168. dec_lance_platform_remove();
  1169. tc_unregister_driver(&dec_lance_tc_driver);
  1170. }
  1171. module_init(dec_lance_init);
  1172. module_exit(dec_lance_exit);