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

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

Linux/Unix编程

开发平台：

Unix_Linux

kaweth.c：源码内容
  1. /****************************************************************
  2.  *
  3.  *     kaweth.c - driver for KL5KUSB101 based USB->Ethernet
  4.  *
  5.  *     (c) 2000 Interlan Communications
  6.  *     (c) 2000 Stephane Alnet
  7.  *     (C) 2001 Brad Hards
  8.  *     (C) 2002 Oliver Neukum
  9.  *
  10.  *     Original author: The Zapman <zapman@interlan.net>
  11.  *     Inspired by, and much credit goes to Michael Rothwell
  12.  *     <rothwell@interlan.net> for the test equipment, help, and patience
  13.  *     Based off of (and with thanks to) Petko Manolov's pegaus.c driver.
  14.  *     Also many thanks to Joel Silverman and Ed Surprenant at Kawasaki
  15.  *     for providing the firmware and driver resources.
  16.  *
  17.  *     This program is free software; you can redistribute it and/or
  18.  *     modify it under the terms of the GNU General Public License as
  19.  *     published by the Free Software Foundation; either version 2, or
  20.  *     (at your option) any later version.
  21.  *
  22.  *     This program is distributed in the hope that it will be useful,
  23.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25.  *     GNU General Public License for more details.
  26.  *
  27.  *     You should have received a copy of the GNU General Public License
  28.  *     along with this program; if not, write to the Free Software Foundation,
  29.  *     Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  30.  *
  31.  ****************************************************************/
  33. /* TODO:
  34.  * Fix in_interrupt() problem
  35.  * Develop test procedures for USB net interfaces
  36.  * Run test procedures
  37.  * Fix bugs from previous two steps
  38.  * Snoop other OSs for any tricks we're not doing
  39.  * SMP locking
  40.  * Reduce arbitrary timeouts
  41.  * Smart multicast support
  42.  * Temporary MAC change support
  43.  * Tunable SOFs parameter - ioctl()?
  44.  * Ethernet stats collection
  45.  * Code formatting improvements
  46.  */
  48. #include <linux/module.h>
  49. #include <linux/sched.h>
  50. #include <linux/slab.h>
  51. #include <linux/string.h>
  52. #include <linux/init.h>
  53. #include <linux/delay.h>
  54. #include <linux/netdevice.h>
  55. #include <linux/etherdevice.h>
  56. #include <linux/usb.h>
  57. #include <linux/types.h>
  58. #include <linux/ethtool.h>
  59. #include <asm/uaccess.h>
  60. #include <asm/semaphore.h>
  61. #include <asm/byteorder.h>
  63. #define DEBUG
  65. #ifdef DEBUG
  66. #define kaweth_dbg(format, arg...) printk(KERN_DEBUG __FILE__ ": " format "n" ,##arg)
  67. #else
  68. #define kaweth_dbg(format, arg...) do {} while (0)
  69. #endif
  70. #define kaweth_err(format, arg...) printk(KERN_ERR __FILE__ ": " format "n" ,##arg)
  71. #define kaweth_info(format, arg...) printk(KERN_INFO __FILE__ ": " format "n" , ##arg)
  72. #define kaweth_warn(format, arg...) printk(KERN_WARNING __FILE__ ": " format "n" , ##arg)
  75. #include "kawethfw.h"
  77. #define KAWETH_MTU 1514
  78. #define KAWETH_BUF_SIZE 1664
  79. #define KAWETH_TX_TIMEOUT (5 * HZ)
  80. #define KAWETH_SCRATCH_SIZE 32
  81. #define KAWETH_FIRMWARE_BUF_SIZE 4096
  82. #define KAWETH_CONTROL_TIMEOUT (30 * HZ)
  84. #define KAWETH_STATUS_BROKEN 0x0000001
  85. #define KAWETH_STATUS_CLOSING 0x0000002
  87. #define KAWETH_PACKET_FILTER_PROMISCUOUS 0x01
  88. #define KAWETH_PACKET_FILTER_ALL_MULTICAST 0x02
  89. #define KAWETH_PACKET_FILTER_DIRECTED 0x04
  90. #define KAWETH_PACKET_FILTER_BROADCAST 0x08
  91. #define KAWETH_PACKET_FILTER_MULTICAST 0x10
  93. /* Table 7 */
  94. #define KAWETH_COMMAND_GET_ETHERNET_DESC 0x00
  95. #define KAWETH_COMMAND_MULTICAST_FILTERS        0x01
  96. #define KAWETH_COMMAND_SET_PACKET_FILTER 0x02
  97. #define KAWETH_COMMAND_STATISTICS               0x03
  98. #define KAWETH_COMMAND_SET_TEMP_MAC      0x06
  99. #define KAWETH_COMMAND_GET_TEMP_MAC             0x07
  100. #define KAWETH_COMMAND_SET_URB_SIZE 0x08
  101. #define KAWETH_COMMAND_SET_SOFS_WAIT 0x09
  102. #define KAWETH_COMMAND_SCAN 0xFF
  104. #define KAWETH_SOFS_TO_WAIT 0x05
  106. #define INTBUFFERSIZE 4
  108. #define STATE_OFFSET 0
  109. #define STATE_MASK 0x40
  110. #define STATE_SHIFT 5
  113. MODULE_AUTHOR("Michael Zappe <zapman@interlan.net>, Stephane Alnet <stephane@u-picardie.fr>, Brad Hards <bhards@bigpond.net.au> and Oliver Neukum <oliver@neukum.org>");
  114. MODULE_DESCRIPTION("KL5USB101 USB Ethernet driver");
  115. MODULE_LICENSE("GPL");
  117. static void *kaweth_probe(
  118.             struct usb_device *dev,             /* the device */
  119.             unsigned ifnum,                     /* what interface */
  120.             const struct usb_device_id *id      /* from id_table */
  121. );
  122. static void kaweth_disconnect(struct usb_device *dev, void *ptr);
  123. int kaweth_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,
  124. struct usb_ctrlrequest *cmd, void *data,
  125. int len, int timeout);
  127. /****************************************************************
  128.  *     usb_device_id
  129.  ****************************************************************/
  130. static struct usb_device_id usb_klsi_table[] = {
  131. { USB_DEVICE(0x03e8, 0x0008) }, /* AOX Endpoints USB Ethernet */
  132. { USB_DEVICE(0x04bb, 0x0901) }, /* I-O DATA USB-ET/T */
  133. { USB_DEVICE(0x0506, 0x03e8) }, /* 3Com 3C19250 */
  134. { USB_DEVICE(0x0557, 0x2002) }, /* ATEN USB Ethernet */
  135. { USB_DEVICE(0x0557, 0x4000) }, /* D-Link DSB-650C */
  136. { USB_DEVICE(0x0565, 0x0002) }, /* Peracom Enet */
  137. { USB_DEVICE(0x0565, 0x0003) }, /* Optus@Home UEP1045A */
  138. { USB_DEVICE(0x0565, 0x0005) }, /* Peracom Enet2 */
  139. { USB_DEVICE(0x05e9, 0x0008) }, /* KLSI KL5KUSB101B */
  140. { USB_DEVICE(0x05e9, 0x0009) }, /* KLSI KL5KUSB101B (Board change) */
  141. { USB_DEVICE(0x066b, 0x2202) }, /* Linksys USB10T */
  142. { USB_DEVICE(0x06e1, 0x0008) }, /* ADS USB-10BT */
  143. { USB_DEVICE(0x06e1, 0x0009) }, /* ADS USB-10BT */
  144. { USB_DEVICE(0x0707, 0x0100) }, /* SMC 2202USB */
  145. { USB_DEVICE(0x07aa, 0x0001) }, /* Correga K.K. */
  146. { USB_DEVICE(0x07b8, 0x4000) }, /* D-Link DU-E10 */
  147. { USB_DEVICE(0x0846, 0x1001) }, /* NetGear EA-101 */
  148. { USB_DEVICE(0x0846, 0x1002) }, /* NetGear EA-101 */
  149. { USB_DEVICE(0x085a, 0x0008) }, /* PortGear Ethernet Adapter */
  150. { USB_DEVICE(0x085a, 0x0009) }, /* PortGear Ethernet Adapter */
  151. { USB_DEVICE(0x087d, 0x5704) }, /* Jaton USB Ethernet Device Adapter */
  152. { USB_DEVICE(0x0951, 0x0008) }, /* Kingston Technology USB Ethernet Adapter */
  153. { USB_DEVICE(0x095a, 0x3003) }, /* Portsmith Express Ethernet Adapter */
  154. { USB_DEVICE(0x10bd, 0x1427) }, /* ASANTE USB To Ethernet Adapter */
  155. { USB_DEVICE(0x1342, 0x0204) }, /* Mobility USB-Ethernet Adapter */
  156. { USB_DEVICE(0x13d2, 0x0400) }, /* Shark Pocket Adapter */
  157. { USB_DEVICE(0x1485, 0x0001) }, /* Silicom U2E */
  158. { USB_DEVICE(0x1645, 0x0005) }, /* Entrega E45 */
  159. { USB_DEVICE(0x1645, 0x0008) }, /* Entrega USB Ethernet Adapter */
  160. { USB_DEVICE(0x1645, 0x8005) }, /* PortGear Ethernet Adapter */
  161. { USB_DEVICE(0x2001, 0x4000) }, /* D-link DSB-650C */
  162. {} /* Null terminator */
  163. };
  165. MODULE_DEVICE_TABLE (usb, usb_klsi_table);
  167. /****************************************************************
  168.  *     kaweth_driver
  169.  ****************************************************************/
  170. static struct usb_driver kaweth_driver = {
  171. .name = "kaweth",
  172. .probe = kaweth_probe,
  173. .disconnect = kaweth_disconnect,
  174. .id_table =     usb_klsi_table,
  175. };
  177. typedef __u8 eth_addr_t[6];
  179. /****************************************************************
  180.  *     usb_eth_dev
  181.  ****************************************************************/
  182. struct usb_eth_dev {
  183. char *name;
  184. __u16 vendor;
  185. __u16 device;
  186. void *pdata;
  187. };
  189. /****************************************************************
  190.  *     kaweth_ethernet_configuration
  191.  *     Refer Table 8
  192.  ****************************************************************/
  193. struct kaweth_ethernet_configuration
  194. {
  195. __u8 size;
  196. __u8 reserved1;
  197. __u8 reserved2;
  198. eth_addr_t hw_addr;
  199. __u32 statistics_mask;
  200. __u16 segment_size;
  201. __u16 max_multicast_filters;
  202. __u8 reserved3;
  203. } __attribute__ ((packed));
  205. /****************************************************************
  206.  *     kaweth_device
  207.  ****************************************************************/
  208. struct kaweth_device
  209. {
  210. spinlock_t device_lock;
  212. __u32 status;
  213. int end;
  214. int removed;
  215. int suspend_lowmem;
  216. int linkstate;
  218. struct usb_device *dev;
  219. struct net_device *net;
  220. wait_queue_head_t term_wait;
  222. struct urb *rx_urb;
  223. struct urb *tx_urb;
  224. struct urb *irq_urb;
  226. struct sk_buff *tx_skb;
  228. __u8 *firmware_buf;
  229. __u8 scratch[KAWETH_SCRATCH_SIZE];
  230. __u8 rx_buf[KAWETH_BUF_SIZE];
  231. __u8 intbuffer[INTBUFFERSIZE];
  232. __u16 packet_filter_bitmap;
  234. struct kaweth_ethernet_configuration configuration;
  236. struct net_device_stats stats;
  237. } __attribute__ ((packed));
  240. /****************************************************************
  241.  *     kaweth_control
  242.  ****************************************************************/
  243. static int kaweth_control(struct kaweth_device *kaweth,
  244.   unsigned int pipe,
  245.   __u8 request,
  246.   __u8 requesttype,
  247.   __u16 value,
  248.   __u16 index,
  249.   void *data,
  250.   __u16 size,
  251.   int timeout)
  252. {
  253. struct usb_ctrlrequest *dr;
  255. kaweth_dbg("kaweth_control()");
  257. if(in_interrupt()) {
  258. kaweth_dbg("in_interrupt()");
  259. return -EBUSY;
  260. }
  262. dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
  264. if (!dr) {
  265. kaweth_dbg("kmalloc() failed");
  266. return -ENOMEM;
  267. }
  269. dr->bRequestType= requesttype;
  270. dr->bRequest = request;
  271. dr->wValue = cpu_to_le16p(&value);
  272. dr->wIndex = cpu_to_le16p(&index);
  273. dr->wLength = cpu_to_le16p(&size);
  275. return kaweth_internal_control_msg(kaweth->dev,
  276. pipe,
  277. dr,
  278. data,
  279. size,
  280. timeout);
  281. }
  283. /****************************************************************
  284.  *     kaweth_read_configuration
  285.  ****************************************************************/
  286. static int kaweth_read_configuration(struct kaweth_device *kaweth)
  287. {
  288. int retval;
  290. kaweth_dbg("Reading kaweth configuration");
  292. retval = kaweth_control(kaweth,
  293. usb_rcvctrlpipe(kaweth->dev, 0),
  294. KAWETH_COMMAND_GET_ETHERNET_DESC,
  295. USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
  296. 0,
  297. 0,
  298. (void *)&kaweth->configuration,
  299. sizeof(kaweth->configuration),
  300. KAWETH_CONTROL_TIMEOUT);
  302. return retval;
  303. }
  305. /****************************************************************
  306.  *     kaweth_set_urb_size
  307.  ****************************************************************/
  308. static int kaweth_set_urb_size(struct kaweth_device *kaweth, __u16 urb_size)
  309. {
  310. int retval;
  312. kaweth_dbg("Setting URB size to %d", (unsigned)urb_size);
  314. retval = kaweth_control(kaweth,
  315. usb_sndctrlpipe(kaweth->dev, 0),
  316. KAWETH_COMMAND_SET_URB_SIZE,
  317. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  318. urb_size,
  319. 0,
  320. (void *)&kaweth->scratch,
  321. 0,
  322. KAWETH_CONTROL_TIMEOUT);
  324. return retval;
  325. }
  327. /****************************************************************
  328.  *     kaweth_set_sofs_wait
  329.  ****************************************************************/
  330. static int kaweth_set_sofs_wait(struct kaweth_device *kaweth, __u16 sofs_wait)
  331. {
  332. int retval;
  334. kaweth_dbg("Set SOFS wait to %d", (unsigned)sofs_wait);
  336. retval = kaweth_control(kaweth,
  337. usb_sndctrlpipe(kaweth->dev, 0),
  338. KAWETH_COMMAND_SET_SOFS_WAIT,
  339. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  340. sofs_wait,
  341. 0,
  342. (void *)&kaweth->scratch,
  343. 0,
  344. KAWETH_CONTROL_TIMEOUT);
  346. return retval;
  347. }
  349. /****************************************************************
  350.  *     kaweth_set_receive_filter
  351.  ****************************************************************/
  352. static int kaweth_set_receive_filter(struct kaweth_device *kaweth,
  353.      __u16 receive_filter)
  354. {
  355. int retval;
  357. kaweth_dbg("Set receive filter to %d", (unsigned)receive_filter);
  359. retval = kaweth_control(kaweth,
  360. usb_sndctrlpipe(kaweth->dev, 0),
  361. KAWETH_COMMAND_SET_PACKET_FILTER,
  362. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  363. receive_filter,
  364. 0,
  365. (void *)&kaweth->scratch,
  366. 0,
  367. KAWETH_CONTROL_TIMEOUT);
  369. return retval;
  370. }
  372. /****************************************************************
  373.  *     kaweth_download_firmware
  374.  ****************************************************************/
  375. static int kaweth_download_firmware(struct kaweth_device *kaweth,
  376.     __u8 *data,
  377.     __u16 data_len,
  378.     __u8 interrupt,
  379.     __u8 type)
  380. {
  381. if(data_len > KAWETH_FIRMWARE_BUF_SIZE) {
  382. kaweth_err("Firmware too big: %d", data_len);
  383. return -ENOSPC;
  384. }
  386. memcpy(kaweth->firmware_buf, data, data_len);
  388. kaweth->firmware_buf[2] = (data_len & 0xFF) - 7;
  389. kaweth->firmware_buf[3] = data_len >> 8;
  390. kaweth->firmware_buf[4] = type;
  391. kaweth->firmware_buf[5] = interrupt;
  393. kaweth_dbg("High: %i, Low:%i", kaweth->firmware_buf[3],
  394.    kaweth->firmware_buf[2]);
  396. kaweth_dbg("Downloading firmware at %p to kaweth device at %p",
  397.     data,
  398.     kaweth);
  399. kaweth_dbg("Firmware length: %d", data_len);
  401. return kaweth_control(kaweth,
  402.               usb_sndctrlpipe(kaweth->dev, 0),
  403.       KAWETH_COMMAND_SCAN,
  404.       USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  405.       0,
  406.       0,
  407.       (void *)kaweth->firmware_buf,
  408.       data_len,
  409.       KAWETH_CONTROL_TIMEOUT);
  410. }
  412. /****************************************************************
  413.  *     kaweth_trigger_firmware
  414.  ****************************************************************/
  415. static int kaweth_trigger_firmware(struct kaweth_device *kaweth,
  416.    __u8 interrupt)
  417. {
  418. kaweth->firmware_buf[0] = 0xB6;
  419. kaweth->firmware_buf[1] = 0xC3;
  420. kaweth->firmware_buf[2] = 0x01;
  421. kaweth->firmware_buf[3] = 0x00;
  422. kaweth->firmware_buf[4] = 0x06;
  423. kaweth->firmware_buf[5] = interrupt;
  424. kaweth->firmware_buf[6] = 0x00;
  425. kaweth->firmware_buf[7] = 0x00;
  427. kaweth_dbg("Triggering firmware");
  429. return kaweth_control(kaweth,
  430.       usb_sndctrlpipe(kaweth->dev, 0),
  431.       KAWETH_COMMAND_SCAN,
  432.       USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  433.       0,
  434.       0,
  435.       (void *)kaweth->firmware_buf,
  436.       8,
  437.       KAWETH_CONTROL_TIMEOUT);
  438. }
  440. /****************************************************************
  441.  *     kaweth_reset
  442.  ****************************************************************/
  443. static int kaweth_reset(struct kaweth_device *kaweth)
  444. {
  445. int result;
  447. kaweth_dbg("kaweth_reset(%p)", kaweth);
  448. result = kaweth_control(kaweth,
  449. usb_sndctrlpipe(kaweth->dev, 0),
  450. USB_REQ_SET_CONFIGURATION,
  451. 0,
  452. kaweth->dev->config[0].bConfigurationValue,
  453. 0,
  454. NULL,
  455. 0,
  456. KAWETH_CONTROL_TIMEOUT);
  458. udelay(10000);
  460. kaweth_dbg("kaweth_reset() returns %d.",result);
  462. return result;
  463. }
  465. static void kaweth_usb_receive(struct urb *);
  466. static void kaweth_resubmit_rx_urb(struct kaweth_device *);
  468. /****************************************************************
  469. int_callback
  470. *****************************************************************/
  471. static void int_callback(struct urb *u)
  472. {
  473. struct kaweth_device *kaweth = u->context;
  474. int act_state;
  476. /* we abuse the interrupt urb for rebsubmitting under low memory saving a timer */
  477. if (kaweth->suspend_lowmem)
  478. kaweth_resubmit_rx_urb(kaweth);
  480. /* we check the link state to report changes */
  481. if (kaweth->linkstate != (act_state = ( kaweth->intbuffer[STATE_OFFSET] | STATE_MASK) >> STATE_SHIFT)) {
  482. if (!act_state)
  483. netif_carrier_on(kaweth->net);
  484. else
  485. netif_carrier_off(kaweth->net);
  487. kaweth->linkstate = act_state;
  488. }
  490. }
  492. /****************************************************************
  493.  *     kaweth_resubmit_rx_urb
  494.  ****************************************************************/
  495. static void kaweth_resubmit_rx_urb(struct kaweth_device *kaweth)
  496. {
  497. int result;
  498. long flags;
  500. FILL_BULK_URB(kaweth->rx_urb,
  501.       kaweth->dev,
  502.       usb_rcvbulkpipe(kaweth->dev, 1),
  503.       kaweth->rx_buf,
  504.       KAWETH_BUF_SIZE,
  505.       kaweth_usb_receive,
  506.       kaweth);
  508. spin_lock_irqsave(&kaweth->device_lock, flags);
  509. if (!kaweth->removed) { /* no resubmit if disconnecting */
  510. if((result = usb_submit_urb(kaweth->rx_urb))) {
  511. if (result == -ENOMEM)
  512. kaweth->suspend_lowmem = 1;
  513. kaweth_err("resubmitting rx_urb %d failed", result);
  514. } else {
  515. kaweth->suspend_lowmem = 0;
  516. }
  517. }
  518. spin_unlock_irqrestore(&kaweth->device_lock, flags);
  519. }
  521. static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth);
  523. /****************************************************************
  524.  *     kaweth_usb_receive
  525.  ****************************************************************/
  526. static void kaweth_usb_receive(struct urb *urb)
  527. {
  528. struct kaweth_device *kaweth = urb->context;
  529. struct net_device *net = kaweth->net;
  531. int count = urb->actual_length;
  532. int count2 = urb->transfer_buffer_length;
  534. __u16 pkt_len = le16_to_cpup((u16 *)kaweth->rx_buf);
  536. struct sk_buff *skb;
  538. if(urb->status == -ECONNRESET || urb->status == -ECONNABORTED)
  539. /* we are killed - set a flag and wake the disconnect handler */
  540. {
  541. kaweth->end = 1;
  542. wake_up(&kaweth->term_wait);
  543. return;
  544. }
  546. if (kaweth->status & KAWETH_STATUS_CLOSING)
  547. return;
  549. if(urb->status && urb->status != -EREMOTEIO && count != 1) {
  550. kaweth_err("%s RX status: %d count: %d packet_len: %d",
  551.                            net->name,
  552.    urb->status,
  553.    count,
  554.    (int)pkt_len);
  555. kaweth_resubmit_rx_urb(kaweth);
  556.                 return;
  557. }
  559. if(kaweth->net && (count > 2)) {
  560. if(pkt_len > (count - 2)) {
  561. kaweth_err("Packet length too long for USB frame (pkt_len: %x, count: %x)",pkt_len, count);
  562. kaweth_err("Packet len & 2047: %x", pkt_len & 2047);
  563. kaweth_err("Count 2: %x", count2);
  564.         kaweth_resubmit_rx_urb(kaweth);
  565.                         return;
  566.                 }
  568. if(!(skb = dev_alloc_skb(pkt_len+2))) {
  569.         kaweth_resubmit_rx_urb(kaweth);
  570.                         return;
  571. }
  573. skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
  575. skb->dev = net;
  577. eth_copy_and_sum(skb, kaweth->rx_buf + 2, pkt_len, 0);
  579. skb_put(skb, pkt_len);
  581. skb->protocol = eth_type_trans(skb, net);
  583. netif_rx(skb);
  585. kaweth->stats.rx_packets++;
  586. kaweth->stats.rx_bytes += pkt_len;
  587. }
  589. kaweth_resubmit_rx_urb(kaweth);
  590. }
  592. /****************************************************************
  593.  *     kaweth_open
  594.  ****************************************************************/
  595. static int kaweth_open(struct net_device *net)
  596. {
  597. struct kaweth_device *kaweth = (struct kaweth_device *)net->priv;
  599. kaweth_dbg("Dev usage: %d", kaweth->dev->refcnt.counter);
  601. kaweth_dbg("Opening network device.");
  603. MOD_INC_USE_COUNT;
  605. kaweth_resubmit_rx_urb(kaweth);
  607. FILL_INT_URB(
  608. kaweth->irq_urb,
  609. kaweth->dev,
  610. usb_rcvintpipe(kaweth->dev, 3),
  611. kaweth->intbuffer,
  612. INTBUFFERSIZE,
  613. int_callback,
  614. kaweth,
  615. HZ/4);
  617. usb_submit_urb(kaweth->irq_urb);
  619. netif_start_queue(net);
  621. kaweth_async_set_rx_mode(kaweth);
  622. return 0;
  623. }
  625. /****************************************************************
  626.  *     kaweth_close
  627.  ****************************************************************/
  628. static int kaweth_close(struct net_device *net)
  629. {
  630. struct kaweth_device *kaweth = net->priv;
  632. netif_stop_queue(net);
  634. spin_lock_irq(&kaweth->device_lock);
  635. kaweth->status |= KAWETH_STATUS_CLOSING;
  636. spin_unlock_irq(&kaweth->device_lock);
  638. usb_unlink_urb(kaweth->irq_urb);
  639. usb_unlink_urb(kaweth->rx_urb);
  641. kaweth->status &= ~KAWETH_STATUS_CLOSING;
  643. MOD_DEC_USE_COUNT;
  645. printk("Dev usage: %d", kaweth->dev->refcnt.counter);
  647. return 0;
  648. }
  650. static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
  651. {
  652. u32 ethcmd;
  654. if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
  655. return -EFAULT;
  657. switch (ethcmd) {
  658. case ETHTOOL_GDRVINFO: {
  659. struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
  660. strncpy(info.driver, "kaweth", sizeof(info.driver)-1);
  661. if (copy_to_user(useraddr, &info, sizeof(info)))
  662. return -EFAULT;
  663. return 0;
  664. }
  665. }
  667. return -EOPNOTSUPP;
  668. }
  670. /****************************************************************
  671.  *     kaweth_ioctl
  672.  ****************************************************************/
  673. static int kaweth_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
  674. {
  675. switch (cmd) {
  676. case SIOCETHTOOL:
  677. return netdev_ethtool_ioctl(net, (void *) rq->ifr_data);
  678. }
  679. return -EOPNOTSUPP;
  680. }
  682. /****************************************************************
  683.  *     kaweth_usb_transmit_complete
  684.  ****************************************************************/
  685. static void kaweth_usb_transmit_complete(struct urb *urb)
  686. {
  687. struct kaweth_device *kaweth = urb->context;
  688. struct sk_buff *skb = kaweth->tx_skb;
  690. if (urb->status != 0)
  691. kaweth_dbg("%s: TX status %d.", kaweth->net->name, urb->status);
  693. netif_wake_queue(kaweth->net);
  694. dev_kfree_skb(skb);
  695. }
  697. /****************************************************************
  698.  *     kaweth_start_xmit
  699.  ****************************************************************/
  700. static int kaweth_start_xmit(struct sk_buff *skb, struct net_device *net)
  701. {
  702. struct kaweth_device *kaweth = net->priv;
  703. char *private_header;
  705. int res;
  707. spin_lock(&kaweth->device_lock);
  709. if (kaweth->removed) {
  710. /* our device is undergoing disconnection - we bail out */
  711. spin_unlock(&kaweth->device_lock);
  712. dev_kfree_skb(skb);
  713. return 0;
  714. }
  716. kaweth_async_set_rx_mode(kaweth);
  717. netif_stop_queue(net);
  719. /* We now decide whether we can put our special header into the sk_buff */
  720. if (skb_cloned(skb) || skb_headroom(skb) < 2) {
  721. /* no such luck - we make our own */
  722. struct sk_buff *copied_skb;
  723. copied_skb = skb_copy_expand(skb, 2, 0, GFP_ATOMIC);
  724. dev_kfree_skb_any(skb);
  725. skb = copied_skb;
  726. if (!copied_skb) {
  727. kaweth->stats.tx_errors++;
  728. netif_start_queue(net);
  729. spin_unlock(&kaweth->device_lock);
  730. return 0;
  731. }
  732. }
  734. private_header = __skb_push(skb, 2);
  735. *private_header = cpu_to_le16(skb->len);
  736. kaweth->tx_skb = skb;
  738. FILL_BULK_URB(kaweth->tx_urb,
  739.       kaweth->dev,
  740.       usb_sndbulkpipe(kaweth->dev, 2),
  741.       private_header,
  742.       skb->len,
  743.       kaweth_usb_transmit_complete,
  744.       kaweth);
  745. kaweth->end = 0;
  746. kaweth->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
  748. if((res = usb_submit_urb(kaweth->tx_urb)))
  749. {
  750. kaweth_warn("kaweth failed tx_urb %d", res);
  751. kaweth->stats.tx_errors++;
  753. netif_start_queue(net);
  754. dev_kfree_skb(skb);
  755. }
  756. else
  757. {
  758. kaweth->stats.tx_packets++;
  759. kaweth->stats.tx_bytes += skb->len;
  760. net->trans_start = jiffies;
  761. }
  763. spin_unlock(&kaweth->device_lock);
  765. return 0;
  766. }
  768. /****************************************************************
  769.  *     kaweth_set_rx_mode
  770.  ****************************************************************/
  771. static void kaweth_set_rx_mode(struct net_device *net)
  772. {
  773. struct kaweth_device *kaweth = net->priv;
  775. __u16 packet_filter_bitmap = KAWETH_PACKET_FILTER_DIRECTED |
  776.                                      KAWETH_PACKET_FILTER_BROADCAST |
  777.                      KAWETH_PACKET_FILTER_MULTICAST;
  779. kaweth_dbg("Setting Rx mode to %d", packet_filter_bitmap);
  781. netif_stop_queue(net);
  783. if (net->flags & IFF_PROMISC) {
  784. packet_filter_bitmap |= KAWETH_PACKET_FILTER_PROMISCUOUS;
  785. }
  786. else if ((net->mc_count) || (net->flags & IFF_ALLMULTI)) {
  787. packet_filter_bitmap |= KAWETH_PACKET_FILTER_ALL_MULTICAST;
  788. }
  790. kaweth->packet_filter_bitmap = packet_filter_bitmap;
  791. netif_wake_queue(net);
  792. }
  794. /****************************************************************
  795.  *     kaweth_async_set_rx_mode
  796.  ****************************************************************/
  797. static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
  798. {
  799. __u16 packet_filter_bitmap = kaweth->packet_filter_bitmap;
  800. kaweth->packet_filter_bitmap = 0;
  801. if(packet_filter_bitmap == 0) return;
  803. {
  804. int result;
  805. result = kaweth_control(kaweth,
  806. usb_sndctrlpipe(kaweth->dev, 0),
  807. KAWETH_COMMAND_SET_PACKET_FILTER,
  808. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  809. packet_filter_bitmap,
  810. 0,
  811. (void *)&kaweth->scratch,
  812. 0,
  813. KAWETH_CONTROL_TIMEOUT);
  815. if(result < 0) {
  816. kaweth_err("Failed to set Rx mode: %d", result);
  817. }
  818. else {
  819. kaweth_dbg("Set Rx mode to %d", packet_filter_bitmap);
  820. }
  821. }
  822. }
  824. /****************************************************************
  825.  *     kaweth_netdev_stats
  826.  ****************************************************************/
  827. static struct net_device_stats *kaweth_netdev_stats(struct net_device *dev)
  828. {
  829. return &((struct kaweth_device *)dev->priv)->stats;
  830. }
  832. /****************************************************************
  833.  *     kaweth_tx_timeout
  834.  ****************************************************************/
  835. static void kaweth_tx_timeout(struct net_device *net)
  836. {
  837. struct kaweth_device *kaweth = net->priv;
  839. kaweth_warn("%s: Tx timed out. Resetting.", net->name);
  840. kaweth->stats.tx_errors++;
  841. net->trans_start = jiffies;
  843. usb_unlink_urb(kaweth->tx_urb);
  844. }
  846. /****************************************************************
  847.  *     kaweth_probe
  848.  ****************************************************************/
  849. static void *kaweth_probe(
  850.             struct usb_device *dev,             /* the device */
  851.             unsigned ifnum,                      /* what interface */
  852.             const struct usb_device_id *id      /* from id_table */
  853. )
  854. {
  855. struct kaweth_device *kaweth;
  856. const eth_addr_t bcast_addr = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  857. int result = 0;
  859. kaweth_dbg("Kawasaki Device Probe (Device number:%d): 0x%4.4x:0x%4.4x:0x%4.4x",
  860.  dev->devnum,
  861.  (int)dev->descriptor.idVendor,
  862.  (int)dev->descriptor.idProduct,
  863.  (int)dev->descriptor.bcdDevice);
  865. kaweth_dbg("Device at %p", dev);
  867. kaweth_dbg("Descriptor length: %x type: %x",
  868.  (int)dev->descriptor.bLength,
  869.  (int)dev->descriptor.bDescriptorType);
  871. if(!(kaweth = kmalloc(sizeof(struct kaweth_device), GFP_KERNEL))) {
  872. kaweth_dbg("out of memory allocating device structuren");
  873. return NULL;
  874. }
  876. memset(kaweth, 0, sizeof(struct kaweth_device));
  878. kaweth->dev = dev;
  879. spin_lock_init(&kaweth->device_lock);
  880. init_waitqueue_head(&kaweth->term_wait);
  882. kaweth_dbg("Resetting.");
  884. kaweth_reset(kaweth);
  886. /*
  887.  * If high byte of bcdDevice is nonzero, firmware is already
  888.  * downloaded. Don't try to do it again, or we'll hang the device.
  889.  */
  891. if (dev->descriptor.bcdDevice >> 8) {
  892. kaweth_info("Firmware present in device.");
  893. } else {
  894. /* Download the firmware */
  895. kaweth_info("Downloading firmware...");
  896. kaweth->firmware_buf = (__u8 *)__get_free_page(GFP_KERNEL);
  897. if ((result = kaweth_download_firmware(kaweth,
  898.       kaweth_new_code,
  899.       len_kaweth_new_code,
  900.       100,
  901.       2)) < 0) {
  902. kaweth_err("Error downloading firmware (%d)", result);
  903. free_page((unsigned long)kaweth->firmware_buf);
  904. kfree(kaweth);
  905. return NULL;
  906. }
  908. if ((result = kaweth_download_firmware(kaweth,
  909.       kaweth_new_code_fix,
  910.       len_kaweth_new_code_fix,
  911.       100,
  912.       3)) < 0) {
  913. kaweth_err("Error downloading firmware fix (%d)", result);
  914. free_page((unsigned long)kaweth->firmware_buf);
  915. kfree(kaweth);
  916. return NULL;
  917. }
  919. if ((result = kaweth_download_firmware(kaweth,
  920.       kaweth_trigger_code,
  921.       len_kaweth_trigger_code,
  922.       126,
  923.       2)) < 0) {
  924. kaweth_err("Error downloading trigger code (%d)", result);
  925. free_page((unsigned long)kaweth->firmware_buf);
  926. kfree(kaweth);
  927. return NULL;
  928. }
  930. if ((result = kaweth_download_firmware(kaweth,
  931.       kaweth_trigger_code_fix,
  932.       len_kaweth_trigger_code_fix,
  933.       126,
  934.       3)) < 0) {
  935. kaweth_err("Error downloading trigger code fix (%d)", result);
  936. free_page((unsigned long)kaweth->firmware_buf);
  937. kfree(kaweth);
  938. return NULL;
  939. }
  942. if ((result = kaweth_trigger_firmware(kaweth, 126)) < 0) {
  943. kaweth_err("Error triggering firmware (%d)", result);
  944. free_page((unsigned long)kaweth->firmware_buf);
  945. kfree(kaweth);
  946. return NULL;
  947. }
  949. /* Device will now disappear for a moment...  */
  950. kaweth_info("Firmware loaded.  I'll be back...");
  951. free_page((unsigned long)kaweth->firmware_buf);
  952. kfree(kaweth);
  953. return NULL;
  954. }
  956. result = kaweth_read_configuration(kaweth);
  958. if(result < 0) {
  959. kaweth_err("Error reading configuration (%d), no net device created", result);
  960. kfree(kaweth);
  961. return NULL;
  962. }
  964. kaweth_info("Statistics collection: %x", kaweth->configuration.statistics_mask);
  965. kaweth_info("Multicast filter limit: %x", kaweth->configuration.max_multicast_filters & ((1 << 15) - 1));
  966. kaweth_info("MTU: %d", le16_to_cpu(kaweth->configuration.segment_size));
  967. kaweth_info("Read MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
  968.  (int)kaweth->configuration.hw_addr[0],
  969.  (int)kaweth->configuration.hw_addr[1],
  970.  (int)kaweth->configuration.hw_addr[2],
  971.  (int)kaweth->configuration.hw_addr[3],
  972.  (int)kaweth->configuration.hw_addr[4],
  973.  (int)kaweth->configuration.hw_addr[5]);
  975. if(!memcmp(&kaweth->configuration.hw_addr,
  976.                    &bcast_addr,
  977.    sizeof(bcast_addr))) {
  978. kaweth_err("Firmware not functioning properly, no net device created");
  979. kfree(kaweth);
  980. return NULL;
  981. }
  983. if(kaweth_set_urb_size(kaweth, KAWETH_BUF_SIZE) < 0) {
  984. kaweth_dbg("Error setting URB size");
  985. return kaweth;
  986. }
  988. if(kaweth_set_sofs_wait(kaweth, KAWETH_SOFS_TO_WAIT) < 0) {
  989. kaweth_err("Error setting SOFS wait");
  990. return kaweth;
  991. }
  993. result = kaweth_set_receive_filter(kaweth,
  994.                                            KAWETH_PACKET_FILTER_DIRECTED |
  995.                                            KAWETH_PACKET_FILTER_BROADCAST |
  996.                                            KAWETH_PACKET_FILTER_MULTICAST);
  998. if(result < 0) {
  999. kaweth_err("Error setting receive filter");
  1000. return kaweth;
  1001. }
  1003. kaweth_dbg("Initializing net device.");
  1005. kaweth->tx_urb = usb_alloc_urb(0);
  1006. if (!kaweth->tx_urb)
  1007. goto err_no_urb;
  1008. kaweth->rx_urb = usb_alloc_urb(0);
  1009. if (!kaweth->rx_urb)
  1010. goto err_only_tx;
  1011. kaweth->irq_urb = usb_alloc_urb(0);
  1012. if (!kaweth->irq_urb)
  1013. goto err_tx_and_rx;
  1015. kaweth->net = init_etherdev(0, 0);
  1016. if (!kaweth->net) {
  1017. kaweth_err("Error calling init_etherdev.");
  1018. return kaweth;
  1019. }
  1021. memcpy(kaweth->net->broadcast, &bcast_addr, sizeof(bcast_addr));
  1022. memcpy(kaweth->net->dev_addr,
  1023.                &kaweth->configuration.hw_addr,
  1024.                sizeof(kaweth->configuration.hw_addr));
  1026. kaweth->net->priv = kaweth;
  1027. kaweth->net->open = kaweth_open;
  1028. kaweth->net->stop = kaweth_close;
  1030. kaweth->net->watchdog_timeo = KAWETH_TX_TIMEOUT;
  1031. kaweth->net->tx_timeout = kaweth_tx_timeout;
  1033. kaweth->net->do_ioctl = kaweth_ioctl;
  1034. kaweth->net->hard_start_xmit = kaweth_start_xmit;
  1035. kaweth->net->set_multicast_list = kaweth_set_rx_mode;
  1036. kaweth->net->get_stats = kaweth_netdev_stats;
  1037. kaweth->net->mtu = le16_to_cpu(kaweth->configuration.segment_size);
  1039. memset(&kaweth->stats, 0, sizeof(kaweth->stats));
  1041. kaweth_info("kaweth interface created at %s", kaweth->net->name);
  1043. kaweth_dbg("Kaweth probe returning.");
  1045. return kaweth;
  1047. err_tx_and_rx:
  1048. usb_free_urb(kaweth->rx_urb);
  1049. err_only_tx:
  1050. usb_free_urb(kaweth->tx_urb);
  1051. err_no_urb:
  1052. kfree(kaweth);
  1053. return NULL;
  1054. }
  1056. /****************************************************************
  1057.  *     kaweth_disconnect
  1058.  ****************************************************************/
  1059. static void kaweth_disconnect(struct usb_device *dev, void *ptr)
  1060. {
  1061. struct kaweth_device *kaweth = ptr;
  1063. kaweth_info("Unregistering");
  1065. if (!kaweth) {
  1066. kaweth_warn("unregistering non-existant device");
  1067. return;
  1068. }
  1070. kaweth->removed = 1;
  1071. usb_unlink_urb(kaweth->irq_urb);
  1072. usb_unlink_urb(kaweth->rx_urb);
  1074. /* we need to wait for the urb to be cancelled, if it is active */
  1075. spin_lock_irq(&kaweth->device_lock);
  1076. if (usb_unlink_urb(kaweth->tx_urb) == -EINPROGRESS) {
  1077. spin_unlock_irq(&kaweth->device_lock);
  1078. wait_event(kaweth->term_wait, kaweth->end);
  1079. } else {
  1080. spin_unlock_irq(&kaweth->device_lock);
  1081. }
  1083. if(kaweth->net) {
  1084. if(kaweth->net->flags & IFF_UP) {
  1085. kaweth_dbg("Closing net device");
  1086. dev_close(kaweth->net);
  1087. }
  1089. kaweth_dbg("Unregistering net device");
  1090. unregister_netdev(kaweth->net);
  1091. }
  1093. usb_free_urb(kaweth->rx_urb);
  1094. usb_free_urb(kaweth->tx_urb);
  1096. kfree(kaweth);
  1097. }
  1100. // FIXME this completion stuff is a modified clone of
  1101. // an OLD version of some stuff in usb.c ...
  1102. struct kw_api_data {
  1103. wait_queue_head_t wqh;
  1104. int done;
  1105. };
  1107. /*-------------------------------------------------------------------*
  1108.  * completion handler for compatibility wrappers (sync control/bulk) *
  1109.  *-------------------------------------------------------------------*/
  1110. static void usb_api_blocking_completion(struct urb *urb)
  1111. {
  1112.         struct kw_api_data *awd = (struct kw_api_data *)urb->context;
  1114. awd->done=1;
  1115. wake_up(&awd->wqh);
  1116. }
  1118. /*-------------------------------------------------------------------*
  1119.  *                         COMPATIBILITY STUFF                       *
  1120.  *-------------------------------------------------------------------*/
  1122. // Starts urb and waits for completion or timeout
  1123. static int usb_start_wait_urb(struct urb *urb, int timeout, int* actual_length)
  1124. {
  1125.         DECLARE_WAITQUEUE(wait, current);
  1126. struct kw_api_data awd;
  1127.         int status;
  1129.         init_waitqueue_head(&awd.wqh);
  1130.         awd.done = 0;
  1132.         set_current_state(TASK_INTERRUPTIBLE);
  1133.         add_wait_queue(&awd.wqh, &wait);
  1134.         urb->context = &awd;
  1135.         status = usb_submit_urb(urb);
  1136.         if (status) {
  1137.                 // something went wrong
  1138.                 usb_free_urb(urb);
  1139.                 set_current_state(TASK_RUNNING);
  1140.                 remove_wait_queue(&awd.wqh, &wait);
  1141.                 return status;
  1142.         }
  1144. while (timeout && !awd.done)
  1145. timeout = schedule_timeout(timeout);
  1147.         set_current_state(TASK_RUNNING);
  1148.         remove_wait_queue(&awd.wqh, &wait);
  1150.         if (!timeout) {
  1151.                 // timeout
  1152.                 kaweth_warn("usb_control/bulk_msg: timeout");
  1153.                 usb_unlink_urb(urb);  // remove urb safely
  1154.                 status = -ETIMEDOUT;
  1155.         }
  1156. else {
  1157.                 status = urb->status;
  1158. }
  1160.         if (actual_length) {
  1161.                 *actual_length = urb->actual_length;
  1162. }
  1164.         usb_free_urb(urb);
  1165.         return status;
  1166. }
  1168. /*-------------------------------------------------------------------*/
  1169. // returns status (negative) or length (positive)
  1170. int kaweth_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,
  1171.                             struct usb_ctrlrequest *cmd, void *data, int len,
  1172.     int timeout)
  1173. {
  1174.         struct urb *urb;
  1175.         int retv;
  1176.         int length;
  1178.         urb = usb_alloc_urb(0);
  1179.         if (!urb)
  1180.                 return -ENOMEM;
  1182.         FILL_CONTROL_URB(urb, usb_dev, pipe, (unsigned char*)cmd, data,
  1183.  len, (usb_complete_t)usb_api_blocking_completion,0);
  1185.         retv = usb_start_wait_urb(urb, timeout, &length);
  1186.         if (retv < 0) {
  1187.                 return retv;
  1188. }
  1189.         else {
  1190.                 return length;
  1191. }
  1192. }
  1195. /****************************************************************
  1196.  *     kaweth_init
  1197.  ****************************************************************/
  1198. int __init kaweth_init(void)
  1199. {
  1200. kaweth_dbg("Driver loading");
  1201. return usb_register(&kaweth_driver);
  1202. }
  1204. /****************************************************************
  1205.  *     kaweth_exit
  1206.  ****************************************************************/
  1207. void __exit kaweth_exit(void)
  1208. {
  1209. usb_deregister(&kaweth_driver);
  1210. }
  1212. module_init(kaweth_init);
  1213. module_exit(kaweth_exit);