projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ipv6: Kill ipv6 dependency of icmpv6_send().
[linux-2.6-block.git] / drivers / net / usb / pegasus.c
CommitLineData
1da177e4
LT		 1/*
2 * Copyright (c) 1999-2005 Petko Manolov (petkan@users.sourceforge.net)
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * ChangeLog:
9 * .... Most of the time spent on reading sources & docs.
10 * v0.2.x First official release for the Linux kernel.
11 * v0.3.0 Beutified and structured, some bugs fixed.
12 * v0.3.x URBifying bulk requests and bugfixing. First relatively
13 * stable release. Still can touch device's registers only
14 * from top-halves.
15 * v0.4.0 Control messages remained unurbified are now URBs.
16 * Now we can touch the HW at any time.
17 * v0.4.9 Control urbs again use process context to wait. Argh...
18 * Some long standing bugs (enable_net_traffic) fixed.
19 * Also nasty trick about resubmiting control urb from
20 * interrupt context used. Please let me know how it
21 * behaves. Pegasus II support added since this version.
22 * TODO: suppressing HCD warnings spewage on disconnect.
23 * v0.4.13 Ethernet address is now set at probe(), not at open()
5a9dbfe0 24 * time as this seems to break dhcpd.
1da177e4
LT		 25 * v0.5.0 branch to 2.5.x kernels
26 * v0.5.1 ethtool support added
27 * v0.5.5 rx socket buffers are in a pool and the their allocation
5a9dbfe0 28 * is out of the interrupt routine.
1da177e4
LT		 29 */
30
1da177e4
LT		 31#include <linux/sched.h>
32#include <linux/slab.h>
33#include <linux/init.h>
34#include <linux/delay.h>
35#include <linux/netdevice.h>
36#include <linux/etherdevice.h>
37#include <linux/ethtool.h>
38#include <linux/mii.h>
39#include <linux/usb.h>
40#include <linux/module.h>
41#include <asm/byteorder.h>
42#include <asm/uaccess.h>
43#include "pegasus.h"
44
45/*
46 * Version Information
47 */
37cf3477 48#define DRIVER_VERSION "v0.6.14 (2006/09/27)"
1da177e4
LT		 49#define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
50#define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"
51
52static const char driver_name[] = "pegasus";
53
54#undef PEGASUS_WRITE_EEPROM
55#define BMSR_MEDIA (BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | \
56 BMSR_100FULL | BMSR_ANEGCAPABLE)
57
eb939922
RR		 58static bool loopback;
59static bool mii_mode;
5a9dbfe0 60static char *devid;
1da177e4
LT		 61
62static struct usb_eth_dev usb_dev_id[] = {
63#define PEGASUS_DEV(pn, vid, pid, flags) \
64 {.name = pn, .vendor = vid, .device = pid, .private = flags},
ab854b24
CR		 65#define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
66 PEGASUS_DEV(pn, vid, pid, flags)
1da177e4
LT		 67#include "pegasus.h"
68#undef PEGASUS_DEV
ab854b24 69#undef PEGASUS_DEV_CLASS
a4f81a61 70 {NULL, 0, 0, 0},
1da177e4
LT		 71 {NULL, 0, 0, 0}
72};
73
74static struct usb_device_id pegasus_ids[] = {
75#define PEGASUS_DEV(pn, vid, pid, flags) \
76 {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid},
ab854b24
CR		 77/*
78 * The Belkin F8T012xx1 bluetooth adaptor has the same vendor and product
79 * IDs as the Belkin F5D5050, so we need to teach the pegasus driver to
80 * ignore adaptors belonging to the "Wireless" class 0xE0. For this one
81 * case anyway, seeing as the pegasus is for "Wired" adaptors.
82 */
83#define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
84 {.match_flags = (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_CLASS), \
85 .idVendor = vid, .idProduct = pid, .bDeviceClass = dclass},
1da177e4
LT		 86#include "pegasus.h"
87#undef PEGASUS_DEV
ab854b24 88#undef PEGASUS_DEV_CLASS
a4f81a61 89 {},
1da177e4
LT		 90 {}
91};
92
93MODULE_AUTHOR(DRIVER_AUTHOR);
94MODULE_DESCRIPTION(DRIVER_DESC);
95MODULE_LICENSE("GPL");
96module_param(loopback, bool, 0);
97module_param(mii_mode, bool, 0);
a4f81a61 98module_param(devid, charp, 0);
1da177e4
LT		 99MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");
100MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");
a4f81a61 101MODULE_PARM_DESC(devid, "The format is: 'DEV_name:VendorID:DeviceID:Flags'");
1da177e4
LT		 102
103/* use ethtool to change the level for any given device */
104static int msg_level = -1;
5a9dbfe0
NK		 105module_param(msg_level, int, 0);
106MODULE_PARM_DESC(msg_level, "Override default message level");
1da177e4
LT		 107
108MODULE_DEVICE_TABLE(usb, pegasus_ids);
8cb89571 109static const struct net_device_ops pegasus_netdev_ops;
1da177e4
LT		 110
111static int update_eth_regs_async(pegasus_t *);
112/* Aargh!!! I _really_ hate such tweaks */
7d12e780 113static void ctrl_callback(struct urb *urb)
1da177e4
LT		 114{
115 pegasus_t *pegasus = urb->context;
c94cb314 116 int status = urb->status;
1da177e4
LT		 117
118 if (!pegasus)
119 return;
120
c94cb314 121 switch (status) {
1da177e4
LT		 122 case 0:
123 if (pegasus->flags & ETH_REGS_CHANGE) {
124 pegasus->flags &= ~ETH_REGS_CHANGE;
125 pegasus->flags |= ETH_REGS_CHANGED;
126 update_eth_regs_async(pegasus);
127 return;
128 }
129 break;
130 case -EINPROGRESS:
131 return;
132 case -ENOENT:
133 break;
134 default:
a475f603
JP		 135 if (net_ratelimit())
136 netif_dbg(pegasus, drv, pegasus->net,
137 "%s, status %d\n", __func__, status);
138 break;
1da177e4
LT		 139 }
140 pegasus->flags &= ~ETH_REGS_CHANGED;
141 wake_up(&pegasus->ctrl_wait);
142}
143
5a9dbfe0 144static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size,
1da177e4
LT		 145 void *data)
146{
147 int ret;
148 char *buffer;
149 DECLARE_WAITQUEUE(wait, current);
150
151 buffer = kmalloc(size, GFP_KERNEL);
14f8dc49 152 if (!buffer)
1da177e4 153 return -ENOMEM;
14f8dc49 154
1da177e4
LT		 155 add_wait_queue(&pegasus->ctrl_wait, &wait);
156 set_current_state(TASK_UNINTERRUPTIBLE);
157 while (pegasus->flags & ETH_REGS_CHANGED)
158 schedule();
159 remove_wait_queue(&pegasus->ctrl_wait, &wait);
160 set_current_state(TASK_RUNNING);
161
162 pegasus->dr.bRequestType = PEGASUS_REQT_READ;
163 pegasus->dr.bRequest = PEGASUS_REQ_GET_REGS;
164 pegasus->dr.wValue = cpu_to_le16(0);
da2bbdcc
HH		 165 pegasus->dr.wIndex = cpu_to_le16(indx);
166 pegasus->dr.wLength = cpu_to_le16(size);
1da177e4
LT		 167 pegasus->ctrl_urb->transfer_buffer_length = size;
168
169 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
170 usb_rcvctrlpipe(pegasus->usb, 0),
171 (char *) &pegasus->dr,
172 buffer, size, ctrl_callback, pegasus);
173
174 add_wait_queue(&pegasus->ctrl_wait, &wait);
175 set_current_state(TASK_UNINTERRUPTIBLE);
176
177 /* using ATOMIC, we'd never wake up if we slept */
178 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
10c8211c 179 set_current_state(TASK_RUNNING);
955a2608
DB		 180 if (ret == -ENODEV)
181 netif_device_detach(pegasus->net);
a475f603
JP		 182 if (net_ratelimit())
183 netif_err(pegasus, drv, pegasus->net,
184 "%s, status %d\n", __func__, ret);
1da177e4
LT		 185 goto out;
186 }
187
188 schedule();
189out:
190 remove_wait_queue(&pegasus->ctrl_wait, &wait);
191 memcpy(data, buffer, size);
192 kfree(buffer);
193
194 return ret;
195}
196
5a9dbfe0 197static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size,
1da177e4
LT		 198 void *data)
199{
200 int ret;
201 char *buffer;
202 DECLARE_WAITQUEUE(wait, current);
203
175c0441 204 buffer = kmemdup(data, size, GFP_KERNEL);
1da177e4 205 if (!buffer) {
a475f603
JP		 206 netif_warn(pegasus, drv, pegasus->net,
207 "out of memory in %s\n", __func__);
1da177e4
LT		 208 return -ENOMEM;
209 }
1da177e4
LT		 210
211 add_wait_queue(&pegasus->ctrl_wait, &wait);
212 set_current_state(TASK_UNINTERRUPTIBLE);
213 while (pegasus->flags & ETH_REGS_CHANGED)
214 schedule();
215 remove_wait_queue(&pegasus->ctrl_wait, &wait);
216 set_current_state(TASK_RUNNING);
217
218 pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
219 pegasus->dr.bRequest = PEGASUS_REQ_SET_REGS;
220 pegasus->dr.wValue = cpu_to_le16(0);
da2bbdcc
HH		 221 pegasus->dr.wIndex = cpu_to_le16(indx);
222 pegasus->dr.wLength = cpu_to_le16(size);
1da177e4
LT		 223 pegasus->ctrl_urb->transfer_buffer_length = size;
224
225 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
226 usb_sndctrlpipe(pegasus->usb, 0),
227 (char *) &pegasus->dr,
228 buffer, size, ctrl_callback, pegasus);
229
230 add_wait_queue(&pegasus->ctrl_wait, &wait);
231 set_current_state(TASK_UNINTERRUPTIBLE);
232
233 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
955a2608
DB		 234 if (ret == -ENODEV)
235 netif_device_detach(pegasus->net);
a475f603
JP		 236 netif_err(pegasus, drv, pegasus->net,
237 "%s, status %d\n", __func__, ret);
1da177e4
LT		 238 goto out;
239 }
240
241 schedule();
242out:
243 remove_wait_queue(&pegasus->ctrl_wait, &wait);
244 kfree(buffer);
245
246 return ret;
247}
248
5a9dbfe0 249static int set_register(pegasus_t *pegasus, __u16 indx, __u8 data)
1da177e4
LT		 250{
251 int ret;
252 char *tmp;
253 DECLARE_WAITQUEUE(wait, current);
254
175c0441 255 tmp = kmemdup(&data, 1, GFP_KERNEL);
1da177e4 256 if (!tmp) {
a475f603
JP		 257 netif_warn(pegasus, drv, pegasus->net,
258 "out of memory in %s\n", __func__);
1da177e4
LT		 259 return -ENOMEM;
260 }
1da177e4
LT		 261 add_wait_queue(&pegasus->ctrl_wait, &wait);
262 set_current_state(TASK_UNINTERRUPTIBLE);
263 while (pegasus->flags & ETH_REGS_CHANGED)
264 schedule();
265 remove_wait_queue(&pegasus->ctrl_wait, &wait);
266 set_current_state(TASK_RUNNING);
267
268 pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
269 pegasus->dr.bRequest = PEGASUS_REQ_SET_REG;
270 pegasus->dr.wValue = cpu_to_le16(data);
da2bbdcc 271 pegasus->dr.wIndex = cpu_to_le16(indx);
1da177e4
LT		 272 pegasus->dr.wLength = cpu_to_le16(1);
273 pegasus->ctrl_urb->transfer_buffer_length = 1;
274
275 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
276 usb_sndctrlpipe(pegasus->usb, 0),
277 (char *) &pegasus->dr,
016534cf 278 tmp, 1, ctrl_callback, pegasus);
1da177e4
LT		 279
280 add_wait_queue(&pegasus->ctrl_wait, &wait);
281 set_current_state(TASK_UNINTERRUPTIBLE);
282
283 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
955a2608
DB		 284 if (ret == -ENODEV)
285 netif_device_detach(pegasus->net);
a475f603
JP		 286 if (net_ratelimit())
287 netif_err(pegasus, drv, pegasus->net,
288 "%s, status %d\n", __func__, ret);
1da177e4
LT		 289 goto out;
290 }
291
292 schedule();
293out:
294 remove_wait_queue(&pegasus->ctrl_wait, &wait);
295 kfree(tmp);
296
297 return ret;
298}
299
5a9dbfe0 300static int update_eth_regs_async(pegasus_t *pegasus)
1da177e4
LT		 301{
302 int ret;
303
304 pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
305 pegasus->dr.bRequest = PEGASUS_REQ_SET_REGS;
e3453f63 306 pegasus->dr.wValue = cpu_to_le16(0);
1da177e4
LT		 307 pegasus->dr.wIndex = cpu_to_le16(EthCtrl0);
308 pegasus->dr.wLength = cpu_to_le16(3);
309 pegasus->ctrl_urb->transfer_buffer_length = 3;
310
311 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
312 usb_sndctrlpipe(pegasus->usb, 0),
313 (char *) &pegasus->dr,
314 pegasus->eth_regs, 3, ctrl_callback, pegasus);
315
955a2608
DB		 316 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
317 if (ret == -ENODEV)
318 netif_device_detach(pegasus->net);
a475f603
JP		 319 netif_err(pegasus, drv, pegasus->net,
320 "%s, status %d\n", __func__, ret);
955a2608 321 }
1da177e4
LT		 322
323 return ret;
324}
325
c43c49bd 326/* Returns 0 on success, error on failure */
5a9dbfe0 327static int read_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd)
1da177e4
LT		 328{
329 int i;
330 __u8 data[4] = { phy, 0, 0, indx };
331 __le16 regdi;
332 int ret;
333
4a1728a2 334 set_register(pegasus, PhyCtrl, 0);
5a9dbfe0 335 set_registers(pegasus, PhyAddr, sizeof(data), data);
4a1728a2 336 set_register(pegasus, PhyCtrl, (indx | PHY_READ));
1da177e4
LT		 337 for (i = 0; i < REG_TIMEOUT; i++) {
338 ret = get_registers(pegasus, PhyCtrl, 1, data);
7e713b82
DB		 339 if (ret == -ESHUTDOWN)
340 goto fail;
1da177e4
LT		 341 if (data[0] & PHY_DONE)
342 break;
343 }
a475f603
JP		 344
345 if (i >= REG_TIMEOUT)
346 goto fail;
347
348 ret = get_registers(pegasus, PhyData, 2, &regdi);
349 *regd = le16_to_cpu(regdi);
350 return ret;
351
7e713b82 352fail:
a475f603 353 netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
1da177e4 354
4a1728a2 355 return ret;
1da177e4
LT		 356}
357
358static int mdio_read(struct net_device *dev, int phy_id, int loc)
359{
8739cfef 360 pegasus_t *pegasus = netdev_priv(dev);
1da177e4
LT		 361 u16 res;
362
363 read_mii_word(pegasus, phy_id, loc, &res);
364 return (int)res;
365}
366
5a9dbfe0 367static int write_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 regd)
1da177e4
LT		 368{
369 int i;
370 __u8 data[4] = { phy, 0, 0, indx };
371 int ret;
372
373 data[1] = (u8) regd;
374 data[2] = (u8) (regd >> 8);
4a1728a2
PM		 375 set_register(pegasus, PhyCtrl, 0);
376 set_registers(pegasus, PhyAddr, sizeof(data), data);
377 set_register(pegasus, PhyCtrl, (indx | PHY_WRITE));
1da177e4
LT		 378 for (i = 0; i < REG_TIMEOUT; i++) {
379 ret = get_registers(pegasus, PhyCtrl, 1, data);
7e713b82
DB		 380 if (ret == -ESHUTDOWN)
381 goto fail;
1da177e4
LT		 382 if (data[0] & PHY_DONE)
383 break;
384 }
a475f603
JP		 385
386 if (i >= REG_TIMEOUT)
387 goto fail;
388
389 return ret;
1da177e4 390
7e713b82 391fail:
a475f603 392 netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
4a1728a2 393 return -ETIMEDOUT;
1da177e4
LT		 394}
395
396static void mdio_write(struct net_device *dev, int phy_id, int loc, int val)
397{
8739cfef 398 pegasus_t *pegasus = netdev_priv(dev);
1da177e4
LT		 399
400 write_mii_word(pegasus, phy_id, loc, val);
401}
402
5a9dbfe0 403static int read_eprom_word(pegasus_t *pegasus, __u8 index, __u16 *retdata)
1da177e4
LT		 404{
405 int i;
406 __u8 tmp;
407 __le16 retdatai;
408 int ret;
409
4a1728a2
PM		 410 set_register(pegasus, EpromCtrl, 0);
411 set_register(pegasus, EpromOffset, index);
412 set_register(pegasus, EpromCtrl, EPROM_READ);
1da177e4
LT		 413
414 for (i = 0; i < REG_TIMEOUT; i++) {
415 ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
416 if (tmp & EPROM_DONE)
417 break;
7e713b82
DB		 418 if (ret == -ESHUTDOWN)
419 goto fail;
1da177e4 420 }
a475f603
JP		 421 if (i >= REG_TIMEOUT)
422 goto fail;
423
424 ret = get_registers(pegasus, EpromData, 2, &retdatai);
425 *retdata = le16_to_cpu(retdatai);
426 return ret;
1da177e4 427
7e713b82 428fail:
a475f603 429 netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
4a1728a2 430 return -ETIMEDOUT;
1da177e4
LT		 431}
432
433#ifdef PEGASUS_WRITE_EEPROM
5a9dbfe0 434static inline void enable_eprom_write(pegasus_t *pegasus)
1da177e4
LT		 435{
436 __u8 tmp;
437 int ret;
438
4a1728a2
PM		 439 get_registers(pegasus, EthCtrl2, 1, &tmp);
440 set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE);
1da177e4
LT		 441}
442
5a9dbfe0 443static inline void disable_eprom_write(pegasus_t *pegasus)
1da177e4
LT		 444{
445 __u8 tmp;
446 int ret;
447
4a1728a2
PM		 448 get_registers(pegasus, EthCtrl2, 1, &tmp);
449 set_register(pegasus, EpromCtrl, 0);
450 set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE);
1da177e4
LT		 451}
452
5a9dbfe0 453static int write_eprom_word(pegasus_t *pegasus, __u8 index, __u16 data)
1da177e4
LT		 454{
455 int i;
456 __u8 tmp, d[4] = { 0x3f, 0, 0, EPROM_WRITE };
457 int ret;
e3453f63 458 __le16 le_data = cpu_to_le16(data);
1da177e4 459
4a1728a2 460 set_registers(pegasus, EpromOffset, 4, d);
1da177e4 461 enable_eprom_write(pegasus);
4a1728a2 462 set_register(pegasus, EpromOffset, index);
e3453f63 463 set_registers(pegasus, EpromData, 2, &le_data);
4a1728a2 464 set_register(pegasus, EpromCtrl, EPROM_WRITE);
1da177e4
LT		 465
466 for (i = 0; i < REG_TIMEOUT; i++) {
467 ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
7e713b82
DB		 468 if (ret == -ESHUTDOWN)
469 goto fail;
1da177e4
LT		 470 if (tmp & EPROM_DONE)
471 break;
472 }
473 disable_eprom_write(pegasus);
a475f603
JP		 474 if (i >= REG_TIMEOUT)
475 goto fail;
476
477 return ret;
478
7e713b82 479fail:
a475f603 480 netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
4a1728a2 481 return -ETIMEDOUT;
1da177e4
LT		 482}
483#endif /* PEGASUS_WRITE_EEPROM */
484
5a9dbfe0 485static inline void get_node_id(pegasus_t *pegasus, __u8 *id)
1da177e4
LT		 486{
487 int i;
488 __u16 w16;
489
490 for (i = 0; i < 3; i++) {
491 read_eprom_word(pegasus, i, &w16);
da2bbdcc 492 ((__le16 *) id)[i] = cpu_to_le16(w16);
1da177e4
LT		 493 }
494}
495
5a9dbfe0 496static void set_ethernet_addr(pegasus_t *pegasus)
1da177e4
LT		 497{
498 __u8 node_id[6];
1da177e4 499
37cf3477
PM		 500 if (pegasus->features & PEGASUS_II) {
501 get_registers(pegasus, 0x10, sizeof(node_id), node_id);
502 } else {
503 get_node_id(pegasus, node_id);
5a9dbfe0 504 set_registers(pegasus, EthID, sizeof(node_id), node_id);
37cf3477 505 }
5a9dbfe0 506 memcpy(pegasus->net->dev_addr, node_id, sizeof(node_id));
1da177e4
LT		 507}
508
5a9dbfe0 509static inline int reset_mac(pegasus_t *pegasus)
1da177e4
LT		 510{
511 __u8 data = 0x8;
512 int i;
1da177e4 513
4a1728a2 514 set_register(pegasus, EthCtrl1, data);
1da177e4 515 for (i = 0; i < REG_TIMEOUT; i++) {
4a1728a2 516 get_registers(pegasus, EthCtrl1, 1, &data);
1da177e4 517 if (~data & 0x08) {
681f1623 518 if (loopback)
1da177e4
LT		 519 break;
520 if (mii_mode && (pegasus->features & HAS_HOME_PNA))
4a1728a2 521 set_register(pegasus, Gpio1, 0x34);
1da177e4 522 else
4a1728a2
PM		 523 set_register(pegasus, Gpio1, 0x26);
524 set_register(pegasus, Gpio0, pegasus->features);
525 set_register(pegasus, Gpio0, DEFAULT_GPIO_SET);
1da177e4
LT		 526 break;
527 }
528 }
529 if (i == REG_TIMEOUT)
4a1728a2 530 return -ETIMEDOUT;
1da177e4
LT		 531
532 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
533 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
4a1728a2
PM		 534 set_register(pegasus, Gpio0, 0x24);
535 set_register(pegasus, Gpio0, 0x26);
1da177e4
LT		 536 }
537 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) {
538 __u16 auxmode;
539 read_mii_word(pegasus, 3, 0x1b, &auxmode);
540 write_mii_word(pegasus, 3, 0x1b, auxmode | 4);
541 }
542
543 return 0;
544}
545
546static int enable_net_traffic(struct net_device *dev, struct usb_device *usb)
547{
548 __u16 linkpart;
549 __u8 data[4];
550 pegasus_t *pegasus = netdev_priv(dev);
551 int ret;
552
553 read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
554 data[0] = 0xc9;
555 data[1] = 0;
556 if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL))
557 data[1] |= 0x20; /* set full duplex */
558 if (linkpart & (ADVERTISE_100FULL | ADVERTISE_100HALF))
559 data[1] |= 0x10; /* set 100 Mbps */
560 if (mii_mode)
561 data[1] = 0;
681f1623 562 data[2] = loopback ? 0x09 : 0x01;
1da177e4 563
5a9dbfe0 564 memcpy(pegasus->eth_regs, data, sizeof(data));
1da177e4
LT		 565 ret = set_registers(pegasus, EthCtrl0, 3, data);
566
567 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
efafe6fb 568 usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS2 ||
1da177e4
LT		 569 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
570 u16 auxmode;
571 read_mii_word(pegasus, 0, 0x1b, &auxmode);
572 write_mii_word(pegasus, 0, 0x1b, auxmode | 4);
573 }
574
4a1728a2 575 return ret;
1da177e4
LT		 576}
577
5a9dbfe0 578static void fill_skb_pool(pegasus_t *pegasus)
1da177e4
LT		 579{
580 int i;
581
582 for (i = 0; i < RX_SKBS; i++) {
583 if (pegasus->rx_pool[i])
584 continue;
585 pegasus->rx_pool[i] = dev_alloc_skb(PEGASUS_MTU + 2);
586 /*
587 ** we give up if the allocation fail. the tasklet will be
588 ** rescheduled again anyway...
589 */
590 if (pegasus->rx_pool[i] == NULL)
591 return;
1da177e4
LT		 592 skb_reserve(pegasus->rx_pool[i], 2);
593 }
594}
595
5a9dbfe0 596static void free_skb_pool(pegasus_t *pegasus)
1da177e4
LT		 597{
598 int i;
599
600 for (i = 0; i < RX_SKBS; i++) {
601 if (pegasus->rx_pool[i]) {
602 dev_kfree_skb(pegasus->rx_pool[i]);
603 pegasus->rx_pool[i] = NULL;
604 }
605 }
606}
607
608static inline struct sk_buff *pull_skb(pegasus_t * pegasus)
609{
610 int i;
611 struct sk_buff *skb;
612
613 for (i = 0; i < RX_SKBS; i++) {
614 if (likely(pegasus->rx_pool[i] != NULL)) {
615 skb = pegasus->rx_pool[i];
616 pegasus->rx_pool[i] = NULL;
617 return skb;
618 }
619 }
620 return NULL;
621}
622
7d12e780 623static void read_bulk_callback(struct urb *urb)
1da177e4
LT		 624{
625 pegasus_t *pegasus = urb->context;
626 struct net_device *net;
627 int rx_status, count = urb->actual_length;
c94cb314 628 int status = urb->status;
1da177e4
LT		 629 u8 *buf = urb->transfer_buffer;
630 __u16 pkt_len;
631
632 if (!pegasus)
633 return;
634
635 net = pegasus->net;
636 if (!netif_device_present(net) || !netif_running(net))
637 return;
638
c94cb314 639 switch (status) {
1da177e4
LT		 640 case 0:
641 break;
38e2bfc9 642 case -ETIME:
a475f603 643 netif_dbg(pegasus, rx_err, net, "reset MAC\n");
1da177e4
LT		 644 pegasus->flags &= ~PEGASUS_RX_BUSY;
645 break;
646 case -EPIPE: /* stall, or disconnect from TT */
647 /* FIXME schedule work to clear the halt */
a475f603 648 netif_warn(pegasus, rx_err, net, "no rx stall recovery\n");
1da177e4
LT		 649 return;
650 case -ENOENT:
651 case -ECONNRESET:
652 case -ESHUTDOWN:
a475f603 653 netif_dbg(pegasus, ifdown, net, "rx unlink, %d\n", status);
1da177e4
LT		 654 return;
655 default:
a475f603 656 netif_dbg(pegasus, rx_err, net, "RX status %d\n", status);
1da177e4
LT		 657 goto goon;
658 }
659
660 if (!count || count < 4)
661 goto goon;
662
663 rx_status = buf[count - 2];
664 if (rx_status & 0x1e) {
a475f603
JP		 665 netif_dbg(pegasus, rx_err, net,
666 "RX packet error %x\n", rx_status);
1da177e4 667 pegasus->stats.rx_errors++;
5a9dbfe0 668 if (rx_status & 0x06) /* long or runt */
1da177e4
LT		 669 pegasus->stats.rx_length_errors++;
670 if (rx_status & 0x08)
671 pegasus->stats.rx_crc_errors++;
5a9dbfe0 672 if (rx_status & 0x10) /* extra bits */
1da177e4
LT		 673 pegasus->stats.rx_frame_errors++;
674 goto goon;
675 }
676 if (pegasus->chip == 0x8513) {
677 pkt_len = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
678 pkt_len &= 0x0fff;
679 pegasus->rx_skb->data += 2;
680 } else {
681 pkt_len = buf[count - 3] << 8;
682 pkt_len += buf[count - 4];
683 pkt_len &= 0xfff;
684 pkt_len -= 8;
685 }
686
a85a46f2
KV		 687 /*
688 * If the packet is unreasonably long, quietly drop it rather than
689 * kernel panicing by calling skb_put.
690 */
691 if (pkt_len > PEGASUS_MTU)
692 goto goon;
693
1da177e4
LT		 694 /*
695 * at this point we are sure pegasus->rx_skb != NULL
696 * so we go ahead and pass up the packet.
697 */
698 skb_put(pegasus->rx_skb, pkt_len);
699 pegasus->rx_skb->protocol = eth_type_trans(pegasus->rx_skb, net);
700 netif_rx(pegasus->rx_skb);
701 pegasus->stats.rx_packets++;
702 pegasus->stats.rx_bytes += pkt_len;
703
704 if (pegasus->flags & PEGASUS_UNPLUG)
705 return;
706
707 spin_lock(&pegasus->rx_pool_lock);
708 pegasus->rx_skb = pull_skb(pegasus);
709 spin_unlock(&pegasus->rx_pool_lock);
710
711 if (pegasus->rx_skb == NULL)
712 goto tl_sched;
713goon:
714 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
715 usb_rcvbulkpipe(pegasus->usb, 1),
716 pegasus->rx_skb->data, PEGASUS_MTU + 8,
717 read_bulk_callback, pegasus);
955a2608
DB		 718 rx_status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
719 if (rx_status == -ENODEV)
720 netif_device_detach(pegasus->net);
721 else if (rx_status) {
1da177e4
LT		 722 pegasus->flags |= PEGASUS_RX_URB_FAIL;
723 goto tl_sched;
724 } else {
725 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
726 }
727
728 return;
729
730tl_sched:
731 tasklet_schedule(&pegasus->rx_tl);
732}
733
734static void rx_fixup(unsigned long data)
735{
736 pegasus_t *pegasus;
737 unsigned long flags;
955a2608 738 int status;
1da177e4
LT		 739
740 pegasus = (pegasus_t *) data;
741 if (pegasus->flags & PEGASUS_UNPLUG)
742 return;
743
744 spin_lock_irqsave(&pegasus->rx_pool_lock, flags);
745 fill_skb_pool(pegasus);
746 if (pegasus->flags & PEGASUS_RX_URB_FAIL)
747 if (pegasus->rx_skb)
748 goto try_again;
5a9dbfe0 749 if (pegasus->rx_skb == NULL)
1da177e4 750 pegasus->rx_skb = pull_skb(pegasus);
1da177e4 751 if (pegasus->rx_skb == NULL) {
a475f603 752 netif_warn(pegasus, rx_err, pegasus->net, "low on memory\n");
1da177e4
LT		 753 tasklet_schedule(&pegasus->rx_tl);
754 goto done;
755 }
756 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
757 usb_rcvbulkpipe(pegasus->usb, 1),
758 pegasus->rx_skb->data, PEGASUS_MTU + 8,
759 read_bulk_callback, pegasus);
760try_again:
955a2608
DB		 761 status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
762 if (status == -ENODEV)
763 netif_device_detach(pegasus->net);
764 else if (status) {
1da177e4
LT		 765 pegasus->flags |= PEGASUS_RX_URB_FAIL;
766 tasklet_schedule(&pegasus->rx_tl);
767 } else {
768 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
769 }
770done:
771 spin_unlock_irqrestore(&pegasus->rx_pool_lock, flags);
772}
773
7d12e780 774static void write_bulk_callback(struct urb *urb)
1da177e4
LT		 775{
776 pegasus_t *pegasus = urb->context;
9351982b 777 struct net_device *net;
c94cb314 778 int status = urb->status;
1da177e4
LT		 779
780 if (!pegasus)
781 return;
782
9351982b
MG		 783 net = pegasus->net;
784
1da177e4
LT		 785 if (!netif_device_present(net) || !netif_running(net))
786 return;
787
c94cb314 788 switch (status) {
1da177e4
LT		 789 case -EPIPE:
790 /* FIXME schedule_work() to clear the tx halt */
791 netif_stop_queue(net);
a475f603 792 netif_warn(pegasus, tx_err, net, "no tx stall recovery\n");
1da177e4
LT		 793 return;
794 case -ENOENT:
795 case -ECONNRESET:
796 case -ESHUTDOWN:
a475f603 797 netif_dbg(pegasus, ifdown, net, "tx unlink, %d\n", status);
1da177e4
LT		 798 return;
799 default:
a475f603 800 netif_info(pegasus, tx_err, net, "TX status %d\n", status);
1da177e4
LT		 801 /* FALL THROUGH */
802 case 0:
803 break;
804 }
805
1ae5dc34 806 net->trans_start = jiffies; /* prevent tx timeout */
1da177e4
LT		 807 netif_wake_queue(net);
808}
809
7d12e780 810static void intr_callback(struct urb *urb)
1da177e4
LT		 811{
812 pegasus_t *pegasus = urb->context;
813 struct net_device *net;
c94cb314 814 int res, status = urb->status;
1da177e4
LT		 815
816 if (!pegasus)
817 return;
818 net = pegasus->net;
819
c94cb314 820 switch (status) {
1da177e4
LT		 821 case 0:
822 break;
823 case -ECONNRESET: /* unlink */
824 case -ENOENT:
825 case -ESHUTDOWN:
826 return;
827 default:
828 /* some Pegasus-I products report LOTS of data
829 * toggle errors... avoid log spamming
830 */
a475f603 831 netif_dbg(pegasus, timer, net, "intr status %d\n", status);
1da177e4
LT		 832 }
833
834 if (urb->actual_length >= 6) {
5a9dbfe0 835 u8 *d = urb->transfer_buffer;
1da177e4
LT		 836
837 /* byte 0 == tx_status1, reg 2B */
838 if (d[0] & (TX_UNDERRUN|EXCESSIVE_COL
839 |LATE_COL|JABBER_TIMEOUT)) {
840 pegasus->stats.tx_errors++;
841 if (d[0] & TX_UNDERRUN)
842 pegasus->stats.tx_fifo_errors++;
843 if (d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT))
844 pegasus->stats.tx_aborted_errors++;
845 if (d[0] & LATE_COL)
846 pegasus->stats.tx_window_errors++;
847 }
848
849 /* d[5].LINK_STATUS lies on some adapters.
850 * d[0].NO_CARRIER kicks in only with failed TX.
851 * ... so monitoring with MII may be safest.
852 */
1da177e4
LT		 853
854 /* bytes 3-4 == rx_lostpkt, reg 2E/2F */
855 pegasus->stats.rx_missed_errors += ((d[3] & 0x7f) << 8) | d[4];
856 }
857
c94cb314
ON		 858 res = usb_submit_urb(urb, GFP_ATOMIC);
859 if (res == -ENODEV)
955a2608 860 netif_device_detach(pegasus->net);
a475f603
JP		 861 if (res)
862 netif_err(pegasus, timer, net,
863 "can't resubmit interrupt urb, %d\n", res);
1da177e4
LT		 864}
865
866static void pegasus_tx_timeout(struct net_device *net)
867{
868 pegasus_t *pegasus = netdev_priv(net);
a475f603 869 netif_warn(pegasus, timer, net, "tx timeout\n");
1da177e4
LT		 870 usb_unlink_urb(pegasus->tx_urb);
871 pegasus->stats.tx_errors++;
872}
873
25a79c41
SH		 874static netdev_tx_t pegasus_start_xmit(struct sk_buff *skb,
875 struct net_device *net)
1da177e4
LT		 876{
877 pegasus_t *pegasus = netdev_priv(net);
878 int count = ((skb->len + 2) & 0x3f) ? skb->len + 2 : skb->len + 3;
879 int res;
880 __u16 l16 = skb->len;
881
882 netif_stop_queue(net);
883
884 ((__le16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16);
d626f62b 885 skb_copy_from_linear_data(skb, pegasus->tx_buff + 2, skb->len);
1da177e4
LT		 886 usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb,
887 usb_sndbulkpipe(pegasus->usb, 2),
888 pegasus->tx_buff, count,
889 write_bulk_callback, pegasus);
890 if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) {
a475f603 891 netif_warn(pegasus, tx_err, net, "fail tx, %d\n", res);
1da177e4
LT		 892 switch (res) {
893 case -EPIPE: /* stall, or disconnect from TT */
894 /* cleanup should already have been scheduled */
895 break;
896 case -ENODEV: /* disconnect() upcoming */
9dd014eb 897 case -EPERM:
955a2608 898 netif_device_detach(pegasus->net);
1da177e4
LT		 899 break;
900 default:
901 pegasus->stats.tx_errors++;
902 netif_start_queue(net);
903 }
904 } else {
905 pegasus->stats.tx_packets++;
906 pegasus->stats.tx_bytes += skb->len;
1da177e4
LT		 907 }
908 dev_kfree_skb(skb);
909
6ed10654 910 return NETDEV_TX_OK;
1da177e4
LT		 911}
912
913static struct net_device_stats *pegasus_netdev_stats(struct net_device *dev)
914{
915 return &((pegasus_t *) netdev_priv(dev))->stats;
916}
917
5a9dbfe0 918static inline void disable_net_traffic(pegasus_t *pegasus)
1da177e4 919{
e3453f63 920 __le16 tmp = cpu_to_le16(0);
1da177e4 921
e3453f63 922 set_registers(pegasus, EthCtrl0, sizeof(tmp), &tmp);
1da177e4
LT		 923}
924
5a9dbfe0 925static inline void get_interrupt_interval(pegasus_t *pegasus)
1da177e4 926{
e3453f63
MB		 927 u16 data;
928 u8 interval;
1da177e4 929
e3453f63
MB		 930 read_eprom_word(pegasus, 4, &data);
931 interval = data >> 8;
a85a46f2 932 if (pegasus->usb->speed != USB_SPEED_HIGH) {
e3453f63 933 if (interval < 0x80) {
a475f603
JP		 934 netif_info(pegasus, timer, pegasus->net,
935 "intr interval changed from %ums to %ums\n",
936 interval, 0x80);
e3453f63
MB		 937 interval = 0x80;
938 data = (data & 0x00FF) | ((u16)interval << 8);
a85a46f2 939#ifdef PEGASUS_WRITE_EEPROM
e3453f63 940 write_eprom_word(pegasus, 4, data);
1da177e4 941#endif
a85a46f2 942 }
1da177e4 943 }
e3453f63 944 pegasus->intr_interval = interval;
1da177e4
LT		 945}
946
947static void set_carrier(struct net_device *net)
948{
949 pegasus_t *pegasus = netdev_priv(net);
950 u16 tmp;
951
c43c49bd 952 if (read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp))
1da177e4 953 return;
a85a46f2 954
1da177e4
LT		 955 if (tmp & BMSR_LSTATUS)
956 netif_carrier_on(net);
957 else
958 netif_carrier_off(net);
959}
960
5a9dbfe0 961static void free_all_urbs(pegasus_t *pegasus)
1da177e4
LT		 962{
963 usb_free_urb(pegasus->intr_urb);
964 usb_free_urb(pegasus->tx_urb);
965 usb_free_urb(pegasus->rx_urb);
966 usb_free_urb(pegasus->ctrl_urb);
967}
968
5a9dbfe0 969static void unlink_all_urbs(pegasus_t *pegasus)
1da177e4
LT		 970{
971 usb_kill_urb(pegasus->intr_urb);
972 usb_kill_urb(pegasus->tx_urb);
973 usb_kill_urb(pegasus->rx_urb);
974 usb_kill_urb(pegasus->ctrl_urb);
975}
976
5a9dbfe0 977static int alloc_urbs(pegasus_t *pegasus)
1da177e4
LT		 978{
979 pegasus->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL);
5a9dbfe0 980 if (!pegasus->ctrl_urb)
1da177e4 981 return 0;
1da177e4
LT		 982 pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
983 if (!pegasus->rx_urb) {
984 usb_free_urb(pegasus->ctrl_urb);
985 return 0;
986 }
987 pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
988 if (!pegasus->tx_urb) {
989 usb_free_urb(pegasus->rx_urb);
990 usb_free_urb(pegasus->ctrl_urb);
991 return 0;
992 }
993 pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
994 if (!pegasus->intr_urb) {
995 usb_free_urb(pegasus->tx_urb);
996 usb_free_urb(pegasus->rx_urb);
997 usb_free_urb(pegasus->ctrl_urb);
998 return 0;
999 }
1000
1001 return 1;
1002}
1003
1004static int pegasus_open(struct net_device *net)
1005{
1006 pegasus_t *pegasus = netdev_priv(net);
1007 int res;
1008
1009 if (pegasus->rx_skb == NULL)
1010 pegasus->rx_skb = pull_skb(pegasus);
1011 /*
1012 ** Note: no point to free the pool. it is empty :-)
1013 */
1014 if (!pegasus->rx_skb)
1015 return -ENOMEM;
1016
1017 res = set_registers(pegasus, EthID, 6, net->dev_addr);
5a9dbfe0 1018
1da177e4
LT		 1019 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
1020 usb_rcvbulkpipe(pegasus->usb, 1),
1021 pegasus->rx_skb->data, PEGASUS_MTU + 8,
1022 read_bulk_callback, pegasus);
1023 if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) {
955a2608
DB		 1024 if (res == -ENODEV)
1025 netif_device_detach(pegasus->net);
a475f603 1026 netif_dbg(pegasus, ifup, net, "failed rx_urb, %d\n", res);
1da177e4
LT		 1027 goto exit;
1028 }
1029
1030 usb_fill_int_urb(pegasus->intr_urb, pegasus->usb,
1031 usb_rcvintpipe(pegasus->usb, 3),
5a9dbfe0 1032 pegasus->intr_buff, sizeof(pegasus->intr_buff),
1da177e4
LT		 1033 intr_callback, pegasus, pegasus->intr_interval);
1034 if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL))) {
955a2608
DB		 1035 if (res == -ENODEV)
1036 netif_device_detach(pegasus->net);
a475f603 1037 netif_dbg(pegasus, ifup, net, "failed intr_urb, %d\n", res);
1da177e4
LT		 1038 usb_kill_urb(pegasus->rx_urb);
1039 goto exit;
1040 }
1041 if ((res = enable_net_traffic(net, pegasus->usb))) {
a475f603
JP		 1042 netif_dbg(pegasus, ifup, net,
1043 "can't enable_net_traffic() - %d\n", res);
1da177e4
LT		 1044 res = -EIO;
1045 usb_kill_urb(pegasus->rx_urb);
1046 usb_kill_urb(pegasus->intr_urb);
1047 free_skb_pool(pegasus);
1048 goto exit;
1049 }
1050 set_carrier(net);
1051 netif_start_queue(net);
a475f603 1052 netif_dbg(pegasus, ifup, net, "open\n");
1da177e4
LT		 1053 res = 0;
1054exit:
1055 return res;
1056}
1057
1058static int pegasus_close(struct net_device *net)
1059{
1060 pegasus_t *pegasus = netdev_priv(net);
1061
1062 netif_stop_queue(net);
1063 if (!(pegasus->flags & PEGASUS_UNPLUG))
1064 disable_net_traffic(pegasus);
1065 tasklet_kill(&pegasus->rx_tl);
1066 unlink_all_urbs(pegasus);
1067
1068 return 0;
1069}
1070
1071static void pegasus_get_drvinfo(struct net_device *dev,
1072 struct ethtool_drvinfo *info)
1073{
1074 pegasus_t *pegasus = netdev_priv(dev);
7826d43f
JP		 1075
1076 strlcpy(info->driver, driver_name, sizeof(info->driver));
1077 strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
5a9dbfe0 1078 usb_make_path(pegasus->usb, info->bus_info, sizeof(info->bus_info));
1da177e4
LT		 1079}
1080
1081/* also handles three patterns of some kind in hardware */
1082#define WOL_SUPPORTED (WAKE_MAGIC|WAKE_PHY)
1083
1084static void
1085pegasus_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1086{
1087 pegasus_t *pegasus = netdev_priv(dev);
1088
1089 wol->supported = WAKE_MAGIC | WAKE_PHY;
1090 wol->wolopts = pegasus->wolopts;
1091}
1092
1093static int
1094pegasus_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1095{
1096 pegasus_t *pegasus = netdev_priv(dev);
1097 u8 reg78 = 0x04;
4fbc5b20 1098 int ret;
5a9dbfe0 1099
1da177e4
LT		 1100 if (wol->wolopts & ~WOL_SUPPORTED)
1101 return -EINVAL;
1102
1103 if (wol->wolopts & WAKE_MAGIC)
1104 reg78 |= 0x80;
1105 if (wol->wolopts & WAKE_PHY)
1106 reg78 |= 0x40;
1107 /* FIXME this 0x10 bit still needs to get set in the chip... */
1108 if (wol->wolopts)
1109 pegasus->eth_regs[0] |= 0x10;
1110 else
1111 pegasus->eth_regs[0] &= ~0x10;
1112 pegasus->wolopts = wol->wolopts;
4fbc5b20
ML		 1113
1114 ret = set_register(pegasus, WakeupControl, reg78);
1115 if (!ret)
1116 ret = device_set_wakeup_enable(&pegasus->usb->dev,
1117 wol->wolopts);
1118 return ret;
1da177e4
LT		 1119}
1120
1121static inline void pegasus_reset_wol(struct net_device *dev)
1122{
1123 struct ethtool_wolinfo wol;
5a9dbfe0 1124
1da177e4
LT		 1125 memset(&wol, 0, sizeof wol);
1126 (void) pegasus_set_wol(dev, &wol);
1127}
1128
1129static int
1130pegasus_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1131{
1132 pegasus_t *pegasus;
1133
1da177e4
LT		 1134 pegasus = netdev_priv(dev);
1135 mii_ethtool_gset(&pegasus->mii, ecmd);
1da177e4
LT		 1136 return 0;
1137}
1138
1139static int
1140pegasus_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1141{
1142 pegasus_t *pegasus = netdev_priv(dev);
1143 return mii_ethtool_sset(&pegasus->mii, ecmd);
1144}
1145
1146static int pegasus_nway_reset(struct net_device *dev)
1147{
1148 pegasus_t *pegasus = netdev_priv(dev);
1149 return mii_nway_restart(&pegasus->mii);
1150}
1151
1152static u32 pegasus_get_link(struct net_device *dev)
1153{
1154 pegasus_t *pegasus = netdev_priv(dev);
1155 return mii_link_ok(&pegasus->mii);
1156}
1157
1158static u32 pegasus_get_msglevel(struct net_device *dev)
1159{
1160 pegasus_t *pegasus = netdev_priv(dev);
1161 return pegasus->msg_enable;
1162}
1163
1164static void pegasus_set_msglevel(struct net_device *dev, u32 v)
1165{
1166 pegasus_t *pegasus = netdev_priv(dev);
1167 pegasus->msg_enable = v;
1168}
1169
0fc0b732 1170static const struct ethtool_ops ops = {
1da177e4
LT		 1171 .get_drvinfo = pegasus_get_drvinfo,
1172 .get_settings = pegasus_get_settings,
1173 .set_settings = pegasus_set_settings,
1174 .nway_reset = pegasus_nway_reset,
1175 .get_link = pegasus_get_link,
1176 .get_msglevel = pegasus_get_msglevel,
1177 .set_msglevel = pegasus_set_msglevel,
1178 .get_wol = pegasus_get_wol,
1179 .set_wol = pegasus_set_wol,
1180};
1181
1182static int pegasus_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
1183{
5a9dbfe0 1184 __u16 *data = (__u16 *) &rq->ifr_ifru;
1da177e4
LT		 1185 pegasus_t *pegasus = netdev_priv(net);
1186 int res;
1187
1188 switch (cmd) {
1189 case SIOCDEVPRIVATE:
1190 data[0] = pegasus->phy;
1191 case SIOCDEVPRIVATE + 1:
1192 read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
1193 res = 0;
1194 break;
1195 case SIOCDEVPRIVATE + 2:
1196 if (!capable(CAP_NET_ADMIN))
1197 return -EPERM;
1198 write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, data[2]);
1199 res = 0;
1200 break;
1201 default:
1202 res = -EOPNOTSUPP;
1203 }
1204 return res;
1205}
1206
1207static void pegasus_set_multicast(struct net_device *net)
1208{
1209 pegasus_t *pegasus = netdev_priv(net);
1210
1211 if (net->flags & IFF_PROMISC) {
1212 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
a475f603 1213 netif_info(pegasus, link, net, "Promiscuous mode enabled\n");
4cd24eaf 1214 } else if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI)) {
1da177e4
LT		 1215 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
1216 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
a475f603 1217 netif_dbg(pegasus, link, net, "set allmulti\n");
1da177e4
LT		 1218 } else {
1219 pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
1220 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1221 }
1222
e000ea13
DB		 1223 pegasus->ctrl_urb->status = 0;
1224
1da177e4 1225 pegasus->flags |= ETH_REGS_CHANGE;
7d12e780 1226 ctrl_callback(pegasus->ctrl_urb);
1da177e4
LT		 1227}
1228
5a9dbfe0 1229static __u8 mii_phy_probe(pegasus_t *pegasus)
1da177e4
LT		 1230{
1231 int i;
1232 __u16 tmp;
1233
1234 for (i = 0; i < 32; i++) {
1235 read_mii_word(pegasus, i, MII_BMSR, &tmp);
1236 if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0)
1237 continue;
1238 else
1239 return i;
1240 }
1241
1242 return 0xff;
1243}
1244
5a9dbfe0 1245static inline void setup_pegasus_II(pegasus_t *pegasus)
1da177e4
LT		 1246{
1247 __u8 data = 0xa5;
5a9dbfe0 1248
4a1728a2
PM		 1249 set_register(pegasus, Reg1d, 0);
1250 set_register(pegasus, Reg7b, 1);
1da177e4
LT		 1251 mdelay(100);
1252 if ((pegasus->features & HAS_HOME_PNA) && mii_mode)
4a1728a2 1253 set_register(pegasus, Reg7b, 0);
1da177e4 1254 else
4a1728a2 1255 set_register(pegasus, Reg7b, 2);
1da177e4 1256
4a1728a2
PM		 1257 set_register(pegasus, 0x83, data);
1258 get_registers(pegasus, 0x83, 1, &data);
1da177e4 1259
5a9dbfe0 1260 if (data == 0xa5)
1da177e4 1261 pegasus->chip = 0x8513;
5a9dbfe0 1262 else
1da177e4 1263 pegasus->chip = 0;
1da177e4 1264
4a1728a2
PM		 1265 set_register(pegasus, 0x80, 0xc0);
1266 set_register(pegasus, 0x83, 0xff);
1267 set_register(pegasus, 0x84, 0x01);
5a9dbfe0 1268
1da177e4 1269 if (pegasus->features & HAS_HOME_PNA && mii_mode)
4a1728a2 1270 set_register(pegasus, Reg81, 6);
1da177e4 1271 else
4a1728a2 1272 set_register(pegasus, Reg81, 2);
1da177e4
LT		 1273}
1274
1275
cda2836d 1276static int pegasus_count;
5a9dbfe0 1277static struct workqueue_struct *pegasus_workqueue;
1da177e4
LT		 1278#define CARRIER_CHECK_DELAY (2 * HZ)
1279
c4028958 1280static void check_carrier(struct work_struct *work)
1da177e4 1281{
c4028958 1282 pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work);
1da177e4
LT		 1283 set_carrier(pegasus->net);
1284 if (!(pegasus->flags & PEGASUS_UNPLUG)) {
1285 queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
1286 CARRIER_CHECK_DELAY);
1287 }
1288}
1289
4f63135e
BC		 1290static int pegasus_blacklisted(struct usb_device *udev)
1291{
1292 struct usb_device_descriptor *udd = &udev->descriptor;
1293
1294 /* Special quirk to keep the driver from handling the Belkin Bluetooth
1295 * dongle which happens to have the same ID.
1296 */
e3453f63
MB		 1297 if ((udd->idVendor == cpu_to_le16(VENDOR_BELKIN)) &&
1298 (udd->idProduct == cpu_to_le16(0x0121)) &&
4f63135e
BC		 1299 (udd->bDeviceClass == USB_CLASS_WIRELESS_CONTROLLER) &&
1300 (udd->bDeviceProtocol == 1))
1301 return 1;
1302
1303 return 0;
1304}
1305
cda2836d
DB		 1306/* we rely on probe() and remove() being serialized so we
1307 * don't need extra locking on pegasus_count.
1308 */
1309static void pegasus_dec_workqueue(void)
1310{
1311 pegasus_count--;
1312 if (pegasus_count == 0) {
1313 destroy_workqueue(pegasus_workqueue);
1314 pegasus_workqueue = NULL;
1315 }
1316}
1317
1da177e4
LT		 1318static int pegasus_probe(struct usb_interface *intf,
1319 const struct usb_device_id *id)
1320{
1321 struct usb_device *dev = interface_to_usbdev(intf);
1322 struct net_device *net;
1323 pegasus_t *pegasus;
1324 int dev_index = id - pegasus_ids;
1325 int res = -ENOMEM;
1326
cda2836d
DB		 1327 if (pegasus_blacklisted(dev))
1328 return -ENODEV;
4f63135e 1329
cda2836d
DB		 1330 if (pegasus_count == 0) {
1331 pegasus_workqueue = create_singlethread_workqueue("pegasus");
1332 if (!pegasus_workqueue)
1333 return -ENOMEM;
4f63135e 1334 }
cda2836d
DB		 1335 pegasus_count++;
1336
1da177e4 1337 net = alloc_etherdev(sizeof(struct pegasus));
41de8d4c 1338 if (!net)
1da177e4 1339 goto out;
1da177e4
LT		 1340
1341 pegasus = netdev_priv(net);
1da177e4
LT		 1342 pegasus->dev_index = dev_index;
1343 init_waitqueue_head(&pegasus->ctrl_wait);
1344
1345 if (!alloc_urbs(pegasus)) {
1346 dev_err(&intf->dev, "can't allocate %s\n", "urbs");
1347 goto out1;
1348 }
1349
1350 tasklet_init(&pegasus->rx_tl, rx_fixup, (unsigned long) pegasus);
1351
c4028958 1352 INIT_DELAYED_WORK(&pegasus->carrier_check, check_carrier);
1da177e4
LT		 1353
1354 pegasus->intf = intf;
1355 pegasus->usb = dev;
1356 pegasus->net = net;
8cb89571
ON		 1357
1358
1da177e4 1359 net->watchdog_timeo = PEGASUS_TX_TIMEOUT;
8cb89571 1360 net->netdev_ops = &pegasus_netdev_ops;
1da177e4
LT		 1361 SET_ETHTOOL_OPS(net, &ops);
1362 pegasus->mii.dev = net;
1363 pegasus->mii.mdio_read = mdio_read;
1364 pegasus->mii.mdio_write = mdio_write;
1365 pegasus->mii.phy_id_mask = 0x1f;
1366 pegasus->mii.reg_num_mask = 0x1f;
1367 spin_lock_init(&pegasus->rx_pool_lock);
5a9dbfe0 1368 pegasus->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
1da177e4
LT		 1369 | NETIF_MSG_PROBE | NETIF_MSG_LINK);
1370
1371 pegasus->features = usb_dev_id[dev_index].private;
1372 get_interrupt_interval(pegasus);
1373 if (reset_mac(pegasus)) {
1374 dev_err(&intf->dev, "can't reset MAC\n");
1375 res = -EIO;
1376 goto out2;
1377 }
1378 set_ethernet_addr(pegasus);
1379 fill_skb_pool(pegasus);
1380 if (pegasus->features & PEGASUS_II) {
1381 dev_info(&intf->dev, "setup Pegasus II specific registers\n");
1382 setup_pegasus_II(pegasus);
1383 }
1384 pegasus->phy = mii_phy_probe(pegasus);
1385 if (pegasus->phy == 0xff) {
1386 dev_warn(&intf->dev, "can't locate MII phy, using default\n");
1387 pegasus->phy = 1;
1388 }
1389 pegasus->mii.phy_id = pegasus->phy;
1390 usb_set_intfdata(intf, pegasus);
1391 SET_NETDEV_DEV(net, &intf->dev);
1392 pegasus_reset_wol(net);
1393 res = register_netdev(net);
1394 if (res)
1395 goto out3;
1396 queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
1397 CARRIER_CHECK_DELAY);
1398
e174961c 1399 dev_info(&intf->dev, "%s, %s, %pM\n",
0795af57
JP		 1400 net->name,
1401 usb_dev_id[dev_index].name,
e174961c 1402 net->dev_addr);
1da177e4
LT		 1403 return 0;
1404
1405out3:
1406 usb_set_intfdata(intf, NULL);
1407 free_skb_pool(pegasus);
1408out2:
1409 free_all_urbs(pegasus);
1410out1:
1411 free_netdev(net);
1412out:
cda2836d 1413 pegasus_dec_workqueue();
1da177e4
LT		 1414 return res;
1415}
1416
1417static void pegasus_disconnect(struct usb_interface *intf)
1418{
1419 struct pegasus *pegasus = usb_get_intfdata(intf);
1420
1421 usb_set_intfdata(intf, NULL);
1422 if (!pegasus) {
1423 dev_dbg(&intf->dev, "unregistering non-bound device?\n");
1424 return;
1425 }
1426
1427 pegasus->flags |= PEGASUS_UNPLUG;
1428 cancel_delayed_work(&pegasus->carrier_check);
1429 unregister_netdev(pegasus->net);
a85a46f2 1430 unlink_all_urbs(pegasus);
1da177e4
LT		 1431 free_all_urbs(pegasus);
1432 free_skb_pool(pegasus);
4c13eb66 1433 if (pegasus->rx_skb != NULL) {
1da177e4 1434 dev_kfree_skb(pegasus->rx_skb);
4c13eb66
ACM		 1435 pegasus->rx_skb = NULL;
1436 }
1da177e4 1437 free_netdev(pegasus->net);
cda2836d 1438 pegasus_dec_workqueue();
1da177e4
LT		 1439}
1440
5a9dbfe0 1441static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
1da177e4
LT		 1442{
1443 struct pegasus *pegasus = usb_get_intfdata(intf);
5a9dbfe0
NK		 1444
1445 netif_device_detach(pegasus->net);
7e713b82 1446 cancel_delayed_work(&pegasus->carrier_check);
27d72e85 1447 if (netif_running(pegasus->net)) {
27d72e85
DB		 1448 usb_kill_urb(pegasus->rx_urb);
1449 usb_kill_urb(pegasus->intr_urb);
1450 }
1da177e4
LT		 1451 return 0;
1452}
1453
5a9dbfe0 1454static int pegasus_resume(struct usb_interface *intf)
1da177e4
LT		 1455{
1456 struct pegasus *pegasus = usb_get_intfdata(intf);
1457
5a9dbfe0 1458 netif_device_attach(pegasus->net);
27d72e85
DB		 1459 if (netif_running(pegasus->net)) {
1460 pegasus->rx_urb->status = 0;
1461 pegasus->rx_urb->actual_length = 0;
7d12e780 1462 read_bulk_callback(pegasus->rx_urb);
27d72e85
DB		 1463
1464 pegasus->intr_urb->status = 0;
1465 pegasus->intr_urb->actual_length = 0;
7d12e780 1466 intr_callback(pegasus->intr_urb);
27d72e85 1467 }
7e713b82
DB		 1468 queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
1469 CARRIER_CHECK_DELAY);
1da177e4
LT		 1470 return 0;
1471}
1472
8cb89571
ON		 1473static const struct net_device_ops pegasus_netdev_ops = {
1474 .ndo_open = pegasus_open,
1475 .ndo_stop = pegasus_close,
1476 .ndo_do_ioctl = pegasus_ioctl,
1477 .ndo_start_xmit = pegasus_start_xmit,
afc4b13d 1478 .ndo_set_rx_mode = pegasus_set_multicast,
8cb89571
ON		 1479 .ndo_get_stats = pegasus_netdev_stats,
1480 .ndo_tx_timeout = pegasus_tx_timeout,
635ecaa7 1481 .ndo_change_mtu = eth_change_mtu,
240c102d
BH		 1482 .ndo_set_mac_address = eth_mac_addr,
1483 .ndo_validate_addr = eth_validate_addr,
8cb89571
ON		 1484};
1485
1da177e4
LT		 1486static struct usb_driver pegasus_driver = {
1487 .name = driver_name,
1488 .probe = pegasus_probe,
1489 .disconnect = pegasus_disconnect,
1490 .id_table = pegasus_ids,
1491 .suspend = pegasus_suspend,
1492 .resume = pegasus_resume,
e1f12eb6 1493 .disable_hub_initiated_lpm = 1,
1da177e4
LT		 1494};
1495
cda2836d 1496static void __init parse_id(char *id)
a4f81a61 1497{
5a9dbfe0
NK		 1498 unsigned int vendor_id = 0, device_id = 0, flags = 0, i = 0;
1499 char *token, *name = NULL;
a4f81a61
Y		 1500
1501 if ((token = strsep(&id, ":")) != NULL)
1502 name = token;
1503 /* name now points to a null terminated string*/
1504 if ((token = strsep(&id, ":")) != NULL)
1505 vendor_id = simple_strtoul(token, NULL, 16);
1506 if ((token = strsep(&id, ":")) != NULL)
1507 device_id = simple_strtoul(token, NULL, 16);
1508 flags = simple_strtoul(id, NULL, 16);
1509 pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n",
5a9dbfe0 1510 driver_name, name, vendor_id, device_id, flags);
a4f81a61
Y		 1511
1512 if (vendor_id > 0x10000 || vendor_id == 0)
1513 return;
1514 if (device_id > 0x10000 || device_id == 0)
1515 return;
1516
5a9dbfe0 1517 for (i = 0; usb_dev_id[i].name; i++);
a4f81a61
Y		 1518 usb_dev_id[i].name = name;
1519 usb_dev_id[i].vendor = vendor_id;
1520 usb_dev_id[i].device = device_id;
1521 usb_dev_id[i].private = flags;
1522 pegasus_ids[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
1523 pegasus_ids[i].idVendor = vendor_id;
1524 pegasus_ids[i].idProduct = device_id;
1525}
1526
1da177e4
LT		 1527static int __init pegasus_init(void)
1528{
1529 pr_info("%s: %s, " DRIVER_DESC "\n", driver_name, DRIVER_VERSION);
a4f81a61
Y		 1530 if (devid)
1531 parse_id(devid);
1da177e4
LT		 1532 return usb_register(&pegasus_driver);
1533}
1534
1535static void __exit pegasus_exit(void)
1536{
1da177e4
LT		 1537 usb_deregister(&pegasus_driver);
1538}
1539
1540module_init(pegasus_init);
1541module_exit(pegasus_exit);
Linux 6.x block layer and io_uring tree(s)