de600.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548
  1. static const char version[] = "de600.c: $Revision: 1.1.1.1 $, Bjorn Ekwall (bj0rn@blox.se)\n";
  2. /*
  3. * de600.c
  4. *
  5. * Linux driver for the D-Link DE-600 Ethernet pocket adapter.
  6. *
  7. * Portions (C) Copyright 1993, 1994 by Bjorn Ekwall
  8. * The Author may be reached as bj0rn@blox.se
  9. *
  10. * Based on adapter information gathered from DE600.ASM by D-Link Inc.,
  11. * as included on disk C in the v.2.11 of PC/TCP from FTP Software.
  12. * For DE600.asm:
  13. * Portions (C) Copyright 1990 D-Link, Inc.
  14. * Copyright, 1988-1992, Russell Nelson, Crynwr Software
  15. *
  16. * Adapted to the sample network driver core for linux,
  17. * written by: Donald Becker <becker@super.org>
  18. * (Now at <becker@scyld.com>)
  19. *
  20. **************************************************************/
  21. /*
  22. * This program is free software; you can redistribute it and/or modify
  23. * it under the terms of the GNU General Public License as published by
  24. * the Free Software Foundation; either version 2, or (at your option)
  25. * any later version.
  26. *
  27. * This program is distributed in the hope that it will be useful,
  28. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  30. * GNU General Public License for more details.
  31. *
  32. * You should have received a copy of the GNU General Public License
  33. * along with this program; if not, write to the Free Software
  34. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  35. *
  36. **************************************************************/
  37. /* Add more time here if your adapter won't work OK: */
  38. #define DE600_SLOW_DOWN udelay(delay_time)
  39. /* use 0 for production, 1 for verification, >2 for debug */
  40. #ifdef DE600_DEBUG
  41. #define PRINTK(x) if (de600_debug >= 2) printk x
  42. #else
  43. #define DE600_DEBUG 0
  44. #define PRINTK(x) /**/
  45. #endif
  46. #include <linux/module.h>
  47. #include <linux/kernel.h>
  48. #include <linux/types.h>
  49. #include <linux/fcntl.h>
  50. #include <linux/string.h>
  51. #include <linux/interrupt.h>
  52. #include <linux/ioport.h>
  53. #include <linux/in.h>
  54. #include <asm/system.h>
  55. #include <linux/errno.h>
  56. #include <linux/init.h>
  57. #include <linux/delay.h>
  58. #include <linux/inet.h>
  59. #include <linux/netdevice.h>
  60. #include <linux/etherdevice.h>
  61. #include <linux/skbuff.h>
  62. #include <asm/io.h>
  63. #include "de600.h"
  64. static unsigned int de600_debug = DE600_DEBUG;
  65. module_param(de600_debug, int, 0);
  66. MODULE_PARM_DESC(de600_debug, "DE-600 debug level (0-2)");
  67. static unsigned int check_lost = 1;
  68. module_param(check_lost, bool, 0);
  69. MODULE_PARM_DESC(check_lost, "If set then check for unplugged de600");
  70. static unsigned int delay_time = 10;
  71. module_param(delay_time, int, 0);
  72. MODULE_PARM_DESC(delay_time, "DE-600 deley on I/O in microseconds");
  73. /*
  74. * D-Link driver variables:
  75. */
  76. static volatile int rx_page;
  77. #define TX_PAGES 2
  78. static volatile int tx_fifo[TX_PAGES];
  79. static volatile int tx_fifo_in;
  80. static volatile int tx_fifo_out;
  81. static volatile int free_tx_pages = TX_PAGES;
  82. static int was_down;
  83. static DEFINE_SPINLOCK(de600_lock);
  84. static inline u8 de600_read_status(struct net_device *dev)
  85. {
  86. u8 status;
  87. outb_p(STATUS, DATA_PORT);
  88. status = inb(STATUS_PORT);
  89. outb_p(NULL_COMMAND | HI_NIBBLE, DATA_PORT);
  90. return status;
  91. }
  92. static inline u8 de600_read_byte(unsigned char type, struct net_device *dev)
  93. {
  94. /* dev used by macros */
  95. u8 lo;
  96. outb_p((type), DATA_PORT);
  97. lo = ((unsigned char)inb(STATUS_PORT)) >> 4;
  98. outb_p((type) | HI_NIBBLE, DATA_PORT);
  99. return ((unsigned char)inb(STATUS_PORT) & (unsigned char)0xf0) | lo;
  100. }
  101. /*
  102. * Open/initialize the board. This is called (in the current kernel)
  103. * after booting when 'ifconfig <dev->name> $IP_ADDR' is run (in rc.inet1).
  104. *
  105. * This routine should set everything up anew at each open, even
  106. * registers that "should" only need to be set once at boot, so that
  107. * there is a non-reboot way to recover if something goes wrong.
  108. */
  109. static int de600_open(struct net_device *dev)
  110. {
  111. unsigned long flags;
  112. int ret = request_irq(DE600_IRQ, de600_interrupt, 0, dev->name, dev);
  113. if (ret) {
  114. printk(KERN_ERR "%s: unable to get IRQ %d\n", dev->name, DE600_IRQ);
  115. return ret;
  116. }
  117. spin_lock_irqsave(&de600_lock, flags);
  118. ret = adapter_init(dev);
  119. spin_unlock_irqrestore(&de600_lock, flags);
  120. return ret;
  121. }
  122. /*
  123. * The inverse routine to de600_open().
  124. */
  125. static int de600_close(struct net_device *dev)
  126. {
  127. select_nic();
  128. rx_page = 0;
  129. de600_put_command(RESET);
  130. de600_put_command(STOP_RESET);
  131. de600_put_command(0);
  132. select_prn();
  133. free_irq(DE600_IRQ, dev);
  134. return 0;
  135. }
  136. static struct net_device_stats *get_stats(struct net_device *dev)
  137. {
  138. return (struct net_device_stats *)(dev->priv);
  139. }
  140. static inline void trigger_interrupt(struct net_device *dev)
  141. {
  142. de600_put_command(FLIP_IRQ);
  143. select_prn();
  144. DE600_SLOW_DOWN;
  145. select_nic();
  146. de600_put_command(0);
  147. }
  148. /*
  149. * Copy a buffer to the adapter transmit page memory.
  150. * Start sending.
  151. */
  152. static int de600_start_xmit(struct sk_buff *skb, struct net_device *dev)
  153. {
  154. unsigned long flags;
  155. int transmit_from;
  156. int len;
  157. int tickssofar;
  158. u8 *buffer = skb->data;
  159. int i;
  160. if (free_tx_pages <= 0) { /* Do timeouts, to avoid hangs. */
  161. tickssofar = jiffies - dev->trans_start;
  162. if (tickssofar < 5)
  163. return 1;
  164. /* else */
  165. printk(KERN_WARNING "%s: transmit timed out (%d), %s?\n", dev->name, tickssofar, "network cable problem");
  166. /* Restart the adapter. */
  167. spin_lock_irqsave(&de600_lock, flags);
  168. if (adapter_init(dev)) {
  169. spin_unlock_irqrestore(&de600_lock, flags);
  170. return 1;
  171. }
  172. spin_unlock_irqrestore(&de600_lock, flags);
  173. }
  174. /* Start real output */
  175. PRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
  176. if ((len = skb->len) < RUNT)
  177. len = RUNT;
  178. spin_lock_irqsave(&de600_lock, flags);
  179. select_nic();
  180. tx_fifo[tx_fifo_in] = transmit_from = tx_page_adr(tx_fifo_in) - len;
  181. tx_fifo_in = (tx_fifo_in + 1) % TX_PAGES; /* Next free tx page */
  182. if(check_lost)
  183. {
  184. /* This costs about 40 instructions per packet... */
  185. de600_setup_address(NODE_ADDRESS, RW_ADDR);
  186. de600_read_byte(READ_DATA, dev);
  187. if (was_down || (de600_read_byte(READ_DATA, dev) != 0xde)) {
  188. if (adapter_init(dev)) {
  189. spin_unlock_irqrestore(&de600_lock, flags);
  190. return 1;
  191. }
  192. }
  193. }
  194. de600_setup_address(transmit_from, RW_ADDR);
  195. for (i = 0; i < skb->len ; ++i, ++buffer)
  196. de600_put_byte(*buffer);
  197. for (; i < len; ++i)
  198. de600_put_byte(0);
  199. if (free_tx_pages-- == TX_PAGES) { /* No transmission going on */
  200. dev->trans_start = jiffies;
  201. netif_start_queue(dev); /* allow more packets into adapter */
  202. /* Send page and generate a faked interrupt */
  203. de600_setup_address(transmit_from, TX_ADDR);
  204. de600_put_command(TX_ENABLE);
  205. }
  206. else {
  207. if (free_tx_pages)
  208. netif_start_queue(dev);
  209. else
  210. netif_stop_queue(dev);
  211. select_prn();
  212. }
  213. spin_unlock_irqrestore(&de600_lock, flags);
  214. dev_kfree_skb(skb);
  215. return 0;
  216. }
  217. /*
  218. * The typical workload of the driver:
  219. * Handle the network interface interrupts.
  220. */
  221. static irqreturn_t de600_interrupt(int irq, void *dev_id)
  222. {
  223. struct net_device *dev = dev_id;
  224. u8 irq_status;
  225. int retrig = 0;
  226. int boguscount = 0;
  227. spin_lock(&de600_lock);
  228. select_nic();
  229. irq_status = de600_read_status(dev);
  230. do {
  231. PRINTK(("de600_interrupt (%02X)\n", irq_status));
  232. if (irq_status & RX_GOOD)
  233. de600_rx_intr(dev);
  234. else if (!(irq_status & RX_BUSY))
  235. de600_put_command(RX_ENABLE);
  236. /* Any transmission in progress? */
  237. if (free_tx_pages < TX_PAGES)
  238. retrig = de600_tx_intr(dev, irq_status);
  239. else
  240. retrig = 0;
  241. irq_status = de600_read_status(dev);
  242. } while ( (irq_status & RX_GOOD) || ((++boguscount < 100) && retrig) );
  243. /*
  244. * Yeah, it _looks_ like busy waiting, smells like busy waiting
  245. * and I know it's not PC, but please, it will only occur once
  246. * in a while and then only for a loop or so (< 1ms for sure!)
  247. */
  248. /* Enable adapter interrupts */
  249. select_prn();
  250. if (retrig)
  251. trigger_interrupt(dev);
  252. spin_unlock(&de600_lock);
  253. return IRQ_HANDLED;
  254. }
  255. static int de600_tx_intr(struct net_device *dev, int irq_status)
  256. {
  257. /*
  258. * Returns 1 if tx still not done
  259. */
  260. /* Check if current transmission is done yet */
  261. if (irq_status & TX_BUSY)
  262. return 1; /* tx not done, try again */
  263. /* else */
  264. /* If last transmission OK then bump fifo index */
  265. if (!(irq_status & TX_FAILED16)) {
  266. tx_fifo_out = (tx_fifo_out + 1) % TX_PAGES;
  267. ++free_tx_pages;
  268. ((struct net_device_stats *)(dev->priv))->tx_packets++;
  269. netif_wake_queue(dev);
  270. }
  271. /* More to send, or resend last packet? */
  272. if ((free_tx_pages < TX_PAGES) || (irq_status & TX_FAILED16)) {
  273. dev->trans_start = jiffies;
  274. de600_setup_address(tx_fifo[tx_fifo_out], TX_ADDR);
  275. de600_put_command(TX_ENABLE);
  276. return 1;
  277. }
  278. /* else */
  279. return 0;
  280. }
  281. /*
  282. * We have a good packet, get it out of the adapter.
  283. */
  284. static void de600_rx_intr(struct net_device *dev)
  285. {
  286. struct sk_buff *skb;
  287. int i;
  288. int read_from;
  289. int size;
  290. unsigned char *buffer;
  291. /* Get size of received packet */
  292. size = de600_read_byte(RX_LEN, dev); /* low byte */
  293. size += (de600_read_byte(RX_LEN, dev) << 8); /* high byte */
  294. size -= 4; /* Ignore trailing 4 CRC-bytes */
  295. /* Tell adapter where to store next incoming packet, enable receiver */
  296. read_from = rx_page_adr();
  297. next_rx_page();
  298. de600_put_command(RX_ENABLE);
  299. if ((size < 32) || (size > 1535)) {
  300. printk(KERN_WARNING "%s: Bogus packet size %d.\n", dev->name, size);
  301. if (size > 10000)
  302. adapter_init(dev);
  303. return;
  304. }
  305. skb = dev_alloc_skb(size+2);
  306. if (skb == NULL) {
  307. printk("%s: Couldn't allocate a sk_buff of size %d.\n", dev->name, size);
  308. return;
  309. }
  310. /* else */
  311. skb->dev = dev;
  312. skb_reserve(skb,2); /* Align */
  313. /* 'skb->data' points to the start of sk_buff data area. */
  314. buffer = skb_put(skb,size);
  315. /* copy the packet into the buffer */
  316. de600_setup_address(read_from, RW_ADDR);
  317. for (i = size; i > 0; --i, ++buffer)
  318. *buffer = de600_read_byte(READ_DATA, dev);
  319. skb->protocol=eth_type_trans(skb,dev);
  320. netif_rx(skb);
  321. /* update stats */
  322. dev->last_rx = jiffies;
  323. ((struct net_device_stats *)(dev->priv))->rx_packets++; /* count all receives */
  324. ((struct net_device_stats *)(dev->priv))->rx_bytes += size; /* count all received bytes */
  325. /*
  326. * If any worth-while packets have been received, netif_rx()
  327. * will work on them when we get to the tasklets.
  328. */
  329. }
  330. static struct net_device * __init de600_probe(void)
  331. {
  332. int i;
  333. struct net_device *dev;
  334. int err;
  335. dev = alloc_etherdev(sizeof(struct net_device_stats));
  336. if (!dev)
  337. return ERR_PTR(-ENOMEM);
  338. SET_MODULE_OWNER(dev);
  339. if (!request_region(DE600_IO, 3, "de600")) {
  340. printk(KERN_WARNING "DE600: port 0x%x busy\n", DE600_IO);
  341. err = -EBUSY;
  342. goto out;
  343. }
  344. printk(KERN_INFO "%s: D-Link DE-600 pocket adapter", dev->name);
  345. /* Alpha testers must have the version number to report bugs. */
  346. if (de600_debug > 1)
  347. printk(version);
  348. /* probe for adapter */
  349. err = -ENODEV;
  350. rx_page = 0;
  351. select_nic();
  352. (void)de600_read_status(dev);
  353. de600_put_command(RESET);
  354. de600_put_command(STOP_RESET);
  355. if (de600_read_status(dev) & 0xf0) {
  356. printk(": not at I/O %#3x.\n", DATA_PORT);
  357. goto out1;
  358. }
  359. /*
  360. * Maybe we found one,
  361. * have to check if it is a D-Link DE-600 adapter...
  362. */
  363. /* Get the adapter ethernet address from the ROM */
  364. de600_setup_address(NODE_ADDRESS, RW_ADDR);
  365. for (i = 0; i < ETH_ALEN; i++) {
  366. dev->dev_addr[i] = de600_read_byte(READ_DATA, dev);
  367. dev->broadcast[i] = 0xff;
  368. }
  369. /* Check magic code */
  370. if ((dev->dev_addr[1] == 0xde) && (dev->dev_addr[2] == 0x15)) {
  371. /* OK, install real address */
  372. dev->dev_addr[0] = 0x00;
  373. dev->dev_addr[1] = 0x80;
  374. dev->dev_addr[2] = 0xc8;
  375. dev->dev_addr[3] &= 0x0f;
  376. dev->dev_addr[3] |= 0x70;
  377. } else {
  378. printk(" not identified in the printer port\n");
  379. goto out1;
  380. }
  381. printk(", Ethernet Address: %02X", dev->dev_addr[0]);
  382. for (i = 1; i < ETH_ALEN; i++)
  383. printk(":%02X",dev->dev_addr[i]);
  384. printk("\n");
  385. dev->get_stats = get_stats;
  386. dev->open = de600_open;
  387. dev->stop = de600_close;
  388. dev->hard_start_xmit = &de600_start_xmit;
  389. dev->flags&=~IFF_MULTICAST;
  390. select_prn();
  391. err = register_netdev(dev);
  392. if (err)
  393. goto out1;
  394. return dev;
  395. out1:
  396. release_region(DE600_IO, 3);
  397. out:
  398. free_netdev(dev);
  399. return ERR_PTR(err);
  400. }
  401. static int adapter_init(struct net_device *dev)
  402. {
  403. int i;
  404. select_nic();
  405. rx_page = 0; /* used by RESET */
  406. de600_put_command(RESET);
  407. de600_put_command(STOP_RESET);
  408. /* Check if it is still there... */
  409. /* Get the some bytes of the adapter ethernet address from the ROM */
  410. de600_setup_address(NODE_ADDRESS, RW_ADDR);
  411. de600_read_byte(READ_DATA, dev);
  412. if ((de600_read_byte(READ_DATA, dev) != 0xde) ||
  413. (de600_read_byte(READ_DATA, dev) != 0x15)) {
  414. /* was: if (de600_read_status(dev) & 0xf0) { */
  415. printk("Something has happened to the DE-600! Please check it and do a new ifconfig!\n");
  416. /* Goodbye, cruel world... */
  417. dev->flags &= ~IFF_UP;
  418. de600_close(dev);
  419. was_down = 1;
  420. netif_stop_queue(dev); /* Transmit busy... */
  421. return 1; /* failed */
  422. }
  423. if (was_down) {
  424. printk(KERN_INFO "%s: Thanks, I feel much better now!\n", dev->name);
  425. was_down = 0;
  426. }
  427. tx_fifo_in = 0;
  428. tx_fifo_out = 0;
  429. free_tx_pages = TX_PAGES;
  430. /* set the ether address. */
  431. de600_setup_address(NODE_ADDRESS, RW_ADDR);
  432. for (i = 0; i < ETH_ALEN; i++)
  433. de600_put_byte(dev->dev_addr[i]);
  434. /* where to start saving incoming packets */
  435. rx_page = RX_BP | RX_BASE_PAGE;
  436. de600_setup_address(MEM_4K, RW_ADDR);
  437. /* Enable receiver */
  438. de600_put_command(RX_ENABLE);
  439. select_prn();
  440. netif_start_queue(dev);
  441. return 0; /* OK */
  442. }
  443. static struct net_device *de600_dev;
  444. static int __init de600_init(void)
  445. {
  446. de600_dev = de600_probe();
  447. if (IS_ERR(de600_dev))
  448. return PTR_ERR(de600_dev);
  449. return 0;
  450. }
  451. static void __exit de600_exit(void)
  452. {
  453. unregister_netdev(de600_dev);
  454. release_region(DE600_IO, 3);
  455. free_netdev(de600_dev);
  456. }
  457. module_init(de600_init);
  458. module_exit(de600_exit);
  459. MODULE_LICENSE("GPL");