ariadne.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875
  1. /*
  2. * Amiga Linux/m68k Ariadne Ethernet Driver
  3. *
  4. * © Copyright 1995-2003 by Geert Uytterhoeven (geert@linux-m68k.org)
  5. * Peter De Schrijver (p2@mind.be)
  6. *
  7. * ---------------------------------------------------------------------------
  8. *
  9. * This program is based on
  10. *
  11. * lance.c: An AMD LANCE ethernet driver for linux.
  12. * Written 1993-94 by Donald Becker.
  13. *
  14. * Am79C960: PCnet(tm)-ISA Single-Chip Ethernet Controller
  15. * Advanced Micro Devices
  16. * Publication #16907, Rev. B, Amendment/0, May 1994
  17. *
  18. * MC68230: Parallel Interface/Timer (PI/T)
  19. * Motorola Semiconductors, December, 1983
  20. *
  21. * ---------------------------------------------------------------------------
  22. *
  23. * This file is subject to the terms and conditions of the GNU General Public
  24. * License. See the file COPYING in the main directory of the Linux
  25. * distribution for more details.
  26. *
  27. * ---------------------------------------------------------------------------
  28. *
  29. * The Ariadne is a Zorro-II board made by Village Tronic. It contains:
  30. *
  31. * - an Am79C960 PCnet-ISA Single-Chip Ethernet Controller with both
  32. * 10BASE-2 (thin coax) and 10BASE-T (UTP) connectors
  33. *
  34. * - an MC68230 Parallel Interface/Timer configured as 2 parallel ports
  35. */
  36. #include <linux/module.h>
  37. #include <linux/stddef.h>
  38. #include <linux/kernel.h>
  39. #include <linux/string.h>
  40. #include <linux/errno.h>
  41. #include <linux/ioport.h>
  42. #include <linux/slab.h>
  43. #include <linux/netdevice.h>
  44. #include <linux/etherdevice.h>
  45. #include <linux/interrupt.h>
  46. #include <linux/skbuff.h>
  47. #include <linux/init.h>
  48. #include <linux/zorro.h>
  49. #include <linux/bitops.h>
  50. #include <asm/amigaints.h>
  51. #include <asm/amigahw.h>
  52. #include <asm/irq.h>
  53. #include "ariadne.h"
  54. #ifdef ARIADNE_DEBUG
  55. int ariadne_debug = ARIADNE_DEBUG;
  56. #else
  57. int ariadne_debug = 1;
  58. #endif
  59. /*
  60. * Macros to Fix Endianness problems
  61. */
  62. /* Swap the Bytes in a WORD */
  63. #define swapw(x) (((x>>8)&0x00ff)|((x<<8)&0xff00))
  64. /* Get the Low BYTE in a WORD */
  65. #define lowb(x) (x&0xff)
  66. /* Get the Swapped High WORD in a LONG */
  67. #define swhighw(x) ((((x)>>8)&0xff00)|(((x)>>24)&0x00ff))
  68. /* Get the Swapped Low WORD in a LONG */
  69. #define swloww(x) ((((x)<<8)&0xff00)|(((x)>>8)&0x00ff))
  70. /*
  71. * Transmit/Receive Ring Definitions
  72. */
  73. #define TX_RING_SIZE 5
  74. #define RX_RING_SIZE 16
  75. #define PKT_BUF_SIZE 1520
  76. /*
  77. * Private Device Data
  78. */
  79. struct ariadne_private {
  80. volatile struct TDRE *tx_ring[TX_RING_SIZE];
  81. volatile struct RDRE *rx_ring[RX_RING_SIZE];
  82. volatile u_short *tx_buff[TX_RING_SIZE];
  83. volatile u_short *rx_buff[RX_RING_SIZE];
  84. int cur_tx, cur_rx; /* The next free ring entry */
  85. int dirty_tx; /* The ring entries to be free()ed. */
  86. struct net_device_stats stats;
  87. char tx_full;
  88. };
  89. /*
  90. * Structure Created in the Ariadne's RAM Buffer
  91. */
  92. struct lancedata {
  93. struct TDRE tx_ring[TX_RING_SIZE];
  94. struct RDRE rx_ring[RX_RING_SIZE];
  95. u_short tx_buff[TX_RING_SIZE][PKT_BUF_SIZE/sizeof(u_short)];
  96. u_short rx_buff[RX_RING_SIZE][PKT_BUF_SIZE/sizeof(u_short)];
  97. };
  98. static int ariadne_open(struct net_device *dev);
  99. static void ariadne_init_ring(struct net_device *dev);
  100. static int ariadne_start_xmit(struct sk_buff *skb, struct net_device *dev);
  101. static void ariadne_tx_timeout(struct net_device *dev);
  102. static int ariadne_rx(struct net_device *dev);
  103. static void ariadne_reset(struct net_device *dev);
  104. static irqreturn_t ariadne_interrupt(int irq, void *data);
  105. static int ariadne_close(struct net_device *dev);
  106. static struct net_device_stats *ariadne_get_stats(struct net_device *dev);
  107. #ifdef HAVE_MULTICAST
  108. static void set_multicast_list(struct net_device *dev);
  109. #endif
  110. static void memcpyw(volatile u_short *dest, u_short *src, int len)
  111. {
  112. while (len >= 2) {
  113. *(dest++) = *(src++);
  114. len -= 2;
  115. }
  116. if (len == 1)
  117. *dest = (*(u_char *)src)<<8;
  118. }
  119. static int __devinit ariadne_init_one(struct zorro_dev *z,
  120. const struct zorro_device_id *ent);
  121. static void __devexit ariadne_remove_one(struct zorro_dev *z);
  122. static struct zorro_device_id ariadne_zorro_tbl[] __devinitdata = {
  123. { ZORRO_PROD_VILLAGE_TRONIC_ARIADNE },
  124. { 0 }
  125. };
  126. static struct zorro_driver ariadne_driver = {
  127. .name = "ariadne",
  128. .id_table = ariadne_zorro_tbl,
  129. .probe = ariadne_init_one,
  130. .remove = __devexit_p(ariadne_remove_one),
  131. };
  132. static int __devinit ariadne_init_one(struct zorro_dev *z,
  133. const struct zorro_device_id *ent)
  134. {
  135. unsigned long board = z->resource.start;
  136. unsigned long base_addr = board+ARIADNE_LANCE;
  137. unsigned long mem_start = board+ARIADNE_RAM;
  138. struct resource *r1, *r2;
  139. struct net_device *dev;
  140. struct ariadne_private *priv;
  141. int err;
  142. r1 = request_mem_region(base_addr, sizeof(struct Am79C960), "Am79C960");
  143. if (!r1)
  144. return -EBUSY;
  145. r2 = request_mem_region(mem_start, ARIADNE_RAM_SIZE, "RAM");
  146. if (!r2) {
  147. release_resource(r1);
  148. return -EBUSY;
  149. }
  150. dev = alloc_etherdev(sizeof(struct ariadne_private));
  151. if (dev == NULL) {
  152. release_resource(r1);
  153. release_resource(r2);
  154. return -ENOMEM;
  155. }
  156. SET_MODULE_OWNER(dev);
  157. priv = netdev_priv(dev);
  158. r1->name = dev->name;
  159. r2->name = dev->name;
  160. dev->dev_addr[0] = 0x00;
  161. dev->dev_addr[1] = 0x60;
  162. dev->dev_addr[2] = 0x30;
  163. dev->dev_addr[3] = (z->rom.er_SerialNumber>>16) & 0xff;
  164. dev->dev_addr[4] = (z->rom.er_SerialNumber>>8) & 0xff;
  165. dev->dev_addr[5] = z->rom.er_SerialNumber & 0xff;
  166. dev->base_addr = ZTWO_VADDR(base_addr);
  167. dev->mem_start = ZTWO_VADDR(mem_start);
  168. dev->mem_end = dev->mem_start+ARIADNE_RAM_SIZE;
  169. dev->open = &ariadne_open;
  170. dev->stop = &ariadne_close;
  171. dev->hard_start_xmit = &ariadne_start_xmit;
  172. dev->tx_timeout = &ariadne_tx_timeout;
  173. dev->watchdog_timeo = 5*HZ;
  174. dev->get_stats = &ariadne_get_stats;
  175. dev->set_multicast_list = &set_multicast_list;
  176. err = register_netdev(dev);
  177. if (err) {
  178. release_resource(r1);
  179. release_resource(r2);
  180. free_netdev(dev);
  181. return err;
  182. }
  183. zorro_set_drvdata(z, dev);
  184. printk(KERN_INFO "%s: Ariadne at 0x%08lx, Ethernet Address "
  185. "%02x:%02x:%02x:%02x:%02x:%02x\n", dev->name, board,
  186. dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
  187. dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
  188. return 0;
  189. }
  190. static int ariadne_open(struct net_device *dev)
  191. {
  192. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  193. u_short in;
  194. u_long version;
  195. int i;
  196. /* Reset the LANCE */
  197. in = lance->Reset;
  198. /* Stop the LANCE */
  199. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  200. lance->RDP = STOP;
  201. /* Check the LANCE version */
  202. lance->RAP = CSR88; /* Chip ID */
  203. version = swapw(lance->RDP);
  204. lance->RAP = CSR89; /* Chip ID */
  205. version |= swapw(lance->RDP)<<16;
  206. if ((version & 0x00000fff) != 0x00000003) {
  207. printk(KERN_WARNING "ariadne_open: Couldn't find AMD Ethernet Chip\n");
  208. return -EAGAIN;
  209. }
  210. if ((version & 0x0ffff000) != 0x00003000) {
  211. printk(KERN_WARNING "ariadne_open: Couldn't find Am79C960 (Wrong part "
  212. "number = %ld)\n", (version & 0x0ffff000)>>12);
  213. return -EAGAIN;
  214. }
  215. #if 0
  216. printk(KERN_DEBUG "ariadne_open: Am79C960 (PCnet-ISA) Revision %ld\n",
  217. (version & 0xf0000000)>>28);
  218. #endif
  219. ariadne_init_ring(dev);
  220. /* Miscellaneous Stuff */
  221. lance->RAP = CSR3; /* Interrupt Masks and Deferral Control */
  222. lance->RDP = 0x0000;
  223. lance->RAP = CSR4; /* Test and Features Control */
  224. lance->RDP = DPOLL|APAD_XMT|MFCOM|RCVCCOM|TXSTRTM|JABM;
  225. /* Set the Multicast Table */
  226. lance->RAP = CSR8; /* Logical Address Filter, LADRF[15:0] */
  227. lance->RDP = 0x0000;
  228. lance->RAP = CSR9; /* Logical Address Filter, LADRF[31:16] */
  229. lance->RDP = 0x0000;
  230. lance->RAP = CSR10; /* Logical Address Filter, LADRF[47:32] */
  231. lance->RDP = 0x0000;
  232. lance->RAP = CSR11; /* Logical Address Filter, LADRF[63:48] */
  233. lance->RDP = 0x0000;
  234. /* Set the Ethernet Hardware Address */
  235. lance->RAP = CSR12; /* Physical Address Register, PADR[15:0] */
  236. lance->RDP = ((u_short *)&dev->dev_addr[0])[0];
  237. lance->RAP = CSR13; /* Physical Address Register, PADR[31:16] */
  238. lance->RDP = ((u_short *)&dev->dev_addr[0])[1];
  239. lance->RAP = CSR14; /* Physical Address Register, PADR[47:32] */
  240. lance->RDP = ((u_short *)&dev->dev_addr[0])[2];
  241. /* Set the Init Block Mode */
  242. lance->RAP = CSR15; /* Mode Register */
  243. lance->RDP = 0x0000;
  244. /* Set the Transmit Descriptor Ring Pointer */
  245. lance->RAP = CSR30; /* Base Address of Transmit Ring */
  246. lance->RDP = swloww(ARIADNE_RAM+offsetof(struct lancedata, tx_ring));
  247. lance->RAP = CSR31; /* Base Address of transmit Ring */
  248. lance->RDP = swhighw(ARIADNE_RAM+offsetof(struct lancedata, tx_ring));
  249. /* Set the Receive Descriptor Ring Pointer */
  250. lance->RAP = CSR24; /* Base Address of Receive Ring */
  251. lance->RDP = swloww(ARIADNE_RAM+offsetof(struct lancedata, rx_ring));
  252. lance->RAP = CSR25; /* Base Address of Receive Ring */
  253. lance->RDP = swhighw(ARIADNE_RAM+offsetof(struct lancedata, rx_ring));
  254. /* Set the Number of RX and TX Ring Entries */
  255. lance->RAP = CSR76; /* Receive Ring Length */
  256. lance->RDP = swapw(((u_short)-RX_RING_SIZE));
  257. lance->RAP = CSR78; /* Transmit Ring Length */
  258. lance->RDP = swapw(((u_short)-TX_RING_SIZE));
  259. /* Enable Media Interface Port Auto Select (10BASE-2/10BASE-T) */
  260. lance->RAP = ISACSR2; /* Miscellaneous Configuration */
  261. lance->IDP = ASEL;
  262. /* LED Control */
  263. lance->RAP = ISACSR5; /* LED1 Status */
  264. lance->IDP = PSE|XMTE;
  265. lance->RAP = ISACSR6; /* LED2 Status */
  266. lance->IDP = PSE|COLE;
  267. lance->RAP = ISACSR7; /* LED3 Status */
  268. lance->IDP = PSE|RCVE;
  269. netif_start_queue(dev);
  270. i = request_irq(IRQ_AMIGA_PORTS, ariadne_interrupt, IRQF_SHARED,
  271. dev->name, dev);
  272. if (i) return i;
  273. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  274. lance->RDP = INEA|STRT;
  275. return 0;
  276. }
  277. static void ariadne_init_ring(struct net_device *dev)
  278. {
  279. struct ariadne_private *priv = netdev_priv(dev);
  280. volatile struct lancedata *lancedata = (struct lancedata *)dev->mem_start;
  281. int i;
  282. netif_stop_queue(dev);
  283. priv->tx_full = 0;
  284. priv->cur_rx = priv->cur_tx = 0;
  285. priv->dirty_tx = 0;
  286. /* Set up TX Ring */
  287. for (i = 0; i < TX_RING_SIZE; i++) {
  288. volatile struct TDRE *t = &lancedata->tx_ring[i];
  289. t->TMD0 = swloww(ARIADNE_RAM+offsetof(struct lancedata, tx_buff[i]));
  290. t->TMD1 = swhighw(ARIADNE_RAM+offsetof(struct lancedata, tx_buff[i])) |
  291. TF_STP | TF_ENP;
  292. t->TMD2 = swapw((u_short)-PKT_BUF_SIZE);
  293. t->TMD3 = 0;
  294. priv->tx_ring[i] = &lancedata->tx_ring[i];
  295. priv->tx_buff[i] = lancedata->tx_buff[i];
  296. #if 0
  297. printk(KERN_DEBUG "TX Entry %2d at %p, Buf at %p\n", i,
  298. &lancedata->tx_ring[i], lancedata->tx_buff[i]);
  299. #endif
  300. }
  301. /* Set up RX Ring */
  302. for (i = 0; i < RX_RING_SIZE; i++) {
  303. volatile struct RDRE *r = &lancedata->rx_ring[i];
  304. r->RMD0 = swloww(ARIADNE_RAM+offsetof(struct lancedata, rx_buff[i]));
  305. r->RMD1 = swhighw(ARIADNE_RAM+offsetof(struct lancedata, rx_buff[i])) |
  306. RF_OWN;
  307. r->RMD2 = swapw((u_short)-PKT_BUF_SIZE);
  308. r->RMD3 = 0x0000;
  309. priv->rx_ring[i] = &lancedata->rx_ring[i];
  310. priv->rx_buff[i] = lancedata->rx_buff[i];
  311. #if 0
  312. printk(KERN_DEBUG "RX Entry %2d at %p, Buf at %p\n", i,
  313. &lancedata->rx_ring[i], lancedata->rx_buff[i]);
  314. #endif
  315. }
  316. }
  317. static int ariadne_close(struct net_device *dev)
  318. {
  319. struct ariadne_private *priv = netdev_priv(dev);
  320. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  321. netif_stop_queue(dev);
  322. lance->RAP = CSR112; /* Missed Frame Count */
  323. priv->stats.rx_missed_errors = swapw(lance->RDP);
  324. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  325. if (ariadne_debug > 1) {
  326. printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n",
  327. dev->name, lance->RDP);
  328. printk(KERN_DEBUG "%s: %lu packets missed\n", dev->name,
  329. priv->stats.rx_missed_errors);
  330. }
  331. /* We stop the LANCE here -- it occasionally polls memory if we don't. */
  332. lance->RDP = STOP;
  333. free_irq(IRQ_AMIGA_PORTS, dev);
  334. return 0;
  335. }
  336. static inline void ariadne_reset(struct net_device *dev)
  337. {
  338. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  339. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  340. lance->RDP = STOP;
  341. ariadne_init_ring(dev);
  342. lance->RDP = INEA|STRT;
  343. netif_start_queue(dev);
  344. }
  345. static irqreturn_t ariadne_interrupt(int irq, void *data)
  346. {
  347. struct net_device *dev = (struct net_device *)data;
  348. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  349. struct ariadne_private *priv;
  350. int csr0, boguscnt;
  351. int handled = 0;
  352. if (dev == NULL) {
  353. printk(KERN_WARNING "ariadne_interrupt(): irq for unknown device.\n");
  354. return IRQ_NONE;
  355. }
  356. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  357. if (!(lance->RDP & INTR)) /* Check if any interrupt has been */
  358. return IRQ_NONE; /* generated by the board. */
  359. priv = netdev_priv(dev);
  360. boguscnt = 10;
  361. while ((csr0 = lance->RDP) & (ERR|RINT|TINT) && --boguscnt >= 0) {
  362. /* Acknowledge all of the current interrupt sources ASAP. */
  363. lance->RDP = csr0 & ~(INEA|TDMD|STOP|STRT|INIT);
  364. #if 0
  365. if (ariadne_debug > 5) {
  366. printk(KERN_DEBUG "%s: interrupt csr0=%#2.2x new csr=%#2.2x.",
  367. dev->name, csr0, lance->RDP);
  368. printk("[");
  369. if (csr0 & INTR)
  370. printk(" INTR");
  371. if (csr0 & INEA)
  372. printk(" INEA");
  373. if (csr0 & RXON)
  374. printk(" RXON");
  375. if (csr0 & TXON)
  376. printk(" TXON");
  377. if (csr0 & TDMD)
  378. printk(" TDMD");
  379. if (csr0 & STOP)
  380. printk(" STOP");
  381. if (csr0 & STRT)
  382. printk(" STRT");
  383. if (csr0 & INIT)
  384. printk(" INIT");
  385. if (csr0 & ERR)
  386. printk(" ERR");
  387. if (csr0 & BABL)
  388. printk(" BABL");
  389. if (csr0 & CERR)
  390. printk(" CERR");
  391. if (csr0 & MISS)
  392. printk(" MISS");
  393. if (csr0 & MERR)
  394. printk(" MERR");
  395. if (csr0 & RINT)
  396. printk(" RINT");
  397. if (csr0 & TINT)
  398. printk(" TINT");
  399. if (csr0 & IDON)
  400. printk(" IDON");
  401. printk(" ]\n");
  402. }
  403. #endif
  404. if (csr0 & RINT) { /* Rx interrupt */
  405. handled = 1;
  406. ariadne_rx(dev);
  407. }
  408. if (csr0 & TINT) { /* Tx-done interrupt */
  409. int dirty_tx = priv->dirty_tx;
  410. handled = 1;
  411. while (dirty_tx < priv->cur_tx) {
  412. int entry = dirty_tx % TX_RING_SIZE;
  413. int status = lowb(priv->tx_ring[entry]->TMD1);
  414. if (status & TF_OWN)
  415. break; /* It still hasn't been Txed */
  416. priv->tx_ring[entry]->TMD1 &= 0xff00;
  417. if (status & TF_ERR) {
  418. /* There was an major error, log it. */
  419. int err_status = priv->tx_ring[entry]->TMD3;
  420. priv->stats.tx_errors++;
  421. if (err_status & EF_RTRY)
  422. priv->stats.tx_aborted_errors++;
  423. if (err_status & EF_LCAR)
  424. priv->stats.tx_carrier_errors++;
  425. if (err_status & EF_LCOL)
  426. priv->stats.tx_window_errors++;
  427. if (err_status & EF_UFLO) {
  428. /* Ackk! On FIFO errors the Tx unit is turned off! */
  429. priv->stats.tx_fifo_errors++;
  430. /* Remove this verbosity later! */
  431. printk(KERN_ERR "%s: Tx FIFO error! Status %4.4x.\n",
  432. dev->name, csr0);
  433. /* Restart the chip. */
  434. lance->RDP = STRT;
  435. }
  436. } else {
  437. if (status & (TF_MORE|TF_ONE))
  438. priv->stats.collisions++;
  439. priv->stats.tx_packets++;
  440. }
  441. dirty_tx++;
  442. }
  443. #ifndef final_version
  444. if (priv->cur_tx - dirty_tx >= TX_RING_SIZE) {
  445. printk(KERN_ERR "out-of-sync dirty pointer, %d vs. %d, "
  446. "full=%d.\n", dirty_tx, priv->cur_tx, priv->tx_full);
  447. dirty_tx += TX_RING_SIZE;
  448. }
  449. #endif
  450. if (priv->tx_full && netif_queue_stopped(dev) &&
  451. dirty_tx > priv->cur_tx - TX_RING_SIZE + 2) {
  452. /* The ring is no longer full. */
  453. priv->tx_full = 0;
  454. netif_wake_queue(dev);
  455. }
  456. priv->dirty_tx = dirty_tx;
  457. }
  458. /* Log misc errors. */
  459. if (csr0 & BABL) {
  460. handled = 1;
  461. priv->stats.tx_errors++; /* Tx babble. */
  462. }
  463. if (csr0 & MISS) {
  464. handled = 1;
  465. priv->stats.rx_errors++; /* Missed a Rx frame. */
  466. }
  467. if (csr0 & MERR) {
  468. handled = 1;
  469. printk(KERN_ERR "%s: Bus master arbitration failure, status "
  470. "%4.4x.\n", dev->name, csr0);
  471. /* Restart the chip. */
  472. lance->RDP = STRT;
  473. }
  474. }
  475. /* Clear any other interrupt, and set interrupt enable. */
  476. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  477. lance->RDP = INEA|BABL|CERR|MISS|MERR|IDON;
  478. #if 0
  479. if (ariadne_debug > 4)
  480. printk(KERN_DEBUG "%s: exiting interrupt, csr%d=%#4.4x.\n", dev->name,
  481. lance->RAP, lance->RDP);
  482. #endif
  483. return IRQ_RETVAL(handled);
  484. }
  485. static void ariadne_tx_timeout(struct net_device *dev)
  486. {
  487. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  488. printk(KERN_ERR "%s: transmit timed out, status %4.4x, resetting.\n",
  489. dev->name, lance->RDP);
  490. ariadne_reset(dev);
  491. netif_wake_queue(dev);
  492. }
  493. static int ariadne_start_xmit(struct sk_buff *skb, struct net_device *dev)
  494. {
  495. struct ariadne_private *priv = netdev_priv(dev);
  496. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  497. int entry;
  498. unsigned long flags;
  499. int len = skb->len;
  500. #if 0
  501. if (ariadne_debug > 3) {
  502. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  503. printk(KERN_DEBUG "%s: ariadne_start_xmit() called, csr0 %4.4x.\n",
  504. dev->name, lance->RDP);
  505. lance->RDP = 0x0000;
  506. }
  507. #endif
  508. /* FIXME: is the 79C960 new enough to do its own padding right ? */
  509. if (skb->len < ETH_ZLEN)
  510. {
  511. if (skb_padto(skb, ETH_ZLEN))
  512. return 0;
  513. len = ETH_ZLEN;
  514. }
  515. /* Fill in a Tx ring entry */
  516. #if 0
  517. printk(KERN_DEBUG "TX pkt type 0x%04x from ", ((u_short *)skb->data)[6]);
  518. {
  519. int i;
  520. u_char *ptr = &((u_char *)skb->data)[6];
  521. for (i = 0; i < 6; i++)
  522. printk("%02x", ptr[i]);
  523. }
  524. printk(" to ");
  525. {
  526. int i;
  527. u_char *ptr = (u_char *)skb->data;
  528. for (i = 0; i < 6; i++)
  529. printk("%02x", ptr[i]);
  530. }
  531. printk(" data 0x%08x len %d\n", (int)skb->data, (int)skb->len);
  532. #endif
  533. local_irq_save(flags);
  534. entry = priv->cur_tx % TX_RING_SIZE;
  535. /* Caution: the write order is important here, set the base address with
  536. the "ownership" bits last. */
  537. priv->tx_ring[entry]->TMD2 = swapw((u_short)-skb->len);
  538. priv->tx_ring[entry]->TMD3 = 0x0000;
  539. memcpyw(priv->tx_buff[entry], (u_short *)skb->data, len);
  540. #if 0
  541. {
  542. int i, len;
  543. len = skb->len > 64 ? 64 : skb->len;
  544. len >>= 1;
  545. for (i = 0; i < len; i += 8) {
  546. int j;
  547. printk(KERN_DEBUG "%04x:", i);
  548. for (j = 0; (j < 8) && ((i+j) < len); j++) {
  549. if (!(j & 1))
  550. printk(" ");
  551. printk("%04x", priv->tx_buff[entry][i+j]);
  552. }
  553. printk("\n");
  554. }
  555. }
  556. #endif
  557. priv->tx_ring[entry]->TMD1 = (priv->tx_ring[entry]->TMD1&0xff00)|TF_OWN|TF_STP|TF_ENP;
  558. dev_kfree_skb(skb);
  559. priv->cur_tx++;
  560. if ((priv->cur_tx >= TX_RING_SIZE) && (priv->dirty_tx >= TX_RING_SIZE)) {
  561. #if 0
  562. printk(KERN_DEBUG "*** Subtracting TX_RING_SIZE from cur_tx (%d) and "
  563. "dirty_tx (%d)\n", priv->cur_tx, priv->dirty_tx);
  564. #endif
  565. priv->cur_tx -= TX_RING_SIZE;
  566. priv->dirty_tx -= TX_RING_SIZE;
  567. }
  568. /* Trigger an immediate send poll. */
  569. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  570. lance->RDP = INEA|TDMD;
  571. dev->trans_start = jiffies;
  572. if (lowb(priv->tx_ring[(entry+1) % TX_RING_SIZE]->TMD1) != 0) {
  573. netif_stop_queue(dev);
  574. priv->tx_full = 1;
  575. }
  576. local_irq_restore(flags);
  577. return 0;
  578. }
  579. static int ariadne_rx(struct net_device *dev)
  580. {
  581. struct ariadne_private *priv = netdev_priv(dev);
  582. int entry = priv->cur_rx % RX_RING_SIZE;
  583. int i;
  584. /* If we own the next entry, it's a new packet. Send it up. */
  585. while (!(lowb(priv->rx_ring[entry]->RMD1) & RF_OWN)) {
  586. int status = lowb(priv->rx_ring[entry]->RMD1);
  587. if (status != (RF_STP|RF_ENP)) { /* There was an error. */
  588. /* There is a tricky error noted by John Murphy,
  589. <murf@perftech.com> to Russ Nelson: Even with full-sized
  590. buffers it's possible for a jabber packet to use two
  591. buffers, with only the last correctly noting the error. */
  592. if (status & RF_ENP)
  593. /* Only count a general error at the end of a packet.*/
  594. priv->stats.rx_errors++;
  595. if (status & RF_FRAM)
  596. priv->stats.rx_frame_errors++;
  597. if (status & RF_OFLO)
  598. priv->stats.rx_over_errors++;
  599. if (status & RF_CRC)
  600. priv->stats.rx_crc_errors++;
  601. if (status & RF_BUFF)
  602. priv->stats.rx_fifo_errors++;
  603. priv->rx_ring[entry]->RMD1 &= 0xff00|RF_STP|RF_ENP;
  604. } else {
  605. /* Malloc up new buffer, compatible with net-3. */
  606. short pkt_len = swapw(priv->rx_ring[entry]->RMD3);
  607. struct sk_buff *skb;
  608. skb = dev_alloc_skb(pkt_len+2);
  609. if (skb == NULL) {
  610. printk(KERN_WARNING "%s: Memory squeeze, deferring packet.\n",
  611. dev->name);
  612. for (i = 0; i < RX_RING_SIZE; i++)
  613. if (lowb(priv->rx_ring[(entry+i) % RX_RING_SIZE]->RMD1) & RF_OWN)
  614. break;
  615. if (i > RX_RING_SIZE-2) {
  616. priv->stats.rx_dropped++;
  617. priv->rx_ring[entry]->RMD1 |= RF_OWN;
  618. priv->cur_rx++;
  619. }
  620. break;
  621. }
  622. skb->dev = dev;
  623. skb_reserve(skb,2); /* 16 byte align */
  624. skb_put(skb,pkt_len); /* Make room */
  625. eth_copy_and_sum(skb, (char *)priv->rx_buff[entry], pkt_len,0);
  626. skb->protocol=eth_type_trans(skb,dev);
  627. #if 0
  628. printk(KERN_DEBUG "RX pkt type 0x%04x from ",
  629. ((u_short *)skb->data)[6]);
  630. {
  631. int i;
  632. u_char *ptr = &((u_char *)skb->data)[6];
  633. for (i = 0; i < 6; i++)
  634. printk("%02x", ptr[i]);
  635. }
  636. printk(" to ");
  637. {
  638. int i;
  639. u_char *ptr = (u_char *)skb->data;
  640. for (i = 0; i < 6; i++)
  641. printk("%02x", ptr[i]);
  642. }
  643. printk(" data 0x%08x len %d\n", (int)skb->data, (int)skb->len);
  644. #endif
  645. netif_rx(skb);
  646. dev->last_rx = jiffies;
  647. priv->stats.rx_packets++;
  648. priv->stats.rx_bytes += pkt_len;
  649. }
  650. priv->rx_ring[entry]->RMD1 |= RF_OWN;
  651. entry = (++priv->cur_rx) % RX_RING_SIZE;
  652. }
  653. priv->cur_rx = priv->cur_rx % RX_RING_SIZE;
  654. /* We should check that at least two ring entries are free. If not,
  655. we should free one and mark stats->rx_dropped++. */
  656. return 0;
  657. }
  658. static struct net_device_stats *ariadne_get_stats(struct net_device *dev)
  659. {
  660. struct ariadne_private *priv = netdev_priv(dev);
  661. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  662. short saved_addr;
  663. unsigned long flags;
  664. local_irq_save(flags);
  665. saved_addr = lance->RAP;
  666. lance->RAP = CSR112; /* Missed Frame Count */
  667. priv->stats.rx_missed_errors = swapw(lance->RDP);
  668. lance->RAP = saved_addr;
  669. local_irq_restore(flags);
  670. return &priv->stats;
  671. }
  672. /* Set or clear the multicast filter for this adaptor.
  673. num_addrs == -1 Promiscuous mode, receive all packets
  674. num_addrs == 0 Normal mode, clear multicast list
  675. num_addrs > 0 Multicast mode, receive normal and MC packets, and do
  676. best-effort filtering.
  677. */
  678. static void set_multicast_list(struct net_device *dev)
  679. {
  680. volatile struct Am79C960 *lance = (struct Am79C960*)dev->base_addr;
  681. if (!netif_running(dev))
  682. return;
  683. netif_stop_queue(dev);
  684. /* We take the simple way out and always enable promiscuous mode. */
  685. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  686. lance->RDP = STOP; /* Temporarily stop the lance. */
  687. ariadne_init_ring(dev);
  688. if (dev->flags & IFF_PROMISC) {
  689. lance->RAP = CSR15; /* Mode Register */
  690. lance->RDP = PROM; /* Set promiscuous mode */
  691. } else {
  692. short multicast_table[4];
  693. int num_addrs = dev->mc_count;
  694. int i;
  695. /* We don't use the multicast table, but rely on upper-layer filtering. */
  696. memset(multicast_table, (num_addrs == 0) ? 0 : -1,
  697. sizeof(multicast_table));
  698. for (i = 0; i < 4; i++) {
  699. lance->RAP = CSR8+(i<<8); /* Logical Address Filter */
  700. lance->RDP = swapw(multicast_table[i]);
  701. }
  702. lance->RAP = CSR15; /* Mode Register */
  703. lance->RDP = 0x0000; /* Unset promiscuous mode */
  704. }
  705. lance->RAP = CSR0; /* PCnet-ISA Controller Status */
  706. lance->RDP = INEA|STRT|IDON; /* Resume normal operation. */
  707. netif_wake_queue(dev);
  708. }
  709. static void __devexit ariadne_remove_one(struct zorro_dev *z)
  710. {
  711. struct net_device *dev = zorro_get_drvdata(z);
  712. unregister_netdev(dev);
  713. release_mem_region(ZTWO_PADDR(dev->base_addr), sizeof(struct Am79C960));
  714. release_mem_region(ZTWO_PADDR(dev->mem_start), ARIADNE_RAM_SIZE);
  715. free_netdev(dev);
  716. }
  717. static int __init ariadne_init_module(void)
  718. {
  719. return zorro_register_driver(&ariadne_driver);
  720. }
  721. static void __exit ariadne_cleanup_module(void)
  722. {
  723. zorro_unregister_driver(&ariadne_driver);
  724. }
  725. module_init(ariadne_init_module);
  726. module_exit(ariadne_cleanup_module);
  727. MODULE_LICENSE("GPL");