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

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

嵌入式Linux

开发平台：

Unix_Linux

pegasus.c：源码内容
  1. /*
  2. ** Pegasus: USB 10/100Mbps/HomePNA (1Mbps) Controller
  3. **
  4. ** Copyright (c) 1999-2001 Petko Manolov (pmanolov@lnxw.com)
  5. **
  6. **
  7. ** ChangeLog:
  8. ** .... Most of the time spend reading sources & docs.
  9. ** v0.2.x First official release for the Linux kernel.
  10. ** v0.3.0 Beutified and structured, some bugs fixed.
  11. ** v0.3.x URBifying bulk requests and bugfixing. First relatively
  12. ** stable release. Still can touch device's registers only
  13. ** from top-halves.
  14. ** v0.4.0 Control messages remained unurbified are now URBs.
  15. ** Now we can touch the HW at any time.
  16. ** v0.4.9 Control urbs again use process context to wait. Argh...
  17. ** Some long standing bugs (enable_net_traffic) fixed.
  18. ** Also nasty trick about resubmiting control urb from
  19. ** interrupt context used. Please let me know how it
  20. ** behaves. Pegasus II support added since this version.
  21. ** TODO: suppressing HCD warnings spewage on disconnect.
  22. ** v0.4.13 Ethernet address is now set at probe(), not at open()
  23. ** time as this seems to break dhcpd. 
  24. */
  26. /*
  27.  * This program is free software; you can redistribute it and/or modify
  28.  * it under the terms of the GNU General Public License as published by
  29.  * the Free Software Foundation; either version 2 of the License, or
  30.  * (at your option) any later version.
  31.  *
  32.  * This program is distributed in the hope that it will be useful,
  33.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  34.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35.  * GNU General Public License for more details.
  36.  *
  37.  * You should have received a copy of the GNU General Public License
  38.  * along with this program; if not, write to the Free Software
  39.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  40.  */
  43. #include <linux/sched.h>
  44. #include <linux/slab.h>
  45. #include <linux/init.h>
  46. #include <linux/delay.h>
  47. #include <linux/netdevice.h>
  48. #include <linux/etherdevice.h>
  49. #include <linux/usb.h>
  50. #include <linux/module.h>
  51. #include "pegasus.h"
  53. /*
  54.  * Version Information
  55.  */
  56. #define DRIVER_VERSION "v0.4.22 (2001/12/07)"
  57. #define DRIVER_AUTHOR "Petko Manolov <pmanolov@lnxw.com>"
  58. #define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"
  60. #define PEGASUS_USE_INTR
  61. #define PEGASUS_WRITE_EEPROM
  63. static int loopback = 0;
  64. static int mii_mode = 0;
  65. static int multicast_filter_limit = 32;
  67. static struct usb_eth_dev usb_dev_id[] = {
  68. #define PEGASUS_DEV(pn, vid, pid, flags)
  69. {name:pn, vendor:vid, device:pid, private:flags},
  70. #include "pegasus.h"
  71. #undef PEGASUS_DEV
  72. {NULL, 0, 0, 0}
  73. };
  75. static struct usb_device_id pegasus_ids[] = {
  76. #define PEGASUS_DEV(pn, vid, pid, flags) 
  77. {match_flags: USB_DEVICE_ID_MATCH_DEVICE, idVendor:vid, idProduct:pid},
  78. #include "pegasus.h"
  79. #undef PEGASUS_DEV
  80. { }
  81. };
  84. MODULE_AUTHOR( DRIVER_AUTHOR );
  85. MODULE_DESCRIPTION( DRIVER_DESC );
  86. MODULE_LICENSE("GPL");
  87. MODULE_PARM(loopback, "i");
  88. MODULE_PARM(mii_mode, "i");
  89. MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");
  90. MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");
  92. MODULE_DEVICE_TABLE (usb, pegasus_ids);
  95. static int update_eth_regs_async( pegasus_t * );
  96. /* Aargh!!! I _really_ hate such tweaks */
  97. static void ctrl_callback( urb_t *urb )
  98. {
  99. pegasus_t *pegasus = urb->context;
  101. if ( !pegasus )
  102. return;
  104. switch ( urb->status ) {
  105. case USB_ST_NOERROR:
  106. if ( pegasus->flags & ETH_REGS_CHANGE ) {
  107. pegasus->flags &= ~ETH_REGS_CHANGE;
  108. pegasus->flags |= ETH_REGS_CHANGED;
  109. update_eth_regs_async( pegasus );
  110. return;
  111. }
  112. break;
  113. case USB_ST_URB_PENDING:
  114. return;
  115. case USB_ST_URB_KILLED:
  116. break;
  117. default:
  118. warn( __FUNCTION__ " status %d", urb->status);
  119. }
  120. pegasus->flags &= ~ETH_REGS_CHANGED;
  121. wake_up(&pegasus->ctrl_wait );
  122. }
  125. static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
  126. {
  127. int ret;
  128. unsigned char *buffer;
  129. DECLARE_WAITQUEUE(wait, current);
  131. buffer = kmalloc(size,GFP_KERNEL);
  132. if (!buffer) {
  133. err("unable to allocate memory for configuration descriptors");
  134. return 0;
  135. }
  136. memcpy(buffer,data,size);
  138. add_wait_queue(&pegasus->ctrl_wait, &wait);
  139. set_current_state(TASK_UNINTERRUPTIBLE);
  140. while ( pegasus->flags & ETH_REGS_CHANGED )
  141. schedule();
  142. remove_wait_queue(&pegasus->ctrl_wait, &wait);
  143. set_current_state(TASK_RUNNING);
  145. pegasus->dr.requesttype = PEGASUS_REQT_READ;
  146. pegasus->dr.request = PEGASUS_REQ_GET_REGS;
  147. pegasus->dr.value = cpu_to_le16 (0);
  148. pegasus->dr.index = cpu_to_le16p(&indx);
  149. pegasus->dr.length = cpu_to_le16p(&size);
  150. pegasus->ctrl_urb.transfer_buffer_length = size;
  152. FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
  153.   usb_rcvctrlpipe(pegasus->usb,0),
  154.   (char *)&pegasus->dr,
  155.   buffer, size, ctrl_callback, pegasus );
  157. add_wait_queue( &pegasus->ctrl_wait, &wait );
  158. set_current_state( TASK_UNINTERRUPTIBLE );
  160. if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {
  161. err( __FUNCTION__ " BAD CTRLs %d", ret);
  162. goto out;
  163. }
  165. schedule();
  166. out:
  167. remove_wait_queue( &pegasus->ctrl_wait, &wait );
  168. memcpy(data,buffer,size);
  169. kfree(buffer);
  171. return ret;
  172. }
  175. static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
  176. {
  177. int ret;
  178. unsigned char *buffer;
  179. DECLARE_WAITQUEUE(wait, current);
  181. buffer = kmalloc(size, GFP_KERNEL);
  182. if (!buffer) {
  183. err("unable to allocate memory for configuration descriptors");
  184. return 0;
  185. }
  186. memcpy(buffer, data, size);
  188. add_wait_queue(&pegasus->ctrl_wait, &wait);
  189. set_current_state(TASK_UNINTERRUPTIBLE);
  190. while ( pegasus->flags & ETH_REGS_CHANGED )
  191. schedule();
  192. remove_wait_queue(&pegasus->ctrl_wait, &wait);
  193. set_current_state(TASK_RUNNING);
  195. pegasus->dr.requesttype = PEGASUS_REQT_WRITE;
  196. pegasus->dr.request = PEGASUS_REQ_SET_REGS;
  197. pegasus->dr.value = cpu_to_le16 (0);
  198. pegasus->dr.index = cpu_to_le16p( &indx );
  199. pegasus->dr.length = cpu_to_le16p( &size );
  200. pegasus->ctrl_urb.transfer_buffer_length = size;
  202. FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
  203.   usb_sndctrlpipe(pegasus->usb,0),
  204.   (char *)&pegasus->dr,
  205.   buffer, size, ctrl_callback, pegasus );
  206.   
  207. add_wait_queue( &pegasus->ctrl_wait, &wait );
  208. set_current_state( TASK_UNINTERRUPTIBLE );
  210. if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {
  211. err( __FUNCTION__ " BAD CTRL %d", ret);
  212. goto out;
  213. }
  215. schedule();
  216. out:
  217. remove_wait_queue( &pegasus->ctrl_wait, &wait );
  218. kfree(buffer);
  220. return ret;
  221. }
  224. static int set_register( pegasus_t *pegasus, __u16 indx, __u8 data )
  225. {
  226. int ret;
  227. unsigned char *buffer;
  228. __u16 dat = data;
  229. DECLARE_WAITQUEUE(wait, current);
  231. buffer = kmalloc(1, GFP_KERNEL);
  232. if (!buffer) {
  233. err("unable to allocate memory for configuration descriptors");
  234. return 0;
  235. }
  236. memcpy(buffer, &data, 1);
  238. add_wait_queue(&pegasus->ctrl_wait, &wait);
  239. set_current_state(TASK_UNINTERRUPTIBLE);
  240. while ( pegasus->flags & ETH_REGS_CHANGED )
  241. schedule();
  242. remove_wait_queue(&pegasus->ctrl_wait, &wait);
  243. set_current_state(TASK_RUNNING);
  245. pegasus->dr.requesttype = PEGASUS_REQT_WRITE;
  246. pegasus->dr.request = PEGASUS_REQ_SET_REG;
  247. pegasus->dr.value = cpu_to_le16p( &dat);
  248. pegasus->dr.index = cpu_to_le16p( &indx );
  249. pegasus->dr.length = cpu_to_le16( 1 );
  250. pegasus->ctrl_urb.transfer_buffer_length = 1;
  252. FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
  253.   usb_sndctrlpipe(pegasus->usb,0),
  254.   (char *)&pegasus->dr,
  255.   buffer, 1, ctrl_callback, pegasus );
  257. add_wait_queue( &pegasus->ctrl_wait, &wait );
  258. set_current_state( TASK_UNINTERRUPTIBLE );
  260. if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) ) {
  261. err( __FUNCTION__ " BAD CTRL %d", ret);
  262. goto out;
  263. }
  265. schedule();
  266. out:
  267. remove_wait_queue( &pegasus->ctrl_wait, &wait );
  268. kfree(buffer);
  270. return ret;
  271. }
  274. static int update_eth_regs_async( pegasus_t *pegasus )
  275. {
  276. int ret;
  278. pegasus->dr.requesttype = PEGASUS_REQT_WRITE;
  279. pegasus->dr.request = PEGASUS_REQ_SET_REGS;
  280. pegasus->dr.value = 0;
  281. pegasus->dr.index =  cpu_to_le16(EthCtrl0);
  282. pegasus->dr.length = cpu_to_le16(3);
  283. pegasus->ctrl_urb.transfer_buffer_length = 3;
  285. FILL_CONTROL_URB( &pegasus->ctrl_urb, pegasus->usb,
  286.   usb_sndctrlpipe(pegasus->usb,0),
  287.   (char *)&pegasus->dr,
  288.   pegasus->eth_regs, 3, ctrl_callback, pegasus );
  290. if ( (ret = usb_submit_urb( &pegasus->ctrl_urb )) )
  291. err( __FUNCTION__ " BAD CTRL %d, flags %x",ret,pegasus->flags );
  293. return ret;
  294. }
  297. static int read_mii_word( pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd )
  298. {
  299. int i;
  300. __u8 data[4] = { phy, 0, 0, indx };
  301. __u16  regdi;
  303. set_register( pegasus, PhyCtrl, 0 );
  304. set_registers( pegasus, PhyAddr, sizeof(data), data );
  305. set_register( pegasus, PhyCtrl, (indx | PHY_READ) );
  306. for (i = 0; i < REG_TIMEOUT; i++) {
  307. get_registers(pegasus, PhyCtrl, 1, data);
  308. if ( data[0] & PHY_DONE ) 
  309. break;
  310. }
  311. if ( i < REG_TIMEOUT ) {
  312. get_registers( pegasus, PhyData, 2, &regdi );
  313. *regd = le16_to_cpu(regdi);
  314. return 0;
  315. }
  316. warn( __FUNCTION__ " failed" );
  318. return 1;
  319. }
  322. static int write_mii_word( pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 regd )
  323. {
  324. int i;
  325. __u8 data[4] = { phy, 0, 0, indx };
  327. *(data + 1) = cpu_to_le16p( &regd );
  328. set_register( pegasus, PhyCtrl, 0 );
  329. set_registers( pegasus, PhyAddr, 4, data );
  330. set_register( pegasus, PhyCtrl, (indx | PHY_WRITE) );
  331. for (i = 0; i < REG_TIMEOUT; i++) {
  332. get_registers(pegasus, PhyCtrl, 1, data);
  333. if ( data[0] & PHY_DONE ) 
  334. break;
  335. }
  336. if ( i < REG_TIMEOUT )
  337. return 0;
  338. warn( __FUNCTION__ " failed" );
  340. return 1;
  341. }
  344. static int read_eprom_word( pegasus_t *pegasus, __u8 index, __u16 *retdata )
  345. {
  346. int i;
  347. __u8 tmp;
  348. __u16 retdatai;
  350. set_register( pegasus, EpromCtrl, 0 );
  351. set_register( pegasus, EpromOffset, index );
  352. set_register( pegasus, EpromCtrl, EPROM_READ); 
  354. for ( i=0; i < REG_TIMEOUT; i++ ) {
  355. get_registers( pegasus, EpromCtrl, 1, &tmp );
  356. if ( tmp & EPROM_DONE )
  357. break;
  358. }
  359. if ( i < REG_TIMEOUT ) {
  360. get_registers( pegasus, EpromData, 2, &retdatai );
  361. *retdata = le16_to_cpu (retdatai);
  362. return 0;
  363. }
  364. warn( __FUNCTION__ " failed" );
  366. return -1;
  367. }
  369. #ifdef PEGASUS_WRITE_EEPROM
  370. static inline void enable_eprom_write( pegasus_t *pegasus )
  371. {
  372. __u8 tmp;
  374. get_registers( pegasus, EthCtrl2, 1, &tmp );
  375. set_register( pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE );
  376. }
  379. static inline void disable_eprom_write( pegasus_t *pegasus )
  380. {
  381. __u8  tmp;
  383. get_registers( pegasus, EthCtrl2, 1, &tmp );
  384. set_register( pegasus, EpromCtrl, 0 );
  385. set_register( pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE );
  386. }
  389. static int write_eprom_word( pegasus_t *pegasus, __u8 index, __u16 data )
  390. {
  391. int i, tmp;
  392. __u8 d[4] = {0x3f, 0, 0, EPROM_WRITE};
  394. set_registers( pegasus, EpromOffset, 4, d );
  395. enable_eprom_write( pegasus );
  396. set_register( pegasus, EpromOffset, index );
  397. set_registers( pegasus, EpromData, 2, &data );
  398. set_register( pegasus, EpromCtrl, EPROM_WRITE );
  400. for ( i=0; i < REG_TIMEOUT; i++ ) {
  401. get_registers( pegasus, EpromCtrl, 1, &tmp );
  402. if ( tmp & EPROM_DONE )
  403. break;
  404. }
  405. disable_eprom_write( pegasus );
  406. if ( i < REG_TIMEOUT )
  407. return 0;
  408. warn( __FUNCTION__ " failed" );
  409. return -1;
  410. }
  411. #endif /* PEGASUS_WRITE_EEPROM */
  413. static inline void get_node_id( pegasus_t *pegasus, __u8 *id )
  414. {
  415. int i;
  416. __u16 w16;
  418. for (i = 0; i < 3; i++) {
  419. read_eprom_word( pegasus, i, &w16);
  420. ((__u16 *) id)[i] = cpu_to_le16p (&w16);
  421. }
  422. }
  425. static void set_ethernet_addr( pegasus_t *pegasus )
  426. {
  427. __u8 node_id[6];
  429. get_node_id(pegasus, node_id);
  430. set_registers( pegasus, EthID, sizeof(node_id), node_id );
  431. memcpy( pegasus->net->dev_addr, node_id, sizeof(node_id) );
  432. }
  435. static inline int reset_mac( pegasus_t *pegasus )
  436. {
  437. __u8 data = 0x8;
  438. int i;
  440. set_register(pegasus, EthCtrl1, data);
  441. for (i = 0; i < REG_TIMEOUT; i++) {
  442. get_registers(pegasus, EthCtrl1, 1, &data);
  443. if (~data & 0x08) {
  444. if (loopback & 1) 
  445. break;
  446. if ( mii_mode && (pegasus->features & HAS_HOME_PNA) )
  447. set_register( pegasus, Gpio1, 0x34 );
  448. else
  449. set_register( pegasus, Gpio1, 0x26 );
  450. set_register( pegasus, Gpio0, pegasus->features );
  451. set_register( pegasus, Gpio0, DEFAULT_GPIO_SET );
  452. break;
  453. }
  454. }
  455. if ( i == REG_TIMEOUT )
  456. return 1;
  458. if ( usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
  459.      usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK ) {
  460. __u16 auxmode;
  462. read_mii_word( pegasus, 0, 0x1b, &auxmode );
  463. write_mii_word( pegasus, 0, 0x1b, auxmode | 4 );
  464. }
  466. return 0;
  467. }
  470. static int enable_net_traffic( struct net_device *dev, struct usb_device *usb )
  471. {
  472. __u16 linkpart, bmsr;
  473. __u8 data[4];
  474. pegasus_t *pegasus = dev->priv;
  477. if ( read_mii_word(pegasus, pegasus->phy, MII_BMSR, &bmsr) ) 
  478. return 1;
  479. if ( !(bmsr & 0x20) && !loopback ) 
  480. warn( "%s: link NOT established (0x%x) - check the cable.",
  481. dev->name, bmsr );
  482. if ( read_mii_word(pegasus, pegasus->phy, MII_ANLPA, &linkpart) )
  483. return 2;
  484. if ( !(linkpart & 1) )
  485. warn( "link partner stat %x", linkpart );
  487. data[0] = 0xc9;
  488. data[1] = 0;
  489. if ( linkpart & (ANLPA_100TX_FD | ANLPA_10T_FD) )
  490. data[1] |= 0x20; /* set full duplex */
  491. if ( linkpart & (ANLPA_100TX_FD | ANLPA_100TX_HD) )
  492. data[1] |= 0x10; /* set 100 Mbps */
  493. if ( mii_mode )
  494. data[1] = 0;
  495. data[2] = (loopback & 1) ? 0x09 : 0x01;
  497. memcpy( pegasus->eth_regs, data, sizeof(data) );
  499. set_registers( pegasus, EthCtrl0, 3, data );
  501. return 0;
  502. }
  505. static void read_bulk_callback( struct urb *urb )
  506. {
  507. pegasus_t *pegasus = urb->context;
  508. struct net_device *net;
  509. int count = urb->actual_length, res;
  510. int rx_status;
  511. struct sk_buff *skb;
  512. __u16 pkt_len;
  514. if ( !pegasus || !(pegasus->flags & PEGASUS_RUNNING) )
  515. return;
  517. net = pegasus->net;
  518. if ( !netif_device_present(net) )
  519. return;
  521. if ( pegasus->flags & PEGASUS_RX_BUSY ) {
  522. pegasus->stats.rx_errors++;
  523. dbg("pegasus Rx busy");
  524. return;
  525. }
  526. pegasus->flags |= PEGASUS_RX_BUSY;
  528. switch ( urb->status ) {
  529. case USB_ST_NOERROR:
  530. break;
  531. case USB_ST_NORESPONSE:
  532. dbg( "reset MAC" );
  533. pegasus->flags &= ~PEGASUS_RX_BUSY;
  534. break;
  535. default:
  536. dbg( "%s: RX status %d", net->name, urb->status );
  537. goto goon;
  538. }
  540. if ( !count )
  541. goto goon;
  543. rx_status = le32_to_cpu(*(int *)(pegasus->rx_buff + count - 4));
  544. if ( rx_status & 0x000e0000 ) {
  545. dbg("%s: RX packet error %x", net->name, rx_status & 0xe0000);
  546. pegasus->stats.rx_errors++;
  547. if ( rx_status & 0x060000 )
  548. pegasus->stats.rx_length_errors++;
  549. if ( rx_status & 0x080000 )
  550. pegasus->stats.rx_crc_errors++;
  551. if ( rx_status & 0x100000 )
  552. pegasus->stats.rx_frame_errors++;
  553. goto goon;
  554. }
  556. pkt_len = (rx_status & 0xfff) - 8;
  558. if ( !(skb = dev_alloc_skb(pkt_len+2)) )
  559. goto goon;
  561. skb->dev = net;
  562. skb_reserve(skb, 2);
  563. eth_copy_and_sum(skb, pegasus->rx_buff, pkt_len, 0);
  564. skb_put(skb, pkt_len);
  566. skb->protocol = eth_type_trans(skb, net);
  567. netif_rx(skb);
  568. pegasus->stats.rx_packets++;
  569. pegasus->stats.rx_bytes += pkt_len;
  571. goon:
  572. FILL_BULK_URB( &pegasus->rx_urb, pegasus->usb,
  573. usb_rcvbulkpipe(pegasus->usb, 1),
  574. pegasus->rx_buff, PEGASUS_MAX_MTU, 
  575. read_bulk_callback, pegasus );
  576. if ( (res = usb_submit_urb(&pegasus->rx_urb)) )
  577. warn( __FUNCTION__ " failed submint rx_urb %d", res);
  578. pegasus->flags &= ~PEGASUS_RX_BUSY;
  579. }
  582. static void write_bulk_callback( struct urb *urb )
  583. {
  584. pegasus_t *pegasus = urb->context;
  586. if ( !pegasus || !(pegasus->flags & PEGASUS_RUNNING) )
  587. return;
  589. if ( !netif_device_present(pegasus->net) )
  590. return;
  592. if ( urb->status )
  593. info("%s: TX status %d", pegasus->net->name, urb->status);
  595. pegasus->net->trans_start = jiffies;
  596. netif_wake_queue( pegasus->net );
  597. }
  599. #ifdef PEGASUS_USE_INTR
  600. static void intr_callback( struct urb *urb )
  601. {
  602. pegasus_t *pegasus = urb->context;
  603. struct net_device *net;
  604. __u8 *d;
  606. if ( !pegasus )
  607. return;
  609. switch ( urb->status ) {
  610. case USB_ST_NOERROR:
  611. break;
  612. case USB_ST_URB_KILLED:
  613. return;
  614. default:
  615. info("intr status %d", urb->status);
  616. }
  618. d = urb->transfer_buffer;
  619. net = pegasus->net;
  620. if ( d[0] & 0xfc ) {
  621. pegasus->stats.tx_errors++;
  622. if ( d[0] & TX_UNDERRUN )
  623. pegasus->stats.tx_fifo_errors++;
  624. if ( d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT) )
  625. pegasus->stats.tx_aborted_errors++;
  626. if ( d[0] & LATE_COL )
  627. pegasus->stats.tx_window_errors++;
  628. if ( d[0] & (NO_CARRIER | LOSS_CARRIER) )
  629. pegasus->stats.tx_carrier_errors++;
  630. }
  631. }
  632. #endif
  634. static void pegasus_tx_timeout( struct net_device *net )
  635. {
  636. pegasus_t *pegasus = net->priv;
  638. if ( !pegasus )
  639. return;
  641. warn("%s: Tx timed out.", net->name);
  642. pegasus->tx_urb.transfer_flags |= USB_ASYNC_UNLINK;
  643. usb_unlink_urb( &pegasus->tx_urb );
  644. pegasus->stats.tx_errors++;
  645. }
  648. static int pegasus_start_xmit( struct sk_buff *skb, struct net_device *net )
  649. {
  650. pegasus_t *pegasus = net->priv;
  651. int  count = ((skb->len+2) & 0x3f) ? skb->len+2 : skb->len+3;
  652. int  res;
  653. __u16 l16 = skb->len;
  655. netif_stop_queue( net );
  657. ((__u16 *)pegasus->tx_buff)[0] = cpu_to_le16( l16 );
  658. memcpy(pegasus->tx_buff+2, skb->data, skb->len);
  659. FILL_BULK_URB( &pegasus->tx_urb, pegasus->usb,
  660. usb_sndbulkpipe(pegasus->usb, 2),
  661. pegasus->tx_buff, PEGASUS_MAX_MTU, 
  662. write_bulk_callback, pegasus );
  663. pegasus->tx_urb.transfer_buffer_length = count;
  664. if ((res = usb_submit_urb(&pegasus->tx_urb))) {
  665. warn("failed tx_urb %d", res);
  666. pegasus->stats.tx_errors++;
  667. netif_start_queue( net );
  668. } else {
  669. pegasus->stats.tx_packets++;
  670. pegasus->stats.tx_bytes += skb->len;
  671. net->trans_start = jiffies;
  672. }
  674. dev_kfree_skb(skb);
  676. return 0;
  677. }
  680. static struct net_device_stats *pegasus_netdev_stats( struct net_device *dev )
  681. {
  682. return &((pegasus_t *)dev->priv)->stats;
  683. }
  686. static inline void disable_net_traffic( pegasus_t *pegasus )
  687. {
  688. int  tmp=0;
  690. set_registers( pegasus, EthCtrl0, 2, &tmp );
  691. }
  694. static inline void get_interrupt_interval( pegasus_t *pegasus )
  695. {
  696. __u8 data[2];
  698. read_eprom_word( pegasus, 4, (__u16 *)data );
  699. if ( data[1] < 0x80 ) {
  700. info( "intr interval will be changed from %ums to %ums",
  701.      data[1], 0x80 );
  702. data[1] = 0x80;
  703. #ifdef PEGASUS_WRITE_EEPROM
  704. write_eprom_word( pegasus, 4, *(__u16 *)data );
  705. #endif
  706. }
  707. pegasus->intr_interval = data[1];
  708. }
  711. static int pegasus_open(struct net_device *net)
  712. {
  713. pegasus_t *pegasus = (pegasus_t *)net->priv;
  714. int res;
  716. if ( (res = enable_net_traffic(net, pegasus->usb)) ) {
  717. err("can't enable_net_traffic() - %d", res);
  718. return -EIO;
  719. }
  720. FILL_BULK_URB( &pegasus->rx_urb, pegasus->usb,
  721. usb_rcvbulkpipe(pegasus->usb, 1),
  722. pegasus->rx_buff, PEGASUS_MAX_MTU, 
  723. read_bulk_callback, pegasus );
  724. if ( (res = usb_submit_urb(&pegasus->rx_urb)) )
  725. warn( __FUNCTION__ " failed rx_urb %d", res );
  726. #ifdef PEGASUS_USE_INTR
  727. FILL_INT_URB( &pegasus->intr_urb, pegasus->usb,
  728. usb_rcvintpipe(pegasus->usb, 3),
  729. pegasus->intr_buff, sizeof(pegasus->intr_buff),
  730. intr_callback, pegasus, pegasus->intr_interval );
  731. if ( (res = usb_submit_urb(&pegasus->intr_urb)) )
  732. warn( __FUNCTION__ " failed intr_urb %d", res);
  733. #endif
  734. netif_start_queue( net );
  735. pegasus->flags |= PEGASUS_RUNNING;
  737. return 0;
  738. }
  741. static int pegasus_close( struct net_device *net )
  742. {
  743. pegasus_t *pegasus = net->priv;
  745. pegasus->flags &= ~PEGASUS_RUNNING;
  746. netif_stop_queue( net );
  747. if ( !(pegasus->flags & PEGASUS_UNPLUG) )
  748. disable_net_traffic( pegasus );
  750. usb_unlink_urb( &pegasus->rx_urb );
  751. usb_unlink_urb( &pegasus->tx_urb );
  752. usb_unlink_urb( &pegasus->ctrl_urb );
  753. #ifdef PEGASUS_USE_INTR
  754. usb_unlink_urb( &pegasus->intr_urb );
  755. #endif
  757. return 0;
  758. }
  761. static int pegasus_ioctl( struct net_device *net, struct ifreq *rq, int cmd )
  762. {
  763. __u16 *data = (__u16 *)&rq->ifr_data;
  764. pegasus_t *pegasus = net->priv;
  766. switch(cmd) {
  767. case SIOCDEVPRIVATE:
  768. data[0] = pegasus->phy;
  769. case SIOCDEVPRIVATE+1:
  770. read_mii_word(pegasus, data[0], data[1]&0x1f, &data[3]);
  771. return 0;
  772. case SIOCDEVPRIVATE+2:
  773. if ( !capable(CAP_NET_ADMIN) )
  774. return -EPERM;
  775. write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, data[2]);
  776. return 0;
  777. default:
  778. return -EOPNOTSUPP;
  779. }
  780. }
  783. static void pegasus_set_multicast( struct net_device *net )
  784. {
  785. pegasus_t *pegasus = net->priv;
  787. netif_stop_queue(net);
  789. if (net->flags & IFF_PROMISC) {
  790. pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
  791. info("%s: Promiscuous mode enabled", net->name);
  792. } else if ((net->mc_count > multicast_filter_limit) ||
  793. (net->flags & IFF_ALLMULTI)) {
  794. pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
  795. pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
  796. info("%s set allmulti", net->name);
  797. } else {
  798. pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
  799. pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
  800. }
  802. pegasus->flags |= ETH_REGS_CHANGE;
  803. ctrl_callback( &pegasus->ctrl_urb );
  805. netif_wake_queue(net);
  806. }
  809. static __u8 mii_phy_probe( pegasus_t *pegasus )
  810. {
  811. int i;
  812. __u16 tmp;
  814. for ( i=0; i < 32; i++ ) {
  815. read_mii_word( pegasus, i, MII_BMSR, &tmp );
  816. if ( tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0 )
  817. continue;
  818. else
  819. return i;
  820. }
  822. return 0xff;
  823. }
  826. static inline void setup_pegasus_II( pegasus_t *pegasus )
  827. {
  828. set_register( pegasus, Reg1d, 0 );
  829. set_register( pegasus, Reg7b, 2 );
  830. if ( pegasus->features & HAS_HOME_PNA  && mii_mode )
  831. set_register( pegasus, Reg81, 6 );
  832. else
  833. set_register( pegasus, Reg81, 2 );
  834. }
  837. static void * pegasus_probe( struct usb_device *dev, unsigned int ifnum,
  838.      const struct usb_device_id *id)
  839. {
  840. struct net_device *net;
  841. pegasus_t *pegasus;
  842. int dev_index = id - pegasus_ids;
  844. if (usb_set_configuration(dev, dev->config[0].bConfigurationValue)) {
  845. err("usb_set_configuration() failed");
  846. return NULL;
  847. }
  849. if(!(pegasus = kmalloc(sizeof(struct pegasus), GFP_KERNEL))) {
  850. err("out of memory allocating device structure");
  851. return NULL;
  852. }
  854. usb_inc_dev_use( dev );
  855. memset(pegasus, 0, sizeof(struct pegasus));
  856. pegasus->dev_index = dev_index;
  857. init_waitqueue_head( &pegasus->ctrl_wait );
  859. net = init_etherdev( NULL, 0 );
  860. if ( !net ) {
  861. kfree( pegasus );
  862. return NULL;
  863. }
  865. pegasus->usb = dev;
  866. pegasus->net = net;
  867. SET_MODULE_OWNER(net);
  868. net->priv = pegasus;
  869. net->open = pegasus_open;
  870. net->stop = pegasus_close;
  871. net->watchdog_timeo = PEGASUS_TX_TIMEOUT;
  872. net->tx_timeout = pegasus_tx_timeout;
  873. net->do_ioctl = pegasus_ioctl;
  874. net->hard_start_xmit = pegasus_start_xmit;
  875. net->set_multicast_list = pegasus_set_multicast;
  876. net->get_stats = pegasus_netdev_stats;
  877. net->mtu = PEGASUS_MTU;
  879. pegasus->features = usb_dev_id[dev_index].private;
  880. #ifdef PEGASUS_USE_INTR
  881. get_interrupt_interval( pegasus );
  882. #endif
  883. if ( reset_mac(pegasus) ) {
  884. err("can't reset MAC");
  885. unregister_netdev( pegasus->net );
  886. kfree(pegasus->net);
  887. kfree(pegasus);
  888. pegasus = NULL;
  889. return NULL;
  890. }
  892. info( "%s: %s", net->name, usb_dev_id[dev_index].name );
  894. set_ethernet_addr( pegasus );
  896. if ( pegasus->features & PEGASUS_II ) {
  897. info( "setup Pegasus II specific registers" );
  898. setup_pegasus_II( pegasus );
  899. }
  901. pegasus->phy = mii_phy_probe( pegasus );
  902. if ( pegasus->phy == 0xff ) {
  903. warn( "can't locate MII phy, using default" );
  904. pegasus->phy = 1;
  905. }
  907. return pegasus;
  908. }
  911. static void pegasus_disconnect( struct usb_device *dev, void *ptr )
  912. {
  913. struct pegasus *pegasus = ptr;
  915. if ( !pegasus ) {
  916. warn("unregistering non-existant device");
  917. return;
  918. }
  920. pegasus->flags |= PEGASUS_UNPLUG;
  921. unregister_netdev( pegasus->net );
  922. usb_dec_dev_use( dev );
  923. kfree( pegasus->net );
  924. kfree( pegasus );
  925. pegasus = NULL;
  926. }
  929. static struct usb_driver pegasus_driver = {
  930. name: "pegasus",
  931. probe: pegasus_probe,
  932. disconnect: pegasus_disconnect,
  933. id_table: pegasus_ids,
  934. };
  936. int __init pegasus_init(void)
  937. {
  938. info(DRIVER_VERSION ":" DRIVER_DESC);
  939. return usb_register( &pegasus_driver );
  940. }
  942. void __exit pegasus_exit(void)
  943. {
  944. usb_deregister( &pegasus_driver );
  945. }
  947. module_init( pegasus_init );
  948. module_exit( pegasus_exit );