开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
catc.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：23k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

catc.c：源码内容
  1. /*
  2.  *  Copyright (c) 2001 Vojtech Pavlik
  3.  *
  4.  *  CATC EL1210A NetMate USB Ethernet driver
  5.  *
  6.  *  Sponsored by SuSE
  7.  *
  8.  *  Based on the work of
  9.  * Donald Becker
  10.  * 
  11.  *  Old chipset support added by Simon Evans <spse@secret.org.uk> 2002
  12.  *    - adds support for Belkin F5U011
  13.  */
  15. /*
  16.  * This program is free software; you can redistribute it and/or modify
  17.  * it under the terms of the GNU General Public License as published by
  18.  * the Free Software Foundation; either version 2 of the License, or 
  19.  * (at your option) any later version.
  20.  * 
  21.  * This program is distributed in the hope that it will be useful,
  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24.  * GNU General Public License for more details.
  25.  * 
  26.  * You should have received a copy of the GNU General Public License
  27.  * along with this program; if not, write to the Free Software
  28.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29.  * 
  30.  * Should you need to contact me, the author, you can do so either by
  31.  * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
  32.  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  33.  */
  35. #include <linux/init.h>
  36. #include <linux/module.h>
  37. #include <linux/kernel.h>
  38. #include <linux/string.h>
  39. #include <linux/slab.h>
  40. #include <linux/netdevice.h>
  41. #include <linux/etherdevice.h>
  42. #include <linux/skbuff.h>
  43. #include <linux/spinlock.h>
  44. #include <linux/ethtool.h>
  45. #include <asm/bitops.h>
  46. #include <asm/uaccess.h>
  48. #undef DEBUG
  50. #include <linux/usb.h>
  52. /*
  53.  * Version information.
  54.  */
  56. #define DRIVER_VERSION "v2.8"
  57. #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@suse.cz>"
  58. #define DRIVER_DESC "CATC EL1210A NetMate USB Ethernet driver"
  59. #define SHORT_DRIVER_DESC "EL1210A NetMate USB Ethernet"
  61. MODULE_AUTHOR(DRIVER_AUTHOR);
  62. MODULE_DESCRIPTION(DRIVER_DESC);
  63. MODULE_LICENSE("GPL");
  65. /*
  66.  * Some defines.
  67.  */ 
  69. #define STATS_UPDATE (HZ) /* Time between stats updates */
  70. #define TX_TIMEOUT (5*HZ) /* Max time the queue can be stopped */
  71. #define PKT_SZ 1536 /* Max Ethernet packet size */
  72. #define RX_MAX_BURST 15 /* Max packets per rx buffer (> 0, < 16) */
  73. #define TX_MAX_BURST 15 /* Max full sized packets per tx buffer (> 0) */
  74. #define CTRL_QUEUE 16 /* Max control requests in flight (power of two) */
  75. #define RX_PKT_SZ 1600 /* Max size of receive packet for F5U011 */
  77. /*
  78.  * Control requests.
  79.  */
  81. enum control_requests {
  82. ReadMem = 0xf1,
  83. GetMac = 0xf2,
  84. Reset = 0xf4,
  85. SetMac = 0xf5,
  86. SetRxMode =     0xf5,  /* F5U011 only */
  87. WriteROM = 0xf8,
  88. SetReg = 0xfa,
  89. GetReg = 0xfb,
  90. WriteMem = 0xfc,
  91. ReadROM = 0xfd,
  92. };
  94. /*
  95.  * Registers.
  96.  */
  98. enum register_offsets {
  99. TxBufCount = 0x20,
  100. RxBufCount = 0x21,
  101. OpModes = 0x22,
  102. TxQed = 0x23,
  103. RxQed = 0x24,
  104. MaxBurst = 0x25,
  105. RxUnit = 0x60,
  106. EthStatus = 0x61,
  107. StationAddr0 = 0x67,
  108. EthStats = 0x69,
  109. LEDCtrl = 0x81,
  110. };
  112. enum eth_stats {
  113. TxSingleColl = 0x00,
  114.         TxMultiColl = 0x02,
  115.         TxExcessColl = 0x04,
  116.         RxFramErr = 0x06,
  117. };
  119. enum op_mode_bits {
  120. Op3MemWaits = 0x03,
  121. OpLenInclude = 0x08,
  122. OpRxMerge = 0x10,
  123. OpTxMerge = 0x20,
  124. OpWin95bugfix = 0x40,
  125. OpLoopback = 0x80,
  126. };
  128. enum rx_filter_bits {
  129. RxEnable = 0x01,
  130. RxPolarity = 0x02,
  131. RxForceOK = 0x04,
  132. RxMultiCast = 0x08,
  133. RxPromisc = 0x10,
  134. AltRxPromisc =  0x20, /* F5U011 uses different bit */
  135. };
  137. enum led_values {
  138. LEDFast =  0x01,
  139. LEDSlow = 0x02,
  140. LEDFlash = 0x03,
  141. LEDPulse = 0x04,
  142. LEDLink = 0x08,
  143. };
  145. enum link_status {
  146. LinkNoChange = 0,
  147. LinkGood     = 1,
  148. LinkBad      = 2
  149. };
  151. /*
  152.  * The catc struct.
  153.  */
  155. #define CTRL_RUNNING 0
  156. #define RX_RUNNING 1
  157. #define TX_RUNNING 2
  159. struct catc {
  160. struct net_device *netdev;
  161. struct usb_device *usbdev;
  163. struct net_device_stats stats;
  164. unsigned long flags;
  166. unsigned int tx_ptr, tx_idx;
  167. unsigned int ctrl_head, ctrl_tail;
  168. spinlock_t tx_lock, ctrl_lock;
  170. u8 tx_buf[2][TX_MAX_BURST * (PKT_SZ + 2)];
  171. u8 rx_buf[RX_MAX_BURST * (PKT_SZ + 2)];
  172. u8 irq_buf[2];
  173. u8 ctrl_buf[64];
  174. struct usb_ctrlrequest ctrl_dr;
  176. struct timer_list timer;
  177. u8 stats_buf[8];
  178. u16 stats_vals[4];
  179. unsigned long last_stats;
  181. u8 multicast[64];
  183. struct ctrl_queue {
  184. u8 dir;
  185. u8 request;
  186. u16 value;
  187. u16 index;
  188. void *buf;
  189. int len;
  190. void (*callback)(struct catc *catc, struct ctrl_queue *q);
  191. } ctrl_queue[CTRL_QUEUE];
  193. struct urb tx_urb, rx_urb, irq_urb, ctrl_urb;
  195. u8 is_f5u011; /* Set if device is an F5U011 */
  196. u8 rxmode[2]; /* Used for F5U011 */
  197. atomic_t recq_sz; /* Used for F5U011 - counter of waiting rx packets */
  198. };
  200. /*
  201.  * Useful macros.
  202.  */
  204. #define catc_get_mac(catc, mac) catc_ctrl_msg(catc, USB_DIR_IN,  GetMac, 0, 0, mac,  6)
  205. #define catc_reset(catc) catc_ctrl_msg(catc, USB_DIR_OUT, Reset, 0, 0, NULL, 0)
  206. #define catc_set_reg(catc, reg, val) catc_ctrl_msg(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0)
  207. #define catc_get_reg(catc, reg, buf) catc_ctrl_msg(catc, USB_DIR_IN,  GetReg, 0, reg, buf, 1)
  208. #define catc_write_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size)
  209. #define catc_read_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_IN,  ReadMem, 0, addr, buf, size)
  211. #define f5u011_rxmode(catc, rxmode) catc_ctrl_msg(catc, USB_DIR_OUT, SetRxMode, 0, 1, rxmode, 2)
  212. #define f5u011_rxmode_async(catc, rxmode) catc_ctrl_async(catc, USB_DIR_OUT, SetRxMode, 0, 1, &rxmode, 2, NULL)
  213. #define f5u011_mchash_async(catc, hash) catc_ctrl_async(catc, USB_DIR_OUT, SetRxMode, 0, 2, &hash, 8, NULL)
  215. #define catc_set_reg_async(catc, reg, val) catc_ctrl_async(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0, NULL)
  216. #define catc_get_reg_async(catc, reg, cb) catc_ctrl_async(catc, USB_DIR_IN, GetReg, 0, reg, NULL, 1, cb)
  217. #define catc_write_mem_async(catc, addr, buf, size) catc_ctrl_async(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size, NULL)
  219. /*
  220.  * Receive routines.
  221.  */
  223. static void catc_rx_done(struct urb *urb)
  224. {
  225. struct catc *catc = urb->context;
  226. u8 *pkt_start = urb->transfer_buffer;
  227. struct sk_buff *skb;
  228. int pkt_len, pkt_offset = 0;
  230. if (!catc->is_f5u011) {
  231. clear_bit(RX_RUNNING, &catc->flags);
  232. pkt_offset = 2;
  233. }
  235. if (urb->status) {
  236. dbg("rx_done, status %d, length %d", urb->status, urb->actual_length);
  237. return;
  238. }
  240. do {
  241. if(!catc->is_f5u011) {
  242. pkt_len = le16_to_cpup((u16*)pkt_start);
  243. if (pkt_len > urb->actual_length) {
  244. catc->stats.rx_length_errors++;
  245. catc->stats.rx_errors++;
  246. break;
  247. }
  248. } else {
  249. pkt_len = urb->actual_length;
  250. }
  252. if (!(skb = dev_alloc_skb(pkt_len)))
  253. return;
  255. skb->dev = catc->netdev;
  256. eth_copy_and_sum(skb, pkt_start + pkt_offset, pkt_len, 0);
  257. skb_put(skb, pkt_len);
  259. skb->protocol = eth_type_trans(skb, catc->netdev);
  260. netif_rx(skb);
  262. catc->stats.rx_packets++;
  263. catc->stats.rx_bytes += pkt_len;
  265. /* F5U011 only does one packet per RX */
  266. if (catc->is_f5u011)
  267. break;
  268. pkt_start += (((pkt_len + 1) >> 6) + 1) << 6;
  270. } while (pkt_start - (u8 *) urb->transfer_buffer < urb->actual_length);
  272. catc->netdev->last_rx = jiffies;
  274. if (catc->is_f5u011) {
  275. if (atomic_read(&catc->recq_sz)) {
  276. int status;
  277. atomic_dec(&catc->recq_sz);
  278. dbg("getting extra packet");
  279. urb->dev = catc->usbdev;
  280. if ((status = usb_submit_urb(urb)) < 0) {
  281. dbg("submit(rx_urb) status %d", status);
  282. }
  283. } else {
  284. clear_bit(RX_RUNNING, &catc->flags);
  285. }
  286. }
  287. }
  289. static void catc_irq_done(struct urb *urb)
  290. {
  291. struct catc *catc = urb->context;
  292. u8 *data = urb->transfer_buffer;
  293. int status;
  294. unsigned int hasdata = 0, linksts = LinkNoChange;
  296. if (!catc->is_f5u011) {
  297. hasdata = data[1] & 0x80;
  298. if (data[1] & 0x40)
  299. linksts = LinkGood;
  300. else if (data[1] & 0x20)
  301. linksts = LinkBad;
  302. } else {
  303. hasdata = (unsigned int)(be16_to_cpup((u16*)data) & 0x0fff);
  304. if (data[0] == 0x90)
  305. linksts = LinkGood;
  306. else if (data[0] == 0xA0)
  307. linksts = LinkBad;
  308. }
  310. if (urb->status) {
  311. dbg("irq_done, status %d, data %02x %02x.", urb->status, data[0], data[1]);
  312. return;
  313. }
  315. if (linksts == LinkGood) {
  316. netif_carrier_on(catc->netdev);
  317. dbg("link ok");
  318. }
  320. if (linksts == LinkBad) {
  321. netif_carrier_off(catc->netdev);
  322. dbg("link bad");
  323. }
  325. if (hasdata) {
  326. if (test_and_set_bit(RX_RUNNING, &catc->flags)) {
  327. if (catc->is_f5u011)
  328. atomic_inc(&catc->recq_sz);
  329. } else {
  330. catc->rx_urb.dev = catc->usbdev;
  331. if ((status = usb_submit_urb(&catc->rx_urb)) < 0) {
  332. err("submit(rx_urb) status %d", status);
  333. }
  334. } 
  335. }
  336. }
  338. /*
  339.  * Transmit routines.
  340.  */
  342. static void catc_tx_run(struct catc *catc)
  343. {
  344. int status;
  346. if (catc->is_f5u011)
  347. catc->tx_ptr = (catc->tx_ptr + 63) & ~63;
  349. catc->tx_urb.transfer_buffer_length = catc->tx_ptr;
  350. catc->tx_urb.transfer_buffer = catc->tx_buf[catc->tx_idx];
  351. catc->tx_urb.dev = catc->usbdev;
  353. if ((status = usb_submit_urb(&catc->tx_urb)) < 0)
  354. err("submit(tx_urb), status %d", status);
  356. catc->tx_idx = !catc->tx_idx;
  357. catc->tx_ptr = 0;
  359. catc->netdev->trans_start = jiffies;
  360. }
  362. static void catc_tx_done(struct urb *urb)
  363. {
  364. struct catc *catc = urb->context;
  365. unsigned long flags;
  367. if (urb->status == -ECONNRESET) {
  368. dbg("Tx Reset.");
  369. urb->transfer_flags &= ~USB_ASYNC_UNLINK;
  370. urb->status = 0;
  371. catc->netdev->trans_start = jiffies;
  372. catc->stats.tx_errors++;
  373. clear_bit(TX_RUNNING, &catc->flags);
  374. netif_wake_queue(catc->netdev);
  375. return;
  376. }
  378. if (urb->status) {
  379. dbg("tx_done, status %d, length %d", urb->status, urb->actual_length);
  380. return;
  381. }
  383. spin_lock_irqsave(&catc->tx_lock, flags);
  385. if (catc->tx_ptr)
  386. catc_tx_run(catc);
  387. else
  388. clear_bit(TX_RUNNING, &catc->flags);
  390. netif_wake_queue(catc->netdev);
  392. spin_unlock_irqrestore(&catc->tx_lock, flags);
  393. }
  395. static int catc_hard_start_xmit(struct sk_buff *skb, struct net_device *netdev)
  396. {
  397. struct catc *catc = netdev->priv;
  398. unsigned long flags;
  399. char *tx_buf;
  401. spin_lock_irqsave(&catc->tx_lock, flags);
  403. catc->tx_ptr = (((catc->tx_ptr - 1) >> 6) + 1) << 6;
  404. tx_buf = catc->tx_buf[catc->tx_idx] + catc->tx_ptr;
  405. *((u16*)tx_buf) = (catc->is_f5u011) ? 
  406. cpu_to_be16((u16)skb->len) : cpu_to_le16((u16)skb->len);
  407. memcpy(tx_buf + 2, skb->data, skb->len);
  408. catc->tx_ptr += skb->len + 2;
  410. if (!test_and_set_bit(TX_RUNNING, &catc->flags))
  411. catc_tx_run(catc);
  413. if ((catc->is_f5u011 && catc->tx_ptr)
  414.      || (catc->tx_ptr >= ((TX_MAX_BURST - 1) * (PKT_SZ + 2))))
  415. netif_stop_queue(netdev);
  417. spin_unlock_irqrestore(&catc->tx_lock, flags);
  419. catc->stats.tx_bytes += skb->len;
  420. catc->stats.tx_packets++;
  422. dev_kfree_skb(skb);
  424. return 0;
  425. }
  427. static void catc_tx_timeout(struct net_device *netdev)
  428. {
  429. struct catc *catc = netdev->priv;
  431. warn("Transmit timed out.");
  432. catc->tx_urb.transfer_flags |= USB_ASYNC_UNLINK;
  433. usb_unlink_urb(&catc->tx_urb);
  434. }
  436. /*
  437.  * Control messages.
  438.  */
  440. static int catc_ctrl_msg(struct catc *catc, u8 dir, u8 request, u16 value, u16 index, void *buf, int len)
  441. {
  442.         int retval = usb_control_msg(catc->usbdev,
  443. dir ? usb_rcvctrlpipe(catc->usbdev, 0) : usb_sndctrlpipe(catc->usbdev, 0),
  444.  request, 0x40 | dir, value, index, buf, len, HZ);
  445.         return retval < 0 ? retval : 0;
  446. }
  448. static void catc_ctrl_run(struct catc *catc)
  449. {
  450. struct ctrl_queue *q = catc->ctrl_queue + catc->ctrl_tail;
  451. struct usb_device *usbdev = catc->usbdev;
  452. struct urb *urb = &catc->ctrl_urb;
  453. struct usb_ctrlrequest *dr = &catc->ctrl_dr;
  454. int status;
  456. dr->bRequest = q->request;
  457. dr->bRequestType = 0x40 | q->dir;
  458. dr->wValue = cpu_to_le16(q->value);
  459. dr->wIndex = cpu_to_le16(q->index);
  460. dr->wLength = cpu_to_le16(q->len);
  462.         urb->pipe = q->dir ? usb_rcvctrlpipe(usbdev, 0) : usb_sndctrlpipe(usbdev, 0);
  463. urb->transfer_buffer_length = q->len;
  464. urb->transfer_buffer = catc->ctrl_buf;
  465. urb->setup_packet = (void *) dr;
  466. urb->dev = usbdev;
  468. if (!q->dir && q->buf && q->len)
  469. memcpy(catc->ctrl_buf, q->buf, q->len);
  471. if ((status = usb_submit_urb(&catc->ctrl_urb)))
  472. err("submit(ctrl_urb) status %d", status);
  473. }
  475. static void catc_ctrl_done(struct urb *urb)
  476. {
  477. struct catc *catc = urb->context;
  478. struct ctrl_queue *q;
  479. unsigned long flags;
  481. if (urb->status)
  482. dbg("ctrl_done, status %d, len %d.", urb->status, urb->actual_length);
  484. spin_lock_irqsave(&catc->ctrl_lock, flags);
  486. q = catc->ctrl_queue + catc->ctrl_tail;
  488. if (q->dir) {
  489. if (q->buf && q->len)
  490. memcpy(q->buf, catc->ctrl_buf, q->len);
  491. else
  492. q->buf = catc->ctrl_buf;
  493. }
  495. if (q->callback)
  496. q->callback(catc, q);
  498. catc->ctrl_tail = (catc->ctrl_tail + 1) & (CTRL_QUEUE - 1);
  500. if (catc->ctrl_head != catc->ctrl_tail)
  501. catc_ctrl_run(catc);
  502. else
  503. clear_bit(CTRL_RUNNING, &catc->flags);
  505. spin_unlock_irqrestore(&catc->ctrl_lock, flags);
  506. }
  508. static int catc_ctrl_async(struct catc *catc, u8 dir, u8 request, u16 value,
  509. u16 index, void *buf, int len, void (*callback)(struct catc *catc, struct ctrl_queue *q))
  510. {
  511. struct ctrl_queue *q;
  512. int retval = 0;
  513. unsigned long flags;
  515. spin_lock_irqsave(&catc->ctrl_lock, flags);
  517. q = catc->ctrl_queue + catc->ctrl_head;
  519. q->dir = dir;
  520. q->request = request;
  521. q->value = value;
  522. q->index = index;
  523. q->buf = buf;
  524. q->len = len;
  525. q->callback = callback;
  527. catc->ctrl_head = (catc->ctrl_head + 1) & (CTRL_QUEUE - 1);
  529. if (catc->ctrl_head == catc->ctrl_tail) {
  530. err("ctrl queue full");
  531. catc->ctrl_tail = (catc->ctrl_tail + 1) & (CTRL_QUEUE - 1);
  532. retval = -1;
  533. }
  535. if (!test_and_set_bit(CTRL_RUNNING, &catc->flags))
  536. catc_ctrl_run(catc);
  538. spin_unlock_irqrestore(&catc->ctrl_lock, flags);
  540. return retval;
  541. }
  543. /*
  544.  * Statistics.
  545.  */
  547. static void catc_stats_done(struct catc *catc, struct ctrl_queue *q)
  548. {
  549. int index = q->index - EthStats;
  550. u16 data, last;
  552. catc->stats_buf[index] = *((char *)q->buf);
  554. if (index & 1)
  555. return;
  557. data = ((u16)catc->stats_buf[index] << 8) | catc->stats_buf[index + 1];
  558. last = catc->stats_vals[index >> 1];
  560. switch (index) {
  561. case TxSingleColl:
  562. case TxMultiColl:
  563. catc->stats.collisions += data - last;
  564. break;
  565. case TxExcessColl:
  566. catc->stats.tx_aborted_errors += data - last;
  567. catc->stats.tx_errors += data - last;
  568. break;
  569. case RxFramErr:
  570. catc->stats.rx_frame_errors += data - last;
  571. catc->stats.rx_errors += data - last;
  572. break;
  573. }
  575. catc->stats_vals[index >> 1] = data;
  576. }
  578. static void catc_stats_timer(unsigned long data)
  579. {
  580. struct catc *catc = (void *) data;
  581. int i;
  583. for (i = 0; i < 8; i++)
  584. catc_get_reg_async(catc, EthStats + 7 - i, catc_stats_done);
  586. mod_timer(&catc->timer, jiffies + STATS_UPDATE);
  587. }
  589. static struct net_device_stats *catc_get_stats(struct net_device *netdev)
  590. {
  591. struct catc *catc = netdev->priv;
  592. return &catc->stats;
  593. }
  595. /*
  596.  * Receive modes. Broadcast, Multicast, Promisc.
  597.  */
  599. static inline u32 ether_crc_le(int cnt, unsigned char *addr)
  600. {
  601. unsigned int crc = 0xffffffff;
  602. u8 byte, idx, bit;
  604.         for (idx = 0; idx < cnt; idx++)
  605.                 for (byte = *addr++, bit = 0; bit < 8; bit++, byte >>= 1)
  606.                         crc = (crc >> 1) ^ (((crc ^ byte) & 1) ? 0xedb88320U : 0);
  607. return crc;
  608. }
  610. static void catc_multicast(unsigned char *addr, u8 *multicast)
  611. {
  612. unsigned int crc = ether_crc_le(6, addr);
  613. multicast[(crc >> 3) & 0x3f] |= 1 << (crc & 7);
  614. }
  616. static void catc_set_multicast_list(struct net_device *netdev)
  617. {
  618. struct catc *catc = netdev->priv;
  619. struct dev_mc_list *mc;
  620. u8 broadcast[6];
  621. u8 rx = RxEnable | RxPolarity | RxMultiCast;
  622. int i;
  624. memset(broadcast, 0xff, 6);
  625. memset(catc->multicast, 0, 64);
  627. catc_multicast(broadcast, catc->multicast);
  628. catc_multicast(netdev->dev_addr, catc->multicast);
  630. if (netdev->flags & IFF_PROMISC) {
  631. memset(catc->multicast, 0xff, 64);
  632. rx |= (!catc->is_f5u011) ? RxPromisc : AltRxPromisc;
  633. } 
  635. if (netdev->flags & IFF_ALLMULTI) {
  636. memset(catc->multicast, 0xff, 64);
  637. } else {
  638. for (i = 0, mc = netdev->mc_list; mc && i < netdev->mc_count; i++, mc = mc->next) {
  639. u32 crc = ether_crc_le(6, mc->dmi_addr);
  640. if (!catc->is_f5u011) {
  641. catc->multicast[(crc >> 3) & 0x3f] |= 1 << (crc & 7);
  642. } else {
  643. catc->multicast[7-(crc >> 29)] |= 1 << ((crc >> 26) & 7);
  644. }
  645. }
  646. }
  647. if (!catc->is_f5u011) {
  648. catc_set_reg_async(catc, RxUnit, rx);
  649. catc_write_mem_async(catc, 0xfa80, catc->multicast, 64);
  650. } else {
  651. f5u011_mchash_async(catc, catc->multicast);
  652. if (catc->rxmode[0] != rx) {
  653. catc->rxmode[0] = rx;
  654. dbg("Setting RX mode to %2.2X %2.2X", catc->rxmode[0],
  655.     catc->rxmode[1]);
  656. f5u011_rxmode_async(catc, catc->rxmode);
  657. }
  658. }
  659. }
  661. /*
  662.  * ioctl's
  663.  */
  664. static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
  665. {
  666.         struct catc *catc = dev->priv;
  667.         u32 cmd;
  668. char tmp[40];
  669.         
  670.         if (get_user(cmd, (u32 *)useraddr))
  671.                 return -EFAULT;
  673.         switch (cmd) {
  674.         /* get driver info */
  675.         case ETHTOOL_GDRVINFO: {
  676.                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
  677.                 strncpy(info.driver, SHORT_DRIVER_DESC, ETHTOOL_BUSINFO_LEN);
  678.                 strncpy(info.version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
  679. sprintf(tmp, "usb%d:%d", catc->usbdev->bus->busnum, catc->usbdev->devnum);
  680.                 strncpy(info.bus_info, tmp,ETHTOOL_BUSINFO_LEN);
  681.                 if (copy_to_user(useraddr, &info, sizeof(info)))
  682.                         return -EFAULT;
  683.                 return 0;
  684.         }
  686. /* get settings */
  687. case ETHTOOL_GSET:
  688. if (catc->is_f5u011) {
  689. struct ethtool_cmd ecmd = { 
  690. ETHTOOL_GSET, 
  691. SUPPORTED_10baseT_Half | SUPPORTED_TP, 
  692. ADVERTISED_10baseT_Half | ADVERTISED_TP, 
  693. SPEED_10, 
  694. DUPLEX_HALF, 
  695. PORT_TP, 
  696. 0, 
  697. XCVR_INTERNAL, 
  698. AUTONEG_DISABLE, 
  699. 1, 
  700. 1 
  701. };
  702. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  703. return -EFAULT;
  704. return 0;
  705. } else {
  706. return -EOPNOTSUPP;
  707. }
  709.         /* get link status */
  710.         case ETHTOOL_GLINK: {
  711.                 struct ethtool_value edata = {ETHTOOL_GLINK};
  712.                 edata.data = netif_carrier_ok(dev);
  713.                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
  714.                         return -EFAULT;
  715.                 return 0;
  716.         }
  717. }
  718.         /* Note that the ethtool user space code requires EOPNOTSUPP */
  719.         return -EOPNOTSUPP;
  720. }
  722. static int catc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  723. {
  724.         switch(cmd) {
  725.         case SIOCETHTOOL:
  726.        return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
  727.         default:
  728.        return -ENOTTY; /* Apparently this is the standard ioctl errno */
  729.         }
  730. }
  733. /*
  734.  * Open, close.
  735.  */
  737. static int catc_open(struct net_device *netdev)
  738. {
  739. struct catc *catc = netdev->priv;
  740. int status;
  742. catc->irq_urb.dev = catc->usbdev;
  743. if ((status = usb_submit_urb(&catc->irq_urb)) < 0) {
  744. err("submit(irq_urb) status %d", status);
  745. return -1;
  746. }
  748. netif_start_queue(netdev);
  750. if (!catc->is_f5u011)
  751. mod_timer(&catc->timer, jiffies + STATS_UPDATE);
  753. return 0;
  754. }
  756. static int catc_stop(struct net_device *netdev)
  757. {
  758. struct catc *catc = netdev->priv;
  760. netif_stop_queue(netdev);
  762. if (!catc->is_f5u011)
  763. del_timer_sync(&catc->timer);
  765. usb_unlink_urb(&catc->rx_urb);
  766. usb_unlink_urb(&catc->tx_urb);
  767. usb_unlink_urb(&catc->irq_urb);
  768. usb_unlink_urb(&catc->ctrl_urb);
  770. return 0;
  771. }
  773. /*
  774.  * USB probe, disconnect.
  775.  */
  777. static void *catc_probe(struct usb_device *usbdev, unsigned int ifnum, const struct usb_device_id *id)
  778. {
  779. struct net_device *netdev;
  780. struct catc *catc;
  781. u8 broadcast[6];
  782. int i, pktsz;
  784. if (usb_set_interface(usbdev, ifnum, 1)) {
  785.                 err("Can't set altsetting 1.");
  786. return NULL;
  787. }
  789. catc = kmalloc(sizeof(struct catc), GFP_KERNEL);
  790. if (!catc)
  791. return NULL;
  793. memset(catc, 0, sizeof(struct catc));
  795. netdev = init_etherdev(0, 0);
  796. if (!netdev) {
  797. kfree(catc);
  798. return NULL;
  799. }
  801. netdev->open = catc_open;
  802. netdev->hard_start_xmit = catc_hard_start_xmit;
  803. netdev->stop = catc_stop;
  804. netdev->get_stats = catc_get_stats;
  805. netdev->tx_timeout = catc_tx_timeout;
  806. netdev->watchdog_timeo = TX_TIMEOUT;
  807. netdev->set_multicast_list = catc_set_multicast_list;
  808. netdev->do_ioctl = catc_ioctl;
  809. netdev->priv = catc;
  811. catc->usbdev = usbdev;
  812. catc->netdev = netdev;
  814. catc->tx_lock = SPIN_LOCK_UNLOCKED;
  815. catc->ctrl_lock = SPIN_LOCK_UNLOCKED;
  817. init_timer(&catc->timer);
  818. catc->timer.data = (long) catc;
  819. catc->timer.function = catc_stats_timer;
  821. /* The F5U011 has the same vendor/product as the netmate 
  822.  *  but a device version of 0x130
  823.  */
  824. if (usbdev->descriptor.idVendor == 0x0423 && 
  825.     usbdev->descriptor.idProduct == 0xa &&
  826.     catc->usbdev->descriptor.bcdDevice == 0x0130) {
  827. dbg("Testing for f5u011");
  828. catc->is_f5u011 = 1;
  829. atomic_set(&catc->recq_sz, 0);
  830. pktsz = RX_PKT_SZ;
  831. } else {
  832. pktsz = RX_MAX_BURST * (PKT_SZ + 2);
  833. }
  835. FILL_CONTROL_URB(&catc->ctrl_urb, usbdev, usb_sndctrlpipe(usbdev, 0),
  836. NULL, NULL, 0, catc_ctrl_done, catc);
  838. FILL_BULK_URB(&catc->tx_urb, usbdev, usb_sndbulkpipe(usbdev, 1),
  839. NULL, 0, catc_tx_done, catc);
  841. FILL_BULK_URB(&catc->rx_urb, usbdev, usb_rcvbulkpipe(usbdev, 1),
  842. catc->rx_buf, pktsz, catc_rx_done, catc);
  844. FILL_INT_URB(&catc->irq_urb, usbdev, usb_rcvintpipe(usbdev, 2),
  845.                 catc->irq_buf, 2, catc_irq_done, catc, 1);
  847. if (!catc->is_f5u011) {
  848. dbg("Checking memory sizen");
  850. i = 0x12345678;
  851. catc_write_mem(catc, 0x7a80, &i, 4);
  852. i = 0x87654321;
  853. catc_write_mem(catc, 0xfa80, &i, 4);
  854. catc_read_mem(catc, 0x7a80, &i, 4);
  855.   
  856. switch (i) {
  857. case 0x12345678:
  858. catc_set_reg(catc, TxBufCount, 8);
  859. catc_set_reg(catc, RxBufCount, 32);
  860. dbg("64k Memoryn");
  861. break;
  862. default:
  863. warn("Couldn't detect memory size, assuming 32k");
  864. case 0x87654321:
  865. catc_set_reg(catc, TxBufCount, 4);
  866. catc_set_reg(catc, RxBufCount, 16);
  867. dbg("32k Memoryn");
  868. break;
  869. }
  870.   
  871. dbg("Getting MAC from SEEROM.");
  872.   
  873. catc_get_mac(catc, netdev->dev_addr);
  875. dbg("Setting MAC into registers.");
  876.   
  877. for (i = 0; i < 6; i++)
  878. catc_set_reg(catc, StationAddr0 - i, netdev->dev_addr[i]);
  880. dbg("Filling the multicast list.");
  881.   
  882. memset(broadcast, 0xff, 6);
  883. catc_multicast(broadcast, catc->multicast);
  884. catc_multicast(netdev->dev_addr, catc->multicast);
  885. catc_write_mem(catc, 0xfa80, catc->multicast, 64);
  887. dbg("Clearing error counters.");
  889. for (i = 0; i < 8; i++)
  890. catc_set_reg(catc, EthStats + i, 0);
  891. catc->last_stats = jiffies;
  893. dbg("Enabling.");
  895. catc_set_reg(catc, MaxBurst, RX_MAX_BURST);
  896. catc_set_reg(catc, OpModes, OpTxMerge | OpRxMerge | OpLenInclude | Op3MemWaits);
  897. catc_set_reg(catc, LEDCtrl, LEDLink);
  898. catc_set_reg(catc, RxUnit, RxEnable | RxPolarity | RxMultiCast);
  899. } else {
  900. dbg("Performing resetn");
  901. catc_reset(catc);
  902. catc_get_mac(catc, netdev->dev_addr);
  904. dbg("Setting RX Mode");
  905. catc->rxmode[0] = RxEnable | RxPolarity | RxMultiCast;
  906. catc->rxmode[1] = 0;
  907. f5u011_rxmode(catc, catc->rxmode);
  908. }
  909. dbg("Init done.");
  910. printk(KERN_INFO "%s: %s USB Ethernet at usb%d:%d.%d, ",
  911.        netdev->name, (catc->is_f5u011) ? "Belkin F5U011" : "CATC EL1210A NetMate",
  912.        usbdev->bus->busnum, usbdev->devnum, ifnum);
  913. for (i = 0; i < 5; i++) printk("%2.2x:", netdev->dev_addr[i]);
  914. printk("%2.2x.n", netdev->dev_addr[i]);
  915. return catc;
  916. }
  918. static void catc_disconnect(struct usb_device *usbdev, void *dev_ptr)
  919. {
  920. struct catc *catc = dev_ptr;
  921. unregister_netdev(catc->netdev);
  922. kfree(catc->netdev);
  923. kfree(catc);
  924. }
  926. /*
  927.  * Module functions and tables.
  928.  */
  930. static struct usb_device_id catc_id_table [] = {
  931. { USB_DEVICE(0x0423, 0xa) }, /* CATC Netmate, Belkin F5U011 */
  932. { USB_DEVICE(0x0423, 0xc) }, /* CATC Netmate II, Belkin F5U111 */
  933. { USB_DEVICE(0x08d1, 0x1) }, /* smartBridges smartNIC */
  934. { }
  935. };
  937. MODULE_DEVICE_TABLE(usb, catc_id_table);
  939. static struct usb_driver catc_driver = {
  940. name: "catc",
  941. probe: catc_probe,
  942. disconnect: catc_disconnect,
  943. id_table: catc_id_table,
  944. };
  946. static int __init catc_init(void)
  947. {
  948. info(DRIVER_VERSION " " DRIVER_DESC);
  949. usb_register(&catc_driver);
  950. return 0;
  951. }
  953. static void __exit catc_exit(void)
  954. {
  955. usb_deregister(&catc_driver);
  956. }
  958. module_init(catc_init);
  959. module_exit(catc_exit);