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

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

嵌入式Linux

开发平台：

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.  *
  9.  *     Original author: The Zapman <zapman@interlan.net>
  10.  *     Inspired by, and much credit goes to Michael Rothwell 
  11.  *     <rothwell@interlan.net> for the test equipment, help, and patience
  12.  *     Based off of (and with thanks to) Petko Manolov's pegaus.c driver.
  13.  *     Also many thanks to Joel Silverman and Ed Surprenant at Kawasaki 
  14.  *     for providing the firmware and driver resources.
  15.  *
  16.  *     This program is free software; you can redistribute it and/or
  17.  *     modify it under the terms of the GNU General Public License as
  18.  *     published by the Free Software Foundation; either version 2, 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 Foundation,
  28.  *     Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
  29.  *
  30.  ****************************************************************/
  32. /* TODO:
  33.  * Fix in_interrupt() problem
  34.  * Develop test procedures for USB net interfaces
  35.  * Run test procedures
  36.  * Fix bugs from previous two steps
  37.  * Snoop other OSs for any tricks we're not doing
  38.  * SMP locking
  39.  * Reduce arbitrary timeouts 
  40.  * Smart multicast support 
  41.  * Temporary MAC change support
  42.  * Tunable SOFs parameter - ioctl()?
  43.  * Ethernet stats collection
  44.  * Code formatting improvements
  45.  */
  47. #include <linux/module.h>
  48. #include <linux/sched.h>
  49. #include <linux/slab.h>
  50. #include <linux/string.h>
  51. #include <linux/init.h>
  52. #include <linux/delay.h>
  53. #include <linux/netdevice.h>
  54. #include <linux/etherdevice.h>
  55. #include <linux/usb.h>
  56. #include <linux/types.h>
  57. #include <asm/semaphore.h>
  59. #define DEBUG
  61. #ifdef DEBUG
  62. #define kaweth_dbg(format, arg...) printk(KERN_DEBUG __FILE__ ": " format "n" ,##arg)
  63. #else
  64. #define kaweth_dbg(format, arg...) do {} while (0)
  65. #endif
  66. #define kaweth_err(format, arg...) printk(KERN_ERR __FILE__ ": " format "n" ,##arg)
  67. #define kaweth_info(format, arg...) printk(KERN_INFO __FILE__ ": " format "n" , ##arg)
  68. #define kaweth_warn(format, arg...) printk(KERN_WARNING __FILE__ ": " format "n" , ##arg)
  71. #include "kawethfw.h"
  73. #define KAWETH_MTU 1514
  74. #define KAWETH_BUF_SIZE 1664
  75. #define KAWETH_TX_TIMEOUT (5 * HZ)
  76. #define KAWETH_FIRMWARE_BUF_SIZE 4096
  77. #define KAWETH_CONTROL_TIMEOUT (30 * HZ)
  79. #define KAWETH_STATUS_BROKEN 0x0000001
  80. #define KAWETH_STATUS_CLOSING 0x0000002
  82. #define KAWETH_PACKET_FILTER_PROMISCUOUS 0x01
  83. #define KAWETH_PACKET_FILTER_ALL_MULTICAST 0x02
  84. #define KAWETH_PACKET_FILTER_DIRECTED 0x04
  85. #define KAWETH_PACKET_FILTER_BROADCAST 0x08
  86. #define KAWETH_PACKET_FILTER_MULTICAST 0x10
  88. /* Table 7 */
  89. #define KAWETH_COMMAND_GET_ETHERNET_DESC 0x00
  90. #define KAWETH_COMMAND_MULTICAST_FILTERS        0x01
  91. #define KAWETH_COMMAND_SET_PACKET_FILTER 0x02
  92. #define KAWETH_COMMAND_STATISTICS               0x03
  93. #define KAWETH_COMMAND_SET_TEMP_MAC      0x06
  94. #define KAWETH_COMMAND_GET_TEMP_MAC             0x07
  95. #define KAWETH_COMMAND_SET_URB_SIZE 0x08
  96. #define KAWETH_COMMAND_SET_SOFS_WAIT 0x09
  97. #define KAWETH_COMMAND_SCAN 0xFF
  99. #define KAWETH_SOFS_TO_WAIT 0x05
  102. MODULE_AUTHOR("Michael Zappe <zapman@interlan.net>, Stephane Alnet <stephane@u-picardie.fr> and Brad Hards <bhards@bigpond.net.au>");
  103. MODULE_DESCRIPTION("KL5USB101 USB Ethernet driver");
  104. MODULE_LICENSE("GPL");
  106. static void *kaweth_probe(
  107.             struct usb_device *dev,             /* the device */
  108.             unsigned ifnum,                     /* what interface */
  109.             const struct usb_device_id *id      /* from id_table */
  110. );
  111. static void kaweth_disconnect(struct usb_device *dev, void *ptr);
  112. int kaweth_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,
  113. devrequest *cmd, void *data, int len,
  114. int timeout);
  116. /****************************************************************
  117.  *     usb_device_id
  118.  ****************************************************************/
  119. static struct usb_device_id usb_klsi_table[] = {
  120. { USB_DEVICE(0x03e8, 0x0008) }, /* AOX Endpoints USB Ethernet */ 
  121. { USB_DEVICE(0x04bb, 0x0901) }, /* I-O DATA USB-ET/T */
  122. { USB_DEVICE(0x0506, 0x03e8) }, /* 3Com 3C19250 */ 
  123. { USB_DEVICE(0x0557, 0x2002) }, /* ATEN USB Ethernet */ 
  124. { USB_DEVICE(0x0557, 0x4000) }, /* D-Link DSB-650C */ 
  125. { USB_DEVICE(0x0565, 0x0002) }, /* Peracom Enet */
  126. { USB_DEVICE(0x0565, 0x0005) }, /* Peracom Enet2 */ 
  127. { USB_DEVICE(0x05e9, 0x0008) }, /* KLSI KL5KUSB101B */
  128. { USB_DEVICE(0x05e9, 0x0009) }, /* KLSI KL5KUSB101B (Board change) */
  129. { USB_DEVICE(0x066b, 0x2202) }, /* Linksys USB10T */ 
  130. { USB_DEVICE(0x06e1, 0x0008) }, /* ADS USB-10BT */ 
  131. { USB_DEVICE(0x06e1, 0x0009) }, /* ADS USB-10BT */ 
  132. { USB_DEVICE(0x0707, 0x0100) }, /* SMC 2202USB */ 
  133. { USB_DEVICE(0x07aa, 0x0001) }, /* Correga K.K. */ 
  134. { USB_DEVICE(0x07b8, 0x4000) }, /* D-Link DU-E10 */
  135. { USB_DEVICE(0x0846, 0x1001) }, /* NetGear EA-101 */
  136. { USB_DEVICE(0x0846, 0x1002) }, /* NetGear EA-101 */
  137. { USB_DEVICE(0x085a, 0x0008) }, /* PortGear Ethernet Adapter */
  138. { USB_DEVICE(0x085a, 0x0009) }, /* PortGear Ethernet Adapter */
  139. { USB_DEVICE(0x087d, 0x5704) }, /* Jaton USB Ethernet Device Adapter */
  140. { USB_DEVICE(0x0951, 0x0008) }, /* Kingston Technology USB Ethernet Adapter */
  141. { USB_DEVICE(0x095a, 0x3003) }, /* Portsmith Express Ethernet Adapter */
  142. { USB_DEVICE(0x10bd, 0x1427) }, /* ASANTE USB To Ethernet Adapter */
  143. { USB_DEVICE(0x1342, 0x0204) }, /* Mobility USB-Ethernet Adapter */
  144. { USB_DEVICE(0x13d2, 0x0400) }, /* Shark Pocket Adapter */
  145. { USB_DEVICE(0x1645, 0x0005) }, /* Entrega E45 */ 
  146. { USB_DEVICE(0x1645, 0x0008) }, /* Entrega USB Ethernet Adapter */ 
  147. { USB_DEVICE(0x1645, 0x8005) }, /* PortGear Ethernet Adapter */ 
  148. { USB_DEVICE(0x2001, 0x4000) }, /* D-link DSB-650C */
  149. {} /* Null terminator */
  150. };
  152. MODULE_DEVICE_TABLE (usb, usb_klsi_table);
  154. /****************************************************************
  155.  *     kaweth_driver
  156.  ****************************************************************/
  157. static struct usb_driver kaweth_driver = {
  158. name: "kaweth",
  159. probe: kaweth_probe,
  160. disconnect: kaweth_disconnect,
  161. id_table:       usb_klsi_table,
  162. };
  164. typedef __u8 eth_addr_t[6];
  166. /****************************************************************
  167.  *     usb_eth_dev
  168.  ****************************************************************/
  169. struct usb_eth_dev {
  170. char *name;
  171. __u16 vendor;
  172. __u16 device;
  173. void *pdata;
  174. };
  176. /****************************************************************
  177.  *     kaweth_ethernet_configuration
  178.  *     Refer Table 8
  179.  ****************************************************************/
  180. struct kaweth_ethernet_configuration
  181. {
  182. __u8 size;
  183. __u8 reserved1;
  184. __u8 reserved2;
  185. eth_addr_t hw_addr;
  186. __u32 statistics_mask;
  187. __u16 segment_size;
  188. __u16 max_multicast_filters;
  189. __u8 reserved3;
  190. } __attribute__ ((packed));
  192. /****************************************************************
  193.  *     kaweth_device
  194.  ****************************************************************/
  195. struct kaweth_device
  196. {
  197. spinlock_t device_lock;
  199. __u32 status;
  201. struct usb_device *dev;
  202. struct net_device *net;
  203. wait_queue_head_t control_wait;
  205. struct urb *rx_urb;
  206. struct urb *tx_urb;
  208. __u8 firmware_buf[KAWETH_FIRMWARE_BUF_SIZE];
  209. __u8 tx_buf[KAWETH_BUF_SIZE];
  210. __u8 rx_buf[KAWETH_BUF_SIZE];
  211. __u16 packet_filter_bitmap;
  213. struct kaweth_ethernet_configuration configuration;
  215. struct net_device_stats stats;
  216. } __attribute__ ((packed));
  219. /****************************************************************
  220.  *     kaweth_control
  221.  ****************************************************************/
  222. static int kaweth_control(struct kaweth_device *kaweth,
  223.   unsigned int pipe, 
  224.   __u8 request, 
  225.   __u8 requesttype, 
  226.   __u16 value, 
  227.   __u16 index,
  228.   void *data, 
  229.   __u16 size, 
  230.   int timeout)
  231. {
  232. devrequest *dr;
  234. kaweth_dbg("kaweth_control()");
  236. if(in_interrupt()) {
  237. kaweth_dbg("in_interrupt()");
  238. return -EBUSY;
  239. }
  241. dr = kmalloc(sizeof(devrequest), 
  242.                      in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
  244. if(!dr)
  245. {
  246. kaweth_dbg("kmalloc() failed");
  247. return -ENOMEM;
  248. }
  250. dr->requesttype = requesttype;
  251. dr->request = request;
  252. dr->value = cpu_to_le16p(&value);
  253. dr->index = cpu_to_le16p(&index);
  254. dr->length = cpu_to_le16p(&size);
  256. return kaweth_internal_control_msg(kaweth->dev,
  257. pipe,
  258. dr,
  259. data,
  260. size,
  261. timeout);
  262. }
  264. /****************************************************************
  265.  *     kaweth_read_configuration
  266.  ****************************************************************/
  267. static int kaweth_read_configuration(struct kaweth_device *kaweth)
  268. {
  269. int retval;
  271. kaweth_dbg("Reading kaweth configuration");
  273. retval = kaweth_control(kaweth,
  274. usb_rcvctrlpipe(kaweth->dev, 0),
  275. KAWETH_COMMAND_GET_ETHERNET_DESC,
  276. USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
  277. 0,
  278. 0,
  279. (void *)&kaweth->configuration,
  280. sizeof(kaweth->configuration),
  281. KAWETH_CONTROL_TIMEOUT);
  283. return retval;
  284. }
  286. /****************************************************************
  287.  *     kaweth_set_urb_size
  288.  ****************************************************************/
  289. static int kaweth_set_urb_size(struct kaweth_device *kaweth, __u16 urb_size)
  290. {
  291. int retval;
  293. kaweth_dbg("Setting URB size to %d", (unsigned)urb_size);
  295. retval = kaweth_control(kaweth,
  296. usb_sndctrlpipe(kaweth->dev, 0),
  297. KAWETH_COMMAND_SET_URB_SIZE,
  298. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  299. urb_size,
  300. 0,
  301. (void *)&kaweth->firmware_buf,
  302. 0,
  303. KAWETH_CONTROL_TIMEOUT);
  305. return retval;
  306. }
  308. /****************************************************************
  309.  *     kaweth_set_sofs_wait
  310.  ****************************************************************/
  311. static int kaweth_set_sofs_wait(struct kaweth_device *kaweth, __u16 sofs_wait)
  312. {
  313. int retval;
  315. kaweth_dbg("Set SOFS wait to %d", (unsigned)sofs_wait);
  317. retval = kaweth_control(kaweth,
  318. usb_sndctrlpipe(kaweth->dev, 0),
  319. KAWETH_COMMAND_SET_SOFS_WAIT,
  320. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  321. sofs_wait,
  322. 0,
  323. (void *)&kaweth->firmware_buf,
  324. 0,
  325. KAWETH_CONTROL_TIMEOUT);
  327. return retval;
  328. }
  330. /****************************************************************
  331.  *     kaweth_set_receive_filter
  332.  ****************************************************************/
  333. static int kaweth_set_receive_filter(struct kaweth_device *kaweth,
  334.      __u16 receive_filter)
  335. {
  336. int retval;
  338. kaweth_dbg("Set receive filter to %d", (unsigned)receive_filter);
  340. retval = kaweth_control(kaweth,
  341. usb_sndctrlpipe(kaweth->dev, 0),
  342. KAWETH_COMMAND_SET_PACKET_FILTER,
  343. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  344. receive_filter,
  345. 0,
  346. (void *)&kaweth->firmware_buf,
  347. 0,
  348. KAWETH_CONTROL_TIMEOUT);
  350. return retval;
  351. }
  353. /****************************************************************
  354.  *     kaweth_download_firmware
  355.  ****************************************************************/
  356. static int kaweth_download_firmware(struct kaweth_device *kaweth, 
  357.     __u8 *data, 
  358.     __u16 data_len,
  359.     __u8 interrupt,
  360.     __u8 type)
  361. {
  362. if(data_len > KAWETH_FIRMWARE_BUF_SIZE) {
  363. kaweth_err("Firmware too big: %d", data_len);
  364. return -ENOSPC;
  365. }
  367. memcpy(kaweth->firmware_buf, data, data_len);
  369. kaweth->firmware_buf[2] = (data_len & 0xFF) - 7;
  370. kaweth->firmware_buf[3] = data_len >> 8;
  371. kaweth->firmware_buf[4] = type;
  372. kaweth->firmware_buf[5] = interrupt;
  374. kaweth_dbg("High: %i, Low:%i", kaweth->firmware_buf[3],
  375.    kaweth->firmware_buf[2]);
  377. kaweth_dbg("Downloading firmware at %p to kaweth device at %p", 
  378.     data, 
  379.     kaweth);
  380. kaweth_dbg("Firmware length: %d", data_len);
  382. return kaweth_control(kaweth,
  383.               usb_sndctrlpipe(kaweth->dev, 0),
  384.       KAWETH_COMMAND_SCAN,
  385.       USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  386.       0,
  387.       0,
  388.       (void *)&kaweth->firmware_buf,
  389.       data_len,
  390.       KAWETH_CONTROL_TIMEOUT);
  391. }
  393. /****************************************************************
  394.  *     kaweth_trigger_firmware
  395.  ****************************************************************/
  396. static int kaweth_trigger_firmware(struct kaweth_device *kaweth,
  397.    __u8 interrupt)
  398. {
  399. kaweth->firmware_buf[0] = 0xB6;
  400. kaweth->firmware_buf[1] = 0xC3;
  401. kaweth->firmware_buf[2] = 0x01;
  402. kaweth->firmware_buf[3] = 0x00;
  403. kaweth->firmware_buf[4] = 0x06;
  404. kaweth->firmware_buf[5] = interrupt;
  405. kaweth->firmware_buf[6] = 0x00;
  406. kaweth->firmware_buf[7] = 0x00;
  408. kaweth_dbg("Triggering firmware");
  410. return kaweth_control(kaweth,
  411.       usb_sndctrlpipe(kaweth->dev, 0),
  412.       KAWETH_COMMAND_SCAN,
  413.       USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  414.       0,
  415.       0,
  416.       (void *)&kaweth->firmware_buf,
  417.       8,
  418.       KAWETH_CONTROL_TIMEOUT);
  419. }
  421. /****************************************************************
  422.  *     kaweth_reset
  423.  ****************************************************************/
  424. static int kaweth_reset(struct kaweth_device *kaweth)
  425. {
  426. int result;
  428. kaweth_dbg("kaweth_reset(%p)", kaweth);
  429. result = kaweth_control(kaweth,
  430. usb_sndctrlpipe(kaweth->dev, 0),
  431. USB_REQ_SET_CONFIGURATION, 
  432. 0, 
  433. kaweth->dev->config[0].bConfigurationValue,
  434. 0, 
  435. NULL, 
  436. 0, 
  437. KAWETH_CONTROL_TIMEOUT);
  439. udelay(10000);
  441. kaweth_dbg("kaweth_reset() returns %d.",result);
  443. return result;
  444. }
  446. static void kaweth_usb_receive(struct urb *);
  448. /****************************************************************
  449.  *     kaweth_resubmit_rx_urb
  450.  ****************************************************************/
  451. static inline void kaweth_resubmit_rx_urb(struct kaweth_device *kaweth)
  452. {
  453. int result;
  455. memset(kaweth->rx_urb, 0, sizeof(*kaweth->rx_urb));
  457. FILL_BULK_URB(kaweth->rx_urb,
  458.       kaweth->dev,
  459.       usb_rcvbulkpipe(kaweth->dev, 1),
  460.       kaweth->rx_buf,
  461.       KAWETH_BUF_SIZE,
  462.       kaweth_usb_receive,
  463.       kaweth);
  465. if((result = usb_submit_urb(kaweth->rx_urb))) {
  466. kaweth_err("resubmitting rx_urb %d failed", result);
  467. }
  468. }
  470. static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth);
  472. /****************************************************************
  473.  *     kaweth_usb_receive
  474.  ****************************************************************/
  475. static void kaweth_usb_receive(struct urb *urb)
  476. {
  477. struct kaweth_device *kaweth = urb->context;
  478. struct net_device *net = kaweth->net;
  480. int count = urb->actual_length;
  481. int count2 = urb->transfer_buffer_length;
  483. __u16 pkt_len = le16_to_cpup((u16 *)kaweth->rx_buf);
  485. struct sk_buff *skb;
  487. if(kaweth->status & KAWETH_STATUS_CLOSING) {
  488. return;
  489. }
  491. if(urb->status && urb->status != -EREMOTEIO && count != 1) { 
  492. kaweth_err("%s RX status: %d count: %d packet_len: %d",
  493.                            net->name, 
  494.    urb->status,
  495.    count, 
  496.    (int)pkt_len);
  497. kaweth_resubmit_rx_urb(kaweth);
  498.                 return;
  499. }
  501. if(kaweth->net && (count > 2)) {
  502. if(pkt_len > (count - 2)) {
  503. kaweth_err("Packet length too long for USB frame (pkt_len: %x, count: %x)",pkt_len, count);
  504. kaweth_err("Packet len & 2047: %x", pkt_len & 2047);
  505. kaweth_err("Count 2: %x", count2);
  506.         kaweth_resubmit_rx_urb(kaweth);
  507.                         return;
  508.                 }
  510. if(!(skb = dev_alloc_skb(pkt_len+2))) {
  511.         kaweth_resubmit_rx_urb(kaweth);
  512.                         return;
  513. }
  515. skb->dev = net;
  517. eth_copy_and_sum(skb, kaweth->rx_buf + 2, pkt_len, 0);
  519. skb_put(skb, pkt_len);
  521. skb->protocol = eth_type_trans(skb, net);
  523. netif_rx(skb);
  525. kaweth->stats.rx_packets++;
  526. kaweth->stats.rx_bytes += pkt_len;
  527. }
  529. kaweth_resubmit_rx_urb(kaweth);
  530. }
  532. /****************************************************************
  533.  *     kaweth_open
  534.  ****************************************************************/
  535. static int kaweth_open(struct net_device *net)
  536. {
  537. struct kaweth_device *kaweth = (struct kaweth_device *)net->priv;
  539. kaweth_dbg("Dev usage: %d", kaweth->dev->refcnt.counter);
  541. kaweth_dbg("Opening network device.");
  543. kaweth_resubmit_rx_urb(kaweth);
  545. netif_start_queue(net);
  547. MOD_INC_USE_COUNT;
  549. kaweth_async_set_rx_mode(kaweth);
  550. return 0;
  551. }
  553. /****************************************************************
  554.  *     kaweth_close
  555.  ****************************************************************/
  556. static int kaweth_close(struct net_device *net)
  557. {
  558. struct kaweth_device *kaweth = net->priv;
  560. netif_stop_queue(net);
  562. kaweth->status |= KAWETH_STATUS_CLOSING;
  564. usb_unlink_urb(kaweth->rx_urb);
  566. kaweth->status &= ~KAWETH_STATUS_CLOSING;
  568. MOD_DEC_USE_COUNT;
  570. printk("Dev usage: %d", kaweth->dev->refcnt.counter);
  572. return 0;
  573. }
  575. /****************************************************************
  576.  *     kaweth_ioctl
  577.  ****************************************************************/
  578. static int kaweth_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
  579. {
  580. return -EOPNOTSUPP;
  581. }
  583. /****************************************************************
  584.  *     kaweth_usb_transmit_complete
  585.  ****************************************************************/
  586. static void kaweth_usb_transmit_complete(struct urb *urb)
  587. {
  588. struct kaweth_device *kaweth = urb->context;
  590. spin_lock(&kaweth->device_lock);
  592. if (urb->status)
  593. kaweth_dbg("%s: TX status %d.", kaweth->net->name, urb->status);
  595. netif_wake_queue(kaweth->net);
  597. spin_unlock(&kaweth->device_lock);
  598. }
  600. /****************************************************************
  601.  *     kaweth_start_xmit
  602.  ****************************************************************/
  603. static int kaweth_start_xmit(struct sk_buff *skb, struct net_device *net)
  604. {
  605. struct kaweth_device *kaweth = net->priv;
  606. int count = skb->len;
  608. int res;
  610. spin_lock(&kaweth->device_lock);
  612. kaweth_async_set_rx_mode(kaweth);
  613. netif_stop_queue(net);
  615. *((__u16 *)kaweth->tx_buf) = cpu_to_le16(skb->len);
  617. memcpy(kaweth->tx_buf + 2, skb->data, skb->len);
  619. memset(kaweth->tx_urb, 0, sizeof(*kaweth->tx_urb));
  621. FILL_BULK_URB(kaweth->tx_urb,
  622.       kaweth->dev,
  623.       usb_sndbulkpipe(kaweth->dev, 2),
  624.       kaweth->tx_buf,
  625.       count + 2,
  626.       kaweth_usb_transmit_complete,
  627.       kaweth);
  629. if((res = usb_submit_urb(kaweth->tx_urb)))
  630. {
  631. kaweth_warn("kaweth failed tx_urb %d", res);
  632. kaweth->stats.tx_errors++;
  634. netif_start_queue(net);
  635. } 
  636. else 
  637. {
  638. kaweth->stats.tx_packets++;
  639. kaweth->stats.tx_bytes += skb->len;
  640. net->trans_start = jiffies;
  641. }
  643. dev_kfree_skb(skb);
  645. spin_unlock(&kaweth->device_lock);
  647. return 0;
  648. }
  650. /****************************************************************
  651.  *     kaweth_set_rx_mode
  652.  ****************************************************************/
  653. static void kaweth_set_rx_mode(struct net_device *net)
  654. {
  655. struct kaweth_device *kaweth = net->priv;
  657. __u16 packet_filter_bitmap = KAWETH_PACKET_FILTER_DIRECTED |
  658.                                      KAWETH_PACKET_FILTER_BROADCAST |
  659.                      KAWETH_PACKET_FILTER_MULTICAST;
  661. kaweth_dbg("Setting Rx mode to %d", packet_filter_bitmap);
  663. netif_stop_queue(net);
  665. if (net->flags & IFF_PROMISC) {
  666. packet_filter_bitmap |= KAWETH_PACKET_FILTER_PROMISCUOUS;
  667. } 
  668. else if ((net->mc_count) || (net->flags & IFF_ALLMULTI)) {
  669. packet_filter_bitmap |= KAWETH_PACKET_FILTER_ALL_MULTICAST;
  670. }
  672. kaweth->packet_filter_bitmap = packet_filter_bitmap;
  673. netif_wake_queue(net);
  674. }
  676. /****************************************************************
  677.  *     kaweth_async_set_rx_mode
  678.  ****************************************************************/
  679. static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
  680. {
  681. __u16 packet_filter_bitmap = kaweth->packet_filter_bitmap;
  682. kaweth->packet_filter_bitmap = 0;
  683. if(packet_filter_bitmap == 0) return;
  685. {
  686. int result;
  687. result = kaweth_control(kaweth,
  688. usb_sndctrlpipe(kaweth->dev, 0),
  689. KAWETH_COMMAND_SET_PACKET_FILTER,
  690. USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
  691. packet_filter_bitmap,
  692. 0,
  693. (void *)&kaweth->firmware_buf,
  694. 0,
  695. KAWETH_CONTROL_TIMEOUT);
  697. if(result < 0) {
  698. kaweth_err("Failed to set Rx mode: %d", result);
  699. }
  700. else {
  701. kaweth_dbg("Set Rx mode to %d", packet_filter_bitmap);
  702. }
  703. }
  704. }
  706. /****************************************************************
  707.  *     kaweth_netdev_stats
  708.  ****************************************************************/
  709. static struct net_device_stats *kaweth_netdev_stats(struct net_device *dev)
  710. {
  711. return &((struct kaweth_device *)dev->priv)->stats;
  712. }
  714. /****************************************************************
  715.  *     kaweth_tx_timeout
  716.  ****************************************************************/
  717. static void kaweth_tx_timeout(struct net_device *net)
  718. {
  719. struct kaweth_device *kaweth = net->priv;
  721. kaweth_warn("%s: Tx timed out. Resetting.", net->name);
  722. kaweth->stats.tx_errors++;
  723. net->trans_start = jiffies;
  725. usb_unlink_urb(kaweth->tx_urb);
  726. }
  728. /****************************************************************
  729.  *     kaweth_probe
  730.  ****************************************************************/
  731. static void *kaweth_probe(
  732.             struct usb_device *dev,             /* the device */
  733.             unsigned ifnum,                      /* what interface */
  734.             const struct usb_device_id *id      /* from id_table */
  735. )
  736. {
  737. struct kaweth_device *kaweth;
  738. const eth_addr_t bcast_addr = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  739. int result = 0;
  741. kaweth_dbg("Kawasaki Device Probe (Device number:%d): 0x%4.4x:0x%4.4x:0x%4.4x",
  742.  dev->devnum, 
  743.  (int)dev->descriptor.idVendor, 
  744.  (int)dev->descriptor.idProduct,
  745.  (int)dev->descriptor.bcdDevice);
  747. kaweth_dbg("Device at %p", dev);
  749. kaweth_dbg("Descriptor length: %x type: %x", 
  750.  (int)dev->descriptor.bLength,
  751.  (int)dev->descriptor.bDescriptorType);
  753. if(!(kaweth = kmalloc(sizeof(struct kaweth_device), GFP_KERNEL))) {
  754. kaweth_dbg("out of memory allocating device structuren");
  755. return NULL;
  756. }
  758. memset(kaweth, 0, sizeof(struct kaweth_device));
  760. kaweth->dev = dev;
  761. kaweth->status = 0;
  762. kaweth->net = NULL;
  763. kaweth->device_lock = SPIN_LOCK_UNLOCKED;
  765. kaweth_dbg("Resetting.");
  767. kaweth_reset(kaweth);
  769. /*
  770.  * If high byte of bcdDevice is nonzero, firmware is already
  771.  * downloaded. Don't try to do it again, or we'll hang the device.
  772.  */
  774. if (dev->descriptor.bcdDevice >> 8) {
  775. kaweth_info("Firmware present in device.");
  776. } else {
  777. /* Download the firmware */
  778. kaweth_info("Downloading firmware...");
  779. if ((result = kaweth_download_firmware(kaweth, 
  780.       kaweth_new_code, 
  781.       len_kaweth_new_code, 
  782.       100, 
  783.       2)) < 0) {
  784. kaweth_err("Error downloading firmware (%d)", result);
  785. kfree(kaweth);
  786. return NULL;
  787. }
  789. if ((result = kaweth_download_firmware(kaweth, 
  790.       kaweth_new_code_fix, 
  791.       len_kaweth_new_code_fix, 
  792.       100, 
  793.       3)) < 0) {
  794. kaweth_err("Error downloading firmware fix (%d)", result);
  795. kfree(kaweth);
  796. return NULL;
  797. }
  799. if ((result = kaweth_download_firmware(kaweth,
  800.       kaweth_trigger_code,
  801.       len_kaweth_trigger_code,
  802.       126,
  803.       2)) < 0) {
  804. kaweth_err("Error downloading trigger code (%d)", result);
  805. kfree(kaweth);
  806. return NULL;
  807. }
  809. if ((result = kaweth_download_firmware(kaweth,
  810.       kaweth_trigger_code_fix,
  811.       len_kaweth_trigger_code_fix,
  812.       126,
  813.       3)) < 0) {
  814. kaweth_err("Error downloading trigger code fix (%d)", result);
  815. kfree(kaweth);
  816. return NULL;
  817. }
  820. if ((result = kaweth_trigger_firmware(kaweth, 126)) < 0) {
  821. kaweth_err("Error triggering firmware (%d)", result);
  822. kfree(kaweth);
  823. return NULL;
  824. }
  826. /* Device will now disappear for a moment...  */
  827. kaweth_info("Firmware loaded.  I'll be back...");
  828. return NULL;
  829. }
  831. result = kaweth_read_configuration(kaweth);
  833. if(result < 0) {
  834. kaweth_err("Error reading configuration (%d), no net device created", result);
  835. kfree(kaweth);
  836. return NULL;
  837. }
  839. kaweth_info("Statistics collection: %x", kaweth->configuration.statistics_mask);
  840. kaweth_info("Multicast filter limit: %x", kaweth->configuration.max_multicast_filters & ((1 << 15) - 1));
  841. kaweth_info("MTU: %d", le16_to_cpu(kaweth->configuration.segment_size));
  842. kaweth_info("Read MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
  843.  (int)kaweth->configuration.hw_addr[0],
  844.  (int)kaweth->configuration.hw_addr[1],
  845.  (int)kaweth->configuration.hw_addr[2],
  846.  (int)kaweth->configuration.hw_addr[3],
  847.  (int)kaweth->configuration.hw_addr[4],
  848.  (int)kaweth->configuration.hw_addr[5]);
  850. if(!memcmp(&kaweth->configuration.hw_addr,
  851.                    &bcast_addr, 
  852.    sizeof(bcast_addr))) {
  853. kaweth_err("Firmware not functioning properly, no net device created");
  854. kfree(kaweth);
  855. return NULL;
  856. }
  858. if(kaweth_set_urb_size(kaweth, KAWETH_BUF_SIZE) < 0) {
  859. kaweth_dbg("Error setting URB size");
  860. return kaweth;
  861. }
  863. if(kaweth_set_sofs_wait(kaweth, KAWETH_SOFS_TO_WAIT) < 0) {
  864. kaweth_err("Error setting SOFS wait");
  865. return kaweth;
  866. }
  868. result = kaweth_set_receive_filter(kaweth, 
  869.                                            KAWETH_PACKET_FILTER_DIRECTED |
  870.                                            KAWETH_PACKET_FILTER_BROADCAST |
  871.                                            KAWETH_PACKET_FILTER_MULTICAST);
  873. if(result < 0) {
  874. kaweth_err("Error setting receive filter");
  875. return kaweth;
  876. }
  878. kaweth_dbg("Initializing net device.");
  880. kaweth->tx_urb = usb_alloc_urb(0);
  881. kaweth->rx_urb = usb_alloc_urb(0);
  883. kaweth->net = init_etherdev(0, 0);
  884. if (!kaweth->net) {
  885. kaweth_err("Error calling init_etherdev.");
  886. return kaweth;
  887. }
  889. memcpy(kaweth->net->broadcast, &bcast_addr, sizeof(bcast_addr));
  890. memcpy(kaweth->net->dev_addr, 
  891.                &kaweth->configuration.hw_addr,
  892.                sizeof(kaweth->configuration.hw_addr));
  893.  
  894. kaweth->net->priv = kaweth;
  895. kaweth->net->open = kaweth_open;
  896. kaweth->net->stop = kaweth_close;
  898. kaweth->net->watchdog_timeo = KAWETH_TX_TIMEOUT;
  899. kaweth->net->tx_timeout = kaweth_tx_timeout;
  901. kaweth->net->do_ioctl = kaweth_ioctl;
  902. kaweth->net->hard_start_xmit = kaweth_start_xmit;
  903. kaweth->net->set_multicast_list = kaweth_set_rx_mode;
  904. kaweth->net->get_stats = kaweth_netdev_stats;
  905. kaweth->net->mtu = le16_to_cpu(kaweth->configuration.segment_size);
  907. memset(&kaweth->stats, 0, sizeof(kaweth->stats));
  909. kaweth_info("kaweth interface created at %s", kaweth->net->name);
  911. kaweth_dbg("Kaweth probe returning.");
  913. return kaweth;
  914. }
  916. /****************************************************************
  917.  *     kaweth_disconnect
  918.  ****************************************************************/
  919. static void kaweth_disconnect(struct usb_device *dev, void *ptr)
  920. {
  921. struct kaweth_device *kaweth = ptr;
  923. kaweth_info("Unregistering");
  925. if (!kaweth) {
  926. kaweth_warn("unregistering non-existant device");
  927. return;
  928. }
  930. if(kaweth->net) {
  931. if(kaweth->net->flags & IFF_UP) {
  932. kaweth_dbg("Closing net device");
  933. dev_close(kaweth->net);
  934. }
  936. kaweth_dbg("Unregistering net device");
  937. unregister_netdev(kaweth->net);
  938. }
  940. usb_free_urb(kaweth->rx_urb);
  941. usb_free_urb(kaweth->tx_urb);
  943. kfree(kaweth);
  944. }
  947. /*-------------------------------------------------------------------*
  948.  * completion handler for compatibility wrappers (sync control/bulk) *
  949.  *-------------------------------------------------------------------*/
  950. static void usb_api_blocking_completion(urb_t *urb)
  951. {
  952.         struct usb_api_data *awd = (struct usb_api_data *)urb->context;
  954. awd->done=1;
  955. wake_up(&awd->wqh);
  956. }
  958. /*-------------------------------------------------------------------*
  959.  *                         COMPATIBILITY STUFF                       *
  960.  *-------------------------------------------------------------------*/
  962. // Starts urb and waits for completion or timeout
  963. static int usb_start_wait_urb(urb_t *urb, int timeout, int* actual_length)
  964. {
  965.         DECLARE_WAITQUEUE(wait, current);
  966. struct usb_api_data awd;
  967.         int status;
  969.         init_waitqueue_head(&awd.wqh);
  970.         awd.done = 0;
  971.         
  972.         set_current_state(TASK_INTERRUPTIBLE);
  973.         add_wait_queue(&awd.wqh, &wait);
  974.         urb->context = &awd;
  975.         status = usb_submit_urb(urb);
  976.         if (status) {
  977.                 // something went wrong
  978.                 usb_free_urb(urb);
  979.                 set_current_state(TASK_RUNNING);
  980.                 remove_wait_queue(&awd.wqh, &wait);
  981.                 return status;
  982.         }
  984. while (timeout && !awd.done)
  985. timeout = schedule_timeout(timeout);
  987.         set_current_state(TASK_RUNNING);
  988.         remove_wait_queue(&awd.wqh, &wait);
  990.         if (!timeout) {
  991.                 // timeout
  992.                 kaweth_warn("usb_control/bulk_msg: timeout");
  993.                 usb_unlink_urb(urb);  // remove urb safely
  994.                 status = -ETIMEDOUT;
  995.         }
  996. else {
  997.                 status = urb->status;
  998. }
  1000.         if (actual_length) {
  1001.                 *actual_length = urb->actual_length;
  1002. }
  1004.         usb_free_urb(urb);
  1005.         return status;
  1006. }
  1008. /*-------------------------------------------------------------------*/
  1009. // returns status (negative) or length (positive)
  1010. int kaweth_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,
  1011.                             devrequest *cmd,  void *data, int len, int timeout)
  1012. {
  1013.         urb_t *urb;
  1014.         int retv;
  1015.         int length;
  1017.         urb = usb_alloc_urb(0);
  1018.         if (!urb)
  1019.                 return -ENOMEM;
  1021.         FILL_CONTROL_URB(urb, usb_dev, pipe, (unsigned char*)cmd, data,
  1022.  len, (usb_complete_t)usb_api_blocking_completion,0);
  1024.         retv = usb_start_wait_urb(urb, timeout, &length);
  1025.         if (retv < 0) {
  1026.                 return retv;
  1027. }
  1028.         else {
  1029.                 return length;
  1030. }
  1031. }
  1034. /****************************************************************
  1035.  *     kaweth_init
  1036.  ****************************************************************/
  1037. int __init kaweth_init(void)
  1038. {
  1039. kaweth_dbg("Driver loading");
  1040. return usb_register(&kaweth_driver);
  1041. }
  1043. /****************************************************************
  1044.  *     kaweth_exit
  1045.  ****************************************************************/
  1046. void __exit kaweth_exit(void)
  1047. {
  1048. usb_deregister(&kaweth_driver);
  1049. }
  1051. module_init(kaweth_init);
  1052. module_exit(kaweth_exit);