de620.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047
  1. /*
  2. * de620.c $Revision: 1.1.1.1 $ BETA
  3. *
  4. *
  5. * Linux driver for the D-Link DE-620 Ethernet pocket adapter.
  6. *
  7. * Portions (C) Copyright 1993, 1994 by Bjorn Ekwall <bj0rn@blox.se>
  8. *
  9. * Based on adapter information gathered from DOS packetdriver
  10. * sources from D-Link Inc: (Special thanks to Henry Ngai of D-Link.)
  11. * Portions (C) Copyright D-Link SYSTEM Inc. 1991, 1992
  12. * Copyright, 1988, Russell Nelson, Crynwr Software
  13. *
  14. * Adapted to the sample network driver core for linux,
  15. * written by: Donald Becker <becker@super.org>
  16. * (Now at <becker@scyld.com>)
  17. *
  18. * Valuable assistance from:
  19. * J. Joshua Kopper <kopper@rtsg.mot.com>
  20. * Olav Kvittem <Olav.Kvittem@uninett.no>
  21. * Germano Caronni <caronni@nessie.cs.id.ethz.ch>
  22. * Jeremy Fitzhardinge <jeremy@suite.sw.oz.au>
  23. *
  24. *****************************************************************************/
  25. /*
  26. * This program is free software; you can redistribute it and/or modify
  27. * it under the terms of the GNU General Public License as published by
  28. * the Free Software Foundation; either version 2, or (at your option)
  29. * any later version.
  30. *
  31. * This program is distributed in the hope that it will be useful,
  32. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  33. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  34. * GNU General Public License for more details.
  35. *
  36. * You should have received a copy of the GNU General Public License
  37. * along with this program; if not, write to the Free Software
  38. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  39. *
  40. *****************************************************************************/
  41. static const char version[] =
  42. "de620.c: $Revision: 1.1.1.1 $, Bjorn Ekwall <bj0rn@blox.se>\n";
  43. /***********************************************************************
  44. *
  45. * "Tuning" section.
  46. *
  47. * Compile-time options: (see below for descriptions)
  48. * -DDE620_IO=0x378 (lpt1)
  49. * -DDE620_IRQ=7 (lpt1)
  50. * -DDE602_DEBUG=...
  51. * -DSHUTDOWN_WHEN_LOST
  52. * -DCOUNT_LOOPS
  53. * -DLOWSPEED
  54. * -DREAD_DELAY
  55. * -DWRITE_DELAY
  56. */
  57. /*
  58. * This driver assumes that the printer port is a "normal",
  59. * dumb, uni-directional port!
  60. * If your port is "fancy" in any way, please try to set it to "normal"
  61. * with your BIOS setup. I have no access to machines with bi-directional
  62. * ports, so I can't test such a driver :-(
  63. * (Yes, I _know_ it is possible to use DE620 with bidirectional ports...)
  64. *
  65. * There are some clones of DE620 out there, with different names.
  66. * If the current driver does not recognize a clone, try to change
  67. * the following #define to:
  68. *
  69. * #define DE620_CLONE 1
  70. */
  71. #define DE620_CLONE 0
  72. /*
  73. * If the adapter has problems with high speeds, enable this #define
  74. * otherwise full printerport speed will be attempted.
  75. *
  76. * You can tune the READ_DELAY/WRITE_DELAY below if you enable LOWSPEED
  77. *
  78. #define LOWSPEED
  79. */
  80. #ifndef READ_DELAY
  81. #define READ_DELAY 100 /* adapter internal read delay in 100ns units */
  82. #endif
  83. #ifndef WRITE_DELAY
  84. #define WRITE_DELAY 100 /* adapter internal write delay in 100ns units */
  85. #endif
  86. /*
  87. * Enable this #define if you want the adapter to do a "ifconfig down" on
  88. * itself when we have detected that something is possibly wrong with it.
  89. * The default behaviour is to retry with "adapter_init()" until success.
  90. * This should be used for debugging purposes only.
  91. *
  92. #define SHUTDOWN_WHEN_LOST
  93. */
  94. /*
  95. * Enable debugging by "-DDE620_DEBUG=3" when compiling,
  96. * OR by enabling the following #define
  97. *
  98. * use 0 for production, 1 for verification, >2 for debug
  99. *
  100. #define DE620_DEBUG 3
  101. */
  102. #ifdef LOWSPEED
  103. /*
  104. * Enable this #define if you want to see debugging output that show how long
  105. * we have to wait before the DE-620 is ready for the next read/write/command.
  106. *
  107. #define COUNT_LOOPS
  108. */
  109. #endif
  110. #include <linux/module.h>
  111. #include <linux/kernel.h>
  112. #include <linux/types.h>
  113. #include <linux/fcntl.h>
  114. #include <linux/string.h>
  115. #include <linux/interrupt.h>
  116. #include <linux/ioport.h>
  117. #include <linux/in.h>
  118. #include <linux/errno.h>
  119. #include <linux/init.h>
  120. #include <linux/inet.h>
  121. #include <linux/netdevice.h>
  122. #include <linux/etherdevice.h>
  123. #include <linux/skbuff.h>
  124. #include <asm/io.h>
  125. #include <asm/system.h>
  126. /* Constant definitions for the DE-620 registers, commands and bits */
  127. #include "de620.h"
  128. typedef unsigned char byte;
  129. /*******************************************************
  130. * *
  131. * Definition of D-Link DE-620 Ethernet Pocket adapter *
  132. * See also "de620.h" *
  133. * *
  134. *******************************************************/
  135. #ifndef DE620_IO /* Compile-time configurable */
  136. #define DE620_IO 0x378
  137. #endif
  138. #ifndef DE620_IRQ /* Compile-time configurable */
  139. #define DE620_IRQ 7
  140. #endif
  141. #define DATA_PORT (dev->base_addr)
  142. #define STATUS_PORT (dev->base_addr + 1)
  143. #define COMMAND_PORT (dev->base_addr + 2)
  144. #define RUNT 60 /* Too small Ethernet packet */
  145. #define GIANT 1514 /* largest legal size packet, no fcs */
  146. #ifdef DE620_DEBUG /* Compile-time configurable */
  147. #define PRINTK(x) if (de620_debug >= 2) printk x
  148. #else
  149. #define DE620_DEBUG 0
  150. #define PRINTK(x) /**/
  151. #endif
  152. /*
  153. * Force media with insmod:
  154. * insmod de620.o bnc=1
  155. * or
  156. * insmod de620.o utp=1
  157. *
  158. * Force io and/or irq with insmod:
  159. * insmod de620.o io=0x378 irq=7
  160. *
  161. * Make a clone skip the Ethernet-address range check:
  162. * insmod de620.o clone=1
  163. */
  164. static int bnc;
  165. static int utp;
  166. static int io = DE620_IO;
  167. static int irq = DE620_IRQ;
  168. static int clone = DE620_CLONE;
  169. static unsigned int de620_debug = DE620_DEBUG;
  170. static spinlock_t de620_lock;
  171. module_param(bnc, int, 0);
  172. module_param(utp, int, 0);
  173. module_param(io, int, 0);
  174. module_param(irq, int, 0);
  175. module_param(clone, int, 0);
  176. module_param(de620_debug, int, 0);
  177. MODULE_PARM_DESC(bnc, "DE-620 set BNC medium (0-1)");
  178. MODULE_PARM_DESC(utp, "DE-620 set UTP medium (0-1)");
  179. MODULE_PARM_DESC(io, "DE-620 I/O base address,required");
  180. MODULE_PARM_DESC(irq, "DE-620 IRQ number,required");
  181. MODULE_PARM_DESC(clone, "Check also for non-D-Link DE-620 clones (0-1)");
  182. MODULE_PARM_DESC(de620_debug, "DE-620 debug level (0-2)");
  183. /***********************************************
  184. * *
  185. * Index to functions, as function prototypes. *
  186. * *
  187. ***********************************************/
  188. /*
  189. * Routines used internally. (See also "convenience macros.. below")
  190. */
  191. /* Put in the device structure. */
  192. static int de620_open(struct net_device *);
  193. static int de620_close(struct net_device *);
  194. static struct net_device_stats *get_stats(struct net_device *);
  195. static void de620_set_multicast_list(struct net_device *);
  196. static int de620_start_xmit(struct sk_buff *, struct net_device *);
  197. /* Dispatch from interrupts. */
  198. static irqreturn_t de620_interrupt(int, void *);
  199. static int de620_rx_intr(struct net_device *);
  200. /* Initialization */
  201. static int adapter_init(struct net_device *);
  202. static int read_eeprom(struct net_device *);
  203. /*
  204. * D-Link driver variables:
  205. */
  206. #define SCR_DEF NIBBLEMODE |INTON | SLEEP | AUTOTX
  207. #define TCR_DEF RXPB /* not used: | TXSUCINT | T16INT */
  208. #define DE620_RX_START_PAGE 12 /* 12 pages (=3k) reserved for tx */
  209. #define DEF_NIC_CMD IRQEN | ICEN | DS1
  210. static volatile byte NIC_Cmd;
  211. static volatile byte next_rx_page;
  212. static byte first_rx_page;
  213. static byte last_rx_page;
  214. static byte EIPRegister;
  215. static struct nic {
  216. byte NodeID[6];
  217. byte RAM_Size;
  218. byte Model;
  219. byte Media;
  220. byte SCR;
  221. } nic_data;
  222. /**********************************************************
  223. * *
  224. * Convenience macros/functions for D-Link DE-620 adapter *
  225. * *
  226. **********************************************************/
  227. #define de620_tx_buffs(dd) (inb(STATUS_PORT) & (TXBF0 | TXBF1))
  228. #define de620_flip_ds(dd) NIC_Cmd ^= DS0 | DS1; outb(NIC_Cmd, COMMAND_PORT);
  229. /* Check for ready-status, and return a nibble (high 4 bits) for data input */
  230. #ifdef COUNT_LOOPS
  231. static int tot_cnt;
  232. #endif
  233. static inline byte
  234. de620_ready(struct net_device *dev)
  235. {
  236. byte value;
  237. register short int cnt = 0;
  238. while ((((value = inb(STATUS_PORT)) & READY) == 0) && (cnt <= 1000))
  239. ++cnt;
  240. #ifdef COUNT_LOOPS
  241. tot_cnt += cnt;
  242. #endif
  243. return value & 0xf0; /* nibble */
  244. }
  245. static inline void
  246. de620_send_command(struct net_device *dev, byte cmd)
  247. {
  248. de620_ready(dev);
  249. if (cmd == W_DUMMY)
  250. outb(NIC_Cmd, COMMAND_PORT);
  251. outb(cmd, DATA_PORT);
  252. outb(NIC_Cmd ^ CS0, COMMAND_PORT);
  253. de620_ready(dev);
  254. outb(NIC_Cmd, COMMAND_PORT);
  255. }
  256. static inline void
  257. de620_put_byte(struct net_device *dev, byte value)
  258. {
  259. /* The de620_ready() makes 7 loops, on the average, on a DX2/66 */
  260. de620_ready(dev);
  261. outb(value, DATA_PORT);
  262. de620_flip_ds(dev);
  263. }
  264. static inline byte
  265. de620_read_byte(struct net_device *dev)
  266. {
  267. byte value;
  268. /* The de620_ready() makes 7 loops, on the average, on a DX2/66 */
  269. value = de620_ready(dev); /* High nibble */
  270. de620_flip_ds(dev);
  271. value |= de620_ready(dev) >> 4; /* Low nibble */
  272. return value;
  273. }
  274. static inline void
  275. de620_write_block(struct net_device *dev, byte *buffer, int count, int pad)
  276. {
  277. #ifndef LOWSPEED
  278. byte uflip = NIC_Cmd ^ (DS0 | DS1);
  279. byte dflip = NIC_Cmd;
  280. #else /* LOWSPEED */
  281. #ifdef COUNT_LOOPS
  282. int bytes = count;
  283. #endif /* COUNT_LOOPS */
  284. #endif /* LOWSPEED */
  285. #ifdef LOWSPEED
  286. #ifdef COUNT_LOOPS
  287. tot_cnt = 0;
  288. #endif /* COUNT_LOOPS */
  289. /* No further optimization useful, the limit is in the adapter. */
  290. for ( ; count > 0; --count, ++buffer) {
  291. de620_put_byte(dev,*buffer);
  292. }
  293. for ( count = pad ; count > 0; --count, ++buffer) {
  294. de620_put_byte(dev, 0);
  295. }
  296. de620_send_command(dev,W_DUMMY);
  297. #ifdef COUNT_LOOPS
  298. /* trial debug output: loops per byte in de620_ready() */
  299. printk("WRITE(%d)\n", tot_cnt/((bytes?bytes:1)));
  300. #endif /* COUNT_LOOPS */
  301. #else /* not LOWSPEED */
  302. for ( ; count > 0; count -=2) {
  303. outb(*buffer++, DATA_PORT);
  304. outb(uflip, COMMAND_PORT);
  305. outb(*buffer++, DATA_PORT);
  306. outb(dflip, COMMAND_PORT);
  307. }
  308. de620_send_command(dev,W_DUMMY);
  309. #endif /* LOWSPEED */
  310. }
  311. static inline void
  312. de620_read_block(struct net_device *dev, byte *data, int count)
  313. {
  314. #ifndef LOWSPEED
  315. byte value;
  316. byte uflip = NIC_Cmd ^ (DS0 | DS1);
  317. byte dflip = NIC_Cmd;
  318. #else /* LOWSPEED */
  319. #ifdef COUNT_LOOPS
  320. int bytes = count;
  321. tot_cnt = 0;
  322. #endif /* COUNT_LOOPS */
  323. #endif /* LOWSPEED */
  324. #ifdef LOWSPEED
  325. /* No further optimization useful, the limit is in the adapter. */
  326. while (count-- > 0) {
  327. *data++ = de620_read_byte(dev);
  328. de620_flip_ds(dev);
  329. }
  330. #ifdef COUNT_LOOPS
  331. /* trial debug output: loops per byte in de620_ready() */
  332. printk("READ(%d)\n", tot_cnt/(2*(bytes?bytes:1)));
  333. #endif /* COUNT_LOOPS */
  334. #else /* not LOWSPEED */
  335. while (count-- > 0) {
  336. value = inb(STATUS_PORT) & 0xf0; /* High nibble */
  337. outb(uflip, COMMAND_PORT);
  338. *data++ = value | inb(STATUS_PORT) >> 4; /* Low nibble */
  339. outb(dflip , COMMAND_PORT);
  340. }
  341. #endif /* LOWSPEED */
  342. }
  343. static inline void
  344. de620_set_delay(struct net_device *dev)
  345. {
  346. de620_ready(dev);
  347. outb(W_DFR, DATA_PORT);
  348. outb(NIC_Cmd ^ CS0, COMMAND_PORT);
  349. de620_ready(dev);
  350. #ifdef LOWSPEED
  351. outb(WRITE_DELAY, DATA_PORT);
  352. #else
  353. outb(0, DATA_PORT);
  354. #endif
  355. de620_flip_ds(dev);
  356. de620_ready(dev);
  357. #ifdef LOWSPEED
  358. outb(READ_DELAY, DATA_PORT);
  359. #else
  360. outb(0, DATA_PORT);
  361. #endif
  362. de620_flip_ds(dev);
  363. }
  364. static inline void
  365. de620_set_register(struct net_device *dev, byte reg, byte value)
  366. {
  367. de620_ready(dev);
  368. outb(reg, DATA_PORT);
  369. outb(NIC_Cmd ^ CS0, COMMAND_PORT);
  370. de620_put_byte(dev, value);
  371. }
  372. static inline byte
  373. de620_get_register(struct net_device *dev, byte reg)
  374. {
  375. byte value;
  376. de620_send_command(dev,reg);
  377. value = de620_read_byte(dev);
  378. de620_send_command(dev,W_DUMMY);
  379. return value;
  380. }
  381. /*********************************************************************
  382. *
  383. * Open/initialize the board.
  384. *
  385. * This routine should set everything up anew at each open, even
  386. * registers that "should" only need to be set once at boot, so that
  387. * there is a non-reboot way to recover if something goes wrong.
  388. *
  389. */
  390. static int de620_open(struct net_device *dev)
  391. {
  392. int ret = request_irq(dev->irq, de620_interrupt, 0, dev->name, dev);
  393. if (ret) {
  394. printk (KERN_ERR "%s: unable to get IRQ %d\n", dev->name, dev->irq);
  395. return ret;
  396. }
  397. if (adapter_init(dev)) {
  398. ret = -EIO;
  399. goto out_free_irq;
  400. }
  401. netif_start_queue(dev);
  402. return 0;
  403. out_free_irq:
  404. free_irq(dev->irq, dev);
  405. return ret;
  406. }
  407. /************************************************
  408. *
  409. * The inverse routine to de620_open().
  410. *
  411. */
  412. static int de620_close(struct net_device *dev)
  413. {
  414. netif_stop_queue(dev);
  415. /* disable recv */
  416. de620_set_register(dev, W_TCR, RXOFF);
  417. free_irq(dev->irq, dev);
  418. return 0;
  419. }
  420. /*********************************************
  421. *
  422. * Return current statistics
  423. *
  424. */
  425. static struct net_device_stats *get_stats(struct net_device *dev)
  426. {
  427. return (struct net_device_stats *)(dev->priv);
  428. }
  429. /*********************************************
  430. *
  431. * Set or clear the multicast filter for this adaptor.
  432. * (no real multicast implemented for the DE-620, but she can be promiscuous...)
  433. *
  434. */
  435. static void de620_set_multicast_list(struct net_device *dev)
  436. {
  437. if (dev->mc_count || dev->flags&(IFF_ALLMULTI|IFF_PROMISC))
  438. { /* Enable promiscuous mode */
  439. /*
  440. * We must make the kernel realise we had to move
  441. * into promisc mode or we start all out war on
  442. * the cable. - AC
  443. */
  444. dev->flags|=IFF_PROMISC;
  445. de620_set_register(dev, W_TCR, (TCR_DEF & ~RXPBM) | RXALL);
  446. }
  447. else
  448. { /* Disable promiscuous mode, use normal mode */
  449. de620_set_register(dev, W_TCR, TCR_DEF);
  450. }
  451. }
  452. /*******************************************************
  453. *
  454. * Handle timeouts on transmit
  455. */
  456. static void de620_timeout(struct net_device *dev)
  457. {
  458. printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name, "network cable problem");
  459. /* Restart the adapter. */
  460. if (!adapter_init(dev)) /* maybe close it */
  461. netif_wake_queue(dev);
  462. }
  463. /*******************************************************
  464. *
  465. * Copy a buffer to the adapter transmit page memory.
  466. * Start sending.
  467. */
  468. static int de620_start_xmit(struct sk_buff *skb, struct net_device *dev)
  469. {
  470. unsigned long flags;
  471. int len;
  472. byte *buffer = skb->data;
  473. byte using_txbuf;
  474. using_txbuf = de620_tx_buffs(dev); /* Peek at the adapter */
  475. netif_stop_queue(dev);
  476. if ((len = skb->len) < RUNT)
  477. len = RUNT;
  478. if (len & 1) /* send an even number of bytes */
  479. ++len;
  480. /* Start real output */
  481. spin_lock_irqsave(&de620_lock, flags)
  482. PRINTK(("de620_start_xmit: len=%d, bufs 0x%02x\n",
  483. (int)skb->len, using_txbuf));
  484. /* select a free tx buffer. if there is one... */
  485. switch (using_txbuf) {
  486. default: /* both are free: use TXBF0 */
  487. case TXBF1: /* use TXBF0 */
  488. de620_send_command(dev,W_CR | RW0);
  489. using_txbuf |= TXBF0;
  490. break;
  491. case TXBF0: /* use TXBF1 */
  492. de620_send_command(dev,W_CR | RW1);
  493. using_txbuf |= TXBF1;
  494. break;
  495. case (TXBF0 | TXBF1): /* NONE!!! */
  496. printk(KERN_WARNING "%s: No tx-buffer available!\n", dev->name);
  497. spin_unlock_irqrestore(&de620_lock, flags);
  498. return 1;
  499. }
  500. de620_write_block(dev, buffer, skb->len, len-skb->len);
  501. dev->trans_start = jiffies;
  502. if(!(using_txbuf == (TXBF0 | TXBF1)))
  503. netif_wake_queue(dev);
  504. ((struct net_device_stats *)(dev->priv))->tx_packets++;
  505. spin_unlock_irqrestore(&de620_lock, flags);
  506. dev_kfree_skb (skb);
  507. return 0;
  508. }
  509. /*****************************************************
  510. *
  511. * Handle the network interface interrupts.
  512. *
  513. */
  514. static irqreturn_t
  515. de620_interrupt(int irq_in, void *dev_id)
  516. {
  517. struct net_device *dev = dev_id;
  518. byte irq_status;
  519. int bogus_count = 0;
  520. int again = 0;
  521. spin_lock(&de620_lock);
  522. /* Read the status register (_not_ the status port) */
  523. irq_status = de620_get_register(dev, R_STS);
  524. PRINTK(("de620_interrupt (%2.2X)\n", irq_status));
  525. if (irq_status & RXGOOD) {
  526. do {
  527. again = de620_rx_intr(dev);
  528. PRINTK(("again=%d\n", again));
  529. }
  530. while (again && (++bogus_count < 100));
  531. }
  532. if(de620_tx_buffs(dev) != (TXBF0 | TXBF1))
  533. netif_wake_queue(dev);
  534. spin_unlock(&de620_lock);
  535. return IRQ_HANDLED;
  536. }
  537. /**************************************
  538. *
  539. * Get a packet from the adapter
  540. *
  541. * Send it "upstairs"
  542. *
  543. */
  544. static int de620_rx_intr(struct net_device *dev)
  545. {
  546. struct header_buf {
  547. byte status;
  548. byte Rx_NextPage;
  549. unsigned short Rx_ByteCount;
  550. } header_buf;
  551. struct sk_buff *skb;
  552. int size;
  553. byte *buffer;
  554. byte pagelink;
  555. byte curr_page;
  556. PRINTK(("de620_rx_intr: next_rx_page = %d\n", next_rx_page));
  557. /* Tell the adapter that we are going to read data, and from where */
  558. de620_send_command(dev, W_CR | RRN);
  559. de620_set_register(dev, W_RSA1, next_rx_page);
  560. de620_set_register(dev, W_RSA0, 0);
  561. /* Deep breath, and away we goooooo */
  562. de620_read_block(dev, (byte *)&header_buf, sizeof(struct header_buf));
  563. PRINTK(("page status=0x%02x, nextpage=%d, packetsize=%d\n",
  564. header_buf.status, header_buf.Rx_NextPage, header_buf.Rx_ByteCount));
  565. /* Plausible page header? */
  566. pagelink = header_buf.Rx_NextPage;
  567. if ((pagelink < first_rx_page) || (last_rx_page < pagelink)) {
  568. /* Ouch... Forget it! Skip all and start afresh... */
  569. printk(KERN_WARNING "%s: Ring overrun? Restoring...\n", dev->name);
  570. /* You win some, you lose some. And sometimes plenty... */
  571. adapter_init(dev);
  572. netif_wake_queue(dev);
  573. ((struct net_device_stats *)(dev->priv))->rx_over_errors++;
  574. return 0;
  575. }
  576. /* OK, this look good, so far. Let's see if it's consistent... */
  577. /* Let's compute the start of the next packet, based on where we are */
  578. pagelink = next_rx_page +
  579. ((header_buf.Rx_ByteCount + (4 - 1 + 0x100)) >> 8);
  580. /* Are we going to wrap around the page counter? */
  581. if (pagelink > last_rx_page)
  582. pagelink -= (last_rx_page - first_rx_page + 1);
  583. /* Is the _computed_ next page number equal to what the adapter says? */
  584. if (pagelink != header_buf.Rx_NextPage) {
  585. /* Naah, we'll skip this packet. Probably bogus data as well */
  586. printk(KERN_WARNING "%s: Page link out of sync! Restoring...\n", dev->name);
  587. next_rx_page = header_buf.Rx_NextPage; /* at least a try... */
  588. de620_send_command(dev, W_DUMMY);
  589. de620_set_register(dev, W_NPRF, next_rx_page);
  590. ((struct net_device_stats *)(dev->priv))->rx_over_errors++;
  591. return 0;
  592. }
  593. next_rx_page = pagelink;
  594. size = header_buf.Rx_ByteCount - 4;
  595. if ((size < RUNT) || (GIANT < size)) {
  596. printk(KERN_WARNING "%s: Illegal packet size: %d!\n", dev->name, size);
  597. }
  598. else { /* Good packet? */
  599. skb = dev_alloc_skb(size+2);
  600. if (skb == NULL) { /* Yeah, but no place to put it... */
  601. printk(KERN_WARNING "%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, size);
  602. ((struct net_device_stats *)(dev->priv))->rx_dropped++;
  603. }
  604. else { /* Yep! Go get it! */
  605. skb_reserve(skb,2); /* Align */
  606. skb->dev = dev;
  607. /* skb->data points to the start of sk_buff data area */
  608. buffer = skb_put(skb,size);
  609. /* copy the packet into the buffer */
  610. de620_read_block(dev, buffer, size);
  611. PRINTK(("Read %d bytes\n", size));
  612. skb->protocol=eth_type_trans(skb,dev);
  613. netif_rx(skb); /* deliver it "upstairs" */
  614. dev->last_rx = jiffies;
  615. /* count all receives */
  616. ((struct net_device_stats *)(dev->priv))->rx_packets++;
  617. ((struct net_device_stats *)(dev->priv))->rx_bytes += size;
  618. }
  619. }
  620. /* Let's peek ahead to see if we have read the last current packet */
  621. /* NOTE! We're _not_ checking the 'EMPTY'-flag! This seems better... */
  622. curr_page = de620_get_register(dev, R_CPR);
  623. de620_set_register(dev, W_NPRF, next_rx_page);
  624. PRINTK(("next_rx_page=%d CPR=%d\n", next_rx_page, curr_page));
  625. return (next_rx_page != curr_page); /* That was slightly tricky... */
  626. }
  627. /*********************************************
  628. *
  629. * Reset the adapter to a known state
  630. *
  631. */
  632. static int adapter_init(struct net_device *dev)
  633. {
  634. int i;
  635. static int was_down;
  636. if ((nic_data.Model == 3) || (nic_data.Model == 0)) { /* CT */
  637. EIPRegister = NCTL0;
  638. if (nic_data.Media != 1)
  639. EIPRegister |= NIS0; /* not BNC */
  640. }
  641. else if (nic_data.Model == 2) { /* UTP */
  642. EIPRegister = NCTL0 | NIS0;
  643. }
  644. if (utp)
  645. EIPRegister = NCTL0 | NIS0;
  646. if (bnc)
  647. EIPRegister = NCTL0;
  648. de620_send_command(dev, W_CR | RNOP | CLEAR);
  649. de620_send_command(dev, W_CR | RNOP);
  650. de620_set_register(dev, W_SCR, SCR_DEF);
  651. /* disable recv to wait init */
  652. de620_set_register(dev, W_TCR, RXOFF);
  653. /* Set the node ID in the adapter */
  654. for (i = 0; i < 6; ++i) { /* W_PARn = 0xaa + n */
  655. de620_set_register(dev, W_PAR0 + i, dev->dev_addr[i]);
  656. }
  657. de620_set_register(dev, W_EIP, EIPRegister);
  658. next_rx_page = first_rx_page = DE620_RX_START_PAGE;
  659. if (nic_data.RAM_Size)
  660. last_rx_page = nic_data.RAM_Size - 1;
  661. else /* 64k RAM */
  662. last_rx_page = 255;
  663. de620_set_register(dev, W_SPR, first_rx_page); /* Start Page Register*/
  664. de620_set_register(dev, W_EPR, last_rx_page); /* End Page Register */
  665. de620_set_register(dev, W_CPR, first_rx_page);/*Current Page Register*/
  666. de620_send_command(dev, W_NPR | first_rx_page); /* Next Page Register*/
  667. de620_send_command(dev, W_DUMMY);
  668. de620_set_delay(dev);
  669. /* Final sanity check: Anybody out there? */
  670. /* Let's hope some bits from the statusregister make a good check */
  671. #define CHECK_MASK ( 0 | TXSUC | T16 | 0 | RXCRC | RXSHORT | 0 | 0 )
  672. #define CHECK_OK ( 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 )
  673. /* success: X 0 0 X 0 0 X X */
  674. /* ignore: EEDI RXGOOD COLS LNKS*/
  675. if (((i = de620_get_register(dev, R_STS)) & CHECK_MASK) != CHECK_OK) {
  676. printk(KERN_ERR "%s: Something has happened to the DE-620! Please check it"
  677. #ifdef SHUTDOWN_WHEN_LOST
  678. " and do a new ifconfig"
  679. #endif
  680. "! (%02x)\n", dev->name, i);
  681. #ifdef SHUTDOWN_WHEN_LOST
  682. /* Goodbye, cruel world... */
  683. dev->flags &= ~IFF_UP;
  684. de620_close(dev);
  685. #endif
  686. was_down = 1;
  687. return 1; /* failed */
  688. }
  689. if (was_down) {
  690. printk(KERN_WARNING "%s: Thanks, I feel much better now!\n", dev->name);
  691. was_down = 0;
  692. }
  693. /* All OK, go ahead... */
  694. de620_set_register(dev, W_TCR, TCR_DEF);
  695. return 0; /* all ok */
  696. }
  697. /******************************************************************************
  698. *
  699. * Only start-up code below
  700. *
  701. */
  702. /****************************************
  703. *
  704. * Check if there is a DE-620 connected
  705. */
  706. struct net_device * __init de620_probe(int unit)
  707. {
  708. byte checkbyte = 0xa5;
  709. struct net_device *dev;
  710. int err = -ENOMEM;
  711. int i;
  712. dev = alloc_etherdev(sizeof(struct net_device_stats));
  713. if (!dev)
  714. goto out;
  715. SET_MODULE_OWNER(dev);
  716. spin_lock_init(&de620_lock);
  717. /*
  718. * This is where the base_addr and irq gets set.
  719. * Tunable at compile-time and insmod-time
  720. */
  721. dev->base_addr = io;
  722. dev->irq = irq;
  723. /* allow overriding parameters on command line */
  724. if (unit >= 0) {
  725. sprintf(dev->name, "eth%d", unit);
  726. netdev_boot_setup_check(dev);
  727. }
  728. if (de620_debug)
  729. printk(version);
  730. printk(KERN_INFO "D-Link DE-620 pocket adapter");
  731. if (!request_region(dev->base_addr, 3, "de620")) {
  732. printk(" io 0x%3lX, which is busy.\n", dev->base_addr);
  733. err = -EBUSY;
  734. goto out1;
  735. }
  736. /* Initially, configure basic nibble mode, so we can read the EEPROM */
  737. NIC_Cmd = DEF_NIC_CMD;
  738. de620_set_register(dev, W_EIP, EIPRegister);
  739. /* Anybody out there? */
  740. de620_set_register(dev, W_CPR, checkbyte);
  741. checkbyte = de620_get_register(dev, R_CPR);
  742. if ((checkbyte != 0xa5) || (read_eeprom(dev) != 0)) {
  743. printk(" not identified in the printer port\n");
  744. err = -ENODEV;
  745. goto out2;
  746. }
  747. /* else, got it! */
  748. printk(", Ethernet Address: %2.2X",
  749. dev->dev_addr[0] = nic_data.NodeID[0]);
  750. for (i = 1; i < ETH_ALEN; i++) {
  751. printk(":%2.2X", dev->dev_addr[i] = nic_data.NodeID[i]);
  752. dev->broadcast[i] = 0xff;
  753. }
  754. printk(" (%dk RAM,",
  755. (nic_data.RAM_Size) ? (nic_data.RAM_Size >> 2) : 64);
  756. if (nic_data.Media == 1)
  757. printk(" BNC)\n");
  758. else
  759. printk(" UTP)\n");
  760. dev->get_stats = get_stats;
  761. dev->open = de620_open;
  762. dev->stop = de620_close;
  763. dev->hard_start_xmit = de620_start_xmit;
  764. dev->tx_timeout = de620_timeout;
  765. dev->watchdog_timeo = HZ*2;
  766. dev->set_multicast_list = de620_set_multicast_list;
  767. /* base_addr and irq are already set, see above! */
  768. /* dump eeprom */
  769. if (de620_debug) {
  770. printk("\nEEPROM contents:\n");
  771. printk("RAM_Size = 0x%02X\n", nic_data.RAM_Size);
  772. printk("NodeID = %02X:%02X:%02X:%02X:%02X:%02X\n",
  773. nic_data.NodeID[0], nic_data.NodeID[1],
  774. nic_data.NodeID[2], nic_data.NodeID[3],
  775. nic_data.NodeID[4], nic_data.NodeID[5]);
  776. printk("Model = %d\n", nic_data.Model);
  777. printk("Media = %d\n", nic_data.Media);
  778. printk("SCR = 0x%02x\n", nic_data.SCR);
  779. }
  780. err = register_netdev(dev);
  781. if (err)
  782. goto out2;
  783. return dev;
  784. out2:
  785. release_region(dev->base_addr, 3);
  786. out1:
  787. free_netdev(dev);
  788. out:
  789. return ERR_PTR(err);
  790. }
  791. /**********************************
  792. *
  793. * Read info from on-board EEPROM
  794. *
  795. * Note: Bitwise serial I/O to/from the EEPROM vi the status _register_!
  796. */
  797. #define sendit(dev,data) de620_set_register(dev, W_EIP, data | EIPRegister);
  798. static unsigned short __init ReadAWord(struct net_device *dev, int from)
  799. {
  800. unsigned short data;
  801. int nbits;
  802. /* cs [__~~] SET SEND STATE */
  803. /* di [____] */
  804. /* sck [_~~_] */
  805. sendit(dev, 0); sendit(dev, 1); sendit(dev, 5); sendit(dev, 4);
  806. /* Send the 9-bit address from where we want to read the 16-bit word */
  807. for (nbits = 9; nbits > 0; --nbits, from <<= 1) {
  808. if (from & 0x0100) { /* bit set? */
  809. /* cs [~~~~] SEND 1 */
  810. /* di [~~~~] */
  811. /* sck [_~~_] */
  812. sendit(dev, 6); sendit(dev, 7); sendit(dev, 7); sendit(dev, 6);
  813. }
  814. else {
  815. /* cs [~~~~] SEND 0 */
  816. /* di [____] */
  817. /* sck [_~~_] */
  818. sendit(dev, 4); sendit(dev, 5); sendit(dev, 5); sendit(dev, 4);
  819. }
  820. }
  821. /* Shift in the 16-bit word. The bits appear serially in EEDI (=0x80) */
  822. for (data = 0, nbits = 16; nbits > 0; --nbits) {
  823. /* cs [~~~~] SEND 0 */
  824. /* di [____] */
  825. /* sck [_~~_] */
  826. sendit(dev, 4); sendit(dev, 5); sendit(dev, 5); sendit(dev, 4);
  827. data = (data << 1) | ((de620_get_register(dev, R_STS) & EEDI) >> 7);
  828. }
  829. /* cs [____] RESET SEND STATE */
  830. /* di [____] */
  831. /* sck [_~~_] */
  832. sendit(dev, 0); sendit(dev, 1); sendit(dev, 1); sendit(dev, 0);
  833. return data;
  834. }
  835. static int __init read_eeprom(struct net_device *dev)
  836. {
  837. unsigned short wrd;
  838. /* D-Link Ethernet addresses are in the series 00:80:c8:7X:XX:XX:XX */
  839. wrd = ReadAWord(dev, 0x1aa); /* bytes 0 + 1 of NodeID */
  840. if (!clone && (wrd != htons(0x0080))) /* Valid D-Link ether sequence? */
  841. return -1; /* Nope, not a DE-620 */
  842. nic_data.NodeID[0] = wrd & 0xff;
  843. nic_data.NodeID[1] = wrd >> 8;
  844. wrd = ReadAWord(dev, 0x1ab); /* bytes 2 + 3 of NodeID */
  845. if (!clone && ((wrd & 0xff) != 0xc8)) /* Valid D-Link ether sequence? */
  846. return -1; /* Nope, not a DE-620 */
  847. nic_data.NodeID[2] = wrd & 0xff;
  848. nic_data.NodeID[3] = wrd >> 8;
  849. wrd = ReadAWord(dev, 0x1ac); /* bytes 4 + 5 of NodeID */
  850. nic_data.NodeID[4] = wrd & 0xff;
  851. nic_data.NodeID[5] = wrd >> 8;
  852. wrd = ReadAWord(dev, 0x1ad); /* RAM size in pages (256 bytes). 0 = 64k */
  853. nic_data.RAM_Size = (wrd >> 8);
  854. wrd = ReadAWord(dev, 0x1ae); /* hardware model (CT = 3) */
  855. nic_data.Model = (wrd & 0xff);
  856. wrd = ReadAWord(dev, 0x1af); /* media (indicates BNC/UTP) */
  857. nic_data.Media = (wrd & 0xff);
  858. wrd = ReadAWord(dev, 0x1a8); /* System Configuration Register */
  859. nic_data.SCR = (wrd >> 8);
  860. return 0; /* no errors */
  861. }
  862. /******************************************************************************
  863. *
  864. * Loadable module skeleton
  865. *
  866. */
  867. #ifdef MODULE
  868. static struct net_device *de620_dev;
  869. int __init init_module(void)
  870. {
  871. de620_dev = de620_probe(-1);
  872. if (IS_ERR(de620_dev))
  873. return PTR_ERR(de620_dev);
  874. return 0;
  875. }
  876. void cleanup_module(void)
  877. {
  878. unregister_netdev(de620_dev);
  879. release_region(de620_dev->base_addr, 3);
  880. free_netdev(de620_dev);
  881. }
  882. #endif /* MODULE */
  883. MODULE_LICENSE("GPL");
  884. /*
  885. * (add '-DMODULE' when compiling as loadable module)
  886. *
  887. * compile-command:
  888. * gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O2 \
  889. * -fomit-frame-pointer -m486 \
  890. * -I/usr/src/linux/include -I../../net/inet -c de620.c
  891. */
  892. /*
  893. * Local variables:
  894. * kernel-compile-command: "gcc -D__KERNEL__ -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
  895. * module-compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
  896. * compile-command: "gcc -D__KERNEL__ -DMODULE -Ilinux/include -I../../net/inet -Wall -Wstrict-prototypes -O2 -m486 -c de620.c"
  897. * End:
  898. */