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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
catc.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：17k
源码类别：

嵌入式Linux

开发平台：

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.  */
  12. /*
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2 of the License, or 
  16.  * (at your option) any later version.
  17.  * 
  18.  * This program is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  * 
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with this program; if not, write to the Free Software
  25.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26.  * 
  27.  * Should you need to contact me, the author, you can do so either by
  28.  * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
  29.  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  30.  */
  32. #include <linux/init.h>
  33. #include <linux/module.h>
  34. #include <linux/kernel.h>
  35. #include <linux/string.h>
  36. #include <linux/slab.h>
  37. #include <linux/netdevice.h>
  38. #include <linux/etherdevice.h>
  39. #include <linux/skbuff.h>
  40. #include <linux/spinlock.h>
  41. #include <asm/bitops.h>
  43. #undef DEBUG
  45. #include <linux/usb.h>
  47. /*
  48.  * Version information.
  49.  */
  51. #define DRIVER_VERSION "v2.7"
  52. #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@suse.cz>"
  53. #define DRIVER_DESC "CATC EL1210A NetMate USB Ethernet driver"
  55. MODULE_AUTHOR(DRIVER_AUTHOR);
  56. MODULE_DESCRIPTION(DRIVER_DESC);
  57. MODULE_LICENSE("GPL");
  59. /*
  60.  * Some defines.
  61.  */ 
  63. #define STATS_UPDATE (HZ) /* Time between stats updates */
  64. #define TX_TIMEOUT (5*HZ) /* Max time the queue can be stopped */
  65. #define PKT_SZ 1536 /* Max Ethernet packet size */
  66. #define RX_MAX_BURST 15 /* Max packets per rx buffer (> 0, < 16) */
  67. #define TX_MAX_BURST 15 /* Max full sized packets per tx buffer (> 0) */
  68. #define CTRL_QUEUE 16 /* Max control requests in flight (power of two) */
  70. /*
  71.  * Control requests.
  72.  */
  74. enum control_requests {
  75. ReadMem = 0xf1,
  76. GetMac = 0xf2,
  77. Reset = 0xf4,
  78. SetMac = 0xf5,
  79. WriteROM = 0xf8,
  80. SetReg = 0xfa,
  81. GetReg = 0xfb,
  82. WriteMem = 0xfc,
  83. ReadROM = 0xfd,
  84. };
  86. /*
  87.  * Registers.
  88.  */
  90. enum register_offsets {
  91. TxBufCount = 0x20,
  92. RxBufCount = 0x21,
  93. OpModes = 0x22,
  94. TxQed = 0x23,
  95. RxQed = 0x24,
  96. MaxBurst = 0x25,
  97. RxUnit = 0x60,
  98. EthStatus = 0x61,
  99. StationAddr0 = 0x67,
  100. EthStats = 0x69,
  101. LEDCtrl = 0x81,
  102. };
  104. enum eth_stats {
  105. TxSingleColl = 0x00,
  106.         TxMultiColl = 0x02,
  107.         TxExcessColl = 0x04,
  108.         RxFramErr = 0x06,
  109. };
  111. enum op_mode_bits {
  112. Op3MemWaits = 0x03,
  113. OpLenInclude = 0x08,
  114. OpRxMerge = 0x10,
  115. OpTxMerge = 0x20,
  116. OpWin95bugfix = 0x40,
  117. OpLoopback = 0x80,
  118. };
  120. enum rx_filter_bits {
  121. RxEnable = 0x01,
  122. RxPolarity = 0x02,
  123. RxForceOK = 0x04,
  124. RxMultiCast = 0x08,
  125. RxPromisc = 0x10,
  126. };
  128. enum led_values {
  129. LEDFast =  0x01,
  130. LEDSlow = 0x02,
  131. LEDFlash = 0x03,
  132. LEDPulse = 0x04,
  133. LEDLink = 0x08,
  134. };
  136. /*
  137.  * The catc struct.
  138.  */
  140. #define CTRL_RUNNING 0
  141. #define RX_RUNNING 1
  142. #define TX_RUNNING 2
  144. struct catc {
  145. struct net_device *netdev;
  146. struct usb_device *usbdev;
  148. struct net_device_stats stats;
  149. unsigned long flags;
  151. unsigned int tx_ptr, tx_idx;
  152. unsigned int ctrl_head, ctrl_tail;
  153. spinlock_t tx_lock, ctrl_lock;
  155. u8 tx_buf[2][TX_MAX_BURST * (PKT_SZ + 2)];
  156. u8 rx_buf[RX_MAX_BURST * (PKT_SZ + 2)];
  157. u8 irq_buf[2];
  158. u8 ctrl_buf[64];
  159. devrequest ctrl_dr;
  161. struct timer_list timer;
  162. u8 stats_buf[8];
  163. u16 stats_vals[4];
  164. unsigned long last_stats;
  166. u8 multicast[64];
  168. struct ctrl_queue {
  169. u8 dir;
  170. u8 request;
  171. u16 value;
  172. u16 index;
  173. void *buf;
  174. int len;
  175. void (*callback)(struct catc *catc, struct ctrl_queue *q);
  176. } ctrl_queue[CTRL_QUEUE];
  178. struct urb tx_urb, rx_urb, irq_urb, ctrl_urb;
  179. };
  181. /*
  182.  * Useful macros.
  183.  */
  185. #define catc_get_mac(catc, mac) catc_ctrl_msg(catc, USB_DIR_IN,  GetMac, 0, 0, mac,  6)
  186. #define catc_reset(catc) catc_ctrl_msg(catc, USB_DIR_OUT, Reset, 0, 0, NULL, 0)
  187. #define catc_set_reg(catc, reg, val) catc_ctrl_msg(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0)
  188. #define catc_get_reg(catc, reg, buf) catc_ctrl_msg(catc, USB_DIR_IN,  GetReg, 0, reg, buf, 1)
  189. #define catc_write_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size)
  190. #define catc_read_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_IN,  ReadMem, 0, addr, buf, size)
  192. #define catc_set_reg_async(catc, reg, val) catc_ctrl_async(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0, NULL)
  193. #define catc_get_reg_async(catc, reg, cb) catc_ctrl_async(catc, USB_DIR_IN, GetReg, 0, reg, NULL, 1, cb)
  194. #define catc_write_mem_async(catc, addr, buf, size) catc_ctrl_async(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size, NULL)
  196. /*
  197.  * Receive routines.
  198.  */
  200. static void catc_rx_done(struct urb *urb)
  201. {
  202. struct catc *catc = urb->context;
  203. u8 *pkt_start = urb->transfer_buffer;
  204. struct sk_buff *skb;
  205. int pkt_len;
  207. clear_bit(RX_RUNNING, &catc->flags);
  209. if (urb->status) {
  210. dbg("rx_done, status %d, length %d", urb->status, urb->actual_length);
  211. return;
  212. }
  214. do {
  215. pkt_len = le16_to_cpup((u16*)pkt_start);
  217. if (pkt_len > urb->actual_length) {
  218. catc->stats.rx_length_errors++;
  219. catc->stats.rx_errors++;
  220. break;
  221. }
  223. if (!(skb = dev_alloc_skb(pkt_len)))
  224. return;
  226. skb->dev = catc->netdev;
  227. eth_copy_and_sum(skb, pkt_start + 2, pkt_len, 0);
  228. skb_put(skb, pkt_len);
  230. skb->protocol = eth_type_trans(skb, catc->netdev);
  231. netif_rx(skb);
  233. catc->stats.rx_packets++;
  234. catc->stats.rx_bytes += pkt_len;
  236. pkt_start += (((pkt_len + 1) >> 6) + 1) << 6;
  238. } while (pkt_start - (u8 *) urb->transfer_buffer < urb->actual_length);
  240. catc->netdev->last_rx = jiffies;
  241. }
  243. static void catc_irq_done(struct urb *urb)
  244. {
  245. struct catc *catc = urb->context;
  246. u8 *data = urb->transfer_buffer;
  247. int status;
  249. if (urb->status) {
  250. dbg("irq_done, status %d, data %02x %02x.", urb->status, data[0], data[1]);
  251. return;
  252. }
  254. if ((data[1] & 0x80) && !test_and_set_bit(RX_RUNNING, &catc->flags)) {
  255. catc->rx_urb.dev = catc->usbdev;
  256. if ((status = usb_submit_urb(&catc->rx_urb)) < 0) {
  257. err("submit(rx_urb) status %d", status);
  258. return;
  259. } 
  260. }
  262. if (data[1] & 0x40)
  263. dbg("link ok");
  265. if (data[1] & 0x20) 
  266. dbg("link bad");
  267. }
  269. /*
  270.  * Transmit routines.
  271.  */
  273. static void catc_tx_run(struct catc *catc)
  274. {
  275. int status;
  277. catc->tx_urb.transfer_buffer_length = catc->tx_ptr;
  278. catc->tx_urb.transfer_buffer = catc->tx_buf[catc->tx_idx];
  279. catc->tx_urb.dev = catc->usbdev;
  281. if ((status = usb_submit_urb(&catc->tx_urb)) < 0)
  282. err("submit(tx_urb), status %d", status);
  284. catc->tx_idx = !catc->tx_idx;
  285. catc->tx_ptr = 0;
  287. catc->netdev->trans_start = jiffies;
  288. }
  290. static void catc_tx_done(struct urb *urb)
  291. {
  292. struct catc *catc = urb->context;
  293. unsigned long flags;
  295. if (urb->status == -ECONNRESET) {
  296. dbg("Tx Reset.");
  297. urb->transfer_flags &= ~USB_ASYNC_UNLINK;
  298. urb->status = 0;
  299. catc->netdev->trans_start = jiffies;
  300. catc->stats.tx_errors++;
  301. clear_bit(TX_RUNNING, &catc->flags);
  302. netif_wake_queue(catc->netdev);
  303. return;
  304. }
  306. if (urb->status) {
  307. dbg("tx_done, status %d, length %d", urb->status, urb->actual_length);
  308. return;
  309. }
  311. spin_lock_irqsave(&catc->tx_lock, flags);
  313. if (catc->tx_ptr)
  314. catc_tx_run(catc);
  315. else
  316. clear_bit(TX_RUNNING, &catc->flags);
  318. netif_wake_queue(catc->netdev);
  320. spin_unlock_irqrestore(&catc->tx_lock, flags);
  321. }
  323. static int catc_hard_start_xmit(struct sk_buff *skb, struct net_device *netdev)
  324. {
  325. struct catc *catc = netdev->priv;
  326. unsigned long flags;
  327. char *tx_buf;
  329. spin_lock_irqsave(&catc->tx_lock, flags);
  331. catc->tx_ptr = (((catc->tx_ptr - 1) >> 6) + 1) << 6;
  332. tx_buf = catc->tx_buf[catc->tx_idx] + catc->tx_ptr;
  333. *((u16*)tx_buf) = cpu_to_le16((u16)skb->len);
  334. memcpy(tx_buf + 2, skb->data, skb->len);
  335. catc->tx_ptr += skb->len + 2;
  337. if (!test_and_set_bit(TX_RUNNING, &catc->flags))
  338. catc_tx_run(catc);
  340. if (catc->tx_ptr >= ((TX_MAX_BURST - 1) * (PKT_SZ + 2)))
  341. netif_stop_queue(netdev);
  343. spin_unlock_irqrestore(&catc->tx_lock, flags);
  345. catc->stats.tx_bytes += skb->len;
  346. catc->stats.tx_packets++;
  348. dev_kfree_skb(skb);
  350. return 0;
  351. }
  353. static void catc_tx_timeout(struct net_device *netdev)
  354. {
  355. struct catc *catc = netdev->priv;
  357. warn("Transmit timed out.");
  358. catc->tx_urb.transfer_flags |= USB_ASYNC_UNLINK;
  359. usb_unlink_urb(&catc->tx_urb);
  360. }
  362. /*
  363.  * Control messages.
  364.  */
  366. static int catc_ctrl_msg(struct catc *catc, u8 dir, u8 request, u16 value, u16 index, void *buf, int len)
  367. {
  368.         int retval = usb_control_msg(catc->usbdev,
  369. dir ? usb_rcvctrlpipe(catc->usbdev, 0) : usb_sndctrlpipe(catc->usbdev, 0),
  370.  request, 0x40 | dir, value, index, buf, len, HZ);
  371.         return retval < 0 ? retval : 0;
  372. }
  374. static void catc_ctrl_run(struct catc *catc)
  375. {
  376. struct ctrl_queue *q = catc->ctrl_queue + catc->ctrl_tail;
  377. struct usb_device *usbdev = catc->usbdev;
  378. struct urb *urb = &catc->ctrl_urb;
  379. devrequest *dr = &catc->ctrl_dr;
  380. int status;
  382. dr->request = q->request;
  383. dr->requesttype = 0x40 | q->dir;
  384. dr->value = cpu_to_le16(q->value);
  385. dr->index = cpu_to_le16(q->index);
  386. dr->length = cpu_to_le16(q->len);
  388.         urb->pipe = q->dir ? usb_rcvctrlpipe(usbdev, 0) : usb_sndctrlpipe(usbdev, 0);
  389. urb->transfer_buffer_length = q->len;
  390. urb->transfer_buffer = catc->ctrl_buf;
  391. urb->setup_packet = (void *) dr;
  392. urb->dev = usbdev;
  394. if (!q->dir && q->buf && q->len)
  395. memcpy(catc->ctrl_buf, q->buf, q->len);
  397. if ((status = usb_submit_urb(&catc->ctrl_urb)))
  398. err("submit(ctrl_urb) status %d", status);
  399. }
  401. static void catc_ctrl_done(struct urb *urb)
  402. {
  403. struct catc *catc = urb->context;
  404. struct ctrl_queue *q;
  405. long flags;
  407. if (urb->status)
  408. dbg("ctrl_done, status %d, len %d.", urb->status, urb->actual_length);
  410. spin_lock_irqsave(&catc->ctrl_lock, flags);
  412. q = catc->ctrl_queue + catc->ctrl_tail;
  414. if (q->dir) {
  415. if (q->buf && q->len)
  416. memcpy(q->buf, catc->ctrl_buf, q->len);
  417. else
  418. q->buf = catc->ctrl_buf;
  419. }
  421. if (q->callback)
  422. q->callback(catc, q);
  424. catc->ctrl_tail = (catc->ctrl_tail + 1) & (CTRL_QUEUE - 1);
  426. if (catc->ctrl_head != catc->ctrl_tail)
  427. catc_ctrl_run(catc);
  428. else
  429. clear_bit(CTRL_RUNNING, &catc->flags);
  431. spin_unlock_irqrestore(&catc->ctrl_lock, flags);
  432. }
  434. static int catc_ctrl_async(struct catc *catc, u8 dir, u8 request, u16 value,
  435. u16 index, void *buf, int len, void (*callback)(struct catc *catc, struct ctrl_queue *q))
  436. {
  437. struct ctrl_queue *q;
  438. int retval = 0;
  439. long flags;
  441. spin_lock_irqsave(&catc->ctrl_lock, flags);
  443. q = catc->ctrl_queue + catc->ctrl_head;
  445. q->dir = dir;
  446. q->request = request;
  447. q->value = value;
  448. q->index = index;
  449. q->buf = buf;
  450. q->len = len;
  451. q->callback = callback;
  453. catc->ctrl_head = (catc->ctrl_head + 1) & (CTRL_QUEUE - 1);
  455. if (catc->ctrl_head == catc->ctrl_tail) {
  456. err("ctrl queue full");
  457. catc->ctrl_tail = (catc->ctrl_tail + 1) & (CTRL_QUEUE - 1);
  458. retval = -1;
  459. }
  461. if (!test_and_set_bit(CTRL_RUNNING, &catc->flags))
  462. catc_ctrl_run(catc);
  464. spin_unlock_irqrestore(&catc->ctrl_lock, flags);
  466. return retval;
  467. }
  469. /*
  470.  * Statistics.
  471.  */
  473. static void catc_stats_done(struct catc *catc, struct ctrl_queue *q)
  474. {
  475. int index = q->index - EthStats;
  476. u16 data, last;
  478. catc->stats_buf[index] = *((char *)q->buf);
  480. if (index & 1)
  481. return;
  483. data = ((u16)catc->stats_buf[index] << 8) | catc->stats_buf[index + 1];
  484. last = catc->stats_vals[index >> 1];
  486. switch (index) {
  487. case TxSingleColl:
  488. case TxMultiColl:
  489. catc->stats.collisions += data - last;
  490. break;
  491. case TxExcessColl:
  492. catc->stats.tx_aborted_errors += data - last;
  493. catc->stats.tx_errors += data - last;
  494. break;
  495. case RxFramErr:
  496. catc->stats.rx_frame_errors += data - last;
  497. catc->stats.rx_errors += data - last;
  498. break;
  499. }
  501. catc->stats_vals[index >> 1] = data;
  502. }
  504. static void catc_stats_timer(unsigned long data)
  505. {
  506. struct catc *catc = (void *) data;
  507. int i;
  509. for (i = 0; i < 8; i++)
  510. catc_get_reg_async(catc, EthStats + 7 - i, catc_stats_done);
  512. mod_timer(&catc->timer, jiffies + STATS_UPDATE);
  513. }
  515. static struct net_device_stats *catc_get_stats(struct net_device *netdev)
  516. {
  517. struct catc *catc = netdev->priv;
  518. return &catc->stats;
  519. }
  521. /*
  522.  * Receive modes. Broadcast, Multicast, Promisc.
  523.  */
  525. static void catc_multicast(unsigned char *addr, u8 *multicast)
  526. {
  527. unsigned int crc = 0xffffffff;
  528. u8 byte, idx, bit;
  530.         for (idx = 0; idx < 6; idx++)
  531.                 for (byte = *addr++, bit = 0; bit < 8; bit++, byte >>= 1)
  532.                         crc = (crc >> 1) ^ (((crc ^ byte) & 1) ? 0xedb88320U : 0);
  534. multicast[(crc >> 3) & 0x3f] |= 1 << (crc & 7);
  535. }
  537. static void catc_set_multicast_list(struct net_device *netdev)
  538. {
  539. struct catc *catc = netdev->priv;
  540. struct dev_mc_list *mc;
  541. u8 broadcast[6];
  542. u8 rx = RxEnable | RxPolarity | RxMultiCast;
  543. int i;
  545. memset(broadcast, 0xff, 6);
  546. memset(catc->multicast, 0, 64);
  548. catc_multicast(broadcast, catc->multicast);
  549. catc_multicast(netdev->dev_addr, catc->multicast);
  551. if (netdev->flags & IFF_PROMISC) {
  552. memset(catc->multicast, 0xff, 64);
  553. rx |= RxPromisc;
  554. } 
  556. if (netdev->flags & IFF_ALLMULTI)
  557. memset(catc->multicast, 0xff, 64);
  559. for (i = 0, mc = netdev->mc_list; mc && i < netdev->mc_count; i++, mc = mc->next)
  560. catc_multicast(mc->dmi_addr, catc->multicast);
  562. catc_set_reg_async(catc, RxUnit, rx);
  563. catc_write_mem_async(catc, 0xfa80, catc->multicast, 64);
  564. }
  566. /*
  567.  * Open, close.
  568.  */
  570. static int catc_open(struct net_device *netdev)
  571. {
  572. struct catc *catc = netdev->priv;
  573. int status;
  575. catc->irq_urb.dev = catc->usbdev;
  576. if ((status = usb_submit_urb(&catc->irq_urb)) < 0) {
  577. err("submit(irq_urb) status %d", status);
  578. return -1;
  579. }
  581. netif_start_queue(netdev);
  583. mod_timer(&catc->timer, jiffies + STATS_UPDATE);
  585. return 0;
  586. }
  588. static int catc_stop(struct net_device *netdev)
  589. {
  590. struct catc *catc = netdev->priv;
  592. netif_stop_queue(netdev);
  594. del_timer_sync(&catc->timer);
  596. usb_unlink_urb(&catc->rx_urb);
  597. usb_unlink_urb(&catc->tx_urb);
  598. usb_unlink_urb(&catc->irq_urb);
  599. usb_unlink_urb(&catc->ctrl_urb);
  601. return 0;
  602. }
  604. /*
  605.  * USB probe, disconnect.
  606.  */
  608. static void *catc_probe(struct usb_device *usbdev, unsigned int ifnum, const struct usb_device_id *id)
  609. {
  610. struct net_device *netdev;
  611. struct catc *catc;
  612. u8 broadcast[6];
  613. int i;
  615. if (usb_set_interface(usbdev, ifnum, 1)) {
  616.                 err("Can't set altsetting 1.");
  617. return NULL;
  618. }
  620. catc = kmalloc(sizeof(struct catc), GFP_KERNEL);
  621. memset(catc, 0, sizeof(struct catc));
  623. netdev = init_etherdev(0, 0);
  625. netdev->open = catc_open;
  626. netdev->hard_start_xmit = catc_hard_start_xmit;
  627. netdev->stop = catc_stop;
  628. netdev->get_stats = catc_get_stats;
  629. netdev->tx_timeout = catc_tx_timeout;
  630. netdev->watchdog_timeo = TX_TIMEOUT;
  631. netdev->set_multicast_list = catc_set_multicast_list;
  632. netdev->priv = catc;
  634. catc->usbdev = usbdev;
  635. catc->netdev = netdev;
  637. catc->tx_lock = SPIN_LOCK_UNLOCKED;
  638. catc->ctrl_lock = SPIN_LOCK_UNLOCKED;
  640. init_timer(&catc->timer);
  641. catc->timer.data = (long) catc;
  642. catc->timer.function = catc_stats_timer;
  644. FILL_CONTROL_URB(&catc->ctrl_urb, usbdev, usb_sndctrlpipe(usbdev, 0),
  645. NULL, NULL, 0, catc_ctrl_done, catc);
  647. FILL_BULK_URB(&catc->tx_urb, usbdev, usb_sndbulkpipe(usbdev, 1),
  648. NULL, 0, catc_tx_done, catc);
  650. FILL_BULK_URB(&catc->rx_urb, usbdev, usb_rcvbulkpipe(usbdev, 1),
  651. catc->rx_buf, RX_MAX_BURST * (PKT_SZ + 2), catc_rx_done, catc);
  653. FILL_INT_URB(&catc->irq_urb, usbdev, usb_rcvintpipe(usbdev, 2),
  654.                 catc->irq_buf, 2, catc_irq_done, catc, 1);
  656. dbg("Checking memory sizen");
  658. i = 0x12345678;
  659. catc_write_mem(catc, 0x7a80, &i, 4);
  660. i = 0x87654321;
  661. catc_write_mem(catc, 0xfa80, &i, 4);
  662. catc_read_mem(catc, 0x7a80, &i, 4);
  664. switch (i) {
  665. case 0x12345678:
  666. catc_set_reg(catc, TxBufCount, 8);
  667. catc_set_reg(catc, RxBufCount, 32);
  668. dbg("64k Memoryn");
  669. break;
  670. default:
  671. warn("Couldn't detect memory size, assuming 32k");
  672. case 0x87654321:
  673. catc_set_reg(catc, TxBufCount, 4);
  674. catc_set_reg(catc, RxBufCount, 16);
  675. dbg("32k Memoryn");
  676. break;
  677. }
  679. dbg("Getting MAC from SEEROM.");
  681. catc_get_mac(catc, netdev->dev_addr);
  683. dbg("Setting MAC into registers.");
  685. for (i = 0; i < 6; i++)
  686. catc_set_reg(catc, StationAddr0 - i, netdev->dev_addr[i]);
  688. dbg("Filling the multicast list.");
  690. memset(broadcast, 0xff, 8);
  691. catc_multicast(broadcast, catc->multicast);
  692. catc_multicast(netdev->dev_addr, catc->multicast);
  693. catc_write_mem(catc, 0xfa80, catc->multicast, 64);
  695. dbg("Clearing error counters.");
  697. for (i = 0; i < 8; i++)
  698. catc_set_reg(catc, EthStats + i, 0);
  699. catc->last_stats = jiffies;
  701. dbg("Enabling.");
  703. catc_set_reg(catc, MaxBurst, RX_MAX_BURST);
  704. catc_set_reg(catc, OpModes, OpTxMerge | OpRxMerge | OpLenInclude | Op3MemWaits);
  705. catc_set_reg(catc, LEDCtrl, LEDLink);
  706. catc_set_reg(catc, RxUnit, RxEnable | RxPolarity | RxMultiCast);
  708. dbg("Init done.");
  710. printk(KERN_INFO "%s: CATC EL1210A NetMate USB Ethernet at usb%d:%d.%d, ",
  711. netdev->name, usbdev->bus->busnum, usbdev->devnum, ifnum);
  712. for (i = 0; i < 5; i++) printk("%2.2x:", netdev->dev_addr[i]);
  713. printk("%2.2x.n", netdev->dev_addr[i]);
  715. return catc;
  716. }
  718. static void catc_disconnect(struct usb_device *usbdev, void *dev_ptr)
  719. {
  720. struct catc *catc = dev_ptr;
  721. unregister_netdev(catc->netdev);
  722. kfree(catc->netdev);
  723. kfree(catc);
  724. }
  726. /*
  727.  * Module functions and tables.
  728.  */
  730. static struct usb_device_id catc_id_table [] = {
  731. { USB_DEVICE(0x0423, 0xa) }, /* CATC Netmate */
  732. { USB_DEVICE(0x0423, 0xc) }, /* CATC Netmate II, Belkin F5U111 */
  733. { USB_DEVICE(0x08d1, 0x1) }, /* smartBridges smartNIC */
  734. { }
  735. };
  737. MODULE_DEVICE_TABLE(usb, catc_id_table);
  739. static struct usb_driver catc_driver = {
  740. name: "catc",
  741. probe: catc_probe,
  742. disconnect: catc_disconnect,
  743. id_table: catc_id_table,
  744. };
  746. static int __init catc_init(void)
  747. {
  748. info(DRIVER_VERSION " " DRIVER_DESC);
  749. usb_register(&catc_driver);
  750. return 0;
  751. }
  753. static void __exit catc_exit(void)
  754. {
  755. usb_deregister(&catc_driver);
  756. }
  758. module_init(catc_init);
  759. module_exit(catc_exit);