]> git.ipfire.org Git - ipfire-2.x.git/blame - src/patches/backports-3.18.1-1-add_usbnet_modules.patch
projects / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge remote-tracking branch 'amarx/BUG10797' into next
[ipfire-2.x.git] / src / patches / backports-3.18.1-1-add_usbnet_modules.patch
CommitLineData
82bcc200
AF		 1diff -Naur backports-3.18.1-1.org/drivers/net/usb/asix_common.c backports-3.18.1-1/drivers/net/usb/asix_common.c
2--- backports-3.18.1-1.org/drivers/net/usb/asix_common.c 1970-01-01 01:00:00.000000000 +0100
3+++ backports-3.18.1-1/drivers/net/usb/asix_common.c 2014-12-16 18:39:45.000000000 +0100
4@@ -0,0 +1,582 @@
5+/*
6+ * ASIX AX8817X based USB 2.0 Ethernet Devices
7+ * Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
8+ * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
9+ * Copyright (C) 2006 James Painter <jamie.painter@iname.com>
10+ * Copyright (c) 2002-2003 TiVo Inc.
11+ *
12+ * This program is free software; you can redistribute it and/or modify
13+ * it under the terms of the GNU General Public License as published by
14+ * the Free Software Foundation; either version 2 of the License, or
15+ * (at your option) any later version.
16+ *
17+ * This program is distributed in the hope that it will be useful,
18+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
19+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20+ * GNU General Public License for more details.
21+ *
22+ * You should have received a copy of the GNU General Public License
23+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
24+ */
25+
26+#include "asix.h"
27+
28+int asix_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
29+ u16 size, void *data)
30+{
31+ int ret;
32+ ret = usbnet_read_cmd(dev, cmd,
33+ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
34+ value, index, data, size);
35+
36+ if (ret != size && ret >= 0)
37+ return -EINVAL;
38+ return ret;
39+}
40+
41+int asix_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
42+ u16 size, void *data)
43+{
44+ return usbnet_write_cmd(dev, cmd,
45+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
46+ value, index, data, size);
47+}
48+
49+void asix_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
50+ u16 size, void *data)
51+{
52+ usbnet_write_cmd_async(dev, cmd,
53+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
54+ value, index, data, size);
55+}
56+
57+int asix_rx_fixup_internal(struct usbnet *dev, struct sk_buff *skb,
58+ struct asix_rx_fixup_info *rx)
59+{
60+ int offset = 0;
61+
62+ while (offset + sizeof(u16) <= skb->len) {
63+ u16 remaining = 0;
64+ unsigned char *data;
65+
66+ if (!rx->size) {
67+ if ((skb->len - offset == sizeof(u16)) ||
68+ rx->split_head) {
69+ if(!rx->split_head) {
70+ rx->header = get_unaligned_le16(
71+ skb->data + offset);
72+ rx->split_head = true;
73+ offset += sizeof(u16);
74+ break;
75+ } else {
76+ rx->header |= (get_unaligned_le16(
77+ skb->data + offset)
78+ << 16);
79+ rx->split_head = false;
80+ offset += sizeof(u16);
81+ }
82+ } else {
83+ rx->header = get_unaligned_le32(skb->data +
84+ offset);
85+ offset += sizeof(u32);
86+ }
87+
88+ /* get the packet length */
89+ rx->size = (u16) (rx->header & 0x7ff);
90+ if (rx->size != ((~rx->header >> 16) & 0x7ff)) {
91+ netdev_err(dev->net, "asix_rx_fixup() Bad Header Length 0x%x, offset %d\n",
92+ rx->header, offset);
93+ rx->size = 0;
94+ return 0;
95+ }
96+ rx->ax_skb = netdev_alloc_skb_ip_align(dev->net,
97+ rx->size);
98+ if (!rx->ax_skb)
99+ return 0;
100+ }
101+
102+ if (rx->size > dev->net->mtu + ETH_HLEN + VLAN_HLEN) {
103+ netdev_err(dev->net, "asix_rx_fixup() Bad RX Length %d\n",
104+ rx->size);
105+ kfree_skb(rx->ax_skb);
106+ rx->ax_skb = NULL;
107+ rx->size = 0U;
108+
109+ return 0;
110+ }
111+
112+ if (rx->size > skb->len - offset) {
113+ remaining = rx->size - (skb->len - offset);
114+ rx->size = skb->len - offset;
115+ }
116+
117+ data = skb_put(rx->ax_skb, rx->size);
118+ memcpy(data, skb->data + offset, rx->size);
119+ if (!remaining)
120+ usbnet_skb_return(dev, rx->ax_skb);
121+
122+ offset += (rx->size + 1) & 0xfffe;
123+ rx->size = remaining;
124+ }
125+
126+ if (skb->len != offset) {
127+ netdev_err(dev->net, "asix_rx_fixup() Bad SKB Length %d, %d\n",
128+ skb->len, offset);
129+ return 0;
130+ }
131+
132+ return 1;
133+}
134+
135+int asix_rx_fixup_common(struct usbnet *dev, struct sk_buff *skb)
136+{
137+ struct asix_common_private *dp = dev->driver_priv;
138+ struct asix_rx_fixup_info *rx = &dp->rx_fixup_info;
139+
140+ return asix_rx_fixup_internal(dev, skb, rx);
141+}
142+
143+struct sk_buff *asix_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
144+ gfp_t flags)
145+{
146+ int padlen;
147+ int headroom = skb_headroom(skb);
148+ int tailroom = skb_tailroom(skb);
149+ u32 packet_len;
150+ u32 padbytes = 0xffff0000;
151+
152+ padlen = ((skb->len + 4) & (dev->maxpacket - 1)) ? 0 : 4;
153+
154+ /* We need to push 4 bytes in front of frame (packet_len)
155+ * and maybe add 4 bytes after the end (if padlen is 4)
156+ *
157+ * Avoid skb_copy_expand() expensive call, using following rules :
158+ * - We are allowed to push 4 bytes in headroom if skb_header_cloned()
159+ * is false (and if we have 4 bytes of headroom)
160+ * - We are allowed to put 4 bytes at tail if skb_cloned()
161+ * is false (and if we have 4 bytes of tailroom)
162+ *
163+ * TCP packets for example are cloned, but skb_header_release()
164+ * was called in tcp stack, allowing us to use headroom for our needs.
165+ */
166+ if (!skb_header_cloned(skb) &&
167+ !(padlen && skb_cloned(skb)) &&
168+ headroom + tailroom >= 4 + padlen) {
169+ /* following should not happen, but better be safe */
170+ if (headroom < 4 ||
171+ tailroom < padlen) {
172+ skb->data = memmove(skb->head + 4, skb->data, skb->len);
173+ skb_set_tail_pointer(skb, skb->len);
174+ }
175+ } else {
176+ struct sk_buff *skb2;
177+
178+ skb2 = skb_copy_expand(skb, 4, padlen, flags);
179+ dev_kfree_skb_any(skb);
180+ skb = skb2;
181+ if (!skb)
182+ return NULL;
183+ }
184+
185+ packet_len = ((skb->len ^ 0x0000ffff) << 16) + skb->len;
186+ skb_push(skb, 4);
187+ cpu_to_le32s(&packet_len);
188+ skb_copy_to_linear_data(skb, &packet_len, sizeof(packet_len));
189+
190+ if (padlen) {
191+ cpu_to_le32s(&padbytes);
192+ memcpy(skb_tail_pointer(skb), &padbytes, sizeof(padbytes));
193+ skb_put(skb, sizeof(padbytes));
194+ }
195+ return skb;
196+}
197+
198+int asix_set_sw_mii(struct usbnet *dev)
199+{
200+ int ret;
201+ ret = asix_write_cmd(dev, AX_CMD_SET_SW_MII, 0x0000, 0, 0, NULL);
202+ if (ret < 0)
203+ netdev_err(dev->net, "Failed to enable software MII access\n");
204+ return ret;
205+}
206+
207+int asix_set_hw_mii(struct usbnet *dev)
208+{
209+ int ret;
210+ ret = asix_write_cmd(dev, AX_CMD_SET_HW_MII, 0x0000, 0, 0, NULL);
211+ if (ret < 0)
212+ netdev_err(dev->net, "Failed to enable hardware MII access\n");
213+ return ret;
214+}
215+
216+int asix_read_phy_addr(struct usbnet *dev, int internal)
217+{
218+ int offset = (internal ? 1 : 0);
219+ u8 buf[2];
220+ int ret = asix_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf);
221+
222+ netdev_dbg(dev->net, "asix_get_phy_addr()\n");
223+
224+ if (ret < 0) {
225+ netdev_err(dev->net, "Error reading PHYID register: %02x\n", ret);
226+ goto out;
227+ }
228+ netdev_dbg(dev->net, "asix_get_phy_addr() returning 0x%04x\n",
229+ *((__le16 *)buf));
230+ ret = buf[offset];
231+
232+out:
233+ return ret;
234+}
235+
236+int asix_get_phy_addr(struct usbnet *dev)
237+{
238+ /* return the address of the internal phy */
239+ return asix_read_phy_addr(dev, 1);
240+}
241+
242+
243+int asix_sw_reset(struct usbnet *dev, u8 flags)
244+{
245+ int ret;
246+
247+ ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL);
248+ if (ret < 0)
249+ netdev_err(dev->net, "Failed to send software reset: %02x\n", ret);
250+
251+ return ret;
252+}
253+
254+u16 asix_read_rx_ctl(struct usbnet *dev)
255+{
256+ __le16 v;
257+ int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, &v);
258+
259+ if (ret < 0) {
260+ netdev_err(dev->net, "Error reading RX_CTL register: %02x\n", ret);
261+ goto out;
262+ }
263+ ret = le16_to_cpu(v);
264+out:
265+ return ret;
266+}
267+
268+int asix_write_rx_ctl(struct usbnet *dev, u16 mode)
269+{
270+ int ret;
271+
272+ netdev_dbg(dev->net, "asix_write_rx_ctl() - mode = 0x%04x\n", mode);
273+ ret = asix_write_cmd(dev, AX_CMD_WRITE_RX_CTL, mode, 0, 0, NULL);
274+ if (ret < 0)
275+ netdev_err(dev->net, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
276+ mode, ret);
277+
278+ return ret;
279+}
280+
281+u16 asix_read_medium_status(struct usbnet *dev)
282+{
283+ __le16 v;
284+ int ret = asix_read_cmd(dev, AX_CMD_READ_MEDIUM_STATUS, 0, 0, 2, &v);
285+
286+ if (ret < 0) {
287+ netdev_err(dev->net, "Error reading Medium Status register: %02x\n",
288+ ret);
289+ return ret; /* TODO: callers not checking for error ret */
290+ }
291+
292+ return le16_to_cpu(v);
293+
294+}
295+
296+int asix_write_medium_mode(struct usbnet *dev, u16 mode)
297+{
298+ int ret;
299+
300+ netdev_dbg(dev->net, "asix_write_medium_mode() - mode = 0x%04x\n", mode);
301+ ret = asix_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
302+ if (ret < 0)
303+ netdev_err(dev->net, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
304+ mode, ret);
305+
306+ return ret;
307+}
308+
309+int asix_write_gpio(struct usbnet *dev, u16 value, int sleep)
310+{
311+ int ret;
312+
313+ netdev_dbg(dev->net, "asix_write_gpio() - value = 0x%04x\n", value);
314+ ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS, value, 0, 0, NULL);
315+ if (ret < 0)
316+ netdev_err(dev->net, "Failed to write GPIO value 0x%04x: %02x\n",
317+ value, ret);
318+
319+ if (sleep)
320+ msleep(sleep);
321+
322+ return ret;
323+}
324+
325+/*
326+ * AX88772 & AX88178 have a 16-bit RX_CTL value
327+ */
328+void asix_set_multicast(struct net_device *net)
329+{
330+ struct usbnet *dev = netdev_priv(net);
331+ struct asix_data *data = (struct asix_data *)&dev->data;
332+ u16 rx_ctl = AX_DEFAULT_RX_CTL;
333+
334+ if (net->flags & IFF_PROMISC) {
335+ rx_ctl |= AX_RX_CTL_PRO;
336+ } else if (net->flags & IFF_ALLMULTI ||
337+ netdev_mc_count(net) > AX_MAX_MCAST) {
338+ rx_ctl |= AX_RX_CTL_AMALL;
339+ } else if (netdev_mc_empty(net)) {
340+ /* just broadcast and directed */
341+ } else {
342+ /* We use the 20 byte dev->data
343+ * for our 8 byte filter buffer
344+ * to avoid allocating memory that
345+ * is tricky to free later */
346+ struct netdev_hw_addr *ha;
347+ u32 crc_bits;
348+
349+ memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
350+
351+ /* Build the multicast hash filter. */
352+ netdev_for_each_mc_addr(ha, net) {
353+ crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
354+ data->multi_filter[crc_bits >> 3] |=
355+ 1 << (crc_bits & 7);
356+ }
357+
358+ asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
359+ AX_MCAST_FILTER_SIZE, data->multi_filter);
360+
361+ rx_ctl |= AX_RX_CTL_AM;
362+ }
363+
364+ asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
365+}
366+
367+int asix_mdio_read(struct net_device *netdev, int phy_id, int loc)
368+{
369+ struct usbnet *dev = netdev_priv(netdev);
370+ __le16 res;
371+
372+ mutex_lock(&dev->phy_mutex);
373+ asix_set_sw_mii(dev);
374+ asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id,
375+ (__u16)loc, 2, &res);
376+ asix_set_hw_mii(dev);
377+ mutex_unlock(&dev->phy_mutex);
378+
379+ netdev_dbg(dev->net, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
380+ phy_id, loc, le16_to_cpu(res));
381+
382+ return le16_to_cpu(res);
383+}
384+
385+void asix_mdio_write(struct net_device *netdev, int phy_id, int loc, int val)
386+{
387+ struct usbnet *dev = netdev_priv(netdev);
388+ __le16 res = cpu_to_le16(val);
389+
390+ netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
391+ phy_id, loc, val);
392+ mutex_lock(&dev->phy_mutex);
393+ asix_set_sw_mii(dev);
394+ asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2, &res);
395+ asix_set_hw_mii(dev);
396+ mutex_unlock(&dev->phy_mutex);
397+}
398+
399+void asix_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
400+{
401+ struct usbnet *dev = netdev_priv(net);
402+ u8 opt;
403+
404+ if (asix_read_cmd(dev, AX_CMD_READ_MONITOR_MODE, 0, 0, 1, &opt) < 0) {
405+ wolinfo->supported = 0;
406+ wolinfo->wolopts = 0;
407+ return;
408+ }
409+ wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
410+ wolinfo->wolopts = 0;
411+ if (opt & AX_MONITOR_LINK)
412+ wolinfo->wolopts |= WAKE_PHY;
413+ if (opt & AX_MONITOR_MAGIC)
414+ wolinfo->wolopts |= WAKE_MAGIC;
415+}
416+
417+int asix_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
418+{
419+ struct usbnet *dev = netdev_priv(net);
420+ u8 opt = 0;
421+
422+ if (wolinfo->wolopts & WAKE_PHY)
423+ opt |= AX_MONITOR_LINK;
424+ if (wolinfo->wolopts & WAKE_MAGIC)
425+ opt |= AX_MONITOR_MAGIC;
426+
427+ if (asix_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE,
428+ opt, 0, 0, NULL) < 0)
429+ return -EINVAL;
430+
431+ return 0;
432+}
433+
434+int asix_get_eeprom_len(struct net_device *net)
435+{
436+ return AX_EEPROM_LEN;
437+}
438+
439+int asix_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
440+ u8 *data)
441+{
442+ struct usbnet *dev = netdev_priv(net);
443+ u16 *eeprom_buff;
444+ int first_word, last_word;
445+ int i;
446+
447+ if (eeprom->len == 0)
448+ return -EINVAL;
449+
450+ eeprom->magic = AX_EEPROM_MAGIC;
451+
452+ first_word = eeprom->offset >> 1;
453+ last_word = (eeprom->offset + eeprom->len - 1) >> 1;
454+
455+ eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),
456+ GFP_KERNEL);
457+ if (!eeprom_buff)
458+ return -ENOMEM;
459+
460+ /* ax8817x returns 2 bytes from eeprom on read */
461+ for (i = first_word; i <= last_word; i++) {
462+ if (asix_read_cmd(dev, AX_CMD_READ_EEPROM, i, 0, 2,
463+ &(eeprom_buff[i - first_word])) < 0) {
464+ kfree(eeprom_buff);
465+ return -EIO;
466+ }
467+ }
468+
469+ memcpy(data, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
470+ kfree(eeprom_buff);
471+ return 0;
472+}
473+
474+int asix_set_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
475+ u8 *data)
476+{
477+ struct usbnet *dev = netdev_priv(net);
478+ u16 *eeprom_buff;
479+ int first_word, last_word;
480+ int i;
481+ int ret;
482+
483+ netdev_dbg(net, "write EEPROM len %d, offset %d, magic 0x%x\n",
484+ eeprom->len, eeprom->offset, eeprom->magic);
485+
486+ if (eeprom->len == 0)
487+ return -EINVAL;
488+
489+ if (eeprom->magic != AX_EEPROM_MAGIC)
490+ return -EINVAL;
491+
492+ first_word = eeprom->offset >> 1;
493+ last_word = (eeprom->offset + eeprom->len - 1) >> 1;
494+
495+ eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),
496+ GFP_KERNEL);
497+ if (!eeprom_buff)
498+ return -ENOMEM;
499+
500+ /* align data to 16 bit boundaries, read the missing data from
501+ the EEPROM */
502+ if (eeprom->offset & 1) {
503+ ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, first_word, 0, 2,
504+ &(eeprom_buff[0]));
505+ if (ret < 0) {
506+ netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", first_word);
507+ goto free;
508+ }
509+ }
510+
511+ if ((eeprom->offset + eeprom->len) & 1) {
512+ ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, last_word, 0, 2,
513+ &(eeprom_buff[last_word - first_word]));
514+ if (ret < 0) {
515+ netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", last_word);
516+ goto free;
517+ }
518+ }
519+
520+ memcpy((u8 *)eeprom_buff + (eeprom->offset & 1), data, eeprom->len);
521+
522+ /* write data to EEPROM */
523+ ret = asix_write_cmd(dev, AX_CMD_WRITE_ENABLE, 0x0000, 0, 0, NULL);
524+ if (ret < 0) {
525+ netdev_err(net, "Failed to enable EEPROM write\n");
526+ goto free;
527+ }
528+ msleep(20);
529+
530+ for (i = first_word; i <= last_word; i++) {
531+ netdev_dbg(net, "write to EEPROM at offset 0x%02x, data 0x%04x\n",
532+ i, eeprom_buff[i - first_word]);
533+ ret = asix_write_cmd(dev, AX_CMD_WRITE_EEPROM, i,
534+ eeprom_buff[i - first_word], 0, NULL);
535+ if (ret < 0) {
536+ netdev_err(net, "Failed to write EEPROM at offset 0x%02x.\n",
537+ i);
538+ goto free;
539+ }
540+ msleep(20);
541+ }
542+
543+ ret = asix_write_cmd(dev, AX_CMD_WRITE_DISABLE, 0x0000, 0, 0, NULL);
544+ if (ret < 0) {
545+ netdev_err(net, "Failed to disable EEPROM write\n");
546+ goto free;
547+ }
548+
549+ ret = 0;
550+free:
551+ kfree(eeprom_buff);
552+ return ret;
553+}
554+
555+void asix_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
556+{
557+ /* Inherit standard device info */
558+ usbnet_get_drvinfo(net, info);
559+ strlcpy(info->driver, DRIVER_NAME, sizeof(info->driver));
560+ strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
561+ info->eedump_len = AX_EEPROM_LEN;
562+}
563+
564+int asix_set_mac_address(struct net_device *net, void *p)
565+{
566+ struct usbnet *dev = netdev_priv(net);
567+ struct asix_data *data = (struct asix_data *)&dev->data;
568+ struct sockaddr *addr = p;
569+
570+ if (netif_running(net))
571+ return -EBUSY;
572+ if (!is_valid_ether_addr(addr->sa_data))
573+ return -EADDRNOTAVAIL;
574+
575+ memcpy(net->dev_addr, addr->sa_data, ETH_ALEN);
576+
577+ /* We use the 20 byte dev->data
578+ * for our 6 byte mac buffer
579+ * to avoid allocating memory that
580+ * is tricky to free later */
581+ memcpy(data->mac_addr, addr->sa_data, ETH_ALEN);
582+ asix_write_cmd_async(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
583+ data->mac_addr);
584+
585+ return 0;
586+}
587diff -Naur backports-3.18.1-1.org/drivers/net/usb/asix_devices.c backports-3.18.1-1/drivers/net/usb/asix_devices.c
588--- backports-3.18.1-1.org/drivers/net/usb/asix_devices.c 1970-01-01 01:00:00.000000000 +0100
589+++ backports-3.18.1-1/drivers/net/usb/asix_devices.c 2014-12-16 18:39:45.000000000 +0100
590@@ -0,0 +1,1104 @@
591+/*
592+ * ASIX AX8817X based USB 2.0 Ethernet Devices
593+ * Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
594+ * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
595+ * Copyright (C) 2006 James Painter <jamie.painter@iname.com>
596+ * Copyright (c) 2002-2003 TiVo Inc.
597+ *
598+ * This program is free software; you can redistribute it and/or modify
599+ * it under the terms of the GNU General Public License as published by
600+ * the Free Software Foundation; either version 2 of the License, or
601+ * (at your option) any later version.
602+ *
603+ * This program is distributed in the hope that it will be useful,
604+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
605+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
606+ * GNU General Public License for more details.
607+ *
608+ * You should have received a copy of the GNU General Public License
609+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
610+ */
611+
612+#include "asix.h"
613+
614+#define PHY_MODE_MARVELL 0x0000
615+#define MII_MARVELL_LED_CTRL 0x0018
616+#define MII_MARVELL_STATUS 0x001b
617+#define MII_MARVELL_CTRL 0x0014
618+
619+#define MARVELL_LED_MANUAL 0x0019
620+
621+#define MARVELL_STATUS_HWCFG 0x0004
622+
623+#define MARVELL_CTRL_TXDELAY 0x0002
624+#define MARVELL_CTRL_RXDELAY 0x0080
625+
626+#define PHY_MODE_RTL8211CL 0x000C
627+
628+struct ax88172_int_data {
629+ __le16 res1;
630+ u8 link;
631+ __le16 res2;
632+ u8 status;
633+ __le16 res3;
634+} __packed;
635+
636+static void asix_status(struct usbnet *dev, struct urb *urb)
637+{
638+ struct ax88172_int_data *event;
639+ int link;
640+
641+ if (urb->actual_length < 8)
642+ return;
643+
644+ event = urb->transfer_buffer;
645+ link = event->link & 0x01;
646+ if (netif_carrier_ok(dev->net) != link) {
647+ usbnet_link_change(dev, link, 1);
648+ netdev_dbg(dev->net, "Link Status is: %d\n", link);
649+ }
650+}
651+
652+static void asix_set_netdev_dev_addr(struct usbnet *dev, u8 *addr)
653+{
654+ if (is_valid_ether_addr(addr)) {
655+ memcpy(dev->net->dev_addr, addr, ETH_ALEN);
656+ } else {
657+ netdev_info(dev->net, "invalid hw address, using random\n");
658+ eth_hw_addr_random(dev->net);
659+ }
660+}
661+
662+/* Get the PHY Identifier from the PHYSID1 & PHYSID2 MII registers */
663+static u32 asix_get_phyid(struct usbnet *dev)
664+{
665+ int phy_reg;
666+ u32 phy_id;
667+ int i;
668+
669+ /* Poll for the rare case the FW or phy isn't ready yet. */
670+ for (i = 0; i < 100; i++) {
671+ phy_reg = asix_mdio_read(dev->net, dev->mii.phy_id, MII_PHYSID1);
672+ if (phy_reg != 0 && phy_reg != 0xFFFF)
673+ break;
674+ mdelay(1);
675+ }
676+
677+ if (phy_reg <= 0 || phy_reg == 0xFFFF)
678+ return 0;
679+
680+ phy_id = (phy_reg & 0xffff) << 16;
681+
682+ phy_reg = asix_mdio_read(dev->net, dev->mii.phy_id, MII_PHYSID2);
683+ if (phy_reg < 0)
684+ return 0;
685+
686+ phy_id |= (phy_reg & 0xffff);
687+
688+ return phy_id;
689+}
690+
691+static u32 asix_get_link(struct net_device *net)
692+{
693+ struct usbnet *dev = netdev_priv(net);
694+
695+ return mii_link_ok(&dev->mii);
696+}
697+
698+static int asix_ioctl (struct net_device *net, struct ifreq *rq, int cmd)
699+{
700+ struct usbnet *dev = netdev_priv(net);
701+
702+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
703+}
704+
705+/* We need to override some ethtool_ops so we require our
706+ own structure so we don't interfere with other usbnet
707+ devices that may be connected at the same time. */
708+static const struct ethtool_ops ax88172_ethtool_ops = {
709+ .get_drvinfo = asix_get_drvinfo,
710+ .get_link = asix_get_link,
711+ .get_msglevel = usbnet_get_msglevel,
712+ .set_msglevel = usbnet_set_msglevel,
713+ .get_wol = asix_get_wol,
714+ .set_wol = asix_set_wol,
715+ .get_eeprom_len = asix_get_eeprom_len,
716+ .get_eeprom = asix_get_eeprom,
717+ .set_eeprom = asix_set_eeprom,
718+ .get_settings = usbnet_get_settings,
719+ .set_settings = usbnet_set_settings,
720+ .nway_reset = usbnet_nway_reset,
721+};
722+
723+static void ax88172_set_multicast(struct net_device *net)
724+{
725+ struct usbnet *dev = netdev_priv(net);
726+ struct asix_data *data = (struct asix_data *)&dev->data;
727+ u8 rx_ctl = 0x8c;
728+
729+ if (net->flags & IFF_PROMISC) {
730+ rx_ctl |= 0x01;
731+ } else if (net->flags & IFF_ALLMULTI ||
732+ netdev_mc_count(net) > AX_MAX_MCAST) {
733+ rx_ctl |= 0x02;
734+ } else if (netdev_mc_empty(net)) {
735+ /* just broadcast and directed */
736+ } else {
737+ /* We use the 20 byte dev->data
738+ * for our 8 byte filter buffer
739+ * to avoid allocating memory that
740+ * is tricky to free later */
741+ struct netdev_hw_addr *ha;
742+ u32 crc_bits;
743+
744+ memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
745+
746+ /* Build the multicast hash filter. */
747+ netdev_for_each_mc_addr(ha, net) {
748+ crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
749+ data->multi_filter[crc_bits >> 3] |=
750+ 1 << (crc_bits & 7);
751+ }
752+
753+ asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
754+ AX_MCAST_FILTER_SIZE, data->multi_filter);
755+
756+ rx_ctl |= 0x10;
757+ }
758+
759+ asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
760+}
761+
762+static int ax88172_link_reset(struct usbnet *dev)
763+{
764+ u8 mode;
765+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
766+
767+ mii_check_media(&dev->mii, 1, 1);
768+ mii_ethtool_gset(&dev->mii, &ecmd);
769+ mode = AX88172_MEDIUM_DEFAULT;
770+
771+ if (ecmd.duplex != DUPLEX_FULL)
772+ mode |= ~AX88172_MEDIUM_FD;
773+
774+ netdev_dbg(dev->net, "ax88172_link_reset() speed: %u duplex: %d setting mode to 0x%04x\n",
775+ ethtool_cmd_speed(&ecmd), ecmd.duplex, mode);
776+
777+ asix_write_medium_mode(dev, mode);
778+
779+ return 0;
780+}
781+
782+static const struct net_device_ops ax88172_netdev_ops = {
783+ .ndo_open = usbnet_open,
784+ .ndo_stop = usbnet_stop,
785+ .ndo_start_xmit = usbnet_start_xmit,
786+ .ndo_tx_timeout = usbnet_tx_timeout,
787+ .ndo_change_mtu = usbnet_change_mtu,
788+ .ndo_set_mac_address = eth_mac_addr,
789+ .ndo_validate_addr = eth_validate_addr,
790+ .ndo_do_ioctl = asix_ioctl,
791+ .ndo_set_rx_mode = ax88172_set_multicast,
792+};
793+
794+static int ax88172_bind(struct usbnet *dev, struct usb_interface *intf)
795+{
796+ int ret = 0;
797+ u8 buf[ETH_ALEN];
798+ int i;
799+ unsigned long gpio_bits = dev->driver_info->data;
800+
801+ usbnet_get_endpoints(dev,intf);
802+
803+ /* Toggle the GPIOs in a manufacturer/model specific way */
804+ for (i = 2; i >= 0; i--) {
805+ ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS,
806+ (gpio_bits >> (i * 8)) & 0xff, 0, 0, NULL);
807+ if (ret < 0)
808+ goto out;
809+ msleep(5);
810+ }
811+
812+ ret = asix_write_rx_ctl(dev, 0x80);
813+ if (ret < 0)
814+ goto out;
815+
816+ /* Get the MAC address */
817+ ret = asix_read_cmd(dev, AX88172_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf);
818+ if (ret < 0) {
819+ netdev_dbg(dev->net, "read AX_CMD_READ_NODE_ID failed: %d\n",
820+ ret);
821+ goto out;
822+ }
823+
824+ asix_set_netdev_dev_addr(dev, buf);
825+
826+ /* Initialize MII structure */
827+ dev->mii.dev = dev->net;
828+ dev->mii.mdio_read = asix_mdio_read;
829+ dev->mii.mdio_write = asix_mdio_write;
830+ dev->mii.phy_id_mask = 0x3f;
831+ dev->mii.reg_num_mask = 0x1f;
832+ dev->mii.phy_id = asix_get_phy_addr(dev);
833+
834+ dev->net->netdev_ops = &ax88172_netdev_ops;
835+ dev->net->ethtool_ops = &ax88172_ethtool_ops;
836+ dev->net->needed_headroom = 4; /* cf asix_tx_fixup() */
837+ dev->net->needed_tailroom = 4; /* cf asix_tx_fixup() */
838+
839+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
840+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
841+ ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
842+ mii_nway_restart(&dev->mii);
843+
844+ return 0;
845+
846+out:
847+ return ret;
848+}
849+
850+static const struct ethtool_ops ax88772_ethtool_ops = {
851+ .get_drvinfo = asix_get_drvinfo,
852+ .get_link = asix_get_link,
853+ .get_msglevel = usbnet_get_msglevel,
854+ .set_msglevel = usbnet_set_msglevel,
855+ .get_wol = asix_get_wol,
856+ .set_wol = asix_set_wol,
857+ .get_eeprom_len = asix_get_eeprom_len,
858+ .get_eeprom = asix_get_eeprom,
859+ .set_eeprom = asix_set_eeprom,
860+ .get_settings = usbnet_get_settings,
861+ .set_settings = usbnet_set_settings,
862+ .nway_reset = usbnet_nway_reset,
863+};
864+
865+static int ax88772_link_reset(struct usbnet *dev)
866+{
867+ u16 mode;
868+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
869+
870+ mii_check_media(&dev->mii, 1, 1);
871+ mii_ethtool_gset(&dev->mii, &ecmd);
872+ mode = AX88772_MEDIUM_DEFAULT;
873+
874+ if (ethtool_cmd_speed(&ecmd) != SPEED_100)
875+ mode &= ~AX_MEDIUM_PS;
876+
877+ if (ecmd.duplex != DUPLEX_FULL)
878+ mode &= ~AX_MEDIUM_FD;
879+
880+ netdev_dbg(dev->net, "ax88772_link_reset() speed: %u duplex: %d setting mode to 0x%04x\n",
881+ ethtool_cmd_speed(&ecmd), ecmd.duplex, mode);
882+
883+ asix_write_medium_mode(dev, mode);
884+
885+ return 0;
886+}
887+
888+static int ax88772_reset(struct usbnet *dev)
889+{
890+ struct asix_data *data = (struct asix_data *)&dev->data;
891+ int ret, embd_phy;
892+ u16 rx_ctl;
893+
894+ ret = asix_write_gpio(dev,
895+ AX_GPIO_RSE | AX_GPIO_GPO_2 | AX_GPIO_GPO2EN, 5);
896+ if (ret < 0)
897+ goto out;
898+
899+ embd_phy = ((asix_get_phy_addr(dev) & 0x1f) == 0x10 ? 1 : 0);
900+
901+ ret = asix_write_cmd(dev, AX_CMD_SW_PHY_SELECT, embd_phy, 0, 0, NULL);
902+ if (ret < 0) {
903+ netdev_dbg(dev->net, "Select PHY #1 failed: %d\n", ret);
904+ goto out;
905+ }
906+
907+ ret = asix_sw_reset(dev, AX_SWRESET_IPPD | AX_SWRESET_PRL);
908+ if (ret < 0)
909+ goto out;
910+
911+ msleep(150);
912+
913+ ret = asix_sw_reset(dev, AX_SWRESET_CLEAR);
914+ if (ret < 0)
915+ goto out;
916+
917+ msleep(150);
918+
919+ if (embd_phy) {
920+ ret = asix_sw_reset(dev, AX_SWRESET_IPRL);
921+ if (ret < 0)
922+ goto out;
923+ } else {
924+ ret = asix_sw_reset(dev, AX_SWRESET_PRTE);
925+ if (ret < 0)
926+ goto out;
927+ }
928+
929+ msleep(150);
930+ rx_ctl = asix_read_rx_ctl(dev);
931+ netdev_dbg(dev->net, "RX_CTL is 0x%04x after software reset\n", rx_ctl);
932+ ret = asix_write_rx_ctl(dev, 0x0000);
933+ if (ret < 0)
934+ goto out;
935+
936+ rx_ctl = asix_read_rx_ctl(dev);
937+ netdev_dbg(dev->net, "RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl);
938+
939+ ret = asix_sw_reset(dev, AX_SWRESET_PRL);
940+ if (ret < 0)
941+ goto out;
942+
943+ msleep(150);
944+
945+ ret = asix_sw_reset(dev, AX_SWRESET_IPRL | AX_SWRESET_PRL);
946+ if (ret < 0)
947+ goto out;
948+
949+ msleep(150);
950+
951+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
952+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
953+ ADVERTISE_ALL | ADVERTISE_CSMA);
954+ mii_nway_restart(&dev->mii);
955+
956+ ret = asix_write_medium_mode(dev, AX88772_MEDIUM_DEFAULT);
957+ if (ret < 0)
958+ goto out;
959+
960+ ret = asix_write_cmd(dev, AX_CMD_WRITE_IPG0,
961+ AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,
962+ AX88772_IPG2_DEFAULT, 0, NULL);
963+ if (ret < 0) {
964+ netdev_dbg(dev->net, "Write IPG,IPG1,IPG2 failed: %d\n", ret);
965+ goto out;
966+ }
967+
968+ /* Rewrite MAC address */
969+ memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN);
970+ ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
971+ data->mac_addr);
972+ if (ret < 0)
973+ goto out;
974+
975+ /* Set RX_CTL to default values with 2k buffer, and enable cactus */
976+ ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
977+ if (ret < 0)
978+ goto out;
979+
980+ rx_ctl = asix_read_rx_ctl(dev);
981+ netdev_dbg(dev->net, "RX_CTL is 0x%04x after all initializations\n",
982+ rx_ctl);
983+
984+ rx_ctl = asix_read_medium_status(dev);
985+ netdev_dbg(dev->net,
986+ "Medium Status is 0x%04x after all initializations\n",
987+ rx_ctl);
988+
989+ return 0;
990+
991+out:
992+ return ret;
993+
994+}
995+
996+static const struct net_device_ops ax88772_netdev_ops = {
997+ .ndo_open = usbnet_open,
998+ .ndo_stop = usbnet_stop,
999+ .ndo_start_xmit = usbnet_start_xmit,
1000+ .ndo_tx_timeout = usbnet_tx_timeout,
1001+ .ndo_change_mtu = usbnet_change_mtu,
1002+ .ndo_set_mac_address = asix_set_mac_address,
1003+ .ndo_validate_addr = eth_validate_addr,
1004+ .ndo_do_ioctl = asix_ioctl,
1005+ .ndo_set_rx_mode = asix_set_multicast,
1006+};
1007+
1008+static int ax88772_bind(struct usbnet *dev, struct usb_interface *intf)
1009+{
1010+ int ret, embd_phy, i;
1011+ u8 buf[ETH_ALEN];
1012+ u32 phyid;
1013+
1014+ usbnet_get_endpoints(dev,intf);
1015+
1016+ /* Get the MAC address */
1017+ if (dev->driver_info->data & FLAG_EEPROM_MAC) {
1018+ for (i = 0; i < (ETH_ALEN >> 1); i++) {
1019+ ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, 0x04 + i,
1020+ 0, 2, buf + i * 2);
1021+ if (ret < 0)
1022+ break;
1023+ }
1024+ } else {
1025+ ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID,
1026+ 0, 0, ETH_ALEN, buf);
1027+ }
1028+
1029+ if (ret < 0) {
1030+ netdev_dbg(dev->net, "Failed to read MAC address: %d\n", ret);
1031+ return ret;
1032+ }
1033+
1034+ asix_set_netdev_dev_addr(dev, buf);
1035+
1036+ /* Initialize MII structure */
1037+ dev->mii.dev = dev->net;
1038+ dev->mii.mdio_read = asix_mdio_read;
1039+ dev->mii.mdio_write = asix_mdio_write;
1040+ dev->mii.phy_id_mask = 0x1f;
1041+ dev->mii.reg_num_mask = 0x1f;
1042+ dev->mii.phy_id = asix_get_phy_addr(dev);
1043+
1044+ dev->net->netdev_ops = &ax88772_netdev_ops;
1045+ dev->net->ethtool_ops = &ax88772_ethtool_ops;
1046+ dev->net->needed_headroom = 4; /* cf asix_tx_fixup() */
1047+ dev->net->needed_tailroom = 4; /* cf asix_tx_fixup() */
1048+
1049+ embd_phy = ((dev->mii.phy_id & 0x1f) == 0x10 ? 1 : 0);
1050+
1051+ /* Reset the PHY to normal operation mode */
1052+ ret = asix_write_cmd(dev, AX_CMD_SW_PHY_SELECT, embd_phy, 0, 0, NULL);
1053+ if (ret < 0) {
1054+ netdev_dbg(dev->net, "Select PHY #1 failed: %d\n", ret);
1055+ return ret;
1056+ }
1057+
1058+ ax88772_reset(dev);
1059+
1060+ /* Read PHYID register *AFTER* the PHY was reset properly */
1061+ phyid = asix_get_phyid(dev);
1062+ netdev_dbg(dev->net, "PHYID=0x%08x\n", phyid);
1063+
1064+ /* Asix framing packs multiple eth frames into a 2K usb bulk transfer */
1065+ if (dev->driver_info->flags & FLAG_FRAMING_AX) {
1066+ /* hard_mtu is still the default - the device does not support
1067+ jumbo eth frames */
1068+ dev->rx_urb_size = 2048;
1069+ }
1070+
1071+ dev->driver_priv = kzalloc(sizeof(struct asix_common_private), GFP_KERNEL);
1072+ if (!dev->driver_priv)
1073+ return -ENOMEM;
1074+
1075+ return 0;
1076+}
1077+
1078+static void ax88772_unbind(struct usbnet *dev, struct usb_interface *intf)
1079+{
1080+ if (dev->driver_priv)
1081+ kfree(dev->driver_priv);
1082+}
1083+
1084+static const struct ethtool_ops ax88178_ethtool_ops = {
1085+ .get_drvinfo = asix_get_drvinfo,
1086+ .get_link = asix_get_link,
1087+ .get_msglevel = usbnet_get_msglevel,
1088+ .set_msglevel = usbnet_set_msglevel,
1089+ .get_wol = asix_get_wol,
1090+ .set_wol = asix_set_wol,
1091+ .get_eeprom_len = asix_get_eeprom_len,
1092+ .get_eeprom = asix_get_eeprom,
1093+ .set_eeprom = asix_set_eeprom,
1094+ .get_settings = usbnet_get_settings,
1095+ .set_settings = usbnet_set_settings,
1096+ .nway_reset = usbnet_nway_reset,
1097+};
1098+
1099+static int marvell_phy_init(struct usbnet *dev)
1100+{
1101+ struct asix_data *data = (struct asix_data *)&dev->data;
1102+ u16 reg;
1103+
1104+ netdev_dbg(dev->net, "marvell_phy_init()\n");
1105+
1106+ reg = asix_mdio_read(dev->net, dev->mii.phy_id, MII_MARVELL_STATUS);
1107+ netdev_dbg(dev->net, "MII_MARVELL_STATUS = 0x%04x\n", reg);
1108+
1109+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_MARVELL_CTRL,
1110+ MARVELL_CTRL_RXDELAY | MARVELL_CTRL_TXDELAY);
1111+
1112+ if (data->ledmode) {
1113+ reg = asix_mdio_read(dev->net, dev->mii.phy_id,
1114+ MII_MARVELL_LED_CTRL);
1115+ netdev_dbg(dev->net, "MII_MARVELL_LED_CTRL (1) = 0x%04x\n", reg);
1116+
1117+ reg &= 0xf8ff;
1118+ reg |= (1 + 0x0100);
1119+ asix_mdio_write(dev->net, dev->mii.phy_id,
1120+ MII_MARVELL_LED_CTRL, reg);
1121+
1122+ reg = asix_mdio_read(dev->net, dev->mii.phy_id,
1123+ MII_MARVELL_LED_CTRL);
1124+ netdev_dbg(dev->net, "MII_MARVELL_LED_CTRL (2) = 0x%04x\n", reg);
1125+ reg &= 0xfc0f;
1126+ }
1127+
1128+ return 0;
1129+}
1130+
1131+static int rtl8211cl_phy_init(struct usbnet *dev)
1132+{
1133+ struct asix_data *data = (struct asix_data *)&dev->data;
1134+
1135+ netdev_dbg(dev->net, "rtl8211cl_phy_init()\n");
1136+
1137+ asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0x0005);
1138+ asix_mdio_write (dev->net, dev->mii.phy_id, 0x0c, 0);
1139+ asix_mdio_write (dev->net, dev->mii.phy_id, 0x01,
1140+ asix_mdio_read (dev->net, dev->mii.phy_id, 0x01) | 0x0080);
1141+ asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0);
1142+
1143+ if (data->ledmode == 12) {
1144+ asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0x0002);
1145+ asix_mdio_write (dev->net, dev->mii.phy_id, 0x1a, 0x00cb);
1146+ asix_mdio_write (dev->net, dev->mii.phy_id, 0x1f, 0);
1147+ }
1148+
1149+ return 0;
1150+}
1151+
1152+static int marvell_led_status(struct usbnet *dev, u16 speed)
1153+{
1154+ u16 reg = asix_mdio_read(dev->net, dev->mii.phy_id, MARVELL_LED_MANUAL);
1155+
1156+ netdev_dbg(dev->net, "marvell_led_status() read 0x%04x\n", reg);
1157+
1158+ /* Clear out the center LED bits - 0x03F0 */
1159+ reg &= 0xfc0f;
1160+
1161+ switch (speed) {
1162+ case SPEED_1000:
1163+ reg |= 0x03e0;
1164+ break;
1165+ case SPEED_100:
1166+ reg |= 0x03b0;
1167+ break;
1168+ default:
1169+ reg |= 0x02f0;
1170+ }
1171+
1172+ netdev_dbg(dev->net, "marvell_led_status() writing 0x%04x\n", reg);
1173+ asix_mdio_write(dev->net, dev->mii.phy_id, MARVELL_LED_MANUAL, reg);
1174+
1175+ return 0;
1176+}
1177+
1178+static int ax88178_reset(struct usbnet *dev)
1179+{
1180+ struct asix_data *data = (struct asix_data *)&dev->data;
1181+ int ret;
1182+ __le16 eeprom;
1183+ u8 status;
1184+ int gpio0 = 0;
1185+ u32 phyid;
1186+
1187+ asix_read_cmd(dev, AX_CMD_READ_GPIOS, 0, 0, 1, &status);
1188+ netdev_dbg(dev->net, "GPIO Status: 0x%04x\n", status);
1189+
1190+ asix_write_cmd(dev, AX_CMD_WRITE_ENABLE, 0, 0, 0, NULL);
1191+ asix_read_cmd(dev, AX_CMD_READ_EEPROM, 0x0017, 0, 2, &eeprom);
1192+ asix_write_cmd(dev, AX_CMD_WRITE_DISABLE, 0, 0, 0, NULL);
1193+
1194+ netdev_dbg(dev->net, "EEPROM index 0x17 is 0x%04x\n", eeprom);
1195+
1196+ if (eeprom == cpu_to_le16(0xffff)) {
1197+ data->phymode = PHY_MODE_MARVELL;
1198+ data->ledmode = 0;
1199+ gpio0 = 1;
1200+ } else {
1201+ data->phymode = le16_to_cpu(eeprom) & 0x7F;
1202+ data->ledmode = le16_to_cpu(eeprom) >> 8;
1203+ gpio0 = (le16_to_cpu(eeprom) & 0x80) ? 0 : 1;
1204+ }
1205+ netdev_dbg(dev->net, "GPIO0: %d, PhyMode: %d\n", gpio0, data->phymode);
1206+
1207+ /* Power up external GigaPHY through AX88178 GPIO pin */
1208+ asix_write_gpio(dev, AX_GPIO_RSE | AX_GPIO_GPO_1 | AX_GPIO_GPO1EN, 40);
1209+ if ((le16_to_cpu(eeprom) >> 8) != 1) {
1210+ asix_write_gpio(dev, 0x003c, 30);
1211+ asix_write_gpio(dev, 0x001c, 300);
1212+ asix_write_gpio(dev, 0x003c, 30);
1213+ } else {
1214+ netdev_dbg(dev->net, "gpio phymode == 1 path\n");
1215+ asix_write_gpio(dev, AX_GPIO_GPO1EN, 30);
1216+ asix_write_gpio(dev, AX_GPIO_GPO1EN | AX_GPIO_GPO_1, 30);
1217+ }
1218+
1219+ /* Read PHYID register *AFTER* powering up PHY */
1220+ phyid = asix_get_phyid(dev);
1221+ netdev_dbg(dev->net, "PHYID=0x%08x\n", phyid);
1222+
1223+ /* Set AX88178 to enable MII/GMII/RGMII interface for external PHY */
1224+ asix_write_cmd(dev, AX_CMD_SW_PHY_SELECT, 0, 0, 0, NULL);
1225+
1226+ asix_sw_reset(dev, 0);
1227+ msleep(150);
1228+
1229+ asix_sw_reset(dev, AX_SWRESET_PRL | AX_SWRESET_IPPD);
1230+ msleep(150);
1231+
1232+ asix_write_rx_ctl(dev, 0);
1233+
1234+ if (data->phymode == PHY_MODE_MARVELL) {
1235+ marvell_phy_init(dev);
1236+ msleep(60);
1237+ } else if (data->phymode == PHY_MODE_RTL8211CL)
1238+ rtl8211cl_phy_init(dev);
1239+
1240+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR,
1241+ BMCR_RESET | BMCR_ANENABLE);
1242+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
1243+ ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
1244+ asix_mdio_write(dev->net, dev->mii.phy_id, MII_CTRL1000,
1245+ ADVERTISE_1000FULL);
1246+
1247+ mii_nway_restart(&dev->mii);
1248+
1249+ ret = asix_write_medium_mode(dev, AX88178_MEDIUM_DEFAULT);
1250+ if (ret < 0)
1251+ return ret;
1252+
1253+ /* Rewrite MAC address */
1254+ memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN);
1255+ ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
1256+ data->mac_addr);
1257+ if (ret < 0)
1258+ return ret;
1259+
1260+ ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
1261+ if (ret < 0)
1262+ return ret;
1263+
1264+ return 0;
1265+}
1266+
1267+static int ax88178_link_reset(struct usbnet *dev)
1268+{
1269+ u16 mode;
1270+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
1271+ struct asix_data *data = (struct asix_data *)&dev->data;
1272+ u32 speed;
1273+
1274+ netdev_dbg(dev->net, "ax88178_link_reset()\n");
1275+
1276+ mii_check_media(&dev->mii, 1, 1);
1277+ mii_ethtool_gset(&dev->mii, &ecmd);
1278+ mode = AX88178_MEDIUM_DEFAULT;
1279+ speed = ethtool_cmd_speed(&ecmd);
1280+
1281+ if (speed == SPEED_1000)
1282+ mode |= AX_MEDIUM_GM;
1283+ else if (speed == SPEED_100)
1284+ mode |= AX_MEDIUM_PS;
1285+ else
1286+ mode &= ~(AX_MEDIUM_PS | AX_MEDIUM_GM);
1287+
1288+ mode |= AX_MEDIUM_ENCK;
1289+
1290+ if (ecmd.duplex == DUPLEX_FULL)
1291+ mode |= AX_MEDIUM_FD;
1292+ else
1293+ mode &= ~AX_MEDIUM_FD;
1294+
1295+ netdev_dbg(dev->net, "ax88178_link_reset() speed: %u duplex: %d setting mode to 0x%04x\n",
1296+ speed, ecmd.duplex, mode);
1297+
1298+ asix_write_medium_mode(dev, mode);
1299+
1300+ if (data->phymode == PHY_MODE_MARVELL && data->ledmode)
1301+ marvell_led_status(dev, speed);
1302+
1303+ return 0;
1304+}
1305+
1306+static void ax88178_set_mfb(struct usbnet *dev)
1307+{
1308+ u16 mfb = AX_RX_CTL_MFB_16384;
1309+ u16 rxctl;
1310+ u16 medium;
1311+ int old_rx_urb_size = dev->rx_urb_size;
1312+
1313+ if (dev->hard_mtu < 2048) {
1314+ dev->rx_urb_size = 2048;
1315+ mfb = AX_RX_CTL_MFB_2048;
1316+ } else if (dev->hard_mtu < 4096) {
1317+ dev->rx_urb_size = 4096;
1318+ mfb = AX_RX_CTL_MFB_4096;
1319+ } else if (dev->hard_mtu < 8192) {
1320+ dev->rx_urb_size = 8192;
1321+ mfb = AX_RX_CTL_MFB_8192;
1322+ } else if (dev->hard_mtu < 16384) {
1323+ dev->rx_urb_size = 16384;
1324+ mfb = AX_RX_CTL_MFB_16384;
1325+ }
1326+
1327+ rxctl = asix_read_rx_ctl(dev);
1328+ asix_write_rx_ctl(dev, (rxctl & ~AX_RX_CTL_MFB_16384) | mfb);
1329+
1330+ medium = asix_read_medium_status(dev);
1331+ if (dev->net->mtu > 1500)
1332+ medium |= AX_MEDIUM_JFE;
1333+ else
1334+ medium &= ~AX_MEDIUM_JFE;
1335+ asix_write_medium_mode(dev, medium);
1336+
1337+ if (dev->rx_urb_size > old_rx_urb_size)
1338+ usbnet_unlink_rx_urbs(dev);
1339+}
1340+
1341+static int ax88178_change_mtu(struct net_device *net, int new_mtu)
1342+{
1343+ struct usbnet *dev = netdev_priv(net);
1344+ int ll_mtu = new_mtu + net->hard_header_len + 4;
1345+
1346+ netdev_dbg(dev->net, "ax88178_change_mtu() new_mtu=%d\n", new_mtu);
1347+
1348+ if (new_mtu <= 0 || ll_mtu > 16384)
1349+ return -EINVAL;
1350+
1351+ if ((ll_mtu % dev->maxpacket) == 0)
1352+ return -EDOM;
1353+
1354+ net->mtu = new_mtu;
1355+ dev->hard_mtu = net->mtu + net->hard_header_len;
1356+ ax88178_set_mfb(dev);
1357+
1358+ /* max qlen depend on hard_mtu and rx_urb_size */
1359+ usbnet_update_max_qlen(dev);
1360+
1361+ return 0;
1362+}
1363+
1364+static const struct net_device_ops ax88178_netdev_ops = {
1365+ .ndo_open = usbnet_open,
1366+ .ndo_stop = usbnet_stop,
1367+ .ndo_start_xmit = usbnet_start_xmit,
1368+ .ndo_tx_timeout = usbnet_tx_timeout,
1369+ .ndo_set_mac_address = asix_set_mac_address,
1370+ .ndo_validate_addr = eth_validate_addr,
1371+ .ndo_set_rx_mode = asix_set_multicast,
1372+ .ndo_do_ioctl = asix_ioctl,
1373+ .ndo_change_mtu = ax88178_change_mtu,
1374+};
1375+
1376+static int ax88178_bind(struct usbnet *dev, struct usb_interface *intf)
1377+{
1378+ int ret;
1379+ u8 buf[ETH_ALEN];
1380+
1381+ usbnet_get_endpoints(dev,intf);
1382+
1383+ /* Get the MAC address */
1384+ ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf);
1385+ if (ret < 0) {
1386+ netdev_dbg(dev->net, "Failed to read MAC address: %d\n", ret);
1387+ return ret;
1388+ }
1389+
1390+ asix_set_netdev_dev_addr(dev, buf);
1391+
1392+ /* Initialize MII structure */
1393+ dev->mii.dev = dev->net;
1394+ dev->mii.mdio_read = asix_mdio_read;
1395+ dev->mii.mdio_write = asix_mdio_write;
1396+ dev->mii.phy_id_mask = 0x1f;
1397+ dev->mii.reg_num_mask = 0xff;
1398+ dev->mii.supports_gmii = 1;
1399+ dev->mii.phy_id = asix_get_phy_addr(dev);
1400+
1401+ dev->net->netdev_ops = &ax88178_netdev_ops;
1402+ dev->net->ethtool_ops = &ax88178_ethtool_ops;
1403+
1404+ /* Blink LEDS so users know driver saw dongle */
1405+ asix_sw_reset(dev, 0);
1406+ msleep(150);
1407+
1408+ asix_sw_reset(dev, AX_SWRESET_PRL | AX_SWRESET_IPPD);
1409+ msleep(150);
1410+
1411+ /* Asix framing packs multiple eth frames into a 2K usb bulk transfer */
1412+ if (dev->driver_info->flags & FLAG_FRAMING_AX) {
1413+ /* hard_mtu is still the default - the device does not support
1414+ jumbo eth frames */
1415+ dev->rx_urb_size = 2048;
1416+ }
1417+
1418+ dev->driver_priv = kzalloc(sizeof(struct asix_common_private), GFP_KERNEL);
1419+ if (!dev->driver_priv)
1420+ return -ENOMEM;
1421+
1422+ return 0;
1423+}
1424+
1425+static const struct driver_info ax8817x_info = {
1426+ .description = "ASIX AX8817x USB 2.0 Ethernet",
1427+ .bind = ax88172_bind,
1428+ .status = asix_status,
1429+ .link_reset = ax88172_link_reset,
1430+ .reset = ax88172_link_reset,
1431+ .flags = FLAG_ETHER | FLAG_LINK_INTR,
1432+ .data = 0x00130103,
1433+};
1434+
1435+static const struct driver_info dlink_dub_e100_info = {
1436+ .description = "DLink DUB-E100 USB Ethernet",
1437+ .bind = ax88172_bind,
1438+ .status = asix_status,
1439+ .link_reset = ax88172_link_reset,
1440+ .reset = ax88172_link_reset,
1441+ .flags = FLAG_ETHER | FLAG_LINK_INTR,
1442+ .data = 0x009f9d9f,
1443+};
1444+
1445+static const struct driver_info netgear_fa120_info = {
1446+ .description = "Netgear FA-120 USB Ethernet",
1447+ .bind = ax88172_bind,
1448+ .status = asix_status,
1449+ .link_reset = ax88172_link_reset,
1450+ .reset = ax88172_link_reset,
1451+ .flags = FLAG_ETHER | FLAG_LINK_INTR,
1452+ .data = 0x00130103,
1453+};
1454+
1455+static const struct driver_info hawking_uf200_info = {
1456+ .description = "Hawking UF200 USB Ethernet",
1457+ .bind = ax88172_bind,
1458+ .status = asix_status,
1459+ .link_reset = ax88172_link_reset,
1460+ .reset = ax88172_link_reset,
1461+ .flags = FLAG_ETHER | FLAG_LINK_INTR,
1462+ .data = 0x001f1d1f,
1463+};
1464+
1465+static const struct driver_info ax88772_info = {
1466+ .description = "ASIX AX88772 USB 2.0 Ethernet",
1467+ .bind = ax88772_bind,
1468+ .unbind = ax88772_unbind,
1469+ .status = asix_status,
1470+ .link_reset = ax88772_link_reset,
1471+ .reset = ax88772_link_reset,
1472+ .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR | FLAG_MULTI_PACKET,
1473+ .rx_fixup = asix_rx_fixup_common,
1474+ .tx_fixup = asix_tx_fixup,
1475+};
1476+
1477+static const struct driver_info ax88772b_info = {
1478+ .description = "ASIX AX88772B USB 2.0 Ethernet",
1479+ .bind = ax88772_bind,
1480+ .unbind = ax88772_unbind,
1481+ .status = asix_status,
1482+ .link_reset = ax88772_link_reset,
1483+ .reset = ax88772_reset,
1484+ .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR |
1485+ FLAG_MULTI_PACKET,
1486+ .rx_fixup = asix_rx_fixup_common,
1487+ .tx_fixup = asix_tx_fixup,
1488+ .data = FLAG_EEPROM_MAC,
1489+};
1490+
1491+static const struct driver_info ax88178_info = {
1492+ .description = "ASIX AX88178 USB 2.0 Ethernet",
1493+ .bind = ax88178_bind,
1494+ .unbind = ax88772_unbind,
1495+ .status = asix_status,
1496+ .link_reset = ax88178_link_reset,
1497+ .reset = ax88178_reset,
1498+ .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR |
1499+ FLAG_MULTI_PACKET,
1500+ .rx_fixup = asix_rx_fixup_common,
1501+ .tx_fixup = asix_tx_fixup,
1502+};
1503+
1504+/*
1505+ * USBLINK 20F9 "USB 2.0 LAN" USB ethernet adapter, typically found in
1506+ * no-name packaging.
1507+ * USB device strings are:
1508+ * 1: Manufacturer: USBLINK
1509+ * 2: Product: HG20F9 USB2.0
1510+ * 3: Serial: 000003
1511+ * Appears to be compatible with Asix 88772B.
1512+ */
1513+static const struct driver_info hg20f9_info = {
1514+ .description = "HG20F9 USB 2.0 Ethernet",
1515+ .bind = ax88772_bind,
1516+ .unbind = ax88772_unbind,
1517+ .status = asix_status,
1518+ .link_reset = ax88772_link_reset,
1519+ .reset = ax88772_reset,
1520+ .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR |
1521+ FLAG_MULTI_PACKET,
1522+ .rx_fixup = asix_rx_fixup_common,
1523+ .tx_fixup = asix_tx_fixup,
1524+ .data = FLAG_EEPROM_MAC,
1525+};
1526+
1527+static const struct usb_device_id products [] = {
1528+{
1529+ // Linksys USB200M
1530+ USB_DEVICE (0x077b, 0x2226),
1531+ .driver_info = (unsigned long) &ax8817x_info,
1532+}, {
1533+ // Netgear FA120
1534+ USB_DEVICE (0x0846, 0x1040),
1535+ .driver_info = (unsigned long) &netgear_fa120_info,
1536+}, {
1537+ // DLink DUB-E100
1538+ USB_DEVICE (0x2001, 0x1a00),
1539+ .driver_info = (unsigned long) &dlink_dub_e100_info,
1540+}, {
1541+ // Intellinet, ST Lab USB Ethernet
1542+ USB_DEVICE (0x0b95, 0x1720),
1543+ .driver_info = (unsigned long) &ax8817x_info,
1544+}, {
1545+ // Hawking UF200, TrendNet TU2-ET100
1546+ USB_DEVICE (0x07b8, 0x420a),
1547+ .driver_info = (unsigned long) &hawking_uf200_info,
1548+}, {
1549+ // Billionton Systems, USB2AR
1550+ USB_DEVICE (0x08dd, 0x90ff),
1551+ .driver_info = (unsigned long) &ax8817x_info,
1552+}, {
1553+ // ATEN UC210T
1554+ USB_DEVICE (0x0557, 0x2009),
1555+ .driver_info = (unsigned long) &ax8817x_info,
1556+}, {
1557+ // Buffalo LUA-U2-KTX
1558+ USB_DEVICE (0x0411, 0x003d),
1559+ .driver_info = (unsigned long) &ax8817x_info,
1560+}, {
1561+ // Buffalo LUA-U2-GT 10/100/1000
1562+ USB_DEVICE (0x0411, 0x006e),
1563+ .driver_info = (unsigned long) &ax88178_info,
1564+}, {
1565+ // Sitecom LN-029 "USB 2.0 10/100 Ethernet adapter"
1566+ USB_DEVICE (0x6189, 0x182d),
1567+ .driver_info = (unsigned long) &ax8817x_info,
1568+}, {
1569+ // Sitecom LN-031 "USB 2.0 10/100/1000 Ethernet adapter"
1570+ USB_DEVICE (0x0df6, 0x0056),
1571+ .driver_info = (unsigned long) &ax88178_info,
1572+}, {
1573+ // corega FEther USB2-TX
1574+ USB_DEVICE (0x07aa, 0x0017),
1575+ .driver_info = (unsigned long) &ax8817x_info,
1576+}, {
1577+ // Surecom EP-1427X-2
1578+ USB_DEVICE (0x1189, 0x0893),
1579+ .driver_info = (unsigned long) &ax8817x_info,
1580+}, {
1581+ // goodway corp usb gwusb2e
1582+ USB_DEVICE (0x1631, 0x6200),
1583+ .driver_info = (unsigned long) &ax8817x_info,
1584+}, {
1585+ // JVC MP-PRX1 Port Replicator
1586+ USB_DEVICE (0x04f1, 0x3008),
1587+ .driver_info = (unsigned long) &ax8817x_info,
1588+}, {
1589+ // Lenovo U2L100P 10/100
1590+ USB_DEVICE (0x17ef, 0x7203),
1591+ .driver_info = (unsigned long) &ax88772_info,
1592+}, {
1593+ // ASIX AX88772B 10/100
1594+ USB_DEVICE (0x0b95, 0x772b),
1595+ .driver_info = (unsigned long) &ax88772b_info,
1596+}, {
1597+ // ASIX AX88772 10/100
1598+ USB_DEVICE (0x0b95, 0x7720),
1599+ .driver_info = (unsigned long) &ax88772_info,
1600+}, {
1601+ // ASIX AX88178 10/100/1000
1602+ USB_DEVICE (0x0b95, 0x1780),
1603+ .driver_info = (unsigned long) &ax88178_info,
1604+}, {
1605+ // Logitec LAN-GTJ/U2A
1606+ USB_DEVICE (0x0789, 0x0160),
1607+ .driver_info = (unsigned long) &ax88178_info,
1608+}, {
1609+ // Linksys USB200M Rev 2
1610+ USB_DEVICE (0x13b1, 0x0018),
1611+ .driver_info = (unsigned long) &ax88772_info,
1612+}, {
1613+ // 0Q0 cable ethernet
1614+ USB_DEVICE (0x1557, 0x7720),
1615+ .driver_info = (unsigned long) &ax88772_info,
1616+}, {
1617+ // DLink DUB-E100 H/W Ver B1
1618+ USB_DEVICE (0x07d1, 0x3c05),
1619+ .driver_info = (unsigned long) &ax88772_info,
1620+}, {
1621+ // DLink DUB-E100 H/W Ver B1 Alternate
1622+ USB_DEVICE (0x2001, 0x3c05),
1623+ .driver_info = (unsigned long) &ax88772_info,
1624+}, {
1625+ // DLink DUB-E100 H/W Ver C1
1626+ USB_DEVICE (0x2001, 0x1a02),
1627+ .driver_info = (unsigned long) &ax88772_info,
1628+}, {
1629+ // Linksys USB1000
1630+ USB_DEVICE (0x1737, 0x0039),
1631+ .driver_info = (unsigned long) &ax88178_info,
1632+}, {
1633+ // IO-DATA ETG-US2
1634+ USB_DEVICE (0x04bb, 0x0930),
1635+ .driver_info = (unsigned long) &ax88178_info,
1636+}, {
1637+ // Belkin F5D5055
1638+ USB_DEVICE(0x050d, 0x5055),
1639+ .driver_info = (unsigned long) &ax88178_info,
1640+}, {
1641+ // Apple USB Ethernet Adapter
1642+ USB_DEVICE(0x05ac, 0x1402),
1643+ .driver_info = (unsigned long) &ax88772_info,
1644+}, {
1645+ // Cables-to-Go USB Ethernet Adapter
1646+ USB_DEVICE(0x0b95, 0x772a),
1647+ .driver_info = (unsigned long) &ax88772_info,
1648+}, {
1649+ // ABOCOM for pci
1650+ USB_DEVICE(0x14ea, 0xab11),
1651+ .driver_info = (unsigned long) &ax88178_info,
1652+}, {
1653+ // ASIX 88772a
1654+ USB_DEVICE(0x0db0, 0xa877),
1655+ .driver_info = (unsigned long) &ax88772_info,
1656+}, {
1657+ // Asus USB Ethernet Adapter
1658+ USB_DEVICE (0x0b95, 0x7e2b),
1659+ .driver_info = (unsigned long) &ax88772_info,
1660+}, {
1661+ /* ASIX 88172a demo board */
1662+ USB_DEVICE(0x0b95, 0x172a),
1663+ .driver_info = (unsigned long) &ax88172a_info,
1664+}, {
1665+ /*
1666+ * USBLINK HG20F9 "USB 2.0 LAN"
1667+ * Appears to have gazumped Linksys's manufacturer ID but
1668+ * doesn't (yet) conflict with any known Linksys product.
1669+ */
1670+ USB_DEVICE(0x066b, 0x20f9),
1671+ .driver_info = (unsigned long) &hg20f9_info,
1672+},
1673+ { }, // END
1674+};
1675+MODULE_DEVICE_TABLE(usb, products);
1676+
1677+static struct usb_driver asix_driver = {
1678+ .name = DRIVER_NAME,
1679+ .id_table = products,
1680+ .probe = usbnet_probe,
1681+ .suspend = usbnet_suspend,
1682+ .resume = usbnet_resume,
1683+ .disconnect = usbnet_disconnect,
1684+ .supports_autosuspend = 1,
1685+ .disable_hub_initiated_lpm = 1,
1686+};
1687+
1688+module_usb_driver(asix_driver);
1689+
1690+MODULE_AUTHOR("David Hollis");
1691+MODULE_VERSION(DRIVER_VERSION);
1692+MODULE_DESCRIPTION("ASIX AX8817X based USB 2.0 Ethernet Devices");
1693+MODULE_LICENSE("GPL");
1694+
1695diff -Naur backports-3.18.1-1.org/drivers/net/usb/asix.h backports-3.18.1-1/drivers/net/usb/asix.h
1696--- backports-3.18.1-1.org/drivers/net/usb/asix.h 1970-01-01 01:00:00.000000000 +0100
1697+++ backports-3.18.1-1/drivers/net/usb/asix.h 2014-12-16 18:39:45.000000000 +0100
1698@@ -0,0 +1,234 @@
1699+/*
1700+ * ASIX AX8817X based USB 2.0 Ethernet Devices
1701+ * Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
1702+ * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
1703+ * Copyright (C) 2006 James Painter <jamie.painter@iname.com>
1704+ * Copyright (c) 2002-2003 TiVo Inc.
1705+ *
1706+ * This program is free software; you can redistribute it and/or modify
1707+ * it under the terms of the GNU General Public License as published by
1708+ * the Free Software Foundation; either version 2 of the License, or
1709+ * (at your option) any later version.
1710+ *
1711+ * This program is distributed in the hope that it will be useful,
1712+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
1713+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1714+ * GNU General Public License for more details.
1715+ *
1716+ * You should have received a copy of the GNU General Public License
1717+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
1718+ */
1719+
1720+#ifndef _ASIX_H
1721+#define _ASIX_H
1722+
1723+// #define DEBUG // error path messages, extra info
1724+// #define VERBOSE // more; success messages
1725+
1726+#include <linux/module.h>
1727+#include <linux/kmod.h>
1728+#include <linux/netdevice.h>
1729+#include <linux/etherdevice.h>
1730+#include <linux/ethtool.h>
1731+#include <linux/workqueue.h>
1732+#include <linux/mii.h>
1733+#include <linux/usb.h>
1734+#include <linux/crc32.h>
1735+#include <linux/usb/usbnet.h>
1736+#include <linux/slab.h>
1737+#include <linux/if_vlan.h>
1738+
1739+#define DRIVER_VERSION "22-Dec-2011"
1740+#define DRIVER_NAME "asix"
1741+
1742+/* ASIX AX8817X based USB 2.0 Ethernet Devices */
1743+
1744+#define AX_CMD_SET_SW_MII 0x06
1745+#define AX_CMD_READ_MII_REG 0x07
1746+#define AX_CMD_WRITE_MII_REG 0x08
1747+#define AX_CMD_SET_HW_MII 0x0a
1748+#define AX_CMD_READ_EEPROM 0x0b
1749+#define AX_CMD_WRITE_EEPROM 0x0c
1750+#define AX_CMD_WRITE_ENABLE 0x0d
1751+#define AX_CMD_WRITE_DISABLE 0x0e
1752+#define AX_CMD_READ_RX_CTL 0x0f
1753+#define AX_CMD_WRITE_RX_CTL 0x10
1754+#define AX_CMD_READ_IPG012 0x11
1755+#define AX_CMD_WRITE_IPG0 0x12
1756+#define AX_CMD_WRITE_IPG1 0x13
1757+#define AX_CMD_READ_NODE_ID 0x13
1758+#define AX_CMD_WRITE_NODE_ID 0x14
1759+#define AX_CMD_WRITE_IPG2 0x14
1760+#define AX_CMD_WRITE_MULTI_FILTER 0x16
1761+#define AX88172_CMD_READ_NODE_ID 0x17
1762+#define AX_CMD_READ_PHY_ID 0x19
1763+#define AX_CMD_READ_MEDIUM_STATUS 0x1a
1764+#define AX_CMD_WRITE_MEDIUM_MODE 0x1b
1765+#define AX_CMD_READ_MONITOR_MODE 0x1c
1766+#define AX_CMD_WRITE_MONITOR_MODE 0x1d
1767+#define AX_CMD_READ_GPIOS 0x1e
1768+#define AX_CMD_WRITE_GPIOS 0x1f
1769+#define AX_CMD_SW_RESET 0x20
1770+#define AX_CMD_SW_PHY_STATUS 0x21
1771+#define AX_CMD_SW_PHY_SELECT 0x22
1772+
1773+#define AX_PHY_SELECT_MASK (BIT(3) | BIT(2))
1774+#define AX_PHY_SELECT_INTERNAL 0
1775+#define AX_PHY_SELECT_EXTERNAL BIT(2)
1776+
1777+#define AX_MONITOR_MODE 0x01
1778+#define AX_MONITOR_LINK 0x02
1779+#define AX_MONITOR_MAGIC 0x04
1780+#define AX_MONITOR_HSFS 0x10
1781+
1782+/* AX88172 Medium Status Register values */
1783+#define AX88172_MEDIUM_FD 0x02
1784+#define AX88172_MEDIUM_TX 0x04
1785+#define AX88172_MEDIUM_FC 0x10
1786+#define AX88172_MEDIUM_DEFAULT \
1787+ ( AX88172_MEDIUM_FD | AX88172_MEDIUM_TX | AX88172_MEDIUM_FC )
1788+
1789+#define AX_MCAST_FILTER_SIZE 8
1790+#define AX_MAX_MCAST 64
1791+
1792+#define AX_SWRESET_CLEAR 0x00
1793+#define AX_SWRESET_RR 0x01
1794+#define AX_SWRESET_RT 0x02
1795+#define AX_SWRESET_PRTE 0x04
1796+#define AX_SWRESET_PRL 0x08
1797+#define AX_SWRESET_BZ 0x10
1798+#define AX_SWRESET_IPRL 0x20
1799+#define AX_SWRESET_IPPD 0x40
1800+
1801+#define AX88772_IPG0_DEFAULT 0x15
1802+#define AX88772_IPG1_DEFAULT 0x0c
1803+#define AX88772_IPG2_DEFAULT 0x12
1804+
1805+/* AX88772 & AX88178 Medium Mode Register */
1806+#define AX_MEDIUM_PF 0x0080
1807+#define AX_MEDIUM_JFE 0x0040
1808+#define AX_MEDIUM_TFC 0x0020
1809+#define AX_MEDIUM_RFC 0x0010
1810+#define AX_MEDIUM_ENCK 0x0008
1811+#define AX_MEDIUM_AC 0x0004
1812+#define AX_MEDIUM_FD 0x0002
1813+#define AX_MEDIUM_GM 0x0001
1814+#define AX_MEDIUM_SM 0x1000
1815+#define AX_MEDIUM_SBP 0x0800
1816+#define AX_MEDIUM_PS 0x0200
1817+#define AX_MEDIUM_RE 0x0100
1818+
1819+#define AX88178_MEDIUM_DEFAULT \
1820+ (AX_MEDIUM_PS | AX_MEDIUM_FD | AX_MEDIUM_AC | \
1821+ AX_MEDIUM_RFC | AX_MEDIUM_TFC | AX_MEDIUM_JFE | \
1822+ AX_MEDIUM_RE)
1823+
1824+#define AX88772_MEDIUM_DEFAULT \
1825+ (AX_MEDIUM_FD | AX_MEDIUM_RFC | \
1826+ AX_MEDIUM_TFC | AX_MEDIUM_PS | \
1827+ AX_MEDIUM_AC | AX_MEDIUM_RE)
1828+
1829+/* AX88772 & AX88178 RX_CTL values */
1830+#define AX_RX_CTL_SO 0x0080
1831+#define AX_RX_CTL_AP 0x0020
1832+#define AX_RX_CTL_AM 0x0010
1833+#define AX_RX_CTL_AB 0x0008
1834+#define AX_RX_CTL_SEP 0x0004
1835+#define AX_RX_CTL_AMALL 0x0002
1836+#define AX_RX_CTL_PRO 0x0001
1837+#define AX_RX_CTL_MFB_2048 0x0000
1838+#define AX_RX_CTL_MFB_4096 0x0100
1839+#define AX_RX_CTL_MFB_8192 0x0200
1840+#define AX_RX_CTL_MFB_16384 0x0300
1841+
1842+#define AX_DEFAULT_RX_CTL (AX_RX_CTL_SO | AX_RX_CTL_AB)
1843+
1844+/* GPIO 0 .. 2 toggles */
1845+#define AX_GPIO_GPO0EN 0x01 /* GPIO0 Output enable */
1846+#define AX_GPIO_GPO_0 0x02 /* GPIO0 Output value */
1847+#define AX_GPIO_GPO1EN 0x04 /* GPIO1 Output enable */
1848+#define AX_GPIO_GPO_1 0x08 /* GPIO1 Output value */
1849+#define AX_GPIO_GPO2EN 0x10 /* GPIO2 Output enable */
1850+#define AX_GPIO_GPO_2 0x20 /* GPIO2 Output value */
1851+#define AX_GPIO_RESERVED 0x40 /* Reserved */
1852+#define AX_GPIO_RSE 0x80 /* Reload serial EEPROM */
1853+
1854+#define AX_EEPROM_MAGIC 0xdeadbeef
1855+#define AX_EEPROM_LEN 0x200
1856+
1857+/* This structure cannot exceed sizeof(unsigned long [5]) AKA 20 bytes */
1858+struct asix_data {
1859+ u8 multi_filter[AX_MCAST_FILTER_SIZE];
1860+ u8 mac_addr[ETH_ALEN];
1861+ u8 phymode;
1862+ u8 ledmode;
1863+ u8 res;
1864+};
1865+
1866+struct asix_rx_fixup_info {
1867+ struct sk_buff *ax_skb;
1868+ u32 header;
1869+ u16 size;
1870+ bool split_head;
1871+};
1872+
1873+struct asix_common_private {
1874+ struct asix_rx_fixup_info rx_fixup_info;
1875+};
1876+
1877+extern const struct driver_info ax88172a_info;
1878+
1879+/* ASIX specific flags */
1880+#define FLAG_EEPROM_MAC (1UL << 0) /* init device MAC from eeprom */
1881+
1882+int asix_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
1883+ u16 size, void *data);
1884+
1885+int asix_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
1886+ u16 size, void *data);
1887+
1888+void asix_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value,
1889+ u16 index, u16 size, void *data);
1890+
1891+int asix_rx_fixup_internal(struct usbnet *dev, struct sk_buff *skb,
1892+ struct asix_rx_fixup_info *rx);
1893+int asix_rx_fixup_common(struct usbnet *dev, struct sk_buff *skb);
1894+
1895+struct sk_buff *asix_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
1896+ gfp_t flags);
1897+
1898+int asix_set_sw_mii(struct usbnet *dev);
1899+int asix_set_hw_mii(struct usbnet *dev);
1900+
1901+int asix_read_phy_addr(struct usbnet *dev, int internal);
1902+int asix_get_phy_addr(struct usbnet *dev);
1903+
1904+int asix_sw_reset(struct usbnet *dev, u8 flags);
1905+
1906+u16 asix_read_rx_ctl(struct usbnet *dev);
1907+int asix_write_rx_ctl(struct usbnet *dev, u16 mode);
1908+
1909+u16 asix_read_medium_status(struct usbnet *dev);
1910+int asix_write_medium_mode(struct usbnet *dev, u16 mode);
1911+
1912+int asix_write_gpio(struct usbnet *dev, u16 value, int sleep);
1913+
1914+void asix_set_multicast(struct net_device *net);
1915+
1916+int asix_mdio_read(struct net_device *netdev, int phy_id, int loc);
1917+void asix_mdio_write(struct net_device *netdev, int phy_id, int loc, int val);
1918+
1919+void asix_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo);
1920+int asix_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo);
1921+
1922+int asix_get_eeprom_len(struct net_device *net);
1923+int asix_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
1924+ u8 *data);
1925+int asix_set_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
1926+ u8 *data);
1927+
1928+void asix_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info);
1929+
1930+int asix_set_mac_address(struct net_device *net, void *p);
1931+
1932+#endif /* _ASIX_H */
1933diff -Naur backports-3.18.1-1.org/drivers/net/usb/ax88172a.c backports-3.18.1-1/drivers/net/usb/ax88172a.c
1934--- backports-3.18.1-1.org/drivers/net/usb/ax88172a.c 1970-01-01 01:00:00.000000000 +0100
1935+++ backports-3.18.1-1/drivers/net/usb/ax88172a.c 2014-12-16 18:39:45.000000000 +0100
1936@@ -0,0 +1,422 @@
1937+/*
1938+ * ASIX AX88172A based USB 2.0 Ethernet Devices
1939+ * Copyright (C) 2012 OMICRON electronics GmbH
1940+ *
1941+ * Supports external PHYs via phylib. Based on the driver for the
1942+ * AX88772. Original copyrights follow:
1943+ *
1944+ * Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
1945+ * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
1946+ * Copyright (C) 2006 James Painter <jamie.painter@iname.com>
1947+ * Copyright (c) 2002-2003 TiVo Inc.
1948+ *
1949+ * This program is free software; you can redistribute it and/or modify
1950+ * it under the terms of the GNU General Public License as published by
1951+ * the Free Software Foundation; either version 2 of the License, or
1952+ * (at your option) any later version.
1953+ *
1954+ * This program is distributed in the hope that it will be useful,
1955+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
1956+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1957+ * GNU General Public License for more details.
1958+ *
1959+ * You should have received a copy of the GNU General Public License
1960+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
1961+ */
1962+
1963+#include "asix.h"
1964+#include <linux/phy.h>
1965+
1966+struct ax88172a_private {
1967+ struct mii_bus *mdio;
1968+ struct phy_device *phydev;
1969+ char phy_name[20];
1970+ u16 phy_addr;
1971+ u16 oldmode;
1972+ int use_embdphy;
1973+ struct asix_rx_fixup_info rx_fixup_info;
1974+};
1975+
1976+/* MDIO read and write wrappers for phylib */
1977+static int asix_mdio_bus_read(struct mii_bus *bus, int phy_id, int regnum)
1978+{
1979+ return asix_mdio_read(((struct usbnet *)bus->priv)->net, phy_id,
1980+ regnum);
1981+}
1982+
1983+static int asix_mdio_bus_write(struct mii_bus *bus, int phy_id, int regnum,
1984+ u16 val)
1985+{
1986+ asix_mdio_write(((struct usbnet *)bus->priv)->net, phy_id, regnum, val);
1987+ return 0;
1988+}
1989+
1990+static int ax88172a_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
1991+{
1992+ if (!netif_running(net))
1993+ return -EINVAL;
1994+
1995+ if (!net->phydev)
1996+ return -ENODEV;
1997+
1998+ return phy_mii_ioctl(net->phydev, rq, cmd);
1999+}
2000+
2001+/* set MAC link settings according to information from phylib */
2002+static void ax88172a_adjust_link(struct net_device *netdev)
2003+{
2004+ struct phy_device *phydev = netdev->phydev;
2005+ struct usbnet *dev = netdev_priv(netdev);
2006+ struct ax88172a_private *priv = dev->driver_priv;
2007+ u16 mode = 0;
2008+
2009+ if (phydev->link) {
2010+ mode = AX88772_MEDIUM_DEFAULT;
2011+
2012+ if (phydev->duplex == DUPLEX_HALF)
2013+ mode &= ~AX_MEDIUM_FD;
2014+
2015+ if (phydev->speed != SPEED_100)
2016+ mode &= ~AX_MEDIUM_PS;
2017+ }
2018+
2019+ if (mode != priv->oldmode) {
2020+ asix_write_medium_mode(dev, mode);
2021+ priv->oldmode = mode;
2022+ netdev_dbg(netdev, "speed %u duplex %d, setting mode to 0x%04x\n",
2023+ phydev->speed, phydev->duplex, mode);
2024+ phy_print_status(phydev);
2025+ }
2026+}
2027+
2028+static void ax88172a_status(struct usbnet *dev, struct urb *urb)
2029+{
2030+ /* link changes are detected by polling the phy */
2031+}
2032+
2033+/* use phylib infrastructure */
2034+static int ax88172a_init_mdio(struct usbnet *dev)
2035+{
2036+ struct ax88172a_private *priv = dev->driver_priv;
2037+ int ret, i;
2038+
2039+ priv->mdio = mdiobus_alloc();
2040+ if (!priv->mdio) {
2041+ netdev_err(dev->net, "Could not allocate MDIO bus\n");
2042+ return -ENOMEM;
2043+ }
2044+
2045+ priv->mdio->priv = (void *)dev;
2046+ priv->mdio->read = &asix_mdio_bus_read;
2047+ priv->mdio->write = &asix_mdio_bus_write;
2048+ priv->mdio->name = "Asix MDIO Bus";
2049+ /* mii bus name is usb-<usb bus number>-<usb device number> */
2050+ snprintf(priv->mdio->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
2051+ dev->udev->bus->busnum, dev->udev->devnum);
2052+
2053+ priv->mdio->irq = kzalloc(sizeof(int) * PHY_MAX_ADDR, GFP_KERNEL);
2054+ if (!priv->mdio->irq) {
2055+ ret = -ENOMEM;
2056+ goto mfree;
2057+ }
2058+ for (i = 0; i < PHY_MAX_ADDR; i++)
2059+ priv->mdio->irq[i] = PHY_POLL;
2060+
2061+ ret = mdiobus_register(priv->mdio);
2062+ if (ret) {
2063+ netdev_err(dev->net, "Could not register MDIO bus\n");
2064+ goto ifree;
2065+ }
2066+
2067+ netdev_info(dev->net, "registered mdio bus %s\n", priv->mdio->id);
2068+ return 0;
2069+
2070+ifree:
2071+ kfree(priv->mdio->irq);
2072+mfree:
2073+ mdiobus_free(priv->mdio);
2074+ return ret;
2075+}
2076+
2077+static void ax88172a_remove_mdio(struct usbnet *dev)
2078+{
2079+ struct ax88172a_private *priv = dev->driver_priv;
2080+
2081+ netdev_info(dev->net, "deregistering mdio bus %s\n", priv->mdio->id);
2082+ mdiobus_unregister(priv->mdio);
2083+ kfree(priv->mdio->irq);
2084+ mdiobus_free(priv->mdio);
2085+}
2086+
2087+static const struct net_device_ops ax88172a_netdev_ops = {
2088+ .ndo_open = usbnet_open,
2089+ .ndo_stop = usbnet_stop,
2090+ .ndo_start_xmit = usbnet_start_xmit,
2091+ .ndo_tx_timeout = usbnet_tx_timeout,
2092+ .ndo_change_mtu = usbnet_change_mtu,
2093+ .ndo_set_mac_address = asix_set_mac_address,
2094+ .ndo_validate_addr = eth_validate_addr,
2095+ .ndo_do_ioctl = ax88172a_ioctl,
2096+ .ndo_set_rx_mode = asix_set_multicast,
2097+};
2098+
2099+static int ax88172a_get_settings(struct net_device *net,
2100+ struct ethtool_cmd *cmd)
2101+{
2102+ if (!net->phydev)
2103+ return -ENODEV;
2104+
2105+ return phy_ethtool_gset(net->phydev, cmd);
2106+}
2107+
2108+static int ax88172a_set_settings(struct net_device *net,
2109+ struct ethtool_cmd *cmd)
2110+{
2111+ if (!net->phydev)
2112+ return -ENODEV;
2113+
2114+ return phy_ethtool_sset(net->phydev, cmd);
2115+}
2116+
2117+static int ax88172a_nway_reset(struct net_device *net)
2118+{
2119+ if (!net->phydev)
2120+ return -ENODEV;
2121+
2122+ return phy_start_aneg(net->phydev);
2123+}
2124+
2125+static const struct ethtool_ops ax88172a_ethtool_ops = {
2126+ .get_drvinfo = asix_get_drvinfo,
2127+ .get_link = usbnet_get_link,
2128+ .get_msglevel = usbnet_get_msglevel,
2129+ .set_msglevel = usbnet_set_msglevel,
2130+ .get_wol = asix_get_wol,
2131+ .set_wol = asix_set_wol,
2132+ .get_eeprom_len = asix_get_eeprom_len,
2133+ .get_eeprom = asix_get_eeprom,
2134+ .set_eeprom = asix_set_eeprom,
2135+ .get_settings = ax88172a_get_settings,
2136+ .set_settings = ax88172a_set_settings,
2137+ .nway_reset = ax88172a_nway_reset,
2138+};
2139+
2140+static int ax88172a_reset_phy(struct usbnet *dev, int embd_phy)
2141+{
2142+ int ret;
2143+
2144+ ret = asix_sw_reset(dev, AX_SWRESET_IPPD);
2145+ if (ret < 0)
2146+ goto err;
2147+
2148+ msleep(150);
2149+ ret = asix_sw_reset(dev, AX_SWRESET_CLEAR);
2150+ if (ret < 0)
2151+ goto err;
2152+
2153+ msleep(150);
2154+
2155+ ret = asix_sw_reset(dev, embd_phy ? AX_SWRESET_IPRL : AX_SWRESET_IPPD);
2156+ if (ret < 0)
2157+ goto err;
2158+
2159+ return 0;
2160+
2161+err:
2162+ return ret;
2163+}
2164+
2165+
2166+static int ax88172a_bind(struct usbnet *dev, struct usb_interface *intf)
2167+{
2168+ int ret;
2169+ u8 buf[ETH_ALEN];
2170+ struct ax88172a_private *priv;
2171+
2172+ usbnet_get_endpoints(dev, intf);
2173+
2174+ priv = kzalloc(sizeof(*priv), GFP_KERNEL);
2175+ if (!priv)
2176+ return -ENOMEM;
2177+
2178+ dev->driver_priv = priv;
2179+
2180+ /* Get the MAC address */
2181+ ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf);
2182+ if (ret < 0) {
2183+ netdev_err(dev->net, "Failed to read MAC address: %d\n", ret);
2184+ goto free;
2185+ }
2186+ memcpy(dev->net->dev_addr, buf, ETH_ALEN);
2187+
2188+ dev->net->netdev_ops = &ax88172a_netdev_ops;
2189+ dev->net->ethtool_ops = &ax88172a_ethtool_ops;
2190+
2191+ /* are we using the internal or the external phy? */
2192+ ret = asix_read_cmd(dev, AX_CMD_SW_PHY_STATUS, 0, 0, 1, buf);
2193+ if (ret < 0) {
2194+ netdev_err(dev->net, "Failed to read software interface selection register: %d\n",
2195+ ret);
2196+ goto free;
2197+ }
2198+
2199+ netdev_dbg(dev->net, "AX_CMD_SW_PHY_STATUS = 0x%02x\n", buf[0]);
2200+ switch (buf[0] & AX_PHY_SELECT_MASK) {
2201+ case AX_PHY_SELECT_INTERNAL:
2202+ netdev_dbg(dev->net, "use internal phy\n");
2203+ priv->use_embdphy = 1;
2204+ break;
2205+ case AX_PHY_SELECT_EXTERNAL:
2206+ netdev_dbg(dev->net, "use external phy\n");
2207+ priv->use_embdphy = 0;
2208+ break;
2209+ default:
2210+ netdev_err(dev->net, "Interface mode not supported by driver\n");
2211+ ret = -ENOTSUPP;
2212+ goto free;
2213+ }
2214+
2215+ priv->phy_addr = asix_read_phy_addr(dev, priv->use_embdphy);
2216+ ax88172a_reset_phy(dev, priv->use_embdphy);
2217+
2218+ /* Asix framing packs multiple eth frames into a 2K usb bulk transfer */
2219+ if (dev->driver_info->flags & FLAG_FRAMING_AX) {
2220+ /* hard_mtu is still the default - the device does not support
2221+ jumbo eth frames */
2222+ dev->rx_urb_size = 2048;
2223+ }
2224+
2225+ /* init MDIO bus */
2226+ ret = ax88172a_init_mdio(dev);
2227+ if (ret)
2228+ goto free;
2229+
2230+ return 0;
2231+
2232+free:
2233+ kfree(priv);
2234+ return ret;
2235+}
2236+
2237+static int ax88172a_stop(struct usbnet *dev)
2238+{
2239+ struct ax88172a_private *priv = dev->driver_priv;
2240+
2241+ netdev_dbg(dev->net, "Stopping interface\n");
2242+
2243+ if (priv->phydev) {
2244+ netdev_info(dev->net, "Disconnecting from phy %s\n",
2245+ priv->phy_name);
2246+ phy_stop(priv->phydev);
2247+ phy_disconnect(priv->phydev);
2248+ }
2249+
2250+ return 0;
2251+}
2252+
2253+static void ax88172a_unbind(struct usbnet *dev, struct usb_interface *intf)
2254+{
2255+ struct ax88172a_private *priv = dev->driver_priv;
2256+
2257+ ax88172a_remove_mdio(dev);
2258+ kfree(priv);
2259+}
2260+
2261+static int ax88172a_reset(struct usbnet *dev)
2262+{
2263+ struct asix_data *data = (struct asix_data *)&dev->data;
2264+ struct ax88172a_private *priv = dev->driver_priv;
2265+ int ret;
2266+ u16 rx_ctl;
2267+
2268+ ax88172a_reset_phy(dev, priv->use_embdphy);
2269+
2270+ msleep(150);
2271+ rx_ctl = asix_read_rx_ctl(dev);
2272+ netdev_dbg(dev->net, "RX_CTL is 0x%04x after software reset\n", rx_ctl);
2273+ ret = asix_write_rx_ctl(dev, 0x0000);
2274+ if (ret < 0)
2275+ goto out;
2276+
2277+ rx_ctl = asix_read_rx_ctl(dev);
2278+ netdev_dbg(dev->net, "RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl);
2279+
2280+ msleep(150);
2281+
2282+ ret = asix_write_cmd(dev, AX_CMD_WRITE_IPG0,
2283+ AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,
2284+ AX88772_IPG2_DEFAULT, 0, NULL);
2285+ if (ret < 0) {
2286+ netdev_err(dev->net, "Write IPG,IPG1,IPG2 failed: %d\n", ret);
2287+ goto out;
2288+ }
2289+
2290+ /* Rewrite MAC address */
2291+ memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN);
2292+ ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
2293+ data->mac_addr);
2294+ if (ret < 0)
2295+ goto out;
2296+
2297+ /* Set RX_CTL to default values with 2k buffer, and enable cactus */
2298+ ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
2299+ if (ret < 0)
2300+ goto out;
2301+
2302+ rx_ctl = asix_read_rx_ctl(dev);
2303+ netdev_dbg(dev->net, "RX_CTL is 0x%04x after all initializations\n",
2304+ rx_ctl);
2305+
2306+ rx_ctl = asix_read_medium_status(dev);
2307+ netdev_dbg(dev->net, "Medium Status is 0x%04x after all initializations\n",
2308+ rx_ctl);
2309+
2310+ /* Connect to PHY */
2311+ snprintf(priv->phy_name, 20, PHY_ID_FMT,
2312+ priv->mdio->id, priv->phy_addr);
2313+
2314+ priv->phydev = phy_connect(dev->net, priv->phy_name,
2315+ &ax88172a_adjust_link,
2316+ PHY_INTERFACE_MODE_MII);
2317+ if (IS_ERR(priv->phydev)) {
2318+ netdev_err(dev->net, "Could not connect to PHY device %s\n",
2319+ priv->phy_name);
2320+ ret = PTR_ERR(priv->phydev);
2321+ goto out;
2322+ }
2323+
2324+ netdev_info(dev->net, "Connected to phy %s\n", priv->phy_name);
2325+
2326+ /* During power-up, the AX88172A set the power down (BMCR_PDOWN)
2327+ * bit of the PHY. Bring the PHY up again.
2328+ */
2329+ genphy_resume(priv->phydev);
2330+ phy_start(priv->phydev);
2331+
2332+ return 0;
2333+
2334+out:
2335+ return ret;
2336+
2337+}
2338+
2339+static int ax88172a_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
2340+{
2341+ struct ax88172a_private *dp = dev->driver_priv;
2342+ struct asix_rx_fixup_info *rx = &dp->rx_fixup_info;
2343+
2344+ return asix_rx_fixup_internal(dev, skb, rx);
2345+}
2346+
2347+const struct driver_info ax88172a_info = {
2348+ .description = "ASIX AX88172A USB 2.0 Ethernet",
2349+ .bind = ax88172a_bind,
2350+ .reset = ax88172a_reset,
2351+ .stop = ax88172a_stop,
2352+ .unbind = ax88172a_unbind,
2353+ .status = ax88172a_status,
2354+ .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR |
2355+ FLAG_MULTI_PACKET,
2356+ .rx_fixup = ax88172a_rx_fixup,
2357+ .tx_fixup = asix_tx_fixup,
2358+};
2359diff -Naur backports-3.18.1-1.org/drivers/net/usb/ax88179_178a.c backports-3.18.1-1/drivers/net/usb/ax88179_178a.c
2360--- backports-3.18.1-1.org/drivers/net/usb/ax88179_178a.c 1970-01-01 01:00:00.000000000 +0100
2361+++ backports-3.18.1-1/drivers/net/usb/ax88179_178a.c 2014-12-16 18:39:45.000000000 +0100
2362@@ -0,0 +1,1756 @@
2363+/*
2364+ * ASIX AX88179/178A USB 3.0/2.0 to Gigabit Ethernet Devices
2365+ *
2366+ * Copyright (C) 2011-2013 ASIX
2367+ *
2368+ * This program is free software; you can redistribute it and/or modify
2369+ * it under the terms of the GNU General Public License
2370+ * as published by the Free Software Foundation; either version 2
2371+ * of the License, or (at your option) any later version.
2372+ *
2373+ * This program is distributed in the hope that it will be useful,
2374+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
2375+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2376+ * GNU General Public License for more details.
2377+ *
2378+ * You should have received a copy of the GNU General Public License
2379+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
2380+ */
2381+
2382+#include <linux/module.h>
2383+#include <linux/etherdevice.h>
2384+#include <linux/mii.h>
2385+#include <linux/usb.h>
2386+#include <linux/crc32.h>
2387+#include <linux/usb/usbnet.h>
2388+#include <uapi/linux/mdio.h>
2389+#include <linux/mdio.h>
2390+
2391+#define AX88179_PHY_ID 0x03
2392+#define AX_EEPROM_LEN 0x100
2393+#define AX88179_EEPROM_MAGIC 0x17900b95
2394+#define AX_MCAST_FLTSIZE 8
2395+#define AX_MAX_MCAST 64
2396+#define AX_INT_PPLS_LINK ((u32)BIT(16))
2397+#define AX_RXHDR_L4_TYPE_MASK 0x1c
2398+#define AX_RXHDR_L4_TYPE_UDP 4
2399+#define AX_RXHDR_L4_TYPE_TCP 16
2400+#define AX_RXHDR_L3CSUM_ERR 2
2401+#define AX_RXHDR_L4CSUM_ERR 1
2402+#define AX_RXHDR_CRC_ERR ((u32)BIT(29))
2403+#define AX_RXHDR_DROP_ERR ((u32)BIT(31))
2404+#define AX_ACCESS_MAC 0x01
2405+#define AX_ACCESS_PHY 0x02
2406+#define AX_ACCESS_EEPROM 0x04
2407+#define AX_ACCESS_EFUS 0x05
2408+#define AX_PAUSE_WATERLVL_HIGH 0x54
2409+#define AX_PAUSE_WATERLVL_LOW 0x55
2410+
2411+#define PHYSICAL_LINK_STATUS 0x02
2412+ #define AX_USB_SS 0x04
2413+ #define AX_USB_HS 0x02
2414+
2415+#define GENERAL_STATUS 0x03
2416+/* Check AX88179 version. UA1:Bit2 = 0, UA2:Bit2 = 1 */
2417+ #define AX_SECLD 0x04
2418+
2419+#define AX_SROM_ADDR 0x07
2420+#define AX_SROM_CMD 0x0a
2421+ #define EEP_RD 0x04
2422+ #define EEP_BUSY 0x10
2423+
2424+#define AX_SROM_DATA_LOW 0x08
2425+#define AX_SROM_DATA_HIGH 0x09
2426+
2427+#define AX_RX_CTL 0x0b
2428+ #define AX_RX_CTL_DROPCRCERR 0x0100
2429+ #define AX_RX_CTL_IPE 0x0200
2430+ #define AX_RX_CTL_START 0x0080
2431+ #define AX_RX_CTL_AP 0x0020
2432+ #define AX_RX_CTL_AM 0x0010
2433+ #define AX_RX_CTL_AB 0x0008
2434+ #define AX_RX_CTL_AMALL 0x0002
2435+ #define AX_RX_CTL_PRO 0x0001
2436+ #define AX_RX_CTL_STOP 0x0000
2437+
2438+#define AX_NODE_ID 0x10
2439+#define AX_MULFLTARY 0x16
2440+
2441+#define AX_MEDIUM_STATUS_MODE 0x22
2442+ #define AX_MEDIUM_GIGAMODE 0x01
2443+ #define AX_MEDIUM_FULL_DUPLEX 0x02
2444+ #define AX_MEDIUM_EN_125MHZ 0x08
2445+ #define AX_MEDIUM_RXFLOW_CTRLEN 0x10
2446+ #define AX_MEDIUM_TXFLOW_CTRLEN 0x20
2447+ #define AX_MEDIUM_RECEIVE_EN 0x100
2448+ #define AX_MEDIUM_PS 0x200
2449+ #define AX_MEDIUM_JUMBO_EN 0x8040
2450+
2451+#define AX_MONITOR_MOD 0x24
2452+ #define AX_MONITOR_MODE_RWLC 0x02
2453+ #define AX_MONITOR_MODE_RWMP 0x04
2454+ #define AX_MONITOR_MODE_PMEPOL 0x20
2455+ #define AX_MONITOR_MODE_PMETYPE 0x40
2456+
2457+#define AX_GPIO_CTRL 0x25
2458+ #define AX_GPIO_CTRL_GPIO3EN 0x80
2459+ #define AX_GPIO_CTRL_GPIO2EN 0x40
2460+ #define AX_GPIO_CTRL_GPIO1EN 0x20
2461+
2462+#define AX_PHYPWR_RSTCTL 0x26
2463+ #define AX_PHYPWR_RSTCTL_BZ 0x0010
2464+ #define AX_PHYPWR_RSTCTL_IPRL 0x0020
2465+ #define AX_PHYPWR_RSTCTL_AT 0x1000
2466+
2467+#define AX_RX_BULKIN_QCTRL 0x2e
2468+#define AX_CLK_SELECT 0x33
2469+ #define AX_CLK_SELECT_BCS 0x01
2470+ #define AX_CLK_SELECT_ACS 0x02
2471+ #define AX_CLK_SELECT_ULR 0x08
2472+
2473+#define AX_RXCOE_CTL 0x34
2474+ #define AX_RXCOE_IP 0x01
2475+ #define AX_RXCOE_TCP 0x02
2476+ #define AX_RXCOE_UDP 0x04
2477+ #define AX_RXCOE_TCPV6 0x20
2478+ #define AX_RXCOE_UDPV6 0x40
2479+
2480+#define AX_TXCOE_CTL 0x35
2481+ #define AX_TXCOE_IP 0x01
2482+ #define AX_TXCOE_TCP 0x02
2483+ #define AX_TXCOE_UDP 0x04
2484+ #define AX_TXCOE_TCPV6 0x20
2485+ #define AX_TXCOE_UDPV6 0x40
2486+
2487+#define AX_LEDCTRL 0x73
2488+
2489+#define GMII_PHY_PHYSR 0x11
2490+ #define GMII_PHY_PHYSR_SMASK 0xc000
2491+ #define GMII_PHY_PHYSR_GIGA 0x8000
2492+ #define GMII_PHY_PHYSR_100 0x4000
2493+ #define GMII_PHY_PHYSR_FULL 0x2000
2494+ #define GMII_PHY_PHYSR_LINK 0x400
2495+
2496+#define GMII_LED_ACT 0x1a
2497+ #define GMII_LED_ACTIVE_MASK 0xff8f
2498+ #define GMII_LED0_ACTIVE BIT(4)
2499+ #define GMII_LED1_ACTIVE BIT(5)
2500+ #define GMII_LED2_ACTIVE BIT(6)
2501+
2502+#define GMII_LED_LINK 0x1c
2503+ #define GMII_LED_LINK_MASK 0xf888
2504+ #define GMII_LED0_LINK_10 BIT(0)
2505+ #define GMII_LED0_LINK_100 BIT(1)
2506+ #define GMII_LED0_LINK_1000 BIT(2)
2507+ #define GMII_LED1_LINK_10 BIT(4)
2508+ #define GMII_LED1_LINK_100 BIT(5)
2509+ #define GMII_LED1_LINK_1000 BIT(6)
2510+ #define GMII_LED2_LINK_10 BIT(8)
2511+ #define GMII_LED2_LINK_100 BIT(9)
2512+ #define GMII_LED2_LINK_1000 BIT(10)
2513+ #define LED0_ACTIVE BIT(0)
2514+ #define LED0_LINK_10 BIT(1)
2515+ #define LED0_LINK_100 BIT(2)
2516+ #define LED0_LINK_1000 BIT(3)
2517+ #define LED0_FD BIT(4)
2518+ #define LED0_USB3_MASK 0x001f
2519+ #define LED1_ACTIVE BIT(5)
2520+ #define LED1_LINK_10 BIT(6)
2521+ #define LED1_LINK_100 BIT(7)
2522+ #define LED1_LINK_1000 BIT(8)
2523+ #define LED1_FD BIT(9)
2524+ #define LED1_USB3_MASK 0x03e0
2525+ #define LED2_ACTIVE BIT(10)
2526+ #define LED2_LINK_1000 BIT(13)
2527+ #define LED2_LINK_100 BIT(12)
2528+ #define LED2_LINK_10 BIT(11)
2529+ #define LED2_FD BIT(14)
2530+ #define LED_VALID BIT(15)
2531+ #define LED2_USB3_MASK 0x7c00
2532+
2533+#define GMII_PHYPAGE 0x1e
2534+#define GMII_PHY_PAGE_SELECT 0x1f
2535+ #define GMII_PHY_PGSEL_EXT 0x0007
2536+ #define GMII_PHY_PGSEL_PAGE0 0x0000
2537+ #define GMII_PHY_PGSEL_PAGE3 0x0003
2538+ #define GMII_PHY_PGSEL_PAGE5 0x0005
2539+
2540+struct ax88179_data {
2541+ u8 eee_enabled;
2542+ u8 eee_active;
2543+ u16 rxctl;
2544+ u16 reserved;
2545+};
2546+
2547+struct ax88179_int_data {
2548+ __le32 intdata1;
2549+ __le32 intdata2;
2550+};
2551+
2552+static const struct {
2553+ unsigned char ctrl, timer_l, timer_h, size, ifg;
2554+} AX88179_BULKIN_SIZE[] = {
2555+ {7, 0x4f, 0, 0x12, 0xff},
2556+ {7, 0x20, 3, 0x16, 0xff},
2557+ {7, 0xae, 7, 0x18, 0xff},
2558+ {7, 0xcc, 0x4c, 0x18, 8},
2559+};
2560+
2561+static int __ax88179_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
2562+ u16 size, void *data, int in_pm)
2563+{
2564+ int ret;
2565+ int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
2566+
2567+ BUG_ON(!dev);
2568+
2569+ if (!in_pm)
2570+ fn = usbnet_read_cmd;
2571+ else
2572+ fn = usbnet_read_cmd_nopm;
2573+
2574+ ret = fn(dev, cmd, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2575+ value, index, data, size);
2576+
2577+ if (unlikely(ret < 0))
2578+ netdev_warn(dev->net, "Failed to read reg index 0x%04x: %d\n",
2579+ index, ret);
2580+
2581+ return ret;
2582+}
2583+
2584+static int __ax88179_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
2585+ u16 size, void *data, int in_pm)
2586+{
2587+ int ret;
2588+ int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
2589+
2590+ BUG_ON(!dev);
2591+
2592+ if (!in_pm)
2593+ fn = usbnet_write_cmd;
2594+ else
2595+ fn = usbnet_write_cmd_nopm;
2596+
2597+ ret = fn(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2598+ value, index, data, size);
2599+
2600+ if (unlikely(ret < 0))
2601+ netdev_warn(dev->net, "Failed to write reg index 0x%04x: %d\n",
2602+ index, ret);
2603+
2604+ return ret;
2605+}
2606+
2607+static void ax88179_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value,
2608+ u16 index, u16 size, void *data)
2609+{
2610+ u16 buf;
2611+
2612+ if (2 == size) {
2613+ buf = *((u16 *)data);
2614+ cpu_to_le16s(&buf);
2615+ usbnet_write_cmd_async(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR |
2616+ USB_RECIP_DEVICE, value, index, &buf,
2617+ size);
2618+ } else {
2619+ usbnet_write_cmd_async(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR |
2620+ USB_RECIP_DEVICE, value, index, data,
2621+ size);
2622+ }
2623+}
2624+
2625+static int ax88179_read_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
2626+ u16 index, u16 size, void *data)
2627+{
2628+ int ret;
2629+
2630+ if (2 == size) {
2631+ u16 buf;
2632+ ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 1);
2633+ le16_to_cpus(&buf);
2634+ *((u16 *)data) = buf;
2635+ } else if (4 == size) {
2636+ u32 buf;
2637+ ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 1);
2638+ le32_to_cpus(&buf);
2639+ *((u32 *)data) = buf;
2640+ } else {
2641+ ret = __ax88179_read_cmd(dev, cmd, value, index, size, data, 1);
2642+ }
2643+
2644+ return ret;
2645+}
2646+
2647+static int ax88179_write_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
2648+ u16 index, u16 size, void *data)
2649+{
2650+ int ret;
2651+
2652+ if (2 == size) {
2653+ u16 buf;
2654+ buf = *((u16 *)data);
2655+ cpu_to_le16s(&buf);
2656+ ret = __ax88179_write_cmd(dev, cmd, value, index,
2657+ size, &buf, 1);
2658+ } else {
2659+ ret = __ax88179_write_cmd(dev, cmd, value, index,
2660+ size, data, 1);
2661+ }
2662+
2663+ return ret;
2664+}
2665+
2666+static int ax88179_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
2667+ u16 size, void *data)
2668+{
2669+ int ret;
2670+
2671+ if (2 == size) {
2672+ u16 buf;
2673+ ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 0);
2674+ le16_to_cpus(&buf);
2675+ *((u16 *)data) = buf;
2676+ } else if (4 == size) {
2677+ u32 buf;
2678+ ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 0);
2679+ le32_to_cpus(&buf);
2680+ *((u32 *)data) = buf;
2681+ } else {
2682+ ret = __ax88179_read_cmd(dev, cmd, value, index, size, data, 0);
2683+ }
2684+
2685+ return ret;
2686+}
2687+
2688+static int ax88179_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
2689+ u16 size, void *data)
2690+{
2691+ int ret;
2692+
2693+ if (2 == size) {
2694+ u16 buf;
2695+ buf = *((u16 *)data);
2696+ cpu_to_le16s(&buf);
2697+ ret = __ax88179_write_cmd(dev, cmd, value, index,
2698+ size, &buf, 0);
2699+ } else {
2700+ ret = __ax88179_write_cmd(dev, cmd, value, index,
2701+ size, data, 0);
2702+ }
2703+
2704+ return ret;
2705+}
2706+
2707+static void ax88179_status(struct usbnet *dev, struct urb *urb)
2708+{
2709+ struct ax88179_int_data *event;
2710+ u32 link;
2711+
2712+ if (urb->actual_length < 8)
2713+ return;
2714+
2715+ event = urb->transfer_buffer;
2716+ le32_to_cpus((void *)&event->intdata1);
2717+
2718+ link = (((__force u32)event->intdata1) & AX_INT_PPLS_LINK) >> 16;
2719+
2720+ if (netif_carrier_ok(dev->net) != link) {
2721+ usbnet_link_change(dev, link, 1);
2722+ netdev_info(dev->net, "ax88179 - Link status is: %d\n", link);
2723+ }
2724+}
2725+
2726+static int ax88179_mdio_read(struct net_device *netdev, int phy_id, int loc)
2727+{
2728+ struct usbnet *dev = netdev_priv(netdev);
2729+ u16 res;
2730+
2731+ ax88179_read_cmd(dev, AX_ACCESS_PHY, phy_id, (__u16)loc, 2, &res);
2732+ return res;
2733+}
2734+
2735+static void ax88179_mdio_write(struct net_device *netdev, int phy_id, int loc,
2736+ int val)
2737+{
2738+ struct usbnet *dev = netdev_priv(netdev);
2739+ u16 res = (u16) val;
2740+
2741+ ax88179_write_cmd(dev, AX_ACCESS_PHY, phy_id, (__u16)loc, 2, &res);
2742+}
2743+
2744+static inline int ax88179_phy_mmd_indirect(struct usbnet *dev, u16 prtad,
2745+ u16 devad)
2746+{
2747+ u16 tmp16;
2748+ int ret;
2749+
2750+ tmp16 = devad;
2751+ ret = ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
2752+ MII_MMD_CTRL, 2, &tmp16);
2753+
2754+ tmp16 = prtad;
2755+ ret = ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
2756+ MII_MMD_DATA, 2, &tmp16);
2757+
2758+ tmp16 = devad | MII_MMD_CTRL_NOINCR;
2759+ ret = ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
2760+ MII_MMD_CTRL, 2, &tmp16);
2761+
2762+ return ret;
2763+}
2764+
2765+static int
2766+ax88179_phy_read_mmd_indirect(struct usbnet *dev, u16 prtad, u16 devad)
2767+{
2768+ int ret;
2769+ u16 tmp16;
2770+
2771+ ax88179_phy_mmd_indirect(dev, prtad, devad);
2772+
2773+ ret = ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
2774+ MII_MMD_DATA, 2, &tmp16);
2775+ if (ret < 0)
2776+ return ret;
2777+
2778+ return tmp16;
2779+}
2780+
2781+static int
2782+ax88179_phy_write_mmd_indirect(struct usbnet *dev, u16 prtad, u16 devad,
2783+ u16 data)
2784+{
2785+ int ret;
2786+
2787+ ax88179_phy_mmd_indirect(dev, prtad, devad);
2788+
2789+ ret = ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
2790+ MII_MMD_DATA, 2, &data);
2791+
2792+ if (ret < 0)
2793+ return ret;
2794+
2795+ return 0;
2796+}
2797+
2798+static int ax88179_suspend(struct usb_interface *intf, pm_message_t message)
2799+{
2800+ struct usbnet *dev = usb_get_intfdata(intf);
2801+ u16 tmp16;
2802+ u8 tmp8;
2803+
2804+ usbnet_suspend(intf, message);
2805+
2806+ /* Disable RX path */
2807+ ax88179_read_cmd_nopm(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
2808+ 2, 2, &tmp16);
2809+ tmp16 &= ~AX_MEDIUM_RECEIVE_EN;
2810+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
2811+ 2, 2, &tmp16);
2812+
2813+ /* Force bulk-in zero length */
2814+ ax88179_read_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
2815+ 2, 2, &tmp16);
2816+
2817+ tmp16 |= AX_PHYPWR_RSTCTL_BZ | AX_PHYPWR_RSTCTL_IPRL;
2818+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
2819+ 2, 2, &tmp16);
2820+
2821+ /* change clock */
2822+ tmp8 = 0;
2823+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, &tmp8);
2824+
2825+ /* Configure RX control register => stop operation */
2826+ tmp16 = AX_RX_CTL_STOP;
2827+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, &tmp16);
2828+
2829+ return 0;
2830+}
2831+
2832+/* This function is used to enable the autodetach function. */
2833+/* This function is determined by offset 0x43 of EEPROM */
2834+static int ax88179_auto_detach(struct usbnet *dev, int in_pm)
2835+{
2836+ u16 tmp16;
2837+ u8 tmp8;
2838+ int (*fnr)(struct usbnet *, u8, u16, u16, u16, void *);
2839+ int (*fnw)(struct usbnet *, u8, u16, u16, u16, void *);
2840+
2841+ if (!in_pm) {
2842+ fnr = ax88179_read_cmd;
2843+ fnw = ax88179_write_cmd;
2844+ } else {
2845+ fnr = ax88179_read_cmd_nopm;
2846+ fnw = ax88179_write_cmd_nopm;
2847+ }
2848+
2849+ if (fnr(dev, AX_ACCESS_EEPROM, 0x43, 1, 2, &tmp16) < 0)
2850+ return 0;
2851+
2852+ if ((tmp16 == 0xFFFF) || (!(tmp16 & 0x0100)))
2853+ return 0;
2854+
2855+ /* Enable Auto Detach bit */
2856+ tmp8 = 0;
2857+ fnr(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, &tmp8);
2858+ tmp8 |= AX_CLK_SELECT_ULR;
2859+ fnw(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, &tmp8);
2860+
2861+ fnr(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, &tmp16);
2862+ tmp16 |= AX_PHYPWR_RSTCTL_AT;
2863+ fnw(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, &tmp16);
2864+
2865+ return 0;
2866+}
2867+
2868+static int ax88179_resume(struct usb_interface *intf)
2869+{
2870+ struct usbnet *dev = usb_get_intfdata(intf);
2871+ u16 tmp16;
2872+ u8 tmp8;
2873+
2874+ usbnet_link_change(dev, 0, 0);
2875+
2876+ /* Power up ethernet PHY */
2877+ tmp16 = 0;
2878+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
2879+ 2, 2, &tmp16);
2880+ udelay(1000);
2881+
2882+ tmp16 = AX_PHYPWR_RSTCTL_IPRL;
2883+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
2884+ 2, 2, &tmp16);
2885+ msleep(200);
2886+
2887+ /* Ethernet PHY Auto Detach*/
2888+ ax88179_auto_detach(dev, 1);
2889+
2890+ /* Enable clock */
2891+ ax88179_read_cmd_nopm(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, &tmp8);
2892+ tmp8 |= AX_CLK_SELECT_ACS | AX_CLK_SELECT_BCS;
2893+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, &tmp8);
2894+ msleep(100);
2895+
2896+ /* Configure RX control register => start operation */
2897+ tmp16 = AX_RX_CTL_DROPCRCERR | AX_RX_CTL_IPE | AX_RX_CTL_START |
2898+ AX_RX_CTL_AP | AX_RX_CTL_AMALL | AX_RX_CTL_AB;
2899+ ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, &tmp16);
2900+
2901+ return usbnet_resume(intf);
2902+}
2903+
2904+static void
2905+ax88179_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
2906+{
2907+ struct usbnet *dev = netdev_priv(net);
2908+ u8 opt;
2909+
2910+ if (ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MOD,
2911+ 1, 1, &opt) < 0) {
2912+ wolinfo->supported = 0;
2913+ wolinfo->wolopts = 0;
2914+ return;
2915+ }
2916+
2917+ wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
2918+ wolinfo->wolopts = 0;
2919+ if (opt & AX_MONITOR_MODE_RWLC)
2920+ wolinfo->wolopts |= WAKE_PHY;
2921+ if (opt & AX_MONITOR_MODE_RWMP)
2922+ wolinfo->wolopts |= WAKE_MAGIC;
2923+}
2924+
2925+static int
2926+ax88179_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
2927+{
2928+ struct usbnet *dev = netdev_priv(net);
2929+ u8 opt = 0;
2930+
2931+ if (wolinfo->wolopts & WAKE_PHY)
2932+ opt |= AX_MONITOR_MODE_RWLC;
2933+ if (wolinfo->wolopts & WAKE_MAGIC)
2934+ opt |= AX_MONITOR_MODE_RWMP;
2935+
2936+ if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MOD,
2937+ 1, 1, &opt) < 0)
2938+ return -EINVAL;
2939+
2940+ return 0;
2941+}
2942+
2943+static int ax88179_get_eeprom_len(struct net_device *net)
2944+{
2945+ return AX_EEPROM_LEN;
2946+}
2947+
2948+static int
2949+ax88179_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
2950+ u8 *data)
2951+{
2952+ struct usbnet *dev = netdev_priv(net);
2953+ u16 *eeprom_buff;
2954+ int first_word, last_word;
2955+ int i, ret;
2956+
2957+ if (eeprom->len == 0)
2958+ return -EINVAL;
2959+
2960+ eeprom->magic = AX88179_EEPROM_MAGIC;
2961+
2962+ first_word = eeprom->offset >> 1;
2963+ last_word = (eeprom->offset + eeprom->len - 1) >> 1;
2964+ eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),
2965+ GFP_KERNEL);
2966+ if (!eeprom_buff)
2967+ return -ENOMEM;
2968+
2969+ /* ax88179/178A returns 2 bytes from eeprom on read */
2970+ for (i = first_word; i <= last_word; i++) {
2971+ ret = __ax88179_read_cmd(dev, AX_ACCESS_EEPROM, i, 1, 2,
2972+ &eeprom_buff[i - first_word],
2973+ 0);
2974+ if (ret < 0) {
2975+ kfree(eeprom_buff);
2976+ return -EIO;
2977+ }
2978+ }
2979+
2980+ memcpy(data, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
2981+ kfree(eeprom_buff);
2982+ return 0;
2983+}
2984+
2985+static int ax88179_get_settings(struct net_device *net, struct ethtool_cmd *cmd)
2986+{
2987+ struct usbnet *dev = netdev_priv(net);
2988+ return mii_ethtool_gset(&dev->mii, cmd);
2989+}
2990+
2991+static int ax88179_set_settings(struct net_device *net, struct ethtool_cmd *cmd)
2992+{
2993+ struct usbnet *dev = netdev_priv(net);
2994+ return mii_ethtool_sset(&dev->mii, cmd);
2995+}
2996+
2997+static int
2998+ax88179_ethtool_get_eee(struct usbnet *dev, struct ethtool_eee *data)
2999+{
3000+ int val;
3001+
3002+ /* Get Supported EEE */
3003+ val = ax88179_phy_read_mmd_indirect(dev, MDIO_PCS_EEE_ABLE,
3004+ MDIO_MMD_PCS);
3005+ if (val < 0)
3006+ return val;
3007+ data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
3008+
3009+ /* Get advertisement EEE */
3010+ val = ax88179_phy_read_mmd_indirect(dev, MDIO_AN_EEE_ADV,
3011+ MDIO_MMD_AN);
3012+ if (val < 0)
3013+ return val;
3014+ data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
3015+
3016+ /* Get LP advertisement EEE */
3017+ val = ax88179_phy_read_mmd_indirect(dev, MDIO_AN_EEE_LPABLE,
3018+ MDIO_MMD_AN);
3019+ if (val < 0)
3020+ return val;
3021+ data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
3022+
3023+ return 0;
3024+}
3025+
3026+static int
3027+ax88179_ethtool_set_eee(struct usbnet *dev, struct ethtool_eee *data)
3028+{
3029+ u16 tmp16 = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
3030+
3031+ return ax88179_phy_write_mmd_indirect(dev, MDIO_AN_EEE_ADV,
3032+ MDIO_MMD_AN, tmp16);
3033+}
3034+
3035+static int ax88179_chk_eee(struct usbnet *dev)
3036+{
3037+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
3038+ struct ax88179_data *priv = (struct ax88179_data *)dev->data;
3039+
3040+ mii_ethtool_gset(&dev->mii, &ecmd);
3041+
3042+ if (ecmd.duplex & DUPLEX_FULL) {
3043+ int eee_lp, eee_cap, eee_adv;
3044+ u32 lp, cap, adv, supported = 0;
3045+
3046+ eee_cap = ax88179_phy_read_mmd_indirect(dev,
3047+ MDIO_PCS_EEE_ABLE,
3048+ MDIO_MMD_PCS);
3049+ if (eee_cap < 0) {
3050+ priv->eee_active = 0;
3051+ return false;
3052+ }
3053+
3054+ cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap);
3055+ if (!cap) {
3056+ priv->eee_active = 0;
3057+ return false;
3058+ }
3059+
3060+ eee_lp = ax88179_phy_read_mmd_indirect(dev,
3061+ MDIO_AN_EEE_LPABLE,
3062+ MDIO_MMD_AN);
3063+ if (eee_lp < 0) {
3064+ priv->eee_active = 0;
3065+ return false;
3066+ }
3067+
3068+ eee_adv = ax88179_phy_read_mmd_indirect(dev,
3069+ MDIO_AN_EEE_ADV,
3070+ MDIO_MMD_AN);
3071+
3072+ if (eee_adv < 0) {
3073+ priv->eee_active = 0;
3074+ return false;
3075+ }
3076+
3077+ adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv);
3078+ lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp);
3079+ supported = (ecmd.speed == SPEED_1000) ?
3080+ SUPPORTED_1000baseT_Full :
3081+ SUPPORTED_100baseT_Full;
3082+
3083+ if (!(lp & adv & supported)) {
3084+ priv->eee_active = 0;
3085+ return false;
3086+ }
3087+
3088+ priv->eee_active = 1;
3089+ return true;
3090+ }
3091+
3092+ priv->eee_active = 0;
3093+ return false;
3094+}
3095+
3096+static void ax88179_disable_eee(struct usbnet *dev)
3097+{
3098+ u16 tmp16;
3099+
3100+ tmp16 = GMII_PHY_PGSEL_PAGE3;
3101+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3102+ GMII_PHY_PAGE_SELECT, 2, &tmp16);
3103+
3104+ tmp16 = 0x3246;
3105+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3106+ MII_PHYADDR, 2, &tmp16);
3107+
3108+ tmp16 = GMII_PHY_PGSEL_PAGE0;
3109+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3110+ GMII_PHY_PAGE_SELECT, 2, &tmp16);
3111+}
3112+
3113+static void ax88179_enable_eee(struct usbnet *dev)
3114+{
3115+ u16 tmp16;
3116+
3117+ tmp16 = GMII_PHY_PGSEL_PAGE3;
3118+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3119+ GMII_PHY_PAGE_SELECT, 2, &tmp16);
3120+
3121+ tmp16 = 0x3247;
3122+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3123+ MII_PHYADDR, 2, &tmp16);
3124+
3125+ tmp16 = GMII_PHY_PGSEL_PAGE5;
3126+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3127+ GMII_PHY_PAGE_SELECT, 2, &tmp16);
3128+
3129+ tmp16 = 0x0680;
3130+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3131+ MII_BMSR, 2, &tmp16);
3132+
3133+ tmp16 = GMII_PHY_PGSEL_PAGE0;
3134+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3135+ GMII_PHY_PAGE_SELECT, 2, &tmp16);
3136+}
3137+
3138+static int ax88179_get_eee(struct net_device *net, struct ethtool_eee *edata)
3139+{
3140+ struct usbnet *dev = netdev_priv(net);
3141+ struct ax88179_data *priv = (struct ax88179_data *)dev->data;
3142+
3143+ edata->eee_enabled = priv->eee_enabled;
3144+ edata->eee_active = priv->eee_active;
3145+
3146+ return ax88179_ethtool_get_eee(dev, edata);
3147+}
3148+
3149+static int ax88179_set_eee(struct net_device *net, struct ethtool_eee *edata)
3150+{
3151+ struct usbnet *dev = netdev_priv(net);
3152+ struct ax88179_data *priv = (struct ax88179_data *)dev->data;
3153+ int ret = -EOPNOTSUPP;
3154+
3155+ priv->eee_enabled = edata->eee_enabled;
3156+ if (!priv->eee_enabled) {
3157+ ax88179_disable_eee(dev);
3158+ } else {
3159+ priv->eee_enabled = ax88179_chk_eee(dev);
3160+ if (!priv->eee_enabled)
3161+ return -EOPNOTSUPP;
3162+
3163+ ax88179_enable_eee(dev);
3164+ }
3165+
3166+ ret = ax88179_ethtool_set_eee(dev, edata);
3167+ if (ret)
3168+ return ret;
3169+
3170+ mii_nway_restart(&dev->mii);
3171+
3172+ usbnet_link_change(dev, 0, 0);
3173+
3174+ return ret;
3175+}
3176+
3177+static int ax88179_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
3178+{
3179+ struct usbnet *dev = netdev_priv(net);
3180+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
3181+}
3182+
3183+static const struct ethtool_ops ax88179_ethtool_ops = {
3184+ .get_link = ethtool_op_get_link,
3185+ .get_msglevel = usbnet_get_msglevel,
3186+ .set_msglevel = usbnet_set_msglevel,
3187+ .get_wol = ax88179_get_wol,
3188+ .set_wol = ax88179_set_wol,
3189+ .get_eeprom_len = ax88179_get_eeprom_len,
3190+ .get_eeprom = ax88179_get_eeprom,
3191+ .get_settings = ax88179_get_settings,
3192+ .set_settings = ax88179_set_settings,
3193+ .get_eee = ax88179_get_eee,
3194+ .set_eee = ax88179_set_eee,
3195+ .nway_reset = usbnet_nway_reset,
3196+};
3197+
3198+static void ax88179_set_multicast(struct net_device *net)
3199+{
3200+ struct usbnet *dev = netdev_priv(net);
3201+ struct ax88179_data *data = (struct ax88179_data *)dev->data;
3202+ u8 *m_filter = ((u8 *)dev->data) + 12;
3203+
3204+ data->rxctl = (AX_RX_CTL_START | AX_RX_CTL_AB | AX_RX_CTL_IPE);
3205+
3206+ if (net->flags & IFF_PROMISC) {
3207+ data->rxctl |= AX_RX_CTL_PRO;
3208+ } else if (net->flags & IFF_ALLMULTI ||
3209+ netdev_mc_count(net) > AX_MAX_MCAST) {
3210+ data->rxctl |= AX_RX_CTL_AMALL;
3211+ } else if (netdev_mc_empty(net)) {
3212+ /* just broadcast and directed */
3213+ } else {
3214+ /* We use the 20 byte dev->data for our 8 byte filter buffer
3215+ * to avoid allocating memory that is tricky to free later
3216+ */
3217+ u32 crc_bits;
3218+ struct netdev_hw_addr *ha;
3219+
3220+ memset(m_filter, 0, AX_MCAST_FLTSIZE);
3221+
3222+ netdev_for_each_mc_addr(ha, net) {
3223+ crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
3224+ *(m_filter + (crc_bits >> 3)) |= (1 << (crc_bits & 7));
3225+ }
3226+
3227+ ax88179_write_cmd_async(dev, AX_ACCESS_MAC, AX_MULFLTARY,
3228+ AX_MCAST_FLTSIZE, AX_MCAST_FLTSIZE,
3229+ m_filter);
3230+
3231+ data->rxctl |= AX_RX_CTL_AM;
3232+ }
3233+
3234+ ax88179_write_cmd_async(dev, AX_ACCESS_MAC, AX_RX_CTL,
3235+ 2, 2, &data->rxctl);
3236+}
3237+
3238+static int
3239+ax88179_set_features(struct net_device *net, netdev_features_t features)
3240+{
3241+ u8 tmp;
3242+ struct usbnet *dev = netdev_priv(net);
3243+ netdev_features_t changed = net->features ^ features;
3244+
3245+ if (changed & NETIF_F_IP_CSUM) {
3246+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp);
3247+ tmp ^= AX_TXCOE_TCP | AX_TXCOE_UDP;
3248+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp);
3249+ }
3250+
3251+ if (changed & NETIF_F_IPV6_CSUM) {
3252+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp);
3253+ tmp ^= AX_TXCOE_TCPV6 | AX_TXCOE_UDPV6;
3254+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, &tmp);
3255+ }
3256+
3257+ if (changed & NETIF_F_RXCSUM) {
3258+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, &tmp);
3259+ tmp ^= AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP |
3260+ AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6;
3261+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, &tmp);
3262+ }
3263+
3264+ return 0;
3265+}
3266+
3267+static int ax88179_change_mtu(struct net_device *net, int new_mtu)
3268+{
3269+ struct usbnet *dev = netdev_priv(net);
3270+ u16 tmp16;
3271+
3272+ if (new_mtu <= 0 || new_mtu > 4088)
3273+ return -EINVAL;
3274+
3275+ net->mtu = new_mtu;
3276+ dev->hard_mtu = net->mtu + net->hard_header_len;
3277+
3278+ if (net->mtu > 1500) {
3279+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3280+ 2, 2, &tmp16);
3281+ tmp16 |= AX_MEDIUM_JUMBO_EN;
3282+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3283+ 2, 2, &tmp16);
3284+ } else {
3285+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3286+ 2, 2, &tmp16);
3287+ tmp16 &= ~AX_MEDIUM_JUMBO_EN;
3288+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3289+ 2, 2, &tmp16);
3290+ }
3291+
3292+ /* max qlen depend on hard_mtu and rx_urb_size */
3293+ usbnet_update_max_qlen(dev);
3294+
3295+ return 0;
3296+}
3297+
3298+static int ax88179_set_mac_addr(struct net_device *net, void *p)
3299+{
3300+ struct usbnet *dev = netdev_priv(net);
3301+ struct sockaddr *addr = p;
3302+ int ret;
3303+
3304+ if (netif_running(net))
3305+ return -EBUSY;
3306+ if (!is_valid_ether_addr(addr->sa_data))
3307+ return -EADDRNOTAVAIL;
3308+
3309+ memcpy(net->dev_addr, addr->sa_data, ETH_ALEN);
3310+
3311+ /* Set the MAC address */
3312+ ret = ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN,
3313+ ETH_ALEN, net->dev_addr);
3314+ if (ret < 0)
3315+ return ret;
3316+
3317+ return 0;
3318+}
3319+
3320+static const struct net_device_ops ax88179_netdev_ops = {
3321+ .ndo_open = usbnet_open,
3322+ .ndo_stop = usbnet_stop,
3323+ .ndo_start_xmit = usbnet_start_xmit,
3324+ .ndo_tx_timeout = usbnet_tx_timeout,
3325+ .ndo_change_mtu = ax88179_change_mtu,
3326+ .ndo_set_mac_address = ax88179_set_mac_addr,
3327+ .ndo_validate_addr = eth_validate_addr,
3328+ .ndo_do_ioctl = ax88179_ioctl,
3329+ .ndo_set_rx_mode = ax88179_set_multicast,
3330+ .ndo_set_features = ax88179_set_features,
3331+};
3332+
3333+static int ax88179_check_eeprom(struct usbnet *dev)
3334+{
3335+ u8 i, buf, eeprom[20];
3336+ u16 csum, delay = HZ / 10;
3337+ unsigned long jtimeout;
3338+
3339+ /* Read EEPROM content */
3340+ for (i = 0; i < 6; i++) {
3341+ buf = i;
3342+ if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_ADDR,
3343+ 1, 1, &buf) < 0)
3344+ return -EINVAL;
3345+
3346+ buf = EEP_RD;
3347+ if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
3348+ 1, 1, &buf) < 0)
3349+ return -EINVAL;
3350+
3351+ jtimeout = jiffies + delay;
3352+ do {
3353+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
3354+ 1, 1, &buf);
3355+
3356+ if (time_after(jiffies, jtimeout))
3357+ return -EINVAL;
3358+
3359+ } while (buf & EEP_BUSY);
3360+
3361+ __ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_DATA_LOW,
3362+ 2, 2, &eeprom[i * 2], 0);
3363+
3364+ if ((i == 0) && (eeprom[0] == 0xFF))
3365+ return -EINVAL;
3366+ }
3367+
3368+ csum = eeprom[6] + eeprom[7] + eeprom[8] + eeprom[9];
3369+ csum = (csum >> 8) + (csum & 0xff);
3370+ if ((csum + eeprom[10]) != 0xff)
3371+ return -EINVAL;
3372+
3373+ return 0;
3374+}
3375+
3376+static int ax88179_check_efuse(struct usbnet *dev, u16 *ledmode)
3377+{
3378+ u8 i;
3379+ u8 efuse[64];
3380+ u16 csum = 0;
3381+
3382+ if (ax88179_read_cmd(dev, AX_ACCESS_EFUS, 0, 64, 64, efuse) < 0)
3383+ return -EINVAL;
3384+
3385+ if (*efuse == 0xFF)
3386+ return -EINVAL;
3387+
3388+ for (i = 0; i < 64; i++)
3389+ csum = csum + efuse[i];
3390+
3391+ while (csum > 255)
3392+ csum = (csum & 0x00FF) + ((csum >> 8) & 0x00FF);
3393+
3394+ if (csum != 0xFF)
3395+ return -EINVAL;
3396+
3397+ *ledmode = (efuse[51] << 8) | efuse[52];
3398+
3399+ return 0;
3400+}
3401+
3402+static int ax88179_convert_old_led(struct usbnet *dev, u16 *ledvalue)
3403+{
3404+ u16 led;
3405+
3406+ /* Loaded the old eFuse LED Mode */
3407+ if (ax88179_read_cmd(dev, AX_ACCESS_EEPROM, 0x3C, 1, 2, &led) < 0)
3408+ return -EINVAL;
3409+
3410+ led >>= 8;
3411+ switch (led) {
3412+ case 0xFF:
3413+ led = LED0_ACTIVE | LED1_LINK_10 | LED1_LINK_100 |
3414+ LED1_LINK_1000 | LED2_ACTIVE | LED2_LINK_10 |
3415+ LED2_LINK_100 | LED2_LINK_1000 | LED_VALID;
3416+ break;
3417+ case 0xFE:
3418+ led = LED0_ACTIVE | LED1_LINK_1000 | LED2_LINK_100 | LED_VALID;
3419+ break;
3420+ case 0xFD:
3421+ led = LED0_ACTIVE | LED1_LINK_1000 | LED2_LINK_100 |
3422+ LED2_LINK_10 | LED_VALID;
3423+ break;
3424+ case 0xFC:
3425+ led = LED0_ACTIVE | LED1_ACTIVE | LED1_LINK_1000 | LED2_ACTIVE |
3426+ LED2_LINK_100 | LED2_LINK_10 | LED_VALID;
3427+ break;
3428+ default:
3429+ led = LED0_ACTIVE | LED1_LINK_10 | LED1_LINK_100 |
3430+ LED1_LINK_1000 | LED2_ACTIVE | LED2_LINK_10 |
3431+ LED2_LINK_100 | LED2_LINK_1000 | LED_VALID;
3432+ break;
3433+ }
3434+
3435+ *ledvalue = led;
3436+
3437+ return 0;
3438+}
3439+
3440+static int ax88179_led_setting(struct usbnet *dev)
3441+{
3442+ u8 ledfd, value = 0;
3443+ u16 tmp, ledact, ledlink, ledvalue = 0, delay = HZ / 10;
3444+ unsigned long jtimeout;
3445+
3446+ /* Check AX88179 version. UA1 or UA2*/
3447+ ax88179_read_cmd(dev, AX_ACCESS_MAC, GENERAL_STATUS, 1, 1, &value);
3448+
3449+ if (!(value & AX_SECLD)) { /* UA1 */
3450+ value = AX_GPIO_CTRL_GPIO3EN | AX_GPIO_CTRL_GPIO2EN |
3451+ AX_GPIO_CTRL_GPIO1EN;
3452+ if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_GPIO_CTRL,
3453+ 1, 1, &value) < 0)
3454+ return -EINVAL;
3455+ }
3456+
3457+ /* Check EEPROM */
3458+ if (!ax88179_check_eeprom(dev)) {
3459+ value = 0x42;
3460+ if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_ADDR,
3461+ 1, 1, &value) < 0)
3462+ return -EINVAL;
3463+
3464+ value = EEP_RD;
3465+ if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
3466+ 1, 1, &value) < 0)
3467+ return -EINVAL;
3468+
3469+ jtimeout = jiffies + delay;
3470+ do {
3471+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
3472+ 1, 1, &value);
3473+
3474+ if (time_after(jiffies, jtimeout))
3475+ return -EINVAL;
3476+
3477+ } while (value & EEP_BUSY);
3478+
3479+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_DATA_HIGH,
3480+ 1, 1, &value);
3481+ ledvalue = (value << 8);
3482+
3483+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_DATA_LOW,
3484+ 1, 1, &value);
3485+ ledvalue |= value;
3486+
3487+ /* load internal ROM for defaule setting */
3488+ if ((ledvalue == 0xFFFF) || ((ledvalue & LED_VALID) == 0))
3489+ ax88179_convert_old_led(dev, &ledvalue);
3490+
3491+ } else if (!ax88179_check_efuse(dev, &ledvalue)) {
3492+ if ((ledvalue == 0xFFFF) || ((ledvalue & LED_VALID) == 0))
3493+ ax88179_convert_old_led(dev, &ledvalue);
3494+ } else {
3495+ ax88179_convert_old_led(dev, &ledvalue);
3496+ }
3497+
3498+ tmp = GMII_PHY_PGSEL_EXT;
3499+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3500+ GMII_PHY_PAGE_SELECT, 2, &tmp);
3501+
3502+ tmp = 0x2c;
3503+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3504+ GMII_PHYPAGE, 2, &tmp);
3505+
3506+ ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3507+ GMII_LED_ACT, 2, &ledact);
3508+
3509+ ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3510+ GMII_LED_LINK, 2, &ledlink);
3511+
3512+ ledact &= GMII_LED_ACTIVE_MASK;
3513+ ledlink &= GMII_LED_LINK_MASK;
3514+
3515+ if (ledvalue & LED0_ACTIVE)
3516+ ledact |= GMII_LED0_ACTIVE;
3517+
3518+ if (ledvalue & LED1_ACTIVE)
3519+ ledact |= GMII_LED1_ACTIVE;
3520+
3521+ if (ledvalue & LED2_ACTIVE)
3522+ ledact |= GMII_LED2_ACTIVE;
3523+
3524+ if (ledvalue & LED0_LINK_10)
3525+ ledlink |= GMII_LED0_LINK_10;
3526+
3527+ if (ledvalue & LED1_LINK_10)
3528+ ledlink |= GMII_LED1_LINK_10;
3529+
3530+ if (ledvalue & LED2_LINK_10)
3531+ ledlink |= GMII_LED2_LINK_10;
3532+
3533+ if (ledvalue & LED0_LINK_100)
3534+ ledlink |= GMII_LED0_LINK_100;
3535+
3536+ if (ledvalue & LED1_LINK_100)
3537+ ledlink |= GMII_LED1_LINK_100;
3538+
3539+ if (ledvalue & LED2_LINK_100)
3540+ ledlink |= GMII_LED2_LINK_100;
3541+
3542+ if (ledvalue & LED0_LINK_1000)
3543+ ledlink |= GMII_LED0_LINK_1000;
3544+
3545+ if (ledvalue & LED1_LINK_1000)
3546+ ledlink |= GMII_LED1_LINK_1000;
3547+
3548+ if (ledvalue & LED2_LINK_1000)
3549+ ledlink |= GMII_LED2_LINK_1000;
3550+
3551+ tmp = ledact;
3552+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3553+ GMII_LED_ACT, 2, &tmp);
3554+
3555+ tmp = ledlink;
3556+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3557+ GMII_LED_LINK, 2, &tmp);
3558+
3559+ tmp = GMII_PHY_PGSEL_PAGE0;
3560+ ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3561+ GMII_PHY_PAGE_SELECT, 2, &tmp);
3562+
3563+ /* LED full duplex setting */
3564+ ledfd = 0;
3565+ if (ledvalue & LED0_FD)
3566+ ledfd |= 0x01;
3567+ else if ((ledvalue & LED0_USB3_MASK) == 0)
3568+ ledfd |= 0x02;
3569+
3570+ if (ledvalue & LED1_FD)
3571+ ledfd |= 0x04;
3572+ else if ((ledvalue & LED1_USB3_MASK) == 0)
3573+ ledfd |= 0x08;
3574+
3575+ if (ledvalue & LED2_FD)
3576+ ledfd |= 0x10;
3577+ else if ((ledvalue & LED2_USB3_MASK) == 0)
3578+ ledfd |= 0x20;
3579+
3580+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_LEDCTRL, 1, 1, &ledfd);
3581+
3582+ return 0;
3583+}
3584+
3585+static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf)
3586+{
3587+ u8 buf[5];
3588+ u16 *tmp16;
3589+ u8 *tmp;
3590+ struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
3591+ struct ethtool_eee eee_data;
3592+
3593+ usbnet_get_endpoints(dev, intf);
3594+
3595+ tmp16 = (u16 *)buf;
3596+ tmp = (u8 *)buf;
3597+
3598+ memset(ax179_data, 0, sizeof(*ax179_data));
3599+
3600+ /* Power up ethernet PHY */
3601+ *tmp16 = 0;
3602+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
3603+ *tmp16 = AX_PHYPWR_RSTCTL_IPRL;
3604+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
3605+ msleep(200);
3606+
3607+ *tmp = AX_CLK_SELECT_ACS | AX_CLK_SELECT_BCS;
3608+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp);
3609+ msleep(100);
3610+
3611+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN,
3612+ ETH_ALEN, dev->net->dev_addr);
3613+ memcpy(dev->net->perm_addr, dev->net->dev_addr, ETH_ALEN);
3614+
3615+ /* RX bulk configuration */
3616+ memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5);
3617+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_BULKIN_QCTRL, 5, 5, tmp);
3618+
3619+ dev->rx_urb_size = 1024 * 20;
3620+
3621+ *tmp = 0x34;
3622+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_LOW, 1, 1, tmp);
3623+
3624+ *tmp = 0x52;
3625+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_HIGH,
3626+ 1, 1, tmp);
3627+
3628+ dev->net->netdev_ops = &ax88179_netdev_ops;
3629+ dev->net->ethtool_ops = &ax88179_ethtool_ops;
3630+ dev->net->needed_headroom = 8;
3631+
3632+ /* Initialize MII structure */
3633+ dev->mii.dev = dev->net;
3634+ dev->mii.mdio_read = ax88179_mdio_read;
3635+ dev->mii.mdio_write = ax88179_mdio_write;
3636+ dev->mii.phy_id_mask = 0xff;
3637+ dev->mii.reg_num_mask = 0xff;
3638+ dev->mii.phy_id = 0x03;
3639+ dev->mii.supports_gmii = 1;
3640+
3641+ dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
3642+ NETIF_F_RXCSUM;
3643+
3644+ dev->net->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
3645+ NETIF_F_RXCSUM;
3646+
3647+ /* Enable checksum offload */
3648+ *tmp = AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP |
3649+ AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6;
3650+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, tmp);
3651+
3652+ *tmp = AX_TXCOE_IP | AX_TXCOE_TCP | AX_TXCOE_UDP |
3653+ AX_TXCOE_TCPV6 | AX_TXCOE_UDPV6;
3654+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, tmp);
3655+
3656+ /* Configure RX control register => start operation */
3657+ *tmp16 = AX_RX_CTL_DROPCRCERR | AX_RX_CTL_IPE | AX_RX_CTL_START |
3658+ AX_RX_CTL_AP | AX_RX_CTL_AMALL | AX_RX_CTL_AB;
3659+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp16);
3660+
3661+ *tmp = AX_MONITOR_MODE_PMETYPE | AX_MONITOR_MODE_PMEPOL |
3662+ AX_MONITOR_MODE_RWMP;
3663+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MOD, 1, 1, tmp);
3664+
3665+ /* Configure default medium type => giga */
3666+ *tmp16 = AX_MEDIUM_RECEIVE_EN | AX_MEDIUM_TXFLOW_CTRLEN |
3667+ AX_MEDIUM_RXFLOW_CTRLEN | AX_MEDIUM_FULL_DUPLEX |
3668+ AX_MEDIUM_GIGAMODE;
3669+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3670+ 2, 2, tmp16);
3671+
3672+ ax88179_led_setting(dev);
3673+
3674+ ax179_data->eee_enabled = 0;
3675+ ax179_data->eee_active = 0;
3676+
3677+ ax88179_disable_eee(dev);
3678+
3679+ ax88179_ethtool_get_eee(dev, &eee_data);
3680+ eee_data.advertised = 0;
3681+ ax88179_ethtool_set_eee(dev, &eee_data);
3682+
3683+ /* Restart autoneg */
3684+ mii_nway_restart(&dev->mii);
3685+
3686+ usbnet_link_change(dev, 0, 0);
3687+
3688+ return 0;
3689+}
3690+
3691+static void ax88179_unbind(struct usbnet *dev, struct usb_interface *intf)
3692+{
3693+ u16 tmp16;
3694+
3695+ /* Configure RX control register => stop operation */
3696+ tmp16 = AX_RX_CTL_STOP;
3697+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, &tmp16);
3698+
3699+ tmp16 = 0;
3700+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, &tmp16);
3701+
3702+ /* Power down ethernet PHY */
3703+ tmp16 = 0;
3704+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, &tmp16);
3705+}
3706+
3707+static void
3708+ax88179_rx_checksum(struct sk_buff *skb, u32 *pkt_hdr)
3709+{
3710+ skb->ip_summed = CHECKSUM_NONE;
3711+
3712+ /* checksum error bit is set */
3713+ if ((*pkt_hdr & AX_RXHDR_L3CSUM_ERR) ||
3714+ (*pkt_hdr & AX_RXHDR_L4CSUM_ERR))
3715+ return;
3716+
3717+ /* It must be a TCP or UDP packet with a valid checksum */
3718+ if (((*pkt_hdr & AX_RXHDR_L4_TYPE_MASK) == AX_RXHDR_L4_TYPE_TCP) ||
3719+ ((*pkt_hdr & AX_RXHDR_L4_TYPE_MASK) == AX_RXHDR_L4_TYPE_UDP))
3720+ skb->ip_summed = CHECKSUM_UNNECESSARY;
3721+}
3722+
3723+static int ax88179_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
3724+{
3725+ struct sk_buff *ax_skb;
3726+ int pkt_cnt;
3727+ u32 rx_hdr;
3728+ u16 hdr_off;
3729+ u32 *pkt_hdr;
3730+
3731+ /* This check is no longer done by usbnet */
3732+ if (skb->len < dev->net->hard_header_len)
3733+ return 0;
3734+
3735+ skb_trim(skb, skb->len - 4);
3736+ memcpy(&rx_hdr, skb_tail_pointer(skb), 4);
3737+ le32_to_cpus(&rx_hdr);
3738+
3739+ pkt_cnt = (u16)rx_hdr;
3740+ hdr_off = (u16)(rx_hdr >> 16);
3741+ pkt_hdr = (u32 *)(skb->data + hdr_off);
3742+
3743+ while (pkt_cnt--) {
3744+ u16 pkt_len;
3745+
3746+ le32_to_cpus(pkt_hdr);
3747+ pkt_len = (*pkt_hdr >> 16) & 0x1fff;
3748+
3749+ /* Check CRC or runt packet */
3750+ if ((*pkt_hdr & AX_RXHDR_CRC_ERR) ||
3751+ (*pkt_hdr & AX_RXHDR_DROP_ERR)) {
3752+ skb_pull(skb, (pkt_len + 7) & 0xFFF8);
3753+ pkt_hdr++;
3754+ continue;
3755+ }
3756+
3757+ if (pkt_cnt == 0) {
3758+ /* Skip IP alignment psudo header */
3759+ skb_pull(skb, 2);
3760+ skb->len = pkt_len;
3761+ skb_set_tail_pointer(skb, pkt_len);
3762+ skb->truesize = pkt_len + sizeof(struct sk_buff);
3763+ ax88179_rx_checksum(skb, pkt_hdr);
3764+ return 1;
3765+ }
3766+
3767+ ax_skb = skb_clone(skb, GFP_ATOMIC);
3768+ if (ax_skb) {
3769+ ax_skb->len = pkt_len;
3770+ ax_skb->data = skb->data + 2;
3771+ skb_set_tail_pointer(ax_skb, pkt_len);
3772+ ax_skb->truesize = pkt_len + sizeof(struct sk_buff);
3773+ ax88179_rx_checksum(ax_skb, pkt_hdr);
3774+ usbnet_skb_return(dev, ax_skb);
3775+ } else {
3776+ return 0;
3777+ }
3778+
3779+ skb_pull(skb, (pkt_len + 7) & 0xFFF8);
3780+ pkt_hdr++;
3781+ }
3782+ return 1;
3783+}
3784+
3785+static struct sk_buff *
3786+ax88179_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
3787+{
3788+ u32 tx_hdr1, tx_hdr2;
3789+ int frame_size = dev->maxpacket;
3790+ int mss = skb_shinfo(skb)->gso_size;
3791+ int headroom;
3792+
3793+ tx_hdr1 = skb->len;
3794+ tx_hdr2 = mss;
3795+ if (((skb->len + 8) % frame_size) == 0)
3796+ tx_hdr2 |= 0x80008000; /* Enable padding */
3797+
3798+ headroom = skb_headroom(skb) - 8;
3799+
3800+ if ((skb_header_cloned(skb) || headroom < 0) &&
3801+ pskb_expand_head(skb, headroom < 0 ? 8 : 0, 0, GFP_ATOMIC)) {
3802+ dev_kfree_skb_any(skb);
3803+ return NULL;
3804+ }
3805+
3806+ skb_push(skb, 4);
3807+ cpu_to_le32s(&tx_hdr2);
3808+ skb_copy_to_linear_data(skb, &tx_hdr2, 4);
3809+
3810+ skb_push(skb, 4);
3811+ cpu_to_le32s(&tx_hdr1);
3812+ skb_copy_to_linear_data(skb, &tx_hdr1, 4);
3813+
3814+ return skb;
3815+}
3816+
3817+static int ax88179_link_reset(struct usbnet *dev)
3818+{
3819+ struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
3820+ u8 tmp[5], link_sts;
3821+ u16 mode, tmp16, delay = HZ / 10;
3822+ u32 tmp32 = 0x40000000;
3823+ unsigned long jtimeout;
3824+
3825+ jtimeout = jiffies + delay;
3826+ while (tmp32 & 0x40000000) {
3827+ mode = 0;
3828+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, &mode);
3829+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2,
3830+ &ax179_data->rxctl);
3831+
3832+ /*link up, check the usb device control TX FIFO full or empty*/
3833+ ax88179_read_cmd(dev, 0x81, 0x8c, 0, 4, &tmp32);
3834+
3835+ if (time_after(jiffies, jtimeout))
3836+ return 0;
3837+ }
3838+
3839+ mode = AX_MEDIUM_RECEIVE_EN | AX_MEDIUM_TXFLOW_CTRLEN |
3840+ AX_MEDIUM_RXFLOW_CTRLEN;
3841+
3842+ ax88179_read_cmd(dev, AX_ACCESS_MAC, PHYSICAL_LINK_STATUS,
3843+ 1, 1, &link_sts);
3844+
3845+ ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
3846+ GMII_PHY_PHYSR, 2, &tmp16);
3847+
3848+ if (!(tmp16 & GMII_PHY_PHYSR_LINK)) {
3849+ return 0;
3850+ } else if (GMII_PHY_PHYSR_GIGA == (tmp16 & GMII_PHY_PHYSR_SMASK)) {
3851+ mode |= AX_MEDIUM_GIGAMODE | AX_MEDIUM_EN_125MHZ;
3852+ if (dev->net->mtu > 1500)
3853+ mode |= AX_MEDIUM_JUMBO_EN;
3854+
3855+ if (link_sts & AX_USB_SS)
3856+ memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5);
3857+ else if (link_sts & AX_USB_HS)
3858+ memcpy(tmp, &AX88179_BULKIN_SIZE[1], 5);
3859+ else
3860+ memcpy(tmp, &AX88179_BULKIN_SIZE[3], 5);
3861+ } else if (GMII_PHY_PHYSR_100 == (tmp16 & GMII_PHY_PHYSR_SMASK)) {
3862+ mode |= AX_MEDIUM_PS;
3863+
3864+ if (link_sts & (AX_USB_SS | AX_USB_HS))
3865+ memcpy(tmp, &AX88179_BULKIN_SIZE[2], 5);
3866+ else
3867+ memcpy(tmp, &AX88179_BULKIN_SIZE[3], 5);
3868+ } else {
3869+ memcpy(tmp, &AX88179_BULKIN_SIZE[3], 5);
3870+ }
3871+
3872+ /* RX bulk configuration */
3873+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_BULKIN_QCTRL, 5, 5, tmp);
3874+
3875+ dev->rx_urb_size = (1024 * (tmp[3] + 2));
3876+
3877+ if (tmp16 & GMII_PHY_PHYSR_FULL)
3878+ mode |= AX_MEDIUM_FULL_DUPLEX;
3879+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3880+ 2, 2, &mode);
3881+
3882+ ax179_data->eee_enabled = ax88179_chk_eee(dev);
3883+
3884+ netif_carrier_on(dev->net);
3885+
3886+ return 0;
3887+}
3888+
3889+static int ax88179_reset(struct usbnet *dev)
3890+{
3891+ u8 buf[5];
3892+ u16 *tmp16;
3893+ u8 *tmp;
3894+ struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
3895+ struct ethtool_eee eee_data;
3896+
3897+ tmp16 = (u16 *)buf;
3898+ tmp = (u8 *)buf;
3899+
3900+ /* Power up ethernet PHY */
3901+ *tmp16 = 0;
3902+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
3903+
3904+ *tmp16 = AX_PHYPWR_RSTCTL_IPRL;
3905+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
3906+ msleep(200);
3907+
3908+ *tmp = AX_CLK_SELECT_ACS | AX_CLK_SELECT_BCS;
3909+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp);
3910+ msleep(100);
3911+
3912+ /* Ethernet PHY Auto Detach*/
3913+ ax88179_auto_detach(dev, 0);
3914+
3915+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN, ETH_ALEN,
3916+ dev->net->dev_addr);
3917+ memcpy(dev->net->perm_addr, dev->net->dev_addr, ETH_ALEN);
3918+
3919+ /* RX bulk configuration */
3920+ memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5);
3921+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_BULKIN_QCTRL, 5, 5, tmp);
3922+
3923+ dev->rx_urb_size = 1024 * 20;
3924+
3925+ *tmp = 0x34;
3926+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_LOW, 1, 1, tmp);
3927+
3928+ *tmp = 0x52;
3929+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_HIGH,
3930+ 1, 1, tmp);
3931+
3932+ dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
3933+ NETIF_F_RXCSUM;
3934+
3935+ dev->net->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
3936+ NETIF_F_RXCSUM;
3937+
3938+ /* Enable checksum offload */
3939+ *tmp = AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP |
3940+ AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6;
3941+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, tmp);
3942+
3943+ *tmp = AX_TXCOE_IP | AX_TXCOE_TCP | AX_TXCOE_UDP |
3944+ AX_TXCOE_TCPV6 | AX_TXCOE_UDPV6;
3945+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, tmp);
3946+
3947+ /* Configure RX control register => start operation */
3948+ *tmp16 = AX_RX_CTL_DROPCRCERR | AX_RX_CTL_IPE | AX_RX_CTL_START |
3949+ AX_RX_CTL_AP | AX_RX_CTL_AMALL | AX_RX_CTL_AB;
3950+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp16);
3951+
3952+ *tmp = AX_MONITOR_MODE_PMETYPE | AX_MONITOR_MODE_PMEPOL |
3953+ AX_MONITOR_MODE_RWMP;
3954+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MOD, 1, 1, tmp);
3955+
3956+ /* Configure default medium type => giga */
3957+ *tmp16 = AX_MEDIUM_RECEIVE_EN | AX_MEDIUM_TXFLOW_CTRLEN |
3958+ AX_MEDIUM_RXFLOW_CTRLEN | AX_MEDIUM_FULL_DUPLEX |
3959+ AX_MEDIUM_GIGAMODE;
3960+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3961+ 2, 2, tmp16);
3962+
3963+ ax88179_led_setting(dev);
3964+
3965+ ax179_data->eee_enabled = 0;
3966+ ax179_data->eee_active = 0;
3967+
3968+ ax88179_disable_eee(dev);
3969+
3970+ ax88179_ethtool_get_eee(dev, &eee_data);
3971+ eee_data.advertised = 0;
3972+ ax88179_ethtool_set_eee(dev, &eee_data);
3973+
3974+ /* Restart autoneg */
3975+ mii_nway_restart(&dev->mii);
3976+
3977+ usbnet_link_change(dev, 0, 0);
3978+
3979+ return 0;
3980+}
3981+
3982+static int ax88179_stop(struct usbnet *dev)
3983+{
3984+ u16 tmp16;
3985+
3986+ ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3987+ 2, 2, &tmp16);
3988+ tmp16 &= ~AX_MEDIUM_RECEIVE_EN;
3989+ ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
3990+ 2, 2, &tmp16);
3991+
3992+ return 0;
3993+}
3994+
3995+static const struct driver_info ax88179_info = {
3996+ .description = "ASIX AX88179 USB 3.0 Gigabit Ethernet",
3997+ .bind = ax88179_bind,
3998+ .unbind = ax88179_unbind,
3999+ .status = ax88179_status,
4000+ .link_reset = ax88179_link_reset,
4001+ .reset = ax88179_reset,
4002+ .stop = ax88179_stop,
4003+ .flags = FLAG_ETHER | FLAG_FRAMING_AX,
4004+ .rx_fixup = ax88179_rx_fixup,
4005+ .tx_fixup = ax88179_tx_fixup,
4006+};
4007+
4008+static const struct driver_info ax88178a_info = {
4009+ .description = "ASIX AX88178A USB 2.0 Gigabit Ethernet",
4010+ .bind = ax88179_bind,
4011+ .unbind = ax88179_unbind,
4012+ .status = ax88179_status,
4013+ .link_reset = ax88179_link_reset,
4014+ .reset = ax88179_reset,
4015+ .stop = ax88179_stop,
4016+ .flags = FLAG_ETHER | FLAG_FRAMING_AX,
4017+ .rx_fixup = ax88179_rx_fixup,
4018+ .tx_fixup = ax88179_tx_fixup,
4019+};
4020+
4021+static const struct driver_info dlink_dub1312_info = {
4022+ .description = "D-Link DUB-1312 USB 3.0 to Gigabit Ethernet Adapter",
4023+ .bind = ax88179_bind,
4024+ .unbind = ax88179_unbind,
4025+ .status = ax88179_status,
4026+ .link_reset = ax88179_link_reset,
4027+ .reset = ax88179_reset,
4028+ .stop = ax88179_stop,
4029+ .flags = FLAG_ETHER | FLAG_FRAMING_AX,
4030+ .rx_fixup = ax88179_rx_fixup,
4031+ .tx_fixup = ax88179_tx_fixup,
4032+};
4033+
4034+static const struct driver_info sitecom_info = {
4035+ .description = "Sitecom USB 3.0 to Gigabit Adapter",
4036+ .bind = ax88179_bind,
4037+ .unbind = ax88179_unbind,
4038+ .status = ax88179_status,
4039+ .link_reset = ax88179_link_reset,
4040+ .reset = ax88179_reset,
4041+ .stop = ax88179_stop,
4042+ .flags = FLAG_ETHER | FLAG_FRAMING_AX,
4043+ .rx_fixup = ax88179_rx_fixup,
4044+ .tx_fixup = ax88179_tx_fixup,
4045+};
4046+
4047+static const struct driver_info samsung_info = {
4048+ .description = "Samsung USB Ethernet Adapter",
4049+ .bind = ax88179_bind,
4050+ .unbind = ax88179_unbind,
4051+ .status = ax88179_status,
4052+ .link_reset = ax88179_link_reset,
4053+ .reset = ax88179_reset,
4054+ .stop = ax88179_stop,
4055+ .flags = FLAG_ETHER | FLAG_FRAMING_AX,
4056+ .rx_fixup = ax88179_rx_fixup,
4057+ .tx_fixup = ax88179_tx_fixup,
4058+};
4059+
4060+static const struct driver_info lenovo_info = {
4061+ .description = "Lenovo OneLinkDock Gigabit LAN",
4062+ .bind = ax88179_bind,
4063+ .unbind = ax88179_unbind,
4064+ .status = ax88179_status,
4065+ .link_reset = ax88179_link_reset,
4066+ .reset = ax88179_reset,
4067+ .stop = ax88179_stop,
4068+ .flags = FLAG_ETHER | FLAG_FRAMING_AX,
4069+ .rx_fixup = ax88179_rx_fixup,
4070+ .tx_fixup = ax88179_tx_fixup,
4071+};
4072+
4073+static const struct usb_device_id products[] = {
4074+{
4075+ /* ASIX AX88179 10/100/1000 */
4076+ USB_DEVICE(0x0b95, 0x1790),
4077+ .driver_info = (unsigned long)&ax88179_info,
4078+}, {
4079+ /* ASIX AX88178A 10/100/1000 */
4080+ USB_DEVICE(0x0b95, 0x178a),
4081+ .driver_info = (unsigned long)&ax88178a_info,
4082+}, {
4083+ /* D-Link DUB-1312 USB 3.0 to Gigabit Ethernet Adapter */
4084+ USB_DEVICE(0x2001, 0x4a00),
4085+ .driver_info = (unsigned long)&dlink_dub1312_info,
4086+}, {
4087+ /* Sitecom USB 3.0 to Gigabit Adapter */
4088+ USB_DEVICE(0x0df6, 0x0072),
4089+ .driver_info = (unsigned long)&sitecom_info,
4090+}, {
4091+ /* Samsung USB Ethernet Adapter */
4092+ USB_DEVICE(0x04e8, 0xa100),
4093+ .driver_info = (unsigned long)&samsung_info,
4094+}, {
4095+ /* Lenovo OneLinkDock Gigabit LAN */
4096+ USB_DEVICE(0x17ef, 0x304b),
4097+ .driver_info = (unsigned long)&lenovo_info,
4098+},
4099+ { },
4100+};
4101+MODULE_DEVICE_TABLE(usb, products);
4102+
4103+static struct usb_driver ax88179_178a_driver = {
4104+ .name = "ax88179_178a",
4105+ .id_table = products,
4106+ .probe = usbnet_probe,
4107+ .suspend = ax88179_suspend,
4108+ .resume = ax88179_resume,
4109+ .reset_resume = ax88179_resume,
4110+ .disconnect = usbnet_disconnect,
4111+ .supports_autosuspend = 1,
4112+ .disable_hub_initiated_lpm = 1,
4113+};
4114+
4115+module_usb_driver(ax88179_178a_driver);
4116+
4117+MODULE_DESCRIPTION("ASIX AX88179/178A based USB 3.0/2.0 Gigabit Ethernet Devices");
4118+MODULE_LICENSE("GPL");
4119diff -Naur backports-3.18.1-1.org/drivers/net/usb/catc.c backports-3.18.1-1/drivers/net/usb/catc.c
4120--- backports-3.18.1-1.org/drivers/net/usb/catc.c 1970-01-01 01:00:00.000000000 +0100
4121+++ backports-3.18.1-1/drivers/net/usb/catc.c 2014-12-16 18:39:45.000000000 +0100
4122@@ -0,0 +1,965 @@
4123+/*
4124+ * Copyright (c) 2001 Vojtech Pavlik
4125+ *
4126+ * CATC EL1210A NetMate USB Ethernet driver
4127+ *
4128+ * Sponsored by SuSE
4129+ *
4130+ * Based on the work of
4131+ * Donald Becker
4132+ *
4133+ * Old chipset support added by Simon Evans <spse@secret.org.uk> 2002
4134+ * - adds support for Belkin F5U011
4135+ */
4136+
4137+/*
4138+ * This program is free software; you can redistribute it and/or modify
4139+ * it under the terms of the GNU General Public License as published by
4140+ * the Free Software Foundation; either version 2 of the License, or
4141+ * (at your option) any later version.
4142+ *
4143+ * This program is distributed in the hope that it will be useful,
4144+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
4145+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4146+ * GNU General Public License for more details.
4147+ *
4148+ * You should have received a copy of the GNU General Public License
4149+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
4150+ *
4151+ * Should you need to contact me, the author, you can do so either by
4152+ * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
4153+ * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
4154+ */
4155+
4156+#include <linux/module.h>
4157+#include <linux/kernel.h>
4158+#include <linux/string.h>
4159+#include <linux/netdevice.h>
4160+#include <linux/etherdevice.h>
4161+#include <linux/skbuff.h>
4162+#include <linux/spinlock.h>
4163+#include <linux/ethtool.h>
4164+#include <linux/crc32.h>
4165+#include <linux/bitops.h>
4166+#include <linux/gfp.h>
4167+#include <asm/uaccess.h>
4168+
4169+#undef DEBUG
4170+
4171+#include <linux/usb.h>
4172+
4173+/*
4174+ * Version information.
4175+ */
4176+
4177+#define DRIVER_VERSION "v2.8"
4178+#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@suse.cz>"
4179+#define DRIVER_DESC "CATC EL1210A NetMate USB Ethernet driver"
4180+#define SHORT_DRIVER_DESC "EL1210A NetMate USB Ethernet"
4181+
4182+MODULE_AUTHOR(DRIVER_AUTHOR);
4183+MODULE_DESCRIPTION(DRIVER_DESC);
4184+MODULE_LICENSE("GPL");
4185+
4186+static const char driver_name[] = "catc";
4187+
4188+/*
4189+ * Some defines.
4190+ */
4191+
4192+#define STATS_UPDATE (HZ) /* Time between stats updates */
4193+#define TX_TIMEOUT (5*HZ) /* Max time the queue can be stopped */
4194+#define PKT_SZ 1536 /* Max Ethernet packet size */
4195+#define RX_MAX_BURST 15 /* Max packets per rx buffer (> 0, < 16) */
4196+#define TX_MAX_BURST 15 /* Max full sized packets per tx buffer (> 0) */
4197+#define CTRL_QUEUE 16 /* Max control requests in flight (power of two) */
4198+#define RX_PKT_SZ 1600 /* Max size of receive packet for F5U011 */
4199+
4200+/*
4201+ * Control requests.
4202+ */
4203+
4204+enum control_requests {
4205+ ReadMem = 0xf1,
4206+ GetMac = 0xf2,
4207+ Reset = 0xf4,
4208+ SetMac = 0xf5,
4209+ SetRxMode = 0xf5, /* F5U011 only */
4210+ WriteROM = 0xf8,
4211+ SetReg = 0xfa,
4212+ GetReg = 0xfb,
4213+ WriteMem = 0xfc,
4214+ ReadROM = 0xfd,
4215+};
4216+
4217+/*
4218+ * Registers.
4219+ */
4220+
4221+enum register_offsets {
4222+ TxBufCount = 0x20,
4223+ RxBufCount = 0x21,
4224+ OpModes = 0x22,
4225+ TxQed = 0x23,
4226+ RxQed = 0x24,
4227+ MaxBurst = 0x25,
4228+ RxUnit = 0x60,
4229+ EthStatus = 0x61,
4230+ StationAddr0 = 0x67,
4231+ EthStats = 0x69,
4232+ LEDCtrl = 0x81,
4233+};
4234+
4235+enum eth_stats {
4236+ TxSingleColl = 0x00,
4237+ TxMultiColl = 0x02,
4238+ TxExcessColl = 0x04,
4239+ RxFramErr = 0x06,
4240+};
4241+
4242+enum op_mode_bits {
4243+ Op3MemWaits = 0x03,
4244+ OpLenInclude = 0x08,
4245+ OpRxMerge = 0x10,
4246+ OpTxMerge = 0x20,
4247+ OpWin95bugfix = 0x40,
4248+ OpLoopback = 0x80,
4249+};
4250+
4251+enum rx_filter_bits {
4252+ RxEnable = 0x01,
4253+ RxPolarity = 0x02,
4254+ RxForceOK = 0x04,
4255+ RxMultiCast = 0x08,
4256+ RxPromisc = 0x10,
4257+ AltRxPromisc = 0x20, /* F5U011 uses different bit */
4258+};
4259+
4260+enum led_values {
4261+ LEDFast = 0x01,
4262+ LEDSlow = 0x02,
4263+ LEDFlash = 0x03,
4264+ LEDPulse = 0x04,
4265+ LEDLink = 0x08,
4266+};
4267+
4268+enum link_status {
4269+ LinkNoChange = 0,
4270+ LinkGood = 1,
4271+ LinkBad = 2
4272+};
4273+
4274+/*
4275+ * The catc struct.
4276+ */
4277+
4278+#define CTRL_RUNNING 0
4279+#define RX_RUNNING 1
4280+#define TX_RUNNING 2
4281+
4282+struct catc {
4283+ struct net_device *netdev;
4284+ struct usb_device *usbdev;
4285+
4286+ unsigned long flags;
4287+
4288+ unsigned int tx_ptr, tx_idx;
4289+ unsigned int ctrl_head, ctrl_tail;
4290+ spinlock_t tx_lock, ctrl_lock;
4291+
4292+ u8 tx_buf[2][TX_MAX_BURST * (PKT_SZ + 2)];
4293+ u8 rx_buf[RX_MAX_BURST * (PKT_SZ + 2)];
4294+ u8 irq_buf[2];
4295+ u8 ctrl_buf[64];
4296+ struct usb_ctrlrequest ctrl_dr;
4297+
4298+ struct timer_list timer;
4299+ u8 stats_buf[8];
4300+ u16 stats_vals[4];
4301+ unsigned long last_stats;
4302+
4303+ u8 multicast[64];
4304+
4305+ struct ctrl_queue {
4306+ u8 dir;
4307+ u8 request;
4308+ u16 value;
4309+ u16 index;
4310+ void *buf;
4311+ int len;
4312+ void (*callback)(struct catc *catc, struct ctrl_queue *q);
4313+ } ctrl_queue[CTRL_QUEUE];
4314+
4315+ struct urb *tx_urb, *rx_urb, *irq_urb, *ctrl_urb;
4316+
4317+ u8 is_f5u011; /* Set if device is an F5U011 */
4318+ u8 rxmode[2]; /* Used for F5U011 */
4319+ atomic_t recq_sz; /* Used for F5U011 - counter of waiting rx packets */
4320+};
4321+
4322+/*
4323+ * Useful macros.
4324+ */
4325+
4326+#define catc_get_mac(catc, mac) catc_ctrl_msg(catc, USB_DIR_IN, GetMac, 0, 0, mac, 6)
4327+#define catc_reset(catc) catc_ctrl_msg(catc, USB_DIR_OUT, Reset, 0, 0, NULL, 0)
4328+#define catc_set_reg(catc, reg, val) catc_ctrl_msg(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0)
4329+#define catc_get_reg(catc, reg, buf) catc_ctrl_msg(catc, USB_DIR_IN, GetReg, 0, reg, buf, 1)
4330+#define catc_write_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size)
4331+#define catc_read_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_IN, ReadMem, 0, addr, buf, size)
4332+
4333+#define f5u011_rxmode(catc, rxmode) catc_ctrl_msg(catc, USB_DIR_OUT, SetRxMode, 0, 1, rxmode, 2)
4334+#define f5u011_rxmode_async(catc, rxmode) catc_ctrl_async(catc, USB_DIR_OUT, SetRxMode, 0, 1, &rxmode, 2, NULL)
4335+#define f5u011_mchash_async(catc, hash) catc_ctrl_async(catc, USB_DIR_OUT, SetRxMode, 0, 2, &hash, 8, NULL)
4336+
4337+#define catc_set_reg_async(catc, reg, val) catc_ctrl_async(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0, NULL)
4338+#define catc_get_reg_async(catc, reg, cb) catc_ctrl_async(catc, USB_DIR_IN, GetReg, 0, reg, NULL, 1, cb)
4339+#define catc_write_mem_async(catc, addr, buf, size) catc_ctrl_async(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size, NULL)
4340+
4341+/*
4342+ * Receive routines.
4343+ */
4344+
4345+static void catc_rx_done(struct urb *urb)
4346+{
4347+ struct catc *catc = urb->context;
4348+ u8 *pkt_start = urb->transfer_buffer;
4349+ struct sk_buff *skb;
4350+ int pkt_len, pkt_offset = 0;
4351+ int status = urb->status;
4352+
4353+ if (!catc->is_f5u011) {
4354+ clear_bit(RX_RUNNING, &catc->flags);
4355+ pkt_offset = 2;
4356+ }
4357+
4358+ if (status) {
4359+ dev_dbg(&urb->dev->dev, "rx_done, status %d, length %d\n",
4360+ status, urb->actual_length);
4361+ return;
4362+ }
4363+
4364+ do {
4365+ if(!catc->is_f5u011) {
4366+ pkt_len = le16_to_cpup((__le16*)pkt_start);
4367+ if (pkt_len > urb->actual_length) {
4368+ catc->netdev->stats.rx_length_errors++;
4369+ catc->netdev->stats.rx_errors++;
4370+ break;
4371+ }
4372+ } else {
4373+ pkt_len = urb->actual_length;
4374+ }
4375+
4376+ if (!(skb = dev_alloc_skb(pkt_len)))
4377+ return;
4378+
4379+ skb_copy_to_linear_data(skb, pkt_start + pkt_offset, pkt_len);
4380+ skb_put(skb, pkt_len);
4381+
4382+ skb->protocol = eth_type_trans(skb, catc->netdev);
4383+ netif_rx(skb);
4384+
4385+ catc->netdev->stats.rx_packets++;
4386+ catc->netdev->stats.rx_bytes += pkt_len;
4387+
4388+ /* F5U011 only does one packet per RX */
4389+ if (catc->is_f5u011)
4390+ break;
4391+ pkt_start += (((pkt_len + 1) >> 6) + 1) << 6;
4392+
4393+ } while (pkt_start - (u8 *) urb->transfer_buffer < urb->actual_length);
4394+
4395+ if (catc->is_f5u011) {
4396+ if (atomic_read(&catc->recq_sz)) {
4397+ int state;
4398+ atomic_dec(&catc->recq_sz);
4399+ netdev_dbg(catc->netdev, "getting extra packet\n");
4400+ urb->dev = catc->usbdev;
4401+ if ((state = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
4402+ netdev_dbg(catc->netdev,
4403+ "submit(rx_urb) status %d\n", state);
4404+ }
4405+ } else {
4406+ clear_bit(RX_RUNNING, &catc->flags);
4407+ }
4408+ }
4409+}
4410+
4411+static void catc_irq_done(struct urb *urb)
4412+{
4413+ struct catc *catc = urb->context;
4414+ u8 *data = urb->transfer_buffer;
4415+ int status = urb->status;
4416+ unsigned int hasdata = 0, linksts = LinkNoChange;
4417+ int res;
4418+
4419+ if (!catc->is_f5u011) {
4420+ hasdata = data[1] & 0x80;
4421+ if (data[1] & 0x40)
4422+ linksts = LinkGood;
4423+ else if (data[1] & 0x20)
4424+ linksts = LinkBad;
4425+ } else {
4426+ hasdata = (unsigned int)(be16_to_cpup((__be16*)data) & 0x0fff);
4427+ if (data[0] == 0x90)
4428+ linksts = LinkGood;
4429+ else if (data[0] == 0xA0)
4430+ linksts = LinkBad;
4431+ }
4432+
4433+ switch (status) {
4434+ case 0: /* success */
4435+ break;
4436+ case -ECONNRESET: /* unlink */
4437+ case -ENOENT:
4438+ case -ESHUTDOWN:
4439+ return;
4440+ /* -EPIPE: should clear the halt */
4441+ default: /* error */
4442+ dev_dbg(&urb->dev->dev,
4443+ "irq_done, status %d, data %02x %02x.\n",
4444+ status, data[0], data[1]);
4445+ goto resubmit;
4446+ }
4447+
4448+ if (linksts == LinkGood) {
4449+ netif_carrier_on(catc->netdev);
4450+ netdev_dbg(catc->netdev, "link ok\n");
4451+ }
4452+
4453+ if (linksts == LinkBad) {
4454+ netif_carrier_off(catc->netdev);
4455+ netdev_dbg(catc->netdev, "link bad\n");
4456+ }
4457+
4458+ if (hasdata) {
4459+ if (test_and_set_bit(RX_RUNNING, &catc->flags)) {
4460+ if (catc->is_f5u011)
4461+ atomic_inc(&catc->recq_sz);
4462+ } else {
4463+ catc->rx_urb->dev = catc->usbdev;
4464+ if ((res = usb_submit_urb(catc->rx_urb, GFP_ATOMIC)) < 0) {
4465+ dev_err(&catc->usbdev->dev,
4466+ "submit(rx_urb) status %d\n", res);
4467+ }
4468+ }
4469+ }
4470+resubmit:
4471+ res = usb_submit_urb (urb, GFP_ATOMIC);
4472+ if (res)
4473+ dev_err(&catc->usbdev->dev,
4474+ "can't resubmit intr, %s-%s, status %d\n",
4475+ catc->usbdev->bus->bus_name,
4476+ catc->usbdev->devpath, res);
4477+}
4478+
4479+/*
4480+ * Transmit routines.
4481+ */
4482+
4483+static int catc_tx_run(struct catc *catc)
4484+{
4485+ int status;
4486+
4487+ if (catc->is_f5u011)
4488+ catc->tx_ptr = (catc->tx_ptr + 63) & ~63;
4489+
4490+ catc->tx_urb->transfer_buffer_length = catc->tx_ptr;
4491+ catc->tx_urb->transfer_buffer = catc->tx_buf[catc->tx_idx];
4492+ catc->tx_urb->dev = catc->usbdev;
4493+
4494+ if ((status = usb_submit_urb(catc->tx_urb, GFP_ATOMIC)) < 0)
4495+ dev_err(&catc->usbdev->dev, "submit(tx_urb), status %d\n",
4496+ status);
4497+
4498+ catc->tx_idx = !catc->tx_idx;
4499+ catc->tx_ptr = 0;
4500+
4501+ catc->netdev->trans_start = jiffies;
4502+ return status;
4503+}
4504+
4505+static void catc_tx_done(struct urb *urb)
4506+{
4507+ struct catc *catc = urb->context;
4508+ unsigned long flags;
4509+ int r, status = urb->status;
4510+
4511+ if (status == -ECONNRESET) {
4512+ dev_dbg(&urb->dev->dev, "Tx Reset.\n");
4513+ urb->status = 0;
4514+ catc->netdev->trans_start = jiffies;
4515+ catc->netdev->stats.tx_errors++;
4516+ clear_bit(TX_RUNNING, &catc->flags);
4517+ netif_wake_queue(catc->netdev);
4518+ return;
4519+ }
4520+
4521+ if (status) {
4522+ dev_dbg(&urb->dev->dev, "tx_done, status %d, length %d\n",
4523+ status, urb->actual_length);
4524+ return;
4525+ }
4526+
4527+ spin_lock_irqsave(&catc->tx_lock, flags);
4528+
4529+ if (catc->tx_ptr) {
4530+ r = catc_tx_run(catc);
4531+ if (unlikely(r < 0))
4532+ clear_bit(TX_RUNNING, &catc->flags);
4533+ } else {
4534+ clear_bit(TX_RUNNING, &catc->flags);
4535+ }
4536+
4537+ netif_wake_queue(catc->netdev);
4538+
4539+ spin_unlock_irqrestore(&catc->tx_lock, flags);
4540+}
4541+
4542+static netdev_tx_t catc_start_xmit(struct sk_buff *skb,
4543+ struct net_device *netdev)
4544+{
4545+ struct catc *catc = netdev_priv(netdev);
4546+ unsigned long flags;
4547+ int r = 0;
4548+ char *tx_buf;
4549+
4550+ spin_lock_irqsave(&catc->tx_lock, flags);
4551+
4552+ catc->tx_ptr = (((catc->tx_ptr - 1) >> 6) + 1) << 6;
4553+ tx_buf = catc->tx_buf[catc->tx_idx] + catc->tx_ptr;
4554+ if (catc->is_f5u011)
4555+ *(__be16 *)tx_buf = cpu_to_be16(skb->len);
4556+ else
4557+ *(__le16 *)tx_buf = cpu_to_le16(skb->len);
4558+ skb_copy_from_linear_data(skb, tx_buf + 2, skb->len);
4559+ catc->tx_ptr += skb->len + 2;
4560+
4561+ if (!test_and_set_bit(TX_RUNNING, &catc->flags)) {
4562+ r = catc_tx_run(catc);
4563+ if (r < 0)
4564+ clear_bit(TX_RUNNING, &catc->flags);
4565+ }
4566+
4567+ if ((catc->is_f5u011 && catc->tx_ptr) ||
4568+ (catc->tx_ptr >= ((TX_MAX_BURST - 1) * (PKT_SZ + 2))))
4569+ netif_stop_queue(netdev);
4570+
4571+ spin_unlock_irqrestore(&catc->tx_lock, flags);
4572+
4573+ if (r >= 0) {
4574+ catc->netdev->stats.tx_bytes += skb->len;
4575+ catc->netdev->stats.tx_packets++;
4576+ }
4577+
4578+ dev_kfree_skb(skb);
4579+
4580+ return NETDEV_TX_OK;
4581+}
4582+
4583+static void catc_tx_timeout(struct net_device *netdev)
4584+{
4585+ struct catc *catc = netdev_priv(netdev);
4586+
4587+ dev_warn(&netdev->dev, "Transmit timed out.\n");
4588+ usb_unlink_urb(catc->tx_urb);
4589+}
4590+
4591+/*
4592+ * Control messages.
4593+ */
4594+
4595+static int catc_ctrl_msg(struct catc *catc, u8 dir, u8 request, u16 value, u16 index, void *buf, int len)
4596+{
4597+ int retval = usb_control_msg(catc->usbdev,
4598+ dir ? usb_rcvctrlpipe(catc->usbdev, 0) : usb_sndctrlpipe(catc->usbdev, 0),
4599+ request, 0x40 | dir, value, index, buf, len, 1000);
4600+ return retval < 0 ? retval : 0;
4601+}
4602+
4603+static void catc_ctrl_run(struct catc *catc)
4604+{
4605+ struct ctrl_queue *q = catc->ctrl_queue + catc->ctrl_tail;
4606+ struct usb_device *usbdev = catc->usbdev;
4607+ struct urb *urb = catc->ctrl_urb;
4608+ struct usb_ctrlrequest *dr = &catc->ctrl_dr;
4609+ int status;
4610+
4611+ dr->bRequest = q->request;
4612+ dr->bRequestType = 0x40 | q->dir;
4613+ dr->wValue = cpu_to_le16(q->value);
4614+ dr->wIndex = cpu_to_le16(q->index);
4615+ dr->wLength = cpu_to_le16(q->len);
4616+
4617+ urb->pipe = q->dir ? usb_rcvctrlpipe(usbdev, 0) : usb_sndctrlpipe(usbdev, 0);
4618+ urb->transfer_buffer_length = q->len;
4619+ urb->transfer_buffer = catc->ctrl_buf;
4620+ urb->setup_packet = (void *) dr;
4621+ urb->dev = usbdev;
4622+
4623+ if (!q->dir && q->buf && q->len)
4624+ memcpy(catc->ctrl_buf, q->buf, q->len);
4625+
4626+ if ((status = usb_submit_urb(catc->ctrl_urb, GFP_ATOMIC)))
4627+ dev_err(&catc->usbdev->dev, "submit(ctrl_urb) status %d\n",
4628+ status);
4629+}
4630+
4631+static void catc_ctrl_done(struct urb *urb)
4632+{
4633+ struct catc *catc = urb->context;
4634+ struct ctrl_queue *q;
4635+ unsigned long flags;
4636+ int status = urb->status;
4637+
4638+ if (status)
4639+ dev_dbg(&urb->dev->dev, "ctrl_done, status %d, len %d.\n",
4640+ status, urb->actual_length);
4641+
4642+ spin_lock_irqsave(&catc->ctrl_lock, flags);
4643+
4644+ q = catc->ctrl_queue + catc->ctrl_tail;
4645+
4646+ if (q->dir) {
4647+ if (q->buf && q->len)
4648+ memcpy(q->buf, catc->ctrl_buf, q->len);
4649+ else
4650+ q->buf = catc->ctrl_buf;
4651+ }
4652+
4653+ if (q->callback)
4654+ q->callback(catc, q);
4655+
4656+ catc->ctrl_tail = (catc->ctrl_tail + 1) & (CTRL_QUEUE - 1);
4657+
4658+ if (catc->ctrl_head != catc->ctrl_tail)
4659+ catc_ctrl_run(catc);
4660+ else
4661+ clear_bit(CTRL_RUNNING, &catc->flags);
4662+
4663+ spin_unlock_irqrestore(&catc->ctrl_lock, flags);
4664+}
4665+
4666+static int catc_ctrl_async(struct catc *catc, u8 dir, u8 request, u16 value,
4667+ u16 index, void *buf, int len, void (*callback)(struct catc *catc, struct ctrl_queue *q))
4668+{
4669+ struct ctrl_queue *q;
4670+ int retval = 0;
4671+ unsigned long flags;
4672+
4673+ spin_lock_irqsave(&catc->ctrl_lock, flags);
4674+
4675+ q = catc->ctrl_queue + catc->ctrl_head;
4676+
4677+ q->dir = dir;
4678+ q->request = request;
4679+ q->value = value;
4680+ q->index = index;
4681+ q->buf = buf;
4682+ q->len = len;
4683+ q->callback = callback;
4684+
4685+ catc->ctrl_head = (catc->ctrl_head + 1) & (CTRL_QUEUE - 1);
4686+
4687+ if (catc->ctrl_head == catc->ctrl_tail) {
4688+ dev_err(&catc->usbdev->dev, "ctrl queue full\n");
4689+ catc->ctrl_tail = (catc->ctrl_tail + 1) & (CTRL_QUEUE - 1);
4690+ retval = -1;
4691+ }
4692+
4693+ if (!test_and_set_bit(CTRL_RUNNING, &catc->flags))
4694+ catc_ctrl_run(catc);
4695+
4696+ spin_unlock_irqrestore(&catc->ctrl_lock, flags);
4697+
4698+ return retval;
4699+}
4700+
4701+/*
4702+ * Statistics.
4703+ */
4704+
4705+static void catc_stats_done(struct catc *catc, struct ctrl_queue *q)
4706+{
4707+ int index = q->index - EthStats;
4708+ u16 data, last;
4709+
4710+ catc->stats_buf[index] = *((char *)q->buf);
4711+
4712+ if (index & 1)
4713+ return;
4714+
4715+ data = ((u16)catc->stats_buf[index] << 8) | catc->stats_buf[index + 1];
4716+ last = catc->stats_vals[index >> 1];
4717+
4718+ switch (index) {
4719+ case TxSingleColl:
4720+ case TxMultiColl:
4721+ catc->netdev->stats.collisions += data - last;
4722+ break;
4723+ case TxExcessColl:
4724+ catc->netdev->stats.tx_aborted_errors += data - last;
4725+ catc->netdev->stats.tx_errors += data - last;
4726+ break;
4727+ case RxFramErr:
4728+ catc->netdev->stats.rx_frame_errors += data - last;
4729+ catc->netdev->stats.rx_errors += data - last;
4730+ break;
4731+ }
4732+
4733+ catc->stats_vals[index >> 1] = data;
4734+}
4735+
4736+static void catc_stats_timer(unsigned long data)
4737+{
4738+ struct catc *catc = (void *) data;
4739+ int i;
4740+
4741+ for (i = 0; i < 8; i++)
4742+ catc_get_reg_async(catc, EthStats + 7 - i, catc_stats_done);
4743+
4744+ mod_timer(&catc->timer, jiffies + STATS_UPDATE);
4745+}
4746+
4747+/*
4748+ * Receive modes. Broadcast, Multicast, Promisc.
4749+ */
4750+
4751+static void catc_multicast(unsigned char *addr, u8 *multicast)
4752+{
4753+ u32 crc;
4754+
4755+ crc = ether_crc_le(6, addr);
4756+ multicast[(crc >> 3) & 0x3f] |= 1 << (crc & 7);
4757+}
4758+
4759+static void catc_set_multicast_list(struct net_device *netdev)
4760+{
4761+ struct catc *catc = netdev_priv(netdev);
4762+ struct netdev_hw_addr *ha;
4763+ u8 broadcast[ETH_ALEN];
4764+ u8 rx = RxEnable | RxPolarity | RxMultiCast;
4765+
4766+ memset(broadcast, 0xff, ETH_ALEN);
4767+ memset(catc->multicast, 0, 64);
4768+
4769+ catc_multicast(broadcast, catc->multicast);
4770+ catc_multicast(netdev->dev_addr, catc->multicast);
4771+
4772+ if (netdev->flags & IFF_PROMISC) {
4773+ memset(catc->multicast, 0xff, 64);
4774+ rx |= (!catc->is_f5u011) ? RxPromisc : AltRxPromisc;
4775+ }
4776+
4777+ if (netdev->flags & IFF_ALLMULTI) {
4778+ memset(catc->multicast, 0xff, 64);
4779+ } else {
4780+ netdev_for_each_mc_addr(ha, netdev) {
4781+ u32 crc = ether_crc_le(6, ha->addr);
4782+ if (!catc->is_f5u011) {
4783+ catc->multicast[(crc >> 3) & 0x3f] |= 1 << (crc & 7);
4784+ } else {
4785+ catc->multicast[7-(crc >> 29)] |= 1 << ((crc >> 26) & 7);
4786+ }
4787+ }
4788+ }
4789+ if (!catc->is_f5u011) {
4790+ catc_set_reg_async(catc, RxUnit, rx);
4791+ catc_write_mem_async(catc, 0xfa80, catc->multicast, 64);
4792+ } else {
4793+ f5u011_mchash_async(catc, catc->multicast);
4794+ if (catc->rxmode[0] != rx) {
4795+ catc->rxmode[0] = rx;
4796+ netdev_dbg(catc->netdev,
4797+ "Setting RX mode to %2.2X %2.2X\n",
4798+ catc->rxmode[0], catc->rxmode[1]);
4799+ f5u011_rxmode_async(catc, catc->rxmode);
4800+ }
4801+ }
4802+}
4803+
4804+static void catc_get_drvinfo(struct net_device *dev,
4805+ struct ethtool_drvinfo *info)
4806+{
4807+ struct catc *catc = netdev_priv(dev);
4808+ strlcpy(info->driver, driver_name, sizeof(info->driver));
4809+ strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
4810+ usb_make_path(catc->usbdev, info->bus_info, sizeof(info->bus_info));
4811+}
4812+
4813+static int catc_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
4814+{
4815+ struct catc *catc = netdev_priv(dev);
4816+ if (!catc->is_f5u011)
4817+ return -EOPNOTSUPP;
4818+
4819+ cmd->supported = SUPPORTED_10baseT_Half | SUPPORTED_TP;
4820+ cmd->advertising = ADVERTISED_10baseT_Half | ADVERTISED_TP;
4821+ ethtool_cmd_speed_set(cmd, SPEED_10);
4822+ cmd->duplex = DUPLEX_HALF;
4823+ cmd->port = PORT_TP;
4824+ cmd->phy_address = 0;
4825+ cmd->transceiver = XCVR_INTERNAL;
4826+ cmd->autoneg = AUTONEG_DISABLE;
4827+ cmd->maxtxpkt = 1;
4828+ cmd->maxrxpkt = 1;
4829+ return 0;
4830+}
4831+
4832+static const struct ethtool_ops ops = {
4833+ .get_drvinfo = catc_get_drvinfo,
4834+ .get_settings = catc_get_settings,
4835+ .get_link = ethtool_op_get_link
4836+};
4837+
4838+/*
4839+ * Open, close.
4840+ */
4841+
4842+static int catc_open(struct net_device *netdev)
4843+{
4844+ struct catc *catc = netdev_priv(netdev);
4845+ int status;
4846+
4847+ catc->irq_urb->dev = catc->usbdev;
4848+ if ((status = usb_submit_urb(catc->irq_urb, GFP_KERNEL)) < 0) {
4849+ dev_err(&catc->usbdev->dev, "submit(irq_urb) status %d\n",
4850+ status);
4851+ return -1;
4852+ }
4853+
4854+ netif_start_queue(netdev);
4855+
4856+ if (!catc->is_f5u011)
4857+ mod_timer(&catc->timer, jiffies + STATS_UPDATE);
4858+
4859+ return 0;
4860+}
4861+
4862+static int catc_stop(struct net_device *netdev)
4863+{
4864+ struct catc *catc = netdev_priv(netdev);
4865+
4866+ netif_stop_queue(netdev);
4867+
4868+ if (!catc->is_f5u011)
4869+ del_timer_sync(&catc->timer);
4870+
4871+ usb_kill_urb(catc->rx_urb);
4872+ usb_kill_urb(catc->tx_urb);
4873+ usb_kill_urb(catc->irq_urb);
4874+ usb_kill_urb(catc->ctrl_urb);
4875+
4876+ return 0;
4877+}
4878+
4879+static const struct net_device_ops catc_netdev_ops = {
4880+ .ndo_open = catc_open,
4881+ .ndo_stop = catc_stop,
4882+ .ndo_start_xmit = catc_start_xmit,
4883+
4884+ .ndo_tx_timeout = catc_tx_timeout,
4885+ .ndo_set_rx_mode = catc_set_multicast_list,
4886+ .ndo_change_mtu = eth_change_mtu,
4887+ .ndo_set_mac_address = eth_mac_addr,
4888+ .ndo_validate_addr = eth_validate_addr,
4889+};
4890+
4891+/*
4892+ * USB probe, disconnect.
4893+ */
4894+
4895+static int catc_probe(struct usb_interface *intf, const struct usb_device_id *id)
4896+{
4897+ struct device *dev = &intf->dev;
4898+ struct usb_device *usbdev = interface_to_usbdev(intf);
4899+ struct net_device *netdev;
4900+ struct catc *catc;
4901+ u8 broadcast[ETH_ALEN];
4902+ int i, pktsz;
4903+
4904+ if (usb_set_interface(usbdev,
4905+ intf->altsetting->desc.bInterfaceNumber, 1)) {
4906+ dev_err(dev, "Can't set altsetting 1.\n");
4907+ return -EIO;
4908+ }
4909+
4910+ netdev = alloc_etherdev(sizeof(struct catc));
4911+ if (!netdev)
4912+ return -ENOMEM;
4913+
4914+ catc = netdev_priv(netdev);
4915+
4916+ netdev->netdev_ops = &catc_netdev_ops;
4917+ netdev->watchdog_timeo = TX_TIMEOUT;
4918+ netdev->ethtool_ops = &ops;
4919+
4920+ catc->usbdev = usbdev;
4921+ catc->netdev = netdev;
4922+
4923+ spin_lock_init(&catc->tx_lock);
4924+ spin_lock_init(&catc->ctrl_lock);
4925+
4926+ init_timer(&catc->timer);
4927+ catc->timer.data = (long) catc;
4928+ catc->timer.function = catc_stats_timer;
4929+
4930+ catc->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL);
4931+ catc->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
4932+ catc->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
4933+ catc->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
4934+ if ((!catc->ctrl_urb) || (!catc->tx_urb) ||
4935+ (!catc->rx_urb) || (!catc->irq_urb)) {
4936+ dev_err(&intf->dev, "No free urbs available.\n");
4937+ usb_free_urb(catc->ctrl_urb);
4938+ usb_free_urb(catc->tx_urb);
4939+ usb_free_urb(catc->rx_urb);
4940+ usb_free_urb(catc->irq_urb);
4941+ free_netdev(netdev);
4942+ return -ENOMEM;
4943+ }
4944+
4945+ /* The F5U011 has the same vendor/product as the netmate but a device version of 0x130 */
4946+ if (le16_to_cpu(usbdev->descriptor.idVendor) == 0x0423 &&
4947+ le16_to_cpu(usbdev->descriptor.idProduct) == 0xa &&
4948+ le16_to_cpu(catc->usbdev->descriptor.bcdDevice) == 0x0130) {
4949+ dev_dbg(dev, "Testing for f5u011\n");
4950+ catc->is_f5u011 = 1;
4951+ atomic_set(&catc->recq_sz, 0);
4952+ pktsz = RX_PKT_SZ;
4953+ } else {
4954+ pktsz = RX_MAX_BURST * (PKT_SZ + 2);
4955+ }
4956+
4957+ usb_fill_control_urb(catc->ctrl_urb, usbdev, usb_sndctrlpipe(usbdev, 0),
4958+ NULL, NULL, 0, catc_ctrl_done, catc);
4959+
4960+ usb_fill_bulk_urb(catc->tx_urb, usbdev, usb_sndbulkpipe(usbdev, 1),
4961+ NULL, 0, catc_tx_done, catc);
4962+
4963+ usb_fill_bulk_urb(catc->rx_urb, usbdev, usb_rcvbulkpipe(usbdev, 1),
4964+ catc->rx_buf, pktsz, catc_rx_done, catc);
4965+
4966+ usb_fill_int_urb(catc->irq_urb, usbdev, usb_rcvintpipe(usbdev, 2),
4967+ catc->irq_buf, 2, catc_irq_done, catc, 1);
4968+
4969+ if (!catc->is_f5u011) {
4970+ dev_dbg(dev, "Checking memory size\n");
4971+
4972+ i = 0x12345678;
4973+ catc_write_mem(catc, 0x7a80, &i, 4);
4974+ i = 0x87654321;
4975+ catc_write_mem(catc, 0xfa80, &i, 4);
4976+ catc_read_mem(catc, 0x7a80, &i, 4);
4977+
4978+ switch (i) {
4979+ case 0x12345678:
4980+ catc_set_reg(catc, TxBufCount, 8);
4981+ catc_set_reg(catc, RxBufCount, 32);
4982+ dev_dbg(dev, "64k Memory\n");
4983+ break;
4984+ default:
4985+ dev_warn(&intf->dev,
4986+ "Couldn't detect memory size, assuming 32k\n");
4987+ case 0x87654321:
4988+ catc_set_reg(catc, TxBufCount, 4);
4989+ catc_set_reg(catc, RxBufCount, 16);
4990+ dev_dbg(dev, "32k Memory\n");
4991+ break;
4992+ }
4993+
4994+ dev_dbg(dev, "Getting MAC from SEEROM.\n");
4995+
4996+ catc_get_mac(catc, netdev->dev_addr);
4997+
4998+ dev_dbg(dev, "Setting MAC into registers.\n");
4999+
5000+ for (i = 0; i < 6; i++)
5001+ catc_set_reg(catc, StationAddr0 - i, netdev->dev_addr[i]);
5002+
5003+ dev_dbg(dev, "Filling the multicast list.\n");
5004+
5005+ memset(broadcast, 0xff, ETH_ALEN);
5006+ catc_multicast(broadcast, catc->multicast);
5007+ catc_multicast(netdev->dev_addr, catc->multicast);
5008+ catc_write_mem(catc, 0xfa80, catc->multicast, 64);
5009+
5010+ dev_dbg(dev, "Clearing error counters.\n");
5011+
5012+ for (i = 0; i < 8; i++)
5013+ catc_set_reg(catc, EthStats + i, 0);
5014+ catc->last_stats = jiffies;
5015+
5016+ dev_dbg(dev, "Enabling.\n");
5017+
5018+ catc_set_reg(catc, MaxBurst, RX_MAX_BURST);
5019+ catc_set_reg(catc, OpModes, OpTxMerge | OpRxMerge | OpLenInclude | Op3MemWaits);
5020+ catc_set_reg(catc, LEDCtrl, LEDLink);
5021+ catc_set_reg(catc, RxUnit, RxEnable | RxPolarity | RxMultiCast);
5022+ } else {
5023+ dev_dbg(dev, "Performing reset\n");
5024+ catc_reset(catc);
5025+ catc_get_mac(catc, netdev->dev_addr);
5026+
5027+ dev_dbg(dev, "Setting RX Mode\n");
5028+ catc->rxmode[0] = RxEnable | RxPolarity | RxMultiCast;
5029+ catc->rxmode[1] = 0;
5030+ f5u011_rxmode(catc, catc->rxmode);
5031+ }
5032+ dev_dbg(dev, "Init done.\n");
5033+ printk(KERN_INFO "%s: %s USB Ethernet at usb-%s-%s, %pM.\n",
5034+ netdev->name, (catc->is_f5u011) ? "Belkin F5U011" : "CATC EL1210A NetMate",
5035+ usbdev->bus->bus_name, usbdev->devpath, netdev->dev_addr);
5036+ usb_set_intfdata(intf, catc);
5037+
5038+ SET_NETDEV_DEV(netdev, &intf->dev);
5039+ if (register_netdev(netdev) != 0) {
5040+ usb_set_intfdata(intf, NULL);
5041+ usb_free_urb(catc->ctrl_urb);
5042+ usb_free_urb(catc->tx_urb);
5043+ usb_free_urb(catc->rx_urb);
5044+ usb_free_urb(catc->irq_urb);
5045+ free_netdev(netdev);
5046+ return -EIO;
5047+ }
5048+ return 0;
5049+}
5050+
5051+static void catc_disconnect(struct usb_interface *intf)
5052+{
5053+ struct catc *catc = usb_get_intfdata(intf);
5054+
5055+ usb_set_intfdata(intf, NULL);
5056+ if (catc) {
5057+ unregister_netdev(catc->netdev);
5058+ usb_free_urb(catc->ctrl_urb);
5059+ usb_free_urb(catc->tx_urb);
5060+ usb_free_urb(catc->rx_urb);
5061+ usb_free_urb(catc->irq_urb);
5062+ free_netdev(catc->netdev);
5063+ }
5064+}
5065+
5066+/*
5067+ * Module functions and tables.
5068+ */
5069+
5070+static struct usb_device_id catc_id_table [] = {
5071+ { USB_DEVICE(0x0423, 0xa) }, /* CATC Netmate, Belkin F5U011 */
5072+ { USB_DEVICE(0x0423, 0xc) }, /* CATC Netmate II, Belkin F5U111 */
5073+ { USB_DEVICE(0x08d1, 0x1) }, /* smartBridges smartNIC */
5074+ { }
5075+};
5076+
5077+MODULE_DEVICE_TABLE(usb, catc_id_table);
5078+
5079+static struct usb_driver catc_driver = {
5080+ .name = driver_name,
5081+ .probe = catc_probe,
5082+ .disconnect = catc_disconnect,
5083+ .id_table = catc_id_table,
5084+ .disable_hub_initiated_lpm = 1,
5085+};
5086+
5087+module_usb_driver(catc_driver);
5088diff -Naur backports-3.18.1-1.org/drivers/net/usb/cdc_eem.c backports-3.18.1-1/drivers/net/usb/cdc_eem.c
5089--- backports-3.18.1-1.org/drivers/net/usb/cdc_eem.c 1970-01-01 01:00:00.000000000 +0100
5090+++ backports-3.18.1-1/drivers/net/usb/cdc_eem.c 2014-12-16 18:39:45.000000000 +0100
5091@@ -0,0 +1,381 @@
5092+/*
5093+ * USB CDC EEM network interface driver
5094+ * Copyright (C) 2009 Oberthur Technologies
5095+ * by Omar Laazimani, Olivier Condemine
5096+ *
5097+ * This program is free software; you can redistribute it and/or modify
5098+ * it under the terms of the GNU General Public License as published by
5099+ * the Free Software Foundation; either version 2 of the License, or
5100+ * (at your option) any later version.
5101+ *
5102+ * This program is distributed in the hope that it will be useful,
5103+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
5104+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
5105+ * GNU General Public License for more details.
5106+ *
5107+ * You should have received a copy of the GNU General Public License
5108+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
5109+ */
5110+
5111+#include <linux/module.h>
5112+#include <linux/netdevice.h>
5113+#include <linux/etherdevice.h>
5114+#include <linux/ctype.h>
5115+#include <linux/ethtool.h>
5116+#include <linux/workqueue.h>
5117+#include <linux/mii.h>
5118+#include <linux/usb.h>
5119+#include <linux/crc32.h>
5120+#include <linux/usb/cdc.h>
5121+#include <linux/usb/usbnet.h>
5122+#include <linux/gfp.h>
5123+#include <linux/if_vlan.h>
5124+
5125+
5126+/*
5127+ * This driver is an implementation of the CDC "Ethernet Emulation
5128+ * Model" (EEM) specification, which encapsulates Ethernet frames
5129+ * for transport over USB using a simpler USB device model than the
5130+ * previous CDC "Ethernet Control Model" (ECM, or "CDC Ethernet").
5131+ *
5132+ * For details, see www.usb.org/developers/devclass_docs/CDC_EEM10.pdf
5133+ *
5134+ * This version has been tested with GIGAntIC WuaoW SIM Smart Card on 2.6.24,
5135+ * 2.6.27 and 2.6.30rc2 kernel.
5136+ * It has also been validated on Openmoko Om 2008.12 (based on 2.6.24 kernel).
5137+ * build on 23-April-2009
5138+ */
5139+
5140+#define EEM_HEAD 2 /* 2 byte header */
5141+
5142+/*-------------------------------------------------------------------------*/
5143+
5144+static void eem_linkcmd_complete(struct urb *urb)
5145+{
5146+ dev_kfree_skb(urb->context);
5147+ usb_free_urb(urb);
5148+}
5149+
5150+static void eem_linkcmd(struct usbnet *dev, struct sk_buff *skb)
5151+{
5152+ struct urb *urb;
5153+ int status;
5154+
5155+ urb = usb_alloc_urb(0, GFP_ATOMIC);
5156+ if (!urb)
5157+ goto fail;
5158+
5159+ usb_fill_bulk_urb(urb, dev->udev, dev->out,
5160+ skb->data, skb->len, eem_linkcmd_complete, skb);
5161+
5162+ status = usb_submit_urb(urb, GFP_ATOMIC);
5163+ if (status) {
5164+ usb_free_urb(urb);
5165+fail:
5166+ dev_kfree_skb(skb);
5167+ netdev_warn(dev->net, "link cmd failure\n");
5168+ return;
5169+ }
5170+}
5171+
5172+static int eem_bind(struct usbnet *dev, struct usb_interface *intf)
5173+{
5174+ int status = 0;
5175+
5176+ status = usbnet_get_endpoints(dev, intf);
5177+ if (status < 0) {
5178+ usb_set_intfdata(intf, NULL);
5179+ usb_driver_release_interface(driver_of(intf), intf);
5180+ return status;
5181+ }
5182+
5183+ /* no jumbogram (16K) support for now */
5184+
5185+ dev->net->hard_header_len += EEM_HEAD + ETH_FCS_LEN + VLAN_HLEN;
5186+ dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
5187+
5188+ return 0;
5189+}
5190+
5191+/*
5192+ * EEM permits packing multiple Ethernet frames into USB transfers
5193+ * (a "bundle"), but for TX we don't try to do that.
5194+ */
5195+static struct sk_buff *eem_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
5196+ gfp_t flags)
5197+{
5198+ struct sk_buff *skb2 = NULL;
5199+ u16 len = skb->len;
5200+ u32 crc = 0;
5201+ int padlen = 0;
5202+
5203+ /* When ((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket) is
5204+ * zero, stick two bytes of zero length EEM packet on the end.
5205+ * Else the framework would add invalid single byte padding,
5206+ * since it can't know whether ZLPs will be handled right by
5207+ * all the relevant hardware and software.
5208+ */
5209+ if (!((len + EEM_HEAD + ETH_FCS_LEN) % dev->maxpacket))
5210+ padlen += 2;
5211+
5212+ if (!skb_cloned(skb)) {
5213+ int headroom = skb_headroom(skb);
5214+ int tailroom = skb_tailroom(skb);
5215+
5216+ if ((tailroom >= ETH_FCS_LEN + padlen) &&
5217+ (headroom >= EEM_HEAD))
5218+ goto done;
5219+
5220+ if ((headroom + tailroom)
5221+ > (EEM_HEAD + ETH_FCS_LEN + padlen)) {
5222+ skb->data = memmove(skb->head +
5223+ EEM_HEAD,
5224+ skb->data,
5225+ skb->len);
5226+ skb_set_tail_pointer(skb, len);
5227+ goto done;
5228+ }
5229+ }
5230+
5231+ skb2 = skb_copy_expand(skb, EEM_HEAD, ETH_FCS_LEN + padlen, flags);
5232+ if (!skb2)
5233+ return NULL;
5234+
5235+ dev_kfree_skb_any(skb);
5236+ skb = skb2;
5237+
5238+done:
5239+ /* we don't use the "no Ethernet CRC" option */
5240+ crc = crc32_le(~0, skb->data, skb->len);
5241+ crc = ~crc;
5242+
5243+ put_unaligned_le32(crc, skb_put(skb, 4));
5244+
5245+ /* EEM packet header format:
5246+ * b0..13: length of ethernet frame
5247+ * b14: bmCRC (1 == valid Ethernet CRC)
5248+ * b15: bmType (0 == data)
5249+ */
5250+ len = skb->len;
5251+ put_unaligned_le16(BIT(14) | len, skb_push(skb, 2));
5252+
5253+ /* Bundle a zero length EEM packet if needed */
5254+ if (padlen)
5255+ put_unaligned_le16(0, skb_put(skb, 2));
5256+
5257+ return skb;
5258+}
5259+
5260+static int eem_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
5261+{
5262+ /*
5263+ * Our task here is to strip off framing, leaving skb with one
5264+ * data frame for the usbnet framework code to process. But we
5265+ * may have received multiple EEM payloads, or command payloads.
5266+ * So we must process _everything_ as if it's a header, except
5267+ * maybe the last data payload
5268+ *
5269+ * REVISIT the framework needs updating so that when we consume
5270+ * all payloads (the last or only message was a command, or a
5271+ * zero length EEM packet) that is not accounted as an rx_error.
5272+ */
5273+ do {
5274+ struct sk_buff *skb2 = NULL;
5275+ u16 header;
5276+ u16 len = 0;
5277+
5278+ /* incomplete EEM header? */
5279+ if (skb->len < EEM_HEAD)
5280+ return 0;
5281+
5282+ /*
5283+ * EEM packet header format:
5284+ * b0..14: EEM type dependent (Data or Command)
5285+ * b15: bmType
5286+ */
5287+ header = get_unaligned_le16(skb->data);
5288+ skb_pull(skb, EEM_HEAD);
5289+
5290+ /*
5291+ * The bmType bit helps to denote when EEM
5292+ * packet is data or command :
5293+ * bmType = 0 : EEM data payload
5294+ * bmType = 1 : EEM (link) command
5295+ */
5296+ if (header & BIT(15)) {
5297+ u16 bmEEMCmd;
5298+
5299+ /*
5300+ * EEM (link) command packet:
5301+ * b0..10: bmEEMCmdParam
5302+ * b11..13: bmEEMCmd
5303+ * b14: bmReserved (must be 0)
5304+ * b15: 1 (EEM command)
5305+ */
5306+ if (header & BIT(14)) {
5307+ netdev_dbg(dev->net, "reserved command %04x\n",
5308+ header);
5309+ continue;
5310+ }
5311+
5312+ bmEEMCmd = (header >> 11) & 0x7;
5313+ switch (bmEEMCmd) {
5314+
5315+ /* Responding to echo requests is mandatory. */
5316+ case 0: /* Echo command */
5317+ len = header & 0x7FF;
5318+
5319+ /* bogus command? */
5320+ if (skb->len < len)
5321+ return 0;
5322+
5323+ skb2 = skb_clone(skb, GFP_ATOMIC);
5324+ if (unlikely(!skb2))
5325+ goto next;
5326+ skb_trim(skb2, len);
5327+ put_unaligned_le16(BIT(15) | (1 << 11) | len,
5328+ skb_push(skb2, 2));
5329+ eem_linkcmd(dev, skb2);
5330+ break;
5331+
5332+ /*
5333+ * Host may choose to ignore hints.
5334+ * - suspend: peripheral ready to suspend
5335+ * - response: suggest N millisec polling
5336+ * - response complete: suggest N sec polling
5337+ *
5338+ * Suspend is reported and maybe heeded.
5339+ */
5340+ case 2: /* Suspend hint */
5341+ usbnet_device_suggests_idle(dev);
5342+ continue;
5343+ case 3: /* Response hint */
5344+ case 4: /* Response complete hint */
5345+ continue;
5346+
5347+ /*
5348+ * Hosts should never receive host-to-peripheral
5349+ * or reserved command codes; or responses to an
5350+ * echo command we didn't send.
5351+ */
5352+ case 1: /* Echo response */
5353+ case 5: /* Tickle */
5354+ default: /* reserved */
5355+ netdev_warn(dev->net,
5356+ "unexpected link command %d\n",
5357+ bmEEMCmd);
5358+ continue;
5359+ }
5360+
5361+ } else {
5362+ u32 crc, crc2;
5363+ int is_last;
5364+
5365+ /* zero length EEM packet? */
5366+ if (header == 0)
5367+ continue;
5368+
5369+ /*
5370+ * EEM data packet header :
5371+ * b0..13: length of ethernet frame
5372+ * b14: bmCRC
5373+ * b15: 0 (EEM data)
5374+ */
5375+ len = header & 0x3FFF;
5376+
5377+ /* bogus EEM payload? */
5378+ if (skb->len < len)
5379+ return 0;
5380+
5381+ /* bogus ethernet frame? */
5382+ if (len < (ETH_HLEN + ETH_FCS_LEN))
5383+ goto next;
5384+
5385+ /*
5386+ * Treat the last payload differently: framework
5387+ * code expects our "fixup" to have stripped off
5388+ * headers, so "skb" is a data packet (or error).
5389+ * Else if it's not the last payload, keep "skb"
5390+ * for further processing.
5391+ */
5392+ is_last = (len == skb->len);
5393+ if (is_last)
5394+ skb2 = skb;
5395+ else {
5396+ skb2 = skb_clone(skb, GFP_ATOMIC);
5397+ if (unlikely(!skb2))
5398+ return 0;
5399+ }
5400+
5401+ /*
5402+ * The bmCRC helps to denote when the CRC field in
5403+ * the Ethernet frame contains a calculated CRC:
5404+ * bmCRC = 1 : CRC is calculated
5405+ * bmCRC = 0 : CRC = 0xDEADBEEF
5406+ */
5407+ if (header & BIT(14)) {
5408+ crc = get_unaligned_le32(skb2->data
5409+ + len - ETH_FCS_LEN);
5410+ crc2 = ~crc32_le(~0, skb2->data, skb2->len
5411+ - ETH_FCS_LEN);
5412+ } else {
5413+ crc = get_unaligned_be32(skb2->data
5414+ + len - ETH_FCS_LEN);
5415+ crc2 = 0xdeadbeef;
5416+ }
5417+ skb_trim(skb2, len - ETH_FCS_LEN);
5418+
5419+ if (is_last)
5420+ return crc == crc2;
5421+
5422+ if (unlikely(crc != crc2)) {
5423+ dev->net->stats.rx_errors++;
5424+ dev_kfree_skb_any(skb2);
5425+ } else
5426+ usbnet_skb_return(dev, skb2);
5427+ }
5428+
5429+next:
5430+ skb_pull(skb, len);
5431+ } while (skb->len);
5432+
5433+ return 1;
5434+}
5435+
5436+static const struct driver_info eem_info = {
5437+ .description = "CDC EEM Device",
5438+ .flags = FLAG_ETHER | FLAG_POINTTOPOINT,
5439+ .bind = eem_bind,
5440+ .rx_fixup = eem_rx_fixup,
5441+ .tx_fixup = eem_tx_fixup,
5442+};
5443+
5444+/*-------------------------------------------------------------------------*/
5445+
5446+static const struct usb_device_id products[] = {
5447+{
5448+ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_EEM,
5449+ USB_CDC_PROTO_EEM),
5450+ .driver_info = (unsigned long) &eem_info,
5451+},
5452+{
5453+ /* EMPTY == end of list */
5454+},
5455+};
5456+MODULE_DEVICE_TABLE(usb, products);
5457+
5458+static struct usb_driver eem_driver = {
5459+ .name = "cdc_eem",
5460+ .id_table = products,
5461+ .probe = usbnet_probe,
5462+ .disconnect = usbnet_disconnect,
5463+ .suspend = usbnet_suspend,
5464+ .resume = usbnet_resume,
5465+ .disable_hub_initiated_lpm = 1,
5466+};
5467+
5468+module_usb_driver(eem_driver);
5469+
5470+MODULE_AUTHOR("Omar Laazimani <omar.oberthur@gmail.com>");
5471+MODULE_DESCRIPTION("USB CDC EEM");
5472+MODULE_LICENSE("GPL");
5473diff -Naur backports-3.18.1-1.org/drivers/net/usb/cdc-phonet.c backports-3.18.1-1/drivers/net/usb/cdc-phonet.c
5474--- backports-3.18.1-1.org/drivers/net/usb/cdc-phonet.c 1970-01-01 01:00:00.000000000 +0100
5475+++ backports-3.18.1-1/drivers/net/usb/cdc-phonet.c 2014-12-16 18:39:45.000000000 +0100
5476@@ -0,0 +1,466 @@
5477+/*
5478+ * phonet.c -- USB CDC Phonet host driver
5479+ *
5480+ * Copyright (C) 2008-2009 Nokia Corporation. All rights reserved.
5481+ *
5482+ * Author: Rémi Denis-Courmont
5483+ *
5484+ * This program is free software; you can redistribute it and/or
5485+ * modify it under the terms of the GNU General Public License
5486+ * version 2 as published by the Free Software Foundation.
5487+ *
5488+ * This program is distributed in the hope that it will be useful, but
5489+ * WITHOUT ANY WARRANTY; without even the implied warranty of
5490+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
5491+ * General Public License for more details.
5492+ *
5493+ * You should have received a copy of the GNU General Public License
5494+ * along with this program; if not, write to the Free Software
5495+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
5496+ * 02110-1301 USA
5497+ */
5498+
5499+#include <linux/kernel.h>
5500+#include <linux/mm.h>
5501+#include <linux/module.h>
5502+#include <linux/gfp.h>
5503+#include <linux/usb.h>
5504+#include <linux/usb/cdc.h>
5505+#include <linux/netdevice.h>
5506+#include <linux/if_arp.h>
5507+#include <linux/if_phonet.h>
5508+#include <linux/phonet.h>
5509+
5510+#define PN_MEDIA_USB 0x1B
5511+
5512+static const unsigned rxq_size = 17;
5513+
5514+struct usbpn_dev {
5515+ struct net_device *dev;
5516+
5517+ struct usb_interface *intf, *data_intf;
5518+ struct usb_device *usb;
5519+ unsigned int tx_pipe, rx_pipe;
5520+ u8 active_setting;
5521+ u8 disconnected;
5522+
5523+ unsigned tx_queue;
5524+ spinlock_t tx_lock;
5525+
5526+ spinlock_t rx_lock;
5527+ struct sk_buff *rx_skb;
5528+ struct urb *urbs[0];
5529+};
5530+
5531+static void tx_complete(struct urb *req);
5532+static void rx_complete(struct urb *req);
5533+
5534+/*
5535+ * Network device callbacks
5536+ */
5537+static netdev_tx_t usbpn_xmit(struct sk_buff *skb, struct net_device *dev)
5538+{
5539+ struct usbpn_dev *pnd = netdev_priv(dev);
5540+ struct urb *req = NULL;
5541+ unsigned long flags;
5542+ int err;
5543+
5544+ if (skb->protocol != htons(ETH_P_PHONET))
5545+ goto drop;
5546+
5547+ req = usb_alloc_urb(0, GFP_ATOMIC);
5548+ if (!req)
5549+ goto drop;
5550+ usb_fill_bulk_urb(req, pnd->usb, pnd->tx_pipe, skb->data, skb->len,
5551+ tx_complete, skb);
5552+ req->transfer_flags = URB_ZERO_PACKET;
5553+ err = usb_submit_urb(req, GFP_ATOMIC);
5554+ if (err) {
5555+ usb_free_urb(req);
5556+ goto drop;
5557+ }
5558+
5559+ spin_lock_irqsave(&pnd->tx_lock, flags);
5560+ pnd->tx_queue++;
5561+ if (pnd->tx_queue >= dev->tx_queue_len)
5562+ netif_stop_queue(dev);
5563+ spin_unlock_irqrestore(&pnd->tx_lock, flags);
5564+ return NETDEV_TX_OK;
5565+
5566+drop:
5567+ dev_kfree_skb(skb);
5568+ dev->stats.tx_dropped++;
5569+ return NETDEV_TX_OK;
5570+}
5571+
5572+static void tx_complete(struct urb *req)
5573+{
5574+ struct sk_buff *skb = req->context;
5575+ struct net_device *dev = skb->dev;
5576+ struct usbpn_dev *pnd = netdev_priv(dev);
5577+ int status = req->status;
5578+
5579+ switch (status) {
5580+ case 0:
5581+ dev->stats.tx_bytes += skb->len;
5582+ break;
5583+
5584+ case -ENOENT:
5585+ case -ECONNRESET:
5586+ case -ESHUTDOWN:
5587+ dev->stats.tx_aborted_errors++;
5588+ default:
5589+ dev->stats.tx_errors++;
5590+ dev_dbg(&dev->dev, "TX error (%d)\n", status);
5591+ }
5592+ dev->stats.tx_packets++;
5593+
5594+ spin_lock(&pnd->tx_lock);
5595+ pnd->tx_queue--;
5596+ netif_wake_queue(dev);
5597+ spin_unlock(&pnd->tx_lock);
5598+
5599+ dev_kfree_skb_any(skb);
5600+ usb_free_urb(req);
5601+}
5602+
5603+static int rx_submit(struct usbpn_dev *pnd, struct urb *req, gfp_t gfp_flags)
5604+{
5605+ struct net_device *dev = pnd->dev;
5606+ struct page *page;
5607+ int err;
5608+
5609+ page = __skb_alloc_page(gfp_flags | __GFP_NOMEMALLOC, NULL);
5610+ if (!page)
5611+ return -ENOMEM;
5612+
5613+ usb_fill_bulk_urb(req, pnd->usb, pnd->rx_pipe, page_address(page),
5614+ PAGE_SIZE, rx_complete, dev);
5615+ req->transfer_flags = 0;
5616+ err = usb_submit_urb(req, gfp_flags);
5617+ if (unlikely(err)) {
5618+ dev_dbg(&dev->dev, "RX submit error (%d)\n", err);
5619+ put_page(page);
5620+ }
5621+ return err;
5622+}
5623+
5624+static void rx_complete(struct urb *req)
5625+{
5626+ struct net_device *dev = req->context;
5627+ struct usbpn_dev *pnd = netdev_priv(dev);
5628+ struct page *page = virt_to_page(req->transfer_buffer);
5629+ struct sk_buff *skb;
5630+ unsigned long flags;
5631+ int status = req->status;
5632+
5633+ switch (status) {
5634+ case 0:
5635+ spin_lock_irqsave(&pnd->rx_lock, flags);
5636+ skb = pnd->rx_skb;
5637+ if (!skb) {
5638+ skb = pnd->rx_skb = netdev_alloc_skb(dev, 12);
5639+ if (likely(skb)) {
5640+ /* Can't use pskb_pull() on page in IRQ */
5641+ memcpy(skb_put(skb, 1), page_address(page), 1);
5642+ skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,
5643+ page, 1, req->actual_length,
5644+ PAGE_SIZE);
5645+ page = NULL;
5646+ }
5647+ } else {
5648+ skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags,
5649+ page, 0, req->actual_length,
5650+ PAGE_SIZE);
5651+ page = NULL;
5652+ }
5653+ if (req->actual_length < PAGE_SIZE)
5654+ pnd->rx_skb = NULL; /* Last fragment */
5655+ else
5656+ skb = NULL;
5657+ spin_unlock_irqrestore(&pnd->rx_lock, flags);
5658+ if (skb) {
5659+ skb->protocol = htons(ETH_P_PHONET);
5660+ skb_reset_mac_header(skb);
5661+ __skb_pull(skb, 1);
5662+ skb->dev = dev;
5663+ dev->stats.rx_packets++;
5664+ dev->stats.rx_bytes += skb->len;
5665+
5666+ netif_rx(skb);
5667+ }
5668+ goto resubmit;
5669+
5670+ case -ENOENT:
5671+ case -ECONNRESET:
5672+ case -ESHUTDOWN:
5673+ req = NULL;
5674+ break;
5675+
5676+ case -EOVERFLOW:
5677+ dev->stats.rx_over_errors++;
5678+ dev_dbg(&dev->dev, "RX overflow\n");
5679+ break;
5680+
5681+ case -EILSEQ:
5682+ dev->stats.rx_crc_errors++;
5683+ break;
5684+ }
5685+
5686+ dev->stats.rx_errors++;
5687+resubmit:
5688+ if (page)
5689+ put_page(page);
5690+ if (req)
5691+ rx_submit(pnd, req, GFP_ATOMIC | __GFP_COLD);
5692+}
5693+
5694+static int usbpn_close(struct net_device *dev);
5695+
5696+static int usbpn_open(struct net_device *dev)
5697+{
5698+ struct usbpn_dev *pnd = netdev_priv(dev);
5699+ int err;
5700+ unsigned i;
5701+ unsigned num = pnd->data_intf->cur_altsetting->desc.bInterfaceNumber;
5702+
5703+ err = usb_set_interface(pnd->usb, num, pnd->active_setting);
5704+ if (err)
5705+ return err;
5706+
5707+ for (i = 0; i < rxq_size; i++) {
5708+ struct urb *req = usb_alloc_urb(0, GFP_KERNEL);
5709+
5710+ if (!req || rx_submit(pnd, req, GFP_KERNEL | __GFP_COLD)) {
5711+ usb_free_urb(req);
5712+ usbpn_close(dev);
5713+ return -ENOMEM;
5714+ }
5715+ pnd->urbs[i] = req;
5716+ }
5717+
5718+ netif_wake_queue(dev);
5719+ return 0;
5720+}
5721+
5722+static int usbpn_close(struct net_device *dev)
5723+{
5724+ struct usbpn_dev *pnd = netdev_priv(dev);
5725+ unsigned i;
5726+ unsigned num = pnd->data_intf->cur_altsetting->desc.bInterfaceNumber;
5727+
5728+ netif_stop_queue(dev);
5729+
5730+ for (i = 0; i < rxq_size; i++) {
5731+ struct urb *req = pnd->urbs[i];
5732+
5733+ if (!req)
5734+ continue;
5735+ usb_kill_urb(req);
5736+ usb_free_urb(req);
5737+ pnd->urbs[i] = NULL;
5738+ }
5739+
5740+ return usb_set_interface(pnd->usb, num, !pnd->active_setting);
5741+}
5742+
5743+static int usbpn_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
5744+{
5745+ struct if_phonet_req *req = (struct if_phonet_req *)ifr;
5746+
5747+ switch (cmd) {
5748+ case SIOCPNGAUTOCONF:
5749+ req->ifr_phonet_autoconf.device = PN_DEV_PC;
5750+ return 0;
5751+ }
5752+ return -ENOIOCTLCMD;
5753+}
5754+
5755+static int usbpn_set_mtu(struct net_device *dev, int new_mtu)
5756+{
5757+ if ((new_mtu < PHONET_MIN_MTU) || (new_mtu > PHONET_MAX_MTU))
5758+ return -EINVAL;
5759+
5760+ dev->mtu = new_mtu;
5761+ return 0;
5762+}
5763+
5764+static const struct net_device_ops usbpn_ops = {
5765+ .ndo_open = usbpn_open,
5766+ .ndo_stop = usbpn_close,
5767+ .ndo_start_xmit = usbpn_xmit,
5768+ .ndo_do_ioctl = usbpn_ioctl,
5769+ .ndo_change_mtu = usbpn_set_mtu,
5770+};
5771+
5772+static void usbpn_setup(struct net_device *dev)
5773+{
5774+ dev->features = 0;
5775+ dev->netdev_ops = &usbpn_ops,
5776+ dev->header_ops = &phonet_header_ops;
5777+ dev->type = ARPHRD_PHONET;
5778+ dev->flags = IFF_POINTOPOINT | IFF_NOARP;
5779+ dev->mtu = PHONET_MAX_MTU;
5780+ dev->hard_header_len = 1;
5781+ dev->dev_addr[0] = PN_MEDIA_USB;
5782+ dev->addr_len = 1;
5783+ dev->tx_queue_len = 3;
5784+
5785+ dev->destructor = free_netdev;
5786+}
5787+
5788+/*
5789+ * USB driver callbacks
5790+ */
5791+static struct usb_device_id usbpn_ids[] = {
5792+ {
5793+ .match_flags = USB_DEVICE_ID_MATCH_VENDOR
5794+ | USB_DEVICE_ID_MATCH_INT_CLASS
5795+ | USB_DEVICE_ID_MATCH_INT_SUBCLASS,
5796+ .idVendor = 0x0421, /* Nokia */
5797+ .bInterfaceClass = USB_CLASS_COMM,
5798+ .bInterfaceSubClass = 0xFE,
5799+ },
5800+ { },
5801+};
5802+
5803+MODULE_DEVICE_TABLE(usb, usbpn_ids);
5804+
5805+static struct usb_driver usbpn_driver;
5806+
5807+static int usbpn_probe(struct usb_interface *intf, const struct usb_device_id *id)
5808+{
5809+ static const char ifname[] = "usbpn%d";
5810+ const struct usb_cdc_union_desc *union_header = NULL;
5811+ const struct usb_host_interface *data_desc;
5812+ struct usb_interface *data_intf;
5813+ struct usb_device *usbdev = interface_to_usbdev(intf);
5814+ struct net_device *dev;
5815+ struct usbpn_dev *pnd;
5816+ u8 *data;
5817+ int phonet = 0;
5818+ int len, err;
5819+
5820+ data = intf->altsetting->extra;
5821+ len = intf->altsetting->extralen;
5822+ while (len >= 3) {
5823+ u8 dlen = data[0];
5824+ if (dlen < 3)
5825+ return -EINVAL;
5826+
5827+ /* bDescriptorType */
5828+ if (data[1] == USB_DT_CS_INTERFACE) {
5829+ /* bDescriptorSubType */
5830+ switch (data[2]) {
5831+ case USB_CDC_UNION_TYPE:
5832+ if (union_header || dlen < 5)
5833+ break;
5834+ union_header =
5835+ (struct usb_cdc_union_desc *)data;
5836+ break;
5837+ case 0xAB:
5838+ phonet = 1;
5839+ break;
5840+ }
5841+ }
5842+ data += dlen;
5843+ len -= dlen;
5844+ }
5845+
5846+ if (!union_header || !phonet)
5847+ return -EINVAL;
5848+
5849+ data_intf = usb_ifnum_to_if(usbdev, union_header->bSlaveInterface0);
5850+ if (data_intf == NULL)
5851+ return -ENODEV;
5852+ /* Data interface has one inactive and one active setting */
5853+ if (data_intf->num_altsetting != 2)
5854+ return -EINVAL;
5855+ if (data_intf->altsetting[0].desc.bNumEndpoints == 0 &&
5856+ data_intf->altsetting[1].desc.bNumEndpoints == 2)
5857+ data_desc = data_intf->altsetting + 1;
5858+ else
5859+ if (data_intf->altsetting[0].desc.bNumEndpoints == 2 &&
5860+ data_intf->altsetting[1].desc.bNumEndpoints == 0)
5861+ data_desc = data_intf->altsetting;
5862+ else
5863+ return -EINVAL;
5864+
5865+ dev = alloc_netdev(sizeof(*pnd) + sizeof(pnd->urbs[0]) * rxq_size,
5866+ ifname, NET_NAME_UNKNOWN, usbpn_setup);
5867+ if (!dev)
5868+ return -ENOMEM;
5869+
5870+ pnd = netdev_priv(dev);
5871+ SET_NETDEV_DEV(dev, &intf->dev);
5872+
5873+ pnd->dev = dev;
5874+ pnd->usb = usbdev;
5875+ pnd->intf = intf;
5876+ pnd->data_intf = data_intf;
5877+ spin_lock_init(&pnd->tx_lock);
5878+ spin_lock_init(&pnd->rx_lock);
5879+ /* Endpoints */
5880+ if (usb_pipein(data_desc->endpoint[0].desc.bEndpointAddress)) {
5881+ pnd->rx_pipe = usb_rcvbulkpipe(usbdev,
5882+ data_desc->endpoint[0].desc.bEndpointAddress);
5883+ pnd->tx_pipe = usb_sndbulkpipe(usbdev,
5884+ data_desc->endpoint[1].desc.bEndpointAddress);
5885+ } else {
5886+ pnd->rx_pipe = usb_rcvbulkpipe(usbdev,
5887+ data_desc->endpoint[1].desc.bEndpointAddress);
5888+ pnd->tx_pipe = usb_sndbulkpipe(usbdev,
5889+ data_desc->endpoint[0].desc.bEndpointAddress);
5890+ }
5891+ pnd->active_setting = data_desc - data_intf->altsetting;
5892+
5893+ err = usb_driver_claim_interface(&usbpn_driver, data_intf, pnd);
5894+ if (err)
5895+ goto out;
5896+
5897+ /* Force inactive mode until the network device is brought UP */
5898+ usb_set_interface(usbdev, union_header->bSlaveInterface0,
5899+ !pnd->active_setting);
5900+ usb_set_intfdata(intf, pnd);
5901+
5902+ err = register_netdev(dev);
5903+ if (err) {
5904+ usb_driver_release_interface(&usbpn_driver, data_intf);
5905+ goto out;
5906+ }
5907+
5908+ dev_dbg(&dev->dev, "USB CDC Phonet device found\n");
5909+ return 0;
5910+
5911+out:
5912+ usb_set_intfdata(intf, NULL);
5913+ free_netdev(dev);
5914+ return err;
5915+}
5916+
5917+static void usbpn_disconnect(struct usb_interface *intf)
5918+{
5919+ struct usbpn_dev *pnd = usb_get_intfdata(intf);
5920+
5921+ if (pnd->disconnected)
5922+ return;
5923+
5924+ pnd->disconnected = 1;
5925+ usb_driver_release_interface(&usbpn_driver,
5926+ (pnd->intf == intf) ? pnd->data_intf : pnd->intf);
5927+ unregister_netdev(pnd->dev);
5928+}
5929+
5930+static struct usb_driver usbpn_driver = {
5931+ .name = "cdc_phonet",
5932+ .probe = usbpn_probe,
5933+ .disconnect = usbpn_disconnect,
5934+ .id_table = usbpn_ids,
5935+ .disable_hub_initiated_lpm = 1,
5936+};
5937+
5938+module_usb_driver(usbpn_driver);
5939+
5940+MODULE_AUTHOR("Remi Denis-Courmont");
5941+MODULE_DESCRIPTION("USB CDC Phonet host interface");
5942+MODULE_LICENSE("GPL");
5943diff -Naur backports-3.18.1-1.org/drivers/net/usb/cdc_subset.c backports-3.18.1-1/drivers/net/usb/cdc_subset.c
5944--- backports-3.18.1-1.org/drivers/net/usb/cdc_subset.c 1970-01-01 01:00:00.000000000 +0100
5945+++ backports-3.18.1-1/drivers/net/usb/cdc_subset.c 2014-12-16 18:39:45.000000000 +0100
5946@@ -0,0 +1,369 @@
5947+/*
5948+ * Simple "CDC Subset" USB Networking Links
5949+ * Copyright (C) 2000-2005 by David Brownell
5950+ *
5951+ * This program is free software; you can redistribute it and/or modify
5952+ * it under the terms of the GNU General Public License as published by
5953+ * the Free Software Foundation; either version 2 of the License, or
5954+ * (at your option) any later version.
5955+ *
5956+ * This program is distributed in the hope that it will be useful,
5957+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
5958+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
5959+ * GNU General Public License for more details.
5960+ *
5961+ * You should have received a copy of the GNU General Public License
5962+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
5963+ */
5964+
5965+#include <linux/module.h>
5966+#include <linux/kmod.h>
5967+#include <linux/netdevice.h>
5968+#include <linux/etherdevice.h>
5969+#include <linux/ethtool.h>
5970+#include <linux/workqueue.h>
5971+#include <linux/mii.h>
5972+#include <linux/usb.h>
5973+#include <linux/usb/usbnet.h>
5974+
5975+
5976+/*
5977+ * This supports simple USB network links that don't require any special
5978+ * framing or hardware control operations. The protocol used here is a
5979+ * strict subset of CDC Ethernet, with three basic differences reflecting
5980+ * the goal that almost any hardware should run it:
5981+ *
5982+ * - Minimal runtime control: one interface, no altsettings, and
5983+ * no vendor or class specific control requests. If a device is
5984+ * configured, it is allowed to exchange packets with the host.
5985+ * Fancier models would mean not working on some hardware.
5986+ *
5987+ * - Minimal manufacturing control: no IEEE "Organizationally
5988+ * Unique ID" required, or an EEPROMs to store one. Each host uses
5989+ * one random "locally assigned" Ethernet address instead, which can
5990+ * of course be overridden using standard tools like "ifconfig".
5991+ * (With 2^46 such addresses, same-net collisions are quite rare.)
5992+ *
5993+ * - There is no additional framing data for USB. Packets are written
5994+ * exactly as in CDC Ethernet, starting with an Ethernet header and
5995+ * terminated by a short packet. However, the host will never send a
5996+ * zero length packet; some systems can't handle those robustly.
5997+ *
5998+ * Anything that can transmit and receive USB bulk packets can implement
5999+ * this protocol. That includes both smart peripherals and quite a lot
6000+ * of "host-to-host" USB cables (which embed two devices back-to-back).
6001+ *
6002+ * Note that although Linux may use many of those host-to-host links
6003+ * with this "cdc_subset" framing, that doesn't mean there may not be a
6004+ * better approach. Handling the "other end unplugs/replugs" scenario
6005+ * well tends to require chip-specific vendor requests. Also, Windows
6006+ * peers at the other end of host-to-host cables may expect their own
6007+ * framing to be used rather than this "cdc_subset" model.
6008+ */
6009+
6010+#if defined(CONFIG_USB_EPSON2888) || defined(CONFIG_USB_ARMLINUX)
6011+/* PDA style devices are always connected if present */
6012+static int always_connected (struct usbnet *dev)
6013+{
6014+ return 0;
6015+}
6016+#endif
6017+
6018+#ifdef CONFIG_USB_ALI_M5632
6019+#define HAVE_HARDWARE
6020+
6021+/*-------------------------------------------------------------------------
6022+ *
6023+ * ALi M5632 driver ... does high speed
6024+ *
6025+ * NOTE that the MS-Windows drivers for this chip use some funky and
6026+ * (naturally) undocumented 7-byte prefix to each packet, so this is a
6027+ * case where we don't currently interoperate. Also, once you unplug
6028+ * one end of the cable, you need to replug the other end too ... since
6029+ * chip docs are unavailable, there's no way to reset the relevant state
6030+ * short of a power cycle.
6031+ *
6032+ *-------------------------------------------------------------------------*/
6033+
6034+static void m5632_recover(struct usbnet *dev)
6035+{
6036+ struct usb_device *udev = dev->udev;
6037+ struct usb_interface *intf = dev->intf;
6038+ int r;
6039+
6040+ r = usb_lock_device_for_reset(udev, intf);
6041+ if (r < 0)
6042+ return;
6043+
6044+ usb_reset_device(udev);
6045+ usb_unlock_device(udev);
6046+}
6047+
6048+static const struct driver_info ali_m5632_info = {
6049+ .description = "ALi M5632",
6050+ .flags = FLAG_POINTTOPOINT,
6051+ .recover = m5632_recover,
6052+};
6053+
6054+#endif
6055+
6056+#ifdef CONFIG_USB_AN2720
6057+#define HAVE_HARDWARE
6058+
6059+/*-------------------------------------------------------------------------
6060+ *
6061+ * AnchorChips 2720 driver ... http://www.cypress.com
6062+ *
6063+ * This doesn't seem to have a way to detect whether the peer is
6064+ * connected, or need any reset handshaking. It's got pretty big
6065+ * internal buffers (handles most of a frame's worth of data).
6066+ * Chip data sheets don't describe any vendor control messages.
6067+ *
6068+ *-------------------------------------------------------------------------*/
6069+
6070+static const struct driver_info an2720_info = {
6071+ .description = "AnchorChips/Cypress 2720",
6072+ .flags = FLAG_POINTTOPOINT,
6073+ // no reset available!
6074+ // no check_connect available!
6075+
6076+ .in = 2, .out = 2, // direction distinguishes these
6077+};
6078+
6079+#endif /* CONFIG_USB_AN2720 */
6080+
6081+\f
6082+#ifdef CONFIG_USB_BELKIN
6083+#define HAVE_HARDWARE
6084+
6085+/*-------------------------------------------------------------------------
6086+ *
6087+ * Belkin F5U104 ... two NetChip 2280 devices + Atmel AVR microcontroller
6088+ *
6089+ * ... also two eTEK designs, including one sold as "Advance USBNET"
6090+ *
6091+ *-------------------------------------------------------------------------*/
6092+
6093+static const struct driver_info belkin_info = {
6094+ .description = "Belkin, eTEK, or compatible",
6095+ .flags = FLAG_POINTTOPOINT,
6096+};
6097+
6098+#endif /* CONFIG_USB_BELKIN */
6099+
6100+
6101+\f
6102+#ifdef CONFIG_USB_EPSON2888
6103+#define HAVE_HARDWARE
6104+
6105+/*-------------------------------------------------------------------------
6106+ *
6107+ * EPSON USB clients
6108+ *
6109+ * This is the same idea as Linux PDAs (below) except the firmware in the
6110+ * device might not be Tux-powered. Epson provides reference firmware that
6111+ * implements this interface. Product developers can reuse or modify that
6112+ * code, such as by using their own product and vendor codes.
6113+ *
6114+ * Support was from Juro Bystricky <bystricky.juro@erd.epson.com>
6115+ *
6116+ *-------------------------------------------------------------------------*/
6117+
6118+static const struct driver_info epson2888_info = {
6119+ .description = "Epson USB Device",
6120+ .check_connect = always_connected,
6121+ .flags = FLAG_POINTTOPOINT,
6122+
6123+ .in = 4, .out = 3,
6124+};
6125+
6126+#endif /* CONFIG_USB_EPSON2888 */
6127+
6128+\f
6129+/*-------------------------------------------------------------------------
6130+ *
6131+ * info from Jonathan McDowell <noodles@earth.li>
6132+ *
6133+ *-------------------------------------------------------------------------*/
6134+#ifdef CONFIG_USB_KC2190
6135+#define HAVE_HARDWARE
6136+static const struct driver_info kc2190_info = {
6137+ .description = "KC Technology KC-190",
6138+ .flags = FLAG_POINTTOPOINT,
6139+};
6140+#endif /* CONFIG_USB_KC2190 */
6141+
6142+\f
6143+#ifdef CONFIG_USB_ARMLINUX
6144+#define HAVE_HARDWARE
6145+
6146+/*-------------------------------------------------------------------------
6147+ *
6148+ * Intel's SA-1100 chip integrates basic USB support, and is used
6149+ * in PDAs like some iPaqs, the Yopy, some Zaurus models, and more.
6150+ * When they run Linux, arch/arm/mach-sa1100/usb-eth.c may be used to
6151+ * network using minimal USB framing data.
6152+ *
6153+ * This describes the driver currently in standard ARM Linux kernels.
6154+ * The Zaurus uses a different driver (see later).
6155+ *
6156+ * PXA25x and PXA210 use XScale cores (ARM v5TE) with better USB support
6157+ * and different USB endpoint numbering than the SA1100 devices. The
6158+ * mach-pxa/usb-eth.c driver re-uses the device ids from mach-sa1100
6159+ * so we rely on the endpoint descriptors.
6160+ *
6161+ *-------------------------------------------------------------------------*/
6162+
6163+static const struct driver_info linuxdev_info = {
6164+ .description = "Linux Device",
6165+ .check_connect = always_connected,
6166+ .flags = FLAG_POINTTOPOINT,
6167+};
6168+
6169+static const struct driver_info yopy_info = {
6170+ .description = "Yopy",
6171+ .check_connect = always_connected,
6172+ .flags = FLAG_POINTTOPOINT,
6173+};
6174+
6175+static const struct driver_info blob_info = {
6176+ .description = "Boot Loader OBject",
6177+ .check_connect = always_connected,
6178+ .flags = FLAG_POINTTOPOINT,
6179+};
6180+
6181+#endif /* CONFIG_USB_ARMLINUX */
6182+
6183+\f
6184+/*-------------------------------------------------------------------------*/
6185+
6186+#ifndef HAVE_HARDWARE
6187+#warning You need to configure some hardware for this driver
6188+#endif
6189+
6190+/*
6191+ * chip vendor names won't normally be on the cables, and
6192+ * may not be on the device.
6193+ */
6194+
6195+static const struct usb_device_id products [] = {
6196+
6197+#ifdef CONFIG_USB_ALI_M5632
6198+{
6199+ USB_DEVICE (0x0402, 0x5632), // ALi defaults
6200+ .driver_info = (unsigned long) &ali_m5632_info,
6201+},
6202+{
6203+ USB_DEVICE (0x182d,0x207c), // SiteCom CN-124
6204+ .driver_info = (unsigned long) &ali_m5632_info,
6205+},
6206+#endif
6207+
6208+#ifdef CONFIG_USB_AN2720
6209+{
6210+ USB_DEVICE (0x0547, 0x2720), // AnchorChips defaults
6211+ .driver_info = (unsigned long) &an2720_info,
6212+}, {
6213+ USB_DEVICE (0x0547, 0x2727), // Xircom PGUNET
6214+ .driver_info = (unsigned long) &an2720_info,
6215+},
6216+#endif
6217+
6218+#ifdef CONFIG_USB_BELKIN
6219+{
6220+ USB_DEVICE (0x050d, 0x0004), // Belkin
6221+ .driver_info = (unsigned long) &belkin_info,
6222+}, {
6223+ USB_DEVICE (0x056c, 0x8100), // eTEK
6224+ .driver_info = (unsigned long) &belkin_info,
6225+}, {
6226+ USB_DEVICE (0x0525, 0x9901), // Advance USBNET (eTEK)
6227+ .driver_info = (unsigned long) &belkin_info,
6228+},
6229+#endif
6230+
6231+#ifdef CONFIG_USB_EPSON2888
6232+{
6233+ USB_DEVICE (0x0525, 0x2888), // EPSON USB client
6234+ .driver_info = (unsigned long) &epson2888_info,
6235+},
6236+#endif
6237+
6238+#ifdef CONFIG_USB_KC2190
6239+{
6240+ USB_DEVICE (0x050f, 0x0190), // KC-190
6241+ .driver_info = (unsigned long) &kc2190_info,
6242+},
6243+#endif
6244+
6245+#ifdef CONFIG_USB_ARMLINUX
6246+/*
6247+ * SA-1100 using standard ARM Linux kernels, or compatible.
6248+ * Often used when talking to Linux PDAs (iPaq, Yopy, etc).
6249+ * The sa-1100 "usb-eth" driver handles the basic framing.
6250+ *
6251+ * PXA25x or PXA210 ... these use a "usb-eth" driver much like
6252+ * the sa1100 one, but hardware uses different endpoint numbers.
6253+ *
6254+ * Or the Linux "Ethernet" gadget on hardware that can't talk
6255+ * CDC Ethernet (e.g., no altsettings), in either of two modes:
6256+ * - acting just like the old "usb-eth" firmware, though
6257+ * the implementation is different
6258+ * - supporting RNDIS as the first/default configuration for
6259+ * MS-Windows interop; Linux needs to use the other config
6260+ */
6261+{
6262+ // 1183 = 0x049F, both used as hex values?
6263+ // Compaq "Itsy" vendor/product id
6264+ USB_DEVICE (0x049F, 0x505A), // usb-eth, or compatible
6265+ .driver_info = (unsigned long) &linuxdev_info,
6266+}, {
6267+ USB_DEVICE (0x0E7E, 0x1001), // G.Mate "Yopy"
6268+ .driver_info = (unsigned long) &yopy_info,
6269+}, {
6270+ USB_DEVICE (0x8086, 0x07d3), // "blob" bootloader
6271+ .driver_info = (unsigned long) &blob_info,
6272+}, {
6273+ USB_DEVICE (0x1286, 0x8001), // "blob" bootloader
6274+ .driver_info = (unsigned long) &blob_info,
6275+}, {
6276+ // Linux Ethernet/RNDIS gadget, mostly on PXA, second config
6277+ // e.g. Gumstix, current OpenZaurus, ... or anything else
6278+ // that just enables this gadget option.
6279+ USB_DEVICE (0x0525, 0xa4a2),
6280+ .driver_info = (unsigned long) &linuxdev_info,
6281+},
6282+#endif
6283+
6284+ { }, // END
6285+};
6286+MODULE_DEVICE_TABLE(usb, products);
6287+
6288+/*-------------------------------------------------------------------------*/
6289+static int dummy_prereset(struct usb_interface *intf)
6290+{
6291+ return 0;
6292+}
6293+
6294+static int dummy_postreset(struct usb_interface *intf)
6295+{
6296+ return 0;
6297+}
6298+
6299+static struct usb_driver cdc_subset_driver = {
6300+ .name = "cdc_subset",
6301+ .probe = usbnet_probe,
6302+ .suspend = usbnet_suspend,
6303+ .resume = usbnet_resume,
6304+ .pre_reset = dummy_prereset,
6305+ .post_reset = dummy_postreset,
6306+ .disconnect = usbnet_disconnect,
6307+ .id_table = products,
6308+ .disable_hub_initiated_lpm = 1,
6309+};
6310+
6311+module_usb_driver(cdc_subset_driver);
6312+
6313+MODULE_AUTHOR("David Brownell");
6314+MODULE_DESCRIPTION("Simple 'CDC Subset' USB networking links");
6315+MODULE_LICENSE("GPL");
6316diff -Naur backports-3.18.1-1.org/drivers/net/usb/cx82310_eth.c backports-3.18.1-1/drivers/net/usb/cx82310_eth.c
6317--- backports-3.18.1-1.org/drivers/net/usb/cx82310_eth.c 1970-01-01 01:00:00.000000000 +0100
6318+++ backports-3.18.1-1/drivers/net/usb/cx82310_eth.c 2014-12-16 18:39:45.000000000 +0100
6319@@ -0,0 +1,326 @@
6320+/*
6321+ * Driver for USB ethernet port of Conexant CX82310-based ADSL routers
6322+ * Copyright (C) 2010 by Ondrej Zary
6323+ * some parts inspired by the cxacru driver
6324+ *
6325+ * This program is free software; you can redistribute it and/or modify
6326+ * it under the terms of the GNU General Public License as published by
6327+ * the Free Software Foundation; either version 2 of the License, or
6328+ * (at your option) any later version.
6329+ *
6330+ * This program is distributed in the hope that it will be useful,
6331+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
6332+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
6333+ * GNU General Public License for more details.
6334+ *
6335+ * You should have received a copy of the GNU General Public License
6336+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
6337+ */
6338+
6339+#include <linux/module.h>
6340+#include <linux/netdevice.h>
6341+#include <linux/etherdevice.h>
6342+#include <linux/ethtool.h>
6343+#include <linux/workqueue.h>
6344+#include <linux/mii.h>
6345+#include <linux/usb.h>
6346+#include <linux/usb/usbnet.h>
6347+
6348+enum cx82310_cmd {
6349+ CMD_START = 0x84, /* no effect? */
6350+ CMD_STOP = 0x85, /* no effect? */
6351+ CMD_GET_STATUS = 0x90, /* returns nothing? */
6352+ CMD_GET_MAC_ADDR = 0x91, /* read MAC address */
6353+ CMD_GET_LINK_STATUS = 0x92, /* not useful, link is always up */
6354+ CMD_ETHERNET_MODE = 0x99, /* unknown, needed during init */
6355+};
6356+
6357+enum cx82310_status {
6358+ STATUS_UNDEFINED,
6359+ STATUS_SUCCESS,
6360+ STATUS_ERROR,
6361+ STATUS_UNSUPPORTED,
6362+ STATUS_UNIMPLEMENTED,
6363+ STATUS_PARAMETER_ERROR,
6364+ STATUS_DBG_LOOPBACK,
6365+};
6366+
6367+#define CMD_PACKET_SIZE 64
6368+/* first command after power on can take around 8 seconds */
6369+#define CMD_TIMEOUT 15000
6370+#define CMD_REPLY_RETRY 5
6371+
6372+#define CX82310_MTU 1514
6373+#define CMD_EP 0x01
6374+
6375+/*
6376+ * execute control command
6377+ * - optionally send some data (command parameters)
6378+ * - optionally wait for the reply
6379+ * - optionally read some data from the reply
6380+ */
6381+static int cx82310_cmd(struct usbnet *dev, enum cx82310_cmd cmd, bool reply,
6382+ u8 *wdata, int wlen, u8 *rdata, int rlen)
6383+{
6384+ int actual_len, retries, ret;
6385+ struct usb_device *udev = dev->udev;
6386+ u8 *buf = kzalloc(CMD_PACKET_SIZE, GFP_KERNEL);
6387+
6388+ if (!buf)
6389+ return -ENOMEM;
6390+
6391+ /* create command packet */
6392+ buf[0] = cmd;
6393+ if (wdata)
6394+ memcpy(buf + 4, wdata, min_t(int, wlen, CMD_PACKET_SIZE - 4));
6395+
6396+ /* send command packet */
6397+ ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, CMD_EP), buf,
6398+ CMD_PACKET_SIZE, &actual_len, CMD_TIMEOUT);
6399+ if (ret < 0) {
6400+ dev_err(&dev->udev->dev, "send command %#x: error %d\n",
6401+ cmd, ret);
6402+ goto end;
6403+ }
6404+
6405+ if (reply) {
6406+ /* wait for reply, retry if it's empty */
6407+ for (retries = 0; retries < CMD_REPLY_RETRY; retries++) {
6408+ ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, CMD_EP),
6409+ buf, CMD_PACKET_SIZE, &actual_len,
6410+ CMD_TIMEOUT);
6411+ if (ret < 0) {
6412+ dev_err(&dev->udev->dev,
6413+ "reply receive error %d\n", ret);
6414+ goto end;
6415+ }
6416+ if (actual_len > 0)
6417+ break;
6418+ }
6419+ if (actual_len == 0) {
6420+ dev_err(&dev->udev->dev, "no reply to command %#x\n",
6421+ cmd);
6422+ ret = -EIO;
6423+ goto end;
6424+ }
6425+ if (buf[0] != cmd) {
6426+ dev_err(&dev->udev->dev,
6427+ "got reply to command %#x, expected: %#x\n",
6428+ buf[0], cmd);
6429+ ret = -EIO;
6430+ goto end;
6431+ }
6432+ if (buf[1] != STATUS_SUCCESS) {
6433+ dev_err(&dev->udev->dev, "command %#x failed: %#x\n",
6434+ cmd, buf[1]);
6435+ ret = -EIO;
6436+ goto end;
6437+ }
6438+ if (rdata)
6439+ memcpy(rdata, buf + 4,
6440+ min_t(int, rlen, CMD_PACKET_SIZE - 4));
6441+ }
6442+end:
6443+ kfree(buf);
6444+ return ret;
6445+}
6446+
6447+#define partial_len data[0] /* length of partial packet data */
6448+#define partial_rem data[1] /* remaining (missing) data length */
6449+#define partial_data data[2] /* partial packet data */
6450+
6451+static int cx82310_bind(struct usbnet *dev, struct usb_interface *intf)
6452+{
6453+ int ret;
6454+ char buf[15];
6455+ struct usb_device *udev = dev->udev;
6456+
6457+ /* avoid ADSL modems - continue only if iProduct is "USB NET CARD" */
6458+ if (usb_string(udev, udev->descriptor.iProduct, buf, sizeof(buf)) > 0
6459+ && strcmp(buf, "USB NET CARD")) {
6460+ dev_info(&udev->dev, "ignoring: probably an ADSL modem\n");
6461+ return -ENODEV;
6462+ }
6463+
6464+ ret = usbnet_get_endpoints(dev, intf);
6465+ if (ret)
6466+ return ret;
6467+
6468+ /*
6469+ * this must not include ethernet header as the device can send partial
6470+ * packets with no header (and sometimes even empty URBs)
6471+ */
6472+ dev->net->hard_header_len = 0;
6473+ /* we can send at most 1514 bytes of data (+ 2-byte header) per URB */
6474+ dev->hard_mtu = CX82310_MTU + 2;
6475+ /* we can receive URBs up to 4KB from the device */
6476+ dev->rx_urb_size = 4096;
6477+
6478+ dev->partial_data = (unsigned long) kmalloc(dev->hard_mtu, GFP_KERNEL);
6479+ if (!dev->partial_data)
6480+ return -ENOMEM;
6481+
6482+ /* enable ethernet mode (?) */
6483+ ret = cx82310_cmd(dev, CMD_ETHERNET_MODE, true, "\x01", 1, NULL, 0);
6484+ if (ret) {
6485+ dev_err(&udev->dev, "unable to enable ethernet mode: %d\n",
6486+ ret);
6487+ goto err;
6488+ }
6489+
6490+ /* get the MAC address */
6491+ ret = cx82310_cmd(dev, CMD_GET_MAC_ADDR, true, NULL, 0,
6492+ dev->net->dev_addr, ETH_ALEN);
6493+ if (ret) {
6494+ dev_err(&udev->dev, "unable to read MAC address: %d\n", ret);
6495+ goto err;
6496+ }
6497+
6498+ /* start (does not seem to have any effect?) */
6499+ ret = cx82310_cmd(dev, CMD_START, false, NULL, 0, NULL, 0);
6500+ if (ret)
6501+ goto err;
6502+
6503+ return 0;
6504+err:
6505+ kfree((void *)dev->partial_data);
6506+ return ret;
6507+}
6508+
6509+static void cx82310_unbind(struct usbnet *dev, struct usb_interface *intf)
6510+{
6511+ kfree((void *)dev->partial_data);
6512+}
6513+
6514+/*
6515+ * RX is NOT easy - we can receive multiple packets per skb, each having 2-byte
6516+ * packet length at the beginning.
6517+ * The last packet might be incomplete (when it crosses the 4KB URB size),
6518+ * continuing in the next skb (without any headers).
6519+ * If a packet has odd length, there is one extra byte at the end (before next
6520+ * packet or at the end of the URB).
6521+ */
6522+static int cx82310_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
6523+{
6524+ int len;
6525+ struct sk_buff *skb2;
6526+
6527+ /*
6528+ * If the last skb ended with an incomplete packet, this skb contains
6529+ * end of that packet at the beginning.
6530+ */
6531+ if (dev->partial_rem) {
6532+ len = dev->partial_len + dev->partial_rem;
6533+ skb2 = alloc_skb(len, GFP_ATOMIC);
6534+ if (!skb2)
6535+ return 0;
6536+ skb_put(skb2, len);
6537+ memcpy(skb2->data, (void *)dev->partial_data,
6538+ dev->partial_len);
6539+ memcpy(skb2->data + dev->partial_len, skb->data,
6540+ dev->partial_rem);
6541+ usbnet_skb_return(dev, skb2);
6542+ skb_pull(skb, (dev->partial_rem + 1) & ~1);
6543+ dev->partial_rem = 0;
6544+ if (skb->len < 2)
6545+ return 1;
6546+ }
6547+
6548+ /* a skb can contain multiple packets */
6549+ while (skb->len > 1) {
6550+ /* first two bytes are packet length */
6551+ len = skb->data[0] | (skb->data[1] << 8);
6552+ skb_pull(skb, 2);
6553+
6554+ /* if last packet in the skb, let usbnet to process it */
6555+ if (len == skb->len || len + 1 == skb->len) {
6556+ skb_trim(skb, len);
6557+ break;
6558+ }
6559+
6560+ if (len > CX82310_MTU) {
6561+ dev_err(&dev->udev->dev, "RX packet too long: %d B\n",
6562+ len);
6563+ return 0;
6564+ }
6565+
6566+ /* incomplete packet, save it for the next skb */
6567+ if (len > skb->len) {
6568+ dev->partial_len = skb->len;
6569+ dev->partial_rem = len - skb->len;
6570+ memcpy((void *)dev->partial_data, skb->data,
6571+ dev->partial_len);
6572+ skb_pull(skb, skb->len);
6573+ break;
6574+ }
6575+
6576+ skb2 = alloc_skb(len, GFP_ATOMIC);
6577+ if (!skb2)
6578+ return 0;
6579+ skb_put(skb2, len);
6580+ memcpy(skb2->data, skb->data, len);
6581+ /* process the packet */
6582+ usbnet_skb_return(dev, skb2);
6583+
6584+ skb_pull(skb, (len + 1) & ~1);
6585+ }
6586+
6587+ /* let usbnet process the last packet */
6588+ return 1;
6589+}
6590+
6591+/* TX is easy, just add 2 bytes of length at the beginning */
6592+static struct sk_buff *cx82310_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
6593+ gfp_t flags)
6594+{
6595+ int len = skb->len;
6596+
6597+ if (skb_headroom(skb) < 2) {
6598+ struct sk_buff *skb2 = skb_copy_expand(skb, 2, 0, flags);
6599+ dev_kfree_skb_any(skb);
6600+ skb = skb2;
6601+ if (!skb)
6602+ return NULL;
6603+ }
6604+ skb_push(skb, 2);
6605+
6606+ skb->data[0] = len;
6607+ skb->data[1] = len >> 8;
6608+
6609+ return skb;
6610+}
6611+
6612+
6613+static const struct driver_info cx82310_info = {
6614+ .description = "Conexant CX82310 USB ethernet",
6615+ .flags = FLAG_ETHER,
6616+ .bind = cx82310_bind,
6617+ .unbind = cx82310_unbind,
6618+ .rx_fixup = cx82310_rx_fixup,
6619+ .tx_fixup = cx82310_tx_fixup,
6620+};
6621+
6622+static const struct usb_device_id products[] = {
6623+ {
6624+ USB_DEVICE_AND_INTERFACE_INFO(0x0572, 0xcb01, 0xff, 0, 0),
6625+ .driver_info = (unsigned long) &cx82310_info
6626+ },
6627+ { },
6628+};
6629+MODULE_DEVICE_TABLE(usb, products);
6630+
6631+static struct usb_driver cx82310_driver = {
6632+ .name = "cx82310_eth",
6633+ .id_table = products,
6634+ .probe = usbnet_probe,
6635+ .disconnect = usbnet_disconnect,
6636+ .suspend = usbnet_suspend,
6637+ .resume = usbnet_resume,
6638+ .disable_hub_initiated_lpm = 1,
6639+};
6640+
6641+module_usb_driver(cx82310_driver);
6642+
6643+MODULE_AUTHOR("Ondrej Zary");
6644+MODULE_DESCRIPTION("Conexant CX82310-based ADSL router USB ethernet driver");
6645+MODULE_LICENSE("GPL");
6646diff -Naur backports-3.18.1-1.org/drivers/net/usb/dm9601.c backports-3.18.1-1/drivers/net/usb/dm9601.c
6647--- backports-3.18.1-1.org/drivers/net/usb/dm9601.c 1970-01-01 01:00:00.000000000 +0100
6648+++ backports-3.18.1-1/drivers/net/usb/dm9601.c 2014-12-16 18:39:45.000000000 +0100
6649@@ -0,0 +1,647 @@
6650+/*
6651+ * Davicom DM96xx USB 10/100Mbps ethernet devices
6652+ *
6653+ * Peter Korsgaard <jacmet@sunsite.dk>
6654+ *
6655+ * This file is licensed under the terms of the GNU General Public License
6656+ * version 2. This program is licensed "as is" without any warranty of any
6657+ * kind, whether express or implied.
6658+ */
6659+
6660+//#define DEBUG
6661+
6662+#include <linux/module.h>
6663+#include <linux/sched.h>
6664+#include <linux/stddef.h>
6665+#include <linux/netdevice.h>
6666+#include <linux/etherdevice.h>
6667+#include <linux/ethtool.h>
6668+#include <linux/mii.h>
6669+#include <linux/usb.h>
6670+#include <linux/crc32.h>
6671+#include <linux/usb/usbnet.h>
6672+#include <linux/slab.h>
6673+
6674+/* datasheet:
6675+ http://ptm2.cc.utu.fi/ftp/network/cards/DM9601/From_NET/DM9601-DS-P01-930914.pdf
6676+*/
6677+
6678+/* control requests */
6679+#define DM_READ_REGS 0x00
6680+#define DM_WRITE_REGS 0x01
6681+#define DM_READ_MEMS 0x02
6682+#define DM_WRITE_REG 0x03
6683+#define DM_WRITE_MEMS 0x05
6684+#define DM_WRITE_MEM 0x07
6685+
6686+/* registers */
6687+#define DM_NET_CTRL 0x00
6688+#define DM_RX_CTRL 0x05
6689+#define DM_SHARED_CTRL 0x0b
6690+#define DM_SHARED_ADDR 0x0c
6691+#define DM_SHARED_DATA 0x0d /* low + high */
6692+#define DM_PHY_ADDR 0x10 /* 6 bytes */
6693+#define DM_MCAST_ADDR 0x16 /* 8 bytes */
6694+#define DM_GPR_CTRL 0x1e
6695+#define DM_GPR_DATA 0x1f
6696+#define DM_CHIP_ID 0x2c
6697+#define DM_MODE_CTRL 0x91 /* only on dm9620 */
6698+
6699+/* chip id values */
6700+#define ID_DM9601 0
6701+#define ID_DM9620 1
6702+
6703+#define DM_MAX_MCAST 64
6704+#define DM_MCAST_SIZE 8
6705+#define DM_EEPROM_LEN 256
6706+#define DM_TX_OVERHEAD 2 /* 2 byte header */
6707+#define DM_RX_OVERHEAD 7 /* 3 byte header + 4 byte crc tail */
6708+#define DM_TIMEOUT 1000
6709+
6710+static int dm_read(struct usbnet *dev, u8 reg, u16 length, void *data)
6711+{
6712+ int err;
6713+ err = usbnet_read_cmd(dev, DM_READ_REGS,
6714+ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
6715+ 0, reg, data, length);
6716+ if(err != length && err >= 0)
6717+ err = -EINVAL;
6718+ return err;
6719+}
6720+
6721+static int dm_read_reg(struct usbnet *dev, u8 reg, u8 *value)
6722+{
6723+ return dm_read(dev, reg, 1, value);
6724+}
6725+
6726+static int dm_write(struct usbnet *dev, u8 reg, u16 length, void *data)
6727+{
6728+ int err;
6729+ err = usbnet_write_cmd(dev, DM_WRITE_REGS,
6730+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
6731+ 0, reg, data, length);
6732+
6733+ if (err >= 0 && err < length)
6734+ err = -EINVAL;
6735+ return err;
6736+}
6737+
6738+static int dm_write_reg(struct usbnet *dev, u8 reg, u8 value)
6739+{
6740+ return usbnet_write_cmd(dev, DM_WRITE_REG,
6741+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
6742+ value, reg, NULL, 0);
6743+}
6744+
6745+static void dm_write_async(struct usbnet *dev, u8 reg, u16 length, void *data)
6746+{
6747+ usbnet_write_cmd_async(dev, DM_WRITE_REGS,
6748+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
6749+ 0, reg, data, length);
6750+}
6751+
6752+static void dm_write_reg_async(struct usbnet *dev, u8 reg, u8 value)
6753+{
6754+ usbnet_write_cmd_async(dev, DM_WRITE_REG,
6755+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
6756+ value, reg, NULL, 0);
6757+}
6758+
6759+static int dm_read_shared_word(struct usbnet *dev, int phy, u8 reg, __le16 *value)
6760+{
6761+ int ret, i;
6762+
6763+ mutex_lock(&dev->phy_mutex);
6764+
6765+ dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
6766+ dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0xc : 0x4);
6767+
6768+ for (i = 0; i < DM_TIMEOUT; i++) {
6769+ u8 tmp = 0;
6770+
6771+ udelay(1);
6772+ ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);
6773+ if (ret < 0)
6774+ goto out;
6775+
6776+ /* ready */
6777+ if ((tmp & 1) == 0)
6778+ break;
6779+ }
6780+
6781+ if (i == DM_TIMEOUT) {
6782+ netdev_err(dev->net, "%s read timed out!\n", phy ? "phy" : "eeprom");
6783+ ret = -EIO;
6784+ goto out;
6785+ }
6786+
6787+ dm_write_reg(dev, DM_SHARED_CTRL, 0x0);
6788+ ret = dm_read(dev, DM_SHARED_DATA, 2, value);
6789+
6790+ netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d\n",
6791+ phy, reg, *value, ret);
6792+
6793+ out:
6794+ mutex_unlock(&dev->phy_mutex);
6795+ return ret;
6796+}
6797+
6798+static int dm_write_shared_word(struct usbnet *dev, int phy, u8 reg, __le16 value)
6799+{
6800+ int ret, i;
6801+
6802+ mutex_lock(&dev->phy_mutex);
6803+
6804+ ret = dm_write(dev, DM_SHARED_DATA, 2, &value);
6805+ if (ret < 0)
6806+ goto out;
6807+
6808+ dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
6809+ dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0x1a : 0x12);
6810+
6811+ for (i = 0; i < DM_TIMEOUT; i++) {
6812+ u8 tmp = 0;
6813+
6814+ udelay(1);
6815+ ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);
6816+ if (ret < 0)
6817+ goto out;
6818+
6819+ /* ready */
6820+ if ((tmp & 1) == 0)
6821+ break;
6822+ }
6823+
6824+ if (i == DM_TIMEOUT) {
6825+ netdev_err(dev->net, "%s write timed out!\n", phy ? "phy" : "eeprom");
6826+ ret = -EIO;
6827+ goto out;
6828+ }
6829+
6830+ dm_write_reg(dev, DM_SHARED_CTRL, 0x0);
6831+
6832+out:
6833+ mutex_unlock(&dev->phy_mutex);
6834+ return ret;
6835+}
6836+
6837+static int dm_read_eeprom_word(struct usbnet *dev, u8 offset, void *value)
6838+{
6839+ return dm_read_shared_word(dev, 0, offset, value);
6840+}
6841+
6842+
6843+
6844+static int dm9601_get_eeprom_len(struct net_device *dev)
6845+{
6846+ return DM_EEPROM_LEN;
6847+}
6848+
6849+static int dm9601_get_eeprom(struct net_device *net,
6850+ struct ethtool_eeprom *eeprom, u8 * data)
6851+{
6852+ struct usbnet *dev = netdev_priv(net);
6853+ __le16 *ebuf = (__le16 *) data;
6854+ int i;
6855+
6856+ /* access is 16bit */
6857+ if ((eeprom->offset % 2) || (eeprom->len % 2))
6858+ return -EINVAL;
6859+
6860+ for (i = 0; i < eeprom->len / 2; i++) {
6861+ if (dm_read_eeprom_word(dev, eeprom->offset / 2 + i,
6862+ &ebuf[i]) < 0)
6863+ return -EINVAL;
6864+ }
6865+ return 0;
6866+}
6867+
6868+static int dm9601_mdio_read(struct net_device *netdev, int phy_id, int loc)
6869+{
6870+ struct usbnet *dev = netdev_priv(netdev);
6871+
6872+ __le16 res;
6873+
6874+ if (phy_id) {
6875+ netdev_dbg(dev->net, "Only internal phy supported\n");
6876+ return 0;
6877+ }
6878+
6879+ dm_read_shared_word(dev, 1, loc, &res);
6880+
6881+ netdev_dbg(dev->net,
6882+ "dm9601_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
6883+ phy_id, loc, le16_to_cpu(res));
6884+
6885+ return le16_to_cpu(res);
6886+}
6887+
6888+static void dm9601_mdio_write(struct net_device *netdev, int phy_id, int loc,
6889+ int val)
6890+{
6891+ struct usbnet *dev = netdev_priv(netdev);
6892+ __le16 res = cpu_to_le16(val);
6893+
6894+ if (phy_id) {
6895+ netdev_dbg(dev->net, "Only internal phy supported\n");
6896+ return;
6897+ }
6898+
6899+ netdev_dbg(dev->net, "dm9601_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
6900+ phy_id, loc, val);
6901+
6902+ dm_write_shared_word(dev, 1, loc, res);
6903+}
6904+
6905+static void dm9601_get_drvinfo(struct net_device *net,
6906+ struct ethtool_drvinfo *info)
6907+{
6908+ /* Inherit standard device info */
6909+ usbnet_get_drvinfo(net, info);
6910+ info->eedump_len = DM_EEPROM_LEN;
6911+}
6912+
6913+static u32 dm9601_get_link(struct net_device *net)
6914+{
6915+ struct usbnet *dev = netdev_priv(net);
6916+
6917+ return mii_link_ok(&dev->mii);
6918+}
6919+
6920+static int dm9601_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
6921+{
6922+ struct usbnet *dev = netdev_priv(net);
6923+
6924+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
6925+}
6926+
6927+static const struct ethtool_ops dm9601_ethtool_ops = {
6928+ .get_drvinfo = dm9601_get_drvinfo,
6929+ .get_link = dm9601_get_link,
6930+ .get_msglevel = usbnet_get_msglevel,
6931+ .set_msglevel = usbnet_set_msglevel,
6932+ .get_eeprom_len = dm9601_get_eeprom_len,
6933+ .get_eeprom = dm9601_get_eeprom,
6934+ .get_settings = usbnet_get_settings,
6935+ .set_settings = usbnet_set_settings,
6936+ .nway_reset = usbnet_nway_reset,
6937+};
6938+
6939+static void dm9601_set_multicast(struct net_device *net)
6940+{
6941+ struct usbnet *dev = netdev_priv(net);
6942+ /* We use the 20 byte dev->data for our 8 byte filter buffer
6943+ * to avoid allocating memory that is tricky to free later */
6944+ u8 *hashes = (u8 *) & dev->data;
6945+ u8 rx_ctl = 0x31;
6946+
6947+ memset(hashes, 0x00, DM_MCAST_SIZE);
6948+ hashes[DM_MCAST_SIZE - 1] |= 0x80; /* broadcast address */
6949+
6950+ if (net->flags & IFF_PROMISC) {
6951+ rx_ctl |= 0x02;
6952+ } else if (net->flags & IFF_ALLMULTI ||
6953+ netdev_mc_count(net) > DM_MAX_MCAST) {
6954+ rx_ctl |= 0x08;
6955+ } else if (!netdev_mc_empty(net)) {
6956+ struct netdev_hw_addr *ha;
6957+
6958+ netdev_for_each_mc_addr(ha, net) {
6959+ u32 crc = ether_crc(ETH_ALEN, ha->addr) >> 26;
6960+ hashes[crc >> 3] |= 1 << (crc & 0x7);
6961+ }
6962+ }
6963+
6964+ dm_write_async(dev, DM_MCAST_ADDR, DM_MCAST_SIZE, hashes);
6965+ dm_write_reg_async(dev, DM_RX_CTRL, rx_ctl);
6966+}
6967+
6968+static void __dm9601_set_mac_address(struct usbnet *dev)
6969+{
6970+ dm_write_async(dev, DM_PHY_ADDR, ETH_ALEN, dev->net->dev_addr);
6971+}
6972+
6973+static int dm9601_set_mac_address(struct net_device *net, void *p)
6974+{
6975+ struct sockaddr *addr = p;
6976+ struct usbnet *dev = netdev_priv(net);
6977+
6978+ if (!is_valid_ether_addr(addr->sa_data)) {
6979+ dev_err(&net->dev, "not setting invalid mac address %pM\n",
6980+ addr->sa_data);
6981+ return -EINVAL;
6982+ }
6983+
6984+ memcpy(net->dev_addr, addr->sa_data, net->addr_len);
6985+ __dm9601_set_mac_address(dev);
6986+
6987+ return 0;
6988+}
6989+
6990+static const struct net_device_ops dm9601_netdev_ops = {
6991+ .ndo_open = usbnet_open,
6992+ .ndo_stop = usbnet_stop,
6993+ .ndo_start_xmit = usbnet_start_xmit,
6994+ .ndo_tx_timeout = usbnet_tx_timeout,
6995+ .ndo_change_mtu = usbnet_change_mtu,
6996+ .ndo_validate_addr = eth_validate_addr,
6997+ .ndo_do_ioctl = dm9601_ioctl,
6998+ .ndo_set_rx_mode = dm9601_set_multicast,
6999+ .ndo_set_mac_address = dm9601_set_mac_address,
7000+};
7001+
7002+static int dm9601_bind(struct usbnet *dev, struct usb_interface *intf)
7003+{
7004+ int ret;
7005+ u8 mac[ETH_ALEN], id;
7006+
7007+ ret = usbnet_get_endpoints(dev, intf);
7008+ if (ret)
7009+ goto out;
7010+
7011+ dev->net->netdev_ops = &dm9601_netdev_ops;
7012+ dev->net->ethtool_ops = &dm9601_ethtool_ops;
7013+ dev->net->hard_header_len += DM_TX_OVERHEAD;
7014+ dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
7015+
7016+ /* dm9620/21a require room for 4 byte padding, even in dm9601
7017+ * mode, so we need +1 to be able to receive full size
7018+ * ethernet frames.
7019+ */
7020+ dev->rx_urb_size = dev->net->mtu + ETH_HLEN + DM_RX_OVERHEAD + 1;
7021+
7022+ dev->mii.dev = dev->net;
7023+ dev->mii.mdio_read = dm9601_mdio_read;
7024+ dev->mii.mdio_write = dm9601_mdio_write;
7025+ dev->mii.phy_id_mask = 0x1f;
7026+ dev->mii.reg_num_mask = 0x1f;
7027+
7028+ /* reset */
7029+ dm_write_reg(dev, DM_NET_CTRL, 1);
7030+ udelay(20);
7031+
7032+ /* read MAC */
7033+ if (dm_read(dev, DM_PHY_ADDR, ETH_ALEN, mac) < 0) {
7034+ printk(KERN_ERR "Error reading MAC address\n");
7035+ ret = -ENODEV;
7036+ goto out;
7037+ }
7038+
7039+ /*
7040+ * Overwrite the auto-generated address only with good ones.
7041+ */
7042+ if (is_valid_ether_addr(mac))
7043+ memcpy(dev->net->dev_addr, mac, ETH_ALEN);
7044+ else {
7045+ printk(KERN_WARNING
7046+ "dm9601: No valid MAC address in EEPROM, using %pM\n",
7047+ dev->net->dev_addr);
7048+ __dm9601_set_mac_address(dev);
7049+ }
7050+
7051+ if (dm_read_reg(dev, DM_CHIP_ID, &id) < 0) {
7052+ netdev_err(dev->net, "Error reading chip ID\n");
7053+ ret = -ENODEV;
7054+ goto out;
7055+ }
7056+
7057+ /* put dm9620 devices in dm9601 mode */
7058+ if (id == ID_DM9620) {
7059+ u8 mode;
7060+
7061+ if (dm_read_reg(dev, DM_MODE_CTRL, &mode) < 0) {
7062+ netdev_err(dev->net, "Error reading MODE_CTRL\n");
7063+ ret = -ENODEV;
7064+ goto out;
7065+ }
7066+ dm_write_reg(dev, DM_MODE_CTRL, mode & 0x7f);
7067+ }
7068+
7069+ /* power up phy */
7070+ dm_write_reg(dev, DM_GPR_CTRL, 1);
7071+ dm_write_reg(dev, DM_GPR_DATA, 0);
7072+
7073+ /* receive broadcast packets */
7074+ dm9601_set_multicast(dev->net);
7075+
7076+ dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
7077+ dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
7078+ ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
7079+ mii_nway_restart(&dev->mii);
7080+
7081+out:
7082+ return ret;
7083+}
7084+
7085+static int dm9601_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
7086+{
7087+ u8 status;
7088+ int len;
7089+
7090+ /* format:
7091+ b1: rx status
7092+ b2: packet length (incl crc) low
7093+ b3: packet length (incl crc) high
7094+ b4..n-4: packet data
7095+ bn-3..bn: ethernet crc
7096+ */
7097+
7098+ if (unlikely(skb->len < DM_RX_OVERHEAD)) {
7099+ dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");
7100+ return 0;
7101+ }
7102+
7103+ status = skb->data[0];
7104+ len = (skb->data[1] | (skb->data[2] << 8)) - 4;
7105+
7106+ if (unlikely(status & 0xbf)) {
7107+ if (status & 0x01) dev->net->stats.rx_fifo_errors++;
7108+ if (status & 0x02) dev->net->stats.rx_crc_errors++;
7109+ if (status & 0x04) dev->net->stats.rx_frame_errors++;
7110+ if (status & 0x20) dev->net->stats.rx_missed_errors++;
7111+ if (status & 0x90) dev->net->stats.rx_length_errors++;
7112+ return 0;
7113+ }
7114+
7115+ skb_pull(skb, 3);
7116+ skb_trim(skb, len);
7117+
7118+ return 1;
7119+}
7120+
7121+static struct sk_buff *dm9601_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
7122+ gfp_t flags)
7123+{
7124+ int len, pad;
7125+
7126+ /* format:
7127+ b1: packet length low
7128+ b2: packet length high
7129+ b3..n: packet data
7130+ */
7131+
7132+ len = skb->len + DM_TX_OVERHEAD;
7133+
7134+ /* workaround for dm962x errata with tx fifo getting out of
7135+ * sync if a USB bulk transfer retry happens right after a
7136+ * packet with odd / maxpacket length by adding up to 3 bytes
7137+ * padding.
7138+ */
7139+ while ((len & 1) || !(len % dev->maxpacket))
7140+ len++;
7141+
7142+ len -= DM_TX_OVERHEAD; /* hw header doesn't count as part of length */
7143+ pad = len - skb->len;
7144+
7145+ if (skb_headroom(skb) < DM_TX_OVERHEAD || skb_tailroom(skb) < pad) {
7146+ struct sk_buff *skb2;
7147+
7148+ skb2 = skb_copy_expand(skb, DM_TX_OVERHEAD, pad, flags);
7149+ dev_kfree_skb_any(skb);
7150+ skb = skb2;
7151+ if (!skb)
7152+ return NULL;
7153+ }
7154+
7155+ __skb_push(skb, DM_TX_OVERHEAD);
7156+
7157+ if (pad) {
7158+ memset(skb->data + skb->len, 0, pad);
7159+ __skb_put(skb, pad);
7160+ }
7161+
7162+ skb->data[0] = len;
7163+ skb->data[1] = len >> 8;
7164+
7165+ return skb;
7166+}
7167+
7168+static void dm9601_status(struct usbnet *dev, struct urb *urb)
7169+{
7170+ int link;
7171+ u8 *buf;
7172+
7173+ /* format:
7174+ b0: net status
7175+ b1: tx status 1
7176+ b2: tx status 2
7177+ b3: rx status
7178+ b4: rx overflow
7179+ b5: rx count
7180+ b6: tx count
7181+ b7: gpr
7182+ */
7183+
7184+ if (urb->actual_length < 8)
7185+ return;
7186+
7187+ buf = urb->transfer_buffer;
7188+
7189+ link = !!(buf[0] & 0x40);
7190+ if (netif_carrier_ok(dev->net) != link) {
7191+ usbnet_link_change(dev, link, 1);
7192+ netdev_dbg(dev->net, "Link Status is: %d\n", link);
7193+ }
7194+}
7195+
7196+static int dm9601_link_reset(struct usbnet *dev)
7197+{
7198+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
7199+
7200+ mii_check_media(&dev->mii, 1, 1);
7201+ mii_ethtool_gset(&dev->mii, &ecmd);
7202+
7203+ netdev_dbg(dev->net, "link_reset() speed: %u duplex: %d\n",
7204+ ethtool_cmd_speed(&ecmd), ecmd.duplex);
7205+
7206+ return 0;
7207+}
7208+
7209+static const struct driver_info dm9601_info = {
7210+ .description = "Davicom DM96xx USB 10/100 Ethernet",
7211+ .flags = FLAG_ETHER | FLAG_LINK_INTR,
7212+ .bind = dm9601_bind,
7213+ .rx_fixup = dm9601_rx_fixup,
7214+ .tx_fixup = dm9601_tx_fixup,
7215+ .status = dm9601_status,
7216+ .link_reset = dm9601_link_reset,
7217+ .reset = dm9601_link_reset,
7218+};
7219+
7220+static const struct usb_device_id products[] = {
7221+ {
7222+ USB_DEVICE(0x07aa, 0x9601), /* Corega FEther USB-TXC */
7223+ .driver_info = (unsigned long)&dm9601_info,
7224+ },
7225+ {
7226+ USB_DEVICE(0x0a46, 0x9601), /* Davicom USB-100 */
7227+ .driver_info = (unsigned long)&dm9601_info,
7228+ },
7229+ {
7230+ USB_DEVICE(0x0a46, 0x6688), /* ZT6688 USB NIC */
7231+ .driver_info = (unsigned long)&dm9601_info,
7232+ },
7233+ {
7234+ USB_DEVICE(0x0a46, 0x0268), /* ShanTou ST268 USB NIC */
7235+ .driver_info = (unsigned long)&dm9601_info,
7236+ },
7237+ {
7238+ USB_DEVICE(0x0a46, 0x8515), /* ADMtek ADM8515 USB NIC */
7239+ .driver_info = (unsigned long)&dm9601_info,
7240+ },
7241+ {
7242+ USB_DEVICE(0x0a47, 0x9601), /* Hirose USB-100 */
7243+ .driver_info = (unsigned long)&dm9601_info,
7244+ },
7245+ {
7246+ USB_DEVICE(0x0fe6, 0x8101), /* DM9601 USB to Fast Ethernet Adapter */
7247+ .driver_info = (unsigned long)&dm9601_info,
7248+ },
7249+ {
7250+ USB_DEVICE(0x0fe6, 0x9700), /* DM9601 USB to Fast Ethernet Adapter */
7251+ .driver_info = (unsigned long)&dm9601_info,
7252+ },
7253+ {
7254+ USB_DEVICE(0x0a46, 0x9000), /* DM9000E */
7255+ .driver_info = (unsigned long)&dm9601_info,
7256+ },
7257+ {
7258+ USB_DEVICE(0x0a46, 0x9620), /* DM9620 USB to Fast Ethernet Adapter */
7259+ .driver_info = (unsigned long)&dm9601_info,
7260+ },
7261+ {
7262+ USB_DEVICE(0x0a46, 0x9621), /* DM9621A USB to Fast Ethernet Adapter */
7263+ .driver_info = (unsigned long)&dm9601_info,
7264+ },
7265+ {
7266+ USB_DEVICE(0x0a46, 0x9622), /* DM9622 USB to Fast Ethernet Adapter */
7267+ .driver_info = (unsigned long)&dm9601_info,
7268+ },
7269+ {
7270+ USB_DEVICE(0x0a46, 0x0269), /* DM962OA USB to Fast Ethernet Adapter */
7271+ .driver_info = (unsigned long)&dm9601_info,
7272+ },
7273+ {
7274+ USB_DEVICE(0x0a46, 0x1269), /* DM9621A USB to Fast Ethernet Adapter */
7275+ .driver_info = (unsigned long)&dm9601_info,
7276+ },
7277+ {}, // END
7278+};
7279+
7280+MODULE_DEVICE_TABLE(usb, products);
7281+
7282+static struct usb_driver dm9601_driver = {
7283+ .name = "dm9601",
7284+ .id_table = products,
7285+ .probe = usbnet_probe,
7286+ .disconnect = usbnet_disconnect,
7287+ .suspend = usbnet_suspend,
7288+ .resume = usbnet_resume,
7289+ .disable_hub_initiated_lpm = 1,
7290+};
7291+
7292+module_usb_driver(dm9601_driver);
7293+
7294+MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
7295+MODULE_DESCRIPTION("Davicom DM96xx USB 10/100 ethernet devices");
7296+MODULE_LICENSE("GPL");
7297diff -Naur backports-3.18.1-1.org/drivers/net/usb/gl620a.c backports-3.18.1-1/drivers/net/usb/gl620a.c
7298--- backports-3.18.1-1.org/drivers/net/usb/gl620a.c 1970-01-01 01:00:00.000000000 +0100
7299+++ backports-3.18.1-1/drivers/net/usb/gl620a.c 2014-12-16 18:39:45.000000000 +0100
7300@@ -0,0 +1,242 @@
7301+/*
7302+ * GeneSys GL620USB-A based links
7303+ * Copyright (C) 2001 by Jiun-Jie Huang <huangjj@genesyslogic.com.tw>
7304+ * Copyright (C) 2001 by Stanislav Brabec <utx@penguin.cz>
7305+ *
7306+ * This program is free software; you can redistribute it and/or modify
7307+ * it under the terms of the GNU General Public License as published by
7308+ * the Free Software Foundation; either version 2 of the License, or
7309+ * (at your option) any later version.
7310+ *
7311+ * This program is distributed in the hope that it will be useful,
7312+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
7313+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7314+ * GNU General Public License for more details.
7315+ *
7316+ * You should have received a copy of the GNU General Public License
7317+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
7318+ */
7319+
7320+// #define DEBUG // error path messages, extra info
7321+// #define VERBOSE // more; success messages
7322+
7323+#include <linux/module.h>
7324+#include <linux/netdevice.h>
7325+#include <linux/etherdevice.h>
7326+#include <linux/ethtool.h>
7327+#include <linux/workqueue.h>
7328+#include <linux/mii.h>
7329+#include <linux/usb.h>
7330+#include <linux/usb/usbnet.h>
7331+#include <linux/gfp.h>
7332+
7333+
7334+/*
7335+ * GeneSys GL620USB-A (www.genesyslogic.com.tw)
7336+ *
7337+ * ... should partially interop with the Win32 driver for this hardware.
7338+ * The GeneSys docs imply there's some NDIS issue motivating this framing.
7339+ *
7340+ * Some info from GeneSys:
7341+ * - GL620USB-A is full duplex; GL620USB is only half duplex for bulk.
7342+ * (Some cables, like the BAFO-100c, use the half duplex version.)
7343+ * - For the full duplex model, the low bit of the version code says
7344+ * which side is which ("left/right").
7345+ * - For the half duplex type, a control/interrupt handshake settles
7346+ * the transfer direction. (That's disabled here, partially coded.)
7347+ * A control URB would block until other side writes an interrupt.
7348+ *
7349+ * Original code from Jiun-Jie Huang <huangjj@genesyslogic.com.tw>
7350+ * and merged into "usbnet" by Stanislav Brabec <utx@penguin.cz>.
7351+ */
7352+
7353+// control msg write command
7354+#define GENELINK_CONNECT_WRITE 0xF0
7355+// interrupt pipe index
7356+#define GENELINK_INTERRUPT_PIPE 0x03
7357+// interrupt read buffer size
7358+#define INTERRUPT_BUFSIZE 0x08
7359+// interrupt pipe interval value
7360+#define GENELINK_INTERRUPT_INTERVAL 0x10
7361+// max transmit packet number per transmit
7362+#define GL_MAX_TRANSMIT_PACKETS 32
7363+// max packet length
7364+#define GL_MAX_PACKET_LEN 1514
7365+// max receive buffer size
7366+#define GL_RCV_BUF_SIZE \
7367+ (((GL_MAX_PACKET_LEN + 4) * GL_MAX_TRANSMIT_PACKETS) + 4)
7368+
7369+struct gl_packet {
7370+ __le32 packet_length;
7371+ char packet_data [1];
7372+};
7373+
7374+struct gl_header {
7375+ __le32 packet_count;
7376+ struct gl_packet packets;
7377+};
7378+
7379+static int genelink_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
7380+{
7381+ struct gl_header *header;
7382+ struct gl_packet *packet;
7383+ struct sk_buff *gl_skb;
7384+ u32 size;
7385+ u32 count;
7386+
7387+ /* This check is no longer done by usbnet */
7388+ if (skb->len < dev->net->hard_header_len)
7389+ return 0;
7390+
7391+ header = (struct gl_header *) skb->data;
7392+
7393+ // get the packet count of the received skb
7394+ count = le32_to_cpu(header->packet_count);
7395+ if (count > GL_MAX_TRANSMIT_PACKETS) {
7396+ netdev_dbg(dev->net,
7397+ "genelink: invalid received packet count %u\n",
7398+ count);
7399+ return 0;
7400+ }
7401+
7402+ // set the current packet pointer to the first packet
7403+ packet = &header->packets;
7404+
7405+ // decrement the length for the packet count size 4 bytes
7406+ skb_pull(skb, 4);
7407+
7408+ while (count > 1) {
7409+ // get the packet length
7410+ size = le32_to_cpu(packet->packet_length);
7411+
7412+ // this may be a broken packet
7413+ if (size > GL_MAX_PACKET_LEN) {
7414+ netdev_dbg(dev->net, "genelink: invalid rx length %d\n",
7415+ size);
7416+ return 0;
7417+ }
7418+
7419+ // allocate the skb for the individual packet
7420+ gl_skb = alloc_skb(size, GFP_ATOMIC);
7421+ if (gl_skb) {
7422+
7423+ // copy the packet data to the new skb
7424+ memcpy(skb_put(gl_skb, size),
7425+ packet->packet_data, size);
7426+ usbnet_skb_return(dev, gl_skb);
7427+ }
7428+
7429+ // advance to the next packet
7430+ packet = (struct gl_packet *)&packet->packet_data[size];
7431+ count--;
7432+
7433+ // shift the data pointer to the next gl_packet
7434+ skb_pull(skb, size + 4);
7435+ }
7436+
7437+ // skip the packet length field 4 bytes
7438+ skb_pull(skb, 4);
7439+
7440+ if (skb->len > GL_MAX_PACKET_LEN) {
7441+ netdev_dbg(dev->net, "genelink: invalid rx length %d\n",
7442+ skb->len);
7443+ return 0;
7444+ }
7445+ return 1;
7446+}
7447+
7448+static struct sk_buff *
7449+genelink_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
7450+{
7451+ int padlen;
7452+ int length = skb->len;
7453+ int headroom = skb_headroom(skb);
7454+ int tailroom = skb_tailroom(skb);
7455+ __le32 *packet_count;
7456+ __le32 *packet_len;
7457+
7458+ // FIXME: magic numbers, bleech
7459+ padlen = ((skb->len + (4 + 4*1)) % 64) ? 0 : 1;
7460+
7461+ if ((!skb_cloned(skb))
7462+ && ((headroom + tailroom) >= (padlen + (4 + 4*1)))) {
7463+ if ((headroom < (4 + 4*1)) || (tailroom < padlen)) {
7464+ skb->data = memmove(skb->head + (4 + 4*1),
7465+ skb->data, skb->len);
7466+ skb_set_tail_pointer(skb, skb->len);
7467+ }
7468+ } else {
7469+ struct sk_buff *skb2;
7470+ skb2 = skb_copy_expand(skb, (4 + 4*1) , padlen, flags);
7471+ dev_kfree_skb_any(skb);
7472+ skb = skb2;
7473+ if (!skb)
7474+ return NULL;
7475+ }
7476+
7477+ // attach the packet count to the header
7478+ packet_count = (__le32 *) skb_push(skb, (4 + 4*1));
7479+ packet_len = packet_count + 1;
7480+
7481+ *packet_count = cpu_to_le32(1);
7482+ *packet_len = cpu_to_le32(length);
7483+
7484+ // add padding byte
7485+ if ((skb->len % dev->maxpacket) == 0)
7486+ skb_put(skb, 1);
7487+
7488+ return skb;
7489+}
7490+
7491+static int genelink_bind(struct usbnet *dev, struct usb_interface *intf)
7492+{
7493+ dev->hard_mtu = GL_RCV_BUF_SIZE;
7494+ dev->net->hard_header_len += 4;
7495+ dev->in = usb_rcvbulkpipe(dev->udev, dev->driver_info->in);
7496+ dev->out = usb_sndbulkpipe(dev->udev, dev->driver_info->out);
7497+ return 0;
7498+}
7499+
7500+static const struct driver_info genelink_info = {
7501+ .description = "Genesys GeneLink",
7502+ .flags = FLAG_POINTTOPOINT | FLAG_FRAMING_GL | FLAG_NO_SETINT,
7503+ .bind = genelink_bind,
7504+ .rx_fixup = genelink_rx_fixup,
7505+ .tx_fixup = genelink_tx_fixup,
7506+
7507+ .in = 1, .out = 2,
7508+
7509+#ifdef GENELINK_ACK
7510+ .check_connect =genelink_check_connect,
7511+#endif
7512+};
7513+
7514+static const struct usb_device_id products [] = {
7515+
7516+{
7517+ USB_DEVICE(0x05e3, 0x0502), // GL620USB-A
7518+ .driver_info = (unsigned long) &genelink_info,
7519+},
7520+ /* NOT: USB_DEVICE(0x05e3, 0x0501), // GL620USB
7521+ * that's half duplex, not currently supported
7522+ */
7523+ { }, // END
7524+};
7525+MODULE_DEVICE_TABLE(usb, products);
7526+
7527+static struct usb_driver gl620a_driver = {
7528+ .name = "gl620a",
7529+ .id_table = products,
7530+ .probe = usbnet_probe,
7531+ .disconnect = usbnet_disconnect,
7532+ .suspend = usbnet_suspend,
7533+ .resume = usbnet_resume,
7534+ .disable_hub_initiated_lpm = 1,
7535+};
7536+
7537+module_usb_driver(gl620a_driver);
7538+
7539+MODULE_AUTHOR("Jiun-Jie Huang");
7540+MODULE_DESCRIPTION("GL620-USB-A Host-to-Host Link cables");
7541+MODULE_LICENSE("GPL");
7542+
7543diff -Naur backports-3.18.1-1.org/drivers/net/usb/hso.c backports-3.18.1-1/drivers/net/usb/hso.c
7544--- backports-3.18.1-1.org/drivers/net/usb/hso.c 1970-01-01 01:00:00.000000000 +0100
7545+++ backports-3.18.1-1/drivers/net/usb/hso.c 2015-01-03 13:42:25.000000000 +0100
7546@@ -0,0 +1,3326 @@
7547+/******************************************************************************
7548+ *
7549+ * Driver for Option High Speed Mobile Devices.
7550+ *
7551+ * Copyright (C) 2008 Option International
7552+ * Filip Aben <f.aben@option.com>
7553+ * Denis Joseph Barrow <d.barow@option.com>
7554+ * Jan Dumon <j.dumon@option.com>
7555+ * Copyright (C) 2007 Andrew Bird (Sphere Systems Ltd)
7556+ * <ajb@spheresystems.co.uk>
7557+ * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
7558+ * Copyright (C) 2008 Novell, Inc.
7559+ *
7560+ * This program is free software; you can redistribute it and/or modify
7561+ * it under the terms of the GNU General Public License version 2 as
7562+ * published by the Free Software Foundation.
7563+ *
7564+ * This program is distributed in the hope that it will be useful,
7565+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
7566+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
7567+ * GNU General Public License for more details.
7568+ *
7569+ * You should have received a copy of the GNU General Public License
7570+ * along with this program; if not, write to the Free Software
7571+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
7572+ * USA
7573+ *
7574+ *
7575+ *****************************************************************************/
7576+
7577+/******************************************************************************
7578+ *
7579+ * Description of the device:
7580+ *
7581+ * Interface 0: Contains the IP network interface on the bulk end points.
7582+ * The multiplexed serial ports are using the interrupt and
7583+ * control endpoints.
7584+ * Interrupt contains a bitmap telling which multiplexed
7585+ * serialport needs servicing.
7586+ *
7587+ * Interface 1: Diagnostics port, uses bulk only, do not submit urbs until the
7588+ * port is opened, as this have a huge impact on the network port
7589+ * throughput.
7590+ *
7591+ * Interface 2: Standard modem interface - circuit switched interface, this
7592+ * can be used to make a standard ppp connection however it
7593+ * should not be used in conjunction with the IP network interface
7594+ * enabled for USB performance reasons i.e. if using this set
7595+ * ideally disable_net=1.
7596+ *
7597+ *****************************************************************************/
7598+
7599+#include <linux/sched.h>
7600+#include <linux/slab.h>
7601+#include <linux/init.h>
7602+#include <linux/delay.h>
7603+#include <linux/netdevice.h>
7604+#include <linux/module.h>
7605+#include <linux/ethtool.h>
7606+#include <linux/usb.h>
7607+#include <linux/timer.h>
7608+#include <linux/tty.h>
7609+#include <linux/tty_driver.h>
7610+#include <linux/tty_flip.h>
7611+#include <linux/kmod.h>
7612+#include <linux/rfkill.h>
7613+#include <linux/ip.h>
7614+#include <linux/uaccess.h>
7615+#include <linux/usb/cdc.h>
7616+#include <net/arp.h>
7617+#include <asm/byteorder.h>
7618+#include <linux/serial_core.h>
7619+#include <linux/serial.h>
7620+#include <asm/local.h>
7621+
7622+#define MOD_AUTHOR "Option Wireless"
7623+#define MOD_DESCRIPTION "USB High Speed Option driver"
7624+#define MOD_LICENSE "GPL"
7625+
7626+#define HSO_MAX_NET_DEVICES 10
7627+#define HSO__MAX_MTU 2048
7628+#define DEFAULT_MTU 1500
7629+#define DEFAULT_MRU 1500
7630+
7631+#define CTRL_URB_RX_SIZE 1024
7632+#define CTRL_URB_TX_SIZE 64
7633+
7634+#define BULK_URB_RX_SIZE 4096
7635+#define BULK_URB_TX_SIZE 8192
7636+
7637+#define MUX_BULK_RX_BUF_SIZE HSO__MAX_MTU
7638+#define MUX_BULK_TX_BUF_SIZE HSO__MAX_MTU
7639+#define MUX_BULK_RX_BUF_COUNT 4
7640+#define USB_TYPE_OPTION_VENDOR 0x20
7641+
7642+/* These definitions are used with the struct hso_net flags element */
7643+/* - use *_bit operations on it. (bit indices not values.) */
7644+#define HSO_NET_RUNNING 0
7645+
7646+#define HSO_NET_TX_TIMEOUT (HZ*10)
7647+
7648+#define HSO_SERIAL_MAGIC 0x48534f31
7649+
7650+/* Number of ttys to handle */
7651+#define HSO_SERIAL_TTY_MINORS 256
7652+
7653+#define MAX_RX_URBS 2
7654+
7655+/*****************************************************************************/
7656+/* Debugging functions */
7657+/*****************************************************************************/
7658+#define D__(lvl_, fmt, arg...) \
7659+ do { \
7660+ printk(lvl_ "[%d:%s]: " fmt "\n", \
7661+ __LINE__, __func__, ## arg); \
7662+ } while (0)
7663+
7664+#define D_(lvl, args...) \
7665+ do { \
7666+ if (lvl & debug) \
7667+ D__(KERN_INFO, args); \
7668+ } while (0)
7669+
7670+#define D1(args...) D_(0x01, ##args)
7671+#define D2(args...) D_(0x02, ##args)
7672+#define D3(args...) D_(0x04, ##args)
7673+#define D4(args...) D_(0x08, ##args)
7674+#define D5(args...) D_(0x10, ##args)
7675+
7676+/*****************************************************************************/
7677+/* Enumerators */
7678+/*****************************************************************************/
7679+enum pkt_parse_state {
7680+ WAIT_IP,
7681+ WAIT_DATA,
7682+ WAIT_SYNC
7683+};
7684+
7685+/*****************************************************************************/
7686+/* Structs */
7687+/*****************************************************************************/
7688+
7689+struct hso_shared_int {
7690+ struct usb_endpoint_descriptor *intr_endp;
7691+ void *shared_intr_buf;
7692+ struct urb *shared_intr_urb;
7693+ struct usb_device *usb;
7694+ int use_count;
7695+ int ref_count;
7696+ struct mutex shared_int_lock;
7697+};
7698+
7699+struct hso_net {
7700+ struct hso_device *parent;
7701+ struct net_device *net;
7702+ struct rfkill *rfkill;
7703+
7704+ struct usb_endpoint_descriptor *in_endp;
7705+ struct usb_endpoint_descriptor *out_endp;
7706+
7707+ struct urb *mux_bulk_rx_urb_pool[MUX_BULK_RX_BUF_COUNT];
7708+ struct urb *mux_bulk_tx_urb;
7709+ void *mux_bulk_rx_buf_pool[MUX_BULK_RX_BUF_COUNT];
7710+ void *mux_bulk_tx_buf;
7711+
7712+ struct sk_buff *skb_rx_buf;
7713+ struct sk_buff *skb_tx_buf;
7714+
7715+ enum pkt_parse_state rx_parse_state;
7716+ spinlock_t net_lock;
7717+
7718+ unsigned short rx_buf_size;
7719+ unsigned short rx_buf_missing;
7720+ struct iphdr rx_ip_hdr;
7721+
7722+ unsigned long flags;
7723+};
7724+
7725+enum rx_ctrl_state{
7726+ RX_IDLE,
7727+ RX_SENT,
7728+ RX_PENDING
7729+};
7730+
7731+#define BM_REQUEST_TYPE (0xa1)
7732+#define B_NOTIFICATION (0x20)
7733+#define W_VALUE (0x0)
7734+#define W_LENGTH (0x2)
7735+
7736+#define B_OVERRUN (0x1<<6)
7737+#define B_PARITY (0x1<<5)
7738+#define B_FRAMING (0x1<<4)
7739+#define B_RING_SIGNAL (0x1<<3)
7740+#define B_BREAK (0x1<<2)
7741+#define B_TX_CARRIER (0x1<<1)
7742+#define B_RX_CARRIER (0x1<<0)
7743+
7744+struct hso_serial_state_notification {
7745+ u8 bmRequestType;
7746+ u8 bNotification;
7747+ u16 wValue;
7748+ u16 wIndex;
7749+ u16 wLength;
7750+ u16 UART_state_bitmap;
7751+} __packed;
7752+
7753+struct hso_tiocmget {
7754+ struct mutex mutex;
7755+ wait_queue_head_t waitq;
7756+ int intr_completed;
7757+ struct usb_endpoint_descriptor *endp;
7758+ struct urb *urb;
7759+ struct hso_serial_state_notification serial_state_notification;
7760+ u16 prev_UART_state_bitmap;
7761+ struct uart_icount icount;
7762+};
7763+
7764+
7765+struct hso_serial {
7766+ struct hso_device *parent;
7767+ int magic;
7768+ u8 minor;
7769+
7770+ struct hso_shared_int *shared_int;
7771+
7772+ /* rx/tx urb could be either a bulk urb or a control urb depending
7773+ on which serial port it is used on. */
7774+ struct urb *rx_urb[MAX_RX_URBS];
7775+ u8 num_rx_urbs;
7776+ u8 *rx_data[MAX_RX_URBS];
7777+ u16 rx_data_length; /* should contain allocated length */
7778+
7779+ struct urb *tx_urb;
7780+ u8 *tx_data;
7781+ u8 *tx_buffer;
7782+ u16 tx_data_length; /* should contain allocated length */
7783+ u16 tx_data_count;
7784+ u16 tx_buffer_count;
7785+ struct usb_ctrlrequest ctrl_req_tx;
7786+ struct usb_ctrlrequest ctrl_req_rx;
7787+
7788+ struct usb_endpoint_descriptor *in_endp;
7789+ struct usb_endpoint_descriptor *out_endp;
7790+
7791+ enum rx_ctrl_state rx_state;
7792+ u8 rts_state;
7793+ u8 dtr_state;
7794+ unsigned tx_urb_used:1;
7795+
7796+ struct tty_port port;
7797+ /* from usb_serial_port */
7798+ spinlock_t serial_lock;
7799+
7800+ int (*write_data) (struct hso_serial *serial);
7801+ struct hso_tiocmget *tiocmget;
7802+ /* Hacks required to get flow control
7803+ * working on the serial receive buffers
7804+ * so as not to drop characters on the floor.
7805+ */
7806+ int curr_rx_urb_idx;
7807+ u8 rx_urb_filled[MAX_RX_URBS];
7808+ struct tasklet_struct unthrottle_tasklet;
7809+};
7810+
7811+struct hso_device {
7812+ union {
7813+ struct hso_serial *dev_serial;
7814+ struct hso_net *dev_net;
7815+ } port_data;
7816+
7817+ u32 port_spec;
7818+
7819+ u8 is_active;
7820+ u8 usb_gone;
7821+ struct work_struct async_get_intf;
7822+ struct work_struct async_put_intf;
7823+ struct work_struct reset_device;
7824+
7825+ struct usb_device *usb;
7826+ struct usb_interface *interface;
7827+
7828+ struct device *dev;
7829+ struct kref ref;
7830+ struct mutex mutex;
7831+};
7832+
7833+/* Type of interface */
7834+#define HSO_INTF_MASK 0xFF00
7835+#define HSO_INTF_MUX 0x0100
7836+#define HSO_INTF_BULK 0x0200
7837+
7838+/* Type of port */
7839+#define HSO_PORT_MASK 0xFF
7840+#define HSO_PORT_NO_PORT 0x0
7841+#define HSO_PORT_CONTROL 0x1
7842+#define HSO_PORT_APP 0x2
7843+#define HSO_PORT_GPS 0x3
7844+#define HSO_PORT_PCSC 0x4
7845+#define HSO_PORT_APP2 0x5
7846+#define HSO_PORT_GPS_CONTROL 0x6
7847+#define HSO_PORT_MSD 0x7
7848+#define HSO_PORT_VOICE 0x8
7849+#define HSO_PORT_DIAG2 0x9
7850+#define HSO_PORT_DIAG 0x10
7851+#define HSO_PORT_MODEM 0x11
7852+#define HSO_PORT_NETWORK 0x12
7853+
7854+/* Additional device info */
7855+#define HSO_INFO_MASK 0xFF000000
7856+#define HSO_INFO_CRC_BUG 0x01000000
7857+
7858+/*****************************************************************************/
7859+/* Prototypes */
7860+/*****************************************************************************/
7861+/* Serial driver functions */
7862+static int hso_serial_tiocmset(struct tty_struct *tty,
7863+ unsigned int set, unsigned int clear);
7864+static void ctrl_callback(struct urb *urb);
7865+static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial);
7866+static void hso_kick_transmit(struct hso_serial *serial);
7867+/* Helper functions */
7868+static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int,
7869+ struct usb_device *usb, gfp_t gfp);
7870+static void handle_usb_error(int status, const char *function,
7871+ struct hso_device *hso_dev);
7872+static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
7873+ int type, int dir);
7874+static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports);
7875+static void hso_free_interface(struct usb_interface *intf);
7876+static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags);
7877+static int hso_stop_serial_device(struct hso_device *hso_dev);
7878+static int hso_start_net_device(struct hso_device *hso_dev);
7879+static void hso_free_shared_int(struct hso_shared_int *shared_int);
7880+static int hso_stop_net_device(struct hso_device *hso_dev);
7881+static void hso_serial_ref_free(struct kref *ref);
7882+static void hso_std_serial_read_bulk_callback(struct urb *urb);
7883+static int hso_mux_serial_read(struct hso_serial *serial);
7884+static void async_get_intf(struct work_struct *data);
7885+static void async_put_intf(struct work_struct *data);
7886+static int hso_put_activity(struct hso_device *hso_dev);
7887+static int hso_get_activity(struct hso_device *hso_dev);
7888+static void tiocmget_intr_callback(struct urb *urb);
7889+static void reset_device(struct work_struct *data);
7890+/*****************************************************************************/
7891+/* Helping functions */
7892+/*****************************************************************************/
7893+
7894+/* #define DEBUG */
7895+
7896+static inline struct hso_net *dev2net(struct hso_device *hso_dev)
7897+{
7898+ return hso_dev->port_data.dev_net;
7899+}
7900+
7901+static inline struct hso_serial *dev2ser(struct hso_device *hso_dev)
7902+{
7903+ return hso_dev->port_data.dev_serial;
7904+}
7905+
7906+/* Debugging functions */
7907+#ifdef DEBUG
7908+static void dbg_dump(int line_count, const char *func_name, unsigned char *buf,
7909+ unsigned int len)
7910+{
7911+ static char name[255];
7912+
7913+ sprintf(name, "hso[%d:%s]", line_count, func_name);
7914+ print_hex_dump_bytes(name, DUMP_PREFIX_NONE, buf, len);
7915+}
7916+
7917+#define DUMP(buf_, len_) \
7918+ dbg_dump(__LINE__, __func__, (unsigned char *)buf_, len_)
7919+
7920+#define DUMP1(buf_, len_) \
7921+ do { \
7922+ if (0x01 & debug) \
7923+ DUMP(buf_, len_); \
7924+ } while (0)
7925+#else
7926+#define DUMP(buf_, len_)
7927+#define DUMP1(buf_, len_)
7928+#endif
7929+
7930+/* module parameters */
7931+static int debug;
7932+static int tty_major;
7933+static int disable_net;
7934+
7935+/* driver info */
7936+static const char driver_name[] = "hso";
7937+static const char tty_filename[] = "ttyHS";
7938+static const char *version = __FILE__ ": " MOD_AUTHOR;
7939+/* the usb driver itself (registered in hso_init) */
7940+static struct usb_driver hso_driver;
7941+/* serial structures */
7942+static struct tty_driver *tty_drv;
7943+static struct hso_device *serial_table[HSO_SERIAL_TTY_MINORS];
7944+static struct hso_device *network_table[HSO_MAX_NET_DEVICES];
7945+static spinlock_t serial_table_lock;
7946+
7947+static const s32 default_port_spec[] = {
7948+ HSO_INTF_MUX | HSO_PORT_NETWORK,
7949+ HSO_INTF_BULK | HSO_PORT_DIAG,
7950+ HSO_INTF_BULK | HSO_PORT_MODEM,
7951+ 0
7952+};
7953+
7954+static const s32 icon321_port_spec[] = {
7955+ HSO_INTF_MUX | HSO_PORT_NETWORK,
7956+ HSO_INTF_BULK | HSO_PORT_DIAG2,
7957+ HSO_INTF_BULK | HSO_PORT_MODEM,
7958+ HSO_INTF_BULK | HSO_PORT_DIAG,
7959+ 0
7960+};
7961+
7962+#define default_port_device(vendor, product) \
7963+ USB_DEVICE(vendor, product), \
7964+ .driver_info = (kernel_ulong_t)default_port_spec
7965+
7966+#define icon321_port_device(vendor, product) \
7967+ USB_DEVICE(vendor, product), \
7968+ .driver_info = (kernel_ulong_t)icon321_port_spec
7969+
7970+/* list of devices we support */
7971+static const struct usb_device_id hso_ids[] = {
7972+ {default_port_device(0x0af0, 0x6711)},
7973+ {default_port_device(0x0af0, 0x6731)},
7974+ {default_port_device(0x0af0, 0x6751)},
7975+ {default_port_device(0x0af0, 0x6771)},
7976+ {default_port_device(0x0af0, 0x6791)},
7977+ {default_port_device(0x0af0, 0x6811)},
7978+ {default_port_device(0x0af0, 0x6911)},
7979+ {default_port_device(0x0af0, 0x6951)},
7980+ {default_port_device(0x0af0, 0x6971)},
7981+ {default_port_device(0x0af0, 0x7011)},
7982+ {default_port_device(0x0af0, 0x7031)},
7983+ {default_port_device(0x0af0, 0x7051)},
7984+ {default_port_device(0x0af0, 0x7071)},
7985+ {default_port_device(0x0af0, 0x7111)},
7986+ {default_port_device(0x0af0, 0x7211)},
7987+ {default_port_device(0x0af0, 0x7251)},
7988+ {default_port_device(0x0af0, 0x7271)},
7989+ {default_port_device(0x0af0, 0x7311)},
7990+ {default_port_device(0x0af0, 0xc031)}, /* Icon-Edge */
7991+ {icon321_port_device(0x0af0, 0xd013)}, /* Module HSxPA */
7992+ {icon321_port_device(0x0af0, 0xd031)}, /* Icon-321 */
7993+ {icon321_port_device(0x0af0, 0xd033)}, /* Icon-322 */
7994+ {USB_DEVICE(0x0af0, 0x7301)}, /* GE40x */
7995+ {USB_DEVICE(0x0af0, 0x7361)}, /* GE40x */
7996+ {USB_DEVICE(0x0af0, 0x7381)}, /* GE40x */
7997+ {USB_DEVICE(0x0af0, 0x7401)}, /* GI 0401 */
7998+ {USB_DEVICE(0x0af0, 0x7501)}, /* GTM 382 */
7999+ {USB_DEVICE(0x0af0, 0x7601)}, /* GE40x */
8000+ {USB_DEVICE(0x0af0, 0x7701)},
8001+ {USB_DEVICE(0x0af0, 0x7706)},
8002+ {USB_DEVICE(0x0af0, 0x7801)},
8003+ {USB_DEVICE(0x0af0, 0x7901)},
8004+ {USB_DEVICE(0x0af0, 0x7A01)},
8005+ {USB_DEVICE(0x0af0, 0x7A05)},
8006+ {USB_DEVICE(0x0af0, 0x8200)},
8007+ {USB_DEVICE(0x0af0, 0x8201)},
8008+ {USB_DEVICE(0x0af0, 0x8300)},
8009+ {USB_DEVICE(0x0af0, 0x8302)},
8010+ {USB_DEVICE(0x0af0, 0x8304)},
8011+ {USB_DEVICE(0x0af0, 0x8400)},
8012+ {USB_DEVICE(0x0af0, 0x8600)},
8013+ {USB_DEVICE(0x0af0, 0x8800)},
8014+ {USB_DEVICE(0x0af0, 0x8900)},
8015+ {USB_DEVICE(0x0af0, 0x9000)},
8016+ {USB_DEVICE(0x0af0, 0x9200)}, /* Option GTM671WFS */
8017+ {USB_DEVICE(0x0af0, 0xd035)},
8018+ {USB_DEVICE(0x0af0, 0xd055)},
8019+ {USB_DEVICE(0x0af0, 0xd155)},
8020+ {USB_DEVICE(0x0af0, 0xd255)},
8021+ {USB_DEVICE(0x0af0, 0xd057)},
8022+ {USB_DEVICE(0x0af0, 0xd157)},
8023+ {USB_DEVICE(0x0af0, 0xd257)},
8024+ {USB_DEVICE(0x0af0, 0xd357)},
8025+ {USB_DEVICE(0x0af0, 0xd058)},
8026+ {USB_DEVICE(0x0af0, 0xc100)},
8027+ {}
8028+};
8029+MODULE_DEVICE_TABLE(usb, hso_ids);
8030+
8031+/* Sysfs attribute */
8032+static ssize_t hso_sysfs_show_porttype(struct device *dev,
8033+ struct device_attribute *attr,
8034+ char *buf)
8035+{
8036+ struct hso_device *hso_dev = dev_get_drvdata(dev);
8037+ char *port_name;
8038+
8039+ if (!hso_dev)
8040+ return 0;
8041+
8042+ switch (hso_dev->port_spec & HSO_PORT_MASK) {
8043+ case HSO_PORT_CONTROL:
8044+ port_name = "Control";
8045+ break;
8046+ case HSO_PORT_APP:
8047+ port_name = "Application";
8048+ break;
8049+ case HSO_PORT_APP2:
8050+ port_name = "Application2";
8051+ break;
8052+ case HSO_PORT_GPS:
8053+ port_name = "GPS";
8054+ break;
8055+ case HSO_PORT_GPS_CONTROL:
8056+ port_name = "GPS Control";
8057+ break;
8058+ case HSO_PORT_PCSC:
8059+ port_name = "PCSC";
8060+ break;
8061+ case HSO_PORT_DIAG:
8062+ port_name = "Diagnostic";
8063+ break;
8064+ case HSO_PORT_DIAG2:
8065+ port_name = "Diagnostic2";
8066+ break;
8067+ case HSO_PORT_MODEM:
8068+ port_name = "Modem";
8069+ break;
8070+ case HSO_PORT_NETWORK:
8071+ port_name = "Network";
8072+ break;
8073+ default:
8074+ port_name = "Unknown";
8075+ break;
8076+ }
8077+
8078+ return sprintf(buf, "%s\n", port_name);
8079+}
8080+static DEVICE_ATTR(hsotype, S_IRUGO, hso_sysfs_show_porttype, NULL);
8081+
8082+static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
8083+{
8084+ int idx;
8085+
8086+ for (idx = 0; idx < serial->num_rx_urbs; idx++)
8087+ if (serial->rx_urb[idx] == urb)
8088+ return idx;
8089+ dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
8090+ return -1;
8091+}
8092+
8093+/* converts mux value to a port spec value */
8094+static u32 hso_mux_to_port(int mux)
8095+{
8096+ u32 result;
8097+
8098+ switch (mux) {
8099+ case 0x1:
8100+ result = HSO_PORT_CONTROL;
8101+ break;
8102+ case 0x2:
8103+ result = HSO_PORT_APP;
8104+ break;
8105+ case 0x4:
8106+ result = HSO_PORT_PCSC;
8107+ break;
8108+ case 0x8:
8109+ result = HSO_PORT_GPS;
8110+ break;
8111+ case 0x10:
8112+ result = HSO_PORT_APP2;
8113+ break;
8114+ default:
8115+ result = HSO_PORT_NO_PORT;
8116+ }
8117+ return result;
8118+}
8119+
8120+/* converts port spec value to a mux value */
8121+static u32 hso_port_to_mux(int port)
8122+{
8123+ u32 result;
8124+
8125+ switch (port & HSO_PORT_MASK) {
8126+ case HSO_PORT_CONTROL:
8127+ result = 0x0;
8128+ break;
8129+ case HSO_PORT_APP:
8130+ result = 0x1;
8131+ break;
8132+ case HSO_PORT_PCSC:
8133+ result = 0x2;
8134+ break;
8135+ case HSO_PORT_GPS:
8136+ result = 0x3;
8137+ break;
8138+ case HSO_PORT_APP2:
8139+ result = 0x4;
8140+ break;
8141+ default:
8142+ result = 0x0;
8143+ }
8144+ return result;
8145+}
8146+
8147+static struct hso_serial *get_serial_by_shared_int_and_type(
8148+ struct hso_shared_int *shared_int,
8149+ int mux)
8150+{
8151+ int i, port;
8152+
8153+ port = hso_mux_to_port(mux);
8154+
8155+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
8156+ if (serial_table[i] &&
8157+ (dev2ser(serial_table[i])->shared_int == shared_int) &&
8158+ ((serial_table[i]->port_spec & HSO_PORT_MASK) == port)) {
8159+ return dev2ser(serial_table[i]);
8160+ }
8161+ }
8162+
8163+ return NULL;
8164+}
8165+
8166+static struct hso_serial *get_serial_by_index(unsigned index)
8167+{
8168+ struct hso_serial *serial = NULL;
8169+ unsigned long flags;
8170+
8171+ spin_lock_irqsave(&serial_table_lock, flags);
8172+ if (serial_table[index])
8173+ serial = dev2ser(serial_table[index]);
8174+ spin_unlock_irqrestore(&serial_table_lock, flags);
8175+
8176+ return serial;
8177+}
8178+
8179+static int get_free_serial_index(void)
8180+{
8181+ int index;
8182+ unsigned long flags;
8183+
8184+ spin_lock_irqsave(&serial_table_lock, flags);
8185+ for (index = 0; index < HSO_SERIAL_TTY_MINORS; index++) {
8186+ if (serial_table[index] == NULL) {
8187+ spin_unlock_irqrestore(&serial_table_lock, flags);
8188+ return index;
8189+ }
8190+ }
8191+ spin_unlock_irqrestore(&serial_table_lock, flags);
8192+
8193+ printk(KERN_ERR "%s: no free serial devices in table\n", __func__);
8194+ return -1;
8195+}
8196+
8197+static void set_serial_by_index(unsigned index, struct hso_serial *serial)
8198+{
8199+ unsigned long flags;
8200+
8201+ spin_lock_irqsave(&serial_table_lock, flags);
8202+ if (serial)
8203+ serial_table[index] = serial->parent;
8204+ else
8205+ serial_table[index] = NULL;
8206+ spin_unlock_irqrestore(&serial_table_lock, flags);
8207+}
8208+
8209+static void handle_usb_error(int status, const char *function,
8210+ struct hso_device *hso_dev)
8211+{
8212+ char *explanation;
8213+
8214+ switch (status) {
8215+ case -ENODEV:
8216+ explanation = "no device";
8217+ break;
8218+ case -ENOENT:
8219+ explanation = "endpoint not enabled";
8220+ break;
8221+ case -EPIPE:
8222+ explanation = "endpoint stalled";
8223+ break;
8224+ case -ENOSPC:
8225+ explanation = "not enough bandwidth";
8226+ break;
8227+ case -ESHUTDOWN:
8228+ explanation = "device disabled";
8229+ break;
8230+ case -EHOSTUNREACH:
8231+ explanation = "device suspended";
8232+ break;
8233+ case -EINVAL:
8234+ case -EAGAIN:
8235+ case -EFBIG:
8236+ case -EMSGSIZE:
8237+ explanation = "internal error";
8238+ break;
8239+ case -EILSEQ:
8240+ case -EPROTO:
8241+ case -ETIME:
8242+ case -ETIMEDOUT:
8243+ explanation = "protocol error";
8244+ if (hso_dev)
8245+ schedule_work(&hso_dev->reset_device);
8246+ break;
8247+ default:
8248+ explanation = "unknown status";
8249+ break;
8250+ }
8251+
8252+ /* log a meaningful explanation of an USB status */
8253+ D1("%s: received USB status - %s (%d)", function, explanation, status);
8254+}
8255+
8256+/* Network interface functions */
8257+
8258+/* called when net interface is brought up by ifconfig */
8259+static int hso_net_open(struct net_device *net)
8260+{
8261+ struct hso_net *odev = netdev_priv(net);
8262+ unsigned long flags = 0;
8263+
8264+ if (!odev) {
8265+ dev_err(&net->dev, "No net device !\n");
8266+ return -ENODEV;
8267+ }
8268+
8269+ odev->skb_tx_buf = NULL;
8270+
8271+ /* setup environment */
8272+ spin_lock_irqsave(&odev->net_lock, flags);
8273+ odev->rx_parse_state = WAIT_IP;
8274+ odev->rx_buf_size = 0;
8275+ odev->rx_buf_missing = sizeof(struct iphdr);
8276+ spin_unlock_irqrestore(&odev->net_lock, flags);
8277+
8278+ /* We are up and running. */
8279+ set_bit(HSO_NET_RUNNING, &odev->flags);
8280+ hso_start_net_device(odev->parent);
8281+
8282+ /* Tell the kernel we are ready to start receiving from it */
8283+ netif_start_queue(net);
8284+
8285+ return 0;
8286+}
8287+
8288+/* called when interface is brought down by ifconfig */
8289+static int hso_net_close(struct net_device *net)
8290+{
8291+ struct hso_net *odev = netdev_priv(net);
8292+
8293+ /* we don't need the queue anymore */
8294+ netif_stop_queue(net);
8295+ /* no longer running */
8296+ clear_bit(HSO_NET_RUNNING, &odev->flags);
8297+
8298+ hso_stop_net_device(odev->parent);
8299+
8300+ /* done */
8301+ return 0;
8302+}
8303+
8304+/* USB tells is xmit done, we should start the netqueue again */
8305+static void write_bulk_callback(struct urb *urb)
8306+{
8307+ struct hso_net *odev = urb->context;
8308+ int status = urb->status;
8309+
8310+ /* Sanity check */
8311+ if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
8312+ dev_err(&urb->dev->dev, "%s: device not running\n", __func__);
8313+ return;
8314+ }
8315+
8316+ /* Do we still have a valid kernel network device? */
8317+ if (!netif_device_present(odev->net)) {
8318+ dev_err(&urb->dev->dev, "%s: net device not present\n",
8319+ __func__);
8320+ return;
8321+ }
8322+
8323+ /* log status, but don't act on it, we don't need to resubmit anything
8324+ * anyhow */
8325+ if (status)
8326+ handle_usb_error(status, __func__, odev->parent);
8327+
8328+ hso_put_activity(odev->parent);
8329+
8330+ /* Tell the network interface we are ready for another frame */
8331+ netif_wake_queue(odev->net);
8332+}
8333+
8334+/* called by kernel when we need to transmit a packet */
8335+static netdev_tx_t hso_net_start_xmit(struct sk_buff *skb,
8336+ struct net_device *net)
8337+{
8338+ struct hso_net *odev = netdev_priv(net);
8339+ int result;
8340+
8341+ /* Tell the kernel, "No more frames 'til we are done with this one." */
8342+ netif_stop_queue(net);
8343+ if (hso_get_activity(odev->parent) == -EAGAIN) {
8344+ odev->skb_tx_buf = skb;
8345+ return NETDEV_TX_OK;
8346+ }
8347+
8348+ /* log if asked */
8349+ DUMP1(skb->data, skb->len);
8350+ /* Copy it from kernel memory to OUR memory */
8351+ memcpy(odev->mux_bulk_tx_buf, skb->data, skb->len);
8352+ D1("len: %d/%d", skb->len, MUX_BULK_TX_BUF_SIZE);
8353+
8354+ /* Fill in the URB for shipping it out. */
8355+ usb_fill_bulk_urb(odev->mux_bulk_tx_urb,
8356+ odev->parent->usb,
8357+ usb_sndbulkpipe(odev->parent->usb,
8358+ odev->out_endp->
8359+ bEndpointAddress & 0x7F),
8360+ odev->mux_bulk_tx_buf, skb->len, write_bulk_callback,
8361+ odev);
8362+
8363+ /* Deal with the Zero Length packet problem, I hope */
8364+ odev->mux_bulk_tx_urb->transfer_flags |= URB_ZERO_PACKET;
8365+
8366+ /* Send the URB on its merry way. */
8367+ result = usb_submit_urb(odev->mux_bulk_tx_urb, GFP_ATOMIC);
8368+ if (result) {
8369+ dev_warn(&odev->parent->interface->dev,
8370+ "failed mux_bulk_tx_urb %d\n", result);
8371+ net->stats.tx_errors++;
8372+ netif_start_queue(net);
8373+ } else {
8374+ net->stats.tx_packets++;
8375+ net->stats.tx_bytes += skb->len;
8376+ }
8377+ dev_kfree_skb(skb);
8378+ /* we're done */
8379+ return NETDEV_TX_OK;
8380+}
8381+
8382+static const struct ethtool_ops ops = {
8383+ .get_link = ethtool_op_get_link
8384+};
8385+
8386+/* called when a packet did not ack after watchdogtimeout */
8387+static void hso_net_tx_timeout(struct net_device *net)
8388+{
8389+ struct hso_net *odev = netdev_priv(net);
8390+
8391+ if (!odev)
8392+ return;
8393+
8394+ /* Tell syslog we are hosed. */
8395+ dev_warn(&net->dev, "Tx timed out.\n");
8396+
8397+ /* Tear the waiting frame off the list */
8398+ if (odev->mux_bulk_tx_urb &&
8399+ (odev->mux_bulk_tx_urb->status == -EINPROGRESS))
8400+ usb_unlink_urb(odev->mux_bulk_tx_urb);
8401+
8402+ /* Update statistics */
8403+ net->stats.tx_errors++;
8404+}
8405+
8406+/* make a real packet from the received USB buffer */
8407+static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,
8408+ unsigned int count, unsigned char is_eop)
8409+{
8410+ unsigned short temp_bytes;
8411+ unsigned short buffer_offset = 0;
8412+ unsigned short frame_len;
8413+ unsigned char *tmp_rx_buf;
8414+
8415+ /* log if needed */
8416+ D1("Rx %d bytes", count);
8417+ DUMP(ip_pkt, min(128, (int)count));
8418+
8419+ while (count) {
8420+ switch (odev->rx_parse_state) {
8421+ case WAIT_IP:
8422+ /* waiting for IP header. */
8423+ /* wanted bytes - size of ip header */
8424+ temp_bytes =
8425+ (count <
8426+ odev->rx_buf_missing) ? count : odev->
8427+ rx_buf_missing;
8428+
8429+ memcpy(((unsigned char *)(&odev->rx_ip_hdr)) +
8430+ odev->rx_buf_size, ip_pkt + buffer_offset,
8431+ temp_bytes);
8432+
8433+ odev->rx_buf_size += temp_bytes;
8434+ buffer_offset += temp_bytes;
8435+ odev->rx_buf_missing -= temp_bytes;
8436+ count -= temp_bytes;
8437+
8438+ if (!odev->rx_buf_missing) {
8439+ /* header is complete allocate an sk_buffer and
8440+ * continue to WAIT_DATA */
8441+ frame_len = ntohs(odev->rx_ip_hdr.tot_len);
8442+
8443+ if ((frame_len > DEFAULT_MRU) ||
8444+ (frame_len < sizeof(struct iphdr))) {
8445+ dev_err(&odev->net->dev,
8446+ "Invalid frame (%d) length\n",
8447+ frame_len);
8448+ odev->rx_parse_state = WAIT_SYNC;
8449+ continue;
8450+ }
8451+ /* Allocate an sk_buff */
8452+ odev->skb_rx_buf = netdev_alloc_skb(odev->net,
8453+ frame_len);
8454+ if (!odev->skb_rx_buf) {
8455+ /* We got no receive buffer. */
8456+ D1("could not allocate memory");
8457+ odev->rx_parse_state = WAIT_SYNC;
8458+ return;
8459+ }
8460+
8461+ /* Copy what we got so far. make room for iphdr
8462+ * after tail. */
8463+ tmp_rx_buf =
8464+ skb_put(odev->skb_rx_buf,
8465+ sizeof(struct iphdr));
8466+ memcpy(tmp_rx_buf, (char *)&(odev->rx_ip_hdr),
8467+ sizeof(struct iphdr));
8468+
8469+ /* ETH_HLEN */
8470+ odev->rx_buf_size = sizeof(struct iphdr);
8471+
8472+ /* Filip actually use .tot_len */
8473+ odev->rx_buf_missing =
8474+ frame_len - sizeof(struct iphdr);
8475+ odev->rx_parse_state = WAIT_DATA;
8476+ }
8477+ break;
8478+
8479+ case WAIT_DATA:
8480+ temp_bytes = (count < odev->rx_buf_missing)
8481+ ? count : odev->rx_buf_missing;
8482+
8483+ /* Copy the rest of the bytes that are left in the
8484+ * buffer into the waiting sk_buf. */
8485+ /* Make room for temp_bytes after tail. */
8486+ tmp_rx_buf = skb_put(odev->skb_rx_buf, temp_bytes);
8487+ memcpy(tmp_rx_buf, ip_pkt + buffer_offset, temp_bytes);
8488+
8489+ odev->rx_buf_missing -= temp_bytes;
8490+ count -= temp_bytes;
8491+ buffer_offset += temp_bytes;
8492+ odev->rx_buf_size += temp_bytes;
8493+ if (!odev->rx_buf_missing) {
8494+ /* Packet is complete. Inject into stack. */
8495+ /* We have IP packet here */
8496+ odev->skb_rx_buf->protocol = cpu_to_be16(ETH_P_IP);
8497+ skb_reset_mac_header(odev->skb_rx_buf);
8498+
8499+ /* Ship it off to the kernel */
8500+ netif_rx(odev->skb_rx_buf);
8501+ /* No longer our buffer. */
8502+ odev->skb_rx_buf = NULL;
8503+
8504+ /* update out statistics */
8505+ odev->net->stats.rx_packets++;
8506+
8507+ odev->net->stats.rx_bytes += odev->rx_buf_size;
8508+
8509+ odev->rx_buf_size = 0;
8510+ odev->rx_buf_missing = sizeof(struct iphdr);
8511+ odev->rx_parse_state = WAIT_IP;
8512+ }
8513+ break;
8514+
8515+ case WAIT_SYNC:
8516+ D1(" W_S");
8517+ count = 0;
8518+ break;
8519+ default:
8520+ D1(" ");
8521+ count--;
8522+ break;
8523+ }
8524+ }
8525+
8526+ /* Recovery mechanism for WAIT_SYNC state. */
8527+ if (is_eop) {
8528+ if (odev->rx_parse_state == WAIT_SYNC) {
8529+ odev->rx_parse_state = WAIT_IP;
8530+ odev->rx_buf_size = 0;
8531+ odev->rx_buf_missing = sizeof(struct iphdr);
8532+ }
8533+ }
8534+}
8535+
8536+static void fix_crc_bug(struct urb *urb, __le16 max_packet_size)
8537+{
8538+ static const u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
8539+ u32 rest = urb->actual_length % le16_to_cpu(max_packet_size);
8540+
8541+ if (((rest == 5) || (rest == 6)) &&
8542+ !memcmp(((u8 *)urb->transfer_buffer) + urb->actual_length - 4,
8543+ crc_check, 4)) {
8544+ urb->actual_length -= 4;
8545+ }
8546+}
8547+
8548+/* Moving data from usb to kernel (in interrupt state) */
8549+static void read_bulk_callback(struct urb *urb)
8550+{
8551+ struct hso_net *odev = urb->context;
8552+ struct net_device *net;
8553+ int result;
8554+ int status = urb->status;
8555+
8556+ /* is al ok? (Filip: Who's Al ?) */
8557+ if (status) {
8558+ handle_usb_error(status, __func__, odev->parent);
8559+ return;
8560+ }
8561+
8562+ /* Sanity check */
8563+ if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
8564+ D1("BULK IN callback but driver is not active!");
8565+ return;
8566+ }
8567+ usb_mark_last_busy(urb->dev);
8568+
8569+ net = odev->net;
8570+
8571+ if (!netif_device_present(net)) {
8572+ /* Somebody killed our network interface... */
8573+ return;
8574+ }
8575+
8576+ if (odev->parent->port_spec & HSO_INFO_CRC_BUG)
8577+ fix_crc_bug(urb, odev->in_endp->wMaxPacketSize);
8578+
8579+ /* do we even have a packet? */
8580+ if (urb->actual_length) {
8581+ /* Handle the IP stream, add header and push it onto network
8582+ * stack if the packet is complete. */
8583+ spin_lock(&odev->net_lock);
8584+ packetizeRx(odev, urb->transfer_buffer, urb->actual_length,
8585+ (urb->transfer_buffer_length >
8586+ urb->actual_length) ? 1 : 0);
8587+ spin_unlock(&odev->net_lock);
8588+ }
8589+
8590+ /* We are done with this URB, resubmit it. Prep the USB to wait for
8591+ * another frame. Reuse same as received. */
8592+ usb_fill_bulk_urb(urb,
8593+ odev->parent->usb,
8594+ usb_rcvbulkpipe(odev->parent->usb,
8595+ odev->in_endp->
8596+ bEndpointAddress & 0x7F),
8597+ urb->transfer_buffer, MUX_BULK_RX_BUF_SIZE,
8598+ read_bulk_callback, odev);
8599+
8600+ /* Give this to the USB subsystem so it can tell us when more data
8601+ * arrives. */
8602+ result = usb_submit_urb(urb, GFP_ATOMIC);
8603+ if (result)
8604+ dev_warn(&odev->parent->interface->dev,
8605+ "%s failed submit mux_bulk_rx_urb %d\n", __func__,
8606+ result);
8607+}
8608+
8609+/* Serial driver functions */
8610+
8611+static void hso_init_termios(struct ktermios *termios)
8612+{
8613+ /*
8614+ * The default requirements for this device are:
8615+ */
8616+ termios->c_iflag &=
8617+ ~(IGNBRK /* disable ignore break */
8618+ | BRKINT /* disable break causes interrupt */
8619+ | PARMRK /* disable mark parity errors */
8620+ | ISTRIP /* disable clear high bit of input characters */
8621+ | INLCR /* disable translate NL to CR */
8622+ | IGNCR /* disable ignore CR */
8623+ | ICRNL /* disable translate CR to NL */
8624+ | IXON); /* disable enable XON/XOFF flow control */
8625+
8626+ /* disable postprocess output characters */
8627+ termios->c_oflag &= ~OPOST;
8628+
8629+ termios->c_lflag &=
8630+ ~(ECHO /* disable echo input characters */
8631+ | ECHONL /* disable echo new line */
8632+ | ICANON /* disable erase, kill, werase, and rprnt
8633+ special characters */
8634+ | ISIG /* disable interrupt, quit, and suspend special
8635+ characters */
8636+ | IEXTEN); /* disable non-POSIX special characters */
8637+
8638+ termios->c_cflag &=
8639+ ~(CSIZE /* no size */
8640+ | PARENB /* disable parity bit */
8641+ | CBAUD /* clear current baud rate */
8642+ | CBAUDEX); /* clear current buad rate */
8643+
8644+ termios->c_cflag |= CS8; /* character size 8 bits */
8645+
8646+ /* baud rate 115200 */
8647+ tty_termios_encode_baud_rate(termios, 115200, 115200);
8648+}
8649+
8650+static void _hso_serial_set_termios(struct tty_struct *tty,
8651+ struct ktermios *old)
8652+{
8653+ struct hso_serial *serial = tty->driver_data;
8654+
8655+ if (!serial) {
8656+ printk(KERN_ERR "%s: no tty structures", __func__);
8657+ return;
8658+ }
8659+
8660+ D4("port %d", serial->minor);
8661+
8662+ /*
8663+ * Fix up unsupported bits
8664+ */
8665+ tty->termios.c_iflag &= ~IXON; /* disable enable XON/XOFF flow control */
8666+
8667+ tty->termios.c_cflag &=
8668+ ~(CSIZE /* no size */
8669+ | PARENB /* disable parity bit */
8670+ | CBAUD /* clear current baud rate */
8671+ | CBAUDEX); /* clear current buad rate */
8672+
8673+ tty->termios.c_cflag |= CS8; /* character size 8 bits */
8674+
8675+ /* baud rate 115200 */
8676+ tty_encode_baud_rate(tty, 115200, 115200);
8677+}
8678+
8679+static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
8680+{
8681+ int result;
8682+ /* We are done with this URB, resubmit it. Prep the USB to wait for
8683+ * another frame */
8684+ usb_fill_bulk_urb(urb, serial->parent->usb,
8685+ usb_rcvbulkpipe(serial->parent->usb,
8686+ serial->in_endp->
8687+ bEndpointAddress & 0x7F),
8688+ urb->transfer_buffer, serial->rx_data_length,
8689+ hso_std_serial_read_bulk_callback, serial);
8690+ /* Give this to the USB subsystem so it can tell us when more data
8691+ * arrives. */
8692+ result = usb_submit_urb(urb, GFP_ATOMIC);
8693+ if (result) {
8694+ dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
8695+ __func__, result);
8696+ }
8697+}
8698+
8699+
8700+
8701+
8702+static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
8703+{
8704+ int count;
8705+ struct urb *curr_urb;
8706+
8707+ while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
8708+ curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
8709+ count = put_rxbuf_data(curr_urb, serial);
8710+ if (count == -1)
8711+ return;
8712+ if (count == 0) {
8713+ serial->curr_rx_urb_idx++;
8714+ if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
8715+ serial->curr_rx_urb_idx = 0;
8716+ hso_resubmit_rx_bulk_urb(serial, curr_urb);
8717+ }
8718+ }
8719+}
8720+
8721+static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
8722+{
8723+ int count = 0;
8724+ struct urb *urb;
8725+
8726+ urb = serial->rx_urb[0];
8727+ if (atomic_read(&serial->port.count) > 0) {
8728+ count = put_rxbuf_data(urb, serial);
8729+ if (count == -1)
8730+ return;
8731+ }
8732+ /* Re issue a read as long as we receive data. */
8733+
8734+ if (count == 0 && ((urb->actual_length != 0) ||
8735+ (serial->rx_state == RX_PENDING))) {
8736+ serial->rx_state = RX_SENT;
8737+ hso_mux_serial_read(serial);
8738+ } else
8739+ serial->rx_state = RX_IDLE;
8740+}
8741+
8742+
8743+/* read callback for Diag and CS port */
8744+static void hso_std_serial_read_bulk_callback(struct urb *urb)
8745+{
8746+ struct hso_serial *serial = urb->context;
8747+ int status = urb->status;
8748+
8749+ D4("\n--- Got serial_read_bulk callback %02x ---", status);
8750+
8751+ /* sanity check */
8752+ if (!serial) {
8753+ D1("serial == NULL");
8754+ return;
8755+ }
8756+ if (status) {
8757+ handle_usb_error(status, __func__, serial->parent);
8758+ return;
8759+ }
8760+
8761+ D1("Actual length = %d\n", urb->actual_length);
8762+ DUMP1(urb->transfer_buffer, urb->actual_length);
8763+
8764+ /* Anyone listening? */
8765+ if (atomic_read(&serial->port.count) == 0)
8766+ return;
8767+
8768+ if (serial->parent->port_spec & HSO_INFO_CRC_BUG)
8769+ fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);
8770+ /* Valid data, handle RX data */
8771+ spin_lock(&serial->serial_lock);
8772+ serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
8773+ put_rxbuf_data_and_resubmit_bulk_urb(serial);
8774+ spin_unlock(&serial->serial_lock);
8775+}
8776+
8777+/*
8778+ * This needs to be a tasklet otherwise we will
8779+ * end up recursively calling this function.
8780+ */
8781+static void hso_unthrottle_tasklet(struct hso_serial *serial)
8782+{
8783+ unsigned long flags;
8784+
8785+ spin_lock_irqsave(&serial->serial_lock, flags);
8786+ if ((serial->parent->port_spec & HSO_INTF_MUX))
8787+ put_rxbuf_data_and_resubmit_ctrl_urb(serial);
8788+ else
8789+ put_rxbuf_data_and_resubmit_bulk_urb(serial);
8790+ spin_unlock_irqrestore(&serial->serial_lock, flags);
8791+}
8792+
8793+static void hso_unthrottle(struct tty_struct *tty)
8794+{
8795+ struct hso_serial *serial = tty->driver_data;
8796+
8797+ tasklet_hi_schedule(&serial->unthrottle_tasklet);
8798+}
8799+
8800+/* open the requested serial port */
8801+static int hso_serial_open(struct tty_struct *tty, struct file *filp)
8802+{
8803+ struct hso_serial *serial = get_serial_by_index(tty->index);
8804+ int result;
8805+
8806+ /* sanity check */
8807+ if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {
8808+ WARN_ON(1);
8809+ tty->driver_data = NULL;
8810+ D1("Failed to open port");
8811+ return -ENODEV;
8812+ }
8813+
8814+ mutex_lock(&serial->parent->mutex);
8815+ result = usb_autopm_get_interface(serial->parent->interface);
8816+ if (result < 0)
8817+ goto err_out;
8818+
8819+ D1("Opening %d", serial->minor);
8820+ kref_get(&serial->parent->ref);
8821+
8822+ /* setup */
8823+ tty->driver_data = serial;
8824+ tty_port_tty_set(&serial->port, tty);
8825+
8826+ /* check for port already opened, if not set the termios */
8827+ if (atomic_inc_return(&serial->port.count) == 1) {
8828+ serial->rx_state = RX_IDLE;
8829+ /* Force default termio settings */
8830+ _hso_serial_set_termios(tty, NULL);
8831+ tasklet_init(&serial->unthrottle_tasklet,
8832+ (void (*)(unsigned long))hso_unthrottle_tasklet,
8833+ (unsigned long)serial);
8834+ result = hso_start_serial_device(serial->parent, GFP_KERNEL);
8835+ if (result) {
8836+ hso_stop_serial_device(serial->parent);
8837+ atomic_dec(&serial->port.count);
8838+ kref_put(&serial->parent->ref, hso_serial_ref_free);
8839+ }
8840+ } else {
8841+ D1("Port was already open");
8842+ }
8843+
8844+ usb_autopm_put_interface(serial->parent->interface);
8845+
8846+ /* done */
8847+ if (result)
8848+ hso_serial_tiocmset(tty, TIOCM_RTS | TIOCM_DTR, 0);
8849+err_out:
8850+ mutex_unlock(&serial->parent->mutex);
8851+ return result;
8852+}
8853+
8854+/* close the requested serial port */
8855+static void hso_serial_close(struct tty_struct *tty, struct file *filp)
8856+{
8857+ struct hso_serial *serial = tty->driver_data;
8858+ u8 usb_gone;
8859+
8860+ D1("Closing serial port");
8861+
8862+ /* Open failed, no close cleanup required */
8863+ if (serial == NULL)
8864+ return;
8865+
8866+ mutex_lock(&serial->parent->mutex);
8867+ usb_gone = serial->parent->usb_gone;
8868+
8869+ if (!usb_gone)
8870+ usb_autopm_get_interface(serial->parent->interface);
8871+
8872+ /* reset the rts and dtr */
8873+ /* do the actual close */
8874+ atomic_dec(&serial->port.count);
8875+
8876+ if (atomic_read(&serial->port.count) <= 0) {
8877+ atomic_set(&serial->port.count, 0);
8878+ tty_port_tty_set(&serial->port, NULL);
8879+ if (!usb_gone)
8880+ hso_stop_serial_device(serial->parent);
8881+ tasklet_kill(&serial->unthrottle_tasklet);
8882+ }
8883+
8884+ if (!usb_gone)
8885+ usb_autopm_put_interface(serial->parent->interface);
8886+
8887+ mutex_unlock(&serial->parent->mutex);
8888+
8889+ kref_put(&serial->parent->ref, hso_serial_ref_free);
8890+}
8891+
8892+/* close the requested serial port */
8893+static int hso_serial_write(struct tty_struct *tty, const unsigned char *buf,
8894+ int count)
8895+{
8896+ struct hso_serial *serial = tty->driver_data;
8897+ int space, tx_bytes;
8898+ unsigned long flags;
8899+
8900+ /* sanity check */
8901+ if (serial == NULL) {
8902+ printk(KERN_ERR "%s: serial is NULL\n", __func__);
8903+ return -ENODEV;
8904+ }
8905+
8906+ spin_lock_irqsave(&serial->serial_lock, flags);
8907+
8908+ space = serial->tx_data_length - serial->tx_buffer_count;
8909+ tx_bytes = (count < space) ? count : space;
8910+
8911+ if (!tx_bytes)
8912+ goto out;
8913+
8914+ memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, tx_bytes);
8915+ serial->tx_buffer_count += tx_bytes;
8916+
8917+out:
8918+ spin_unlock_irqrestore(&serial->serial_lock, flags);
8919+
8920+ hso_kick_transmit(serial);
8921+ /* done */
8922+ return tx_bytes;
8923+}
8924+
8925+/* how much room is there for writing */
8926+static int hso_serial_write_room(struct tty_struct *tty)
8927+{
8928+ struct hso_serial *serial = tty->driver_data;
8929+ int room;
8930+ unsigned long flags;
8931+
8932+ spin_lock_irqsave(&serial->serial_lock, flags);
8933+ room = serial->tx_data_length - serial->tx_buffer_count;
8934+ spin_unlock_irqrestore(&serial->serial_lock, flags);
8935+
8936+ /* return free room */
8937+ return room;
8938+}
8939+
8940+/* setup the term */
8941+static void hso_serial_set_termios(struct tty_struct *tty, struct ktermios *old)
8942+{
8943+ struct hso_serial *serial = tty->driver_data;
8944+ unsigned long flags;
8945+
8946+ if (old)
8947+ D5("Termios called with: cflags new[%d] - old[%d]",
8948+ tty->termios.c_cflag, old->c_cflag);
8949+
8950+ /* the actual setup */
8951+ spin_lock_irqsave(&serial->serial_lock, flags);
8952+ if (atomic_read(&serial->port.count))
8953+ _hso_serial_set_termios(tty, old);
8954+ else
8955+ tty->termios = *old;
8956+ spin_unlock_irqrestore(&serial->serial_lock, flags);
8957+
8958+ /* done */
8959+}
8960+
8961+/* how many characters in the buffer */
8962+static int hso_serial_chars_in_buffer(struct tty_struct *tty)
8963+{
8964+ struct hso_serial *serial = tty->driver_data;
8965+ int chars;
8966+ unsigned long flags;
8967+
8968+ /* sanity check */
8969+ if (serial == NULL)
8970+ return 0;
8971+
8972+ spin_lock_irqsave(&serial->serial_lock, flags);
8973+ chars = serial->tx_buffer_count;
8974+ spin_unlock_irqrestore(&serial->serial_lock, flags);
8975+
8976+ return chars;
8977+}
8978+static int tiocmget_submit_urb(struct hso_serial *serial,
8979+ struct hso_tiocmget *tiocmget,
8980+ struct usb_device *usb)
8981+{
8982+ int result;
8983+
8984+ if (serial->parent->usb_gone)
8985+ return -ENODEV;
8986+ usb_fill_int_urb(tiocmget->urb, usb,
8987+ usb_rcvintpipe(usb,
8988+ tiocmget->endp->
8989+ bEndpointAddress & 0x7F),
8990+ &tiocmget->serial_state_notification,
8991+ sizeof(struct hso_serial_state_notification),
8992+ tiocmget_intr_callback, serial,
8993+ tiocmget->endp->bInterval);
8994+ result = usb_submit_urb(tiocmget->urb, GFP_ATOMIC);
8995+ if (result) {
8996+ dev_warn(&usb->dev, "%s usb_submit_urb failed %d\n", __func__,
8997+ result);
8998+ }
8999+ return result;
9000+
9001+}
9002+
9003+static void tiocmget_intr_callback(struct urb *urb)
9004+{
9005+ struct hso_serial *serial = urb->context;
9006+ struct hso_tiocmget *tiocmget;
9007+ int status = urb->status;
9008+ u16 UART_state_bitmap, prev_UART_state_bitmap;
9009+ struct uart_icount *icount;
9010+ struct hso_serial_state_notification *serial_state_notification;
9011+ struct usb_device *usb;
9012+ int if_num;
9013+
9014+ /* Sanity checks */
9015+ if (!serial)
9016+ return;
9017+ if (status) {
9018+ handle_usb_error(status, __func__, serial->parent);
9019+ return;
9020+ }
9021+
9022+ /* tiocmget is only supported on HSO_PORT_MODEM */
9023+ tiocmget = serial->tiocmget;
9024+ if (!tiocmget)
9025+ return;
9026+ BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM);
9027+
9028+ usb = serial->parent->usb;
9029+ if_num = serial->parent->interface->altsetting->desc.bInterfaceNumber;
9030+
9031+ /* wIndex should be the USB interface number of the port to which the
9032+ * notification applies, which should always be the Modem port.
9033+ */
9034+ serial_state_notification = &tiocmget->serial_state_notification;
9035+ if (serial_state_notification->bmRequestType != BM_REQUEST_TYPE ||
9036+ serial_state_notification->bNotification != B_NOTIFICATION ||
9037+ le16_to_cpu(serial_state_notification->wValue) != W_VALUE ||
9038+ le16_to_cpu(serial_state_notification->wIndex) != if_num ||
9039+ le16_to_cpu(serial_state_notification->wLength) != W_LENGTH) {
9040+ dev_warn(&usb->dev,
9041+ "hso received invalid serial state notification\n");
9042+ DUMP(serial_state_notification,
9043+ sizeof(struct hso_serial_state_notification));
9044+ } else {
9045+
9046+ UART_state_bitmap = le16_to_cpu(serial_state_notification->
9047+ UART_state_bitmap);
9048+ prev_UART_state_bitmap = tiocmget->prev_UART_state_bitmap;
9049+ icount = &tiocmget->icount;
9050+ spin_lock(&serial->serial_lock);
9051+ if ((UART_state_bitmap & B_OVERRUN) !=
9052+ (prev_UART_state_bitmap & B_OVERRUN))
9053+ icount->parity++;
9054+ if ((UART_state_bitmap & B_PARITY) !=
9055+ (prev_UART_state_bitmap & B_PARITY))
9056+ icount->parity++;
9057+ if ((UART_state_bitmap & B_FRAMING) !=
9058+ (prev_UART_state_bitmap & B_FRAMING))
9059+ icount->frame++;
9060+ if ((UART_state_bitmap & B_RING_SIGNAL) &&
9061+ !(prev_UART_state_bitmap & B_RING_SIGNAL))
9062+ icount->rng++;
9063+ if ((UART_state_bitmap & B_BREAK) !=
9064+ (prev_UART_state_bitmap & B_BREAK))
9065+ icount->brk++;
9066+ if ((UART_state_bitmap & B_TX_CARRIER) !=
9067+ (prev_UART_state_bitmap & B_TX_CARRIER))
9068+ icount->dsr++;
9069+ if ((UART_state_bitmap & B_RX_CARRIER) !=
9070+ (prev_UART_state_bitmap & B_RX_CARRIER))
9071+ icount->dcd++;
9072+ tiocmget->prev_UART_state_bitmap = UART_state_bitmap;
9073+ spin_unlock(&serial->serial_lock);
9074+ tiocmget->intr_completed = 1;
9075+ wake_up_interruptible(&tiocmget->waitq);
9076+ }
9077+ memset(serial_state_notification, 0,
9078+ sizeof(struct hso_serial_state_notification));
9079+ tiocmget_submit_urb(serial,
9080+ tiocmget,
9081+ serial->parent->usb);
9082+}
9083+
9084+/*
9085+ * next few functions largely stolen from drivers/serial/serial_core.c
9086+ */
9087+/* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
9088+ * - mask passed in arg for lines of interest
9089+ * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
9090+ * Caller should use TIOCGICOUNT to see which one it was
9091+ */
9092+static int
9093+hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
9094+{
9095+ DECLARE_WAITQUEUE(wait, current);
9096+ struct uart_icount cprev, cnow;
9097+ struct hso_tiocmget *tiocmget;
9098+ int ret;
9099+
9100+ tiocmget = serial->tiocmget;
9101+ if (!tiocmget)
9102+ return -ENOENT;
9103+ /*
9104+ * note the counters on entry
9105+ */
9106+ spin_lock_irq(&serial->serial_lock);
9107+ memcpy(&cprev, &tiocmget->icount, sizeof(struct uart_icount));
9108+ spin_unlock_irq(&serial->serial_lock);
9109+ add_wait_queue(&tiocmget->waitq, &wait);
9110+ for (;;) {
9111+ spin_lock_irq(&serial->serial_lock);
9112+ memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
9113+ spin_unlock_irq(&serial->serial_lock);
9114+ set_current_state(TASK_INTERRUPTIBLE);
9115+ if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
9116+ ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
9117+ ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd))) {
9118+ ret = 0;
9119+ break;
9120+ }
9121+ schedule();
9122+ /* see if a signal did it */
9123+ if (signal_pending(current)) {
9124+ ret = -ERESTARTSYS;
9125+ break;
9126+ }
9127+ cprev = cnow;
9128+ }
9129+ current->state = TASK_RUNNING;
9130+ remove_wait_queue(&tiocmget->waitq, &wait);
9131+
9132+ return ret;
9133+}
9134+
9135+/*
9136+ * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
9137+ * Return: write counters to the user passed counter struct
9138+ * NB: both 1->0 and 0->1 transitions are counted except for
9139+ * RI where only 0->1 is counted.
9140+ */
9141+static int hso_get_count(struct tty_struct *tty,
9142+ struct serial_icounter_struct *icount)
9143+{
9144+ struct uart_icount cnow;
9145+ struct hso_serial *serial = tty->driver_data;
9146+ struct hso_tiocmget *tiocmget = serial->tiocmget;
9147+
9148+ memset(icount, 0, sizeof(struct serial_icounter_struct));
9149+
9150+ if (!tiocmget)
9151+ return -ENOENT;
9152+ spin_lock_irq(&serial->serial_lock);
9153+ memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
9154+ spin_unlock_irq(&serial->serial_lock);
9155+
9156+ icount->cts = cnow.cts;
9157+ icount->dsr = cnow.dsr;
9158+ icount->rng = cnow.rng;
9159+ icount->dcd = cnow.dcd;
9160+ icount->rx = cnow.rx;
9161+ icount->tx = cnow.tx;
9162+ icount->frame = cnow.frame;
9163+ icount->overrun = cnow.overrun;
9164+ icount->parity = cnow.parity;
9165+ icount->brk = cnow.brk;
9166+ icount->buf_overrun = cnow.buf_overrun;
9167+
9168+ return 0;
9169+}
9170+
9171+
9172+static int hso_serial_tiocmget(struct tty_struct *tty)
9173+{
9174+ int retval;
9175+ struct hso_serial *serial = tty->driver_data;
9176+ struct hso_tiocmget *tiocmget;
9177+ u16 UART_state_bitmap;
9178+
9179+ /* sanity check */
9180+ if (!serial) {
9181+ D1("no tty structures");
9182+ return -EINVAL;
9183+ }
9184+ spin_lock_irq(&serial->serial_lock);
9185+ retval = ((serial->rts_state) ? TIOCM_RTS : 0) |
9186+ ((serial->dtr_state) ? TIOCM_DTR : 0);
9187+ tiocmget = serial->tiocmget;
9188+ if (tiocmget) {
9189+
9190+ UART_state_bitmap = le16_to_cpu(
9191+ tiocmget->prev_UART_state_bitmap);
9192+ if (UART_state_bitmap & B_RING_SIGNAL)
9193+ retval |= TIOCM_RNG;
9194+ if (UART_state_bitmap & B_RX_CARRIER)
9195+ retval |= TIOCM_CD;
9196+ if (UART_state_bitmap & B_TX_CARRIER)
9197+ retval |= TIOCM_DSR;
9198+ }
9199+ spin_unlock_irq(&serial->serial_lock);
9200+ return retval;
9201+}
9202+
9203+static int hso_serial_tiocmset(struct tty_struct *tty,
9204+ unsigned int set, unsigned int clear)
9205+{
9206+ int val = 0;
9207+ unsigned long flags;
9208+ int if_num;
9209+ struct hso_serial *serial = tty->driver_data;
9210+
9211+ /* sanity check */
9212+ if (!serial) {
9213+ D1("no tty structures");
9214+ return -EINVAL;
9215+ }
9216+
9217+ if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
9218+ return -EINVAL;
9219+
9220+ if_num = serial->parent->interface->altsetting->desc.bInterfaceNumber;
9221+
9222+ spin_lock_irqsave(&serial->serial_lock, flags);
9223+ if (set & TIOCM_RTS)
9224+ serial->rts_state = 1;
9225+ if (set & TIOCM_DTR)
9226+ serial->dtr_state = 1;
9227+
9228+ if (clear & TIOCM_RTS)
9229+ serial->rts_state = 0;
9230+ if (clear & TIOCM_DTR)
9231+ serial->dtr_state = 0;
9232+
9233+ if (serial->dtr_state)
9234+ val |= 0x01;
9235+ if (serial->rts_state)
9236+ val |= 0x02;
9237+
9238+ spin_unlock_irqrestore(&serial->serial_lock, flags);
9239+
9240+ return usb_control_msg(serial->parent->usb,
9241+ usb_rcvctrlpipe(serial->parent->usb, 0), 0x22,
9242+ 0x21, val, if_num, NULL, 0,
9243+ USB_CTRL_SET_TIMEOUT);
9244+}
9245+
9246+static int hso_serial_ioctl(struct tty_struct *tty,
9247+ unsigned int cmd, unsigned long arg)
9248+{
9249+ struct hso_serial *serial = tty->driver_data;
9250+ int ret = 0;
9251+ D4("IOCTL cmd: %d, arg: %ld", cmd, arg);
9252+
9253+ if (!serial)
9254+ return -ENODEV;
9255+ switch (cmd) {
9256+ case TIOCMIWAIT:
9257+ ret = hso_wait_modem_status(serial, arg);
9258+ break;
9259+ default:
9260+ ret = -ENOIOCTLCMD;
9261+ break;
9262+ }
9263+ return ret;
9264+}
9265+
9266+
9267+/* starts a transmit */
9268+static void hso_kick_transmit(struct hso_serial *serial)
9269+{
9270+ u8 *temp;
9271+ unsigned long flags;
9272+ int res;
9273+
9274+ spin_lock_irqsave(&serial->serial_lock, flags);
9275+ if (!serial->tx_buffer_count)
9276+ goto out;
9277+
9278+ if (serial->tx_urb_used)
9279+ goto out;
9280+
9281+ /* Wakeup USB interface if necessary */
9282+ if (hso_get_activity(serial->parent) == -EAGAIN)
9283+ goto out;
9284+
9285+ /* Switch pointers around to avoid memcpy */
9286+ temp = serial->tx_buffer;
9287+ serial->tx_buffer = serial->tx_data;
9288+ serial->tx_data = temp;
9289+ serial->tx_data_count = serial->tx_buffer_count;
9290+ serial->tx_buffer_count = 0;
9291+
9292+ /* If temp is set, it means we switched buffers */
9293+ if (temp && serial->write_data) {
9294+ res = serial->write_data(serial);
9295+ if (res >= 0)
9296+ serial->tx_urb_used = 1;
9297+ }
9298+out:
9299+ spin_unlock_irqrestore(&serial->serial_lock, flags);
9300+}
9301+
9302+/* make a request (for reading and writing data to muxed serial port) */
9303+static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
9304+ struct urb *ctrl_urb,
9305+ struct usb_ctrlrequest *ctrl_req,
9306+ u8 *ctrl_urb_data, u32 size)
9307+{
9308+ int result;
9309+ int pipe;
9310+
9311+ /* Sanity check */
9312+ if (!serial || !ctrl_urb || !ctrl_req) {
9313+ printk(KERN_ERR "%s: Wrong arguments\n", __func__);
9314+ return -EINVAL;
9315+ }
9316+
9317+ /* initialize */
9318+ ctrl_req->wValue = 0;
9319+ ctrl_req->wIndex = cpu_to_le16(hso_port_to_mux(port));
9320+ ctrl_req->wLength = cpu_to_le16(size);
9321+
9322+ if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {
9323+ /* Reading command */
9324+ ctrl_req->bRequestType = USB_DIR_IN |
9325+ USB_TYPE_OPTION_VENDOR |
9326+ USB_RECIP_INTERFACE;
9327+ ctrl_req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
9328+ pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
9329+ } else {
9330+ /* Writing command */
9331+ ctrl_req->bRequestType = USB_DIR_OUT |
9332+ USB_TYPE_OPTION_VENDOR |
9333+ USB_RECIP_INTERFACE;
9334+ ctrl_req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
9335+ pipe = usb_sndctrlpipe(serial->parent->usb, 0);
9336+ }
9337+ /* syslog */
9338+ D2("%s command (%02x) len: %d, port: %d",
9339+ type == USB_CDC_GET_ENCAPSULATED_RESPONSE ? "Read" : "Write",
9340+ ctrl_req->bRequestType, ctrl_req->wLength, port);
9341+
9342+ /* Load ctrl urb */
9343+ ctrl_urb->transfer_flags = 0;
9344+ usb_fill_control_urb(ctrl_urb,
9345+ serial->parent->usb,
9346+ pipe,
9347+ (u8 *) ctrl_req,
9348+ ctrl_urb_data, size, ctrl_callback, serial);
9349+ /* Send it on merry way */
9350+ result = usb_submit_urb(ctrl_urb, GFP_ATOMIC);
9351+ if (result) {
9352+ dev_err(&ctrl_urb->dev->dev,
9353+ "%s failed submit ctrl_urb %d type %d\n", __func__,
9354+ result, type);
9355+ return result;
9356+ }
9357+
9358+ /* done */
9359+ return size;
9360+}
9361+
9362+/* called by intr_callback when read occurs */
9363+static int hso_mux_serial_read(struct hso_serial *serial)
9364+{
9365+ if (!serial)
9366+ return -EINVAL;
9367+
9368+ /* clean data */
9369+ memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);
9370+ /* make the request */
9371+
9372+ if (serial->num_rx_urbs != 1) {
9373+ dev_err(&serial->parent->interface->dev,
9374+ "ERROR: mux'd reads with multiple buffers "
9375+ "not possible\n");
9376+ return 0;
9377+ }
9378+ return mux_device_request(serial,
9379+ USB_CDC_GET_ENCAPSULATED_RESPONSE,
9380+ serial->parent->port_spec & HSO_PORT_MASK,
9381+ serial->rx_urb[0],
9382+ &serial->ctrl_req_rx,
9383+ serial->rx_data[0], serial->rx_data_length);
9384+}
9385+
9386+/* used for muxed serial port callback (muxed serial read) */
9387+static void intr_callback(struct urb *urb)
9388+{
9389+ struct hso_shared_int *shared_int = urb->context;
9390+ struct hso_serial *serial;
9391+ unsigned char *port_req;
9392+ int status = urb->status;
9393+ int i;
9394+
9395+ usb_mark_last_busy(urb->dev);
9396+
9397+ /* sanity check */
9398+ if (!shared_int)
9399+ return;
9400+
9401+ /* status check */
9402+ if (status) {
9403+ handle_usb_error(status, __func__, NULL);
9404+ return;
9405+ }
9406+ D4("\n--- Got intr callback 0x%02X ---", status);
9407+
9408+ /* what request? */
9409+ port_req = urb->transfer_buffer;
9410+ D4(" port_req = 0x%.2X\n", *port_req);
9411+ /* loop over all muxed ports to find the one sending this */
9412+ for (i = 0; i < 8; i++) {
9413+ /* max 8 channels on MUX */
9414+ if (*port_req & (1 << i)) {
9415+ serial = get_serial_by_shared_int_and_type(shared_int,
9416+ (1 << i));
9417+ if (serial != NULL) {
9418+ D1("Pending read interrupt on port %d\n", i);
9419+ spin_lock(&serial->serial_lock);
9420+ if (serial->rx_state == RX_IDLE &&
9421+ atomic_read(&serial->port.count) > 0) {
9422+ /* Setup and send a ctrl req read on
9423+ * port i */
9424+ if (!serial->rx_urb_filled[0]) {
9425+ serial->rx_state = RX_SENT;
9426+ hso_mux_serial_read(serial);
9427+ } else
9428+ serial->rx_state = RX_PENDING;
9429+ } else {
9430+ D1("Already a read pending on "
9431+ "port %d or port not open\n", i);
9432+ }
9433+ spin_unlock(&serial->serial_lock);
9434+ }
9435+ }
9436+ }
9437+ /* Resubmit interrupt urb */
9438+ hso_mux_submit_intr_urb(shared_int, urb->dev, GFP_ATOMIC);
9439+}
9440+
9441+/* called for writing to muxed serial port */
9442+static int hso_mux_serial_write_data(struct hso_serial *serial)
9443+{
9444+ if (NULL == serial)
9445+ return -EINVAL;
9446+
9447+ return mux_device_request(serial,
9448+ USB_CDC_SEND_ENCAPSULATED_COMMAND,
9449+ serial->parent->port_spec & HSO_PORT_MASK,
9450+ serial->tx_urb,
9451+ &serial->ctrl_req_tx,
9452+ serial->tx_data, serial->tx_data_count);
9453+}
9454+
9455+/* write callback for Diag and CS port */
9456+static void hso_std_serial_write_bulk_callback(struct urb *urb)
9457+{
9458+ struct hso_serial *serial = urb->context;
9459+ int status = urb->status;
9460+
9461+ /* sanity check */
9462+ if (!serial) {
9463+ D1("serial == NULL");
9464+ return;
9465+ }
9466+
9467+ spin_lock(&serial->serial_lock);
9468+ serial->tx_urb_used = 0;
9469+ spin_unlock(&serial->serial_lock);
9470+ if (status) {
9471+ handle_usb_error(status, __func__, serial->parent);
9472+ return;
9473+ }
9474+ hso_put_activity(serial->parent);
9475+ tty_port_tty_wakeup(&serial->port);
9476+ hso_kick_transmit(serial);
9477+
9478+ D1(" ");
9479+}
9480+
9481+/* called for writing diag or CS serial port */
9482+static int hso_std_serial_write_data(struct hso_serial *serial)
9483+{
9484+ int count = serial->tx_data_count;
9485+ int result;
9486+
9487+ usb_fill_bulk_urb(serial->tx_urb,
9488+ serial->parent->usb,
9489+ usb_sndbulkpipe(serial->parent->usb,
9490+ serial->out_endp->
9491+ bEndpointAddress & 0x7F),
9492+ serial->tx_data, serial->tx_data_count,
9493+ hso_std_serial_write_bulk_callback, serial);
9494+
9495+ result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
9496+ if (result) {
9497+ dev_warn(&serial->parent->usb->dev,
9498+ "Failed to submit urb - res %d\n", result);
9499+ return result;
9500+ }
9501+
9502+ return count;
9503+}
9504+
9505+/* callback after read or write on muxed serial port */
9506+static void ctrl_callback(struct urb *urb)
9507+{
9508+ struct hso_serial *serial = urb->context;
9509+ struct usb_ctrlrequest *req;
9510+ int status = urb->status;
9511+
9512+ /* sanity check */
9513+ if (!serial)
9514+ return;
9515+
9516+ spin_lock(&serial->serial_lock);
9517+ serial->tx_urb_used = 0;
9518+ spin_unlock(&serial->serial_lock);
9519+ if (status) {
9520+ handle_usb_error(status, __func__, serial->parent);
9521+ return;
9522+ }
9523+
9524+ /* what request? */
9525+ req = (struct usb_ctrlrequest *)(urb->setup_packet);
9526+ D4("\n--- Got muxed ctrl callback 0x%02X ---", status);
9527+ D4("Actual length of urb = %d\n", urb->actual_length);
9528+ DUMP1(urb->transfer_buffer, urb->actual_length);
9529+
9530+ if (req->bRequestType ==
9531+ (USB_DIR_IN | USB_TYPE_OPTION_VENDOR | USB_RECIP_INTERFACE)) {
9532+ /* response to a read command */
9533+ serial->rx_urb_filled[0] = 1;
9534+ spin_lock(&serial->serial_lock);
9535+ put_rxbuf_data_and_resubmit_ctrl_urb(serial);
9536+ spin_unlock(&serial->serial_lock);
9537+ } else {
9538+ hso_put_activity(serial->parent);
9539+ tty_port_tty_wakeup(&serial->port);
9540+ /* response to a write command */
9541+ hso_kick_transmit(serial);
9542+ }
9543+}
9544+
9545+/* handle RX data for serial port */
9546+static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
9547+{
9548+ struct tty_struct *tty;
9549+ int count;
9550+
9551+ /* Sanity check */
9552+ if (urb == NULL || serial == NULL) {
9553+ D1("serial = NULL");
9554+ return -2;
9555+ }
9556+
9557+ tty = tty_port_tty_get(&serial->port);
9558+
9559+ if (tty && test_bit(TTY_THROTTLED, &tty->flags)) {
9560+ tty_kref_put(tty);
9561+ return -1;
9562+ }
9563+
9564+ /* Push data to tty */
9565+ D1("data to push to tty");
9566+ count = tty_buffer_request_room(&serial->port, urb->actual_length);
9567+ if (count >= urb->actual_length) {
9568+ tty_insert_flip_string(&serial->port, urb->transfer_buffer,
9569+ urb->actual_length);
9570+ tty_flip_buffer_push(&serial->port);
9571+ } else {
9572+ dev_warn(&serial->parent->usb->dev,
9573+ "dropping data, %d bytes lost\n", urb->actual_length);
9574+ }
9575+
9576+ tty_kref_put(tty);
9577+
9578+ serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
9579+
9580+ return 0;
9581+}
9582+
9583+
9584+/* Base driver functions */
9585+
9586+static void hso_log_port(struct hso_device *hso_dev)
9587+{
9588+ char *port_type;
9589+ char port_dev[20];
9590+
9591+ switch (hso_dev->port_spec & HSO_PORT_MASK) {
9592+ case HSO_PORT_CONTROL:
9593+ port_type = "Control";
9594+ break;
9595+ case HSO_PORT_APP:
9596+ port_type = "Application";
9597+ break;
9598+ case HSO_PORT_GPS:
9599+ port_type = "GPS";
9600+ break;
9601+ case HSO_PORT_GPS_CONTROL:
9602+ port_type = "GPS control";
9603+ break;
9604+ case HSO_PORT_APP2:
9605+ port_type = "Application2";
9606+ break;
9607+ case HSO_PORT_PCSC:
9608+ port_type = "PCSC";
9609+ break;
9610+ case HSO_PORT_DIAG:
9611+ port_type = "Diagnostic";
9612+ break;
9613+ case HSO_PORT_DIAG2:
9614+ port_type = "Diagnostic2";
9615+ break;
9616+ case HSO_PORT_MODEM:
9617+ port_type = "Modem";
9618+ break;
9619+ case HSO_PORT_NETWORK:
9620+ port_type = "Network";
9621+ break;
9622+ default:
9623+ port_type = "Unknown";
9624+ break;
9625+ }
9626+ if ((hso_dev->port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
9627+ sprintf(port_dev, "%s", dev2net(hso_dev)->net->name);
9628+ } else
9629+ sprintf(port_dev, "/dev/%s%d", tty_filename,
9630+ dev2ser(hso_dev)->minor);
9631+
9632+ dev_dbg(&hso_dev->interface->dev, "HSO: Found %s port %s\n",
9633+ port_type, port_dev);
9634+}
9635+
9636+static int hso_start_net_device(struct hso_device *hso_dev)
9637+{
9638+ int i, result = 0;
9639+ struct hso_net *hso_net = dev2net(hso_dev);
9640+
9641+ if (!hso_net)
9642+ return -ENODEV;
9643+
9644+ /* send URBs for all read buffers */
9645+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
9646+
9647+ /* Prep a receive URB */
9648+ usb_fill_bulk_urb(hso_net->mux_bulk_rx_urb_pool[i],
9649+ hso_dev->usb,
9650+ usb_rcvbulkpipe(hso_dev->usb,
9651+ hso_net->in_endp->
9652+ bEndpointAddress & 0x7F),
9653+ hso_net->mux_bulk_rx_buf_pool[i],
9654+ MUX_BULK_RX_BUF_SIZE, read_bulk_callback,
9655+ hso_net);
9656+
9657+ /* Put it out there so the device can send us stuff */
9658+ result = usb_submit_urb(hso_net->mux_bulk_rx_urb_pool[i],
9659+ GFP_NOIO);
9660+ if (result)
9661+ dev_warn(&hso_dev->usb->dev,
9662+ "%s failed mux_bulk_rx_urb[%d] %d\n", __func__,
9663+ i, result);
9664+ }
9665+
9666+ return result;
9667+}
9668+
9669+static int hso_stop_net_device(struct hso_device *hso_dev)
9670+{
9671+ int i;
9672+ struct hso_net *hso_net = dev2net(hso_dev);
9673+
9674+ if (!hso_net)
9675+ return -ENODEV;
9676+
9677+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
9678+ if (hso_net->mux_bulk_rx_urb_pool[i])
9679+ usb_kill_urb(hso_net->mux_bulk_rx_urb_pool[i]);
9680+
9681+ }
9682+ if (hso_net->mux_bulk_tx_urb)
9683+ usb_kill_urb(hso_net->mux_bulk_tx_urb);
9684+
9685+ return 0;
9686+}
9687+
9688+static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags)
9689+{
9690+ int i, result = 0;
9691+ struct hso_serial *serial = dev2ser(hso_dev);
9692+
9693+ if (!serial)
9694+ return -ENODEV;
9695+
9696+ /* If it is not the MUX port fill in and submit a bulk urb (already
9697+ * allocated in hso_serial_start) */
9698+ if (!(serial->parent->port_spec & HSO_INTF_MUX)) {
9699+ for (i = 0; i < serial->num_rx_urbs; i++) {
9700+ usb_fill_bulk_urb(serial->rx_urb[i],
9701+ serial->parent->usb,
9702+ usb_rcvbulkpipe(serial->parent->usb,
9703+ serial->in_endp->
9704+ bEndpointAddress &
9705+ 0x7F),
9706+ serial->rx_data[i],
9707+ serial->rx_data_length,
9708+ hso_std_serial_read_bulk_callback,
9709+ serial);
9710+ result = usb_submit_urb(serial->rx_urb[i], flags);
9711+ if (result) {
9712+ dev_warn(&serial->parent->usb->dev,
9713+ "Failed to submit urb - res %d\n",
9714+ result);
9715+ break;
9716+ }
9717+ }
9718+ } else {
9719+ mutex_lock(&serial->shared_int->shared_int_lock);
9720+ if (!serial->shared_int->use_count) {
9721+ result =
9722+ hso_mux_submit_intr_urb(serial->shared_int,
9723+ hso_dev->usb, flags);
9724+ }
9725+ serial->shared_int->use_count++;
9726+ mutex_unlock(&serial->shared_int->shared_int_lock);
9727+ }
9728+ if (serial->tiocmget)
9729+ tiocmget_submit_urb(serial,
9730+ serial->tiocmget,
9731+ serial->parent->usb);
9732+ return result;
9733+}
9734+
9735+static int hso_stop_serial_device(struct hso_device *hso_dev)
9736+{
9737+ int i;
9738+ struct hso_serial *serial = dev2ser(hso_dev);
9739+ struct hso_tiocmget *tiocmget;
9740+
9741+ if (!serial)
9742+ return -ENODEV;
9743+
9744+ for (i = 0; i < serial->num_rx_urbs; i++) {
9745+ if (serial->rx_urb[i]) {
9746+ usb_kill_urb(serial->rx_urb[i]);
9747+ serial->rx_urb_filled[i] = 0;
9748+ }
9749+ }
9750+ serial->curr_rx_urb_idx = 0;
9751+
9752+ if (serial->tx_urb)
9753+ usb_kill_urb(serial->tx_urb);
9754+
9755+ if (serial->shared_int) {
9756+ mutex_lock(&serial->shared_int->shared_int_lock);
9757+ if (serial->shared_int->use_count &&
9758+ (--serial->shared_int->use_count == 0)) {
9759+ struct urb *urb;
9760+
9761+ urb = serial->shared_int->shared_intr_urb;
9762+ if (urb)
9763+ usb_kill_urb(urb);
9764+ }
9765+ mutex_unlock(&serial->shared_int->shared_int_lock);
9766+ }
9767+ tiocmget = serial->tiocmget;
9768+ if (tiocmget) {
9769+ wake_up_interruptible(&tiocmget->waitq);
9770+ usb_kill_urb(tiocmget->urb);
9771+ }
9772+
9773+ return 0;
9774+}
9775+
9776+static void hso_serial_common_free(struct hso_serial *serial)
9777+{
9778+ int i;
9779+
9780+ if (serial->parent->dev)
9781+ device_remove_file(serial->parent->dev, &dev_attr_hsotype);
9782+
9783+ tty_unregister_device(tty_drv, serial->minor);
9784+
9785+ for (i = 0; i < serial->num_rx_urbs; i++) {
9786+ /* unlink and free RX URB */
9787+ usb_free_urb(serial->rx_urb[i]);
9788+ /* free the RX buffer */
9789+ kfree(serial->rx_data[i]);
9790+ }
9791+
9792+ /* unlink and free TX URB */
9793+ usb_free_urb(serial->tx_urb);
9794+ kfree(serial->tx_data);
9795+ tty_port_destroy(&serial->port);
9796+}
9797+
9798+static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
9799+ int rx_size, int tx_size)
9800+{
9801+ struct device *dev;
9802+ int minor;
9803+ int i;
9804+
9805+ tty_port_init(&serial->port);
9806+
9807+ minor = get_free_serial_index();
9808+ if (minor < 0)
9809+ goto exit;
9810+
9811+ /* register our minor number */
9812+ serial->parent->dev = tty_port_register_device(&serial->port, tty_drv,
9813+ minor, &serial->parent->interface->dev);
9814+ dev = serial->parent->dev;
9815+ dev_set_drvdata(dev, serial->parent);
9816+ i = device_create_file(dev, &dev_attr_hsotype);
9817+
9818+ /* fill in specific data for later use */
9819+ serial->minor = minor;
9820+ serial->magic = HSO_SERIAL_MAGIC;
9821+ spin_lock_init(&serial->serial_lock);
9822+ serial->num_rx_urbs = num_urbs;
9823+
9824+ /* RX, allocate urb and initialize */
9825+
9826+ /* prepare our RX buffer */
9827+ serial->rx_data_length = rx_size;
9828+ for (i = 0; i < serial->num_rx_urbs; i++) {
9829+ serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
9830+ if (!serial->rx_urb[i]) {
9831+ dev_err(dev, "Could not allocate urb?\n");
9832+ goto exit;
9833+ }
9834+ serial->rx_urb[i]->transfer_buffer = NULL;
9835+ serial->rx_urb[i]->transfer_buffer_length = 0;
9836+ serial->rx_data[i] = kzalloc(serial->rx_data_length,
9837+ GFP_KERNEL);
9838+ if (!serial->rx_data[i])
9839+ goto exit;
9840+ }
9841+
9842+ /* TX, allocate urb and initialize */
9843+ serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
9844+ if (!serial->tx_urb) {
9845+ dev_err(dev, "Could not allocate urb?\n");
9846+ goto exit;
9847+ }
9848+ serial->tx_urb->transfer_buffer = NULL;
9849+ serial->tx_urb->transfer_buffer_length = 0;
9850+ /* prepare our TX buffer */
9851+ serial->tx_data_count = 0;
9852+ serial->tx_buffer_count = 0;
9853+ serial->tx_data_length = tx_size;
9854+ serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
9855+ if (!serial->tx_data)
9856+ goto exit;
9857+
9858+ serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
9859+ if (!serial->tx_buffer)
9860+ goto exit;
9861+
9862+ return 0;
9863+exit:
9864+ hso_serial_common_free(serial);
9865+ return -1;
9866+}
9867+
9868+/* Creates a general hso device */
9869+static struct hso_device *hso_create_device(struct usb_interface *intf,
9870+ int port_spec)
9871+{
9872+ struct hso_device *hso_dev;
9873+
9874+ hso_dev = kzalloc(sizeof(*hso_dev), GFP_ATOMIC);
9875+ if (!hso_dev)
9876+ return NULL;
9877+
9878+ hso_dev->port_spec = port_spec;
9879+ hso_dev->usb = interface_to_usbdev(intf);
9880+ hso_dev->interface = intf;
9881+ kref_init(&hso_dev->ref);
9882+ mutex_init(&hso_dev->mutex);
9883+
9884+ INIT_WORK(&hso_dev->async_get_intf, async_get_intf);
9885+ INIT_WORK(&hso_dev->async_put_intf, async_put_intf);
9886+ INIT_WORK(&hso_dev->reset_device, reset_device);
9887+
9888+ return hso_dev;
9889+}
9890+
9891+/* Removes a network device in the network device table */
9892+static int remove_net_device(struct hso_device *hso_dev)
9893+{
9894+ int i;
9895+
9896+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
9897+ if (network_table[i] == hso_dev) {
9898+ network_table[i] = NULL;
9899+ break;
9900+ }
9901+ }
9902+ if (i == HSO_MAX_NET_DEVICES)
9903+ return -1;
9904+ return 0;
9905+}
9906+
9907+/* Frees our network device */
9908+static void hso_free_net_device(struct hso_device *hso_dev)
9909+{
9910+ int i;
9911+ struct hso_net *hso_net = dev2net(hso_dev);
9912+
9913+ if (!hso_net)
9914+ return;
9915+
9916+ remove_net_device(hso_net->parent);
9917+
9918+ if (hso_net->net)
9919+ unregister_netdev(hso_net->net);
9920+
9921+ /* start freeing */
9922+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
9923+ usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);
9924+ kfree(hso_net->mux_bulk_rx_buf_pool[i]);
9925+ hso_net->mux_bulk_rx_buf_pool[i] = NULL;
9926+ }
9927+ usb_free_urb(hso_net->mux_bulk_tx_urb);
9928+ kfree(hso_net->mux_bulk_tx_buf);
9929+ hso_net->mux_bulk_tx_buf = NULL;
9930+
9931+ if (hso_net->net)
9932+ free_netdev(hso_net->net);
9933+
9934+ kfree(hso_dev);
9935+}
9936+
9937+static const struct net_device_ops hso_netdev_ops = {
9938+ .ndo_open = hso_net_open,
9939+ .ndo_stop = hso_net_close,
9940+ .ndo_start_xmit = hso_net_start_xmit,
9941+ .ndo_tx_timeout = hso_net_tx_timeout,
9942+};
9943+
9944+/* initialize the network interface */
9945+static void hso_net_init(struct net_device *net)
9946+{
9947+ struct hso_net *hso_net = netdev_priv(net);
9948+
9949+ D1("sizeof hso_net is %d", (int)sizeof(*hso_net));
9950+
9951+ /* fill in the other fields */
9952+ net->netdev_ops = &hso_netdev_ops;
9953+ net->watchdog_timeo = HSO_NET_TX_TIMEOUT;
9954+ net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
9955+ net->type = ARPHRD_NONE;
9956+ net->mtu = DEFAULT_MTU - 14;
9957+ net->tx_queue_len = 10;
9958+ net->ethtool_ops = &ops;
9959+
9960+ /* and initialize the semaphore */
9961+ spin_lock_init(&hso_net->net_lock);
9962+}
9963+
9964+/* Adds a network device in the network device table */
9965+static int add_net_device(struct hso_device *hso_dev)
9966+{
9967+ int i;
9968+
9969+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
9970+ if (network_table[i] == NULL) {
9971+ network_table[i] = hso_dev;
9972+ break;
9973+ }
9974+ }
9975+ if (i == HSO_MAX_NET_DEVICES)
9976+ return -1;
9977+ return 0;
9978+}
9979+
9980+static int hso_rfkill_set_block(void *data, bool blocked)
9981+{
9982+ struct hso_device *hso_dev = data;
9983+ int enabled = !blocked;
9984+ int rv;
9985+
9986+ mutex_lock(&hso_dev->mutex);
9987+ if (hso_dev->usb_gone)
9988+ rv = 0;
9989+ else
9990+ rv = usb_control_msg(hso_dev->usb, usb_rcvctrlpipe(hso_dev->usb, 0),
9991+ enabled ? 0x82 : 0x81, 0x40, 0, 0, NULL, 0,
9992+ USB_CTRL_SET_TIMEOUT);
9993+ mutex_unlock(&hso_dev->mutex);
9994+ return rv;
9995+}
9996+
9997+static const struct rfkill_ops hso_rfkill_ops = {
9998+ .set_block = hso_rfkill_set_block,
9999+};
10000+
10001+/* Creates and sets up everything for rfkill */
10002+static void hso_create_rfkill(struct hso_device *hso_dev,
10003+ struct usb_interface *interface)
10004+{
10005+ struct hso_net *hso_net = dev2net(hso_dev);
10006+ struct device *dev = &hso_net->net->dev;
10007+ char *rfkn;
10008+
10009+ rfkn = kzalloc(20, GFP_KERNEL);
10010+ if (!rfkn)
10011+ dev_err(dev, "%s - Out of memory\n", __func__);
10012+
10013+ snprintf(rfkn, 20, "hso-%d",
10014+ interface->altsetting->desc.bInterfaceNumber);
10015+
10016+ hso_net->rfkill = rfkill_alloc(rfkn,
10017+ &interface_to_usbdev(interface)->dev,
10018+ RFKILL_TYPE_WWAN,
10019+ &hso_rfkill_ops, hso_dev);
10020+ if (!hso_net->rfkill) {
10021+ dev_err(dev, "%s - Out of memory\n", __func__);
10022+ kfree(rfkn);
10023+ return;
10024+ }
10025+ if (rfkill_register(hso_net->rfkill) < 0) {
10026+ rfkill_destroy(hso_net->rfkill);
10027+ kfree(rfkn);
10028+ hso_net->rfkill = NULL;
10029+ dev_err(dev, "%s - Failed to register rfkill\n", __func__);
10030+ return;
10031+ }
10032+}
10033+
10034+static struct device_type hso_type = {
10035+ .name = "wwan",
10036+};
10037+
10038+/* Creates our network device */
10039+static struct hso_device *hso_create_net_device(struct usb_interface *interface,
10040+ int port_spec)
10041+{
10042+ int result, i;
10043+ struct net_device *net;
10044+ struct hso_net *hso_net;
10045+ struct hso_device *hso_dev;
10046+
10047+ hso_dev = hso_create_device(interface, port_spec);
10048+ if (!hso_dev)
10049+ return NULL;
10050+
10051+ /* allocate our network device, then we can put in our private data */
10052+ /* call hso_net_init to do the basic initialization */
10053+ net = alloc_netdev(sizeof(struct hso_net), "hso%d", NET_NAME_UNKNOWN,
10054+ hso_net_init);
10055+ if (!net) {
10056+ dev_err(&interface->dev, "Unable to create ethernet device\n");
10057+ goto exit;
10058+ }
10059+
10060+ hso_net = netdev_priv(net);
10061+
10062+ hso_dev->port_data.dev_net = hso_net;
10063+ hso_net->net = net;
10064+ hso_net->parent = hso_dev;
10065+
10066+ hso_net->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
10067+ USB_DIR_IN);
10068+ if (!hso_net->in_endp) {
10069+ dev_err(&interface->dev, "Can't find BULK IN endpoint\n");
10070+ goto exit;
10071+ }
10072+ hso_net->out_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
10073+ USB_DIR_OUT);
10074+ if (!hso_net->out_endp) {
10075+ dev_err(&interface->dev, "Can't find BULK OUT endpoint\n");
10076+ goto exit;
10077+ }
10078+ SET_NETDEV_DEV(net, &interface->dev);
10079+ SET_NETDEV_DEVTYPE(net, &hso_type);
10080+
10081+ /* registering our net device */
10082+ result = register_netdev(net);
10083+ if (result) {
10084+ dev_err(&interface->dev, "Failed to register device\n");
10085+ goto exit;
10086+ }
10087+
10088+ /* start allocating */
10089+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
10090+ hso_net->mux_bulk_rx_urb_pool[i] = usb_alloc_urb(0, GFP_KERNEL);
10091+ if (!hso_net->mux_bulk_rx_urb_pool[i]) {
10092+ dev_err(&interface->dev, "Could not allocate rx urb\n");
10093+ goto exit;
10094+ }
10095+ hso_net->mux_bulk_rx_buf_pool[i] = kzalloc(MUX_BULK_RX_BUF_SIZE,
10096+ GFP_KERNEL);
10097+ if (!hso_net->mux_bulk_rx_buf_pool[i])
10098+ goto exit;
10099+ }
10100+ hso_net->mux_bulk_tx_urb = usb_alloc_urb(0, GFP_KERNEL);
10101+ if (!hso_net->mux_bulk_tx_urb) {
10102+ dev_err(&interface->dev, "Could not allocate tx urb\n");
10103+ goto exit;
10104+ }
10105+ hso_net->mux_bulk_tx_buf = kzalloc(MUX_BULK_TX_BUF_SIZE, GFP_KERNEL);
10106+ if (!hso_net->mux_bulk_tx_buf)
10107+ goto exit;
10108+
10109+ add_net_device(hso_dev);
10110+
10111+ hso_log_port(hso_dev);
10112+
10113+ hso_create_rfkill(hso_dev, interface);
10114+
10115+ return hso_dev;
10116+exit:
10117+ hso_free_net_device(hso_dev);
10118+ return NULL;
10119+}
10120+
10121+static void hso_free_tiomget(struct hso_serial *serial)
10122+{
10123+ struct hso_tiocmget *tiocmget;
10124+ if (!serial)
10125+ return;
10126+ tiocmget = serial->tiocmget;
10127+ if (tiocmget) {
10128+ usb_free_urb(tiocmget->urb);
10129+ tiocmget->urb = NULL;
10130+ serial->tiocmget = NULL;
10131+ kfree(tiocmget);
10132+ }
10133+}
10134+
10135+/* Frees an AT channel ( goes for both mux and non-mux ) */
10136+static void hso_free_serial_device(struct hso_device *hso_dev)
10137+{
10138+ struct hso_serial *serial = dev2ser(hso_dev);
10139+
10140+ if (!serial)
10141+ return;
10142+ set_serial_by_index(serial->minor, NULL);
10143+
10144+ hso_serial_common_free(serial);
10145+
10146+ if (serial->shared_int) {
10147+ mutex_lock(&serial->shared_int->shared_int_lock);
10148+ if (--serial->shared_int->ref_count == 0)
10149+ hso_free_shared_int(serial->shared_int);
10150+ else
10151+ mutex_unlock(&serial->shared_int->shared_int_lock);
10152+ }
10153+ hso_free_tiomget(serial);
10154+ kfree(serial);
10155+ kfree(hso_dev);
10156+}
10157+
10158+/* Creates a bulk AT channel */
10159+static struct hso_device *hso_create_bulk_serial_device(
10160+ struct usb_interface *interface, int port)
10161+{
10162+ struct hso_device *hso_dev;
10163+ struct hso_serial *serial;
10164+ int num_urbs;
10165+ struct hso_tiocmget *tiocmget;
10166+
10167+ hso_dev = hso_create_device(interface, port);
10168+ if (!hso_dev)
10169+ return NULL;
10170+
10171+ serial = kzalloc(sizeof(*serial), GFP_KERNEL);
10172+ if (!serial)
10173+ goto exit;
10174+
10175+ serial->parent = hso_dev;
10176+ hso_dev->port_data.dev_serial = serial;
10177+
10178+ if ((port & HSO_PORT_MASK) == HSO_PORT_MODEM) {
10179+ num_urbs = 2;
10180+ serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
10181+ GFP_KERNEL);
10182+ /* it isn't going to break our heart if serial->tiocmget
10183+ * allocation fails don't bother checking this.
10184+ */
10185+ if (serial->tiocmget) {
10186+ tiocmget = serial->tiocmget;
10187+ tiocmget->urb = usb_alloc_urb(0, GFP_KERNEL);
10188+ if (tiocmget->urb) {
10189+ mutex_init(&tiocmget->mutex);
10190+ init_waitqueue_head(&tiocmget->waitq);
10191+ tiocmget->endp = hso_get_ep(
10192+ interface,
10193+ USB_ENDPOINT_XFER_INT,
10194+ USB_DIR_IN);
10195+ } else
10196+ hso_free_tiomget(serial);
10197+ }
10198+ }
10199+ else
10200+ num_urbs = 1;
10201+
10202+ if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,
10203+ BULK_URB_TX_SIZE))
10204+ goto exit;
10205+
10206+ serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
10207+ USB_DIR_IN);
10208+ if (!serial->in_endp) {
10209+ dev_err(&interface->dev, "Failed to find BULK IN ep\n");
10210+ goto exit2;
10211+ }
10212+
10213+ if (!
10214+ (serial->out_endp =
10215+ hso_get_ep(interface, USB_ENDPOINT_XFER_BULK, USB_DIR_OUT))) {
10216+ dev_err(&interface->dev, "Failed to find BULK IN ep\n");
10217+ goto exit2;
10218+ }
10219+
10220+ serial->write_data = hso_std_serial_write_data;
10221+
10222+ /* and record this serial */
10223+ set_serial_by_index(serial->minor, serial);
10224+
10225+ /* setup the proc dirs and files if needed */
10226+ hso_log_port(hso_dev);
10227+
10228+ /* done, return it */
10229+ return hso_dev;
10230+
10231+exit2:
10232+ hso_serial_common_free(serial);
10233+exit:
10234+ hso_free_tiomget(serial);
10235+ kfree(serial);
10236+ kfree(hso_dev);
10237+ return NULL;
10238+}
10239+
10240+/* Creates a multiplexed AT channel */
10241+static
10242+struct hso_device *hso_create_mux_serial_device(struct usb_interface *interface,
10243+ int port,
10244+ struct hso_shared_int *mux)
10245+{
10246+ struct hso_device *hso_dev;
10247+ struct hso_serial *serial;
10248+ int port_spec;
10249+
10250+ port_spec = HSO_INTF_MUX;
10251+ port_spec &= ~HSO_PORT_MASK;
10252+
10253+ port_spec |= hso_mux_to_port(port);
10254+ if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NO_PORT)
10255+ return NULL;
10256+
10257+ hso_dev = hso_create_device(interface, port_spec);
10258+ if (!hso_dev)
10259+ return NULL;
10260+
10261+ serial = kzalloc(sizeof(*serial), GFP_KERNEL);
10262+ if (!serial)
10263+ goto exit;
10264+
10265+ hso_dev->port_data.dev_serial = serial;
10266+ serial->parent = hso_dev;
10267+
10268+ if (hso_serial_common_create
10269+ (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
10270+ goto exit;
10271+
10272+ serial->tx_data_length--;
10273+ serial->write_data = hso_mux_serial_write_data;
10274+
10275+ serial->shared_int = mux;
10276+ mutex_lock(&serial->shared_int->shared_int_lock);
10277+ serial->shared_int->ref_count++;
10278+ mutex_unlock(&serial->shared_int->shared_int_lock);
10279+
10280+ /* and record this serial */
10281+ set_serial_by_index(serial->minor, serial);
10282+
10283+ /* setup the proc dirs and files if needed */
10284+ hso_log_port(hso_dev);
10285+
10286+ /* done, return it */
10287+ return hso_dev;
10288+
10289+exit:
10290+ if (serial) {
10291+ tty_unregister_device(tty_drv, serial->minor);
10292+ kfree(serial);
10293+ }
10294+ if (hso_dev)
10295+ kfree(hso_dev);
10296+ return NULL;
10297+
10298+}
10299+
10300+static void hso_free_shared_int(struct hso_shared_int *mux)
10301+{
10302+ usb_free_urb(mux->shared_intr_urb);
10303+ kfree(mux->shared_intr_buf);
10304+ mutex_unlock(&mux->shared_int_lock);
10305+ kfree(mux);
10306+}
10307+
10308+static
10309+struct hso_shared_int *hso_create_shared_int(struct usb_interface *interface)
10310+{
10311+ struct hso_shared_int *mux = kzalloc(sizeof(*mux), GFP_KERNEL);
10312+
10313+ if (!mux)
10314+ return NULL;
10315+
10316+ mux->intr_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_INT,
10317+ USB_DIR_IN);
10318+ if (!mux->intr_endp) {
10319+ dev_err(&interface->dev, "Can't find INT IN endpoint\n");
10320+ goto exit;
10321+ }
10322+
10323+ mux->shared_intr_urb = usb_alloc_urb(0, GFP_KERNEL);
10324+ if (!mux->shared_intr_urb) {
10325+ dev_err(&interface->dev, "Could not allocate intr urb?\n");
10326+ goto exit;
10327+ }
10328+ mux->shared_intr_buf =
10329+ kzalloc(le16_to_cpu(mux->intr_endp->wMaxPacketSize),
10330+ GFP_KERNEL);
10331+ if (!mux->shared_intr_buf)
10332+ goto exit;
10333+
10334+ mutex_init(&mux->shared_int_lock);
10335+
10336+ return mux;
10337+
10338+exit:
10339+ kfree(mux->shared_intr_buf);
10340+ usb_free_urb(mux->shared_intr_urb);
10341+ kfree(mux);
10342+ return NULL;
10343+}
10344+
10345+/* Gets the port spec for a certain interface */
10346+static int hso_get_config_data(struct usb_interface *interface)
10347+{
10348+ struct usb_device *usbdev = interface_to_usbdev(interface);
10349+ u8 *config_data = kmalloc(17, GFP_KERNEL);
10350+ u32 if_num = interface->altsetting->desc.bInterfaceNumber;
10351+ s32 result;
10352+
10353+ if (!config_data)
10354+ return -ENOMEM;
10355+ if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
10356+ 0x86, 0xC0, 0, 0, config_data, 17,
10357+ USB_CTRL_SET_TIMEOUT) != 0x11) {
10358+ kfree(config_data);
10359+ return -EIO;
10360+ }
10361+
10362+ switch (config_data[if_num]) {
10363+ case 0x0:
10364+ result = 0;
10365+ break;
10366+ case 0x1:
10367+ result = HSO_PORT_DIAG;
10368+ break;
10369+ case 0x2:
10370+ result = HSO_PORT_GPS;
10371+ break;
10372+ case 0x3:
10373+ result = HSO_PORT_GPS_CONTROL;
10374+ break;
10375+ case 0x4:
10376+ result = HSO_PORT_APP;
10377+ break;
10378+ case 0x5:
10379+ result = HSO_PORT_APP2;
10380+ break;
10381+ case 0x6:
10382+ result = HSO_PORT_CONTROL;
10383+ break;
10384+ case 0x7:
10385+ result = HSO_PORT_NETWORK;
10386+ break;
10387+ case 0x8:
10388+ result = HSO_PORT_MODEM;
10389+ break;
10390+ case 0x9:
10391+ result = HSO_PORT_MSD;
10392+ break;
10393+ case 0xa:
10394+ result = HSO_PORT_PCSC;
10395+ break;
10396+ case 0xb:
10397+ result = HSO_PORT_VOICE;
10398+ break;
10399+ default:
10400+ result = 0;
10401+ }
10402+
10403+ if (result)
10404+ result |= HSO_INTF_BULK;
10405+
10406+ if (config_data[16] & 0x1)
10407+ result |= HSO_INFO_CRC_BUG;
10408+
10409+ kfree(config_data);
10410+ return result;
10411+}
10412+
10413+/* called once for each interface upon device insertion */
10414+static int hso_probe(struct usb_interface *interface,
10415+ const struct usb_device_id *id)
10416+{
10417+ int mux, i, if_num, port_spec;
10418+ unsigned char port_mask;
10419+ struct hso_device *hso_dev = NULL;
10420+ struct hso_shared_int *shared_int;
10421+ struct hso_device *tmp_dev = NULL;
10422+
10423+ if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
10424+ dev_err(&interface->dev, "Not our interface\n");
10425+ return -ENODEV;
10426+ }
10427+
10428+ if_num = interface->altsetting->desc.bInterfaceNumber;
10429+
10430+ /* Get the interface/port specification from either driver_info or from
10431+ * the device itself */
10432+ if (id->driver_info)
10433+ port_spec = ((u32 *)(id->driver_info))[if_num];
10434+ else
10435+ port_spec = hso_get_config_data(interface);
10436+
10437+ /* Check if we need to switch to alt interfaces prior to port
10438+ * configuration */
10439+ if (interface->num_altsetting > 1)
10440+ usb_set_interface(interface_to_usbdev(interface), if_num, 1);
10441+ interface->needs_remote_wakeup = 1;
10442+
10443+ /* Allocate new hso device(s) */
10444+ switch (port_spec & HSO_INTF_MASK) {
10445+ case HSO_INTF_MUX:
10446+ if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
10447+ /* Create the network device */
10448+ if (!disable_net) {
10449+ hso_dev = hso_create_net_device(interface,
10450+ port_spec);
10451+ if (!hso_dev)
10452+ goto exit;
10453+ tmp_dev = hso_dev;
10454+ }
10455+ }
10456+
10457+ if (hso_get_mux_ports(interface, &port_mask))
10458+ /* TODO: de-allocate everything */
10459+ goto exit;
10460+
10461+ shared_int = hso_create_shared_int(interface);
10462+ if (!shared_int)
10463+ goto exit;
10464+
10465+ for (i = 1, mux = 0; i < 0x100; i = i << 1, mux++) {
10466+ if (port_mask & i) {
10467+ hso_dev = hso_create_mux_serial_device(
10468+ interface, i, shared_int);
10469+ if (!hso_dev)
10470+ goto exit;
10471+ }
10472+ }
10473+
10474+ if (tmp_dev)
10475+ hso_dev = tmp_dev;
10476+ break;
10477+
10478+ case HSO_INTF_BULK:
10479+ /* It's a regular bulk interface */
10480+ if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
10481+ if (!disable_net)
10482+ hso_dev =
10483+ hso_create_net_device(interface, port_spec);
10484+ } else {
10485+ hso_dev =
10486+ hso_create_bulk_serial_device(interface, port_spec);
10487+ }
10488+ if (!hso_dev)
10489+ goto exit;
10490+ break;
10491+ default:
10492+ goto exit;
10493+ }
10494+
10495+ /* save our data pointer in this device */
10496+ usb_set_intfdata(interface, hso_dev);
10497+
10498+ /* done */
10499+ return 0;
10500+exit:
10501+ hso_free_interface(interface);
10502+ return -ENODEV;
10503+}
10504+
10505+/* device removed, cleaning up */
10506+static void hso_disconnect(struct usb_interface *interface)
10507+{
10508+ hso_free_interface(interface);
10509+
10510+ /* remove reference of our private data */
10511+ usb_set_intfdata(interface, NULL);
10512+}
10513+
10514+static void async_get_intf(struct work_struct *data)
10515+{
10516+ struct hso_device *hso_dev =
10517+ container_of(data, struct hso_device, async_get_intf);
10518+ usb_autopm_get_interface(hso_dev->interface);
10519+}
10520+
10521+static void async_put_intf(struct work_struct *data)
10522+{
10523+ struct hso_device *hso_dev =
10524+ container_of(data, struct hso_device, async_put_intf);
10525+ usb_autopm_put_interface(hso_dev->interface);
10526+}
10527+
10528+static int hso_get_activity(struct hso_device *hso_dev)
10529+{
10530+ if (hso_dev->usb->state == USB_STATE_SUSPENDED) {
10531+ if (!hso_dev->is_active) {
10532+ hso_dev->is_active = 1;
10533+ schedule_work(&hso_dev->async_get_intf);
10534+ }
10535+ }
10536+
10537+ if (hso_dev->usb->state != USB_STATE_CONFIGURED)
10538+ return -EAGAIN;
10539+
10540+ usb_mark_last_busy(hso_dev->usb);
10541+
10542+ return 0;
10543+}
10544+
10545+static int hso_put_activity(struct hso_device *hso_dev)
10546+{
10547+ if (hso_dev->usb->state != USB_STATE_SUSPENDED) {
10548+ if (hso_dev->is_active) {
10549+ hso_dev->is_active = 0;
10550+ schedule_work(&hso_dev->async_put_intf);
10551+ return -EAGAIN;
10552+ }
10553+ }
10554+ hso_dev->is_active = 0;
10555+ return 0;
10556+}
10557+
10558+/* called by kernel when we need to suspend device */
10559+static int hso_suspend(struct usb_interface *iface, pm_message_t message)
10560+{
10561+ int i, result;
10562+
10563+ /* Stop all serial ports */
10564+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
10565+ if (serial_table[i] && (serial_table[i]->interface == iface)) {
10566+ result = hso_stop_serial_device(serial_table[i]);
10567+ if (result)
10568+ goto out;
10569+ }
10570+ }
10571+
10572+ /* Stop all network ports */
10573+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
10574+ if (network_table[i] &&
10575+ (network_table[i]->interface == iface)) {
10576+ result = hso_stop_net_device(network_table[i]);
10577+ if (result)
10578+ goto out;
10579+ }
10580+ }
10581+
10582+out:
10583+ return 0;
10584+}
10585+
10586+/* called by kernel when we need to resume device */
10587+static int hso_resume(struct usb_interface *iface)
10588+{
10589+ int i, result = 0;
10590+ struct hso_net *hso_net;
10591+
10592+ /* Start all serial ports */
10593+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
10594+ if (serial_table[i] && (serial_table[i]->interface == iface)) {
10595+ if (atomic_read(&dev2ser(serial_table[i])->port.count)) {
10596+ result =
10597+ hso_start_serial_device(serial_table[i], GFP_NOIO);
10598+ hso_kick_transmit(dev2ser(serial_table[i]));
10599+ if (result)
10600+ goto out;
10601+ }
10602+ }
10603+ }
10604+
10605+ /* Start all network ports */
10606+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
10607+ if (network_table[i] &&
10608+ (network_table[i]->interface == iface)) {
10609+ hso_net = dev2net(network_table[i]);
10610+ if (hso_net->flags & IFF_UP) {
10611+ /* First transmit any lingering data,
10612+ then restart the device. */
10613+ if (hso_net->skb_tx_buf) {
10614+ dev_dbg(&iface->dev,
10615+ "Transmitting"
10616+ " lingering data\n");
10617+ hso_net_start_xmit(hso_net->skb_tx_buf,
10618+ hso_net->net);
10619+ hso_net->skb_tx_buf = NULL;
10620+ }
10621+ result = hso_start_net_device(network_table[i]);
10622+ if (result)
10623+ goto out;
10624+ }
10625+ }
10626+ }
10627+
10628+out:
10629+ return result;
10630+}
10631+
10632+static void reset_device(struct work_struct *data)
10633+{
10634+ struct hso_device *hso_dev =
10635+ container_of(data, struct hso_device, reset_device);
10636+ struct usb_device *usb = hso_dev->usb;
10637+ int result;
10638+
10639+ if (hso_dev->usb_gone) {
10640+ D1("No reset during disconnect\n");
10641+ } else {
10642+ result = usb_lock_device_for_reset(usb, hso_dev->interface);
10643+ if (result < 0)
10644+ D1("unable to lock device for reset: %d\n", result);
10645+ else {
10646+ usb_reset_device(usb);
10647+ usb_unlock_device(usb);
10648+ }
10649+ }
10650+}
10651+
10652+static void hso_serial_ref_free(struct kref *ref)
10653+{
10654+ struct hso_device *hso_dev = container_of(ref, struct hso_device, ref);
10655+
10656+ hso_free_serial_device(hso_dev);
10657+}
10658+
10659+static void hso_free_interface(struct usb_interface *interface)
10660+{
10661+ struct hso_serial *hso_dev;
10662+ int i;
10663+
10664+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
10665+ if (serial_table[i] &&
10666+ (serial_table[i]->interface == interface)) {
10667+ hso_dev = dev2ser(serial_table[i]);
10668+ tty_port_tty_hangup(&hso_dev->port, false);
10669+ mutex_lock(&hso_dev->parent->mutex);
10670+ hso_dev->parent->usb_gone = 1;
10671+ mutex_unlock(&hso_dev->parent->mutex);
10672+ kref_put(&serial_table[i]->ref, hso_serial_ref_free);
10673+ }
10674+ }
10675+
10676+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
10677+ if (network_table[i] &&
10678+ (network_table[i]->interface == interface)) {
10679+ struct rfkill *rfk = dev2net(network_table[i])->rfkill;
10680+ /* hso_stop_net_device doesn't stop the net queue since
10681+ * traffic needs to start it again when suspended */
10682+ netif_stop_queue(dev2net(network_table[i])->net);
10683+ hso_stop_net_device(network_table[i]);
10684+ cancel_work_sync(&network_table[i]->async_put_intf);
10685+ cancel_work_sync(&network_table[i]->async_get_intf);
10686+ if (rfk) {
10687+ rfkill_unregister(rfk);
10688+ rfkill_destroy(rfk);
10689+ }
10690+ hso_free_net_device(network_table[i]);
10691+ }
10692+ }
10693+}
10694+
10695+/* Helper functions */
10696+
10697+/* Get the endpoint ! */
10698+static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
10699+ int type, int dir)
10700+{
10701+ int i;
10702+ struct usb_host_interface *iface = intf->cur_altsetting;
10703+ struct usb_endpoint_descriptor *endp;
10704+
10705+ for (i = 0; i < iface->desc.bNumEndpoints; i++) {
10706+ endp = &iface->endpoint[i].desc;
10707+ if (((endp->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == dir) &&
10708+ (usb_endpoint_type(endp) == type))
10709+ return endp;
10710+ }
10711+
10712+ return NULL;
10713+}
10714+
10715+/* Get the byte that describes which ports are enabled */
10716+static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports)
10717+{
10718+ int i;
10719+ struct usb_host_interface *iface = intf->cur_altsetting;
10720+
10721+ if (iface->extralen == 3) {
10722+ *ports = iface->extra[2];
10723+ return 0;
10724+ }
10725+
10726+ for (i = 0; i < iface->desc.bNumEndpoints; i++) {
10727+ if (iface->endpoint[i].extralen == 3) {
10728+ *ports = iface->endpoint[i].extra[2];
10729+ return 0;
10730+ }
10731+ }
10732+
10733+ return -1;
10734+}
10735+
10736+/* interrupt urb needs to be submitted, used for serial read of muxed port */
10737+static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,
10738+ struct usb_device *usb, gfp_t gfp)
10739+{
10740+ int result;
10741+
10742+ usb_fill_int_urb(shared_int->shared_intr_urb, usb,
10743+ usb_rcvintpipe(usb,
10744+ shared_int->intr_endp->bEndpointAddress & 0x7F),
10745+ shared_int->shared_intr_buf,
10746+ 1,
10747+ intr_callback, shared_int,
10748+ shared_int->intr_endp->bInterval);
10749+
10750+ result = usb_submit_urb(shared_int->shared_intr_urb, gfp);
10751+ if (result)
10752+ dev_warn(&usb->dev, "%s failed mux_intr_urb %d\n", __func__,
10753+ result);
10754+
10755+ return result;
10756+}
10757+
10758+/* operations setup of the serial interface */
10759+static const struct tty_operations hso_serial_ops = {
10760+ .open = hso_serial_open,
10761+ .close = hso_serial_close,
10762+ .write = hso_serial_write,
10763+ .write_room = hso_serial_write_room,
10764+ .ioctl = hso_serial_ioctl,
10765+ .set_termios = hso_serial_set_termios,
10766+ .chars_in_buffer = hso_serial_chars_in_buffer,
10767+ .tiocmget = hso_serial_tiocmget,
10768+ .tiocmset = hso_serial_tiocmset,
10769+ .get_icount = hso_get_count,
10770+ .unthrottle = hso_unthrottle
10771+};
10772+
10773+static struct usb_driver hso_driver = {
10774+ .name = driver_name,
10775+ .probe = hso_probe,
10776+ .disconnect = hso_disconnect,
10777+ .id_table = hso_ids,
10778+ .suspend = hso_suspend,
10779+ .resume = hso_resume,
10780+ .reset_resume = hso_resume,
10781+ .supports_autosuspend = 1,
10782+ .disable_hub_initiated_lpm = 1,
10783+};
10784+
10785+static int __init hso_init(void)
10786+{
10787+ int i;
10788+ int result;
10789+
10790+ /* put it in the log */
10791+ printk(KERN_INFO "hso: %s\n", version);
10792+
10793+ /* Initialise the serial table semaphore and table */
10794+ spin_lock_init(&serial_table_lock);
10795+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++)
10796+ serial_table[i] = NULL;
10797+
10798+ /* allocate our driver using the proper amount of supported minors */
10799+ tty_drv = alloc_tty_driver(HSO_SERIAL_TTY_MINORS);
10800+ if (!tty_drv)
10801+ return -ENOMEM;
10802+
10803+ /* fill in all needed values */
10804+ tty_drv->driver_name = driver_name;
10805+ tty_drv->name = tty_filename;
10806+
10807+ /* if major number is provided as parameter, use that one */
10808+ if (tty_major)
10809+ tty_drv->major = tty_major;
10810+
10811+ tty_drv->minor_start = 0;
10812+ tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
10813+ tty_drv->subtype = SERIAL_TYPE_NORMAL;
10814+ tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
10815+ tty_drv->init_termios = tty_std_termios;
10816+ hso_init_termios(&tty_drv->init_termios);
10817+ tty_set_operations(tty_drv, &hso_serial_ops);
10818+
10819+ /* register the tty driver */
10820+ result = tty_register_driver(tty_drv);
10821+ if (result) {
10822+ printk(KERN_ERR "%s - tty_register_driver failed(%d)\n",
10823+ __func__, result);
10824+ goto err_free_tty;
10825+ }
10826+
10827+ /* register this module as an usb driver */
10828+ result = usb_register(&hso_driver);
10829+ if (result) {
10830+ printk(KERN_ERR "Could not register hso driver? error: %d\n",
10831+ result);
10832+ goto err_unreg_tty;
10833+ }
10834+
10835+ /* done */
10836+ return 0;
10837+err_unreg_tty:
10838+ tty_unregister_driver(tty_drv);
10839+err_free_tty:
10840+ put_tty_driver(tty_drv);
10841+ return result;
10842+}
10843+
10844+static void __exit hso_exit(void)
10845+{
10846+ printk(KERN_INFO "hso: unloaded\n");
10847+
10848+ tty_unregister_driver(tty_drv);
10849+ put_tty_driver(tty_drv);
10850+ /* deregister the usb driver */
10851+ usb_deregister(&hso_driver);
10852+}
10853+
10854+/* Module definitions */
10855+module_init(hso_init);
10856+module_exit(hso_exit);
10857+
10858+MODULE_AUTHOR(MOD_AUTHOR);
10859+MODULE_DESCRIPTION(MOD_DESCRIPTION);
10860+MODULE_LICENSE(MOD_LICENSE);
10861+
10862+/* change the debug level (eg: insmod hso.ko debug=0x04) */
10863+MODULE_PARM_DESC(debug, "Level of debug [0x01 | 0x02 | 0x04 | 0x08 | 0x10]");
10864+module_param(debug, int, S_IRUGO | S_IWUSR);
10865+
10866+/* set the major tty number (eg: insmod hso.ko tty_major=245) */
10867+MODULE_PARM_DESC(tty_major, "Set the major tty number");
10868+module_param(tty_major, int, S_IRUGO | S_IWUSR);
10869+
10870+/* disable network interface (eg: insmod hso.ko disable_net=1) */
10871+MODULE_PARM_DESC(disable_net, "Disable the network interface");
10872+module_param(disable_net, int, S_IRUGO | S_IWUSR);
10873diff -Naur backports-3.18.1-1.org/drivers/net/usb/huawei_cdc_ncm.c backports-3.18.1-1/drivers/net/usb/huawei_cdc_ncm.c
10874--- backports-3.18.1-1.org/drivers/net/usb/huawei_cdc_ncm.c 1970-01-01 01:00:00.000000000 +0100
10875+++ backports-3.18.1-1/drivers/net/usb/huawei_cdc_ncm.c 2014-12-16 18:39:45.000000000 +0100
10876@@ -0,0 +1,221 @@
10877+/* huawei_cdc_ncm.c - handles Huawei devices using the CDC NCM protocol as
10878+ * transport layer.
10879+ * Copyright (C) 2013 Enrico Mioso <mrkiko.rs@gmail.com>
10880+ *
10881+ *
10882+ * ABSTRACT:
10883+ * This driver handles devices resembling the CDC NCM standard, but
10884+ * encapsulating another protocol inside it. An example are some Huawei 3G
10885+ * devices, exposing an embedded AT channel where you can set up the NCM
10886+ * connection.
10887+ * This code has been heavily inspired by the cdc_mbim.c driver, which is
10888+ * Copyright (c) 2012 Smith Micro Software, Inc.
10889+ * Copyright (c) 2012 Bjørn Mork <bjorn@mork.no>
10890+ *
10891+ * This program is free software; you can redistribute it and/or
10892+ * modify it under the terms of the GNU General Public License
10893+ * version 2 as published by the Free Software Foundation.
10894+ */
10895+
10896+#include <linux/module.h>
10897+#include <linux/netdevice.h>
10898+#include <linux/ethtool.h>
10899+#include <linux/if_vlan.h>
10900+#include <linux/ip.h>
10901+#include <linux/mii.h>
10902+#include <linux/usb.h>
10903+#include <linux/usb/cdc.h>
10904+#include <linux/usb/usbnet.h>
10905+#include <linux/usb/cdc-wdm.h>
10906+#include <linux/usb/cdc_ncm.h>
10907+
10908+/* Driver data */
10909+struct huawei_cdc_ncm_state {
10910+ struct cdc_ncm_ctx *ctx;
10911+ atomic_t pmcount;
10912+ struct usb_driver *subdriver;
10913+ struct usb_interface *control;
10914+ struct usb_interface *data;
10915+};
10916+
10917+static int huawei_cdc_ncm_manage_power(struct usbnet *usbnet_dev, int on)
10918+{
10919+ struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
10920+ int rv;
10921+
10922+ if ((on && atomic_add_return(1, &drvstate->pmcount) == 1) ||
10923+ (!on && atomic_dec_and_test(&drvstate->pmcount))) {
10924+ rv = usb_autopm_get_interface(usbnet_dev->intf);
10925+ usbnet_dev->intf->needs_remote_wakeup = on;
10926+ if (!rv)
10927+ usb_autopm_put_interface(usbnet_dev->intf);
10928+ }
10929+ return 0;
10930+}
10931+
10932+static int huawei_cdc_ncm_wdm_manage_power(struct usb_interface *intf,
10933+ int status)
10934+{
10935+ struct usbnet *usbnet_dev = usb_get_intfdata(intf);
10936+
10937+ /* can be called while disconnecting */
10938+ if (!usbnet_dev)
10939+ return 0;
10940+
10941+ return huawei_cdc_ncm_manage_power(usbnet_dev, status);
10942+}
10943+
10944+
10945+static int huawei_cdc_ncm_bind(struct usbnet *usbnet_dev,
10946+ struct usb_interface *intf)
10947+{
10948+ struct cdc_ncm_ctx *ctx;
10949+ struct usb_driver *subdriver = ERR_PTR(-ENODEV);
10950+ int ret = -ENODEV;
10951+ struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
10952+
10953+ /* altsetting should always be 1 for NCM devices - so we hard-coded
10954+ * it here
10955+ */
10956+ ret = cdc_ncm_bind_common(usbnet_dev, intf, 1);
10957+ if (ret)
10958+ goto err;
10959+
10960+ ctx = drvstate->ctx;
10961+
10962+ if (usbnet_dev->status)
10963+ /* The wMaxCommand buffer must be big enough to hold
10964+ * any message from the modem. Experience has shown
10965+ * that some replies are more than 256 bytes long
10966+ */
10967+ subdriver = usb_cdc_wdm_register(ctx->control,
10968+ &usbnet_dev->status->desc,
10969+ 1024, /* wMaxCommand */
10970+ huawei_cdc_ncm_wdm_manage_power);
10971+ if (IS_ERR(subdriver)) {
10972+ ret = PTR_ERR(subdriver);
10973+ cdc_ncm_unbind(usbnet_dev, intf);
10974+ goto err;
10975+ }
10976+
10977+ /* Prevent usbnet from using the status descriptor */
10978+ usbnet_dev->status = NULL;
10979+
10980+ drvstate->subdriver = subdriver;
10981+
10982+err:
10983+ return ret;
10984+}
10985+
10986+static void huawei_cdc_ncm_unbind(struct usbnet *usbnet_dev,
10987+ struct usb_interface *intf)
10988+{
10989+ struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
10990+ struct cdc_ncm_ctx *ctx = drvstate->ctx;
10991+
10992+ if (drvstate->subdriver && drvstate->subdriver->disconnect)
10993+ drvstate->subdriver->disconnect(ctx->control);
10994+ drvstate->subdriver = NULL;
10995+
10996+ cdc_ncm_unbind(usbnet_dev, intf);
10997+}
10998+
10999+static int huawei_cdc_ncm_suspend(struct usb_interface *intf,
11000+ pm_message_t message)
11001+{
11002+ int ret = 0;
11003+ struct usbnet *usbnet_dev = usb_get_intfdata(intf);
11004+ struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
11005+ struct cdc_ncm_ctx *ctx = drvstate->ctx;
11006+
11007+ if (ctx == NULL) {
11008+ ret = -ENODEV;
11009+ goto error;
11010+ }
11011+
11012+ ret = usbnet_suspend(intf, message);
11013+ if (ret < 0)
11014+ goto error;
11015+
11016+ if (intf == ctx->control &&
11017+ drvstate->subdriver &&
11018+ drvstate->subdriver->suspend)
11019+ ret = drvstate->subdriver->suspend(intf, message);
11020+ if (ret < 0)
11021+ usbnet_resume(intf);
11022+
11023+error:
11024+ return ret;
11025+}
11026+
11027+static int huawei_cdc_ncm_resume(struct usb_interface *intf)
11028+{
11029+ int ret = 0;
11030+ struct usbnet *usbnet_dev = usb_get_intfdata(intf);
11031+ struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
11032+ bool callsub;
11033+ struct cdc_ncm_ctx *ctx = drvstate->ctx;
11034+
11035+ /* should we call subdriver's resume function? */
11036+ callsub =
11037+ (intf == ctx->control &&
11038+ drvstate->subdriver &&
11039+ drvstate->subdriver->resume);
11040+
11041+ if (callsub)
11042+ ret = drvstate->subdriver->resume(intf);
11043+ if (ret < 0)
11044+ goto err;
11045+ ret = usbnet_resume(intf);
11046+ if (ret < 0 && callsub)
11047+ drvstate->subdriver->suspend(intf, PMSG_SUSPEND);
11048+err:
11049+ return ret;
11050+}
11051+
11052+static const struct driver_info huawei_cdc_ncm_info = {
11053+ .description = "Huawei CDC NCM device",
11054+ .flags = FLAG_NO_SETINT | FLAG_MULTI_PACKET | FLAG_WWAN,
11055+ .bind = huawei_cdc_ncm_bind,
11056+ .unbind = huawei_cdc_ncm_unbind,
11057+ .manage_power = huawei_cdc_ncm_manage_power,
11058+ .rx_fixup = cdc_ncm_rx_fixup,
11059+ .tx_fixup = cdc_ncm_tx_fixup,
11060+};
11061+
11062+static const struct usb_device_id huawei_cdc_ncm_devs[] = {
11063+ /* Huawei NCM devices disguised as vendor specific */
11064+ { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
11065+ .driver_info = (unsigned long)&huawei_cdc_ncm_info,
11066+ },
11067+ { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
11068+ .driver_info = (unsigned long)&huawei_cdc_ncm_info,
11069+ },
11070+ { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x76),
11071+ .driver_info = (unsigned long)&huawei_cdc_ncm_info,
11072+ },
11073+ { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x03, 0x16),
11074+ .driver_info = (unsigned long)&huawei_cdc_ncm_info,
11075+ },
11076+
11077+ /* Terminating entry */
11078+ {
11079+ },
11080+};
11081+MODULE_DEVICE_TABLE(usb, huawei_cdc_ncm_devs);
11082+
11083+static struct usb_driver huawei_cdc_ncm_driver = {
11084+ .name = "huawei_cdc_ncm",
11085+ .id_table = huawei_cdc_ncm_devs,
11086+ .probe = usbnet_probe,
11087+ .disconnect = usbnet_disconnect,
11088+ .suspend = huawei_cdc_ncm_suspend,
11089+ .resume = huawei_cdc_ncm_resume,
11090+ .reset_resume = huawei_cdc_ncm_resume,
11091+ .supports_autosuspend = 1,
11092+ .disable_hub_initiated_lpm = 1,
11093+};
11094+module_usb_driver(huawei_cdc_ncm_driver);
11095+MODULE_AUTHOR("Enrico Mioso <mrkiko.rs@gmail.com>");
11096+MODULE_DESCRIPTION("USB CDC NCM host driver with encapsulated protocol support");
11097+MODULE_LICENSE("GPL");
11098diff -Naur backports-3.18.1-1.org/drivers/net/usb/int51x1.c backports-3.18.1-1/drivers/net/usb/int51x1.c
11099--- backports-3.18.1-1.org/drivers/net/usb/int51x1.c 1970-01-01 01:00:00.000000000 +0100
11100+++ backports-3.18.1-1/drivers/net/usb/int51x1.c 2014-12-16 18:39:45.000000000 +0100
11101@@ -0,0 +1,199 @@
11102+/*
11103+ * Copyright (c) 2009 Peter Holik
11104+ *
11105+ * Intellon usb PLC (Powerline Communications) usb net driver
11106+ *
11107+ * http://www.tandel.be/downloads/INT51X1_Datasheet.pdf
11108+ *
11109+ * Based on the work of Jan 'RedBully' Seiffert
11110+ */
11111+
11112+/*
11113+ * This program is free software; you can redistribute it and/or modify
11114+ * it under the terms of the GNU General Public License as published by
11115+ * the Free Software Foundation; either version 2 of the License, or.
11116+ * (at your option) any later version.
11117+ *
11118+ * This program is distributed in the hope that it will be useful,
11119+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
11120+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11121+ * GNU General Public License for more details.
11122+ *
11123+ * You should have received a copy of the GNU General Public License
11124+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
11125+ */
11126+
11127+#include <linux/module.h>
11128+#include <linux/ctype.h>
11129+#include <linux/netdevice.h>
11130+#include <linux/etherdevice.h>
11131+#include <linux/ethtool.h>
11132+#include <linux/slab.h>
11133+#include <linux/mii.h>
11134+#include <linux/usb.h>
11135+#include <linux/usb/usbnet.h>
11136+
11137+#define INT51X1_VENDOR_ID 0x09e1
11138+#define INT51X1_PRODUCT_ID 0x5121
11139+
11140+#define INT51X1_HEADER_SIZE 2 /* 2 byte header */
11141+
11142+#define PACKET_TYPE_PROMISCUOUS (1 << 0)
11143+#define PACKET_TYPE_ALL_MULTICAST (1 << 1) /* no filter */
11144+#define PACKET_TYPE_DIRECTED (1 << 2)
11145+#define PACKET_TYPE_BROADCAST (1 << 3)
11146+#define PACKET_TYPE_MULTICAST (1 << 4) /* filtered */
11147+
11148+#define SET_ETHERNET_PACKET_FILTER 0x43
11149+
11150+static int int51x1_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
11151+{
11152+ int len;
11153+
11154+ if (!(pskb_may_pull(skb, INT51X1_HEADER_SIZE))) {
11155+ netdev_err(dev->net, "unexpected tiny rx frame\n");
11156+ return 0;
11157+ }
11158+
11159+ len = le16_to_cpu(*(__le16 *)&skb->data[skb->len - 2]);
11160+
11161+ skb_trim(skb, len);
11162+
11163+ return 1;
11164+}
11165+
11166+static struct sk_buff *int51x1_tx_fixup(struct usbnet *dev,
11167+ struct sk_buff *skb, gfp_t flags)
11168+{
11169+ int pack_len = skb->len;
11170+ int pack_with_header_len = pack_len + INT51X1_HEADER_SIZE;
11171+ int headroom = skb_headroom(skb);
11172+ int tailroom = skb_tailroom(skb);
11173+ int need_tail = 0;
11174+ __le16 *len;
11175+
11176+ /* if packet and our header is smaler than 64 pad to 64 (+ ZLP) */
11177+ if ((pack_with_header_len) < dev->maxpacket)
11178+ need_tail = dev->maxpacket - pack_with_header_len + 1;
11179+ /*
11180+ * usbnet would send a ZLP if packetlength mod urbsize == 0 for us,
11181+ * but we need to know ourself, because this would add to the length
11182+ * we send down to the device...
11183+ */
11184+ else if (!(pack_with_header_len % dev->maxpacket))
11185+ need_tail = 1;
11186+
11187+ if (!skb_cloned(skb) &&
11188+ (headroom + tailroom >= need_tail + INT51X1_HEADER_SIZE)) {
11189+ if (headroom < INT51X1_HEADER_SIZE || tailroom < need_tail) {
11190+ skb->data = memmove(skb->head + INT51X1_HEADER_SIZE,
11191+ skb->data, skb->len);
11192+ skb_set_tail_pointer(skb, skb->len);
11193+ }
11194+ } else {
11195+ struct sk_buff *skb2;
11196+
11197+ skb2 = skb_copy_expand(skb,
11198+ INT51X1_HEADER_SIZE,
11199+ need_tail,
11200+ flags);
11201+ dev_kfree_skb_any(skb);
11202+ if (!skb2)
11203+ return NULL;
11204+ skb = skb2;
11205+ }
11206+
11207+ pack_len += need_tail;
11208+ pack_len &= 0x07ff;
11209+
11210+ len = (__le16 *) __skb_push(skb, INT51X1_HEADER_SIZE);
11211+ *len = cpu_to_le16(pack_len);
11212+
11213+ if(need_tail)
11214+ memset(__skb_put(skb, need_tail), 0, need_tail);
11215+
11216+ return skb;
11217+}
11218+
11219+static void int51x1_set_multicast(struct net_device *netdev)
11220+{
11221+ struct usbnet *dev = netdev_priv(netdev);
11222+ u16 filter = PACKET_TYPE_DIRECTED | PACKET_TYPE_BROADCAST;
11223+
11224+ if (netdev->flags & IFF_PROMISC) {
11225+ /* do not expect to see traffic of other PLCs */
11226+ filter |= PACKET_TYPE_PROMISCUOUS;
11227+ netdev_info(dev->net, "promiscuous mode enabled\n");
11228+ } else if (!netdev_mc_empty(netdev) ||
11229+ (netdev->flags & IFF_ALLMULTI)) {
11230+ filter |= PACKET_TYPE_ALL_MULTICAST;
11231+ netdev_dbg(dev->net, "receive all multicast enabled\n");
11232+ } else {
11233+ /* ~PROMISCUOUS, ~MULTICAST */
11234+ netdev_dbg(dev->net, "receive own packets only\n");
11235+ }
11236+
11237+ usbnet_write_cmd_async(dev, SET_ETHERNET_PACKET_FILTER,
11238+ USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
11239+ filter, 0, NULL, 0);
11240+}
11241+
11242+static const struct net_device_ops int51x1_netdev_ops = {
11243+ .ndo_open = usbnet_open,
11244+ .ndo_stop = usbnet_stop,
11245+ .ndo_start_xmit = usbnet_start_xmit,
11246+ .ndo_tx_timeout = usbnet_tx_timeout,
11247+ .ndo_change_mtu = usbnet_change_mtu,
11248+ .ndo_set_mac_address = eth_mac_addr,
11249+ .ndo_validate_addr = eth_validate_addr,
11250+ .ndo_set_rx_mode = int51x1_set_multicast,
11251+};
11252+
11253+static int int51x1_bind(struct usbnet *dev, struct usb_interface *intf)
11254+{
11255+ int status = usbnet_get_ethernet_addr(dev, 3);
11256+
11257+ if (status)
11258+ return status;
11259+
11260+ dev->net->hard_header_len += INT51X1_HEADER_SIZE;
11261+ dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
11262+ dev->net->netdev_ops = &int51x1_netdev_ops;
11263+
11264+ return usbnet_get_endpoints(dev, intf);
11265+}
11266+
11267+static const struct driver_info int51x1_info = {
11268+ .description = "Intellon usb powerline adapter",
11269+ .bind = int51x1_bind,
11270+ .rx_fixup = int51x1_rx_fixup,
11271+ .tx_fixup = int51x1_tx_fixup,
11272+ .in = 1,
11273+ .out = 2,
11274+ .flags = FLAG_ETHER,
11275+};
11276+
11277+static const struct usb_device_id products[] = {
11278+ {
11279+ USB_DEVICE(INT51X1_VENDOR_ID, INT51X1_PRODUCT_ID),
11280+ .driver_info = (unsigned long) &int51x1_info,
11281+ },
11282+ {},
11283+};
11284+MODULE_DEVICE_TABLE(usb, products);
11285+
11286+static struct usb_driver int51x1_driver = {
11287+ .name = "int51x1",
11288+ .id_table = products,
11289+ .probe = usbnet_probe,
11290+ .disconnect = usbnet_disconnect,
11291+ .suspend = usbnet_suspend,
11292+ .resume = usbnet_resume,
11293+ .disable_hub_initiated_lpm = 1,
11294+};
11295+
11296+module_usb_driver(int51x1_driver);
11297+
11298+MODULE_AUTHOR("Peter Holik");
11299+MODULE_DESCRIPTION("Intellon usb powerline adapter");
11300+MODULE_LICENSE("GPL");
11301diff -Naur backports-3.18.1-1.org/drivers/net/usb/ipheth.c backports-3.18.1-1/drivers/net/usb/ipheth.c
11302--- backports-3.18.1-1.org/drivers/net/usb/ipheth.c 1970-01-01 01:00:00.000000000 +0100
11303+++ backports-3.18.1-1/drivers/net/usb/ipheth.c 2014-12-16 18:39:45.000000000 +0100
11304@@ -0,0 +1,588 @@
11305+/*
11306+ * ipheth.c - Apple iPhone USB Ethernet driver
11307+ *
11308+ * Copyright (c) 2009 Diego Giagio <diego@giagio.com>
11309+ * All rights reserved.
11310+ *
11311+ * Redistribution and use in source and binary forms, with or without
11312+ * modification, are permitted provided that the following conditions
11313+ * are met:
11314+ * 1. Redistributions of source code must retain the above copyright
11315+ * notice, this list of conditions and the following disclaimer.
11316+ * 2. Redistributions in binary form must reproduce the above copyright
11317+ * notice, this list of conditions and the following disclaimer in the
11318+ * documentation and/or other materials provided with the distribution.
11319+ * 3. Neither the name of GIAGIO.COM nor the names of its contributors
11320+ * may be used to endorse or promote products derived from this software
11321+ * without specific prior written permission.
11322+ *
11323+ * Alternatively, provided that this notice is retained in full, this
11324+ * software may be distributed under the terms of the GNU General
11325+ * Public License ("GPL") version 2, in which case the provisions of the
11326+ * GPL apply INSTEAD OF those given above.
11327+ *
11328+ * The provided data structures and external interfaces from this code
11329+ * are not restricted to be used by modules with a GPL compatible license.
11330+ *
11331+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
11332+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
11333+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
11334+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
11335+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
11336+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
11337+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
11338+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11339+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
11340+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
11341+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
11342+ * DAMAGE.
11343+ *
11344+ *
11345+ * Attention: iPhone device must be paired, otherwise it won't respond to our
11346+ * driver. For more info: http://giagio.com/wiki/moin.cgi/iPhoneEthernetDriver
11347+ *
11348+ */
11349+
11350+#include <linux/kernel.h>
11351+#include <linux/errno.h>
11352+#include <linux/slab.h>
11353+#include <linux/module.h>
11354+#include <linux/netdevice.h>
11355+#include <linux/etherdevice.h>
11356+#include <linux/ethtool.h>
11357+#include <linux/usb.h>
11358+#include <linux/workqueue.h>
11359+
11360+#define USB_VENDOR_APPLE 0x05ac
11361+#define USB_PRODUCT_IPHONE 0x1290
11362+#define USB_PRODUCT_IPHONE_3G 0x1292
11363+#define USB_PRODUCT_IPHONE_3GS 0x1294
11364+#define USB_PRODUCT_IPHONE_4 0x1297
11365+#define USB_PRODUCT_IPAD 0x129a
11366+#define USB_PRODUCT_IPAD_2 0x12a2
11367+#define USB_PRODUCT_IPAD_3 0x12a6
11368+#define USB_PRODUCT_IPAD_MINI 0x12ab
11369+#define USB_PRODUCT_IPHONE_4_VZW 0x129c
11370+#define USB_PRODUCT_IPHONE_4S 0x12a0
11371+#define USB_PRODUCT_IPHONE_5 0x12a8
11372+
11373+#define IPHETH_USBINTF_CLASS 255
11374+#define IPHETH_USBINTF_SUBCLASS 253
11375+#define IPHETH_USBINTF_PROTO 1
11376+
11377+#define IPHETH_BUF_SIZE 1516
11378+#define IPHETH_IP_ALIGN 2 /* padding at front of URB */
11379+#define IPHETH_TX_TIMEOUT (5 * HZ)
11380+
11381+#define IPHETH_INTFNUM 2
11382+#define IPHETH_ALT_INTFNUM 1
11383+
11384+#define IPHETH_CTRL_ENDP 0x00
11385+#define IPHETH_CTRL_BUF_SIZE 0x40
11386+#define IPHETH_CTRL_TIMEOUT (5 * HZ)
11387+
11388+#define IPHETH_CMD_GET_MACADDR 0x00
11389+#define IPHETH_CMD_CARRIER_CHECK 0x45
11390+
11391+#define IPHETH_CARRIER_CHECK_TIMEOUT round_jiffies_relative(1 * HZ)
11392+#define IPHETH_CARRIER_ON 0x04
11393+
11394+static struct usb_device_id ipheth_table[] = {
11395+ { USB_DEVICE_AND_INTERFACE_INFO(
11396+ USB_VENDOR_APPLE, USB_PRODUCT_IPHONE,
11397+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11398+ IPHETH_USBINTF_PROTO) },
11399+ { USB_DEVICE_AND_INTERFACE_INFO(
11400+ USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_3G,
11401+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11402+ IPHETH_USBINTF_PROTO) },
11403+ { USB_DEVICE_AND_INTERFACE_INFO(
11404+ USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_3GS,
11405+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11406+ IPHETH_USBINTF_PROTO) },
11407+ { USB_DEVICE_AND_INTERFACE_INFO(
11408+ USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4,
11409+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11410+ IPHETH_USBINTF_PROTO) },
11411+ { USB_DEVICE_AND_INTERFACE_INFO(
11412+ USB_VENDOR_APPLE, USB_PRODUCT_IPAD,
11413+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11414+ IPHETH_USBINTF_PROTO) },
11415+ { USB_DEVICE_AND_INTERFACE_INFO(
11416+ USB_VENDOR_APPLE, USB_PRODUCT_IPAD_2,
11417+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11418+ IPHETH_USBINTF_PROTO) },
11419+ { USB_DEVICE_AND_INTERFACE_INFO(
11420+ USB_VENDOR_APPLE, USB_PRODUCT_IPAD_3,
11421+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11422+ IPHETH_USBINTF_PROTO) },
11423+ { USB_DEVICE_AND_INTERFACE_INFO(
11424+ USB_VENDOR_APPLE, USB_PRODUCT_IPAD_MINI,
11425+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11426+ IPHETH_USBINTF_PROTO) },
11427+ { USB_DEVICE_AND_INTERFACE_INFO(
11428+ USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4_VZW,
11429+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11430+ IPHETH_USBINTF_PROTO) },
11431+ { USB_DEVICE_AND_INTERFACE_INFO(
11432+ USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_4S,
11433+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11434+ IPHETH_USBINTF_PROTO) },
11435+ { USB_DEVICE_AND_INTERFACE_INFO(
11436+ USB_VENDOR_APPLE, USB_PRODUCT_IPHONE_5,
11437+ IPHETH_USBINTF_CLASS, IPHETH_USBINTF_SUBCLASS,
11438+ IPHETH_USBINTF_PROTO) },
11439+ { }
11440+};
11441+MODULE_DEVICE_TABLE(usb, ipheth_table);
11442+
11443+struct ipheth_device {
11444+ struct usb_device *udev;
11445+ struct usb_interface *intf;
11446+ struct net_device *net;
11447+ struct sk_buff *tx_skb;
11448+ struct urb *tx_urb;
11449+ struct urb *rx_urb;
11450+ unsigned char *tx_buf;
11451+ unsigned char *rx_buf;
11452+ unsigned char *ctrl_buf;
11453+ u8 bulk_in;
11454+ u8 bulk_out;
11455+ struct delayed_work carrier_work;
11456+};
11457+
11458+static int ipheth_rx_submit(struct ipheth_device *dev, gfp_t mem_flags);
11459+
11460+static int ipheth_alloc_urbs(struct ipheth_device *iphone)
11461+{
11462+ struct urb *tx_urb = NULL;
11463+ struct urb *rx_urb = NULL;
11464+ u8 *tx_buf = NULL;
11465+ u8 *rx_buf = NULL;
11466+
11467+ tx_urb = usb_alloc_urb(0, GFP_KERNEL);
11468+ if (tx_urb == NULL)
11469+ goto error_nomem;
11470+
11471+ rx_urb = usb_alloc_urb(0, GFP_KERNEL);
11472+ if (rx_urb == NULL)
11473+ goto free_tx_urb;
11474+
11475+ tx_buf = usb_alloc_coherent(iphone->udev, IPHETH_BUF_SIZE,
11476+ GFP_KERNEL, &tx_urb->transfer_dma);
11477+ if (tx_buf == NULL)
11478+ goto free_rx_urb;
11479+
11480+ rx_buf = usb_alloc_coherent(iphone->udev, IPHETH_BUF_SIZE,
11481+ GFP_KERNEL, &rx_urb->transfer_dma);
11482+ if (rx_buf == NULL)
11483+ goto free_tx_buf;
11484+
11485+
11486+ iphone->tx_urb = tx_urb;
11487+ iphone->rx_urb = rx_urb;
11488+ iphone->tx_buf = tx_buf;
11489+ iphone->rx_buf = rx_buf;
11490+ return 0;
11491+
11492+free_tx_buf:
11493+ usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, tx_buf,
11494+ tx_urb->transfer_dma);
11495+free_rx_urb:
11496+ usb_free_urb(rx_urb);
11497+free_tx_urb:
11498+ usb_free_urb(tx_urb);
11499+error_nomem:
11500+ return -ENOMEM;
11501+}
11502+
11503+static void ipheth_free_urbs(struct ipheth_device *iphone)
11504+{
11505+ usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, iphone->rx_buf,
11506+ iphone->rx_urb->transfer_dma);
11507+ usb_free_coherent(iphone->udev, IPHETH_BUF_SIZE, iphone->tx_buf,
11508+ iphone->tx_urb->transfer_dma);
11509+ usb_free_urb(iphone->rx_urb);
11510+ usb_free_urb(iphone->tx_urb);
11511+}
11512+
11513+static void ipheth_kill_urbs(struct ipheth_device *dev)
11514+{
11515+ usb_kill_urb(dev->tx_urb);
11516+ usb_kill_urb(dev->rx_urb);
11517+}
11518+
11519+static void ipheth_rcvbulk_callback(struct urb *urb)
11520+{
11521+ struct ipheth_device *dev;
11522+ struct sk_buff *skb;
11523+ int status;
11524+ char *buf;
11525+ int len;
11526+
11527+ dev = urb->context;
11528+ if (dev == NULL)
11529+ return;
11530+
11531+ status = urb->status;
11532+ switch (status) {
11533+ case -ENOENT:
11534+ case -ECONNRESET:
11535+ case -ESHUTDOWN:
11536+ return;
11537+ case 0:
11538+ break;
11539+ default:
11540+ dev_err(&dev->intf->dev, "%s: urb status: %d\n",
11541+ __func__, status);
11542+ return;
11543+ }
11544+
11545+ if (urb->actual_length <= IPHETH_IP_ALIGN) {
11546+ dev->net->stats.rx_length_errors++;
11547+ return;
11548+ }
11549+ len = urb->actual_length - IPHETH_IP_ALIGN;
11550+ buf = urb->transfer_buffer + IPHETH_IP_ALIGN;
11551+
11552+ skb = dev_alloc_skb(len);
11553+ if (!skb) {
11554+ dev_err(&dev->intf->dev, "%s: dev_alloc_skb: -ENOMEM\n",
11555+ __func__);
11556+ dev->net->stats.rx_dropped++;
11557+ return;
11558+ }
11559+
11560+ memcpy(skb_put(skb, len), buf, len);
11561+ skb->dev = dev->net;
11562+ skb->protocol = eth_type_trans(skb, dev->net);
11563+
11564+ dev->net->stats.rx_packets++;
11565+ dev->net->stats.rx_bytes += len;
11566+
11567+ netif_rx(skb);
11568+ ipheth_rx_submit(dev, GFP_ATOMIC);
11569+}
11570+
11571+static void ipheth_sndbulk_callback(struct urb *urb)
11572+{
11573+ struct ipheth_device *dev;
11574+ int status = urb->status;
11575+
11576+ dev = urb->context;
11577+ if (dev == NULL)
11578+ return;
11579+
11580+ if (status != 0 &&
11581+ status != -ENOENT &&
11582+ status != -ECONNRESET &&
11583+ status != -ESHUTDOWN)
11584+ dev_err(&dev->intf->dev, "%s: urb status: %d\n",
11585+ __func__, status);
11586+
11587+ dev_kfree_skb_irq(dev->tx_skb);
11588+ netif_wake_queue(dev->net);
11589+}
11590+
11591+static int ipheth_carrier_set(struct ipheth_device *dev)
11592+{
11593+ struct usb_device *udev = dev->udev;
11594+ int retval;
11595+
11596+ retval = usb_control_msg(udev,
11597+ usb_rcvctrlpipe(udev, IPHETH_CTRL_ENDP),
11598+ IPHETH_CMD_CARRIER_CHECK, /* request */
11599+ 0xc0, /* request type */
11600+ 0x00, /* value */
11601+ 0x02, /* index */
11602+ dev->ctrl_buf, IPHETH_CTRL_BUF_SIZE,
11603+ IPHETH_CTRL_TIMEOUT);
11604+ if (retval < 0) {
11605+ dev_err(&dev->intf->dev, "%s: usb_control_msg: %d\n",
11606+ __func__, retval);
11607+ return retval;
11608+ }
11609+
11610+ if (dev->ctrl_buf[0] == IPHETH_CARRIER_ON)
11611+ netif_carrier_on(dev->net);
11612+ else
11613+ netif_carrier_off(dev->net);
11614+
11615+ return 0;
11616+}
11617+
11618+static void ipheth_carrier_check_work(struct work_struct *work)
11619+{
11620+ struct ipheth_device *dev = container_of(work, struct ipheth_device,
11621+ carrier_work.work);
11622+
11623+ ipheth_carrier_set(dev);
11624+ schedule_delayed_work(&dev->carrier_work, IPHETH_CARRIER_CHECK_TIMEOUT);
11625+}
11626+
11627+static int ipheth_get_macaddr(struct ipheth_device *dev)
11628+{
11629+ struct usb_device *udev = dev->udev;
11630+ struct net_device *net = dev->net;
11631+ int retval;
11632+
11633+ retval = usb_control_msg(udev,
11634+ usb_rcvctrlpipe(udev, IPHETH_CTRL_ENDP),
11635+ IPHETH_CMD_GET_MACADDR, /* request */
11636+ 0xc0, /* request type */
11637+ 0x00, /* value */
11638+ 0x02, /* index */
11639+ dev->ctrl_buf,
11640+ IPHETH_CTRL_BUF_SIZE,
11641+ IPHETH_CTRL_TIMEOUT);
11642+ if (retval < 0) {
11643+ dev_err(&dev->intf->dev, "%s: usb_control_msg: %d\n",
11644+ __func__, retval);
11645+ } else if (retval < ETH_ALEN) {
11646+ dev_err(&dev->intf->dev,
11647+ "%s: usb_control_msg: short packet: %d bytes\n",
11648+ __func__, retval);
11649+ retval = -EINVAL;
11650+ } else {
11651+ memcpy(net->dev_addr, dev->ctrl_buf, ETH_ALEN);
11652+ retval = 0;
11653+ }
11654+
11655+ return retval;
11656+}
11657+
11658+static int ipheth_rx_submit(struct ipheth_device *dev, gfp_t mem_flags)
11659+{
11660+ struct usb_device *udev = dev->udev;
11661+ int retval;
11662+
11663+ usb_fill_bulk_urb(dev->rx_urb, udev,
11664+ usb_rcvbulkpipe(udev, dev->bulk_in),
11665+ dev->rx_buf, IPHETH_BUF_SIZE,
11666+ ipheth_rcvbulk_callback,
11667+ dev);
11668+ dev->rx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
11669+
11670+ retval = usb_submit_urb(dev->rx_urb, mem_flags);
11671+ if (retval)
11672+ dev_err(&dev->intf->dev, "%s: usb_submit_urb: %d\n",
11673+ __func__, retval);
11674+ return retval;
11675+}
11676+
11677+static int ipheth_open(struct net_device *net)
11678+{
11679+ struct ipheth_device *dev = netdev_priv(net);
11680+ struct usb_device *udev = dev->udev;
11681+ int retval = 0;
11682+
11683+ usb_set_interface(udev, IPHETH_INTFNUM, IPHETH_ALT_INTFNUM);
11684+
11685+ retval = ipheth_carrier_set(dev);
11686+ if (retval)
11687+ return retval;
11688+
11689+ retval = ipheth_rx_submit(dev, GFP_KERNEL);
11690+ if (retval)
11691+ return retval;
11692+
11693+ schedule_delayed_work(&dev->carrier_work, IPHETH_CARRIER_CHECK_TIMEOUT);
11694+ netif_start_queue(net);
11695+ return retval;
11696+}
11697+
11698+static int ipheth_close(struct net_device *net)
11699+{
11700+ struct ipheth_device *dev = netdev_priv(net);
11701+
11702+ cancel_delayed_work_sync(&dev->carrier_work);
11703+ netif_stop_queue(net);
11704+ return 0;
11705+}
11706+
11707+static int ipheth_tx(struct sk_buff *skb, struct net_device *net)
11708+{
11709+ struct ipheth_device *dev = netdev_priv(net);
11710+ struct usb_device *udev = dev->udev;
11711+ int retval;
11712+
11713+ /* Paranoid */
11714+ if (skb->len > IPHETH_BUF_SIZE) {
11715+ WARN(1, "%s: skb too large: %d bytes\n", __func__, skb->len);
11716+ dev->net->stats.tx_dropped++;
11717+ dev_kfree_skb_irq(skb);
11718+ return NETDEV_TX_OK;
11719+ }
11720+
11721+ memcpy(dev->tx_buf, skb->data, skb->len);
11722+ if (skb->len < IPHETH_BUF_SIZE)
11723+ memset(dev->tx_buf + skb->len, 0, IPHETH_BUF_SIZE - skb->len);
11724+
11725+ usb_fill_bulk_urb(dev->tx_urb, udev,
11726+ usb_sndbulkpipe(udev, dev->bulk_out),
11727+ dev->tx_buf, IPHETH_BUF_SIZE,
11728+ ipheth_sndbulk_callback,
11729+ dev);
11730+ dev->tx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
11731+
11732+ retval = usb_submit_urb(dev->tx_urb, GFP_ATOMIC);
11733+ if (retval) {
11734+ dev_err(&dev->intf->dev, "%s: usb_submit_urb: %d\n",
11735+ __func__, retval);
11736+ dev->net->stats.tx_errors++;
11737+ dev_kfree_skb_irq(skb);
11738+ } else {
11739+ dev->tx_skb = skb;
11740+
11741+ dev->net->stats.tx_packets++;
11742+ dev->net->stats.tx_bytes += skb->len;
11743+ netif_stop_queue(net);
11744+ }
11745+
11746+ return NETDEV_TX_OK;
11747+}
11748+
11749+static void ipheth_tx_timeout(struct net_device *net)
11750+{
11751+ struct ipheth_device *dev = netdev_priv(net);
11752+
11753+ dev_err(&dev->intf->dev, "%s: TX timeout\n", __func__);
11754+ dev->net->stats.tx_errors++;
11755+ usb_unlink_urb(dev->tx_urb);
11756+}
11757+
11758+static u32 ipheth_ethtool_op_get_link(struct net_device *net)
11759+{
11760+ struct ipheth_device *dev = netdev_priv(net);
11761+ return netif_carrier_ok(dev->net);
11762+}
11763+
11764+static const struct ethtool_ops ops = {
11765+ .get_link = ipheth_ethtool_op_get_link
11766+};
11767+
11768+static const struct net_device_ops ipheth_netdev_ops = {
11769+ .ndo_open = ipheth_open,
11770+ .ndo_stop = ipheth_close,
11771+ .ndo_start_xmit = ipheth_tx,
11772+ .ndo_tx_timeout = ipheth_tx_timeout,
11773+};
11774+
11775+static int ipheth_probe(struct usb_interface *intf,
11776+ const struct usb_device_id *id)
11777+{
11778+ struct usb_device *udev = interface_to_usbdev(intf);
11779+ struct usb_host_interface *hintf;
11780+ struct usb_endpoint_descriptor *endp;
11781+ struct ipheth_device *dev;
11782+ struct net_device *netdev;
11783+ int i;
11784+ int retval;
11785+
11786+ netdev = alloc_etherdev(sizeof(struct ipheth_device));
11787+ if (!netdev)
11788+ return -ENOMEM;
11789+
11790+ netdev->netdev_ops = &ipheth_netdev_ops;
11791+ netdev->watchdog_timeo = IPHETH_TX_TIMEOUT;
11792+ strcpy(netdev->name, "eth%d");
11793+
11794+ dev = netdev_priv(netdev);
11795+ dev->udev = udev;
11796+ dev->net = netdev;
11797+ dev->intf = intf;
11798+
11799+ /* Set up endpoints */
11800+ hintf = usb_altnum_to_altsetting(intf, IPHETH_ALT_INTFNUM);
11801+ if (hintf == NULL) {
11802+ retval = -ENODEV;
11803+ dev_err(&intf->dev, "Unable to find alternate settings interface\n");
11804+ goto err_endpoints;
11805+ }
11806+
11807+ for (i = 0; i < hintf->desc.bNumEndpoints; i++) {
11808+ endp = &hintf->endpoint[i].desc;
11809+ if (usb_endpoint_is_bulk_in(endp))
11810+ dev->bulk_in = endp->bEndpointAddress;
11811+ else if (usb_endpoint_is_bulk_out(endp))
11812+ dev->bulk_out = endp->bEndpointAddress;
11813+ }
11814+ if (!(dev->bulk_in && dev->bulk_out)) {
11815+ retval = -ENODEV;
11816+ dev_err(&intf->dev, "Unable to find endpoints\n");
11817+ goto err_endpoints;
11818+ }
11819+
11820+ dev->ctrl_buf = kmalloc(IPHETH_CTRL_BUF_SIZE, GFP_KERNEL);
11821+ if (dev->ctrl_buf == NULL) {
11822+ retval = -ENOMEM;
11823+ goto err_alloc_ctrl_buf;
11824+ }
11825+
11826+ retval = ipheth_get_macaddr(dev);
11827+ if (retval)
11828+ goto err_get_macaddr;
11829+
11830+ INIT_DELAYED_WORK(&dev->carrier_work, ipheth_carrier_check_work);
11831+
11832+ retval = ipheth_alloc_urbs(dev);
11833+ if (retval) {
11834+ dev_err(&intf->dev, "error allocating urbs: %d\n", retval);
11835+ goto err_alloc_urbs;
11836+ }
11837+
11838+ usb_set_intfdata(intf, dev);
11839+
11840+ SET_NETDEV_DEV(netdev, &intf->dev);
11841+ netdev->ethtool_ops = &ops;
11842+
11843+ retval = register_netdev(netdev);
11844+ if (retval) {
11845+ dev_err(&intf->dev, "error registering netdev: %d\n", retval);
11846+ retval = -EIO;
11847+ goto err_register_netdev;
11848+ }
11849+
11850+ dev_info(&intf->dev, "Apple iPhone USB Ethernet device attached\n");
11851+ return 0;
11852+
11853+err_register_netdev:
11854+ ipheth_free_urbs(dev);
11855+err_alloc_urbs:
11856+err_get_macaddr:
11857+err_alloc_ctrl_buf:
11858+ kfree(dev->ctrl_buf);
11859+err_endpoints:
11860+ free_netdev(netdev);
11861+ return retval;
11862+}
11863+
11864+static void ipheth_disconnect(struct usb_interface *intf)
11865+{
11866+ struct ipheth_device *dev;
11867+
11868+ dev = usb_get_intfdata(intf);
11869+ if (dev != NULL) {
11870+ unregister_netdev(dev->net);
11871+ ipheth_kill_urbs(dev);
11872+ ipheth_free_urbs(dev);
11873+ kfree(dev->ctrl_buf);
11874+ free_netdev(dev->net);
11875+ }
11876+ usb_set_intfdata(intf, NULL);
11877+ dev_info(&intf->dev, "Apple iPhone USB Ethernet now disconnected\n");
11878+}
11879+
11880+static struct usb_driver ipheth_driver = {
11881+ .name = "ipheth",
11882+ .probe = ipheth_probe,
11883+ .disconnect = ipheth_disconnect,
11884+ .id_table = ipheth_table,
11885+ .disable_hub_initiated_lpm = 1,
11886+};
11887+
11888+module_usb_driver(ipheth_driver);
11889+
11890+MODULE_AUTHOR("Diego Giagio <diego@giagio.com>");
11891+MODULE_DESCRIPTION("Apple iPhone USB Ethernet driver");
11892+MODULE_LICENSE("Dual BSD/GPL");
11893diff -Naur backports-3.18.1-1.org/drivers/net/usb/kalmia.c backports-3.18.1-1/drivers/net/usb/kalmia.c
11894--- backports-3.18.1-1.org/drivers/net/usb/kalmia.c 1970-01-01 01:00:00.000000000 +0100
11895+++ backports-3.18.1-1/drivers/net/usb/kalmia.c 2014-12-16 18:39:45.000000000 +0100
11896@@ -0,0 +1,366 @@
11897+/*
11898+ * USB network interface driver for Samsung Kalmia based LTE USB modem like the
11899+ * Samsung GT-B3730 and GT-B3710.
11900+ *
11901+ * Copyright (C) 2011 Marius Bjoernstad Kotsbak <marius@kotsbak.com>
11902+ *
11903+ * Sponsored by Quicklink Video Distribution Services Ltd.
11904+ *
11905+ * Based on the cdc_eem module.
11906+ *
11907+ * This program is free software; you can redistribute it and/or modify
11908+ * it under the terms of the GNU General Public License as published by
11909+ * the Free Software Foundation; either version 2 of the License, or
11910+ * (at your option) any later version.
11911+ */
11912+
11913+#include <linux/module.h>
11914+#include <linux/netdevice.h>
11915+#include <linux/etherdevice.h>
11916+#include <linux/ctype.h>
11917+#include <linux/ethtool.h>
11918+#include <linux/workqueue.h>
11919+#include <linux/mii.h>
11920+#include <linux/usb.h>
11921+#include <linux/crc32.h>
11922+#include <linux/usb/cdc.h>
11923+#include <linux/usb/usbnet.h>
11924+#include <linux/gfp.h>
11925+
11926+/*
11927+ * The Samsung Kalmia based LTE USB modems have a CDC ACM port for modem control
11928+ * handled by the "option" module and an ethernet data port handled by this
11929+ * module.
11930+ *
11931+ * The stick must first be switched into modem mode by usb_modeswitch
11932+ * or similar tool. Then the modem gets sent two initialization packets by
11933+ * this module, which gives the MAC address of the device. User space can then
11934+ * connect the modem using AT commands through the ACM port and then use
11935+ * DHCP on the network interface exposed by this module. Network packets are
11936+ * sent to and from the modem in a proprietary format discovered after watching
11937+ * the behavior of the windows driver for the modem.
11938+ *
11939+ * More information about the use of the modem is available in usb_modeswitch
11940+ * forum and the project page:
11941+ *
11942+ * http://www.draisberghof.de/usb_modeswitch/bb/viewtopic.php?t=465
11943+ * https://github.com/mkotsbak/Samsung-GT-B3730-linux-driver
11944+ */
11945+
11946+/* #define DEBUG */
11947+/* #define VERBOSE */
11948+
11949+#define KALMIA_HEADER_LENGTH 6
11950+#define KALMIA_ALIGN_SIZE 4
11951+#define KALMIA_USB_TIMEOUT 10000
11952+
11953+/*-------------------------------------------------------------------------*/
11954+
11955+static int
11956+kalmia_send_init_packet(struct usbnet *dev, u8 *init_msg, u8 init_msg_len,
11957+ u8 *buffer, u8 expected_len)
11958+{
11959+ int act_len;
11960+ int status;
11961+
11962+ netdev_dbg(dev->net, "Sending init packet");
11963+
11964+ status = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 0x02),
11965+ init_msg, init_msg_len, &act_len, KALMIA_USB_TIMEOUT);
11966+ if (status != 0) {
11967+ netdev_err(dev->net,
11968+ "Error sending init packet. Status %i, length %i\n",
11969+ status, act_len);
11970+ return status;
11971+ }
11972+ else if (act_len != init_msg_len) {
11973+ netdev_err(dev->net,
11974+ "Did not send all of init packet. Bytes sent: %i",
11975+ act_len);
11976+ }
11977+ else {
11978+ netdev_dbg(dev->net, "Successfully sent init packet.");
11979+ }
11980+
11981+ status = usb_bulk_msg(dev->udev, usb_rcvbulkpipe(dev->udev, 0x81),
11982+ buffer, expected_len, &act_len, KALMIA_USB_TIMEOUT);
11983+
11984+ if (status != 0)
11985+ netdev_err(dev->net,
11986+ "Error receiving init result. Status %i, length %i\n",
11987+ status, act_len);
11988+ else if (act_len != expected_len)
11989+ netdev_err(dev->net, "Unexpected init result length: %i\n",
11990+ act_len);
11991+
11992+ return status;
11993+}
11994+
11995+static int
11996+kalmia_init_and_get_ethernet_addr(struct usbnet *dev, u8 *ethernet_addr)
11997+{
11998+ static const char init_msg_1[] =
11999+ { 0x57, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
12000+ 0x00, 0x00 };
12001+ static const char init_msg_2[] =
12002+ { 0x57, 0x50, 0x04, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0xf4,
12003+ 0x00, 0x00 };
12004+ static const int buflen = 28;
12005+ char *usb_buf;
12006+ int status;
12007+
12008+ usb_buf = kmalloc(buflen, GFP_DMA | GFP_KERNEL);
12009+ if (!usb_buf)
12010+ return -ENOMEM;
12011+
12012+ memcpy(usb_buf, init_msg_1, 12);
12013+ status = kalmia_send_init_packet(dev, usb_buf, sizeof(init_msg_1)
12014+ / sizeof(init_msg_1[0]), usb_buf, 24);
12015+ if (status != 0)
12016+ return status;
12017+
12018+ memcpy(usb_buf, init_msg_2, 12);
12019+ status = kalmia_send_init_packet(dev, usb_buf, sizeof(init_msg_2)
12020+ / sizeof(init_msg_2[0]), usb_buf, 28);
12021+ if (status != 0)
12022+ return status;
12023+
12024+ memcpy(ethernet_addr, usb_buf + 10, ETH_ALEN);
12025+
12026+ kfree(usb_buf);
12027+ return status;
12028+}
12029+
12030+static int
12031+kalmia_bind(struct usbnet *dev, struct usb_interface *intf)
12032+{
12033+ int status;
12034+ u8 ethernet_addr[ETH_ALEN];
12035+
12036+ /* Don't bind to AT command interface */
12037+ if (intf->cur_altsetting->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC)
12038+ return -EINVAL;
12039+
12040+ dev->in = usb_rcvbulkpipe(dev->udev, 0x81 & USB_ENDPOINT_NUMBER_MASK);
12041+ dev->out = usb_sndbulkpipe(dev->udev, 0x02 & USB_ENDPOINT_NUMBER_MASK);
12042+ dev->status = NULL;
12043+
12044+ dev->net->hard_header_len += KALMIA_HEADER_LENGTH;
12045+ dev->hard_mtu = 1400;
12046+ dev->rx_urb_size = dev->hard_mtu * 10; // Found as optimal after testing
12047+
12048+ status = kalmia_init_and_get_ethernet_addr(dev, ethernet_addr);
12049+
12050+ if (status < 0) {
12051+ usb_set_intfdata(intf, NULL);
12052+ usb_driver_release_interface(driver_of(intf), intf);
12053+ return status;
12054+ }
12055+
12056+ memcpy(dev->net->dev_addr, ethernet_addr, ETH_ALEN);
12057+
12058+ return status;
12059+}
12060+
12061+static struct sk_buff *
12062+kalmia_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
12063+{
12064+ struct sk_buff *skb2 = NULL;
12065+ u16 content_len;
12066+ unsigned char *header_start;
12067+ unsigned char ether_type_1, ether_type_2;
12068+ u8 remainder, padlen = 0;
12069+
12070+ if (!skb_cloned(skb)) {
12071+ int headroom = skb_headroom(skb);
12072+ int tailroom = skb_tailroom(skb);
12073+
12074+ if ((tailroom >= KALMIA_ALIGN_SIZE) && (headroom
12075+ >= KALMIA_HEADER_LENGTH))
12076+ goto done;
12077+
12078+ if ((headroom + tailroom) > (KALMIA_HEADER_LENGTH
12079+ + KALMIA_ALIGN_SIZE)) {
12080+ skb->data = memmove(skb->head + KALMIA_HEADER_LENGTH,
12081+ skb->data, skb->len);
12082+ skb_set_tail_pointer(skb, skb->len);
12083+ goto done;
12084+ }
12085+ }
12086+
12087+ skb2 = skb_copy_expand(skb, KALMIA_HEADER_LENGTH,
12088+ KALMIA_ALIGN_SIZE, flags);
12089+ if (!skb2)
12090+ return NULL;
12091+
12092+ dev_kfree_skb_any(skb);
12093+ skb = skb2;
12094+
12095+done:
12096+ header_start = skb_push(skb, KALMIA_HEADER_LENGTH);
12097+ ether_type_1 = header_start[KALMIA_HEADER_LENGTH + 12];
12098+ ether_type_2 = header_start[KALMIA_HEADER_LENGTH + 13];
12099+
12100+ netdev_dbg(dev->net, "Sending etherType: %02x%02x", ether_type_1,
12101+ ether_type_2);
12102+
12103+ /* According to empiric data for data packages */
12104+ header_start[0] = 0x57;
12105+ header_start[1] = 0x44;
12106+ content_len = skb->len - KALMIA_HEADER_LENGTH;
12107+
12108+ put_unaligned_le16(content_len, &header_start[2]);
12109+ header_start[4] = ether_type_1;
12110+ header_start[5] = ether_type_2;
12111+
12112+ /* Align to 4 bytes by padding with zeros */
12113+ remainder = skb->len % KALMIA_ALIGN_SIZE;
12114+ if (remainder > 0) {
12115+ padlen = KALMIA_ALIGN_SIZE - remainder;
12116+ memset(skb_put(skb, padlen), 0, padlen);
12117+ }
12118+
12119+ netdev_dbg(dev->net,
12120+ "Sending package with length %i and padding %i. Header: %6phC.",
12121+ content_len, padlen, header_start);
12122+
12123+ return skb;
12124+}
12125+
12126+static int
12127+kalmia_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
12128+{
12129+ /*
12130+ * Our task here is to strip off framing, leaving skb with one
12131+ * data frame for the usbnet framework code to process.
12132+ */
12133+ static const u8 HEADER_END_OF_USB_PACKET[] =
12134+ { 0x57, 0x5a, 0x00, 0x00, 0x08, 0x00 };
12135+ static const u8 EXPECTED_UNKNOWN_HEADER_1[] =
12136+ { 0x57, 0x43, 0x1e, 0x00, 0x15, 0x02 };
12137+ static const u8 EXPECTED_UNKNOWN_HEADER_2[] =
12138+ { 0x57, 0x50, 0x0e, 0x00, 0x00, 0x00 };
12139+ int i = 0;
12140+
12141+ /* incomplete header? */
12142+ if (skb->len < KALMIA_HEADER_LENGTH)
12143+ return 0;
12144+
12145+ do {
12146+ struct sk_buff *skb2 = NULL;
12147+ u8 *header_start;
12148+ u16 usb_packet_length, ether_packet_length;
12149+ int is_last;
12150+
12151+ header_start = skb->data;
12152+
12153+ if (unlikely(header_start[0] != 0x57 || header_start[1] != 0x44)) {
12154+ if (!memcmp(header_start, EXPECTED_UNKNOWN_HEADER_1,
12155+ sizeof(EXPECTED_UNKNOWN_HEADER_1)) || !memcmp(
12156+ header_start, EXPECTED_UNKNOWN_HEADER_2,
12157+ sizeof(EXPECTED_UNKNOWN_HEADER_2))) {
12158+ netdev_dbg(dev->net,
12159+ "Received expected unknown frame header: %6phC. Package length: %i\n",
12160+ header_start,
12161+ skb->len - KALMIA_HEADER_LENGTH);
12162+ }
12163+ else {
12164+ netdev_err(dev->net,
12165+ "Received unknown frame header: %6phC. Package length: %i\n",
12166+ header_start,
12167+ skb->len - KALMIA_HEADER_LENGTH);
12168+ return 0;
12169+ }
12170+ }
12171+ else
12172+ netdev_dbg(dev->net,
12173+ "Received header: %6phC. Package length: %i\n",
12174+ header_start, skb->len - KALMIA_HEADER_LENGTH);
12175+
12176+ /* subtract start header and end header */
12177+ usb_packet_length = skb->len - (2 * KALMIA_HEADER_LENGTH);
12178+ ether_packet_length = get_unaligned_le16(&header_start[2]);
12179+ skb_pull(skb, KALMIA_HEADER_LENGTH);
12180+
12181+ /* Some small packets misses end marker */
12182+ if (usb_packet_length < ether_packet_length) {
12183+ ether_packet_length = usb_packet_length
12184+ + KALMIA_HEADER_LENGTH;
12185+ is_last = true;
12186+ }
12187+ else {
12188+ netdev_dbg(dev->net, "Correct package length #%i", i
12189+ + 1);
12190+
12191+ is_last = (memcmp(skb->data + ether_packet_length,
12192+ HEADER_END_OF_USB_PACKET,
12193+ sizeof(HEADER_END_OF_USB_PACKET)) == 0);
12194+ if (!is_last) {
12195+ header_start = skb->data + ether_packet_length;
12196+ netdev_dbg(dev->net,
12197+ "End header: %6phC. Package length: %i\n",
12198+ header_start,
12199+ skb->len - KALMIA_HEADER_LENGTH);
12200+ }
12201+ }
12202+
12203+ if (is_last) {
12204+ skb2 = skb;
12205+ }
12206+ else {
12207+ skb2 = skb_clone(skb, GFP_ATOMIC);
12208+ if (unlikely(!skb2))
12209+ return 0;
12210+ }
12211+
12212+ skb_trim(skb2, ether_packet_length);
12213+
12214+ if (is_last) {
12215+ return 1;
12216+ }
12217+ else {
12218+ usbnet_skb_return(dev, skb2);
12219+ skb_pull(skb, ether_packet_length);
12220+ }
12221+
12222+ i++;
12223+ }
12224+ while (skb->len);
12225+
12226+ return 1;
12227+}
12228+
12229+static const struct driver_info kalmia_info = {
12230+ .description = "Samsung Kalmia LTE USB dongle",
12231+ .flags = FLAG_WWAN,
12232+ .bind = kalmia_bind,
12233+ .rx_fixup = kalmia_rx_fixup,
12234+ .tx_fixup = kalmia_tx_fixup
12235+};
12236+
12237+/*-------------------------------------------------------------------------*/
12238+
12239+static const struct usb_device_id products[] = {
12240+ /* The unswitched USB ID, to get the module auto loaded: */
12241+ { USB_DEVICE(0x04e8, 0x689a) },
12242+ /* The stick swithed into modem (by e.g. usb_modeswitch): */
12243+ { USB_DEVICE(0x04e8, 0x6889),
12244+ .driver_info = (unsigned long) &kalmia_info, },
12245+ { /* EMPTY == end of list */} };
12246+MODULE_DEVICE_TABLE( usb, products);
12247+
12248+static struct usb_driver kalmia_driver = {
12249+ .name = "kalmia",
12250+ .id_table = products,
12251+ .probe = usbnet_probe,
12252+ .disconnect = usbnet_disconnect,
12253+ .suspend = usbnet_suspend,
12254+ .resume = usbnet_resume,
12255+ .disable_hub_initiated_lpm = 1,
12256+};
12257+
12258+module_usb_driver(kalmia_driver);
12259+
12260+MODULE_AUTHOR("Marius Bjoernstad Kotsbak <marius@kotsbak.com>");
12261+MODULE_DESCRIPTION("Samsung Kalmia USB network driver");
12262+MODULE_LICENSE("GPL");
12263diff -Naur backports-3.18.1-1.org/drivers/net/usb/kaweth.c backports-3.18.1-1/drivers/net/usb/kaweth.c
12264--- backports-3.18.1-1.org/drivers/net/usb/kaweth.c 1970-01-01 01:00:00.000000000 +0100
12265+++ backports-3.18.1-1/drivers/net/usb/kaweth.c 2014-12-16 18:39:45.000000000 +0100
12266@@ -0,0 +1,1331 @@
12267+/****************************************************************
12268+ *
12269+ * kaweth.c - driver for KL5KUSB101 based USB->Ethernet
12270+ *
12271+ * (c) 2000 Interlan Communications
12272+ * (c) 2000 Stephane Alnet
12273+ * (C) 2001 Brad Hards
12274+ * (C) 2002 Oliver Neukum
12275+ *
12276+ * Original author: The Zapman <zapman@interlan.net>
12277+ * Inspired by, and much credit goes to Michael Rothwell
12278+ * <rothwell@interlan.net> for the test equipment, help, and patience
12279+ * Based off of (and with thanks to) Petko Manolov's pegaus.c driver.
12280+ * Also many thanks to Joel Silverman and Ed Surprenant at Kawasaki
12281+ * for providing the firmware and driver resources.
12282+ *
12283+ * This program is free software; you can redistribute it and/or
12284+ * modify it under the terms of the GNU General Public License as
12285+ * published by the Free Software Foundation; either version 2, or
12286+ * (at your option) any later version.
12287+ *
12288+ * This program is distributed in the hope that it will be useful,
12289+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12290+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12291+ * GNU General Public License for more details.
12292+ *
12293+ * You should have received a copy of the GNU General Public License
12294+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
12295+ *
12296+ ****************************************************************/
12297+
12298+/* TODO:
12299+ * Develop test procedures for USB net interfaces
12300+ * Run test procedures
12301+ * Fix bugs from previous two steps
12302+ * Snoop other OSs for any tricks we're not doing
12303+ * Reduce arbitrary timeouts
12304+ * Smart multicast support
12305+ * Temporary MAC change support
12306+ * Tunable SOFs parameter - ioctl()?
12307+ * Ethernet stats collection
12308+ * Code formatting improvements
12309+ */
12310+
12311+#include <linux/module.h>
12312+#include <linux/slab.h>
12313+#include <linux/string.h>
12314+#include <linux/delay.h>
12315+#include <linux/netdevice.h>
12316+#include <linux/etherdevice.h>
12317+#include <linux/usb.h>
12318+#include <linux/types.h>
12319+#include <linux/ethtool.h>
12320+#include <linux/dma-mapping.h>
12321+#include <linux/wait.h>
12322+#include <linux/firmware.h>
12323+#include <asm/uaccess.h>
12324+#include <asm/byteorder.h>
12325+
12326+#undef DEBUG
12327+
12328+#define KAWETH_MTU 1514
12329+#define KAWETH_BUF_SIZE 1664
12330+#define KAWETH_TX_TIMEOUT (5 * HZ)
12331+#define KAWETH_SCRATCH_SIZE 32
12332+#define KAWETH_FIRMWARE_BUF_SIZE 4096
12333+#define KAWETH_CONTROL_TIMEOUT (30000)
12334+
12335+#define KAWETH_STATUS_BROKEN 0x0000001
12336+#define KAWETH_STATUS_CLOSING 0x0000002
12337+#define KAWETH_STATUS_SUSPENDING 0x0000004
12338+
12339+#define KAWETH_STATUS_BLOCKED (KAWETH_STATUS_CLOSING | KAWETH_STATUS_SUSPENDING)
12340+
12341+#define KAWETH_PACKET_FILTER_PROMISCUOUS 0x01
12342+#define KAWETH_PACKET_FILTER_ALL_MULTICAST 0x02
12343+#define KAWETH_PACKET_FILTER_DIRECTED 0x04
12344+#define KAWETH_PACKET_FILTER_BROADCAST 0x08
12345+#define KAWETH_PACKET_FILTER_MULTICAST 0x10
12346+
12347+/* Table 7 */
12348+#define KAWETH_COMMAND_GET_ETHERNET_DESC 0x00
12349+#define KAWETH_COMMAND_MULTICAST_FILTERS 0x01
12350+#define KAWETH_COMMAND_SET_PACKET_FILTER 0x02
12351+#define KAWETH_COMMAND_STATISTICS 0x03
12352+#define KAWETH_COMMAND_SET_TEMP_MAC 0x06
12353+#define KAWETH_COMMAND_GET_TEMP_MAC 0x07
12354+#define KAWETH_COMMAND_SET_URB_SIZE 0x08
12355+#define KAWETH_COMMAND_SET_SOFS_WAIT 0x09
12356+#define KAWETH_COMMAND_SCAN 0xFF
12357+
12358+#define KAWETH_SOFS_TO_WAIT 0x05
12359+
12360+#define INTBUFFERSIZE 4
12361+
12362+#define STATE_OFFSET 0
12363+#define STATE_MASK 0x40
12364+#define STATE_SHIFT 5
12365+
12366+#define IS_BLOCKED(s) (s & KAWETH_STATUS_BLOCKED)
12367+
12368+
12369+MODULE_AUTHOR("Michael Zappe <zapman@interlan.net>, Stephane Alnet <stephane@u-picardie.fr>, Brad Hards <bhards@bigpond.net.au> and Oliver Neukum <oliver@neukum.org>");
12370+MODULE_DESCRIPTION("KL5USB101 USB Ethernet driver");
12371+MODULE_LICENSE("GPL");
12372+MODULE_FIRMWARE("kaweth/new_code.bin");
12373+MODULE_FIRMWARE("kaweth/new_code_fix.bin");
12374+MODULE_FIRMWARE("kaweth/trigger_code.bin");
12375+MODULE_FIRMWARE("kaweth/trigger_code_fix.bin");
12376+
12377+static const char driver_name[] = "kaweth";
12378+
12379+static int kaweth_probe(
12380+ struct usb_interface *intf,
12381+ const struct usb_device_id *id /* from id_table */
12382+ );
12383+static void kaweth_disconnect(struct usb_interface *intf);
12384+static int kaweth_internal_control_msg(struct usb_device *usb_dev,
12385+ unsigned int pipe,
12386+ struct usb_ctrlrequest *cmd, void *data,
12387+ int len, int timeout);
12388+static int kaweth_suspend(struct usb_interface *intf, pm_message_t message);
12389+static int kaweth_resume(struct usb_interface *intf);
12390+
12391+/****************************************************************
12392+ * usb_device_id
12393+ ****************************************************************/
12394+static struct usb_device_id usb_klsi_table[] = {
12395+ { USB_DEVICE(0x03e8, 0x0008) }, /* AOX Endpoints USB Ethernet */
12396+ { USB_DEVICE(0x04bb, 0x0901) }, /* I-O DATA USB-ET/T */
12397+ { USB_DEVICE(0x0506, 0x03e8) }, /* 3Com 3C19250 */
12398+ { USB_DEVICE(0x0506, 0x11f8) }, /* 3Com 3C460 */
12399+ { USB_DEVICE(0x0557, 0x2002) }, /* ATEN USB Ethernet */
12400+ { USB_DEVICE(0x0557, 0x4000) }, /* D-Link DSB-650C */
12401+ { USB_DEVICE(0x0565, 0x0002) }, /* Peracom Enet */
12402+ { USB_DEVICE(0x0565, 0x0003) }, /* Optus@Home UEP1045A */
12403+ { USB_DEVICE(0x0565, 0x0005) }, /* Peracom Enet2 */
12404+ { USB_DEVICE(0x05e9, 0x0008) }, /* KLSI KL5KUSB101B */
12405+ { USB_DEVICE(0x05e9, 0x0009) }, /* KLSI KL5KUSB101B (Board change) */
12406+ { USB_DEVICE(0x066b, 0x2202) }, /* Linksys USB10T */
12407+ { USB_DEVICE(0x06e1, 0x0008) }, /* ADS USB-10BT */
12408+ { USB_DEVICE(0x06e1, 0x0009) }, /* ADS USB-10BT */
12409+ { USB_DEVICE(0x0707, 0x0100) }, /* SMC 2202USB */
12410+ { USB_DEVICE(0x07aa, 0x0001) }, /* Correga K.K. */
12411+ { USB_DEVICE(0x07b8, 0x4000) }, /* D-Link DU-E10 */
12412+ { USB_DEVICE(0x07c9, 0xb010) }, /* Allied Telesyn AT-USB10 USB Ethernet Adapter */
12413+ { USB_DEVICE(0x0846, 0x1001) }, /* NetGear EA-101 */
12414+ { USB_DEVICE(0x0846, 0x1002) }, /* NetGear EA-101 */
12415+ { USB_DEVICE(0x085a, 0x0008) }, /* PortGear Ethernet Adapter */
12416+ { USB_DEVICE(0x085a, 0x0009) }, /* PortGear Ethernet Adapter */
12417+ { USB_DEVICE(0x087d, 0x5704) }, /* Jaton USB Ethernet Device Adapter */
12418+ { USB_DEVICE(0x0951, 0x0008) }, /* Kingston Technology USB Ethernet Adapter */
12419+ { USB_DEVICE(0x095a, 0x3003) }, /* Portsmith Express Ethernet Adapter */
12420+ { USB_DEVICE(0x10bd, 0x1427) }, /* ASANTE USB To Ethernet Adapter */
12421+ { USB_DEVICE(0x1342, 0x0204) }, /* Mobility USB-Ethernet Adapter */
12422+ { USB_DEVICE(0x13d2, 0x0400) }, /* Shark Pocket Adapter */
12423+ { USB_DEVICE(0x1485, 0x0001) }, /* Silicom U2E */
12424+ { USB_DEVICE(0x1485, 0x0002) }, /* Psion Dacom Gold Port Ethernet */
12425+ { USB_DEVICE(0x1645, 0x0005) }, /* Entrega E45 */
12426+ { USB_DEVICE(0x1645, 0x0008) }, /* Entrega USB Ethernet Adapter */
12427+ { USB_DEVICE(0x1645, 0x8005) }, /* PortGear Ethernet Adapter */
12428+ { USB_DEVICE(0x1668, 0x0323) }, /* Actiontec USB Ethernet */
12429+ { USB_DEVICE(0x2001, 0x4000) }, /* D-link DSB-650C */
12430+ {} /* Null terminator */
12431+};
12432+
12433+MODULE_DEVICE_TABLE (usb, usb_klsi_table);
12434+
12435+/****************************************************************
12436+ * kaweth_driver
12437+ ****************************************************************/
12438+static struct usb_driver kaweth_driver = {
12439+ .name = driver_name,
12440+ .probe = kaweth_probe,
12441+ .disconnect = kaweth_disconnect,
12442+ .suspend = kaweth_suspend,
12443+ .resume = kaweth_resume,
12444+ .id_table = usb_klsi_table,
12445+ .supports_autosuspend = 1,
12446+ .disable_hub_initiated_lpm = 1,
12447+};
12448+
12449+typedef __u8 eth_addr_t[6];
12450+
12451+/****************************************************************
12452+ * usb_eth_dev
12453+ ****************************************************************/
12454+struct usb_eth_dev {
12455+ char *name;
12456+ __u16 vendor;
12457+ __u16 device;
12458+ void *pdata;
12459+};
12460+
12461+/****************************************************************
12462+ * kaweth_ethernet_configuration
12463+ * Refer Table 8
12464+ ****************************************************************/
12465+struct kaweth_ethernet_configuration
12466+{
12467+ __u8 size;
12468+ __u8 reserved1;
12469+ __u8 reserved2;
12470+ eth_addr_t hw_addr;
12471+ __u32 statistics_mask;
12472+ __le16 segment_size;
12473+ __u16 max_multicast_filters;
12474+ __u8 reserved3;
12475+} __packed;
12476+
12477+/****************************************************************
12478+ * kaweth_device
12479+ ****************************************************************/
12480+struct kaweth_device
12481+{
12482+ spinlock_t device_lock;
12483+
12484+ __u32 status;
12485+ int end;
12486+ int suspend_lowmem_rx;
12487+ int suspend_lowmem_ctrl;
12488+ int linkstate;
12489+ int opened;
12490+ struct delayed_work lowmem_work;
12491+
12492+ struct usb_device *dev;
12493+ struct usb_interface *intf;
12494+ struct net_device *net;
12495+ wait_queue_head_t term_wait;
12496+
12497+ struct urb *rx_urb;
12498+ struct urb *tx_urb;
12499+ struct urb *irq_urb;
12500+
12501+ dma_addr_t intbufferhandle;
12502+ __u8 *intbuffer;
12503+ dma_addr_t rxbufferhandle;
12504+ __u8 *rx_buf;
12505+
12506+
12507+ struct sk_buff *tx_skb;
12508+
12509+ __u8 *firmware_buf;
12510+ __u8 scratch[KAWETH_SCRATCH_SIZE];
12511+ __u16 packet_filter_bitmap;
12512+
12513+ struct kaweth_ethernet_configuration configuration;
12514+
12515+ struct net_device_stats stats;
12516+};
12517+
12518+/****************************************************************
12519+ * kaweth_control
12520+ ****************************************************************/
12521+static int kaweth_control(struct kaweth_device *kaweth,
12522+ unsigned int pipe,
12523+ __u8 request,
12524+ __u8 requesttype,
12525+ __u16 value,
12526+ __u16 index,
12527+ void *data,
12528+ __u16 size,
12529+ int timeout)
12530+{
12531+ struct usb_ctrlrequest *dr;
12532+ int retval;
12533+
12534+ netdev_dbg(kaweth->net, "kaweth_control()\n");
12535+
12536+ if(in_interrupt()) {
12537+ netdev_dbg(kaweth->net, "in_interrupt()\n");
12538+ return -EBUSY;
12539+ }
12540+
12541+ dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
12542+ if (!dr)
12543+ return -ENOMEM;
12544+
12545+ dr->bRequestType = requesttype;
12546+ dr->bRequest = request;
12547+ dr->wValue = cpu_to_le16(value);
12548+ dr->wIndex = cpu_to_le16(index);
12549+ dr->wLength = cpu_to_le16(size);
12550+
12551+ retval = kaweth_internal_control_msg(kaweth->dev,
12552+ pipe,
12553+ dr,
12554+ data,
12555+ size,
12556+ timeout);
12557+
12558+ kfree(dr);
12559+ return retval;
12560+}
12561+
12562+/****************************************************************
12563+ * kaweth_read_configuration
12564+ ****************************************************************/
12565+static int kaweth_read_configuration(struct kaweth_device *kaweth)
12566+{
12567+ int retval;
12568+
12569+ netdev_dbg(kaweth->net, "Reading kaweth configuration\n");
12570+
12571+ retval = kaweth_control(kaweth,
12572+ usb_rcvctrlpipe(kaweth->dev, 0),
12573+ KAWETH_COMMAND_GET_ETHERNET_DESC,
12574+ USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
12575+ 0,
12576+ 0,
12577+ (void *)&kaweth->configuration,
12578+ sizeof(kaweth->configuration),
12579+ KAWETH_CONTROL_TIMEOUT);
12580+
12581+ return retval;
12582+}
12583+
12584+/****************************************************************
12585+ * kaweth_set_urb_size
12586+ ****************************************************************/
12587+static int kaweth_set_urb_size(struct kaweth_device *kaweth, __u16 urb_size)
12588+{
12589+ int retval;
12590+
12591+ netdev_dbg(kaweth->net, "Setting URB size to %d\n", (unsigned)urb_size);
12592+
12593+ retval = kaweth_control(kaweth,
12594+ usb_sndctrlpipe(kaweth->dev, 0),
12595+ KAWETH_COMMAND_SET_URB_SIZE,
12596+ USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
12597+ urb_size,
12598+ 0,
12599+ (void *)&kaweth->scratch,
12600+ 0,
12601+ KAWETH_CONTROL_TIMEOUT);
12602+
12603+ return retval;
12604+}
12605+
12606+/****************************************************************
12607+ * kaweth_set_sofs_wait
12608+ ****************************************************************/
12609+static int kaweth_set_sofs_wait(struct kaweth_device *kaweth, __u16 sofs_wait)
12610+{
12611+ int retval;
12612+
12613+ netdev_dbg(kaweth->net, "Set SOFS wait to %d\n", (unsigned)sofs_wait);
12614+
12615+ retval = kaweth_control(kaweth,
12616+ usb_sndctrlpipe(kaweth->dev, 0),
12617+ KAWETH_COMMAND_SET_SOFS_WAIT,
12618+ USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
12619+ sofs_wait,
12620+ 0,
12621+ (void *)&kaweth->scratch,
12622+ 0,
12623+ KAWETH_CONTROL_TIMEOUT);
12624+
12625+ return retval;
12626+}
12627+
12628+/****************************************************************
12629+ * kaweth_set_receive_filter
12630+ ****************************************************************/
12631+static int kaweth_set_receive_filter(struct kaweth_device *kaweth,
12632+ __u16 receive_filter)
12633+{
12634+ int retval;
12635+
12636+ netdev_dbg(kaweth->net, "Set receive filter to %d\n",
12637+ (unsigned)receive_filter);
12638+
12639+ retval = kaweth_control(kaweth,
12640+ usb_sndctrlpipe(kaweth->dev, 0),
12641+ KAWETH_COMMAND_SET_PACKET_FILTER,
12642+ USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
12643+ receive_filter,
12644+ 0,
12645+ (void *)&kaweth->scratch,
12646+ 0,
12647+ KAWETH_CONTROL_TIMEOUT);
12648+
12649+ return retval;
12650+}
12651+
12652+/****************************************************************
12653+ * kaweth_download_firmware
12654+ ****************************************************************/
12655+static int kaweth_download_firmware(struct kaweth_device *kaweth,
12656+ const char *fwname,
12657+ __u8 interrupt,
12658+ __u8 type)
12659+{
12660+ const struct firmware *fw;
12661+ int data_len;
12662+ int ret;
12663+
12664+ ret = request_firmware(&fw, fwname, &kaweth->dev->dev);
12665+ if (ret) {
12666+ dev_err(&kaweth->intf->dev, "Firmware request failed\n");
12667+ return ret;
12668+ }
12669+
12670+ if (fw->size > KAWETH_FIRMWARE_BUF_SIZE) {
12671+ dev_err(&kaweth->intf->dev, "Firmware too big: %zu\n",
12672+ fw->size);
12673+ release_firmware(fw);
12674+ return -ENOSPC;
12675+ }
12676+ data_len = fw->size;
12677+ memcpy(kaweth->firmware_buf, fw->data, fw->size);
12678+
12679+ release_firmware(fw);
12680+
12681+ kaweth->firmware_buf[2] = (data_len & 0xFF) - 7;
12682+ kaweth->firmware_buf[3] = data_len >> 8;
12683+ kaweth->firmware_buf[4] = type;
12684+ kaweth->firmware_buf[5] = interrupt;
12685+
12686+ netdev_dbg(kaweth->net, "High: %i, Low:%i\n", kaweth->firmware_buf[3],
12687+ kaweth->firmware_buf[2]);
12688+
12689+ netdev_dbg(kaweth->net,
12690+ "Downloading firmware at %p to kaweth device at %p\n",
12691+ kaweth->firmware_buf, kaweth);
12692+ netdev_dbg(kaweth->net, "Firmware length: %d\n", data_len);
12693+
12694+ return kaweth_control(kaweth,
12695+ usb_sndctrlpipe(kaweth->dev, 0),
12696+ KAWETH_COMMAND_SCAN,
12697+ USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
12698+ 0,
12699+ 0,
12700+ (void *)kaweth->firmware_buf,
12701+ data_len,
12702+ KAWETH_CONTROL_TIMEOUT);
12703+}
12704+
12705+/****************************************************************
12706+ * kaweth_trigger_firmware
12707+ ****************************************************************/
12708+static int kaweth_trigger_firmware(struct kaweth_device *kaweth,
12709+ __u8 interrupt)
12710+{
12711+ kaweth->firmware_buf[0] = 0xB6;
12712+ kaweth->firmware_buf[1] = 0xC3;
12713+ kaweth->firmware_buf[2] = 0x01;
12714+ kaweth->firmware_buf[3] = 0x00;
12715+ kaweth->firmware_buf[4] = 0x06;
12716+ kaweth->firmware_buf[5] = interrupt;
12717+ kaweth->firmware_buf[6] = 0x00;
12718+ kaweth->firmware_buf[7] = 0x00;
12719+
12720+ netdev_dbg(kaweth->net, "Triggering firmware\n");
12721+
12722+ return kaweth_control(kaweth,
12723+ usb_sndctrlpipe(kaweth->dev, 0),
12724+ KAWETH_COMMAND_SCAN,
12725+ USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
12726+ 0,
12727+ 0,
12728+ (void *)kaweth->firmware_buf,
12729+ 8,
12730+ KAWETH_CONTROL_TIMEOUT);
12731+}
12732+
12733+/****************************************************************
12734+ * kaweth_reset
12735+ ****************************************************************/
12736+static int kaweth_reset(struct kaweth_device *kaweth)
12737+{
12738+ int result;
12739+
12740+ netdev_dbg(kaweth->net, "kaweth_reset(%p)\n", kaweth);
12741+ result = usb_reset_configuration(kaweth->dev);
12742+ mdelay(10);
12743+
12744+ netdev_dbg(kaweth->net, "kaweth_reset() returns %d.\n", result);
12745+
12746+ return result;
12747+}
12748+
12749+static void kaweth_usb_receive(struct urb *);
12750+static int kaweth_resubmit_rx_urb(struct kaweth_device *, gfp_t);
12751+
12752+/****************************************************************
12753+ int_callback
12754+*****************************************************************/
12755+
12756+static void kaweth_resubmit_int_urb(struct kaweth_device *kaweth, gfp_t mf)
12757+{
12758+ int status;
12759+
12760+ status = usb_submit_urb (kaweth->irq_urb, mf);
12761+ if (unlikely(status == -ENOMEM)) {
12762+ kaweth->suspend_lowmem_ctrl = 1;
12763+ schedule_delayed_work(&kaweth->lowmem_work, HZ/4);
12764+ } else {
12765+ kaweth->suspend_lowmem_ctrl = 0;
12766+ }
12767+
12768+ if (status)
12769+ dev_err(&kaweth->intf->dev,
12770+ "can't resubmit intr, %s-%s, status %d\n",
12771+ kaweth->dev->bus->bus_name,
12772+ kaweth->dev->devpath, status);
12773+}
12774+
12775+static void int_callback(struct urb *u)
12776+{
12777+ struct kaweth_device *kaweth = u->context;
12778+ int act_state;
12779+ int status = u->status;
12780+
12781+ switch (status) {
12782+ case 0: /* success */
12783+ break;
12784+ case -ECONNRESET: /* unlink */
12785+ case -ENOENT:
12786+ case -ESHUTDOWN:
12787+ return;
12788+ /* -EPIPE: should clear the halt */
12789+ default: /* error */
12790+ goto resubmit;
12791+ }
12792+
12793+ /* we check the link state to report changes */
12794+ if (kaweth->linkstate != (act_state = ( kaweth->intbuffer[STATE_OFFSET] | STATE_MASK) >> STATE_SHIFT)) {
12795+ if (act_state)
12796+ netif_carrier_on(kaweth->net);
12797+ else
12798+ netif_carrier_off(kaweth->net);
12799+
12800+ kaweth->linkstate = act_state;
12801+ }
12802+resubmit:
12803+ kaweth_resubmit_int_urb(kaweth, GFP_ATOMIC);
12804+}
12805+
12806+static void kaweth_resubmit_tl(struct work_struct *work)
12807+{
12808+ struct kaweth_device *kaweth =
12809+ container_of(work, struct kaweth_device, lowmem_work.work);
12810+
12811+ if (IS_BLOCKED(kaweth->status))
12812+ return;
12813+
12814+ if (kaweth->suspend_lowmem_rx)
12815+ kaweth_resubmit_rx_urb(kaweth, GFP_NOIO);
12816+
12817+ if (kaweth->suspend_lowmem_ctrl)
12818+ kaweth_resubmit_int_urb(kaweth, GFP_NOIO);
12819+}
12820+
12821+
12822+/****************************************************************
12823+ * kaweth_resubmit_rx_urb
12824+ ****************************************************************/
12825+static int kaweth_resubmit_rx_urb(struct kaweth_device *kaweth,
12826+ gfp_t mem_flags)
12827+{
12828+ int result;
12829+
12830+ usb_fill_bulk_urb(kaweth->rx_urb,
12831+ kaweth->dev,
12832+ usb_rcvbulkpipe(kaweth->dev, 1),
12833+ kaweth->rx_buf,
12834+ KAWETH_BUF_SIZE,
12835+ kaweth_usb_receive,
12836+ kaweth);
12837+ kaweth->rx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
12838+ kaweth->rx_urb->transfer_dma = kaweth->rxbufferhandle;
12839+
12840+ if((result = usb_submit_urb(kaweth->rx_urb, mem_flags))) {
12841+ if (result == -ENOMEM) {
12842+ kaweth->suspend_lowmem_rx = 1;
12843+ schedule_delayed_work(&kaweth->lowmem_work, HZ/4);
12844+ }
12845+ dev_err(&kaweth->intf->dev, "resubmitting rx_urb %d failed\n",
12846+ result);
12847+ } else {
12848+ kaweth->suspend_lowmem_rx = 0;
12849+ }
12850+
12851+ return result;
12852+}
12853+
12854+static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth);
12855+
12856+/****************************************************************
12857+ * kaweth_usb_receive
12858+ ****************************************************************/
12859+static void kaweth_usb_receive(struct urb *urb)
12860+{
12861+ struct device *dev = &urb->dev->dev;
12862+ struct kaweth_device *kaweth = urb->context;
12863+ struct net_device *net = kaweth->net;
12864+ int status = urb->status;
12865+
12866+ int count = urb->actual_length;
12867+ int count2 = urb->transfer_buffer_length;
12868+
12869+ __u16 pkt_len = le16_to_cpup((__le16 *)kaweth->rx_buf);
12870+
12871+ struct sk_buff *skb;
12872+
12873+ if (unlikely(status == -EPIPE)) {
12874+ kaweth->stats.rx_errors++;
12875+ kaweth->end = 1;
12876+ wake_up(&kaweth->term_wait);
12877+ dev_dbg(dev, "Status was -EPIPE.\n");
12878+ return;
12879+ }
12880+ if (unlikely(status == -ECONNRESET || status == -ESHUTDOWN)) {
12881+ /* we are killed - set a flag and wake the disconnect handler */
12882+ kaweth->end = 1;
12883+ wake_up(&kaweth->term_wait);
12884+ dev_dbg(dev, "Status was -ECONNRESET or -ESHUTDOWN.\n");
12885+ return;
12886+ }
12887+ if (unlikely(status == -EPROTO || status == -ETIME ||
12888+ status == -EILSEQ)) {
12889+ kaweth->stats.rx_errors++;
12890+ dev_dbg(dev, "Status was -EPROTO, -ETIME, or -EILSEQ.\n");
12891+ return;
12892+ }
12893+ if (unlikely(status == -EOVERFLOW)) {
12894+ kaweth->stats.rx_errors++;
12895+ dev_dbg(dev, "Status was -EOVERFLOW.\n");
12896+ }
12897+ spin_lock(&kaweth->device_lock);
12898+ if (IS_BLOCKED(kaweth->status)) {
12899+ spin_unlock(&kaweth->device_lock);
12900+ return;
12901+ }
12902+ spin_unlock(&kaweth->device_lock);
12903+
12904+ if(status && status != -EREMOTEIO && count != 1) {
12905+ dev_err(&kaweth->intf->dev,
12906+ "%s RX status: %d count: %d packet_len: %d\n",
12907+ net->name, status, count, (int)pkt_len);
12908+ kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
12909+ return;
12910+ }
12911+
12912+ if(kaweth->net && (count > 2)) {
12913+ if(pkt_len > (count - 2)) {
12914+ dev_err(&kaweth->intf->dev,
12915+ "Packet length too long for USB frame (pkt_len: %x, count: %x)\n",
12916+ pkt_len, count);
12917+ dev_err(&kaweth->intf->dev, "Packet len & 2047: %x\n",
12918+ pkt_len & 2047);
12919+ dev_err(&kaweth->intf->dev, "Count 2: %x\n", count2);
12920+ kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
12921+ return;
12922+ }
12923+
12924+ if(!(skb = dev_alloc_skb(pkt_len+2))) {
12925+ kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
12926+ return;
12927+ }
12928+
12929+ skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
12930+
12931+ skb_copy_to_linear_data(skb, kaweth->rx_buf + 2, pkt_len);
12932+
12933+ skb_put(skb, pkt_len);
12934+
12935+ skb->protocol = eth_type_trans(skb, net);
12936+
12937+ netif_rx(skb);
12938+
12939+ kaweth->stats.rx_packets++;
12940+ kaweth->stats.rx_bytes += pkt_len;
12941+ }
12942+
12943+ kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
12944+}
12945+
12946+/****************************************************************
12947+ * kaweth_open
12948+ ****************************************************************/
12949+static int kaweth_open(struct net_device *net)
12950+{
12951+ struct kaweth_device *kaweth = netdev_priv(net);
12952+ int res;
12953+
12954+ netdev_dbg(kaweth->net, "Opening network device.\n");
12955+
12956+ res = usb_autopm_get_interface(kaweth->intf);
12957+ if (res) {
12958+ dev_err(&kaweth->intf->dev, "Interface cannot be resumed.\n");
12959+ return -EIO;
12960+ }
12961+ res = kaweth_resubmit_rx_urb(kaweth, GFP_KERNEL);
12962+ if (res)
12963+ goto err_out;
12964+
12965+ usb_fill_int_urb(
12966+ kaweth->irq_urb,
12967+ kaweth->dev,
12968+ usb_rcvintpipe(kaweth->dev, 3),
12969+ kaweth->intbuffer,
12970+ INTBUFFERSIZE,
12971+ int_callback,
12972+ kaweth,
12973+ 250); /* overriding the descriptor */
12974+ kaweth->irq_urb->transfer_dma = kaweth->intbufferhandle;
12975+ kaweth->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
12976+
12977+ res = usb_submit_urb(kaweth->irq_urb, GFP_KERNEL);
12978+ if (res) {
12979+ usb_kill_urb(kaweth->rx_urb);
12980+ goto err_out;
12981+ }
12982+ kaweth->opened = 1;
12983+
12984+ netif_start_queue(net);
12985+
12986+ kaweth_async_set_rx_mode(kaweth);
12987+ return 0;
12988+
12989+err_out:
12990+ usb_autopm_put_interface(kaweth->intf);
12991+ return -EIO;
12992+}
12993+
12994+/****************************************************************
12995+ * kaweth_kill_urbs
12996+ ****************************************************************/
12997+static void kaweth_kill_urbs(struct kaweth_device *kaweth)
12998+{
12999+ usb_kill_urb(kaweth->irq_urb);
13000+ usb_kill_urb(kaweth->rx_urb);
13001+ usb_kill_urb(kaweth->tx_urb);
13002+
13003+ cancel_delayed_work_sync(&kaweth->lowmem_work);
13004+
13005+ /* a scheduled work may have resubmitted,
13006+ we hit them again */
13007+ usb_kill_urb(kaweth->irq_urb);
13008+ usb_kill_urb(kaweth->rx_urb);
13009+}
13010+
13011+/****************************************************************
13012+ * kaweth_close
13013+ ****************************************************************/
13014+static int kaweth_close(struct net_device *net)
13015+{
13016+ struct kaweth_device *kaweth = netdev_priv(net);
13017+
13018+ netif_stop_queue(net);
13019+ kaweth->opened = 0;
13020+
13021+ kaweth->status |= KAWETH_STATUS_CLOSING;
13022+
13023+ kaweth_kill_urbs(kaweth);
13024+
13025+ kaweth->status &= ~KAWETH_STATUS_CLOSING;
13026+
13027+ usb_autopm_put_interface(kaweth->intf);
13028+
13029+ return 0;
13030+}
13031+
13032+static u32 kaweth_get_link(struct net_device *dev)
13033+{
13034+ struct kaweth_device *kaweth = netdev_priv(dev);
13035+
13036+ return kaweth->linkstate;
13037+}
13038+
13039+static const struct ethtool_ops ops = {
13040+ .get_link = kaweth_get_link
13041+};
13042+
13043+/****************************************************************
13044+ * kaweth_usb_transmit_complete
13045+ ****************************************************************/
13046+static void kaweth_usb_transmit_complete(struct urb *urb)
13047+{
13048+ struct kaweth_device *kaweth = urb->context;
13049+ struct sk_buff *skb = kaweth->tx_skb;
13050+ int status = urb->status;
13051+
13052+ if (unlikely(status != 0))
13053+ if (status != -ENOENT)
13054+ dev_dbg(&urb->dev->dev, "%s: TX status %d.\n",
13055+ kaweth->net->name, status);
13056+
13057+ netif_wake_queue(kaweth->net);
13058+ dev_kfree_skb_irq(skb);
13059+}
13060+
13061+/****************************************************************
13062+ * kaweth_start_xmit
13063+ ****************************************************************/
13064+static netdev_tx_t kaweth_start_xmit(struct sk_buff *skb,
13065+ struct net_device *net)
13066+{
13067+ struct kaweth_device *kaweth = netdev_priv(net);
13068+ __le16 *private_header;
13069+
13070+ int res;
13071+
13072+ spin_lock_irq(&kaweth->device_lock);
13073+
13074+ kaweth_async_set_rx_mode(kaweth);
13075+ netif_stop_queue(net);
13076+ if (IS_BLOCKED(kaweth->status)) {
13077+ goto skip;
13078+ }
13079+
13080+ /* We now decide whether we can put our special header into the sk_buff */
13081+ if (skb_cloned(skb) || skb_headroom(skb) < 2) {
13082+ /* no such luck - we make our own */
13083+ struct sk_buff *copied_skb;
13084+ copied_skb = skb_copy_expand(skb, 2, 0, GFP_ATOMIC);
13085+ dev_kfree_skb_irq(skb);
13086+ skb = copied_skb;
13087+ if (!copied_skb) {
13088+ kaweth->stats.tx_errors++;
13089+ netif_start_queue(net);
13090+ spin_unlock_irq(&kaweth->device_lock);
13091+ return NETDEV_TX_OK;
13092+ }
13093+ }
13094+
13095+ private_header = (__le16 *)__skb_push(skb, 2);
13096+ *private_header = cpu_to_le16(skb->len-2);
13097+ kaweth->tx_skb = skb;
13098+
13099+ usb_fill_bulk_urb(kaweth->tx_urb,
13100+ kaweth->dev,
13101+ usb_sndbulkpipe(kaweth->dev, 2),
13102+ private_header,
13103+ skb->len,
13104+ kaweth_usb_transmit_complete,
13105+ kaweth);
13106+ kaweth->end = 0;
13107+
13108+ if((res = usb_submit_urb(kaweth->tx_urb, GFP_ATOMIC)))
13109+ {
13110+ dev_warn(&net->dev, "kaweth failed tx_urb %d\n", res);
13111+skip:
13112+ kaweth->stats.tx_errors++;
13113+
13114+ netif_start_queue(net);
13115+ dev_kfree_skb_irq(skb);
13116+ }
13117+ else
13118+ {
13119+ kaweth->stats.tx_packets++;
13120+ kaweth->stats.tx_bytes += skb->len;
13121+ }
13122+
13123+ spin_unlock_irq(&kaweth->device_lock);
13124+
13125+ return NETDEV_TX_OK;
13126+}
13127+
13128+/****************************************************************
13129+ * kaweth_set_rx_mode
13130+ ****************************************************************/
13131+static void kaweth_set_rx_mode(struct net_device *net)
13132+{
13133+ struct kaweth_device *kaweth = netdev_priv(net);
13134+
13135+ __u16 packet_filter_bitmap = KAWETH_PACKET_FILTER_DIRECTED |
13136+ KAWETH_PACKET_FILTER_BROADCAST |
13137+ KAWETH_PACKET_FILTER_MULTICAST;
13138+
13139+ netdev_dbg(net, "Setting Rx mode to %d\n", packet_filter_bitmap);
13140+
13141+ netif_stop_queue(net);
13142+
13143+ if (net->flags & IFF_PROMISC) {
13144+ packet_filter_bitmap |= KAWETH_PACKET_FILTER_PROMISCUOUS;
13145+ }
13146+ else if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI)) {
13147+ packet_filter_bitmap |= KAWETH_PACKET_FILTER_ALL_MULTICAST;
13148+ }
13149+
13150+ kaweth->packet_filter_bitmap = packet_filter_bitmap;
13151+ netif_wake_queue(net);
13152+}
13153+
13154+/****************************************************************
13155+ * kaweth_async_set_rx_mode
13156+ ****************************************************************/
13157+static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
13158+{
13159+ int result;
13160+ __u16 packet_filter_bitmap = kaweth->packet_filter_bitmap;
13161+
13162+ kaweth->packet_filter_bitmap = 0;
13163+ if (packet_filter_bitmap == 0)
13164+ return;
13165+
13166+ if (in_interrupt())
13167+ return;
13168+
13169+ result = kaweth_control(kaweth,
13170+ usb_sndctrlpipe(kaweth->dev, 0),
13171+ KAWETH_COMMAND_SET_PACKET_FILTER,
13172+ USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
13173+ packet_filter_bitmap,
13174+ 0,
13175+ (void *)&kaweth->scratch,
13176+ 0,
13177+ KAWETH_CONTROL_TIMEOUT);
13178+
13179+ if(result < 0) {
13180+ dev_err(&kaweth->intf->dev, "Failed to set Rx mode: %d\n",
13181+ result);
13182+ }
13183+ else {
13184+ netdev_dbg(kaweth->net, "Set Rx mode to %d\n",
13185+ packet_filter_bitmap);
13186+ }
13187+}
13188+
13189+/****************************************************************
13190+ * kaweth_netdev_stats
13191+ ****************************************************************/
13192+static struct net_device_stats *kaweth_netdev_stats(struct net_device *dev)
13193+{
13194+ struct kaweth_device *kaweth = netdev_priv(dev);
13195+ return &kaweth->stats;
13196+}
13197+
13198+/****************************************************************
13199+ * kaweth_tx_timeout
13200+ ****************************************************************/
13201+static void kaweth_tx_timeout(struct net_device *net)
13202+{
13203+ struct kaweth_device *kaweth = netdev_priv(net);
13204+
13205+ dev_warn(&net->dev, "%s: Tx timed out. Resetting.\n", net->name);
13206+ kaweth->stats.tx_errors++;
13207+ net->trans_start = jiffies;
13208+
13209+ usb_unlink_urb(kaweth->tx_urb);
13210+}
13211+
13212+/****************************************************************
13213+ * kaweth_suspend
13214+ ****************************************************************/
13215+static int kaweth_suspend(struct usb_interface *intf, pm_message_t message)
13216+{
13217+ struct kaweth_device *kaweth = usb_get_intfdata(intf);
13218+ unsigned long flags;
13219+
13220+ dev_dbg(&intf->dev, "Suspending device\n");
13221+ spin_lock_irqsave(&kaweth->device_lock, flags);
13222+ kaweth->status |= KAWETH_STATUS_SUSPENDING;
13223+ spin_unlock_irqrestore(&kaweth->device_lock, flags);
13224+
13225+ kaweth_kill_urbs(kaweth);
13226+ return 0;
13227+}
13228+
13229+/****************************************************************
13230+ * kaweth_resume
13231+ ****************************************************************/
13232+static int kaweth_resume(struct usb_interface *intf)
13233+{
13234+ struct kaweth_device *kaweth = usb_get_intfdata(intf);
13235+ unsigned long flags;
13236+
13237+ dev_dbg(&intf->dev, "Resuming device\n");
13238+ spin_lock_irqsave(&kaweth->device_lock, flags);
13239+ kaweth->status &= ~KAWETH_STATUS_SUSPENDING;
13240+ spin_unlock_irqrestore(&kaweth->device_lock, flags);
13241+
13242+ if (!kaweth->opened)
13243+ return 0;
13244+ kaweth_resubmit_rx_urb(kaweth, GFP_NOIO);
13245+ kaweth_resubmit_int_urb(kaweth, GFP_NOIO);
13246+
13247+ return 0;
13248+}
13249+
13250+/****************************************************************
13251+ * kaweth_probe
13252+ ****************************************************************/
13253+
13254+
13255+static const struct net_device_ops kaweth_netdev_ops = {
13256+ .ndo_open = kaweth_open,
13257+ .ndo_stop = kaweth_close,
13258+ .ndo_start_xmit = kaweth_start_xmit,
13259+ .ndo_tx_timeout = kaweth_tx_timeout,
13260+ .ndo_set_rx_mode = kaweth_set_rx_mode,
13261+ .ndo_get_stats = kaweth_netdev_stats,
13262+ .ndo_change_mtu = eth_change_mtu,
13263+ .ndo_set_mac_address = eth_mac_addr,
13264+ .ndo_validate_addr = eth_validate_addr,
13265+};
13266+
13267+static int kaweth_probe(
13268+ struct usb_interface *intf,
13269+ const struct usb_device_id *id /* from id_table */
13270+ )
13271+{
13272+ struct device *dev = &intf->dev;
13273+ struct usb_device *udev = interface_to_usbdev(intf);
13274+ struct kaweth_device *kaweth;
13275+ struct net_device *netdev;
13276+ const eth_addr_t bcast_addr = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
13277+ int result = 0;
13278+
13279+ dev_dbg(dev,
13280+ "Kawasaki Device Probe (Device number:%d): 0x%4.4x:0x%4.4x:0x%4.4x\n",
13281+ udev->devnum, le16_to_cpu(udev->descriptor.idVendor),
13282+ le16_to_cpu(udev->descriptor.idProduct),
13283+ le16_to_cpu(udev->descriptor.bcdDevice));
13284+
13285+ dev_dbg(dev, "Device at %p\n", udev);
13286+
13287+ dev_dbg(dev, "Descriptor length: %x type: %x\n",
13288+ (int)udev->descriptor.bLength,
13289+ (int)udev->descriptor.bDescriptorType);
13290+
13291+ netdev = alloc_etherdev(sizeof(*kaweth));
13292+ if (!netdev)
13293+ return -ENOMEM;
13294+
13295+ kaweth = netdev_priv(netdev);
13296+ kaweth->dev = udev;
13297+ kaweth->net = netdev;
13298+
13299+ spin_lock_init(&kaweth->device_lock);
13300+ init_waitqueue_head(&kaweth->term_wait);
13301+
13302+ dev_dbg(dev, "Resetting.\n");
13303+
13304+ kaweth_reset(kaweth);
13305+
13306+ /*
13307+ * If high byte of bcdDevice is nonzero, firmware is already
13308+ * downloaded. Don't try to do it again, or we'll hang the device.
13309+ */
13310+
13311+ if (le16_to_cpu(udev->descriptor.bcdDevice) >> 8) {
13312+ dev_info(dev, "Firmware present in device.\n");
13313+ } else {
13314+ /* Download the firmware */
13315+ dev_info(dev, "Downloading firmware...\n");
13316+ kaweth->firmware_buf = (__u8 *)__get_free_page(GFP_KERNEL);
13317+ if ((result = kaweth_download_firmware(kaweth,
13318+ "kaweth/new_code.bin",
13319+ 100,
13320+ 2)) < 0) {
13321+ dev_err(dev, "Error downloading firmware (%d)\n",
13322+ result);
13323+ goto err_fw;
13324+ }
13325+
13326+ if ((result = kaweth_download_firmware(kaweth,
13327+ "kaweth/new_code_fix.bin",
13328+ 100,
13329+ 3)) < 0) {
13330+ dev_err(dev, "Error downloading firmware fix (%d)\n",
13331+ result);
13332+ goto err_fw;
13333+ }
13334+
13335+ if ((result = kaweth_download_firmware(kaweth,
13336+ "kaweth/trigger_code.bin",
13337+ 126,
13338+ 2)) < 0) {
13339+ dev_err(dev, "Error downloading trigger code (%d)\n",
13340+ result);
13341+ goto err_fw;
13342+
13343+ }
13344+
13345+ if ((result = kaweth_download_firmware(kaweth,
13346+ "kaweth/trigger_code_fix.bin",
13347+ 126,
13348+ 3)) < 0) {
13349+ dev_err(dev, "Error downloading trigger code fix (%d)\n", result);
13350+ goto err_fw;
13351+ }
13352+
13353+
13354+ if ((result = kaweth_trigger_firmware(kaweth, 126)) < 0) {
13355+ dev_err(dev, "Error triggering firmware (%d)\n", result);
13356+ goto err_fw;
13357+ }
13358+
13359+ /* Device will now disappear for a moment... */
13360+ dev_info(dev, "Firmware loaded. I'll be back...\n");
13361+err_fw:
13362+ free_page((unsigned long)kaweth->firmware_buf);
13363+ free_netdev(netdev);
13364+ return -EIO;
13365+ }
13366+
13367+ result = kaweth_read_configuration(kaweth);
13368+
13369+ if(result < 0) {
13370+ dev_err(dev, "Error reading configuration (%d), no net device created\n", result);
13371+ goto err_free_netdev;
13372+ }
13373+
13374+ dev_info(dev, "Statistics collection: %x\n", kaweth->configuration.statistics_mask);
13375+ dev_info(dev, "Multicast filter limit: %x\n", kaweth->configuration.max_multicast_filters & ((1 << 15) - 1));
13376+ dev_info(dev, "MTU: %d\n", le16_to_cpu(kaweth->configuration.segment_size));
13377+ dev_info(dev, "Read MAC address %pM\n", kaweth->configuration.hw_addr);
13378+
13379+ if(!memcmp(&kaweth->configuration.hw_addr,
13380+ &bcast_addr,
13381+ sizeof(bcast_addr))) {
13382+ dev_err(dev, "Firmware not functioning properly, no net device created\n");
13383+ goto err_free_netdev;
13384+ }
13385+
13386+ if(kaweth_set_urb_size(kaweth, KAWETH_BUF_SIZE) < 0) {
13387+ dev_dbg(dev, "Error setting URB size\n");
13388+ goto err_free_netdev;
13389+ }
13390+
13391+ if(kaweth_set_sofs_wait(kaweth, KAWETH_SOFS_TO_WAIT) < 0) {
13392+ dev_err(dev, "Error setting SOFS wait\n");
13393+ goto err_free_netdev;
13394+ }
13395+
13396+ result = kaweth_set_receive_filter(kaweth,
13397+ KAWETH_PACKET_FILTER_DIRECTED |
13398+ KAWETH_PACKET_FILTER_BROADCAST |
13399+ KAWETH_PACKET_FILTER_MULTICAST);
13400+
13401+ if(result < 0) {
13402+ dev_err(dev, "Error setting receive filter\n");
13403+ goto err_free_netdev;
13404+ }
13405+
13406+ dev_dbg(dev, "Initializing net device.\n");
13407+
13408+ kaweth->intf = intf;
13409+
13410+ kaweth->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
13411+ if (!kaweth->tx_urb)
13412+ goto err_free_netdev;
13413+ kaweth->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
13414+ if (!kaweth->rx_urb)
13415+ goto err_only_tx;
13416+ kaweth->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
13417+ if (!kaweth->irq_urb)
13418+ goto err_tx_and_rx;
13419+
13420+ kaweth->intbuffer = usb_alloc_coherent( kaweth->dev,
13421+ INTBUFFERSIZE,
13422+ GFP_KERNEL,
13423+ &kaweth->intbufferhandle);
13424+ if (!kaweth->intbuffer)
13425+ goto err_tx_and_rx_and_irq;
13426+ kaweth->rx_buf = usb_alloc_coherent( kaweth->dev,
13427+ KAWETH_BUF_SIZE,
13428+ GFP_KERNEL,
13429+ &kaweth->rxbufferhandle);
13430+ if (!kaweth->rx_buf)
13431+ goto err_all_but_rxbuf;
13432+
13433+ memcpy(netdev->broadcast, &bcast_addr, sizeof(bcast_addr));
13434+ memcpy(netdev->dev_addr, &kaweth->configuration.hw_addr,
13435+ sizeof(kaweth->configuration.hw_addr));
13436+
13437+ netdev->netdev_ops = &kaweth_netdev_ops;
13438+ netdev->watchdog_timeo = KAWETH_TX_TIMEOUT;
13439+ netdev->mtu = le16_to_cpu(kaweth->configuration.segment_size);
13440+ netdev->ethtool_ops = &ops;
13441+
13442+ /* kaweth is zeroed as part of alloc_netdev */
13443+ INIT_DELAYED_WORK(&kaweth->lowmem_work, kaweth_resubmit_tl);
13444+ usb_set_intfdata(intf, kaweth);
13445+
13446+#if 0
13447+// dma_supported() is deeply broken on almost all architectures
13448+ if (dma_supported (dev, 0xffffffffffffffffULL))
13449+ kaweth->net->features |= NETIF_F_HIGHDMA;
13450+#endif
13451+
13452+ SET_NETDEV_DEV(netdev, dev);
13453+ if (register_netdev(netdev) != 0) {
13454+ dev_err(dev, "Error registering netdev.\n");
13455+ goto err_intfdata;
13456+ }
13457+
13458+ dev_info(dev, "kaweth interface created at %s\n",
13459+ kaweth->net->name);
13460+
13461+ dev_dbg(dev, "Kaweth probe returning.\n");
13462+
13463+ return 0;
13464+
13465+err_intfdata:
13466+ usb_set_intfdata(intf, NULL);
13467+ usb_free_coherent(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle);
13468+err_all_but_rxbuf:
13469+ usb_free_coherent(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle);
13470+err_tx_and_rx_and_irq:
13471+ usb_free_urb(kaweth->irq_urb);
13472+err_tx_and_rx:
13473+ usb_free_urb(kaweth->rx_urb);
13474+err_only_tx:
13475+ usb_free_urb(kaweth->tx_urb);
13476+err_free_netdev:
13477+ free_netdev(netdev);
13478+
13479+ return -EIO;
13480+}
13481+
13482+/****************************************************************
13483+ * kaweth_disconnect
13484+ ****************************************************************/
13485+static void kaweth_disconnect(struct usb_interface *intf)
13486+{
13487+ struct kaweth_device *kaweth = usb_get_intfdata(intf);
13488+ struct net_device *netdev;
13489+
13490+ dev_info(&intf->dev, "Unregistering\n");
13491+
13492+ usb_set_intfdata(intf, NULL);
13493+ if (!kaweth) {
13494+ dev_warn(&intf->dev, "unregistering non-existent device\n");
13495+ return;
13496+ }
13497+ netdev = kaweth->net;
13498+
13499+ netdev_dbg(kaweth->net, "Unregistering net device\n");
13500+ unregister_netdev(netdev);
13501+
13502+ usb_free_urb(kaweth->rx_urb);
13503+ usb_free_urb(kaweth->tx_urb);
13504+ usb_free_urb(kaweth->irq_urb);
13505+
13506+ usb_free_coherent(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle);
13507+ usb_free_coherent(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle);
13508+
13509+ free_netdev(netdev);
13510+}
13511+
13512+
13513+// FIXME this completion stuff is a modified clone of
13514+// an OLD version of some stuff in usb.c ...
13515+struct usb_api_data {
13516+ wait_queue_head_t wqh;
13517+ int done;
13518+};
13519+
13520+/*-------------------------------------------------------------------*
13521+ * completion handler for compatibility wrappers (sync control/bulk) *
13522+ *-------------------------------------------------------------------*/
13523+static void usb_api_blocking_completion(struct urb *urb)
13524+{
13525+ struct usb_api_data *awd = (struct usb_api_data *)urb->context;
13526+
13527+ awd->done=1;
13528+ wake_up(&awd->wqh);
13529+}
13530+
13531+/*-------------------------------------------------------------------*
13532+ * COMPATIBILITY STUFF *
13533+ *-------------------------------------------------------------------*/
13534+
13535+// Starts urb and waits for completion or timeout
13536+static int usb_start_wait_urb(struct urb *urb, int timeout, int* actual_length)
13537+{
13538+ struct usb_api_data awd;
13539+ int status;
13540+
13541+ init_waitqueue_head(&awd.wqh);
13542+ awd.done = 0;
13543+
13544+ urb->context = &awd;
13545+ status = usb_submit_urb(urb, GFP_NOIO);
13546+ if (status) {
13547+ // something went wrong
13548+ usb_free_urb(urb);
13549+ return status;
13550+ }
13551+
13552+ if (!wait_event_timeout(awd.wqh, awd.done, timeout)) {
13553+ // timeout
13554+ dev_warn(&urb->dev->dev, "usb_control/bulk_msg: timeout\n");
13555+ usb_kill_urb(urb); // remove urb safely
13556+ status = -ETIMEDOUT;
13557+ }
13558+ else {
13559+ status = urb->status;
13560+ }
13561+
13562+ if (actual_length) {
13563+ *actual_length = urb->actual_length;
13564+ }
13565+
13566+ usb_free_urb(urb);
13567+ return status;
13568+}
13569+
13570+/*-------------------------------------------------------------------*/
13571+// returns status (negative) or length (positive)
13572+static int kaweth_internal_control_msg(struct usb_device *usb_dev,
13573+ unsigned int pipe,
13574+ struct usb_ctrlrequest *cmd, void *data,
13575+ int len, int timeout)
13576+{
13577+ struct urb *urb;
13578+ int retv;
13579+ int length = 0; /* shut up GCC */
13580+
13581+ urb = usb_alloc_urb(0, GFP_ATOMIC);
13582+ if (!urb)
13583+ return -ENOMEM;
13584+
13585+ usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char*)cmd, data,
13586+ len, usb_api_blocking_completion, NULL);
13587+
13588+ retv = usb_start_wait_urb(urb, timeout, &length);
13589+ if (retv < 0) {
13590+ return retv;
13591+ }
13592+ else {
13593+ return length;
13594+ }
13595+}
13596+
13597+module_usb_driver(kaweth_driver);
13598diff -Naur backports-3.18.1-1.org/drivers/net/usb/Kconfig backports-3.18.1-1/drivers/net/usb/Kconfig
13599--- backports-3.18.1-1.org/drivers/net/usb/Kconfig 2014-12-21 22:37:15.000000000 +0100
13600+++ backports-3.18.1-1/drivers/net/usb/Kconfig 2015-01-03 15:19:02.310281530 +0100
13601@@ -13,7 +13,6 @@
13602 if USB_NET_DRIVERS
13603
13604 config USB_CATC
13605- depends on n
13606 tristate "USB CATC NetMate-based Ethernet device support"
13607 depends on m
13608 depends on CRC32
13609@@ -34,7 +33,6 @@
13610 module will be called catc.
13611
13612 config USB_KAWETH
13613- depends on n
13614 tristate "USB KLSI KL5USB101-based ethernet device support"
13615 depends on m
13616 ---help---
13617@@ -75,7 +73,6 @@
13618 module will be called kaweth.
13619
13620 config USB_PEGASUS
13621- depends on n
13622 tristate "USB Pegasus/Pegasus-II based ethernet device support"
13623 depends on m
13624 select BACKPORT_MII
13625@@ -92,7 +89,6 @@
13626 module will be called pegasus.
13627
13628 config USB_RTL8150
13629- depends on n
13630 tristate "USB RTL8150 based ethernet device support"
13631 depends on m
13632 select BACKPORT_MII
13633@@ -105,7 +101,6 @@
13634 module will be called rtl8150.
13635
13636 config USB_RTL8152
13637- depends on n
13638 tristate "Realtek RTL8152/RTL8153 Based USB Ethernet Adapters"
13639 depends on m
13640 select BACKPORT_MII
13641@@ -153,7 +148,6 @@
13642 module will be called usbnet.
13643
13644 config USB_NET_AX8817X
13645- depends on n
13646 tristate "ASIX AX88xxx Based USB 2.0 Ethernet Adapters"
13647 depends on m
13648 depends on USB_USBNET
13649@@ -183,7 +177,6 @@
13650 what other networking devices you have in use.
13651
13652 config USB_NET_AX88179_178A
13653- depends on n
13654 tristate "ASIX AX88179/178A USB 3.0/2.0 to Gigabit Ethernet"
13655 depends on m
13656 depends on USB_USBNET
13657@@ -232,7 +225,6 @@
13658 name is used instead.
13659
13660 config USB_NET_CDC_EEM
13661- depends on n
13662 tristate "CDC EEM support"
13663 depends on m
13664 depends on USB_USBNET
13665@@ -268,7 +260,6 @@
13666 * Ericsson F5521gw Mobile Broadband Module
13667
13668 config USB_NET_HUAWEI_CDC_NCM
13669- depends on n
13670 tristate "Huawei NCM embedded AT channel support"
13671 depends on m
13672 depends on USB_USBNET
13673@@ -304,7 +295,6 @@
13674 module will be called cdc_mbim.
13675
13676 config USB_NET_DM9601
13677- depends on n
13678 tristate "Davicom DM96xx based USB 10/100 ethernet devices"
13679 depends on m
13680 depends on USB_USBNET
13681@@ -314,7 +304,6 @@
13682 based USB 10/100 Ethernet adapters.
13683
13684 config USB_NET_SR9700
13685- depends on n
13686 tristate "CoreChip-sz SR9700 based USB 1.1 10/100 ethernet devices"
13687 depends on m
13688 depends on USB_USBNET
13689@@ -324,7 +313,6 @@
13690 10/100 Ethernet adapters.
13691
13692 config USB_NET_SR9800
13693- depends on n
13694 tristate "CoreChip-sz SR9800 based USB 2.0 10/100 ethernet devices"
13695 depends on m
13696 depends on USB_USBNET
13697@@ -341,7 +329,6 @@
13698 module will be called sr9800.
13699
13700 config USB_NET_SMSC75XX
13701- depends on n
13702 tristate "SMSC LAN75XX based USB 2.0 gigabit ethernet devices"
13703 depends on m
13704 depends on USB_USBNET
13705@@ -353,7 +340,6 @@
13706 Gigabit Ethernet adapters.
13707
13708 config USB_NET_SMSC95XX
13709- depends on n
13710 tristate "SMSC LAN95XX based USB 2.0 10/100 ethernet devices"
13711 depends on m
13712 depends on USB_USBNET
13713@@ -365,7 +351,6 @@
13714 10/100 Ethernet adapters.
13715
13716 config USB_NET_GL620A
13717- depends on n
13718 tristate "GeneSys GL620USB-A based cables"
13719 depends on m
13720 depends on USB_USBNET
13721@@ -376,7 +361,6 @@
13722 Note that the half-duplex "GL620USB" is not supported.
13723
13724 config USB_NET_NET1080
13725- depends on n
13726 tristate "NetChip 1080 based cables (Laplink, ...)"
13727 depends on m
13728 default y
13729@@ -387,7 +371,6 @@
13730 optionally with LEDs that indicate traffic
13731
13732 config USB_NET_PLUSB
13733- depends on n
13734 tristate "Prolific PL-2301/2302/25A1 based cables"
13735 depends on m
13736 # if the handshake/init/reset problems, from original 'plusb',
13737@@ -398,7 +381,6 @@
13738 with one of these chips.
13739
13740 config USB_NET_MCS7830
13741- depends on n
13742 tristate "MosChip MCS7830 based Ethernet adapters"
13743 depends on m
13744 depends on USB_USBNET
13745@@ -424,7 +406,6 @@
13746 (and for) Microsoft; it isn't an "Open" ecosystem or market.
13747
13748 config USB_NET_CDC_SUBSET
13749- depends on n
13750 tristate "Simple USB Network Links (CDC Ethernet subset)"
13751 depends on m
13752 depends on USB_USBNET
13753@@ -496,7 +477,6 @@
13754 with one of these chips.
13755
13756 config USB_NET_ZAURUS
13757- depends on n
13758 tristate "Sharp Zaurus (stock ROMs) and compatible"
13759 depends on m
13760 depends on USB_USBNET
13761@@ -516,7 +496,6 @@
13762 some cases CDC MDLM) protocol, not "g_ether".
13763
13764 config USB_NET_CX82310_ETH
13765- depends on n
13766 tristate "Conexant CX82310 USB ethernet port"
13767 depends on m
13768 depends on USB_USBNET
13769@@ -526,7 +505,6 @@
13770 it will not work with ADSL modems (use cxacru driver instead).
13771
13772 config USB_NET_KALMIA
13773- depends on n
13774 tristate "Samsung Kalmia based LTE USB modem"
13775 depends on m
13776 depends on USB_USBNET
13777@@ -561,7 +539,6 @@
13778 module will be called qmi_wwan.
13779
13780 config USB_HSO
13781- depends on n
13782 tristate "Option USB High Speed Mobile Devices"
13783 depends on m
13784 depends on USB && RFKILL && TTY
13785@@ -574,7 +551,6 @@
13786 module will be called hso.
13787
13788 config USB_NET_INT51X1
13789- depends on n
13790 tristate "Intellon PLC based usb adapter"
13791 depends on m
13792 depends on USB_USBNET
13793@@ -584,7 +560,6 @@
13794 INT51x1/INT5200 chip, like the "devolo dLan duo".
13795
13796 config USB_CDC_PHONET
13797- depends on n
13798 tristate "CDC Phonet support"
13799 depends on m
13800 depends on PHONET
13801@@ -594,7 +569,6 @@
13802 "PC suite" USB profile.
13803
13804 config USB_IPHETH
13805- depends on n
13806 tristate "Apple iPhone USB Ethernet driver"
13807 depends on m
13808 default n
13809@@ -618,11 +592,10 @@
13810 module will be called sierra_net.
13811
13812 config USB_VL600
13813- depends on n
13814 tristate "LG VL600 modem dongle"
13815 depends on m
13816 depends on USB_NET_CDCETHER && TTY
13817- select USB_ACM
13818+# depends on USB_ACM
13819 help
13820 Select this if you want to use an LG Electronics 4G/LTE usb modem
13821 called VL600. This driver only handles the ethernet
13822diff -Naur backports-3.18.1-1.org/drivers/net/usb/lg-vl600.c backports-3.18.1-1/drivers/net/usb/lg-vl600.c
13823--- backports-3.18.1-1.org/drivers/net/usb/lg-vl600.c 1970-01-01 01:00:00.000000000 +0100
13824+++ backports-3.18.1-1/drivers/net/usb/lg-vl600.c 2014-12-16 18:39:45.000000000 +0100
13825@@ -0,0 +1,353 @@
13826+/*
13827+ * Ethernet interface part of the LG VL600 LTE modem (4G dongle)
13828+ *
13829+ * Copyright (C) 2011 Intel Corporation
13830+ * Author: Andrzej Zaborowski <balrogg@gmail.com>
13831+ *
13832+ * This program is free software; you can redistribute it and/or modify
13833+ * it under the terms of the GNU General Public License as published by
13834+ * the Free Software Foundation; either version 2 of the License, or
13835+ * (at your option) any later version.
13836+ *
13837+ * This program is distributed in the hope that it will be useful,
13838+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
13839+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13840+ * GNU General Public License for more details.
13841+ *
13842+ * You should have received a copy of the GNU General Public License
13843+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
13844+ */
13845+#include <linux/etherdevice.h>
13846+#include <linux/ethtool.h>
13847+#include <linux/mii.h>
13848+#include <linux/usb.h>
13849+#include <linux/usb/cdc.h>
13850+#include <linux/usb/usbnet.h>
13851+#include <linux/if_ether.h>
13852+#include <linux/if_arp.h>
13853+#include <linux/inetdevice.h>
13854+#include <linux/module.h>
13855+
13856+/*
13857+ * The device has a CDC ACM port for modem control (it claims to be
13858+ * CDC ACM anyway) and a CDC Ethernet port for actual network data.
13859+ * It will however ignore data on both ports that is not encapsulated
13860+ * in a specific way, any data returned is also encapsulated the same
13861+ * way. The headers don't seem to follow any popular standard.
13862+ *
13863+ * This driver adds and strips these headers from the ethernet frames
13864+ * sent/received from the CDC Ethernet port. The proprietary header
13865+ * replaces the standard ethernet header in a packet so only actual
13866+ * ethernet frames are allowed. The headers allow some form of
13867+ * multiplexing by using non standard values of the .h_proto field.
13868+ * Windows/Mac drivers do send a couple of such frames to the device
13869+ * during initialisation, with protocol set to 0x0906 or 0x0b06 and (what
13870+ * seems to be) a flag in the .dummy_flags. This doesn't seem necessary
13871+ * for modem operation but can possibly be used for GPS or other funcitons.
13872+ */
13873+
13874+struct vl600_frame_hdr {
13875+ __le32 len;
13876+ __le32 serial;
13877+ __le32 pkt_cnt;
13878+ __le32 dummy_flags;
13879+ __le32 dummy;
13880+ __le32 magic;
13881+} __attribute__((packed));
13882+
13883+struct vl600_pkt_hdr {
13884+ __le32 dummy[2];
13885+ __le32 len;
13886+ __be16 h_proto;
13887+} __attribute__((packed));
13888+
13889+struct vl600_state {
13890+ struct sk_buff *current_rx_buf;
13891+};
13892+
13893+static int vl600_bind(struct usbnet *dev, struct usb_interface *intf)
13894+{
13895+ int ret;
13896+ struct vl600_state *s = kzalloc(sizeof(struct vl600_state), GFP_KERNEL);
13897+
13898+ if (!s)
13899+ return -ENOMEM;
13900+
13901+ ret = usbnet_cdc_bind(dev, intf);
13902+ if (ret) {
13903+ kfree(s);
13904+ return ret;
13905+ }
13906+
13907+ dev->driver_priv = s;
13908+
13909+ /* ARP packets don't go through, but they're also of no use. The
13910+ * subnet has only two hosts anyway: us and the gateway / DHCP
13911+ * server (probably simulated by modem firmware or network operator)
13912+ * whose address changes everytime we connect to the intarwebz and
13913+ * who doesn't bother answering ARP requests either. So hardware
13914+ * addresses have no meaning, the destination and the source of every
13915+ * packet depend only on whether it is on the IN or OUT endpoint. */
13916+ dev->net->flags |= IFF_NOARP;
13917+ /* IPv6 NDP relies on multicast. Enable it by default. */
13918+ dev->net->flags |= IFF_MULTICAST;
13919+
13920+ return ret;
13921+}
13922+
13923+static void vl600_unbind(struct usbnet *dev, struct usb_interface *intf)
13924+{
13925+ struct vl600_state *s = dev->driver_priv;
13926+
13927+ if (s->current_rx_buf)
13928+ dev_kfree_skb(s->current_rx_buf);
13929+
13930+ kfree(s);
13931+
13932+ return usbnet_cdc_unbind(dev, intf);
13933+}
13934+
13935+static int vl600_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
13936+{
13937+ struct vl600_frame_hdr *frame;
13938+ struct vl600_pkt_hdr *packet;
13939+ struct ethhdr *ethhdr;
13940+ int packet_len, count;
13941+ struct sk_buff *buf = skb;
13942+ struct sk_buff *clone;
13943+ struct vl600_state *s = dev->driver_priv;
13944+
13945+ /* Frame lengths are generally 4B multiplies but every couple of
13946+ * hours there's an odd number of bytes sized yet correct frame,
13947+ * so don't require this. */
13948+
13949+ /* Allow a packet (or multiple packets batched together) to be
13950+ * split across many frames. We don't allow a new batch to
13951+ * begin in the same frame another one is ending however, and no
13952+ * leading or trailing pad bytes. */
13953+ if (s->current_rx_buf) {
13954+ frame = (struct vl600_frame_hdr *) s->current_rx_buf->data;
13955+ if (skb->len + s->current_rx_buf->len >
13956+ le32_to_cpup(&frame->len)) {
13957+ netif_err(dev, ifup, dev->net, "Fragment too long\n");
13958+ dev->net->stats.rx_length_errors++;
13959+ goto error;
13960+ }
13961+
13962+ buf = s->current_rx_buf;
13963+ memcpy(skb_put(buf, skb->len), skb->data, skb->len);
13964+ } else if (skb->len < 4) {
13965+ netif_err(dev, ifup, dev->net, "Frame too short\n");
13966+ dev->net->stats.rx_length_errors++;
13967+ goto error;
13968+ }
13969+
13970+ frame = (struct vl600_frame_hdr *) buf->data;
13971+ /* Yes, check that frame->magic == 0x53544448 (or 0x44544d48),
13972+ * otherwise we may run out of memory w/a bad packet */
13973+ if (ntohl(frame->magic) != 0x53544448 &&
13974+ ntohl(frame->magic) != 0x44544d48)
13975+ goto error;
13976+
13977+ if (buf->len < sizeof(*frame) ||
13978+ buf->len != le32_to_cpup(&frame->len)) {
13979+ /* Save this fragment for later assembly */
13980+ if (s->current_rx_buf)
13981+ return 0;
13982+
13983+ s->current_rx_buf = skb_copy_expand(skb, 0,
13984+ le32_to_cpup(&frame->len), GFP_ATOMIC);
13985+ if (!s->current_rx_buf) {
13986+ netif_err(dev, ifup, dev->net, "Reserving %i bytes "
13987+ "for packet assembly failed.\n",
13988+ le32_to_cpup(&frame->len));
13989+ dev->net->stats.rx_errors++;
13990+ }
13991+
13992+ return 0;
13993+ }
13994+
13995+ count = le32_to_cpup(&frame->pkt_cnt);
13996+
13997+ skb_pull(buf, sizeof(*frame));
13998+
13999+ while (count--) {
14000+ if (buf->len < sizeof(*packet)) {
14001+ netif_err(dev, ifup, dev->net, "Packet too short\n");
14002+ goto error;
14003+ }
14004+
14005+ packet = (struct vl600_pkt_hdr *) buf->data;
14006+ packet_len = sizeof(*packet) + le32_to_cpup(&packet->len);
14007+ if (packet_len > buf->len) {
14008+ netif_err(dev, ifup, dev->net,
14009+ "Bad packet length stored in header\n");
14010+ goto error;
14011+ }
14012+
14013+ /* Packet header is same size as the ethernet header
14014+ * (sizeof(*packet) == sizeof(*ethhdr)), additionally
14015+ * the h_proto field is in the same place so we just leave it
14016+ * alone and fill in the remaining fields.
14017+ */
14018+ ethhdr = (struct ethhdr *) skb->data;
14019+ if (be16_to_cpup(&ethhdr->h_proto) == ETH_P_ARP &&
14020+ buf->len > 0x26) {
14021+ /* Copy the addresses from packet contents */
14022+ memcpy(ethhdr->h_source,
14023+ &buf->data[sizeof(*ethhdr) + 0x8],
14024+ ETH_ALEN);
14025+ memcpy(ethhdr->h_dest,
14026+ &buf->data[sizeof(*ethhdr) + 0x12],
14027+ ETH_ALEN);
14028+ } else {
14029+ memset(ethhdr->h_source, 0, ETH_ALEN);
14030+ memcpy(ethhdr->h_dest, dev->net->dev_addr, ETH_ALEN);
14031+
14032+ /* Inbound IPv6 packets have an IPv4 ethertype (0x800)
14033+ * for some reason. Peek at the L3 header to check
14034+ * for IPv6 packets, and set the ethertype to IPv6
14035+ * (0x86dd) so Linux can understand it.
14036+ */
14037+ if ((buf->data[sizeof(*ethhdr)] & 0xf0) == 0x60)
14038+ ethhdr->h_proto = htons(ETH_P_IPV6);
14039+ }
14040+
14041+ if (count) {
14042+ /* Not the last packet in this batch */
14043+ clone = skb_clone(buf, GFP_ATOMIC);
14044+ if (!clone)
14045+ goto error;
14046+
14047+ skb_trim(clone, packet_len);
14048+ usbnet_skb_return(dev, clone);
14049+
14050+ skb_pull(buf, (packet_len + 3) & ~3);
14051+ } else {
14052+ skb_trim(buf, packet_len);
14053+
14054+ if (s->current_rx_buf) {
14055+ usbnet_skb_return(dev, buf);
14056+ s->current_rx_buf = NULL;
14057+ return 0;
14058+ }
14059+
14060+ return 1;
14061+ }
14062+ }
14063+
14064+error:
14065+ if (s->current_rx_buf) {
14066+ dev_kfree_skb_any(s->current_rx_buf);
14067+ s->current_rx_buf = NULL;
14068+ }
14069+ dev->net->stats.rx_errors++;
14070+ return 0;
14071+}
14072+
14073+static struct sk_buff *vl600_tx_fixup(struct usbnet *dev,
14074+ struct sk_buff *skb, gfp_t flags)
14075+{
14076+ struct sk_buff *ret;
14077+ struct vl600_frame_hdr *frame;
14078+ struct vl600_pkt_hdr *packet;
14079+ static uint32_t serial = 1;
14080+ int orig_len = skb->len - sizeof(struct ethhdr);
14081+ int full_len = (skb->len + sizeof(struct vl600_frame_hdr) + 3) & ~3;
14082+
14083+ frame = (struct vl600_frame_hdr *) skb->data;
14084+ if (skb->len > sizeof(*frame) && skb->len == le32_to_cpup(&frame->len))
14085+ return skb; /* Already encapsulated? */
14086+
14087+ if (skb->len < sizeof(struct ethhdr))
14088+ /* Drop, device can only deal with ethernet packets */
14089+ return NULL;
14090+
14091+ if (!skb_cloned(skb)) {
14092+ int headroom = skb_headroom(skb);
14093+ int tailroom = skb_tailroom(skb);
14094+
14095+ if (tailroom >= full_len - skb->len - sizeof(*frame) &&
14096+ headroom >= sizeof(*frame))
14097+ /* There's enough head and tail room */
14098+ goto encapsulate;
14099+
14100+ if (headroom + tailroom + skb->len >= full_len) {
14101+ /* There's enough total room, just readjust */
14102+ skb->data = memmove(skb->head + sizeof(*frame),
14103+ skb->data, skb->len);
14104+ skb_set_tail_pointer(skb, skb->len);
14105+ goto encapsulate;
14106+ }
14107+ }
14108+
14109+ /* Alloc a new skb with the required size */
14110+ ret = skb_copy_expand(skb, sizeof(struct vl600_frame_hdr), full_len -
14111+ skb->len - sizeof(struct vl600_frame_hdr), flags);
14112+ dev_kfree_skb_any(skb);
14113+ if (!ret)
14114+ return ret;
14115+ skb = ret;
14116+
14117+encapsulate:
14118+ /* Packet header is same size as ethernet packet header
14119+ * (sizeof(*packet) == sizeof(struct ethhdr)), additionally the
14120+ * h_proto field is in the same place so we just leave it alone and
14121+ * overwrite the remaining fields.
14122+ */
14123+ packet = (struct vl600_pkt_hdr *) skb->data;
14124+ /* The VL600 wants IPv6 packets to have an IPv4 ethertype
14125+ * Since this modem only supports IPv4 and IPv6, just set all
14126+ * frames to 0x0800 (ETH_P_IP)
14127+ */
14128+ packet->h_proto = htons(ETH_P_IP);
14129+ memset(&packet->dummy, 0, sizeof(packet->dummy));
14130+ packet->len = cpu_to_le32(orig_len);
14131+
14132+ frame = (struct vl600_frame_hdr *) skb_push(skb, sizeof(*frame));
14133+ memset(frame, 0, sizeof(*frame));
14134+ frame->len = cpu_to_le32(full_len);
14135+ frame->serial = cpu_to_le32(serial++);
14136+ frame->pkt_cnt = cpu_to_le32(1);
14137+
14138+ if (skb->len < full_len) /* Pad */
14139+ skb_put(skb, full_len - skb->len);
14140+
14141+ return skb;
14142+}
14143+
14144+static const struct driver_info vl600_info = {
14145+ .description = "LG VL600 modem",
14146+ .flags = FLAG_RX_ASSEMBLE | FLAG_WWAN,
14147+ .bind = vl600_bind,
14148+ .unbind = vl600_unbind,
14149+ .status = usbnet_cdc_status,
14150+ .rx_fixup = vl600_rx_fixup,
14151+ .tx_fixup = vl600_tx_fixup,
14152+};
14153+
14154+static const struct usb_device_id products[] = {
14155+ {
14156+ USB_DEVICE_AND_INTERFACE_INFO(0x1004, 0x61aa, USB_CLASS_COMM,
14157+ USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
14158+ .driver_info = (unsigned long) &vl600_info,
14159+ },
14160+ {}, /* End */
14161+};
14162+MODULE_DEVICE_TABLE(usb, products);
14163+
14164+static struct usb_driver lg_vl600_driver = {
14165+ .name = "lg-vl600",
14166+ .id_table = products,
14167+ .probe = usbnet_probe,
14168+ .disconnect = usbnet_disconnect,
14169+ .suspend = usbnet_suspend,
14170+ .resume = usbnet_resume,
14171+ .disable_hub_initiated_lpm = 1,
14172+};
14173+
14174+module_usb_driver(lg_vl600_driver);
14175+
14176+MODULE_AUTHOR("Anrzej Zaborowski");
14177+MODULE_DESCRIPTION("LG-VL600 modem's ethernet link");
14178+MODULE_LICENSE("GPL");
14179diff -Naur backports-3.18.1-1.org/drivers/net/usb/Makefile backports-3.18.1-1/drivers/net/usb/Makefile
14180--- backports-3.18.1-1.org/drivers/net/usb/Makefile 2014-12-21 22:37:15.000000000 +0100
14181+++ backports-3.18.1-1/drivers/net/usb/Makefile 2015-01-03 13:49:51.269970813 +0100
14182@@ -1,39 +1,35 @@
14183-#
14184-# Makefile for USB Network drivers
14185-#
14186-#
14187-#obj-$(CPTCFG_USB_CATC) += catc.o
14188-#obj-$(CPTCFG_USB_KAWETH) += kaweth.o
14189-#obj-$(CPTCFG_USB_PEGASUS) += pegasus.o
14190-#obj-$(CPTCFG_USB_RTL8150) += rtl8150.o
14191-#obj-$(CPTCFG_USB_RTL8152) += r8152.o
14192-#obj-$(CPTCFG_USB_HSO) += hso.o
14193-#obj-$(CPTCFG_USB_NET_AX8817X) += asix.o
14194-#obj-$(CPTCFG_USB_NET_AX88179_178A) += ax88179_178a.o
14195+obj-$(CPTCFG_USB_CATC) += catc.o
14196+obj-$(CPTCFG_USB_KAWETH) += kaweth.o
14197+obj-$(CPTCFG_USB_PEGASUS) += pegasus.o
14198+obj-$(CPTCFG_USB_RTL8150) += rtl8150.o
14199+obj-$(CPTCFG_USB_RTL8152) += r8152.o
14200+obj-$(CPTCFG_USB_HSO) += hso.o
14201+obj-$(CPTCFG_USB_NET_AX8817X) += asix.o
14202+asix-y := asix_devices.o asix_common.o ax88172a.o
14203+obj-$(CPTCFG_USB_NET_AX88179_178A) += ax88179_178a.o
14204 obj-$(CPTCFG_USB_NET_CDCETHER) += cdc_ether.o
14205-#obj-$(CPTCFG_USB_NET_CDC_EEM) += cdc_eem.o
14206-#obj-$(CPTCFG_USB_NET_DM9601) += dm9601.o
14207-#obj-$(CPTCFG_USB_NET_SR9700) += sr9700.o
14208-#obj-$(CPTCFG_USB_NET_SR9800) += sr9800.o
14209-#obj-$(CPTCFG_USB_NET_SMSC75XX) += smsc75xx.o
14210-#obj-$(CPTCFG_USB_NET_SMSC95XX) += smsc95xx.o
14211-#obj-$(CPTCFG_USB_NET_GL620A) += gl620a.o
14212-#obj-$(CPTCFG_USB_NET_NET1080) += net1080.o
14213-#obj-$(CPTCFG_USB_NET_PLUSB) += plusb.o
14214+obj-$(CPTCFG_USB_NET_CDC_EEM) += cdc_eem.o
14215+obj-$(CPTCFG_USB_NET_DM9601) += dm9601.o
14216+obj-$(CPTCFG_USB_NET_SR9700) += sr9700.o
14217+obj-$(CPTCFG_USB_NET_SR9800) += sr9800.o
14218+obj-$(CPTCFG_USB_NET_SMSC75XX) += smsc75xx.o
14219+obj-$(CPTCFG_USB_NET_SMSC95XX) += smsc95xx.o
14220+obj-$(CPTCFG_USB_NET_GL620A) += gl620a.o
14221+obj-$(CPTCFG_USB_NET_NET1080) += net1080.o
14222+obj-$(CPTCFG_USB_NET_PLUSB) += plusb.o
14223 obj-$(CPTCFG_USB_NET_RNDIS_HOST) += rndis_host.o
14224-#obj-$(CPTCFG_USB_NET_CDC_SUBSET) += cdc_subset.o
14225-#obj-$(CPTCFG_USB_NET_ZAURUS) += zaurus.o
14226-#obj-$(CPTCFG_USB_NET_MCS7830) += mcs7830.o
14227+obj-$(CPTCFG_USB_NET_CDC_SUBSET) += cdc_subset.o
14228+obj-$(CPTCFG_USB_NET_ZAURUS) += zaurus.o
14229+obj-$(CPTCFG_USB_NET_MCS7830) += mcs7830.o
14230 obj-$(CPTCFG_USB_USBNET) += usbnet.o
14231-#obj-$(CPTCFG_USB_NET_INT51X1) += int51x1.o
14232-#obj-$(CPTCFG_USB_CDC_PHONET) += cdc-phonet.o
14233-#obj-$(CPTCFG_USB_NET_KALMIA) += kalmia.o
14234-#obj-$(CPTCFG_USB_IPHETH) += ipheth.o
14235+obj-$(CPTCFG_USB_NET_INT51X1) += int51x1.o
14236+obj-$(CPTCFG_USB_CDC_PHONET) += cdc-phonet.o
14237+obj-$(CPTCFG_USB_NET_KALMIA) += kalmia.o
14238+obj-$(CPTCFG_USB_IPHETH) += ipheth.o
14239 obj-$(CPTCFG_USB_SIERRA_NET) += sierra_net.o
14240-#obj-$(CPTCFG_USB_NET_CX82310_ETH) += cx82310_eth.o
14241+obj-$(CPTCFG_USB_NET_CX82310_ETH) += cx82310_eth.o
14242 obj-$(CPTCFG_USB_NET_CDC_NCM) += cdc_ncm.o
14243-#obj-$(CPTCFG_USB_NET_HUAWEI_CDC_NCM) += huawei_cdc_ncm.o
14244-#obj-$(CPTCFG_USB_VL600) += lg-vl600.o
14245+obj-$(CPTCFG_USB_NET_HUAWEI_CDC_NCM) += huawei_cdc_ncm.o
14246+obj-$(CPTCFG_USB_VL600) += lg-vl600.o
14247 obj-$(CPTCFG_USB_NET_QMI_WWAN) += qmi_wwan.o
14248 obj-$(CPTCFG_USB_NET_CDC_MBIM) += cdc_mbim.o
14249-
14250diff -Naur backports-3.18.1-1.org/drivers/net/usb/mcs7830.c backports-3.18.1-1/drivers/net/usb/mcs7830.c
14251--- backports-3.18.1-1.org/drivers/net/usb/mcs7830.c 1970-01-01 01:00:00.000000000 +0100
14252+++ backports-3.18.1-1/drivers/net/usb/mcs7830.c 2014-12-16 18:39:45.000000000 +0100
14253@@ -0,0 +1,643 @@
14254+/*
14255+ * MOSCHIP MCS7830 based (7730/7830/7832) USB 2.0 Ethernet Devices
14256+ *
14257+ * based on usbnet.c, asix.c and the vendor provided mcs7830 driver
14258+ *
14259+ * Copyright (C) 2010 Andreas Mohr <andi@lisas.de>
14260+ * Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>
14261+ * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
14262+ * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
14263+ * Copyright (c) 2002-2003 TiVo Inc.
14264+ *
14265+ * Definitions gathered from MOSCHIP, Data Sheet_7830DA.pdf (thanks!).
14266+ *
14267+ * 2010-12-19: add 7832 USB PID ("functionality same as MCS7830"),
14268+ * per active notification by manufacturer
14269+ *
14270+ * TODO:
14271+ * - support HIF_REG_CONFIG_SLEEPMODE/HIF_REG_CONFIG_TXENABLE (via autopm?)
14272+ * - implement ethtool_ops get_pauseparam/set_pauseparam
14273+ * via HIF_REG_PAUSE_THRESHOLD (>= revision C only!)
14274+ * - implement get_eeprom/[set_eeprom]
14275+ * - switch PHY on/off on ifup/ifdown (perhaps in usbnet.c, via MII)
14276+ * - mcs7830_get_regs() handling is weird: for rev 2 we return 32 regs,
14277+ * can access only ~ 24, remaining user buffer is uninitialized garbage
14278+ * - anything else?
14279+ *
14280+ *
14281+ * This program is free software; you can redistribute it and/or modify
14282+ * it under the terms of the GNU General Public License as published by
14283+ * the Free Software Foundation; either version 2 of the License, or
14284+ * (at your option) any later version.
14285+ *
14286+ * This program is distributed in the hope that it will be useful,
14287+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14288+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14289+ * GNU General Public License for more details.
14290+ *
14291+ * You should have received a copy of the GNU General Public License
14292+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
14293+ */
14294+
14295+#include <linux/crc32.h>
14296+#include <linux/etherdevice.h>
14297+#include <linux/ethtool.h>
14298+#include <linux/mii.h>
14299+#include <linux/module.h>
14300+#include <linux/netdevice.h>
14301+#include <linux/slab.h>
14302+#include <linux/usb.h>
14303+#include <linux/usb/usbnet.h>
14304+
14305+/* requests */
14306+#define MCS7830_RD_BMREQ (USB_DIR_IN | USB_TYPE_VENDOR | \
14307+ USB_RECIP_DEVICE)
14308+#define MCS7830_WR_BMREQ (USB_DIR_OUT | USB_TYPE_VENDOR | \
14309+ USB_RECIP_DEVICE)
14310+#define MCS7830_RD_BREQ 0x0E
14311+#define MCS7830_WR_BREQ 0x0D
14312+
14313+#define MCS7830_CTRL_TIMEOUT 1000
14314+#define MCS7830_MAX_MCAST 64
14315+
14316+#define MCS7830_VENDOR_ID 0x9710
14317+#define MCS7832_PRODUCT_ID 0x7832
14318+#define MCS7830_PRODUCT_ID 0x7830
14319+#define MCS7730_PRODUCT_ID 0x7730
14320+
14321+#define SITECOM_VENDOR_ID 0x0DF6
14322+#define LN_030_PRODUCT_ID 0x0021
14323+
14324+#define MCS7830_MII_ADVERTISE (ADVERTISE_PAUSE_CAP | ADVERTISE_100FULL | \
14325+ ADVERTISE_100HALF | ADVERTISE_10FULL | \
14326+ ADVERTISE_10HALF | ADVERTISE_CSMA)
14327+
14328+/* HIF_REG_XX corresponding index value */
14329+enum {
14330+ HIF_REG_MULTICAST_HASH = 0x00,
14331+ HIF_REG_PACKET_GAP1 = 0x08,
14332+ HIF_REG_PACKET_GAP2 = 0x09,
14333+ HIF_REG_PHY_DATA = 0x0a,
14334+ HIF_REG_PHY_CMD1 = 0x0c,
14335+ HIF_REG_PHY_CMD1_READ = 0x40,
14336+ HIF_REG_PHY_CMD1_WRITE = 0x20,
14337+ HIF_REG_PHY_CMD1_PHYADDR = 0x01,
14338+ HIF_REG_PHY_CMD2 = 0x0d,
14339+ HIF_REG_PHY_CMD2_PEND_FLAG_BIT = 0x80,
14340+ HIF_REG_PHY_CMD2_READY_FLAG_BIT = 0x40,
14341+ HIF_REG_CONFIG = 0x0e,
14342+ /* hmm, spec sez: "R/W", "Except bit 3" (likely TXENABLE). */
14343+ HIF_REG_CONFIG_CFG = 0x80,
14344+ HIF_REG_CONFIG_SPEED100 = 0x40,
14345+ HIF_REG_CONFIG_FULLDUPLEX_ENABLE = 0x20,
14346+ HIF_REG_CONFIG_RXENABLE = 0x10,
14347+ HIF_REG_CONFIG_TXENABLE = 0x08,
14348+ HIF_REG_CONFIG_SLEEPMODE = 0x04,
14349+ HIF_REG_CONFIG_ALLMULTICAST = 0x02,
14350+ HIF_REG_CONFIG_PROMISCUOUS = 0x01,
14351+ HIF_REG_ETHERNET_ADDR = 0x0f,
14352+ HIF_REG_FRAME_DROP_COUNTER = 0x15, /* 0..ff; reset: 0 */
14353+ HIF_REG_PAUSE_THRESHOLD = 0x16,
14354+ HIF_REG_PAUSE_THRESHOLD_DEFAULT = 0,
14355+};
14356+
14357+/* Trailing status byte in Ethernet Rx frame */
14358+enum {
14359+ MCS7830_RX_SHORT_FRAME = 0x01, /* < 64 bytes */
14360+ MCS7830_RX_LENGTH_ERROR = 0x02, /* framelen != Ethernet length field */
14361+ MCS7830_RX_ALIGNMENT_ERROR = 0x04, /* non-even number of nibbles */
14362+ MCS7830_RX_CRC_ERROR = 0x08,
14363+ MCS7830_RX_LARGE_FRAME = 0x10, /* > 1518 bytes */
14364+ MCS7830_RX_FRAME_CORRECT = 0x20, /* frame is correct */
14365+ /* [7:6] reserved */
14366+};
14367+
14368+struct mcs7830_data {
14369+ u8 multi_filter[8];
14370+ u8 config;
14371+};
14372+
14373+static const char driver_name[] = "MOSCHIP usb-ethernet driver";
14374+
14375+static int mcs7830_get_reg(struct usbnet *dev, u16 index, u16 size, void *data)
14376+{
14377+ return usbnet_read_cmd(dev, MCS7830_RD_BREQ, MCS7830_RD_BMREQ,
14378+ 0x0000, index, data, size);
14379+}
14380+
14381+static int mcs7830_set_reg(struct usbnet *dev, u16 index, u16 size, const void *data)
14382+{
14383+ return usbnet_write_cmd(dev, MCS7830_WR_BREQ, MCS7830_WR_BMREQ,
14384+ 0x0000, index, data, size);
14385+}
14386+
14387+static void mcs7830_set_reg_async(struct usbnet *dev, u16 index, u16 size, void *data)
14388+{
14389+ usbnet_write_cmd_async(dev, MCS7830_WR_BREQ, MCS7830_WR_BMREQ,
14390+ 0x0000, index, data, size);
14391+}
14392+
14393+static int mcs7830_hif_get_mac_address(struct usbnet *dev, unsigned char *addr)
14394+{
14395+ int ret = mcs7830_get_reg(dev, HIF_REG_ETHERNET_ADDR, ETH_ALEN, addr);
14396+ if (ret < 0)
14397+ return ret;
14398+ return 0;
14399+}
14400+
14401+static int mcs7830_hif_set_mac_address(struct usbnet *dev, unsigned char *addr)
14402+{
14403+ int ret = mcs7830_set_reg(dev, HIF_REG_ETHERNET_ADDR, ETH_ALEN, addr);
14404+
14405+ if (ret < 0)
14406+ return ret;
14407+ return 0;
14408+}
14409+
14410+static int mcs7830_set_mac_address(struct net_device *netdev, void *p)
14411+{
14412+ int ret;
14413+ struct usbnet *dev = netdev_priv(netdev);
14414+ struct sockaddr *addr = p;
14415+
14416+ if (netif_running(netdev))
14417+ return -EBUSY;
14418+
14419+ if (!is_valid_ether_addr(addr->sa_data))
14420+ return -EADDRNOTAVAIL;
14421+
14422+ ret = mcs7830_hif_set_mac_address(dev, addr->sa_data);
14423+
14424+ if (ret < 0)
14425+ return ret;
14426+
14427+ /* it worked --> adopt it on netdev side */
14428+ memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
14429+
14430+ return 0;
14431+}
14432+
14433+static int mcs7830_read_phy(struct usbnet *dev, u8 index)
14434+{
14435+ int ret;
14436+ int i;
14437+ __le16 val;
14438+
14439+ u8 cmd[2] = {
14440+ HIF_REG_PHY_CMD1_READ | HIF_REG_PHY_CMD1_PHYADDR,
14441+ HIF_REG_PHY_CMD2_PEND_FLAG_BIT | index,
14442+ };
14443+
14444+ mutex_lock(&dev->phy_mutex);
14445+ /* write the MII command */
14446+ ret = mcs7830_set_reg(dev, HIF_REG_PHY_CMD1, 2, cmd);
14447+ if (ret < 0)
14448+ goto out;
14449+
14450+ /* wait for the data to become valid, should be within < 1ms */
14451+ for (i = 0; i < 10; i++) {
14452+ ret = mcs7830_get_reg(dev, HIF_REG_PHY_CMD1, 2, cmd);
14453+ if ((ret < 0) || (cmd[1] & HIF_REG_PHY_CMD2_READY_FLAG_BIT))
14454+ break;
14455+ ret = -EIO;
14456+ msleep(1);
14457+ }
14458+ if (ret < 0)
14459+ goto out;
14460+
14461+ /* read actual register contents */
14462+ ret = mcs7830_get_reg(dev, HIF_REG_PHY_DATA, 2, &val);
14463+ if (ret < 0)
14464+ goto out;
14465+ ret = le16_to_cpu(val);
14466+ dev_dbg(&dev->udev->dev, "read PHY reg %02x: %04x (%d tries)\n",
14467+ index, val, i);
14468+out:
14469+ mutex_unlock(&dev->phy_mutex);
14470+ return ret;
14471+}
14472+
14473+static int mcs7830_write_phy(struct usbnet *dev, u8 index, u16 val)
14474+{
14475+ int ret;
14476+ int i;
14477+ __le16 le_val;
14478+
14479+ u8 cmd[2] = {
14480+ HIF_REG_PHY_CMD1_WRITE | HIF_REG_PHY_CMD1_PHYADDR,
14481+ HIF_REG_PHY_CMD2_PEND_FLAG_BIT | (index & 0x1F),
14482+ };
14483+
14484+ mutex_lock(&dev->phy_mutex);
14485+
14486+ /* write the new register contents */
14487+ le_val = cpu_to_le16(val);
14488+ ret = mcs7830_set_reg(dev, HIF_REG_PHY_DATA, 2, &le_val);
14489+ if (ret < 0)
14490+ goto out;
14491+
14492+ /* write the MII command */
14493+ ret = mcs7830_set_reg(dev, HIF_REG_PHY_CMD1, 2, cmd);
14494+ if (ret < 0)
14495+ goto out;
14496+
14497+ /* wait for the command to be accepted by the PHY */
14498+ for (i = 0; i < 10; i++) {
14499+ ret = mcs7830_get_reg(dev, HIF_REG_PHY_CMD1, 2, cmd);
14500+ if ((ret < 0) || (cmd[1] & HIF_REG_PHY_CMD2_READY_FLAG_BIT))
14501+ break;
14502+ ret = -EIO;
14503+ msleep(1);
14504+ }
14505+ if (ret < 0)
14506+ goto out;
14507+
14508+ ret = 0;
14509+ dev_dbg(&dev->udev->dev, "write PHY reg %02x: %04x (%d tries)\n",
14510+ index, val, i);
14511+out:
14512+ mutex_unlock(&dev->phy_mutex);
14513+ return ret;
14514+}
14515+
14516+/*
14517+ * This algorithm comes from the original mcs7830 version 1.4 driver,
14518+ * not sure if it is needed.
14519+ */
14520+static int mcs7830_set_autoneg(struct usbnet *dev, int ptrUserPhyMode)
14521+{
14522+ int ret;
14523+ /* Enable all media types */
14524+ ret = mcs7830_write_phy(dev, MII_ADVERTISE, MCS7830_MII_ADVERTISE);
14525+
14526+ /* First reset BMCR */
14527+ if (!ret)
14528+ ret = mcs7830_write_phy(dev, MII_BMCR, 0x0000);
14529+ /* Enable Auto Neg */
14530+ if (!ret)
14531+ ret = mcs7830_write_phy(dev, MII_BMCR, BMCR_ANENABLE);
14532+ /* Restart Auto Neg (Keep the Enable Auto Neg Bit Set) */
14533+ if (!ret)
14534+ ret = mcs7830_write_phy(dev, MII_BMCR,
14535+ BMCR_ANENABLE | BMCR_ANRESTART );
14536+ return ret;
14537+}
14538+
14539+
14540+/*
14541+ * if we can read register 22, the chip revision is C or higher
14542+ */
14543+static int mcs7830_get_rev(struct usbnet *dev)
14544+{
14545+ u8 dummy[2];
14546+ int ret;
14547+ ret = mcs7830_get_reg(dev, HIF_REG_FRAME_DROP_COUNTER, 2, dummy);
14548+ if (ret > 0)
14549+ return 2; /* Rev C or later */
14550+ return 1; /* earlier revision */
14551+}
14552+
14553+/*
14554+ * On rev. C we need to set the pause threshold
14555+ */
14556+static void mcs7830_rev_C_fixup(struct usbnet *dev)
14557+{
14558+ u8 pause_threshold = HIF_REG_PAUSE_THRESHOLD_DEFAULT;
14559+ int retry;
14560+
14561+ for (retry = 0; retry < 2; retry++) {
14562+ if (mcs7830_get_rev(dev) == 2) {
14563+ dev_info(&dev->udev->dev, "applying rev.C fixup\n");
14564+ mcs7830_set_reg(dev, HIF_REG_PAUSE_THRESHOLD,
14565+ 1, &pause_threshold);
14566+ }
14567+ msleep(1);
14568+ }
14569+}
14570+
14571+static int mcs7830_mdio_read(struct net_device *netdev, int phy_id,
14572+ int location)
14573+{
14574+ struct usbnet *dev = netdev_priv(netdev);
14575+ return mcs7830_read_phy(dev, location);
14576+}
14577+
14578+static void mcs7830_mdio_write(struct net_device *netdev, int phy_id,
14579+ int location, int val)
14580+{
14581+ struct usbnet *dev = netdev_priv(netdev);
14582+ mcs7830_write_phy(dev, location, val);
14583+}
14584+
14585+static int mcs7830_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
14586+{
14587+ struct usbnet *dev = netdev_priv(net);
14588+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
14589+}
14590+
14591+static inline struct mcs7830_data *mcs7830_get_data(struct usbnet *dev)
14592+{
14593+ return (struct mcs7830_data *)&dev->data;
14594+}
14595+
14596+static void mcs7830_hif_update_multicast_hash(struct usbnet *dev)
14597+{
14598+ struct mcs7830_data *data = mcs7830_get_data(dev);
14599+ mcs7830_set_reg_async(dev, HIF_REG_MULTICAST_HASH,
14600+ sizeof data->multi_filter,
14601+ data->multi_filter);
14602+}
14603+
14604+static void mcs7830_hif_update_config(struct usbnet *dev)
14605+{
14606+ /* implementation specific to data->config
14607+ (argument needs to be heap-based anyway - USB DMA!) */
14608+ struct mcs7830_data *data = mcs7830_get_data(dev);
14609+ mcs7830_set_reg_async(dev, HIF_REG_CONFIG, 1, &data->config);
14610+}
14611+
14612+static void mcs7830_data_set_multicast(struct net_device *net)
14613+{
14614+ struct usbnet *dev = netdev_priv(net);
14615+ struct mcs7830_data *data = mcs7830_get_data(dev);
14616+
14617+ memset(data->multi_filter, 0, sizeof data->multi_filter);
14618+
14619+ data->config = HIF_REG_CONFIG_TXENABLE;
14620+
14621+ /* this should not be needed, but it doesn't work otherwise */
14622+ data->config |= HIF_REG_CONFIG_ALLMULTICAST;
14623+
14624+ if (net->flags & IFF_PROMISC) {
14625+ data->config |= HIF_REG_CONFIG_PROMISCUOUS;
14626+ } else if (net->flags & IFF_ALLMULTI ||
14627+ netdev_mc_count(net) > MCS7830_MAX_MCAST) {
14628+ data->config |= HIF_REG_CONFIG_ALLMULTICAST;
14629+ } else if (netdev_mc_empty(net)) {
14630+ /* just broadcast and directed */
14631+ } else {
14632+ /* We use the 20 byte dev->data
14633+ * for our 8 byte filter buffer
14634+ * to avoid allocating memory that
14635+ * is tricky to free later */
14636+ struct netdev_hw_addr *ha;
14637+ u32 crc_bits;
14638+
14639+ /* Build the multicast hash filter. */
14640+ netdev_for_each_mc_addr(ha, net) {
14641+ crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
14642+ data->multi_filter[crc_bits >> 3] |= 1 << (crc_bits & 7);
14643+ }
14644+ }
14645+}
14646+
14647+static int mcs7830_apply_base_config(struct usbnet *dev)
14648+{
14649+ int ret;
14650+
14651+ /* re-configure known MAC (suspend case etc.) */
14652+ ret = mcs7830_hif_set_mac_address(dev, dev->net->dev_addr);
14653+ if (ret) {
14654+ dev_info(&dev->udev->dev, "Cannot set MAC address\n");
14655+ goto out;
14656+ }
14657+
14658+ /* Set up PHY */
14659+ ret = mcs7830_set_autoneg(dev, 0);
14660+ if (ret) {
14661+ dev_info(&dev->udev->dev, "Cannot set autoneg\n");
14662+ goto out;
14663+ }
14664+
14665+ mcs7830_hif_update_multicast_hash(dev);
14666+ mcs7830_hif_update_config(dev);
14667+
14668+ mcs7830_rev_C_fixup(dev);
14669+ ret = 0;
14670+out:
14671+ return ret;
14672+}
14673+
14674+/* credits go to asix_set_multicast */
14675+static void mcs7830_set_multicast(struct net_device *net)
14676+{
14677+ struct usbnet *dev = netdev_priv(net);
14678+
14679+ mcs7830_data_set_multicast(net);
14680+
14681+ mcs7830_hif_update_multicast_hash(dev);
14682+ mcs7830_hif_update_config(dev);
14683+}
14684+
14685+static int mcs7830_get_regs_len(struct net_device *net)
14686+{
14687+ struct usbnet *dev = netdev_priv(net);
14688+
14689+ switch (mcs7830_get_rev(dev)) {
14690+ case 1:
14691+ return 21;
14692+ case 2:
14693+ return 32;
14694+ }
14695+ return 0;
14696+}
14697+
14698+static void mcs7830_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *drvinfo)
14699+{
14700+ usbnet_get_drvinfo(net, drvinfo);
14701+ drvinfo->regdump_len = mcs7830_get_regs_len(net);
14702+}
14703+
14704+static void mcs7830_get_regs(struct net_device *net, struct ethtool_regs *regs, void *data)
14705+{
14706+ struct usbnet *dev = netdev_priv(net);
14707+
14708+ regs->version = mcs7830_get_rev(dev);
14709+ mcs7830_get_reg(dev, 0, regs->len, data);
14710+}
14711+
14712+static const struct ethtool_ops mcs7830_ethtool_ops = {
14713+ .get_drvinfo = mcs7830_get_drvinfo,
14714+ .get_regs_len = mcs7830_get_regs_len,
14715+ .get_regs = mcs7830_get_regs,
14716+
14717+ /* common usbnet calls */
14718+ .get_link = usbnet_get_link,
14719+ .get_msglevel = usbnet_get_msglevel,
14720+ .set_msglevel = usbnet_set_msglevel,
14721+ .get_settings = usbnet_get_settings,
14722+ .set_settings = usbnet_set_settings,
14723+ .nway_reset = usbnet_nway_reset,
14724+};
14725+
14726+static const struct net_device_ops mcs7830_netdev_ops = {
14727+ .ndo_open = usbnet_open,
14728+ .ndo_stop = usbnet_stop,
14729+ .ndo_start_xmit = usbnet_start_xmit,
14730+ .ndo_tx_timeout = usbnet_tx_timeout,
14731+ .ndo_change_mtu = usbnet_change_mtu,
14732+ .ndo_validate_addr = eth_validate_addr,
14733+ .ndo_do_ioctl = mcs7830_ioctl,
14734+ .ndo_set_rx_mode = mcs7830_set_multicast,
14735+ .ndo_set_mac_address = mcs7830_set_mac_address,
14736+};
14737+
14738+static int mcs7830_bind(struct usbnet *dev, struct usb_interface *udev)
14739+{
14740+ struct net_device *net = dev->net;
14741+ int ret;
14742+ int retry;
14743+
14744+ /* Initial startup: Gather MAC address setting from EEPROM */
14745+ ret = -EINVAL;
14746+ for (retry = 0; retry < 5 && ret; retry++)
14747+ ret = mcs7830_hif_get_mac_address(dev, net->dev_addr);
14748+ if (ret) {
14749+ dev_warn(&dev->udev->dev, "Cannot read MAC address\n");
14750+ goto out;
14751+ }
14752+
14753+ mcs7830_data_set_multicast(net);
14754+
14755+ ret = mcs7830_apply_base_config(dev);
14756+ if (ret)
14757+ goto out;
14758+
14759+ net->ethtool_ops = &mcs7830_ethtool_ops;
14760+ net->netdev_ops = &mcs7830_netdev_ops;
14761+
14762+ /* reserve space for the status byte on rx */
14763+ dev->rx_urb_size = ETH_FRAME_LEN + 1;
14764+
14765+ dev->mii.mdio_read = mcs7830_mdio_read;
14766+ dev->mii.mdio_write = mcs7830_mdio_write;
14767+ dev->mii.dev = net;
14768+ dev->mii.phy_id_mask = 0x3f;
14769+ dev->mii.reg_num_mask = 0x1f;
14770+ dev->mii.phy_id = *((u8 *) net->dev_addr + 1);
14771+
14772+ ret = usbnet_get_endpoints(dev, udev);
14773+out:
14774+ return ret;
14775+}
14776+
14777+/* The chip always appends a status byte that we need to strip */
14778+static int mcs7830_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
14779+{
14780+ u8 status;
14781+
14782+ /* This check is no longer done by usbnet */
14783+ if (skb->len < dev->net->hard_header_len) {
14784+ dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");
14785+ return 0;
14786+ }
14787+
14788+ skb_trim(skb, skb->len - 1);
14789+ status = skb->data[skb->len];
14790+
14791+ if (status != MCS7830_RX_FRAME_CORRECT) {
14792+ dev_dbg(&dev->udev->dev, "rx fixup status %x\n", status);
14793+
14794+ /* hmm, perhaps usbnet.c already sees a globally visible
14795+ frame error and increments rx_errors on its own already? */
14796+ dev->net->stats.rx_errors++;
14797+
14798+ if (status & (MCS7830_RX_SHORT_FRAME
14799+ |MCS7830_RX_LENGTH_ERROR
14800+ |MCS7830_RX_LARGE_FRAME))
14801+ dev->net->stats.rx_length_errors++;
14802+ if (status & MCS7830_RX_ALIGNMENT_ERROR)
14803+ dev->net->stats.rx_frame_errors++;
14804+ if (status & MCS7830_RX_CRC_ERROR)
14805+ dev->net->stats.rx_crc_errors++;
14806+ }
14807+
14808+ return skb->len > 0;
14809+}
14810+
14811+static void mcs7830_status(struct usbnet *dev, struct urb *urb)
14812+{
14813+ u8 *buf = urb->transfer_buffer;
14814+ bool link, link_changed;
14815+
14816+ if (urb->actual_length < 16)
14817+ return;
14818+
14819+ link = !(buf[1] == 0x20);
14820+ link_changed = netif_carrier_ok(dev->net) != link;
14821+ if (link_changed) {
14822+ usbnet_link_change(dev, link, 0);
14823+ netdev_dbg(dev->net, "Link Status is: %d\n", link);
14824+ }
14825+}
14826+
14827+static const struct driver_info moschip_info = {
14828+ .description = "MOSCHIP 7830/7832/7730 usb-NET adapter",
14829+ .bind = mcs7830_bind,
14830+ .rx_fixup = mcs7830_rx_fixup,
14831+ .flags = FLAG_ETHER | FLAG_LINK_INTR,
14832+ .status = mcs7830_status,
14833+ .in = 1,
14834+ .out = 2,
14835+};
14836+
14837+static const struct driver_info sitecom_info = {
14838+ .description = "Sitecom LN-30 usb-NET adapter",
14839+ .bind = mcs7830_bind,
14840+ .rx_fixup = mcs7830_rx_fixup,
14841+ .flags = FLAG_ETHER | FLAG_LINK_INTR,
14842+ .status = mcs7830_status,
14843+ .in = 1,
14844+ .out = 2,
14845+};
14846+
14847+static const struct usb_device_id products[] = {
14848+ {
14849+ USB_DEVICE(MCS7830_VENDOR_ID, MCS7832_PRODUCT_ID),
14850+ .driver_info = (unsigned long) &moschip_info,
14851+ },
14852+ {
14853+ USB_DEVICE(MCS7830_VENDOR_ID, MCS7830_PRODUCT_ID),
14854+ .driver_info = (unsigned long) &moschip_info,
14855+ },
14856+ {
14857+ USB_DEVICE(MCS7830_VENDOR_ID, MCS7730_PRODUCT_ID),
14858+ .driver_info = (unsigned long) &moschip_info,
14859+ },
14860+ {
14861+ USB_DEVICE(SITECOM_VENDOR_ID, LN_030_PRODUCT_ID),
14862+ .driver_info = (unsigned long) &sitecom_info,
14863+ },
14864+ {},
14865+};
14866+MODULE_DEVICE_TABLE(usb, products);
14867+
14868+static int mcs7830_reset_resume (struct usb_interface *intf)
14869+{
14870+ /* YES, this function is successful enough that ethtool -d
14871+ does show same output pre-/post-suspend */
14872+
14873+ struct usbnet *dev = usb_get_intfdata(intf);
14874+
14875+ mcs7830_apply_base_config(dev);
14876+
14877+ usbnet_resume(intf);
14878+
14879+ return 0;
14880+}
14881+
14882+static struct usb_driver mcs7830_driver = {
14883+ .name = driver_name,
14884+ .id_table = products,
14885+ .probe = usbnet_probe,
14886+ .disconnect = usbnet_disconnect,
14887+ .suspend = usbnet_suspend,
14888+ .resume = usbnet_resume,
14889+ .reset_resume = mcs7830_reset_resume,
14890+ .disable_hub_initiated_lpm = 1,
14891+};
14892+
14893+module_usb_driver(mcs7830_driver);
14894+
14895+MODULE_DESCRIPTION("USB to network adapter MCS7830)");
14896+MODULE_LICENSE("GPL");
14897diff -Naur backports-3.18.1-1.org/drivers/net/usb/net1080.c backports-3.18.1-1/drivers/net/usb/net1080.c
14898--- backports-3.18.1-1.org/drivers/net/usb/net1080.c 1970-01-01 01:00:00.000000000 +0100
14899+++ backports-3.18.1-1/drivers/net/usb/net1080.c 2014-12-16 18:39:45.000000000 +0100
14900@@ -0,0 +1,544 @@
14901+/*
14902+ * Net1080 based USB host-to-host cables
14903+ * Copyright (C) 2000-2005 by David Brownell
14904+ *
14905+ * This program is free software; you can redistribute it and/or modify
14906+ * it under the terms of the GNU General Public License as published by
14907+ * the Free Software Foundation; either version 2 of the License, or
14908+ * (at your option) any later version.
14909+ *
14910+ * This program is distributed in the hope that it will be useful,
14911+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
14912+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14913+ * GNU General Public License for more details.
14914+ *
14915+ * You should have received a copy of the GNU General Public License
14916+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
14917+ */
14918+
14919+// #define DEBUG // error path messages, extra info
14920+// #define VERBOSE // more; success messages
14921+
14922+#include <linux/module.h>
14923+#include <linux/netdevice.h>
14924+#include <linux/etherdevice.h>
14925+#include <linux/ethtool.h>
14926+#include <linux/workqueue.h>
14927+#include <linux/mii.h>
14928+#include <linux/usb.h>
14929+#include <linux/usb/usbnet.h>
14930+#include <linux/slab.h>
14931+
14932+#include <asm/unaligned.h>
14933+
14934+
14935+/*
14936+ * Netchip 1080 driver ... http://www.netchip.com
14937+ * (Sept 2004: End-of-life announcement has been sent.)
14938+ * Used in (some) LapLink cables
14939+ */
14940+
14941+#define frame_errors data[1]
14942+
14943+/*
14944+ * NetChip framing of ethernet packets, supporting additional error
14945+ * checks for links that may drop bulk packets from inside messages.
14946+ * Odd USB length == always short read for last usb packet.
14947+ * - nc_header
14948+ * - Ethernet header (14 bytes)
14949+ * - payload
14950+ * - (optional padding byte, if needed so length becomes odd)
14951+ * - nc_trailer
14952+ *
14953+ * This framing is to be avoided for non-NetChip devices.
14954+ */
14955+
14956+struct nc_header { // packed:
14957+ __le16 hdr_len; // sizeof nc_header (LE, all)
14958+ __le16 packet_len; // payload size (including ethhdr)
14959+ __le16 packet_id; // detects dropped packets
14960+#define MIN_HEADER 6
14961+
14962+ // all else is optional, and must start with:
14963+ // __le16 vendorId; // from usb-if
14964+ // __le16 productId;
14965+} __packed;
14966+
14967+#define PAD_BYTE ((unsigned char)0xAC)
14968+
14969+struct nc_trailer {
14970+ __le16 packet_id;
14971+} __packed;
14972+
14973+// packets may use FLAG_FRAMING_NC and optional pad
14974+#define FRAMED_SIZE(mtu) (sizeof (struct nc_header) \
14975+ + sizeof (struct ethhdr) \
14976+ + (mtu) \
14977+ + 1 \
14978+ + sizeof (struct nc_trailer))
14979+
14980+#define MIN_FRAMED FRAMED_SIZE(0)
14981+
14982+/* packets _could_ be up to 64KB... */
14983+#define NC_MAX_PACKET 32767
14984+
14985+
14986+/*
14987+ * Zero means no timeout; else, how long a 64 byte bulk packet may be queued
14988+ * before the hardware drops it. If that's done, the driver will need to
14989+ * frame network packets to guard against the dropped USB packets. The win32
14990+ * driver sets this for both sides of the link.
14991+ */
14992+#define NC_READ_TTL_MS ((u8)255) // ms
14993+
14994+/*
14995+ * We ignore most registers and EEPROM contents.
14996+ */
14997+#define REG_USBCTL ((u8)0x04)
14998+#define REG_TTL ((u8)0x10)
14999+#define REG_STATUS ((u8)0x11)
15000+
15001+/*
15002+ * Vendor specific requests to read/write data
15003+ */
15004+#define REQUEST_REGISTER ((u8)0x10)
15005+#define REQUEST_EEPROM ((u8)0x11)
15006+
15007+static int
15008+nc_vendor_read(struct usbnet *dev, u8 req, u8 regnum, u16 *retval_ptr)
15009+{
15010+ int status = usbnet_read_cmd(dev, req,
15011+ USB_DIR_IN | USB_TYPE_VENDOR |
15012+ USB_RECIP_DEVICE,
15013+ 0, regnum, retval_ptr,
15014+ sizeof *retval_ptr);
15015+ if (status > 0)
15016+ status = 0;
15017+ if (!status)
15018+ le16_to_cpus(retval_ptr);
15019+ return status;
15020+}
15021+
15022+static inline int
15023+nc_register_read(struct usbnet *dev, u8 regnum, u16 *retval_ptr)
15024+{
15025+ return nc_vendor_read(dev, REQUEST_REGISTER, regnum, retval_ptr);
15026+}
15027+
15028+// no retval ... can become async, usable in_interrupt()
15029+static void
15030+nc_vendor_write(struct usbnet *dev, u8 req, u8 regnum, u16 value)
15031+{
15032+ usbnet_write_cmd(dev, req,
15033+ USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
15034+ value, regnum, NULL, 0);
15035+}
15036+
15037+static inline void
15038+nc_register_write(struct usbnet *dev, u8 regnum, u16 value)
15039+{
15040+ nc_vendor_write(dev, REQUEST_REGISTER, regnum, value);
15041+}
15042+
15043+
15044+#if 0
15045+static void nc_dump_registers(struct usbnet *dev)
15046+{
15047+ u8 reg;
15048+ u16 *vp = kmalloc(sizeof (u16));
15049+
15050+ if (!vp)
15051+ return;
15052+
15053+ netdev_dbg(dev->net, "registers:\n");
15054+ for (reg = 0; reg < 0x20; reg++) {
15055+ int retval;
15056+
15057+ // reading some registers is trouble
15058+ if (reg >= 0x08 && reg <= 0xf)
15059+ continue;
15060+ if (reg >= 0x12 && reg <= 0x1e)
15061+ continue;
15062+
15063+ retval = nc_register_read(dev, reg, vp);
15064+ if (retval < 0)
15065+ netdev_dbg(dev->net, "reg [0x%x] ==> error %d\n",
15066+ reg, retval);
15067+ else
15068+ netdev_dbg(dev->net, "reg [0x%x] = 0x%x\n", reg, *vp);
15069+ }
15070+ kfree(vp);
15071+}
15072+#endif
15073+
15074+
15075+/*-------------------------------------------------------------------------*/
15076+
15077+/*
15078+ * Control register
15079+ */
15080+
15081+#define USBCTL_WRITABLE_MASK 0x1f0f
15082+// bits 15-13 reserved, r/o
15083+#define USBCTL_ENABLE_LANG (1 << 12)
15084+#define USBCTL_ENABLE_MFGR (1 << 11)
15085+#define USBCTL_ENABLE_PROD (1 << 10)
15086+#define USBCTL_ENABLE_SERIAL (1 << 9)
15087+#define USBCTL_ENABLE_DEFAULTS (1 << 8)
15088+// bits 7-4 reserved, r/o
15089+#define USBCTL_FLUSH_OTHER (1 << 3)
15090+#define USBCTL_FLUSH_THIS (1 << 2)
15091+#define USBCTL_DISCONN_OTHER (1 << 1)
15092+#define USBCTL_DISCONN_THIS (1 << 0)
15093+
15094+static inline void nc_dump_usbctl(struct usbnet *dev, u16 usbctl)
15095+{
15096+ netif_dbg(dev, link, dev->net,
15097+ "net1080 %s-%s usbctl 0x%x:%s%s%s%s%s; this%s%s; other%s%s; r/o 0x%x\n",
15098+ dev->udev->bus->bus_name, dev->udev->devpath,
15099+ usbctl,
15100+ (usbctl & USBCTL_ENABLE_LANG) ? " lang" : "",
15101+ (usbctl & USBCTL_ENABLE_MFGR) ? " mfgr" : "",
15102+ (usbctl & USBCTL_ENABLE_PROD) ? " prod" : "",
15103+ (usbctl & USBCTL_ENABLE_SERIAL) ? " serial" : "",
15104+ (usbctl & USBCTL_ENABLE_DEFAULTS) ? " defaults" : "",
15105+
15106+ (usbctl & USBCTL_FLUSH_THIS) ? " FLUSH" : "",
15107+ (usbctl & USBCTL_DISCONN_THIS) ? " DIS" : "",
15108+
15109+ (usbctl & USBCTL_FLUSH_OTHER) ? " FLUSH" : "",
15110+ (usbctl & USBCTL_DISCONN_OTHER) ? " DIS" : "",
15111+
15112+ usbctl & ~USBCTL_WRITABLE_MASK);
15113+}
15114+
15115+/*-------------------------------------------------------------------------*/
15116+
15117+/*
15118+ * Status register
15119+ */
15120+
15121+#define STATUS_PORT_A (1 << 15)
15122+
15123+#define STATUS_CONN_OTHER (1 << 14)
15124+#define STATUS_SUSPEND_OTHER (1 << 13)
15125+#define STATUS_MAILBOX_OTHER (1 << 12)
15126+#define STATUS_PACKETS_OTHER(n) (((n) >> 8) & 0x03)
15127+
15128+#define STATUS_CONN_THIS (1 << 6)
15129+#define STATUS_SUSPEND_THIS (1 << 5)
15130+#define STATUS_MAILBOX_THIS (1 << 4)
15131+#define STATUS_PACKETS_THIS(n) (((n) >> 0) & 0x03)
15132+
15133+#define STATUS_UNSPEC_MASK 0x0c8c
15134+#define STATUS_NOISE_MASK ((u16)~(0x0303|STATUS_UNSPEC_MASK))
15135+
15136+
15137+static inline void nc_dump_status(struct usbnet *dev, u16 status)
15138+{
15139+ netif_dbg(dev, link, dev->net,
15140+ "net1080 %s-%s status 0x%x: this (%c) PKT=%d%s%s%s; other PKT=%d%s%s%s; unspec 0x%x\n",
15141+ dev->udev->bus->bus_name, dev->udev->devpath,
15142+ status,
15143+
15144+ // XXX the packet counts don't seem right
15145+ // (1 at reset, not 0); maybe UNSPEC too
15146+
15147+ (status & STATUS_PORT_A) ? 'A' : 'B',
15148+ STATUS_PACKETS_THIS(status),
15149+ (status & STATUS_CONN_THIS) ? " CON" : "",
15150+ (status & STATUS_SUSPEND_THIS) ? " SUS" : "",
15151+ (status & STATUS_MAILBOX_THIS) ? " MBOX" : "",
15152+
15153+ STATUS_PACKETS_OTHER(status),
15154+ (status & STATUS_CONN_OTHER) ? " CON" : "",
15155+ (status & STATUS_SUSPEND_OTHER) ? " SUS" : "",
15156+ (status & STATUS_MAILBOX_OTHER) ? " MBOX" : "",
15157+
15158+ status & STATUS_UNSPEC_MASK);
15159+}
15160+
15161+/*-------------------------------------------------------------------------*/
15162+
15163+/*
15164+ * TTL register
15165+ */
15166+
15167+#define TTL_THIS(ttl) (0x00ff & ttl)
15168+#define TTL_OTHER(ttl) (0x00ff & (ttl >> 8))
15169+#define MK_TTL(this,other) ((u16)(((other)<<8)|(0x00ff&(this))))
15170+
15171+static inline void nc_dump_ttl(struct usbnet *dev, u16 ttl)
15172+{
15173+ netif_dbg(dev, link, dev->net, "net1080 %s-%s ttl 0x%x this = %d, other = %d\n",
15174+ dev->udev->bus->bus_name, dev->udev->devpath,
15175+ ttl, TTL_THIS(ttl), TTL_OTHER(ttl));
15176+}
15177+
15178+/*-------------------------------------------------------------------------*/
15179+
15180+static int net1080_reset(struct usbnet *dev)
15181+{
15182+ u16 usbctl, status, ttl;
15183+ u16 vp;
15184+ int retval;
15185+
15186+ // nc_dump_registers(dev);
15187+
15188+ if ((retval = nc_register_read(dev, REG_STATUS, &vp)) < 0) {
15189+ netdev_dbg(dev->net, "can't read %s-%s status: %d\n",
15190+ dev->udev->bus->bus_name, dev->udev->devpath, retval);
15191+ goto done;
15192+ }
15193+ status = vp;
15194+ nc_dump_status(dev, status);
15195+
15196+ if ((retval = nc_register_read(dev, REG_USBCTL, &vp)) < 0) {
15197+ netdev_dbg(dev->net, "can't read USBCTL, %d\n", retval);
15198+ goto done;
15199+ }
15200+ usbctl = vp;
15201+ nc_dump_usbctl(dev, usbctl);
15202+
15203+ nc_register_write(dev, REG_USBCTL,
15204+ USBCTL_FLUSH_THIS | USBCTL_FLUSH_OTHER);
15205+
15206+ if ((retval = nc_register_read(dev, REG_TTL, &vp)) < 0) {
15207+ netdev_dbg(dev->net, "can't read TTL, %d\n", retval);
15208+ goto done;
15209+ }
15210+ ttl = vp;
15211+ // nc_dump_ttl(dev, ttl);
15212+
15213+ nc_register_write(dev, REG_TTL,
15214+ MK_TTL(NC_READ_TTL_MS, TTL_OTHER(ttl)) );
15215+ netdev_dbg(dev->net, "assigned TTL, %d ms\n", NC_READ_TTL_MS);
15216+
15217+ netif_info(dev, link, dev->net, "port %c, peer %sconnected\n",
15218+ (status & STATUS_PORT_A) ? 'A' : 'B',
15219+ (status & STATUS_CONN_OTHER) ? "" : "dis");
15220+ retval = 0;
15221+
15222+done:
15223+ return retval;
15224+}
15225+
15226+static int net1080_check_connect(struct usbnet *dev)
15227+{
15228+ int retval;
15229+ u16 status;
15230+ u16 vp;
15231+
15232+ retval = nc_register_read(dev, REG_STATUS, &vp);
15233+ status = vp;
15234+ if (retval != 0) {
15235+ netdev_dbg(dev->net, "net1080_check_conn read - %d\n", retval);
15236+ return retval;
15237+ }
15238+ if ((status & STATUS_CONN_OTHER) != STATUS_CONN_OTHER)
15239+ return -ENOLINK;
15240+ return 0;
15241+}
15242+
15243+static void nc_ensure_sync(struct usbnet *dev)
15244+{
15245+ if (++dev->frame_errors <= 5)
15246+ return;
15247+
15248+ if (usbnet_write_cmd_async(dev, REQUEST_REGISTER,
15249+ USB_DIR_OUT | USB_TYPE_VENDOR |
15250+ USB_RECIP_DEVICE,
15251+ USBCTL_FLUSH_THIS |
15252+ USBCTL_FLUSH_OTHER,
15253+ REG_USBCTL, NULL, 0))
15254+ return;
15255+
15256+ netif_dbg(dev, rx_err, dev->net,
15257+ "flush net1080; too many framing errors\n");
15258+ dev->frame_errors = 0;
15259+}
15260+
15261+static int net1080_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
15262+{
15263+ struct nc_header *header;
15264+ struct nc_trailer *trailer;
15265+ u16 hdr_len, packet_len;
15266+
15267+ /* This check is no longer done by usbnet */
15268+ if (skb->len < dev->net->hard_header_len)
15269+ return 0;
15270+
15271+ if (!(skb->len & 0x01)) {
15272+ netdev_dbg(dev->net, "rx framesize %d range %d..%d mtu %d\n",
15273+ skb->len, dev->net->hard_header_len, dev->hard_mtu,
15274+ dev->net->mtu);
15275+ dev->net->stats.rx_frame_errors++;
15276+ nc_ensure_sync(dev);
15277+ return 0;
15278+ }
15279+
15280+ header = (struct nc_header *) skb->data;
15281+ hdr_len = le16_to_cpup(&header->hdr_len);
15282+ packet_len = le16_to_cpup(&header->packet_len);
15283+ if (FRAMED_SIZE(packet_len) > NC_MAX_PACKET) {
15284+ dev->net->stats.rx_frame_errors++;
15285+ netdev_dbg(dev->net, "packet too big, %d\n", packet_len);
15286+ nc_ensure_sync(dev);
15287+ return 0;
15288+ } else if (hdr_len < MIN_HEADER) {
15289+ dev->net->stats.rx_frame_errors++;
15290+ netdev_dbg(dev->net, "header too short, %d\n", hdr_len);
15291+ nc_ensure_sync(dev);
15292+ return 0;
15293+ } else if (hdr_len > MIN_HEADER) {
15294+ // out of band data for us?
15295+ netdev_dbg(dev->net, "header OOB, %d bytes\n", hdr_len - MIN_HEADER);
15296+ nc_ensure_sync(dev);
15297+ // switch (vendor/product ids) { ... }
15298+ }
15299+ skb_pull(skb, hdr_len);
15300+
15301+ trailer = (struct nc_trailer *)
15302+ (skb->data + skb->len - sizeof *trailer);
15303+ skb_trim(skb, skb->len - sizeof *trailer);
15304+
15305+ if ((packet_len & 0x01) == 0) {
15306+ if (skb->data [packet_len] != PAD_BYTE) {
15307+ dev->net->stats.rx_frame_errors++;
15308+ netdev_dbg(dev->net, "bad pad\n");
15309+ return 0;
15310+ }
15311+ skb_trim(skb, skb->len - 1);
15312+ }
15313+ if (skb->len != packet_len) {
15314+ dev->net->stats.rx_frame_errors++;
15315+ netdev_dbg(dev->net, "bad packet len %d (expected %d)\n",
15316+ skb->len, packet_len);
15317+ nc_ensure_sync(dev);
15318+ return 0;
15319+ }
15320+ if (header->packet_id != get_unaligned(&trailer->packet_id)) {
15321+ dev->net->stats.rx_fifo_errors++;
15322+ netdev_dbg(dev->net, "(2+ dropped) rx packet_id mismatch 0x%x 0x%x\n",
15323+ le16_to_cpu(header->packet_id),
15324+ le16_to_cpu(trailer->packet_id));
15325+ return 0;
15326+ }
15327+#if 0
15328+ netdev_dbg(dev->net, "frame <rx h %d p %d id %d\n", header->hdr_len,
15329+ header->packet_len, header->packet_id);
15330+#endif
15331+ dev->frame_errors = 0;
15332+ return 1;
15333+}
15334+
15335+static struct sk_buff *
15336+net1080_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
15337+{
15338+ struct sk_buff *skb2;
15339+ struct nc_header *header = NULL;
15340+ struct nc_trailer *trailer = NULL;
15341+ int padlen = sizeof (struct nc_trailer);
15342+ int len = skb->len;
15343+
15344+ if (!((len + padlen + sizeof (struct nc_header)) & 0x01))
15345+ padlen++;
15346+ if (!skb_cloned(skb)) {
15347+ int headroom = skb_headroom(skb);
15348+ int tailroom = skb_tailroom(skb);
15349+
15350+ if (padlen <= tailroom &&
15351+ sizeof(struct nc_header) <= headroom)
15352+ /* There's enough head and tail room */
15353+ goto encapsulate;
15354+
15355+ if ((sizeof (struct nc_header) + padlen) <
15356+ (headroom + tailroom)) {
15357+ /* There's enough total room, so just readjust */
15358+ skb->data = memmove(skb->head
15359+ + sizeof (struct nc_header),
15360+ skb->data, skb->len);
15361+ skb_set_tail_pointer(skb, len);
15362+ goto encapsulate;
15363+ }
15364+ }
15365+
15366+ /* Create a new skb to use with the correct size */
15367+ skb2 = skb_copy_expand(skb,
15368+ sizeof (struct nc_header),
15369+ padlen,
15370+ flags);
15371+ dev_kfree_skb_any(skb);
15372+ if (!skb2)
15373+ return skb2;
15374+ skb = skb2;
15375+
15376+encapsulate:
15377+ /* header first */
15378+ header = (struct nc_header *) skb_push(skb, sizeof *header);
15379+ header->hdr_len = cpu_to_le16(sizeof (*header));
15380+ header->packet_len = cpu_to_le16(len);
15381+ header->packet_id = cpu_to_le16((u16)dev->xid++);
15382+
15383+ /* maybe pad; then trailer */
15384+ if (!((skb->len + sizeof *trailer) & 0x01))
15385+ *skb_put(skb, 1) = PAD_BYTE;
15386+ trailer = (struct nc_trailer *) skb_put(skb, sizeof *trailer);
15387+ put_unaligned(header->packet_id, &trailer->packet_id);
15388+#if 0
15389+ netdev_dbg(dev->net, "frame >tx h %d p %d id %d\n",
15390+ header->hdr_len, header->packet_len,
15391+ header->packet_id);
15392+#endif
15393+ return skb;
15394+}
15395+
15396+static int net1080_bind(struct usbnet *dev, struct usb_interface *intf)
15397+{
15398+ unsigned extra = sizeof (struct nc_header)
15399+ + 1
15400+ + sizeof (struct nc_trailer);
15401+
15402+ dev->net->hard_header_len += extra;
15403+ dev->rx_urb_size = dev->net->hard_header_len + dev->net->mtu;
15404+ dev->hard_mtu = NC_MAX_PACKET;
15405+ return usbnet_get_endpoints (dev, intf);
15406+}
15407+
15408+static const struct driver_info net1080_info = {
15409+ .description = "NetChip TurboCONNECT",
15410+ .flags = FLAG_POINTTOPOINT | FLAG_FRAMING_NC,
15411+ .bind = net1080_bind,
15412+ .reset = net1080_reset,
15413+ .check_connect = net1080_check_connect,
15414+ .rx_fixup = net1080_rx_fixup,
15415+ .tx_fixup = net1080_tx_fixup,
15416+};
15417+
15418+static const struct usb_device_id products [] = {
15419+{
15420+ USB_DEVICE(0x0525, 0x1080), // NetChip ref design
15421+ .driver_info = (unsigned long) &net1080_info,
15422+}, {
15423+ USB_DEVICE(0x06D0, 0x0622), // Laplink Gold
15424+ .driver_info = (unsigned long) &net1080_info,
15425+},
15426+ { }, // END
15427+};
15428+MODULE_DEVICE_TABLE(usb, products);
15429+
15430+static struct usb_driver net1080_driver = {
15431+ .name = "net1080",
15432+ .id_table = products,
15433+ .probe = usbnet_probe,
15434+ .disconnect = usbnet_disconnect,
15435+ .suspend = usbnet_suspend,
15436+ .resume = usbnet_resume,
15437+ .disable_hub_initiated_lpm = 1,
15438+};
15439+
15440+module_usb_driver(net1080_driver);
15441+
15442+MODULE_AUTHOR("David Brownell");
15443+MODULE_DESCRIPTION("NetChip 1080 based USB Host-to-Host Links");
15444+MODULE_LICENSE("GPL");
15445diff -Naur backports-3.18.1-1.org/drivers/net/usb/pegasus.c backports-3.18.1-1/drivers/net/usb/pegasus.c
15446--- backports-3.18.1-1.org/drivers/net/usb/pegasus.c 1970-01-01 01:00:00.000000000 +0100
15447+++ backports-3.18.1-1/drivers/net/usb/pegasus.c 2014-12-16 18:39:45.000000000 +0100
15448@@ -0,0 +1,1335 @@
15449+/*
15450+ * Copyright (c) 1999-2013 Petko Manolov (petkan@nucleusys.com)
15451+ *
15452+ * This program is free software; you can redistribute it and/or modify
15453+ * it under the terms of the GNU General Public License version 2 as
15454+ * published by the Free Software Foundation.
15455+ *
15456+ * ChangeLog:
15457+ * .... Most of the time spent on reading sources & docs.
15458+ * v0.2.x First official release for the Linux kernel.
15459+ * v0.3.0 Beutified and structured, some bugs fixed.
15460+ * v0.3.x URBifying bulk requests and bugfixing. First relatively
15461+ * stable release. Still can touch device's registers only
15462+ * from top-halves.
15463+ * v0.4.0 Control messages remained unurbified are now URBs.
15464+ * Now we can touch the HW at any time.
15465+ * v0.4.9 Control urbs again use process context to wait. Argh...
15466+ * Some long standing bugs (enable_net_traffic) fixed.
15467+ * Also nasty trick about resubmiting control urb from
15468+ * interrupt context used. Please let me know how it
15469+ * behaves. Pegasus II support added since this version.
15470+ * TODO: suppressing HCD warnings spewage on disconnect.
15471+ * v0.4.13 Ethernet address is now set at probe(), not at open()
15472+ * time as this seems to break dhcpd.
15473+ * v0.5.0 branch to 2.5.x kernels
15474+ * v0.5.1 ethtool support added
15475+ * v0.5.5 rx socket buffers are in a pool and the their allocation
15476+ * is out of the interrupt routine.
15477+ * ...
15478+ * v0.9.3 simplified [get|set]_register(s), async update registers
15479+ * logic revisited, receive skb_pool removed.
15480+ */
15481+
15482+#include <linux/sched.h>
15483+#include <linux/slab.h>
15484+#include <linux/init.h>
15485+#include <linux/delay.h>
15486+#include <linux/netdevice.h>
15487+#include <linux/etherdevice.h>
15488+#include <linux/ethtool.h>
15489+#include <linux/mii.h>
15490+#include <linux/usb.h>
15491+#include <linux/module.h>
15492+#include <asm/byteorder.h>
15493+#include <asm/uaccess.h>
15494+#include "pegasus.h"
15495+
15496+/*
15497+ * Version Information
15498+ */
15499+#define DRIVER_VERSION "v0.9.3 (2013/04/25)"
15500+#define DRIVER_AUTHOR "Petko Manolov <petkan@nucleusys.com>"
15501+#define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"
15502+
15503+static const char driver_name[] = "pegasus";
15504+
15505+#undef PEGASUS_WRITE_EEPROM
15506+#define BMSR_MEDIA (BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | \
15507+ BMSR_100FULL | BMSR_ANEGCAPABLE)
15508+
15509+static bool loopback;
15510+static bool mii_mode;
15511+static char *devid;
15512+
15513+static struct usb_eth_dev usb_dev_id[] = {
15514+#define PEGASUS_DEV(pn, vid, pid, flags) \
15515+ {.name = pn, .vendor = vid, .device = pid, .private = flags},
15516+#define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
15517+ PEGASUS_DEV(pn, vid, pid, flags)
15518+#include "pegasus.h"
15519+#undef PEGASUS_DEV
15520+#undef PEGASUS_DEV_CLASS
15521+ {NULL, 0, 0, 0},
15522+ {NULL, 0, 0, 0}
15523+};
15524+
15525+static struct usb_device_id pegasus_ids[] = {
15526+#define PEGASUS_DEV(pn, vid, pid, flags) \
15527+ {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid},
15528+/*
15529+ * The Belkin F8T012xx1 bluetooth adaptor has the same vendor and product
15530+ * IDs as the Belkin F5D5050, so we need to teach the pegasus driver to
15531+ * ignore adaptors belonging to the "Wireless" class 0xE0. For this one
15532+ * case anyway, seeing as the pegasus is for "Wired" adaptors.
15533+ */
15534+#define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
15535+ {.match_flags = (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_CLASS), \
15536+ .idVendor = vid, .idProduct = pid, .bDeviceClass = dclass},
15537+#include "pegasus.h"
15538+#undef PEGASUS_DEV
15539+#undef PEGASUS_DEV_CLASS
15540+ {},
15541+ {}
15542+};
15543+
15544+MODULE_AUTHOR(DRIVER_AUTHOR);
15545+MODULE_DESCRIPTION(DRIVER_DESC);
15546+MODULE_LICENSE("GPL");
15547+module_param(loopback, bool, 0);
15548+module_param(mii_mode, bool, 0);
15549+module_param(devid, charp, 0);
15550+MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");
15551+MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");
15552+MODULE_PARM_DESC(devid, "The format is: 'DEV_name:VendorID:DeviceID:Flags'");
15553+
15554+/* use ethtool to change the level for any given device */
15555+static int msg_level = -1;
15556+module_param(msg_level, int, 0);
15557+MODULE_PARM_DESC(msg_level, "Override default message level");
15558+
15559+MODULE_DEVICE_TABLE(usb, pegasus_ids);
15560+static const struct net_device_ops pegasus_netdev_ops;
15561+
15562+/*****/
15563+
15564+static void async_ctrl_callback(struct urb *urb)
15565+{
15566+ struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
15567+ int status = urb->status;
15568+
15569+ if (status < 0)
15570+ dev_dbg(&urb->dev->dev, "%s failed with %d", __func__, status);
15571+ kfree(req);
15572+ usb_free_urb(urb);
15573+}
15574+
15575+static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
15576+{
15577+ int ret;
15578+
15579+ ret = usb_control_msg(pegasus->usb, usb_rcvctrlpipe(pegasus->usb, 0),
15580+ PEGASUS_REQ_GET_REGS, PEGASUS_REQT_READ, 0,
15581+ indx, data, size, 1000);
15582+ if (ret < 0)
15583+ netif_dbg(pegasus, drv, pegasus->net,
15584+ "%s returned %d\n", __func__, ret);
15585+ return ret;
15586+}
15587+
15588+static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
15589+{
15590+ int ret;
15591+
15592+ ret = usb_control_msg(pegasus->usb, usb_sndctrlpipe(pegasus->usb, 0),
15593+ PEGASUS_REQ_SET_REGS, PEGASUS_REQT_WRITE, 0,
15594+ indx, data, size, 100);
15595+ if (ret < 0)
15596+ netif_dbg(pegasus, drv, pegasus->net,
15597+ "%s returned %d\n", __func__, ret);
15598+ return ret;
15599+}
15600+
15601+static int set_register(pegasus_t *pegasus, __u16 indx, __u8 data)
15602+{
15603+ int ret;
15604+
15605+ ret = usb_control_msg(pegasus->usb, usb_sndctrlpipe(pegasus->usb, 0),
15606+ PEGASUS_REQ_SET_REG, PEGASUS_REQT_WRITE, data,
15607+ indx, &data, 1, 1000);
15608+ if (ret < 0)
15609+ netif_dbg(pegasus, drv, pegasus->net,
15610+ "%s returned %d\n", __func__, ret);
15611+ return ret;
15612+}
15613+
15614+static int update_eth_regs_async(pegasus_t *pegasus)
15615+{
15616+ int ret = -ENOMEM;
15617+ struct urb *async_urb;
15618+ struct usb_ctrlrequest *req;
15619+
15620+ req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
15621+ if (req == NULL)
15622+ return ret;
15623+
15624+ async_urb = usb_alloc_urb(0, GFP_ATOMIC);
15625+ if (async_urb == NULL) {
15626+ kfree(req);
15627+ return ret;
15628+ }
15629+ req->bRequestType = PEGASUS_REQT_WRITE;
15630+ req->bRequest = PEGASUS_REQ_SET_REGS;
15631+ req->wValue = cpu_to_le16(0);
15632+ req->wIndex = cpu_to_le16(EthCtrl0);
15633+ req->wLength = cpu_to_le16(3);
15634+
15635+ usb_fill_control_urb(async_urb, pegasus->usb,
15636+ usb_sndctrlpipe(pegasus->usb, 0), (void *)req,
15637+ pegasus->eth_regs, 3, async_ctrl_callback, req);
15638+
15639+ ret = usb_submit_urb(async_urb, GFP_ATOMIC);
15640+ if (ret) {
15641+ if (ret == -ENODEV)
15642+ netif_device_detach(pegasus->net);
15643+ netif_err(pegasus, drv, pegasus->net,
15644+ "%s returned %d\n", __func__, ret);
15645+ }
15646+ return ret;
15647+}
15648+
15649+static int __mii_op(pegasus_t *p, __u8 phy, __u8 indx, __u16 *regd, __u8 cmd)
15650+{
15651+ int i;
15652+ __u8 data[4] = { phy, 0, 0, indx };
15653+ __le16 regdi;
15654+ int ret = -ETIMEDOUT;
15655+
15656+ if (cmd & PHY_WRITE) {
15657+ __le16 *t = (__le16 *) & data[1];
15658+ *t = cpu_to_le16(*regd);
15659+ }
15660+ set_register(p, PhyCtrl, 0);
15661+ set_registers(p, PhyAddr, sizeof(data), data);
15662+ set_register(p, PhyCtrl, (indx | cmd));
15663+ for (i = 0; i < REG_TIMEOUT; i++) {
15664+ ret = get_registers(p, PhyCtrl, 1, data);
15665+ if (ret < 0)
15666+ goto fail;
15667+ if (data[0] & PHY_DONE)
15668+ break;
15669+ }
15670+ if (i >= REG_TIMEOUT)
15671+ goto fail;
15672+ if (cmd & PHY_READ) {
15673+ ret = get_registers(p, PhyData, 2, &regdi);
15674+ *regd = le16_to_cpu(regdi);
15675+ return ret;
15676+ }
15677+ return 0;
15678+fail:
15679+ netif_dbg(p, drv, p->net, "%s failed\n", __func__);
15680+ return ret;
15681+}
15682+
15683+/* Returns non-negative int on success, error on failure */
15684+static int read_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd)
15685+{
15686+ return __mii_op(pegasus, phy, indx, regd, PHY_READ);
15687+}
15688+
15689+/* Returns zero on success, error on failure */
15690+static int write_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd)
15691+{
15692+ return __mii_op(pegasus, phy, indx, regd, PHY_WRITE);
15693+}
15694+
15695+static int mdio_read(struct net_device *dev, int phy_id, int loc)
15696+{
15697+ pegasus_t *pegasus = netdev_priv(dev);
15698+ u16 res;
15699+
15700+ read_mii_word(pegasus, phy_id, loc, &res);
15701+ return (int)res;
15702+}
15703+
15704+static void mdio_write(struct net_device *dev, int phy_id, int loc, int val)
15705+{
15706+ pegasus_t *pegasus = netdev_priv(dev);
15707+ u16 data = val;
15708+
15709+ write_mii_word(pegasus, phy_id, loc, &data);
15710+}
15711+
15712+static int read_eprom_word(pegasus_t *pegasus, __u8 index, __u16 *retdata)
15713+{
15714+ int i;
15715+ __u8 tmp;
15716+ __le16 retdatai;
15717+ int ret;
15718+
15719+ set_register(pegasus, EpromCtrl, 0);
15720+ set_register(pegasus, EpromOffset, index);
15721+ set_register(pegasus, EpromCtrl, EPROM_READ);
15722+
15723+ for (i = 0; i < REG_TIMEOUT; i++) {
15724+ ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
15725+ if (tmp & EPROM_DONE)
15726+ break;
15727+ if (ret == -ESHUTDOWN)
15728+ goto fail;
15729+ }
15730+ if (i >= REG_TIMEOUT)
15731+ goto fail;
15732+
15733+ ret = get_registers(pegasus, EpromData, 2, &retdatai);
15734+ *retdata = le16_to_cpu(retdatai);
15735+ return ret;
15736+
15737+fail:
15738+ netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
15739+ return -ETIMEDOUT;
15740+}
15741+
15742+#ifdef PEGASUS_WRITE_EEPROM
15743+static inline void enable_eprom_write(pegasus_t *pegasus)
15744+{
15745+ __u8 tmp;
15746+
15747+ get_registers(pegasus, EthCtrl2, 1, &tmp);
15748+ set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE);
15749+}
15750+
15751+static inline void disable_eprom_write(pegasus_t *pegasus)
15752+{
15753+ __u8 tmp;
15754+
15755+ get_registers(pegasus, EthCtrl2, 1, &tmp);
15756+ set_register(pegasus, EpromCtrl, 0);
15757+ set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE);
15758+}
15759+
15760+static int write_eprom_word(pegasus_t *pegasus, __u8 index, __u16 data)
15761+{
15762+ int i;
15763+ __u8 tmp, d[4] = { 0x3f, 0, 0, EPROM_WRITE };
15764+ int ret;
15765+ __le16 le_data = cpu_to_le16(data);
15766+
15767+ set_registers(pegasus, EpromOffset, 4, d);
15768+ enable_eprom_write(pegasus);
15769+ set_register(pegasus, EpromOffset, index);
15770+ set_registers(pegasus, EpromData, 2, &le_data);
15771+ set_register(pegasus, EpromCtrl, EPROM_WRITE);
15772+
15773+ for (i = 0; i < REG_TIMEOUT; i++) {
15774+ ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
15775+ if (ret == -ESHUTDOWN)
15776+ goto fail;
15777+ if (tmp & EPROM_DONE)
15778+ break;
15779+ }
15780+ disable_eprom_write(pegasus);
15781+ if (i >= REG_TIMEOUT)
15782+ goto fail;
15783+
15784+ return ret;
15785+
15786+fail:
15787+ netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__);
15788+ return -ETIMEDOUT;
15789+}
15790+#endif /* PEGASUS_WRITE_EEPROM */
15791+
15792+static inline void get_node_id(pegasus_t *pegasus, __u8 *id)
15793+{
15794+ int i;
15795+ __u16 w16;
15796+
15797+ for (i = 0; i < 3; i++) {
15798+ read_eprom_word(pegasus, i, &w16);
15799+ ((__le16 *) id)[i] = cpu_to_le16(w16);
15800+ }
15801+}
15802+
15803+static void set_ethernet_addr(pegasus_t *pegasus)
15804+{
15805+ __u8 node_id[6];
15806+
15807+ if (pegasus->features & PEGASUS_II) {
15808+ get_registers(pegasus, 0x10, sizeof(node_id), node_id);
15809+ } else {
15810+ get_node_id(pegasus, node_id);
15811+ set_registers(pegasus, EthID, sizeof(node_id), node_id);
15812+ }
15813+ memcpy(pegasus->net->dev_addr, node_id, sizeof(node_id));
15814+}
15815+
15816+static inline int reset_mac(pegasus_t *pegasus)
15817+{
15818+ __u8 data = 0x8;
15819+ int i;
15820+
15821+ set_register(pegasus, EthCtrl1, data);
15822+ for (i = 0; i < REG_TIMEOUT; i++) {
15823+ get_registers(pegasus, EthCtrl1, 1, &data);
15824+ if (~data & 0x08) {
15825+ if (loopback)
15826+ break;
15827+ if (mii_mode && (pegasus->features & HAS_HOME_PNA))
15828+ set_register(pegasus, Gpio1, 0x34);
15829+ else
15830+ set_register(pegasus, Gpio1, 0x26);
15831+ set_register(pegasus, Gpio0, pegasus->features);
15832+ set_register(pegasus, Gpio0, DEFAULT_GPIO_SET);
15833+ break;
15834+ }
15835+ }
15836+ if (i == REG_TIMEOUT)
15837+ return -ETIMEDOUT;
15838+
15839+ if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
15840+ usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
15841+ set_register(pegasus, Gpio0, 0x24);
15842+ set_register(pegasus, Gpio0, 0x26);
15843+ }
15844+ if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) {
15845+ __u16 auxmode;
15846+ read_mii_word(pegasus, 3, 0x1b, &auxmode);
15847+ auxmode |= 4;
15848+ write_mii_word(pegasus, 3, 0x1b, &auxmode);
15849+ }
15850+
15851+ return 0;
15852+}
15853+
15854+static int enable_net_traffic(struct net_device *dev, struct usb_device *usb)
15855+{
15856+ __u16 linkpart;
15857+ __u8 data[4];
15858+ pegasus_t *pegasus = netdev_priv(dev);
15859+ int ret;
15860+
15861+ read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
15862+ data[0] = 0xc9;
15863+ data[1] = 0;
15864+ if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL))
15865+ data[1] |= 0x20; /* set full duplex */
15866+ if (linkpart & (ADVERTISE_100FULL | ADVERTISE_100HALF))
15867+ data[1] |= 0x10; /* set 100 Mbps */
15868+ if (mii_mode)
15869+ data[1] = 0;
15870+ data[2] = loopback ? 0x09 : 0x01;
15871+
15872+ memcpy(pegasus->eth_regs, data, sizeof(data));
15873+ ret = set_registers(pegasus, EthCtrl0, 3, data);
15874+
15875+ if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
15876+ usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS2 ||
15877+ usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
15878+ u16 auxmode;
15879+ read_mii_word(pegasus, 0, 0x1b, &auxmode);
15880+ auxmode |= 4;
15881+ write_mii_word(pegasus, 0, 0x1b, &auxmode);
15882+ }
15883+
15884+ return ret;
15885+}
15886+
15887+static void read_bulk_callback(struct urb *urb)
15888+{
15889+ pegasus_t *pegasus = urb->context;
15890+ struct net_device *net;
15891+ int rx_status, count = urb->actual_length;
15892+ int status = urb->status;
15893+ u8 *buf = urb->transfer_buffer;
15894+ __u16 pkt_len;
15895+
15896+ if (!pegasus)
15897+ return;
15898+
15899+ net = pegasus->net;
15900+ if (!netif_device_present(net) || !netif_running(net))
15901+ return;
15902+
15903+ switch (status) {
15904+ case 0:
15905+ break;
15906+ case -ETIME:
15907+ netif_dbg(pegasus, rx_err, net, "reset MAC\n");
15908+ pegasus->flags &= ~PEGASUS_RX_BUSY;
15909+ break;
15910+ case -EPIPE: /* stall, or disconnect from TT */
15911+ /* FIXME schedule work to clear the halt */
15912+ netif_warn(pegasus, rx_err, net, "no rx stall recovery\n");
15913+ return;
15914+ case -ENOENT:
15915+ case -ECONNRESET:
15916+ case -ESHUTDOWN:
15917+ netif_dbg(pegasus, ifdown, net, "rx unlink, %d\n", status);
15918+ return;
15919+ default:
15920+ netif_dbg(pegasus, rx_err, net, "RX status %d\n", status);
15921+ goto goon;
15922+ }
15923+
15924+ if (!count || count < 4)
15925+ goto goon;
15926+
15927+ rx_status = buf[count - 2];
15928+ if (rx_status & 0x1e) {
15929+ netif_dbg(pegasus, rx_err, net,
15930+ "RX packet error %x\n", rx_status);
15931+ pegasus->stats.rx_errors++;
15932+ if (rx_status & 0x06) /* long or runt */
15933+ pegasus->stats.rx_length_errors++;
15934+ if (rx_status & 0x08)
15935+ pegasus->stats.rx_crc_errors++;
15936+ if (rx_status & 0x10) /* extra bits */
15937+ pegasus->stats.rx_frame_errors++;
15938+ goto goon;
15939+ }
15940+ if (pegasus->chip == 0x8513) {
15941+ pkt_len = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
15942+ pkt_len &= 0x0fff;
15943+ pegasus->rx_skb->data += 2;
15944+ } else {
15945+ pkt_len = buf[count - 3] << 8;
15946+ pkt_len += buf[count - 4];
15947+ pkt_len &= 0xfff;
15948+ pkt_len -= 8;
15949+ }
15950+
15951+ /*
15952+ * If the packet is unreasonably long, quietly drop it rather than
15953+ * kernel panicing by calling skb_put.
15954+ */
15955+ if (pkt_len > PEGASUS_MTU)
15956+ goto goon;
15957+
15958+ /*
15959+ * at this point we are sure pegasus->rx_skb != NULL
15960+ * so we go ahead and pass up the packet.
15961+ */
15962+ skb_put(pegasus->rx_skb, pkt_len);
15963+ pegasus->rx_skb->protocol = eth_type_trans(pegasus->rx_skb, net);
15964+ netif_rx(pegasus->rx_skb);
15965+ pegasus->stats.rx_packets++;
15966+ pegasus->stats.rx_bytes += pkt_len;
15967+
15968+ if (pegasus->flags & PEGASUS_UNPLUG)
15969+ return;
15970+
15971+ pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net, PEGASUS_MTU,
15972+ GFP_ATOMIC);
15973+
15974+ if (pegasus->rx_skb == NULL)
15975+ goto tl_sched;
15976+goon:
15977+ usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
15978+ usb_rcvbulkpipe(pegasus->usb, 1),
15979+ pegasus->rx_skb->data, PEGASUS_MTU + 8,
15980+ read_bulk_callback, pegasus);
15981+ rx_status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
15982+ if (rx_status == -ENODEV)
15983+ netif_device_detach(pegasus->net);
15984+ else if (rx_status) {
15985+ pegasus->flags |= PEGASUS_RX_URB_FAIL;
15986+ goto tl_sched;
15987+ } else {
15988+ pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
15989+ }
15990+
15991+ return;
15992+
15993+tl_sched:
15994+ tasklet_schedule(&pegasus->rx_tl);
15995+}
15996+
15997+static void rx_fixup(unsigned long data)
15998+{
15999+ pegasus_t *pegasus;
16000+ int status;
16001+
16002+ pegasus = (pegasus_t *) data;
16003+ if (pegasus->flags & PEGASUS_UNPLUG)
16004+ return;
16005+
16006+ if (pegasus->flags & PEGASUS_RX_URB_FAIL)
16007+ if (pegasus->rx_skb)
16008+ goto try_again;
16009+ if (pegasus->rx_skb == NULL)
16010+ pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net,
16011+ PEGASUS_MTU,
16012+ GFP_ATOMIC);
16013+ if (pegasus->rx_skb == NULL) {
16014+ netif_warn(pegasus, rx_err, pegasus->net, "low on memory\n");
16015+ tasklet_schedule(&pegasus->rx_tl);
16016+ return;
16017+ }
16018+ usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
16019+ usb_rcvbulkpipe(pegasus->usb, 1),
16020+ pegasus->rx_skb->data, PEGASUS_MTU + 8,
16021+ read_bulk_callback, pegasus);
16022+try_again:
16023+ status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
16024+ if (status == -ENODEV)
16025+ netif_device_detach(pegasus->net);
16026+ else if (status) {
16027+ pegasus->flags |= PEGASUS_RX_URB_FAIL;
16028+ tasklet_schedule(&pegasus->rx_tl);
16029+ } else {
16030+ pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
16031+ }
16032+}
16033+
16034+static void write_bulk_callback(struct urb *urb)
16035+{
16036+ pegasus_t *pegasus = urb->context;
16037+ struct net_device *net;
16038+ int status = urb->status;
16039+
16040+ if (!pegasus)
16041+ return;
16042+
16043+ net = pegasus->net;
16044+
16045+ if (!netif_device_present(net) || !netif_running(net))
16046+ return;
16047+
16048+ switch (status) {
16049+ case -EPIPE:
16050+ /* FIXME schedule_work() to clear the tx halt */
16051+ netif_stop_queue(net);
16052+ netif_warn(pegasus, tx_err, net, "no tx stall recovery\n");
16053+ return;
16054+ case -ENOENT:
16055+ case -ECONNRESET:
16056+ case -ESHUTDOWN:
16057+ netif_dbg(pegasus, ifdown, net, "tx unlink, %d\n", status);
16058+ return;
16059+ default:
16060+ netif_info(pegasus, tx_err, net, "TX status %d\n", status);
16061+ /* FALL THROUGH */
16062+ case 0:
16063+ break;
16064+ }
16065+
16066+ net->trans_start = jiffies; /* prevent tx timeout */
16067+ netif_wake_queue(net);
16068+}
16069+
16070+static void intr_callback(struct urb *urb)
16071+{
16072+ pegasus_t *pegasus = urb->context;
16073+ struct net_device *net;
16074+ int res, status = urb->status;
16075+
16076+ if (!pegasus)
16077+ return;
16078+ net = pegasus->net;
16079+
16080+ switch (status) {
16081+ case 0:
16082+ break;
16083+ case -ECONNRESET: /* unlink */
16084+ case -ENOENT:
16085+ case -ESHUTDOWN:
16086+ return;
16087+ default:
16088+ /* some Pegasus-I products report LOTS of data
16089+ * toggle errors... avoid log spamming
16090+ */
16091+ netif_dbg(pegasus, timer, net, "intr status %d\n", status);
16092+ }
16093+
16094+ if (urb->actual_length >= 6) {
16095+ u8 *d = urb->transfer_buffer;
16096+
16097+ /* byte 0 == tx_status1, reg 2B */
16098+ if (d[0] & (TX_UNDERRUN|EXCESSIVE_COL
16099+ |LATE_COL|JABBER_TIMEOUT)) {
16100+ pegasus->stats.tx_errors++;
16101+ if (d[0] & TX_UNDERRUN)
16102+ pegasus->stats.tx_fifo_errors++;
16103+ if (d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT))
16104+ pegasus->stats.tx_aborted_errors++;
16105+ if (d[0] & LATE_COL)
16106+ pegasus->stats.tx_window_errors++;
16107+ }
16108+
16109+ /* d[5].LINK_STATUS lies on some adapters.
16110+ * d[0].NO_CARRIER kicks in only with failed TX.
16111+ * ... so monitoring with MII may be safest.
16112+ */
16113+
16114+ /* bytes 3-4 == rx_lostpkt, reg 2E/2F */
16115+ pegasus->stats.rx_missed_errors += ((d[3] & 0x7f) << 8) | d[4];
16116+ }
16117+
16118+ res = usb_submit_urb(urb, GFP_ATOMIC);
16119+ if (res == -ENODEV)
16120+ netif_device_detach(pegasus->net);
16121+ if (res)
16122+ netif_err(pegasus, timer, net,
16123+ "can't resubmit interrupt urb, %d\n", res);
16124+}
16125+
16126+static void pegasus_tx_timeout(struct net_device *net)
16127+{
16128+ pegasus_t *pegasus = netdev_priv(net);
16129+ netif_warn(pegasus, timer, net, "tx timeout\n");
16130+ usb_unlink_urb(pegasus->tx_urb);
16131+ pegasus->stats.tx_errors++;
16132+}
16133+
16134+static netdev_tx_t pegasus_start_xmit(struct sk_buff *skb,
16135+ struct net_device *net)
16136+{
16137+ pegasus_t *pegasus = netdev_priv(net);
16138+ int count = ((skb->len + 2) & 0x3f) ? skb->len + 2 : skb->len + 3;
16139+ int res;
16140+ __u16 l16 = skb->len;
16141+
16142+ netif_stop_queue(net);
16143+
16144+ ((__le16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16);
16145+ skb_copy_from_linear_data(skb, pegasus->tx_buff + 2, skb->len);
16146+ usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb,
16147+ usb_sndbulkpipe(pegasus->usb, 2),
16148+ pegasus->tx_buff, count,
16149+ write_bulk_callback, pegasus);
16150+ if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) {
16151+ netif_warn(pegasus, tx_err, net, "fail tx, %d\n", res);
16152+ switch (res) {
16153+ case -EPIPE: /* stall, or disconnect from TT */
16154+ /* cleanup should already have been scheduled */
16155+ break;
16156+ case -ENODEV: /* disconnect() upcoming */
16157+ case -EPERM:
16158+ netif_device_detach(pegasus->net);
16159+ break;
16160+ default:
16161+ pegasus->stats.tx_errors++;
16162+ netif_start_queue(net);
16163+ }
16164+ } else {
16165+ pegasus->stats.tx_packets++;
16166+ pegasus->stats.tx_bytes += skb->len;
16167+ }
16168+ dev_kfree_skb(skb);
16169+
16170+ return NETDEV_TX_OK;
16171+}
16172+
16173+static struct net_device_stats *pegasus_netdev_stats(struct net_device *dev)
16174+{
16175+ return &((pegasus_t *) netdev_priv(dev))->stats;
16176+}
16177+
16178+static inline void disable_net_traffic(pegasus_t *pegasus)
16179+{
16180+ __le16 tmp = cpu_to_le16(0);
16181+
16182+ set_registers(pegasus, EthCtrl0, sizeof(tmp), &tmp);
16183+}
16184+
16185+static inline void get_interrupt_interval(pegasus_t *pegasus)
16186+{
16187+ u16 data;
16188+ u8 interval;
16189+
16190+ read_eprom_word(pegasus, 4, &data);
16191+ interval = data >> 8;
16192+ if (pegasus->usb->speed != USB_SPEED_HIGH) {
16193+ if (interval < 0x80) {
16194+ netif_info(pegasus, timer, pegasus->net,
16195+ "intr interval changed from %ums to %ums\n",
16196+ interval, 0x80);
16197+ interval = 0x80;
16198+ data = (data & 0x00FF) | ((u16)interval << 8);
16199+#ifdef PEGASUS_WRITE_EEPROM
16200+ write_eprom_word(pegasus, 4, data);
16201+#endif
16202+ }
16203+ }
16204+ pegasus->intr_interval = interval;
16205+}
16206+
16207+static void set_carrier(struct net_device *net)
16208+{
16209+ pegasus_t *pegasus = netdev_priv(net);
16210+ u16 tmp;
16211+
16212+ if (read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp))
16213+ return;
16214+
16215+ if (tmp & BMSR_LSTATUS)
16216+ netif_carrier_on(net);
16217+ else
16218+ netif_carrier_off(net);
16219+}
16220+
16221+static void free_all_urbs(pegasus_t *pegasus)
16222+{
16223+ usb_free_urb(pegasus->intr_urb);
16224+ usb_free_urb(pegasus->tx_urb);
16225+ usb_free_urb(pegasus->rx_urb);
16226+}
16227+
16228+static void unlink_all_urbs(pegasus_t *pegasus)
16229+{
16230+ usb_kill_urb(pegasus->intr_urb);
16231+ usb_kill_urb(pegasus->tx_urb);
16232+ usb_kill_urb(pegasus->rx_urb);
16233+}
16234+
16235+static int alloc_urbs(pegasus_t *pegasus)
16236+{
16237+ int res = -ENOMEM;
16238+
16239+ pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
16240+ if (!pegasus->rx_urb) {
16241+ return res;
16242+ }
16243+ pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
16244+ if (!pegasus->tx_urb) {
16245+ usb_free_urb(pegasus->rx_urb);
16246+ return res;
16247+ }
16248+ pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
16249+ if (!pegasus->intr_urb) {
16250+ usb_free_urb(pegasus->tx_urb);
16251+ usb_free_urb(pegasus->rx_urb);
16252+ return res;
16253+ }
16254+
16255+ return 0;
16256+}
16257+
16258+static int pegasus_open(struct net_device *net)
16259+{
16260+ pegasus_t *pegasus = netdev_priv(net);
16261+ int res=-ENOMEM;
16262+
16263+ if (pegasus->rx_skb == NULL)
16264+ pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net,
16265+ PEGASUS_MTU,
16266+ GFP_KERNEL);
16267+ if (!pegasus->rx_skb)
16268+ goto exit;
16269+
16270+ res = set_registers(pegasus, EthID, 6, net->dev_addr);
16271+
16272+ usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
16273+ usb_rcvbulkpipe(pegasus->usb, 1),
16274+ pegasus->rx_skb->data, PEGASUS_MTU + 8,
16275+ read_bulk_callback, pegasus);
16276+ if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) {
16277+ if (res == -ENODEV)
16278+ netif_device_detach(pegasus->net);
16279+ netif_dbg(pegasus, ifup, net, "failed rx_urb, %d\n", res);
16280+ goto exit;
16281+ }
16282+
16283+ usb_fill_int_urb(pegasus->intr_urb, pegasus->usb,
16284+ usb_rcvintpipe(pegasus->usb, 3),
16285+ pegasus->intr_buff, sizeof(pegasus->intr_buff),
16286+ intr_callback, pegasus, pegasus->intr_interval);
16287+ if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL))) {
16288+ if (res == -ENODEV)
16289+ netif_device_detach(pegasus->net);
16290+ netif_dbg(pegasus, ifup, net, "failed intr_urb, %d\n", res);
16291+ usb_kill_urb(pegasus->rx_urb);
16292+ goto exit;
16293+ }
16294+ res = enable_net_traffic(net, pegasus->usb);
16295+ if (res < 0) {
16296+ netif_dbg(pegasus, ifup, net,
16297+ "can't enable_net_traffic() - %d\n", res);
16298+ res = -EIO;
16299+ usb_kill_urb(pegasus->rx_urb);
16300+ usb_kill_urb(pegasus->intr_urb);
16301+ goto exit;
16302+ }
16303+ set_carrier(net);
16304+ netif_start_queue(net);
16305+ netif_dbg(pegasus, ifup, net, "open\n");
16306+ res = 0;
16307+exit:
16308+ return res;
16309+}
16310+
16311+static int pegasus_close(struct net_device *net)
16312+{
16313+ pegasus_t *pegasus = netdev_priv(net);
16314+
16315+ netif_stop_queue(net);
16316+ if (!(pegasus->flags & PEGASUS_UNPLUG))
16317+ disable_net_traffic(pegasus);
16318+ tasklet_kill(&pegasus->rx_tl);
16319+ unlink_all_urbs(pegasus);
16320+
16321+ return 0;
16322+}
16323+
16324+static void pegasus_get_drvinfo(struct net_device *dev,
16325+ struct ethtool_drvinfo *info)
16326+{
16327+ pegasus_t *pegasus = netdev_priv(dev);
16328+
16329+ strlcpy(info->driver, driver_name, sizeof(info->driver));
16330+ strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
16331+ usb_make_path(pegasus->usb, info->bus_info, sizeof(info->bus_info));
16332+}
16333+
16334+/* also handles three patterns of some kind in hardware */
16335+#define WOL_SUPPORTED (WAKE_MAGIC|WAKE_PHY)
16336+
16337+static void
16338+pegasus_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
16339+{
16340+ pegasus_t *pegasus = netdev_priv(dev);
16341+
16342+ wol->supported = WAKE_MAGIC | WAKE_PHY;
16343+ wol->wolopts = pegasus->wolopts;
16344+}
16345+
16346+static int
16347+pegasus_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
16348+{
16349+ pegasus_t *pegasus = netdev_priv(dev);
16350+ u8 reg78 = 0x04;
16351+ int ret;
16352+
16353+ if (wol->wolopts & ~WOL_SUPPORTED)
16354+ return -EINVAL;
16355+
16356+ if (wol->wolopts & WAKE_MAGIC)
16357+ reg78 |= 0x80;
16358+ if (wol->wolopts & WAKE_PHY)
16359+ reg78 |= 0x40;
16360+ /* FIXME this 0x10 bit still needs to get set in the chip... */
16361+ if (wol->wolopts)
16362+ pegasus->eth_regs[0] |= 0x10;
16363+ else
16364+ pegasus->eth_regs[0] &= ~0x10;
16365+ pegasus->wolopts = wol->wolopts;
16366+
16367+ ret = set_register(pegasus, WakeupControl, reg78);
16368+ if (!ret)
16369+ ret = device_set_wakeup_enable(&pegasus->usb->dev,
16370+ wol->wolopts);
16371+ return ret;
16372+}
16373+
16374+static inline void pegasus_reset_wol(struct net_device *dev)
16375+{
16376+ struct ethtool_wolinfo wol;
16377+
16378+ memset(&wol, 0, sizeof wol);
16379+ (void) pegasus_set_wol(dev, &wol);
16380+}
16381+
16382+static int
16383+pegasus_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
16384+{
16385+ pegasus_t *pegasus;
16386+
16387+ pegasus = netdev_priv(dev);
16388+ mii_ethtool_gset(&pegasus->mii, ecmd);
16389+ return 0;
16390+}
16391+
16392+static int
16393+pegasus_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
16394+{
16395+ pegasus_t *pegasus = netdev_priv(dev);
16396+ return mii_ethtool_sset(&pegasus->mii, ecmd);
16397+}
16398+
16399+static int pegasus_nway_reset(struct net_device *dev)
16400+{
16401+ pegasus_t *pegasus = netdev_priv(dev);
16402+ return mii_nway_restart(&pegasus->mii);
16403+}
16404+
16405+static u32 pegasus_get_link(struct net_device *dev)
16406+{
16407+ pegasus_t *pegasus = netdev_priv(dev);
16408+ return mii_link_ok(&pegasus->mii);
16409+}
16410+
16411+static u32 pegasus_get_msglevel(struct net_device *dev)
16412+{
16413+ pegasus_t *pegasus = netdev_priv(dev);
16414+ return pegasus->msg_enable;
16415+}
16416+
16417+static void pegasus_set_msglevel(struct net_device *dev, u32 v)
16418+{
16419+ pegasus_t *pegasus = netdev_priv(dev);
16420+ pegasus->msg_enable = v;
16421+}
16422+
16423+static const struct ethtool_ops ops = {
16424+ .get_drvinfo = pegasus_get_drvinfo,
16425+ .get_settings = pegasus_get_settings,
16426+ .set_settings = pegasus_set_settings,
16427+ .nway_reset = pegasus_nway_reset,
16428+ .get_link = pegasus_get_link,
16429+ .get_msglevel = pegasus_get_msglevel,
16430+ .set_msglevel = pegasus_set_msglevel,
16431+ .get_wol = pegasus_get_wol,
16432+ .set_wol = pegasus_set_wol,
16433+};
16434+
16435+static int pegasus_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
16436+{
16437+ __u16 *data = (__u16 *) &rq->ifr_ifru;
16438+ pegasus_t *pegasus = netdev_priv(net);
16439+ int res;
16440+
16441+ switch (cmd) {
16442+ case SIOCDEVPRIVATE:
16443+ data[0] = pegasus->phy;
16444+ case SIOCDEVPRIVATE + 1:
16445+ read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
16446+ res = 0;
16447+ break;
16448+ case SIOCDEVPRIVATE + 2:
16449+ if (!capable(CAP_NET_ADMIN))
16450+ return -EPERM;
16451+ write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, &data[2]);
16452+ res = 0;
16453+ break;
16454+ default:
16455+ res = -EOPNOTSUPP;
16456+ }
16457+ return res;
16458+}
16459+
16460+static void pegasus_set_multicast(struct net_device *net)
16461+{
16462+ pegasus_t *pegasus = netdev_priv(net);
16463+
16464+ if (net->flags & IFF_PROMISC) {
16465+ pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
16466+ netif_info(pegasus, link, net, "Promiscuous mode enabled\n");
16467+ } else if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI)) {
16468+ pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
16469+ pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
16470+ netif_dbg(pegasus, link, net, "set allmulti\n");
16471+ } else {
16472+ pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
16473+ pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
16474+ }
16475+ update_eth_regs_async(pegasus);
16476+}
16477+
16478+static __u8 mii_phy_probe(pegasus_t *pegasus)
16479+{
16480+ int i;
16481+ __u16 tmp;
16482+
16483+ for (i = 0; i < 32; i++) {
16484+ read_mii_word(pegasus, i, MII_BMSR, &tmp);
16485+ if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0)
16486+ continue;
16487+ else
16488+ return i;
16489+ }
16490+
16491+ return 0xff;
16492+}
16493+
16494+static inline void setup_pegasus_II(pegasus_t *pegasus)
16495+{
16496+ __u8 data = 0xa5;
16497+
16498+ set_register(pegasus, Reg1d, 0);
16499+ set_register(pegasus, Reg7b, 1);
16500+ mdelay(100);
16501+ if ((pegasus->features & HAS_HOME_PNA) && mii_mode)
16502+ set_register(pegasus, Reg7b, 0);
16503+ else
16504+ set_register(pegasus, Reg7b, 2);
16505+
16506+ set_register(pegasus, 0x83, data);
16507+ get_registers(pegasus, 0x83, 1, &data);
16508+
16509+ if (data == 0xa5)
16510+ pegasus->chip = 0x8513;
16511+ else
16512+ pegasus->chip = 0;
16513+
16514+ set_register(pegasus, 0x80, 0xc0);
16515+ set_register(pegasus, 0x83, 0xff);
16516+ set_register(pegasus, 0x84, 0x01);
16517+
16518+ if (pegasus->features & HAS_HOME_PNA && mii_mode)
16519+ set_register(pegasus, Reg81, 6);
16520+ else
16521+ set_register(pegasus, Reg81, 2);
16522+}
16523+
16524+
16525+static int pegasus_count;
16526+static struct workqueue_struct *pegasus_workqueue;
16527+#define CARRIER_CHECK_DELAY (2 * HZ)
16528+
16529+static void check_carrier(struct work_struct *work)
16530+{
16531+ pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work);
16532+ set_carrier(pegasus->net);
16533+ if (!(pegasus->flags & PEGASUS_UNPLUG)) {
16534+ queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
16535+ CARRIER_CHECK_DELAY);
16536+ }
16537+}
16538+
16539+static int pegasus_blacklisted(struct usb_device *udev)
16540+{
16541+ struct usb_device_descriptor *udd = &udev->descriptor;
16542+
16543+ /* Special quirk to keep the driver from handling the Belkin Bluetooth
16544+ * dongle which happens to have the same ID.
16545+ */
16546+ if ((udd->idVendor == cpu_to_le16(VENDOR_BELKIN)) &&
16547+ (udd->idProduct == cpu_to_le16(0x0121)) &&
16548+ (udd->bDeviceClass == USB_CLASS_WIRELESS_CONTROLLER) &&
16549+ (udd->bDeviceProtocol == 1))
16550+ return 1;
16551+
16552+ return 0;
16553+}
16554+
16555+/* we rely on probe() and remove() being serialized so we
16556+ * don't need extra locking on pegasus_count.
16557+ */
16558+static void pegasus_dec_workqueue(void)
16559+{
16560+ pegasus_count--;
16561+ if (pegasus_count == 0) {
16562+ destroy_workqueue(pegasus_workqueue);
16563+ pegasus_workqueue = NULL;
16564+ }
16565+}
16566+
16567+static int pegasus_probe(struct usb_interface *intf,
16568+ const struct usb_device_id *id)
16569+{
16570+ struct usb_device *dev = interface_to_usbdev(intf);
16571+ struct net_device *net;
16572+ pegasus_t *pegasus;
16573+ int dev_index = id - pegasus_ids;
16574+ int res = -ENOMEM;
16575+
16576+ if (pegasus_blacklisted(dev))
16577+ return -ENODEV;
16578+
16579+ if (pegasus_count == 0) {
16580+ pegasus_workqueue = create_singlethread_workqueue("pegasus");
16581+ if (!pegasus_workqueue)
16582+ return -ENOMEM;
16583+ }
16584+ pegasus_count++;
16585+
16586+ net = alloc_etherdev(sizeof(struct pegasus));
16587+ if (!net)
16588+ goto out;
16589+
16590+ pegasus = netdev_priv(net);
16591+ pegasus->dev_index = dev_index;
16592+
16593+ res = alloc_urbs(pegasus);
16594+ if (res < 0) {
16595+ dev_err(&intf->dev, "can't allocate %s\n", "urbs");
16596+ goto out1;
16597+ }
16598+
16599+ tasklet_init(&pegasus->rx_tl, rx_fixup, (unsigned long) pegasus);
16600+
16601+ INIT_DELAYED_WORK(&pegasus->carrier_check, check_carrier);
16602+
16603+ pegasus->intf = intf;
16604+ pegasus->usb = dev;
16605+ pegasus->net = net;
16606+
16607+
16608+ net->watchdog_timeo = PEGASUS_TX_TIMEOUT;
16609+ net->netdev_ops = &pegasus_netdev_ops;
16610+ net->ethtool_ops = &ops;
16611+ pegasus->mii.dev = net;
16612+ pegasus->mii.mdio_read = mdio_read;
16613+ pegasus->mii.mdio_write = mdio_write;
16614+ pegasus->mii.phy_id_mask = 0x1f;
16615+ pegasus->mii.reg_num_mask = 0x1f;
16616+ pegasus->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
16617+ | NETIF_MSG_PROBE | NETIF_MSG_LINK);
16618+
16619+ pegasus->features = usb_dev_id[dev_index].private;
16620+ get_interrupt_interval(pegasus);
16621+ if (reset_mac(pegasus)) {
16622+ dev_err(&intf->dev, "can't reset MAC\n");
16623+ res = -EIO;
16624+ goto out2;
16625+ }
16626+ set_ethernet_addr(pegasus);
16627+ if (pegasus->features & PEGASUS_II) {
16628+ dev_info(&intf->dev, "setup Pegasus II specific registers\n");
16629+ setup_pegasus_II(pegasus);
16630+ }
16631+ pegasus->phy = mii_phy_probe(pegasus);
16632+ if (pegasus->phy == 0xff) {
16633+ dev_warn(&intf->dev, "can't locate MII phy, using default\n");
16634+ pegasus->phy = 1;
16635+ }
16636+ pegasus->mii.phy_id = pegasus->phy;
16637+ usb_set_intfdata(intf, pegasus);
16638+ SET_NETDEV_DEV(net, &intf->dev);
16639+ pegasus_reset_wol(net);
16640+ res = register_netdev(net);
16641+ if (res)
16642+ goto out3;
16643+ queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
16644+ CARRIER_CHECK_DELAY);
16645+ dev_info(&intf->dev, "%s, %s, %pM\n", net->name,
16646+ usb_dev_id[dev_index].name, net->dev_addr);
16647+ return 0;
16648+
16649+out3:
16650+ usb_set_intfdata(intf, NULL);
16651+out2:
16652+ free_all_urbs(pegasus);
16653+out1:
16654+ free_netdev(net);
16655+out:
16656+ pegasus_dec_workqueue();
16657+ return res;
16658+}
16659+
16660+static void pegasus_disconnect(struct usb_interface *intf)
16661+{
16662+ struct pegasus *pegasus = usb_get_intfdata(intf);
16663+
16664+ usb_set_intfdata(intf, NULL);
16665+ if (!pegasus) {
16666+ dev_dbg(&intf->dev, "unregistering non-bound device?\n");
16667+ return;
16668+ }
16669+
16670+ pegasus->flags |= PEGASUS_UNPLUG;
16671+ cancel_delayed_work(&pegasus->carrier_check);
16672+ unregister_netdev(pegasus->net);
16673+ unlink_all_urbs(pegasus);
16674+ free_all_urbs(pegasus);
16675+ if (pegasus->rx_skb != NULL) {
16676+ dev_kfree_skb(pegasus->rx_skb);
16677+ pegasus->rx_skb = NULL;
16678+ }
16679+ free_netdev(pegasus->net);
16680+ pegasus_dec_workqueue();
16681+}
16682+
16683+static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
16684+{
16685+ struct pegasus *pegasus = usb_get_intfdata(intf);
16686+
16687+ netif_device_detach(pegasus->net);
16688+ cancel_delayed_work(&pegasus->carrier_check);
16689+ if (netif_running(pegasus->net)) {
16690+ usb_kill_urb(pegasus->rx_urb);
16691+ usb_kill_urb(pegasus->intr_urb);
16692+ }
16693+ return 0;
16694+}
16695+
16696+static int pegasus_resume(struct usb_interface *intf)
16697+{
16698+ struct pegasus *pegasus = usb_get_intfdata(intf);
16699+
16700+ netif_device_attach(pegasus->net);
16701+ if (netif_running(pegasus->net)) {
16702+ pegasus->rx_urb->status = 0;
16703+ pegasus->rx_urb->actual_length = 0;
16704+ read_bulk_callback(pegasus->rx_urb);
16705+
16706+ pegasus->intr_urb->status = 0;
16707+ pegasus->intr_urb->actual_length = 0;
16708+ intr_callback(pegasus->intr_urb);
16709+ }
16710+ queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check,
16711+ CARRIER_CHECK_DELAY);
16712+ return 0;
16713+}
16714+
16715+static const struct net_device_ops pegasus_netdev_ops = {
16716+ .ndo_open = pegasus_open,
16717+ .ndo_stop = pegasus_close,
16718+ .ndo_do_ioctl = pegasus_ioctl,
16719+ .ndo_start_xmit = pegasus_start_xmit,
16720+ .ndo_set_rx_mode = pegasus_set_multicast,
16721+ .ndo_get_stats = pegasus_netdev_stats,
16722+ .ndo_tx_timeout = pegasus_tx_timeout,
16723+ .ndo_change_mtu = eth_change_mtu,
16724+ .ndo_set_mac_address = eth_mac_addr,
16725+ .ndo_validate_addr = eth_validate_addr,
16726+};
16727+
16728+static struct usb_driver pegasus_driver = {
16729+ .name = driver_name,
16730+ .probe = pegasus_probe,
16731+ .disconnect = pegasus_disconnect,
16732+ .id_table = pegasus_ids,
16733+ .suspend = pegasus_suspend,
16734+ .resume = pegasus_resume,
16735+ .disable_hub_initiated_lpm = 1,
16736+};
16737+
16738+static void __init parse_id(char *id)
16739+{
16740+ unsigned int vendor_id = 0, device_id = 0, flags = 0, i = 0;
16741+ char *token, *name = NULL;
16742+
16743+ if ((token = strsep(&id, ":")) != NULL)
16744+ name = token;
16745+ /* name now points to a null terminated string*/
16746+ if ((token = strsep(&id, ":")) != NULL)
16747+ vendor_id = simple_strtoul(token, NULL, 16);
16748+ if ((token = strsep(&id, ":")) != NULL)
16749+ device_id = simple_strtoul(token, NULL, 16);
16750+ flags = simple_strtoul(id, NULL, 16);
16751+ pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n",
16752+ driver_name, name, vendor_id, device_id, flags);
16753+
16754+ if (vendor_id > 0x10000 || vendor_id == 0)
16755+ return;
16756+ if (device_id > 0x10000 || device_id == 0)
16757+ return;
16758+
16759+ for (i = 0; usb_dev_id[i].name; i++);
16760+ usb_dev_id[i].name = name;
16761+ usb_dev_id[i].vendor = vendor_id;
16762+ usb_dev_id[i].device = device_id;
16763+ usb_dev_id[i].private = flags;
16764+ pegasus_ids[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
16765+ pegasus_ids[i].idVendor = vendor_id;
16766+ pegasus_ids[i].idProduct = device_id;
16767+}
16768+
16769+static int __init pegasus_init(void)
16770+{
16771+ pr_info("%s: %s, " DRIVER_DESC "\n", driver_name, DRIVER_VERSION);
16772+ if (devid)
16773+ parse_id(devid);
16774+ return usb_register(&pegasus_driver);
16775+}
16776+
16777+static void __exit pegasus_exit(void)
16778+{
16779+ usb_deregister(&pegasus_driver);
16780+}
16781+
16782+module_init(pegasus_init);
16783+module_exit(pegasus_exit);
16784diff -Naur backports-3.18.1-1.org/drivers/net/usb/pegasus.h backports-3.18.1-1/drivers/net/usb/pegasus.h
16785--- backports-3.18.1-1.org/drivers/net/usb/pegasus.h 1970-01-01 01:00:00.000000000 +0100
16786+++ backports-3.18.1-1/drivers/net/usb/pegasus.h 2014-12-16 18:39:45.000000000 +0100
16787@@ -0,0 +1,308 @@
16788+/*
16789+ * Copyright (c) 1999-2013 Petko Manolov (petkan@nucleusys.com)
16790+ *
16791+ * This program is free software; you can redistribute it and/or modify
16792+ * it under the terms of the GNU General Public License version 2 as published
16793+ * by the Free Software Foundation.
16794+ */
16795+
16796+
16797+#ifndef PEGASUS_DEV
16798+
16799+#define PEGASUS_II 0x80000000
16800+#define HAS_HOME_PNA 0x40000000
16801+
16802+#define PEGASUS_MTU 1536
16803+
16804+#define EPROM_WRITE 0x01
16805+#define EPROM_READ 0x02
16806+#define EPROM_DONE 0x04
16807+#define EPROM_WR_ENABLE 0x10
16808+#define EPROM_LOAD 0x20
16809+
16810+#define PHY_DONE 0x80
16811+#define PHY_READ 0x40
16812+#define PHY_WRITE 0x20
16813+#define DEFAULT_GPIO_RESET 0x24
16814+#define DEFAULT_GPIO_SET 0x26
16815+
16816+#define PEGASUS_PRESENT 0x00000001
16817+#define PEGASUS_TX_BUSY 0x00000004
16818+#define PEGASUS_RX_BUSY 0x00000008
16819+#define CTRL_URB_RUNNING 0x00000010
16820+#define CTRL_URB_SLEEP 0x00000020
16821+#define PEGASUS_UNPLUG 0x00000040
16822+#define PEGASUS_RX_URB_FAIL 0x00000080
16823+
16824+#define RX_MULTICAST 2
16825+#define RX_PROMISCUOUS 4
16826+
16827+#define REG_TIMEOUT (HZ)
16828+#define PEGASUS_TX_TIMEOUT (HZ*10)
16829+
16830+#define TX_UNDERRUN 0x80
16831+#define EXCESSIVE_COL 0x40
16832+#define LATE_COL 0x20
16833+#define NO_CARRIER 0x10
16834+#define LOSS_CARRIER 0x08
16835+#define JABBER_TIMEOUT 0x04
16836+
16837+#define LINK_STATUS 0x01
16838+
16839+#define PEGASUS_REQT_READ 0xc0
16840+#define PEGASUS_REQT_WRITE 0x40
16841+#define PEGASUS_REQ_GET_REGS 0xf0
16842+#define PEGASUS_REQ_SET_REGS 0xf1
16843+#define PEGASUS_REQ_SET_REG PEGASUS_REQ_SET_REGS
16844+
16845+enum pegasus_registers {
16846+ EthCtrl0 = 0,
16847+ EthCtrl1 = 1,
16848+ EthCtrl2 = 2,
16849+ EthID = 0x10,
16850+ Reg1d = 0x1d,
16851+ EpromOffset = 0x20,
16852+ EpromData = 0x21, /* 0x21 low, 0x22 high byte */
16853+ EpromCtrl = 0x23,
16854+ PhyAddr = 0x25,
16855+ PhyData = 0x26, /* 0x26 low, 0x27 high byte */
16856+ PhyCtrl = 0x28,
16857+ UsbStst = 0x2a,
16858+ EthTxStat0 = 0x2b,
16859+ EthTxStat1 = 0x2c,
16860+ EthRxStat = 0x2d,
16861+ WakeupControl = 0x78,
16862+ Reg7b = 0x7b,
16863+ Gpio0 = 0x7e,
16864+ Gpio1 = 0x7f,
16865+ Reg81 = 0x81,
16866+};
16867+
16868+
16869+typedef struct pegasus {
16870+ struct usb_device *usb;
16871+ struct usb_interface *intf;
16872+ struct net_device *net;
16873+ struct net_device_stats stats;
16874+ struct mii_if_info mii;
16875+ unsigned flags;
16876+ unsigned features;
16877+ u32 msg_enable;
16878+ u32 wolopts;
16879+ int dev_index;
16880+ int intr_interval;
16881+ struct tasklet_struct rx_tl;
16882+ struct delayed_work carrier_check;
16883+ struct urb *rx_urb, *tx_urb, *intr_urb;
16884+ struct sk_buff *rx_skb;
16885+ int chip;
16886+ unsigned char intr_buff[8];
16887+ __u8 tx_buff[PEGASUS_MTU];
16888+ __u8 eth_regs[4];
16889+ __u8 phy;
16890+ __u8 gpio_res;
16891+} pegasus_t;
16892+
16893+
16894+struct usb_eth_dev {
16895+ char *name;
16896+ __u16 vendor;
16897+ __u16 device;
16898+ __u32 private; /* LSB is gpio reset value */
16899+};
16900+
16901+#define VENDOR_3COM 0x0506
16902+#define VENDOR_ABOCOM 0x07b8
16903+#define VENDOR_ACCTON 0x083a
16904+#define VENDOR_ADMTEK 0x07a6
16905+#define VENDOR_AEILAB 0x3334
16906+#define VENDOR_ALLIEDTEL 0x07c9
16907+#define VENDOR_ATEN 0x0557
16908+#define VENDOR_BELKIN 0x050d
16909+#define VENDOR_BILLIONTON 0x08dd
16910+#define VENDOR_COMPAQ 0x049f
16911+#define VENDOR_COREGA 0x07aa
16912+#define VENDOR_DLINK 0x2001
16913+#define VENDOR_ELCON 0x0db7
16914+#define VENDOR_ELECOM 0x056e
16915+#define VENDOR_ELSA 0x05cc
16916+#define VENDOR_GIGABYTE 0x1044
16917+#define VENDOR_HAWKING 0x0e66
16918+#define VENDOR_HP 0x03f0
16919+#define VENDOR_IODATA 0x04bb
16920+#define VENDOR_KINGSTON 0x0951
16921+#define VENDOR_LANEED 0x056e
16922+#define VENDOR_LINKSYS 0x066b
16923+#define VENDOR_LINKSYS2 0x077b
16924+#define VENDOR_MELCO 0x0411
16925+#define VENDOR_MICROSOFT 0x045e
16926+#define VENDOR_MOBILITY 0x1342
16927+#define VENDOR_NETGEAR 0x0846
16928+#define VENDOR_OCT 0x0b39
16929+#define VENDOR_SMARTBRIDGES 0x08d1
16930+#define VENDOR_SMC 0x0707
16931+#define VENDOR_SOHOWARE 0x15e8
16932+#define VENDOR_SIEMENS 0x067c
16933+
16934+
16935+#else /* PEGASUS_DEV */
16936+
16937+PEGASUS_DEV("3Com USB Ethernet 3C460B", VENDOR_3COM, 0x4601,
16938+ DEFAULT_GPIO_RESET | PEGASUS_II)
16939+PEGASUS_DEV("ATEN USB Ethernet UC-110T", VENDOR_ATEN, 0x2007,
16940+ DEFAULT_GPIO_RESET | PEGASUS_II)
16941+PEGASUS_DEV("USB HPNA/Ethernet", VENDOR_ABOCOM, 0x110c,
16942+ DEFAULT_GPIO_RESET | PEGASUS_II | HAS_HOME_PNA)
16943+PEGASUS_DEV("USB HPNA/Ethernet", VENDOR_ABOCOM, 0x4104,
16944+ DEFAULT_GPIO_RESET | HAS_HOME_PNA)
16945+PEGASUS_DEV("USB HPNA/Ethernet", VENDOR_ABOCOM, 0x4004,
16946+ DEFAULT_GPIO_RESET | HAS_HOME_PNA)
16947+PEGASUS_DEV("USB HPNA/Ethernet", VENDOR_ABOCOM, 0x4007,
16948+ DEFAULT_GPIO_RESET | HAS_HOME_PNA)
16949+PEGASUS_DEV("USB 10/100 Fast Ethernet", VENDOR_ABOCOM, 0x4102,
16950+ DEFAULT_GPIO_RESET | PEGASUS_II)
16951+PEGASUS_DEV("USB 10/100 Fast Ethernet", VENDOR_ABOCOM, 0x4002,
16952+ DEFAULT_GPIO_RESET)
16953+PEGASUS_DEV("USB 10/100 Fast Ethernet", VENDOR_ABOCOM, 0x400b,
16954+ DEFAULT_GPIO_RESET | PEGASUS_II)
16955+PEGASUS_DEV("USB 10/100 Fast Ethernet", VENDOR_ABOCOM, 0x400c,
16956+ DEFAULT_GPIO_RESET | PEGASUS_II)
16957+PEGASUS_DEV("USB 10/100 Fast Ethernet", VENDOR_ABOCOM, 0xabc1,
16958+ DEFAULT_GPIO_RESET)
16959+PEGASUS_DEV("USB 10/100 Fast Ethernet", VENDOR_ABOCOM, 0x200c,
16960+ DEFAULT_GPIO_RESET | PEGASUS_II)
16961+PEGASUS_DEV("Accton USB 10/100 Ethernet Adapter", VENDOR_ACCTON, 0x1046,
16962+ DEFAULT_GPIO_RESET)
16963+PEGASUS_DEV("SpeedStream USB 10/100 Ethernet", VENDOR_ACCTON, 0x5046,
16964+ DEFAULT_GPIO_RESET | PEGASUS_II)
16965+PEGASUS_DEV("Philips USB 10/100 Ethernet", VENDOR_ACCTON, 0xb004,
16966+ DEFAULT_GPIO_RESET | PEGASUS_II)
16967+PEGASUS_DEV("ADMtek ADM8511 \"Pegasus II\" USB Ethernet",
16968+ VENDOR_ADMTEK, 0x8511,
16969+ DEFAULT_GPIO_RESET | PEGASUS_II | HAS_HOME_PNA)
16970+PEGASUS_DEV("ADMtek ADM8513 \"Pegasus II\" USB Ethernet",
16971+ VENDOR_ADMTEK, 0x8513,
16972+ DEFAULT_GPIO_RESET | PEGASUS_II)
16973+PEGASUS_DEV("ADMtek ADM8515 \"Pegasus II\" USB-2.0 Ethernet",
16974+ VENDOR_ADMTEK, 0x8515,
16975+ DEFAULT_GPIO_RESET | PEGASUS_II)
16976+PEGASUS_DEV("ADMtek AN986 \"Pegasus\" USB Ethernet (evaluation board)",
16977+ VENDOR_ADMTEK, 0x0986,
16978+ DEFAULT_GPIO_RESET | HAS_HOME_PNA)
16979+PEGASUS_DEV("AN986A USB MAC", VENDOR_ADMTEK, 1986,
16980+ DEFAULT_GPIO_RESET | PEGASUS_II)
16981+PEGASUS_DEV("AEI USB Fast Ethernet Adapter", VENDOR_AEILAB, 0x1701,
16982+ DEFAULT_GPIO_RESET | PEGASUS_II)
16983+PEGASUS_DEV("Allied Telesyn Int. AT-USB100", VENDOR_ALLIEDTEL, 0xb100,
16984+ DEFAULT_GPIO_RESET | PEGASUS_II)
16985+/*
16986+ * Distinguish between this Belkin adaptor and the Belkin bluetooth adaptors
16987+ * with the same product IDs by checking the device class too.
16988+ */
16989+PEGASUS_DEV_CLASS("Belkin F5D5050 USB Ethernet", VENDOR_BELKIN, 0x0121, 0x00,
16990+ DEFAULT_GPIO_RESET | PEGASUS_II)
16991+PEGASUS_DEV("Belkin F5U122 10/100 USB Ethernet", VENDOR_BELKIN, 0x0122,
16992+ DEFAULT_GPIO_RESET | PEGASUS_II)
16993+PEGASUS_DEV("Billionton USB-100", VENDOR_BILLIONTON, 0x0986,
16994+ DEFAULT_GPIO_RESET)
16995+PEGASUS_DEV("Billionton USBLP-100", VENDOR_BILLIONTON, 0x0987,
16996+ DEFAULT_GPIO_RESET | HAS_HOME_PNA)
16997+PEGASUS_DEV("iPAQ Networking 10/100 USB", VENDOR_COMPAQ, 0x8511,
16998+ DEFAULT_GPIO_RESET | PEGASUS_II)
16999+PEGASUS_DEV("Billionton USBEL-100", VENDOR_BILLIONTON, 0x0988,
17000+ DEFAULT_GPIO_RESET)
17001+PEGASUS_DEV("Billionton USBE-100", VENDOR_BILLIONTON, 0x8511,
17002+ DEFAULT_GPIO_RESET | PEGASUS_II)
17003+PEGASUS_DEV("Corega FEther USB-TX", VENDOR_COREGA, 0x0004,
17004+ DEFAULT_GPIO_RESET)
17005+PEGASUS_DEV("Corega FEther USB-TXS", VENDOR_COREGA, 0x000d,
17006+ DEFAULT_GPIO_RESET | PEGASUS_II)
17007+PEGASUS_DEV("D-Link DSB-650TX", VENDOR_DLINK, 0x4001,
17008+ DEFAULT_GPIO_RESET)
17009+PEGASUS_DEV("D-Link DSB-650TX", VENDOR_DLINK, 0x4002,
17010+ DEFAULT_GPIO_RESET)
17011+PEGASUS_DEV("D-Link DSB-650TX", VENDOR_DLINK, 0x4102,
17012+ DEFAULT_GPIO_RESET | PEGASUS_II)
17013+PEGASUS_DEV("D-Link DSB-650TX", VENDOR_DLINK, 0x400b,
17014+ DEFAULT_GPIO_RESET | PEGASUS_II)
17015+PEGASUS_DEV("D-Link DSB-650TX", VENDOR_DLINK, 0x200c,
17016+ DEFAULT_GPIO_RESET | PEGASUS_II)
17017+PEGASUS_DEV("D-Link DSB-650TX(PNA)", VENDOR_DLINK, 0x4003,
17018+ DEFAULT_GPIO_RESET | HAS_HOME_PNA)
17019+PEGASUS_DEV("D-Link DSB-650", VENDOR_DLINK, 0xabc1,
17020+ DEFAULT_GPIO_RESET)
17021+PEGASUS_DEV("GOLDPFEIL USB Adapter", VENDOR_ELCON, 0x0002,
17022+ DEFAULT_GPIO_RESET | PEGASUS_II | HAS_HOME_PNA)
17023+PEGASUS_DEV("ELECOM USB Ethernet LD-USB20", VENDOR_ELECOM, 0x4010,
17024+ DEFAULT_GPIO_RESET | PEGASUS_II)
17025+PEGASUS_DEV("EasiDock Ethernet", VENDOR_MOBILITY, 0x0304,
17026+ DEFAULT_GPIO_RESET)
17027+PEGASUS_DEV("Elsa Micolink USB2Ethernet", VENDOR_ELSA, 0x3000,
17028+ DEFAULT_GPIO_RESET)
17029+PEGASUS_DEV("GIGABYTE GN-BR402W Wireless Router", VENDOR_GIGABYTE, 0x8002,
17030+ DEFAULT_GPIO_RESET)
17031+PEGASUS_DEV("Hawking UF100 10/100 Ethernet", VENDOR_HAWKING, 0x400c,
17032+ DEFAULT_GPIO_RESET | PEGASUS_II)
17033+PEGASUS_DEV("HP hn210c Ethernet USB", VENDOR_HP, 0x811c,
17034+ DEFAULT_GPIO_RESET | PEGASUS_II)
17035+PEGASUS_DEV("IO DATA USB ET/TX", VENDOR_IODATA, 0x0904,
17036+ DEFAULT_GPIO_RESET)
17037+PEGASUS_DEV("IO DATA USB ET/TX-S", VENDOR_IODATA, 0x0913,
17038+ DEFAULT_GPIO_RESET | PEGASUS_II)
17039+PEGASUS_DEV("IO DATA USB ETX-US2", VENDOR_IODATA, 0x093a,
17040+ DEFAULT_GPIO_RESET | PEGASUS_II)
17041+PEGASUS_DEV("Kingston KNU101TX Ethernet", VENDOR_KINGSTON, 0x000a,
17042+ DEFAULT_GPIO_RESET)
17043+PEGASUS_DEV("LANEED USB Ethernet LD-USB/TX", VENDOR_LANEED, 0x4002,
17044+ DEFAULT_GPIO_RESET)
17045+PEGASUS_DEV("LANEED USB Ethernet LD-USBL/TX", VENDOR_LANEED, 0x4005,
17046+ DEFAULT_GPIO_RESET | PEGASUS_II)
17047+PEGASUS_DEV("LANEED USB Ethernet LD-USB/TX", VENDOR_LANEED, 0x400b,
17048+ DEFAULT_GPIO_RESET | PEGASUS_II)
17049+PEGASUS_DEV("LANEED USB Ethernet LD-USB/T", VENDOR_LANEED, 0xabc1,
17050+ DEFAULT_GPIO_RESET)
17051+PEGASUS_DEV("LANEED USB Ethernet LD-USB/TX", VENDOR_LANEED, 0x200c,
17052+ DEFAULT_GPIO_RESET | PEGASUS_II)
17053+PEGASUS_DEV("Linksys USB10TX", VENDOR_LINKSYS, 0x2202,
17054+ DEFAULT_GPIO_RESET)
17055+PEGASUS_DEV("Linksys USB100TX", VENDOR_LINKSYS, 0x2203,
17056+ DEFAULT_GPIO_RESET)
17057+PEGASUS_DEV("Linksys USB100TX", VENDOR_LINKSYS, 0x2204,
17058+ DEFAULT_GPIO_RESET | HAS_HOME_PNA)
17059+PEGASUS_DEV("Linksys USB10T Ethernet Adapter", VENDOR_LINKSYS, 0x2206,
17060+ DEFAULT_GPIO_RESET | PEGASUS_II)
17061+PEGASUS_DEV("Linksys USBVPN1", VENDOR_LINKSYS2, 0x08b4,
17062+ DEFAULT_GPIO_RESET)
17063+PEGASUS_DEV("Linksys USB USB100TX", VENDOR_LINKSYS, 0x400b,
17064+ DEFAULT_GPIO_RESET | PEGASUS_II)
17065+PEGASUS_DEV("Linksys USB10TX", VENDOR_LINKSYS, 0x200c,
17066+ DEFAULT_GPIO_RESET | PEGASUS_II)
17067+PEGASUS_DEV("MELCO/BUFFALO LUA-TX", VENDOR_MELCO, 0x0001,
17068+ DEFAULT_GPIO_RESET)
17069+PEGASUS_DEV("MELCO/BUFFALO LUA-TX", VENDOR_MELCO, 0x0005,
17070+ DEFAULT_GPIO_RESET)
17071+PEGASUS_DEV("MELCO/BUFFALO LUA2-TX", VENDOR_MELCO, 0x0009,
17072+ DEFAULT_GPIO_RESET | PEGASUS_II)
17073+PEGASUS_DEV("Microsoft MN-110", VENDOR_MICROSOFT, 0x007a,
17074+ DEFAULT_GPIO_RESET | PEGASUS_II)
17075+PEGASUS_DEV("NETGEAR FA101", VENDOR_NETGEAR, 0x1020,
17076+ DEFAULT_GPIO_RESET | PEGASUS_II)
17077+PEGASUS_DEV("OCT Inc.", VENDOR_OCT, 0x0109,
17078+ DEFAULT_GPIO_RESET | PEGASUS_II)
17079+PEGASUS_DEV("OCT USB TO Ethernet", VENDOR_OCT, 0x0901,
17080+ DEFAULT_GPIO_RESET | PEGASUS_II)
17081+PEGASUS_DEV("smartNIC 2 PnP Adapter", VENDOR_SMARTBRIDGES, 0x0003,
17082+ DEFAULT_GPIO_RESET | PEGASUS_II)
17083+PEGASUS_DEV("SMC 202 USB Ethernet", VENDOR_SMC, 0x0200,
17084+ DEFAULT_GPIO_RESET)
17085+PEGASUS_DEV("SMC 2206 USB Ethernet", VENDOR_SMC, 0x0201,
17086+ DEFAULT_GPIO_RESET | PEGASUS_II)
17087+PEGASUS_DEV("SOHOware NUB100 Ethernet", VENDOR_SOHOWARE, 0x9100,
17088+ DEFAULT_GPIO_RESET)
17089+PEGASUS_DEV("SOHOware NUB110 Ethernet", VENDOR_SOHOWARE, 0x9110,
17090+ DEFAULT_GPIO_RESET | PEGASUS_II)
17091+PEGASUS_DEV("SpeedStream USB 10/100 Ethernet", VENDOR_SIEMENS, 0x1001,
17092+ DEFAULT_GPIO_RESET | PEGASUS_II)
17093+
17094+
17095+#endif /* PEGASUS_DEV */
17096diff -Naur backports-3.18.1-1.org/drivers/net/usb/plusb.c backports-3.18.1-1/drivers/net/usb/plusb.c
17097--- backports-3.18.1-1.org/drivers/net/usb/plusb.c 1970-01-01 01:00:00.000000000 +0100
17098+++ backports-3.18.1-1/drivers/net/usb/plusb.c 2014-12-16 18:39:45.000000000 +0100
17099@@ -0,0 +1,157 @@
17100+/*
17101+ * PL-2301/2302 USB host-to-host link cables
17102+ * Copyright (C) 2000-2005 by David Brownell
17103+ *
17104+ * This program is free software; you can redistribute it and/or modify
17105+ * it under the terms of the GNU General Public License as published by
17106+ * the Free Software Foundation; either version 2 of the License, or
17107+ * (at your option) any later version.
17108+ *
17109+ * This program is distributed in the hope that it will be useful,
17110+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
17111+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17112+ * GNU General Public License for more details.
17113+ *
17114+ * You should have received a copy of the GNU General Public License
17115+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
17116+ */
17117+
17118+// #define DEBUG // error path messages, extra info
17119+// #define VERBOSE // more; success messages
17120+
17121+#include <linux/module.h>
17122+#include <linux/netdevice.h>
17123+#include <linux/etherdevice.h>
17124+#include <linux/ethtool.h>
17125+#include <linux/workqueue.h>
17126+#include <linux/mii.h>
17127+#include <linux/usb.h>
17128+#include <linux/usb/usbnet.h>
17129+
17130+
17131+/*
17132+ * Prolific PL-2301/PL-2302 driver ... http://www.prolific.com.tw/
17133+ *
17134+ * The protocol and handshaking used here should be bug-compatible
17135+ * with the Linux 2.2 "plusb" driver, by Deti Fliegl.
17136+ *
17137+ * HEADS UP: this handshaking isn't all that robust. This driver
17138+ * gets confused easily if you unplug one end of the cable then
17139+ * try to connect it again; you'll need to restart both ends. The
17140+ * "naplink" software (used by some PlayStation/2 deveopers) does
17141+ * the handshaking much better! Also, sometimes this hardware
17142+ * seems to get wedged under load. Prolific docs are weak, and
17143+ * don't identify differences between PL2301 and PL2302, much less
17144+ * anything to explain the different PL2302 versions observed.
17145+ *
17146+ * NOTE: pl2501 has several modes, including pl2301 and pl2302
17147+ * compatibility. Some docs suggest the difference between 2301
17148+ * and 2302 is only to make MS-Windows use a different driver...
17149+ *
17150+ * pl25a1 glue based on patch from Tony Gibbs. Prolific "docs" on
17151+ * this chip are as usual incomplete about what control messages
17152+ * are supported.
17153+ */
17154+
17155+/*
17156+ * Bits 0-4 can be used for software handshaking; they're set from
17157+ * one end, cleared from the other, "read" with the interrupt byte.
17158+ */
17159+#define PL_S_EN (1<<7) /* (feature only) suspend enable */
17160+/* reserved bit -- rx ready (6) ? */
17161+#define PL_TX_READY (1<<5) /* (interrupt only) transmit ready */
17162+#define PL_RESET_OUT (1<<4) /* reset output pipe */
17163+#define PL_RESET_IN (1<<3) /* reset input pipe */
17164+#define PL_TX_C (1<<2) /* transmission complete */
17165+#define PL_TX_REQ (1<<1) /* transmission received */
17166+#define PL_PEER_E (1<<0) /* peer exists */
17167+
17168+static inline int
17169+pl_vendor_req(struct usbnet *dev, u8 req, u8 val, u8 index)
17170+{
17171+ return usbnet_read_cmd(dev, req,
17172+ USB_DIR_IN | USB_TYPE_VENDOR |
17173+ USB_RECIP_DEVICE,
17174+ val, index, NULL, 0);
17175+}
17176+
17177+static inline int
17178+pl_clear_QuickLink_features(struct usbnet *dev, int val)
17179+{
17180+ return pl_vendor_req(dev, 1, (u8) val, 0);
17181+}
17182+
17183+static inline int
17184+pl_set_QuickLink_features(struct usbnet *dev, int val)
17185+{
17186+ return pl_vendor_req(dev, 3, (u8) val, 0);
17187+}
17188+
17189+static int pl_reset(struct usbnet *dev)
17190+{
17191+ int status;
17192+
17193+ /* some units seem to need this reset, others reject it utterly.
17194+ * FIXME be more like "naplink" or windows drivers.
17195+ */
17196+ status = pl_set_QuickLink_features(dev,
17197+ PL_S_EN|PL_RESET_OUT|PL_RESET_IN|PL_PEER_E);
17198+ if (status != 0 && netif_msg_probe(dev))
17199+ netif_dbg(dev, link, dev->net, "pl_reset --> %d\n", status);
17200+ return 0;
17201+}
17202+
17203+static const struct driver_info prolific_info = {
17204+ .description = "Prolific PL-2301/PL-2302/PL-25A1",
17205+ .flags = FLAG_POINTTOPOINT | FLAG_NO_SETINT,
17206+ /* some PL-2302 versions seem to fail usb_set_interface() */
17207+ .reset = pl_reset,
17208+};
17209+
17210+
17211+/*-------------------------------------------------------------------------*/
17212+
17213+/*
17214+ * Proilific's name won't normally be on the cables, and
17215+ * may not be on the device.
17216+ */
17217+
17218+static const struct usb_device_id products [] = {
17219+
17220+/* full speed cables */
17221+{
17222+ USB_DEVICE(0x067b, 0x0000), // PL-2301
17223+ .driver_info = (unsigned long) &prolific_info,
17224+}, {
17225+ USB_DEVICE(0x067b, 0x0001), // PL-2302
17226+ .driver_info = (unsigned long) &prolific_info,
17227+},
17228+
17229+/* high speed cables */
17230+{
17231+ USB_DEVICE(0x067b, 0x25a1), /* PL-25A1, no eeprom */
17232+ .driver_info = (unsigned long) &prolific_info,
17233+}, {
17234+ USB_DEVICE(0x050d, 0x258a), /* Belkin F5U258/F5U279 (PL-25A1) */
17235+ .driver_info = (unsigned long) &prolific_info,
17236+},
17237+
17238+ { }, // END
17239+};
17240+MODULE_DEVICE_TABLE(usb, products);
17241+
17242+static struct usb_driver plusb_driver = {
17243+ .name = "plusb",
17244+ .id_table = products,
17245+ .probe = usbnet_probe,
17246+ .disconnect = usbnet_disconnect,
17247+ .suspend = usbnet_suspend,
17248+ .resume = usbnet_resume,
17249+ .disable_hub_initiated_lpm = 1,
17250+};
17251+
17252+module_usb_driver(plusb_driver);
17253+
17254+MODULE_AUTHOR("David Brownell");
17255+MODULE_DESCRIPTION("Prolific PL-2301/2302/25A1 USB Host to Host Link Driver");
17256+MODULE_LICENSE("GPL");
17257diff -Naur backports-3.18.1-1.org/drivers/net/usb/r8152.c backports-3.18.1-1/drivers/net/usb/r8152.c
17258--- backports-3.18.1-1.org/drivers/net/usb/r8152.c 1970-01-01 01:00:00.000000000 +0100
17259+++ backports-3.18.1-1/drivers/net/usb/r8152.c 2015-01-03 13:42:25.000000000 +0100
17260@@ -0,0 +1,3913 @@
17261+/*
17262+ * Copyright (c) 2014 Realtek Semiconductor Corp. All rights reserved.
17263+ *
17264+ * This program is free software; you can redistribute it and/or
17265+ * modify it under the terms of the GNU General Public License
17266+ * version 2 as published by the Free Software Foundation.
17267+ *
17268+ */
17269+
17270+#include <linux/signal.h>
17271+#include <linux/slab.h>
17272+#include <linux/module.h>
17273+#include <linux/netdevice.h>
17274+#include <linux/etherdevice.h>
17275+#include <linux/mii.h>
17276+#include <linux/ethtool.h>
17277+#include <linux/usb.h>
17278+#include <linux/crc32.h>
17279+#include <linux/if_vlan.h>
17280+#include <linux/uaccess.h>
17281+#include <linux/list.h>
17282+#include <linux/ip.h>
17283+#include <linux/ipv6.h>
17284+#include <net/ip6_checksum.h>
17285+#include <uapi/linux/mdio.h>
17286+#include <linux/mdio.h>
17287+
17288+/* Version Information */
17289+#define DRIVER_VERSION "v1.07.0 (2014/10/09)"
17290+#define DRIVER_AUTHOR "Realtek linux nic maintainers <nic_swsd@realtek.com>"
17291+#define DRIVER_DESC "Realtek RTL8152/RTL8153 Based USB Ethernet Adapters"
17292+#define MODULENAME "r8152"
17293+
17294+#define R8152_PHY_ID 32
17295+
17296+#define PLA_IDR 0xc000
17297+#define PLA_RCR 0xc010
17298+#define PLA_RMS 0xc016
17299+#define PLA_RXFIFO_CTRL0 0xc0a0
17300+#define PLA_RXFIFO_CTRL1 0xc0a4
17301+#define PLA_RXFIFO_CTRL2 0xc0a8
17302+#define PLA_FMC 0xc0b4
17303+#define PLA_CFG_WOL 0xc0b6
17304+#define PLA_TEREDO_CFG 0xc0bc
17305+#define PLA_MAR 0xcd00
17306+#define PLA_BACKUP 0xd000
17307+#define PAL_BDC_CR 0xd1a0
17308+#define PLA_TEREDO_TIMER 0xd2cc
17309+#define PLA_REALWOW_TIMER 0xd2e8
17310+#define PLA_LEDSEL 0xdd90
17311+#define PLA_LED_FEATURE 0xdd92
17312+#define PLA_PHYAR 0xde00
17313+#define PLA_BOOT_CTRL 0xe004
17314+#define PLA_GPHY_INTR_IMR 0xe022
17315+#define PLA_EEE_CR 0xe040
17316+#define PLA_EEEP_CR 0xe080
17317+#define PLA_MAC_PWR_CTRL 0xe0c0
17318+#define PLA_MAC_PWR_CTRL2 0xe0ca
17319+#define PLA_MAC_PWR_CTRL3 0xe0cc
17320+#define PLA_MAC_PWR_CTRL4 0xe0ce
17321+#define PLA_WDT6_CTRL 0xe428
17322+#define PLA_TCR0 0xe610
17323+#define PLA_TCR1 0xe612
17324+#define PLA_MTPS 0xe615
17325+#define PLA_TXFIFO_CTRL 0xe618
17326+#define PLA_RSTTALLY 0xe800
17327+#define PLA_CR 0xe813
17328+#define PLA_CRWECR 0xe81c
17329+#define PLA_CONFIG12 0xe81e /* CONFIG1, CONFIG2 */
17330+#define PLA_CONFIG34 0xe820 /* CONFIG3, CONFIG4 */
17331+#define PLA_CONFIG5 0xe822
17332+#define PLA_PHY_PWR 0xe84c
17333+#define PLA_OOB_CTRL 0xe84f
17334+#define PLA_CPCR 0xe854
17335+#define PLA_MISC_0 0xe858
17336+#define PLA_MISC_1 0xe85a
17337+#define PLA_OCP_GPHY_BASE 0xe86c
17338+#define PLA_TALLYCNT 0xe890
17339+#define PLA_SFF_STS_7 0xe8de
17340+#define PLA_PHYSTATUS 0xe908
17341+#define PLA_BP_BA 0xfc26
17342+#define PLA_BP_0 0xfc28
17343+#define PLA_BP_1 0xfc2a
17344+#define PLA_BP_2 0xfc2c
17345+#define PLA_BP_3 0xfc2e
17346+#define PLA_BP_4 0xfc30
17347+#define PLA_BP_5 0xfc32
17348+#define PLA_BP_6 0xfc34
17349+#define PLA_BP_7 0xfc36
17350+#define PLA_BP_EN 0xfc38
17351+
17352+#define USB_U2P3_CTRL 0xb460
17353+#define USB_DEV_STAT 0xb808
17354+#define USB_USB_CTRL 0xd406
17355+#define USB_PHY_CTRL 0xd408
17356+#define USB_TX_AGG 0xd40a
17357+#define USB_RX_BUF_TH 0xd40c
17358+#define USB_USB_TIMER 0xd428
17359+#define USB_RX_EARLY_AGG 0xd42c
17360+#define USB_PM_CTRL_STATUS 0xd432
17361+#define USB_TX_DMA 0xd434
17362+#define USB_TOLERANCE 0xd490
17363+#define USB_LPM_CTRL 0xd41a
17364+#define USB_UPS_CTRL 0xd800
17365+#define USB_MISC_0 0xd81a
17366+#define USB_POWER_CUT 0xd80a
17367+#define USB_AFE_CTRL2 0xd824
17368+#define USB_WDT11_CTRL 0xe43c
17369+#define USB_BP_BA 0xfc26
17370+#define USB_BP_0 0xfc28
17371+#define USB_BP_1 0xfc2a
17372+#define USB_BP_2 0xfc2c
17373+#define USB_BP_3 0xfc2e
17374+#define USB_BP_4 0xfc30
17375+#define USB_BP_5 0xfc32
17376+#define USB_BP_6 0xfc34
17377+#define USB_BP_7 0xfc36
17378+#define USB_BP_EN 0xfc38
17379+
17380+/* OCP Registers */
17381+#define OCP_ALDPS_CONFIG 0x2010
17382+#define OCP_EEE_CONFIG1 0x2080
17383+#define OCP_EEE_CONFIG2 0x2092
17384+#define OCP_EEE_CONFIG3 0x2094
17385+#define OCP_BASE_MII 0xa400
17386+#define OCP_EEE_AR 0xa41a
17387+#define OCP_EEE_DATA 0xa41c
17388+#define OCP_PHY_STATUS 0xa420
17389+#define OCP_POWER_CFG 0xa430
17390+#define OCP_EEE_CFG 0xa432
17391+#define OCP_SRAM_ADDR 0xa436
17392+#define OCP_SRAM_DATA 0xa438
17393+#define OCP_DOWN_SPEED 0xa442
17394+#define OCP_EEE_ABLE 0xa5c4
17395+#define OCP_EEE_ADV 0xa5d0
17396+#define OCP_EEE_LPABLE 0xa5d2
17397+#define OCP_ADC_CFG 0xbc06
17398+
17399+/* SRAM Register */
17400+#define SRAM_LPF_CFG 0x8012
17401+#define SRAM_10M_AMP1 0x8080
17402+#define SRAM_10M_AMP2 0x8082
17403+#define SRAM_IMPEDANCE 0x8084
17404+
17405+/* PLA_RCR */
17406+#define RCR_AAP 0x00000001
17407+#define RCR_APM 0x00000002
17408+#define RCR_AM 0x00000004
17409+#define RCR_AB 0x00000008
17410+#define RCR_ACPT_ALL (RCR_AAP | RCR_APM | RCR_AM | RCR_AB)
17411+
17412+/* PLA_RXFIFO_CTRL0 */
17413+#define RXFIFO_THR1_NORMAL 0x00080002
17414+#define RXFIFO_THR1_OOB 0x01800003
17415+
17416+/* PLA_RXFIFO_CTRL1 */
17417+#define RXFIFO_THR2_FULL 0x00000060
17418+#define RXFIFO_THR2_HIGH 0x00000038
17419+#define RXFIFO_THR2_OOB 0x0000004a
17420+#define RXFIFO_THR2_NORMAL 0x00a0
17421+
17422+/* PLA_RXFIFO_CTRL2 */
17423+#define RXFIFO_THR3_FULL 0x00000078
17424+#define RXFIFO_THR3_HIGH 0x00000048
17425+#define RXFIFO_THR3_OOB 0x0000005a
17426+#define RXFIFO_THR3_NORMAL 0x0110
17427+
17428+/* PLA_TXFIFO_CTRL */
17429+#define TXFIFO_THR_NORMAL 0x00400008
17430+#define TXFIFO_THR_NORMAL2 0x01000008
17431+
17432+/* PLA_FMC */
17433+#define FMC_FCR_MCU_EN 0x0001
17434+
17435+/* PLA_EEEP_CR */
17436+#define EEEP_CR_EEEP_TX 0x0002
17437+
17438+/* PLA_WDT6_CTRL */
17439+#define WDT6_SET_MODE 0x0010
17440+
17441+/* PLA_TCR0 */
17442+#define TCR0_TX_EMPTY 0x0800
17443+#define TCR0_AUTO_FIFO 0x0080
17444+
17445+/* PLA_TCR1 */
17446+#define VERSION_MASK 0x7cf0
17447+
17448+/* PLA_MTPS */
17449+#define MTPS_JUMBO (12 * 1024 / 64)
17450+#define MTPS_DEFAULT (6 * 1024 / 64)
17451+
17452+/* PLA_RSTTALLY */
17453+#define TALLY_RESET 0x0001
17454+
17455+/* PLA_CR */
17456+#define CR_RST 0x10
17457+#define CR_RE 0x08
17458+#define CR_TE 0x04
17459+
17460+/* PLA_CRWECR */
17461+#define CRWECR_NORAML 0x00
17462+#define CRWECR_CONFIG 0xc0
17463+
17464+/* PLA_OOB_CTRL */
17465+#define NOW_IS_OOB 0x80
17466+#define TXFIFO_EMPTY 0x20
17467+#define RXFIFO_EMPTY 0x10
17468+#define LINK_LIST_READY 0x02
17469+#define DIS_MCU_CLROOB 0x01
17470+#define FIFO_EMPTY (TXFIFO_EMPTY | RXFIFO_EMPTY)
17471+
17472+/* PLA_MISC_1 */
17473+#define RXDY_GATED_EN 0x0008
17474+
17475+/* PLA_SFF_STS_7 */
17476+#define RE_INIT_LL 0x8000
17477+#define MCU_BORW_EN 0x4000
17478+
17479+/* PLA_CPCR */
17480+#define CPCR_RX_VLAN 0x0040
17481+
17482+/* PLA_CFG_WOL */
17483+#define MAGIC_EN 0x0001
17484+
17485+/* PLA_TEREDO_CFG */
17486+#define TEREDO_SEL 0x8000
17487+#define TEREDO_WAKE_MASK 0x7f00
17488+#define TEREDO_RS_EVENT_MASK 0x00fe
17489+#define OOB_TEREDO_EN 0x0001
17490+
17491+/* PAL_BDC_CR */
17492+#define ALDPS_PROXY_MODE 0x0001
17493+
17494+/* PLA_CONFIG34 */
17495+#define LINK_ON_WAKE_EN 0x0010
17496+#define LINK_OFF_WAKE_EN 0x0008
17497+
17498+/* PLA_CONFIG5 */
17499+#define BWF_EN 0x0040
17500+#define MWF_EN 0x0020
17501+#define UWF_EN 0x0010
17502+#define LAN_WAKE_EN 0x0002
17503+
17504+/* PLA_LED_FEATURE */
17505+#define LED_MODE_MASK 0x0700
17506+
17507+/* PLA_PHY_PWR */
17508+#define TX_10M_IDLE_EN 0x0080
17509+#define PFM_PWM_SWITCH 0x0040
17510+
17511+/* PLA_MAC_PWR_CTRL */
17512+#define D3_CLK_GATED_EN 0x00004000
17513+#define MCU_CLK_RATIO 0x07010f07
17514+#define MCU_CLK_RATIO_MASK 0x0f0f0f0f
17515+#define ALDPS_SPDWN_RATIO 0x0f87
17516+
17517+/* PLA_MAC_PWR_CTRL2 */
17518+#define EEE_SPDWN_RATIO 0x8007
17519+
17520+/* PLA_MAC_PWR_CTRL3 */
17521+#define PKT_AVAIL_SPDWN_EN 0x0100
17522+#define SUSPEND_SPDWN_EN 0x0004
17523+#define U1U2_SPDWN_EN 0x0002
17524+#define L1_SPDWN_EN 0x0001
17525+
17526+/* PLA_MAC_PWR_CTRL4 */
17527+#define PWRSAVE_SPDWN_EN 0x1000
17528+#define RXDV_SPDWN_EN 0x0800
17529+#define TX10MIDLE_EN 0x0100
17530+#define TP100_SPDWN_EN 0x0020
17531+#define TP500_SPDWN_EN 0x0010
17532+#define TP1000_SPDWN_EN 0x0008
17533+#define EEE_SPDWN_EN 0x0001
17534+
17535+/* PLA_GPHY_INTR_IMR */
17536+#define GPHY_STS_MSK 0x0001
17537+#define SPEED_DOWN_MSK 0x0002
17538+#define SPDWN_RXDV_MSK 0x0004
17539+#define SPDWN_LINKCHG_MSK 0x0008
17540+
17541+/* PLA_PHYAR */
17542+#define PHYAR_FLAG 0x80000000
17543+
17544+/* PLA_EEE_CR */
17545+#define EEE_RX_EN 0x0001
17546+#define EEE_TX_EN 0x0002
17547+
17548+/* PLA_BOOT_CTRL */
17549+#define AUTOLOAD_DONE 0x0002
17550+
17551+/* USB_DEV_STAT */
17552+#define STAT_SPEED_MASK 0x0006
17553+#define STAT_SPEED_HIGH 0x0000
17554+#define STAT_SPEED_FULL 0x0002
17555+
17556+/* USB_TX_AGG */
17557+#define TX_AGG_MAX_THRESHOLD 0x03
17558+
17559+/* USB_RX_BUF_TH */
17560+#define RX_THR_SUPPER 0x0c350180
17561+#define RX_THR_HIGH 0x7a120180
17562+#define RX_THR_SLOW 0xffff0180
17563+
17564+/* USB_TX_DMA */
17565+#define TEST_MODE_DISABLE 0x00000001
17566+#define TX_SIZE_ADJUST1 0x00000100
17567+
17568+/* USB_UPS_CTRL */
17569+#define POWER_CUT 0x0100
17570+
17571+/* USB_PM_CTRL_STATUS */
17572+#define RESUME_INDICATE 0x0001
17573+
17574+/* USB_USB_CTRL */
17575+#define RX_AGG_DISABLE 0x0010
17576+
17577+/* USB_U2P3_CTRL */
17578+#define U2P3_ENABLE 0x0001
17579+
17580+/* USB_POWER_CUT */
17581+#define PWR_EN 0x0001
17582+#define PHASE2_EN 0x0008
17583+
17584+/* USB_MISC_0 */
17585+#define PCUT_STATUS 0x0001
17586+
17587+/* USB_RX_EARLY_AGG */
17588+#define EARLY_AGG_SUPPER 0x0e832981
17589+#define EARLY_AGG_HIGH 0x0e837a12
17590+#define EARLY_AGG_SLOW 0x0e83ffff
17591+
17592+/* USB_WDT11_CTRL */
17593+#define TIMER11_EN 0x0001
17594+
17595+/* USB_LPM_CTRL */
17596+#define LPM_TIMER_MASK 0x0c
17597+#define LPM_TIMER_500MS 0x04 /* 500 ms */
17598+#define LPM_TIMER_500US 0x0c /* 500 us */
17599+
17600+/* USB_AFE_CTRL2 */
17601+#define SEN_VAL_MASK 0xf800
17602+#define SEN_VAL_NORMAL 0xa000
17603+#define SEL_RXIDLE 0x0100
17604+
17605+/* OCP_ALDPS_CONFIG */
17606+#define ENPWRSAVE 0x8000
17607+#define ENPDNPS 0x0200
17608+#define LINKENA 0x0100
17609+#define DIS_SDSAVE 0x0010
17610+
17611+/* OCP_PHY_STATUS */
17612+#define PHY_STAT_MASK 0x0007
17613+#define PHY_STAT_LAN_ON 3
17614+#define PHY_STAT_PWRDN 5
17615+
17616+/* OCP_POWER_CFG */
17617+#define EEE_CLKDIV_EN 0x8000
17618+#define EN_ALDPS 0x0004
17619+#define EN_10M_PLLOFF 0x0001
17620+
17621+/* OCP_EEE_CONFIG1 */
17622+#define RG_TXLPI_MSK_HFDUP 0x8000
17623+#define RG_MATCLR_EN 0x4000
17624+#define EEE_10_CAP 0x2000
17625+#define EEE_NWAY_EN 0x1000
17626+#define TX_QUIET_EN 0x0200
17627+#define RX_QUIET_EN 0x0100
17628+#define sd_rise_time_mask 0x0070
17629+#define sd_rise_time(x) (min(x, 7) << 4) /* bit 4 ~ 6 */
17630+#define RG_RXLPI_MSK_HFDUP 0x0008
17631+#define SDFALLTIME 0x0007 /* bit 0 ~ 2 */
17632+
17633+/* OCP_EEE_CONFIG2 */
17634+#define RG_LPIHYS_NUM 0x7000 /* bit 12 ~ 15 */
17635+#define RG_DACQUIET_EN 0x0400
17636+#define RG_LDVQUIET_EN 0x0200
17637+#define RG_CKRSEL 0x0020
17638+#define RG_EEEPRG_EN 0x0010
17639+
17640+/* OCP_EEE_CONFIG3 */
17641+#define fast_snr_mask 0xff80
17642+#define fast_snr(x) (min(x, 0x1ff) << 7) /* bit 7 ~ 15 */
17643+#define RG_LFS_SEL 0x0060 /* bit 6 ~ 5 */
17644+#define MSK_PH 0x0006 /* bit 0 ~ 3 */
17645+
17646+/* OCP_EEE_AR */
17647+/* bit[15:14] function */
17648+#define FUN_ADDR 0x0000
17649+#define FUN_DATA 0x4000
17650+/* bit[4:0] device addr */
17651+
17652+/* OCP_EEE_CFG */
17653+#define CTAP_SHORT_EN 0x0040
17654+#define EEE10_EN 0x0010
17655+
17656+/* OCP_DOWN_SPEED */
17657+#define EN_10M_BGOFF 0x0080
17658+
17659+/* OCP_ADC_CFG */
17660+#define CKADSEL_L 0x0100
17661+#define ADC_EN 0x0080
17662+#define EN_EMI_L 0x0040
17663+
17664+/* SRAM_LPF_CFG */
17665+#define LPF_AUTO_TUNE 0x8000
17666+
17667+/* SRAM_10M_AMP1 */
17668+#define GDAC_IB_UPALL 0x0008
17669+
17670+/* SRAM_10M_AMP2 */
17671+#define AMP_DN 0x0200
17672+
17673+/* SRAM_IMPEDANCE */
17674+#define RX_DRIVING_MASK 0x6000
17675+
17676+enum rtl_register_content {
17677+ _1000bps = 0x10,
17678+ _100bps = 0x08,
17679+ _10bps = 0x04,
17680+ LINK_STATUS = 0x02,
17681+ FULL_DUP = 0x01,
17682+};
17683+
17684+#define RTL8152_MAX_TX 4
17685+#define RTL8152_MAX_RX 10
17686+#define INTBUFSIZE 2
17687+#define CRC_SIZE 4
17688+#define TX_ALIGN 4
17689+#define RX_ALIGN 8
17690+
17691+#define INTR_LINK 0x0004
17692+
17693+#define RTL8152_REQT_READ 0xc0
17694+#define RTL8152_REQT_WRITE 0x40
17695+#define RTL8152_REQ_GET_REGS 0x05
17696+#define RTL8152_REQ_SET_REGS 0x05
17697+
17698+#define BYTE_EN_DWORD 0xff
17699+#define BYTE_EN_WORD 0x33
17700+#define BYTE_EN_BYTE 0x11
17701+#define BYTE_EN_SIX_BYTES 0x3f
17702+#define BYTE_EN_START_MASK 0x0f
17703+#define BYTE_EN_END_MASK 0xf0
17704+
17705+#define RTL8153_MAX_PACKET 9216 /* 9K */
17706+#define RTL8153_MAX_MTU (RTL8153_MAX_PACKET - VLAN_ETH_HLEN - VLAN_HLEN)
17707+#define RTL8152_RMS (VLAN_ETH_FRAME_LEN + VLAN_HLEN)
17708+#define RTL8153_RMS RTL8153_MAX_PACKET
17709+#define RTL8152_TX_TIMEOUT (5 * HZ)
17710+
17711+/* rtl8152 flags */
17712+enum rtl8152_flags {
17713+ RTL8152_UNPLUG = 0,
17714+ RTL8152_SET_RX_MODE,
17715+ WORK_ENABLE,
17716+ RTL8152_LINK_CHG,
17717+ SELECTIVE_SUSPEND,
17718+ PHY_RESET,
17719+ SCHEDULE_TASKLET,
17720+};
17721+
17722+/* Define these values to match your device */
17723+#define VENDOR_ID_REALTEK 0x0bda
17724+#define PRODUCT_ID_RTL8152 0x8152
17725+#define PRODUCT_ID_RTL8153 0x8153
17726+
17727+#define VENDOR_ID_SAMSUNG 0x04e8
17728+#define PRODUCT_ID_SAMSUNG 0xa101
17729+
17730+#define MCU_TYPE_PLA 0x0100
17731+#define MCU_TYPE_USB 0x0000
17732+
17733+#define REALTEK_USB_DEVICE(vend, prod) \
17734+ USB_DEVICE_INTERFACE_CLASS(vend, prod, USB_CLASS_VENDOR_SPEC)
17735+
17736+struct tally_counter {
17737+ __le64 tx_packets;
17738+ __le64 rx_packets;
17739+ __le64 tx_errors;
17740+ __le32 rx_errors;
17741+ __le16 rx_missed;
17742+ __le16 align_errors;
17743+ __le32 tx_one_collision;
17744+ __le32 tx_multi_collision;
17745+ __le64 rx_unicast;
17746+ __le64 rx_broadcast;
17747+ __le32 rx_multicast;
17748+ __le16 tx_aborted;
17749+ __le16 tx_underun;
17750+};
17751+
17752+struct rx_desc {
17753+ __le32 opts1;
17754+#define RX_LEN_MASK 0x7fff
17755+
17756+ __le32 opts2;
17757+#define RD_UDP_CS (1 << 23)
17758+#define RD_TCP_CS (1 << 22)
17759+#define RD_IPV6_CS (1 << 20)
17760+#define RD_IPV4_CS (1 << 19)
17761+
17762+ __le32 opts3;
17763+#define IPF (1 << 23) /* IP checksum fail */
17764+#define UDPF (1 << 22) /* UDP checksum fail */
17765+#define TCPF (1 << 21) /* TCP checksum fail */
17766+#define RX_VLAN_TAG (1 << 16)
17767+
17768+ __le32 opts4;
17769+ __le32 opts5;
17770+ __le32 opts6;
17771+};
17772+
17773+struct tx_desc {
17774+ __le32 opts1;
17775+#define TX_FS (1 << 31) /* First segment of a packet */
17776+#define TX_LS (1 << 30) /* Final segment of a packet */
17777+#define GTSENDV4 (1 << 28)
17778+#define GTSENDV6 (1 << 27)
17779+#define GTTCPHO_SHIFT 18
17780+#define GTTCPHO_MAX 0x7fU
17781+#define TX_LEN_MAX 0x3ffffU
17782+
17783+ __le32 opts2;
17784+#define UDP_CS (1 << 31) /* Calculate UDP/IP checksum */
17785+#define TCP_CS (1 << 30) /* Calculate TCP/IP checksum */
17786+#define IPV4_CS (1 << 29) /* Calculate IPv4 checksum */
17787+#define IPV6_CS (1 << 28) /* Calculate IPv6 checksum */
17788+#define MSS_SHIFT 17
17789+#define MSS_MAX 0x7ffU
17790+#define TCPHO_SHIFT 17
17791+#define TCPHO_MAX 0x7ffU
17792+#define TX_VLAN_TAG (1 << 16)
17793+};
17794+
17795+struct r8152;
17796+
17797+struct rx_agg {
17798+ struct list_head list;
17799+ struct urb *urb;
17800+ struct r8152 *context;
17801+ void *buffer;
17802+ void *head;
17803+};
17804+
17805+struct tx_agg {
17806+ struct list_head list;
17807+ struct urb *urb;
17808+ struct r8152 *context;
17809+ void *buffer;
17810+ void *head;
17811+ u32 skb_num;
17812+ u32 skb_len;
17813+};
17814+
17815+struct r8152 {
17816+ unsigned long flags;
17817+ struct usb_device *udev;
17818+ struct tasklet_struct tl;
17819+ struct usb_interface *intf;
17820+ struct net_device *netdev;
17821+ struct urb *intr_urb;
17822+ struct tx_agg tx_info[RTL8152_MAX_TX];
17823+ struct rx_agg rx_info[RTL8152_MAX_RX];
17824+ struct list_head rx_done, tx_free;
17825+ struct sk_buff_head tx_queue;
17826+ spinlock_t rx_lock, tx_lock;
17827+ struct delayed_work schedule;
17828+ struct mii_if_info mii;
17829+ struct mutex control; /* use for hw setting */
17830+
17831+ struct rtl_ops {
17832+ void (*init)(struct r8152 *);
17833+ int (*enable)(struct r8152 *);
17834+ void (*disable)(struct r8152 *);
17835+ void (*up)(struct r8152 *);
17836+ void (*down)(struct r8152 *);
17837+ void (*unload)(struct r8152 *);
17838+ int (*eee_get)(struct r8152 *, struct ethtool_eee *);
17839+ int (*eee_set)(struct r8152 *, struct ethtool_eee *);
17840+ } __no_const rtl_ops;
17841+
17842+ int intr_interval;
17843+ u32 saved_wolopts;
17844+ u32 msg_enable;
17845+ u32 tx_qlen;
17846+ u16 ocp_base;
17847+ u8 *intr_buff;
17848+ u8 version;
17849+ u8 speed;
17850+};
17851+
17852+enum rtl_version {
17853+ RTL_VER_UNKNOWN = 0,
17854+ RTL_VER_01,
17855+ RTL_VER_02,
17856+ RTL_VER_03,
17857+ RTL_VER_04,
17858+ RTL_VER_05,
17859+ RTL_VER_MAX
17860+};
17861+
17862+enum tx_csum_stat {
17863+ TX_CSUM_SUCCESS = 0,
17864+ TX_CSUM_TSO,
17865+ TX_CSUM_NONE
17866+};
17867+
17868+/* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
17869+ * The RTL chips use a 64 element hash table based on the Ethernet CRC.
17870+ */
17871+static const int multicast_filter_limit = 32;
17872+static unsigned int agg_buf_sz = 16384;
17873+
17874+#define RTL_LIMITED_TSO_SIZE (agg_buf_sz - sizeof(struct tx_desc) - \
17875+ VLAN_ETH_HLEN - VLAN_HLEN)
17876+
17877+static
17878+int get_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
17879+{
17880+ int ret;
17881+ void *tmp;
17882+
17883+ tmp = kmalloc(size, GFP_KERNEL);
17884+ if (!tmp)
17885+ return -ENOMEM;
17886+
17887+ ret = usb_control_msg(tp->udev, usb_rcvctrlpipe(tp->udev, 0),
17888+ RTL8152_REQ_GET_REGS, RTL8152_REQT_READ,
17889+ value, index, tmp, size, 500);
17890+
17891+ memcpy(data, tmp, size);
17892+ kfree(tmp);
17893+
17894+ return ret;
17895+}
17896+
17897+static
17898+int set_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
17899+{
17900+ int ret;
17901+ void *tmp;
17902+
17903+ tmp = kmemdup(data, size, GFP_KERNEL);
17904+ if (!tmp)
17905+ return -ENOMEM;
17906+
17907+ ret = usb_control_msg(tp->udev, usb_sndctrlpipe(tp->udev, 0),
17908+ RTL8152_REQ_SET_REGS, RTL8152_REQT_WRITE,
17909+ value, index, tmp, size, 500);
17910+
17911+ kfree(tmp);
17912+
17913+ return ret;
17914+}
17915+
17916+static int generic_ocp_read(struct r8152 *tp, u16 index, u16 size,
17917+ void *data, u16 type)
17918+{
17919+ u16 limit = 64;
17920+ int ret = 0;
17921+
17922+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
17923+ return -ENODEV;
17924+
17925+ /* both size and indix must be 4 bytes align */
17926+ if ((size & 3) || !size || (index & 3) || !data)
17927+ return -EPERM;
17928+
17929+ if ((u32)index + (u32)size > 0xffff)
17930+ return -EPERM;
17931+
17932+ while (size) {
17933+ if (size > limit) {
17934+ ret = get_registers(tp, index, type, limit, data);
17935+ if (ret < 0)
17936+ break;
17937+
17938+ index += limit;
17939+ data += limit;
17940+ size -= limit;
17941+ } else {
17942+ ret = get_registers(tp, index, type, size, data);
17943+ if (ret < 0)
17944+ break;
17945+
17946+ index += size;
17947+ data += size;
17948+ size = 0;
17949+ break;
17950+ }
17951+ }
17952+
17953+ return ret;
17954+}
17955+
17956+static int generic_ocp_write(struct r8152 *tp, u16 index, u16 byteen,
17957+ u16 size, void *data, u16 type)
17958+{
17959+ int ret;
17960+ u16 byteen_start, byteen_end, byen;
17961+ u16 limit = 512;
17962+
17963+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
17964+ return -ENODEV;
17965+
17966+ /* both size and indix must be 4 bytes align */
17967+ if ((size & 3) || !size || (index & 3) || !data)
17968+ return -EPERM;
17969+
17970+ if ((u32)index + (u32)size > 0xffff)
17971+ return -EPERM;
17972+
17973+ byteen_start = byteen & BYTE_EN_START_MASK;
17974+ byteen_end = byteen & BYTE_EN_END_MASK;
17975+
17976+ byen = byteen_start | (byteen_start << 4);
17977+ ret = set_registers(tp, index, type | byen, 4, data);
17978+ if (ret < 0)
17979+ goto error1;
17980+
17981+ index += 4;
17982+ data += 4;
17983+ size -= 4;
17984+
17985+ if (size) {
17986+ size -= 4;
17987+
17988+ while (size) {
17989+ if (size > limit) {
17990+ ret = set_registers(tp, index,
17991+ type | BYTE_EN_DWORD,
17992+ limit, data);
17993+ if (ret < 0)
17994+ goto error1;
17995+
17996+ index += limit;
17997+ data += limit;
17998+ size -= limit;
17999+ } else {
18000+ ret = set_registers(tp, index,
18001+ type | BYTE_EN_DWORD,
18002+ size, data);
18003+ if (ret < 0)
18004+ goto error1;
18005+
18006+ index += size;
18007+ data += size;
18008+ size = 0;
18009+ break;
18010+ }
18011+ }
18012+
18013+ byen = byteen_end | (byteen_end >> 4);
18014+ ret = set_registers(tp, index, type | byen, 4, data);
18015+ if (ret < 0)
18016+ goto error1;
18017+ }
18018+
18019+error1:
18020+ return ret;
18021+}
18022+
18023+static inline
18024+int pla_ocp_read(struct r8152 *tp, u16 index, u16 size, void *data)
18025+{
18026+ return generic_ocp_read(tp, index, size, data, MCU_TYPE_PLA);
18027+}
18028+
18029+static inline
18030+int pla_ocp_write(struct r8152 *tp, u16 index, u16 byteen, u16 size, void *data)
18031+{
18032+ return generic_ocp_write(tp, index, byteen, size, data, MCU_TYPE_PLA);
18033+}
18034+
18035+static inline
18036+int usb_ocp_read(struct r8152 *tp, u16 index, u16 size, void *data)
18037+{
18038+ return generic_ocp_read(tp, index, size, data, MCU_TYPE_USB);
18039+}
18040+
18041+static inline
18042+int usb_ocp_write(struct r8152 *tp, u16 index, u16 byteen, u16 size, void *data)
18043+{
18044+ return generic_ocp_write(tp, index, byteen, size, data, MCU_TYPE_USB);
18045+}
18046+
18047+static u32 ocp_read_dword(struct r8152 *tp, u16 type, u16 index)
18048+{
18049+ __le32 data;
18050+
18051+ generic_ocp_read(tp, index, sizeof(data), &data, type);
18052+
18053+ return __le32_to_cpu(data);
18054+}
18055+
18056+static void ocp_write_dword(struct r8152 *tp, u16 type, u16 index, u32 data)
18057+{
18058+ __le32 tmp = __cpu_to_le32(data);
18059+
18060+ generic_ocp_write(tp, index, BYTE_EN_DWORD, sizeof(tmp), &tmp, type);
18061+}
18062+
18063+static u16 ocp_read_word(struct r8152 *tp, u16 type, u16 index)
18064+{
18065+ u32 data;
18066+ __le32 tmp;
18067+ u8 shift = index & 2;
18068+
18069+ index &= ~3;
18070+
18071+ generic_ocp_read(tp, index, sizeof(tmp), &tmp, type);
18072+
18073+ data = __le32_to_cpu(tmp);
18074+ data >>= (shift * 8);
18075+ data &= 0xffff;
18076+
18077+ return (u16)data;
18078+}
18079+
18080+static void ocp_write_word(struct r8152 *tp, u16 type, u16 index, u32 data)
18081+{
18082+ u32 mask = 0xffff;
18083+ __le32 tmp;
18084+ u16 byen = BYTE_EN_WORD;
18085+ u8 shift = index & 2;
18086+
18087+ data &= mask;
18088+
18089+ if (index & 2) {
18090+ byen <<= shift;
18091+ mask <<= (shift * 8);
18092+ data <<= (shift * 8);
18093+ index &= ~3;
18094+ }
18095+
18096+ generic_ocp_read(tp, index, sizeof(tmp), &tmp, type);
18097+
18098+ data |= __le32_to_cpu(tmp) & ~mask;
18099+ tmp = __cpu_to_le32(data);
18100+
18101+ generic_ocp_write(tp, index, byen, sizeof(tmp), &tmp, type);
18102+}
18103+
18104+static u8 ocp_read_byte(struct r8152 *tp, u16 type, u16 index)
18105+{
18106+ u32 data;
18107+ __le32 tmp;
18108+ u8 shift = index & 3;
18109+
18110+ index &= ~3;
18111+
18112+ generic_ocp_read(tp, index, sizeof(tmp), &tmp, type);
18113+
18114+ data = __le32_to_cpu(tmp);
18115+ data >>= (shift * 8);
18116+ data &= 0xff;
18117+
18118+ return (u8)data;
18119+}
18120+
18121+static void ocp_write_byte(struct r8152 *tp, u16 type, u16 index, u32 data)
18122+{
18123+ u32 mask = 0xff;
18124+ __le32 tmp;
18125+ u16 byen = BYTE_EN_BYTE;
18126+ u8 shift = index & 3;
18127+
18128+ data &= mask;
18129+
18130+ if (index & 3) {
18131+ byen <<= shift;
18132+ mask <<= (shift * 8);
18133+ data <<= (shift * 8);
18134+ index &= ~3;
18135+ }
18136+
18137+ generic_ocp_read(tp, index, sizeof(tmp), &tmp, type);
18138+
18139+ data |= __le32_to_cpu(tmp) & ~mask;
18140+ tmp = __cpu_to_le32(data);
18141+
18142+ generic_ocp_write(tp, index, byen, sizeof(tmp), &tmp, type);
18143+}
18144+
18145+static u16 ocp_reg_read(struct r8152 *tp, u16 addr)
18146+{
18147+ u16 ocp_base, ocp_index;
18148+
18149+ ocp_base = addr & 0xf000;
18150+ if (ocp_base != tp->ocp_base) {
18151+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, ocp_base);
18152+ tp->ocp_base = ocp_base;
18153+ }
18154+
18155+ ocp_index = (addr & 0x0fff) | 0xb000;
18156+ return ocp_read_word(tp, MCU_TYPE_PLA, ocp_index);
18157+}
18158+
18159+static void ocp_reg_write(struct r8152 *tp, u16 addr, u16 data)
18160+{
18161+ u16 ocp_base, ocp_index;
18162+
18163+ ocp_base = addr & 0xf000;
18164+ if (ocp_base != tp->ocp_base) {
18165+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, ocp_base);
18166+ tp->ocp_base = ocp_base;
18167+ }
18168+
18169+ ocp_index = (addr & 0x0fff) | 0xb000;
18170+ ocp_write_word(tp, MCU_TYPE_PLA, ocp_index, data);
18171+}
18172+
18173+static inline void r8152_mdio_write(struct r8152 *tp, u32 reg_addr, u32 value)
18174+{
18175+ ocp_reg_write(tp, OCP_BASE_MII + reg_addr * 2, value);
18176+}
18177+
18178+static inline int r8152_mdio_read(struct r8152 *tp, u32 reg_addr)
18179+{
18180+ return ocp_reg_read(tp, OCP_BASE_MII + reg_addr * 2);
18181+}
18182+
18183+static void sram_write(struct r8152 *tp, u16 addr, u16 data)
18184+{
18185+ ocp_reg_write(tp, OCP_SRAM_ADDR, addr);
18186+ ocp_reg_write(tp, OCP_SRAM_DATA, data);
18187+}
18188+
18189+static u16 sram_read(struct r8152 *tp, u16 addr)
18190+{
18191+ ocp_reg_write(tp, OCP_SRAM_ADDR, addr);
18192+ return ocp_reg_read(tp, OCP_SRAM_DATA);
18193+}
18194+
18195+static int read_mii_word(struct net_device *netdev, int phy_id, int reg)
18196+{
18197+ struct r8152 *tp = netdev_priv(netdev);
18198+ int ret;
18199+
18200+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
18201+ return -ENODEV;
18202+
18203+ if (phy_id != R8152_PHY_ID)
18204+ return -EINVAL;
18205+
18206+ ret = r8152_mdio_read(tp, reg);
18207+
18208+ return ret;
18209+}
18210+
18211+static
18212+void write_mii_word(struct net_device *netdev, int phy_id, int reg, int val)
18213+{
18214+ struct r8152 *tp = netdev_priv(netdev);
18215+
18216+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
18217+ return;
18218+
18219+ if (phy_id != R8152_PHY_ID)
18220+ return;
18221+
18222+ r8152_mdio_write(tp, reg, val);
18223+}
18224+
18225+static int
18226+r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags);
18227+
18228+static int rtl8152_set_mac_address(struct net_device *netdev, void *p)
18229+{
18230+ struct r8152 *tp = netdev_priv(netdev);
18231+ struct sockaddr *addr = p;
18232+ int ret = -EADDRNOTAVAIL;
18233+
18234+ if (!is_valid_ether_addr(addr->sa_data))
18235+ goto out1;
18236+
18237+ ret = usb_autopm_get_interface(tp->intf);
18238+ if (ret < 0)
18239+ goto out1;
18240+
18241+ mutex_lock(&tp->control);
18242+
18243+ memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
18244+
18245+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
18246+ pla_ocp_write(tp, PLA_IDR, BYTE_EN_SIX_BYTES, 8, addr->sa_data);
18247+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
18248+
18249+ mutex_unlock(&tp->control);
18250+
18251+ usb_autopm_put_interface(tp->intf);
18252+out1:
18253+ return ret;
18254+}
18255+
18256+static int set_ethernet_addr(struct r8152 *tp)
18257+{
18258+ struct net_device *dev = tp->netdev;
18259+ struct sockaddr sa;
18260+ int ret;
18261+
18262+ if (tp->version == RTL_VER_01)
18263+ ret = pla_ocp_read(tp, PLA_IDR, 8, sa.sa_data);
18264+ else
18265+ ret = pla_ocp_read(tp, PLA_BACKUP, 8, sa.sa_data);
18266+
18267+ if (ret < 0) {
18268+ netif_err(tp, probe, dev, "Get ether addr fail\n");
18269+ } else if (!is_valid_ether_addr(sa.sa_data)) {
18270+ netif_err(tp, probe, dev, "Invalid ether addr %pM\n",
18271+ sa.sa_data);
18272+ eth_hw_addr_random(dev);
18273+ ether_addr_copy(sa.sa_data, dev->dev_addr);
18274+ ret = rtl8152_set_mac_address(dev, &sa);
18275+ netif_info(tp, probe, dev, "Random ether addr %pM\n",
18276+ sa.sa_data);
18277+ } else {
18278+ if (tp->version == RTL_VER_01)
18279+ ether_addr_copy(dev->dev_addr, sa.sa_data);
18280+ else
18281+ ret = rtl8152_set_mac_address(dev, &sa);
18282+ }
18283+
18284+ return ret;
18285+}
18286+
18287+static void read_bulk_callback(struct urb *urb)
18288+{
18289+ struct net_device *netdev;
18290+ int status = urb->status;
18291+ struct rx_agg *agg;
18292+ struct r8152 *tp;
18293+ int result;
18294+
18295+ agg = urb->context;
18296+ if (!agg)
18297+ return;
18298+
18299+ tp = agg->context;
18300+ if (!tp)
18301+ return;
18302+
18303+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
18304+ return;
18305+
18306+ if (!test_bit(WORK_ENABLE, &tp->flags))
18307+ return;
18308+
18309+ netdev = tp->netdev;
18310+
18311+ /* When link down, the driver would cancel all bulks. */
18312+ /* This avoid the re-submitting bulk */
18313+ if (!netif_carrier_ok(netdev))
18314+ return;
18315+
18316+ usb_mark_last_busy(tp->udev);
18317+
18318+ switch (status) {
18319+ case 0:
18320+ if (urb->actual_length < ETH_ZLEN)
18321+ break;
18322+
18323+ spin_lock(&tp->rx_lock);
18324+ list_add_tail(&agg->list, &tp->rx_done);
18325+ spin_unlock(&tp->rx_lock);
18326+ tasklet_schedule(&tp->tl);
18327+ return;
18328+ case -ESHUTDOWN:
18329+ set_bit(RTL8152_UNPLUG, &tp->flags);
18330+ netif_device_detach(tp->netdev);
18331+ return;
18332+ case -ENOENT:
18333+ return; /* the urb is in unlink state */
18334+ case -ETIME:
18335+ if (net_ratelimit())
18336+ netdev_warn(netdev, "maybe reset is needed?\n");
18337+ break;
18338+ default:
18339+ if (net_ratelimit())
18340+ netdev_warn(netdev, "Rx status %d\n", status);
18341+ break;
18342+ }
18343+
18344+ result = r8152_submit_rx(tp, agg, GFP_ATOMIC);
18345+ if (result == -ENODEV) {
18346+ netif_device_detach(tp->netdev);
18347+ } else if (result) {
18348+ spin_lock(&tp->rx_lock);
18349+ list_add_tail(&agg->list, &tp->rx_done);
18350+ spin_unlock(&tp->rx_lock);
18351+ tasklet_schedule(&tp->tl);
18352+ }
18353+}
18354+
18355+static void write_bulk_callback(struct urb *urb)
18356+{
18357+ struct net_device_stats *stats;
18358+ struct net_device *netdev;
18359+ struct tx_agg *agg;
18360+ struct r8152 *tp;
18361+ int status = urb->status;
18362+
18363+ agg = urb->context;
18364+ if (!agg)
18365+ return;
18366+
18367+ tp = agg->context;
18368+ if (!tp)
18369+ return;
18370+
18371+ netdev = tp->netdev;
18372+ stats = &netdev->stats;
18373+ if (status) {
18374+ if (net_ratelimit())
18375+ netdev_warn(netdev, "Tx status %d\n", status);
18376+ stats->tx_errors += agg->skb_num;
18377+ } else {
18378+ stats->tx_packets += agg->skb_num;
18379+ stats->tx_bytes += agg->skb_len;
18380+ }
18381+
18382+ spin_lock(&tp->tx_lock);
18383+ list_add_tail(&agg->list, &tp->tx_free);
18384+ spin_unlock(&tp->tx_lock);
18385+
18386+ usb_autopm_put_interface_async(tp->intf);
18387+
18388+ if (!netif_carrier_ok(netdev))
18389+ return;
18390+
18391+ if (!test_bit(WORK_ENABLE, &tp->flags))
18392+ return;
18393+
18394+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
18395+ return;
18396+
18397+ if (!skb_queue_empty(&tp->tx_queue))
18398+ tasklet_schedule(&tp->tl);
18399+}
18400+
18401+static void intr_callback(struct urb *urb)
18402+{
18403+ struct r8152 *tp;
18404+ __le16 *d;
18405+ int status = urb->status;
18406+ int res;
18407+
18408+ tp = urb->context;
18409+ if (!tp)
18410+ return;
18411+
18412+ if (!test_bit(WORK_ENABLE, &tp->flags))
18413+ return;
18414+
18415+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
18416+ return;
18417+
18418+ switch (status) {
18419+ case 0: /* success */
18420+ break;
18421+ case -ECONNRESET: /* unlink */
18422+ case -ESHUTDOWN:
18423+ netif_device_detach(tp->netdev);
18424+ case -ENOENT:
18425+ case -EPROTO:
18426+ netif_info(tp, intr, tp->netdev,
18427+ "Stop submitting intr, status %d\n", status);
18428+ return;
18429+ case -EOVERFLOW:
18430+ netif_info(tp, intr, tp->netdev, "intr status -EOVERFLOW\n");
18431+ goto resubmit;
18432+ /* -EPIPE: should clear the halt */
18433+ default:
18434+ netif_info(tp, intr, tp->netdev, "intr status %d\n", status);
18435+ goto resubmit;
18436+ }
18437+
18438+ d = urb->transfer_buffer;
18439+ if (INTR_LINK & __le16_to_cpu(d[0])) {
18440+ if (!(tp->speed & LINK_STATUS)) {
18441+ set_bit(RTL8152_LINK_CHG, &tp->flags);
18442+ schedule_delayed_work(&tp->schedule, 0);
18443+ }
18444+ } else {
18445+ if (tp->speed & LINK_STATUS) {
18446+ set_bit(RTL8152_LINK_CHG, &tp->flags);
18447+ schedule_delayed_work(&tp->schedule, 0);
18448+ }
18449+ }
18450+
18451+resubmit:
18452+ res = usb_submit_urb(urb, GFP_ATOMIC);
18453+ if (res == -ENODEV)
18454+ netif_device_detach(tp->netdev);
18455+ else if (res)
18456+ netif_err(tp, intr, tp->netdev,
18457+ "can't resubmit intr, status %d\n", res);
18458+}
18459+
18460+static inline void *rx_agg_align(void *data)
18461+{
18462+ return (void *)ALIGN((uintptr_t)data, RX_ALIGN);
18463+}
18464+
18465+static inline void *tx_agg_align(void *data)
18466+{
18467+ return (void *)ALIGN((uintptr_t)data, TX_ALIGN);
18468+}
18469+
18470+static void free_all_mem(struct r8152 *tp)
18471+{
18472+ int i;
18473+
18474+ for (i = 0; i < RTL8152_MAX_RX; i++) {
18475+ usb_free_urb(tp->rx_info[i].urb);
18476+ tp->rx_info[i].urb = NULL;
18477+
18478+ kfree(tp->rx_info[i].buffer);
18479+ tp->rx_info[i].buffer = NULL;
18480+ tp->rx_info[i].head = NULL;
18481+ }
18482+
18483+ for (i = 0; i < RTL8152_MAX_TX; i++) {
18484+ usb_free_urb(tp->tx_info[i].urb);
18485+ tp->tx_info[i].urb = NULL;
18486+
18487+ kfree(tp->tx_info[i].buffer);
18488+ tp->tx_info[i].buffer = NULL;
18489+ tp->tx_info[i].head = NULL;
18490+ }
18491+
18492+ usb_free_urb(tp->intr_urb);
18493+ tp->intr_urb = NULL;
18494+
18495+ kfree(tp->intr_buff);
18496+ tp->intr_buff = NULL;
18497+}
18498+
18499+static int alloc_all_mem(struct r8152 *tp)
18500+{
18501+ struct net_device *netdev = tp->netdev;
18502+ struct usb_interface *intf = tp->intf;
18503+ struct usb_host_interface *alt = intf->cur_altsetting;
18504+ struct usb_host_endpoint *ep_intr = alt->endpoint + 2;
18505+ struct urb *urb;
18506+ int node, i;
18507+ u8 *buf;
18508+
18509+ node = netdev->dev.parent ? dev_to_node(netdev->dev.parent) : -1;
18510+
18511+ spin_lock_init(&tp->rx_lock);
18512+ spin_lock_init(&tp->tx_lock);
18513+ INIT_LIST_HEAD(&tp->rx_done);
18514+ INIT_LIST_HEAD(&tp->tx_free);
18515+ skb_queue_head_init(&tp->tx_queue);
18516+
18517+ for (i = 0; i < RTL8152_MAX_RX; i++) {
18518+ buf = kmalloc_node(agg_buf_sz, GFP_KERNEL, node);
18519+ if (!buf)
18520+ goto err1;
18521+
18522+ if (buf != rx_agg_align(buf)) {
18523+ kfree(buf);
18524+ buf = kmalloc_node(agg_buf_sz + RX_ALIGN, GFP_KERNEL,
18525+ node);
18526+ if (!buf)
18527+ goto err1;
18528+ }
18529+
18530+ urb = usb_alloc_urb(0, GFP_KERNEL);
18531+ if (!urb) {
18532+ kfree(buf);
18533+ goto err1;
18534+ }
18535+
18536+ INIT_LIST_HEAD(&tp->rx_info[i].list);
18537+ tp->rx_info[i].context = tp;
18538+ tp->rx_info[i].urb = urb;
18539+ tp->rx_info[i].buffer = buf;
18540+ tp->rx_info[i].head = rx_agg_align(buf);
18541+ }
18542+
18543+ for (i = 0; i < RTL8152_MAX_TX; i++) {
18544+ buf = kmalloc_node(agg_buf_sz, GFP_KERNEL, node);
18545+ if (!buf)
18546+ goto err1;
18547+
18548+ if (buf != tx_agg_align(buf)) {
18549+ kfree(buf);
18550+ buf = kmalloc_node(agg_buf_sz + TX_ALIGN, GFP_KERNEL,
18551+ node);
18552+ if (!buf)
18553+ goto err1;
18554+ }
18555+
18556+ urb = usb_alloc_urb(0, GFP_KERNEL);
18557+ if (!urb) {
18558+ kfree(buf);
18559+ goto err1;
18560+ }
18561+
18562+ INIT_LIST_HEAD(&tp->tx_info[i].list);
18563+ tp->tx_info[i].context = tp;
18564+ tp->tx_info[i].urb = urb;
18565+ tp->tx_info[i].buffer = buf;
18566+ tp->tx_info[i].head = tx_agg_align(buf);
18567+
18568+ list_add_tail(&tp->tx_info[i].list, &tp->tx_free);
18569+ }
18570+
18571+ tp->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
18572+ if (!tp->intr_urb)
18573+ goto err1;
18574+
18575+ tp->intr_buff = kmalloc(INTBUFSIZE, GFP_KERNEL);
18576+ if (!tp->intr_buff)
18577+ goto err1;
18578+
18579+ tp->intr_interval = (int)ep_intr->desc.bInterval;
18580+ usb_fill_int_urb(tp->intr_urb, tp->udev, usb_rcvintpipe(tp->udev, 3),
18581+ tp->intr_buff, INTBUFSIZE, intr_callback,
18582+ tp, tp->intr_interval);
18583+
18584+ return 0;
18585+
18586+err1:
18587+ free_all_mem(tp);
18588+ return -ENOMEM;
18589+}
18590+
18591+static struct tx_agg *r8152_get_tx_agg(struct r8152 *tp)
18592+{
18593+ struct tx_agg *agg = NULL;
18594+ unsigned long flags;
18595+
18596+ if (list_empty(&tp->tx_free))
18597+ return NULL;
18598+
18599+ spin_lock_irqsave(&tp->tx_lock, flags);
18600+ if (!list_empty(&tp->tx_free)) {
18601+ struct list_head *cursor;
18602+
18603+ cursor = tp->tx_free.next;
18604+ list_del_init(cursor);
18605+ agg = list_entry(cursor, struct tx_agg, list);
18606+ }
18607+ spin_unlock_irqrestore(&tp->tx_lock, flags);
18608+
18609+ return agg;
18610+}
18611+
18612+static inline __be16 get_protocol(struct sk_buff *skb)
18613+{
18614+ __be16 protocol;
18615+
18616+ if (skb->protocol == htons(ETH_P_8021Q))
18617+ protocol = vlan_eth_hdr(skb)->h_vlan_encapsulated_proto;
18618+ else
18619+ protocol = skb->protocol;
18620+
18621+ return protocol;
18622+}
18623+
18624+/* r8152_csum_workaround()
18625+ * The hw limites the value the transport offset. When the offset is out of the
18626+ * range, calculate the checksum by sw.
18627+ */
18628+static void r8152_csum_workaround(struct r8152 *tp, struct sk_buff *skb,
18629+ struct sk_buff_head *list)
18630+{
18631+ if (skb_shinfo(skb)->gso_size) {
18632+ netdev_features_t features = tp->netdev->features;
18633+ struct sk_buff_head seg_list;
18634+ struct sk_buff *segs, *nskb;
18635+
18636+ features &= ~(NETIF_F_SG | NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
18637+ segs = skb_gso_segment(skb, features);
18638+ if (IS_ERR(segs) || !segs)
18639+ goto drop;
18640+
18641+ __skb_queue_head_init(&seg_list);
18642+
18643+ do {
18644+ nskb = segs;
18645+ segs = segs->next;
18646+ nskb->next = NULL;
18647+ __skb_queue_tail(&seg_list, nskb);
18648+ } while (segs);
18649+
18650+ skb_queue_splice(&seg_list, list);
18651+ dev_kfree_skb(skb);
18652+ } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
18653+ if (skb_checksum_help(skb) < 0)
18654+ goto drop;
18655+
18656+ __skb_queue_head(list, skb);
18657+ } else {
18658+ struct net_device_stats *stats;
18659+
18660+drop:
18661+ stats = &tp->netdev->stats;
18662+ stats->tx_dropped++;
18663+ dev_kfree_skb(skb);
18664+ }
18665+}
18666+
18667+/* msdn_giant_send_check()
18668+ * According to the document of microsoft, the TCP Pseudo Header excludes the
18669+ * packet length for IPv6 TCP large packets.
18670+ */
18671+static int msdn_giant_send_check(struct sk_buff *skb)
18672+{
18673+ const struct ipv6hdr *ipv6h;
18674+ struct tcphdr *th;
18675+ int ret;
18676+
18677+ ret = skb_cow_head(skb, 0);
18678+ if (ret)
18679+ return ret;
18680+
18681+ ipv6h = ipv6_hdr(skb);
18682+ th = tcp_hdr(skb);
18683+
18684+ th->check = 0;
18685+ th->check = ~tcp_v6_check(0, &ipv6h->saddr, &ipv6h->daddr, 0);
18686+
18687+ return ret;
18688+}
18689+
18690+static inline void rtl_tx_vlan_tag(struct tx_desc *desc, struct sk_buff *skb)
18691+{
18692+ if (vlan_tx_tag_present(skb)) {
18693+ u32 opts2;
18694+
18695+ opts2 = TX_VLAN_TAG | swab16(vlan_tx_tag_get(skb));
18696+ desc->opts2 |= cpu_to_le32(opts2);
18697+ }
18698+}
18699+
18700+static inline void rtl_rx_vlan_tag(struct rx_desc *desc, struct sk_buff *skb)
18701+{
18702+ u32 opts2 = le32_to_cpu(desc->opts2);
18703+
18704+ if (opts2 & RX_VLAN_TAG)
18705+ __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
18706+ swab16(opts2 & 0xffff));
18707+}
18708+
18709+static int r8152_tx_csum(struct r8152 *tp, struct tx_desc *desc,
18710+ struct sk_buff *skb, u32 len, u32 transport_offset)
18711+{
18712+ u32 mss = skb_shinfo(skb)->gso_size;
18713+ u32 opts1, opts2 = 0;
18714+ int ret = TX_CSUM_SUCCESS;
18715+
18716+ WARN_ON_ONCE(len > TX_LEN_MAX);
18717+
18718+ opts1 = len | TX_FS | TX_LS;
18719+
18720+ if (mss) {
18721+ if (transport_offset > GTTCPHO_MAX) {
18722+ netif_warn(tp, tx_err, tp->netdev,
18723+ "Invalid transport offset 0x%x for TSO\n",
18724+ transport_offset);
18725+ ret = TX_CSUM_TSO;
18726+ goto unavailable;
18727+ }
18728+
18729+ switch (get_protocol(skb)) {
18730+ case htons(ETH_P_IP):
18731+ opts1 |= GTSENDV4;
18732+ break;
18733+
18734+ case htons(ETH_P_IPV6):
18735+ if (msdn_giant_send_check(skb)) {
18736+ ret = TX_CSUM_TSO;
18737+ goto unavailable;
18738+ }
18739+ opts1 |= GTSENDV6;
18740+ break;
18741+
18742+ default:
18743+ WARN_ON_ONCE(1);
18744+ break;
18745+ }
18746+
18747+ opts1 |= transport_offset << GTTCPHO_SHIFT;
18748+ opts2 |= min(mss, MSS_MAX) << MSS_SHIFT;
18749+ } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
18750+ u8 ip_protocol;
18751+
18752+ if (transport_offset > TCPHO_MAX) {
18753+ netif_warn(tp, tx_err, tp->netdev,
18754+ "Invalid transport offset 0x%x\n",
18755+ transport_offset);
18756+ ret = TX_CSUM_NONE;
18757+ goto unavailable;
18758+ }
18759+
18760+ switch (get_protocol(skb)) {
18761+ case htons(ETH_P_IP):
18762+ opts2 |= IPV4_CS;
18763+ ip_protocol = ip_hdr(skb)->protocol;
18764+ break;
18765+
18766+ case htons(ETH_P_IPV6):
18767+ opts2 |= IPV6_CS;
18768+ ip_protocol = ipv6_hdr(skb)->nexthdr;
18769+ break;
18770+
18771+ default:
18772+ ip_protocol = IPPROTO_RAW;
18773+ break;
18774+ }
18775+
18776+ if (ip_protocol == IPPROTO_TCP)
18777+ opts2 |= TCP_CS;
18778+ else if (ip_protocol == IPPROTO_UDP)
18779+ opts2 |= UDP_CS;
18780+ else
18781+ WARN_ON_ONCE(1);
18782+
18783+ opts2 |= transport_offset << TCPHO_SHIFT;
18784+ }
18785+
18786+ desc->opts2 = cpu_to_le32(opts2);
18787+ desc->opts1 = cpu_to_le32(opts1);
18788+
18789+unavailable:
18790+ return ret;
18791+}
18792+
18793+static int r8152_tx_agg_fill(struct r8152 *tp, struct tx_agg *agg)
18794+{
18795+ struct sk_buff_head skb_head, *tx_queue = &tp->tx_queue;
18796+ int remain, ret;
18797+ u8 *tx_data;
18798+
18799+ __skb_queue_head_init(&skb_head);
18800+ spin_lock(&tx_queue->lock);
18801+ skb_queue_splice_init(tx_queue, &skb_head);
18802+ spin_unlock(&tx_queue->lock);
18803+
18804+ tx_data = agg->head;
18805+ agg->skb_num = 0;
18806+ agg->skb_len = 0;
18807+ remain = agg_buf_sz;
18808+
18809+ while (remain >= ETH_ZLEN + sizeof(struct tx_desc)) {
18810+ struct tx_desc *tx_desc;
18811+ struct sk_buff *skb;
18812+ unsigned int len;
18813+ u32 offset;
18814+
18815+ skb = __skb_dequeue(&skb_head);
18816+ if (!skb)
18817+ break;
18818+
18819+ len = skb->len + sizeof(*tx_desc);
18820+
18821+ if (len > remain) {
18822+ __skb_queue_head(&skb_head, skb);
18823+ break;
18824+ }
18825+
18826+ tx_data = tx_agg_align(tx_data);
18827+ tx_desc = (struct tx_desc *)tx_data;
18828+
18829+ offset = (u32)skb_transport_offset(skb);
18830+
18831+ if (r8152_tx_csum(tp, tx_desc, skb, skb->len, offset)) {
18832+ r8152_csum_workaround(tp, skb, &skb_head);
18833+ continue;
18834+ }
18835+
18836+ rtl_tx_vlan_tag(tx_desc, skb);
18837+
18838+ tx_data += sizeof(*tx_desc);
18839+
18840+ len = skb->len;
18841+ if (skb_copy_bits(skb, 0, tx_data, len) < 0) {
18842+ struct net_device_stats *stats = &tp->netdev->stats;
18843+
18844+ stats->tx_dropped++;
18845+ dev_kfree_skb_any(skb);
18846+ tx_data -= sizeof(*tx_desc);
18847+ continue;
18848+ }
18849+
18850+ tx_data += len;
18851+ agg->skb_len += len;
18852+ agg->skb_num++;
18853+
18854+ dev_kfree_skb_any(skb);
18855+
18856+ remain = agg_buf_sz - (int)(tx_agg_align(tx_data) - agg->head);
18857+ }
18858+
18859+ if (!skb_queue_empty(&skb_head)) {
18860+ spin_lock(&tx_queue->lock);
18861+ skb_queue_splice(&skb_head, tx_queue);
18862+ spin_unlock(&tx_queue->lock);
18863+ }
18864+
18865+ netif_tx_lock(tp->netdev);
18866+
18867+ if (netif_queue_stopped(tp->netdev) &&
18868+ skb_queue_len(&tp->tx_queue) < tp->tx_qlen)
18869+ netif_wake_queue(tp->netdev);
18870+
18871+ netif_tx_unlock(tp->netdev);
18872+
18873+ ret = usb_autopm_get_interface_async(tp->intf);
18874+ if (ret < 0)
18875+ goto out_tx_fill;
18876+
18877+ usb_fill_bulk_urb(agg->urb, tp->udev, usb_sndbulkpipe(tp->udev, 2),
18878+ agg->head, (int)(tx_data - (u8 *)agg->head),
18879+ (usb_complete_t)write_bulk_callback, agg);
18880+
18881+ ret = usb_submit_urb(agg->urb, GFP_ATOMIC);
18882+ if (ret < 0)
18883+ usb_autopm_put_interface_async(tp->intf);
18884+
18885+out_tx_fill:
18886+ return ret;
18887+}
18888+
18889+static u8 r8152_rx_csum(struct r8152 *tp, struct rx_desc *rx_desc)
18890+{
18891+ u8 checksum = CHECKSUM_NONE;
18892+ u32 opts2, opts3;
18893+
18894+ if (tp->version == RTL_VER_01)
18895+ goto return_result;
18896+
18897+ opts2 = le32_to_cpu(rx_desc->opts2);
18898+ opts3 = le32_to_cpu(rx_desc->opts3);
18899+
18900+ if (opts2 & RD_IPV4_CS) {
18901+ if (opts3 & IPF)
18902+ checksum = CHECKSUM_NONE;
18903+ else if ((opts2 & RD_UDP_CS) && (opts3 & UDPF))
18904+ checksum = CHECKSUM_NONE;
18905+ else if ((opts2 & RD_TCP_CS) && (opts3 & TCPF))
18906+ checksum = CHECKSUM_NONE;
18907+ else
18908+ checksum = CHECKSUM_UNNECESSARY;
18909+ } else if (RD_IPV6_CS) {
18910+ if ((opts2 & RD_UDP_CS) && !(opts3 & UDPF))
18911+ checksum = CHECKSUM_UNNECESSARY;
18912+ else if ((opts2 & RD_TCP_CS) && !(opts3 & TCPF))
18913+ checksum = CHECKSUM_UNNECESSARY;
18914+ }
18915+
18916+return_result:
18917+ return checksum;
18918+}
18919+
18920+static void rx_bottom(struct r8152 *tp)
18921+{
18922+ unsigned long flags;
18923+ struct list_head *cursor, *next, rx_queue;
18924+
18925+ if (list_empty(&tp->rx_done))
18926+ return;
18927+
18928+ INIT_LIST_HEAD(&rx_queue);
18929+ spin_lock_irqsave(&tp->rx_lock, flags);
18930+ list_splice_init(&tp->rx_done, &rx_queue);
18931+ spin_unlock_irqrestore(&tp->rx_lock, flags);
18932+
18933+ list_for_each_safe(cursor, next, &rx_queue) {
18934+ struct rx_desc *rx_desc;
18935+ struct rx_agg *agg;
18936+ int len_used = 0;
18937+ struct urb *urb;
18938+ u8 *rx_data;
18939+ int ret;
18940+
18941+ list_del_init(cursor);
18942+
18943+ agg = list_entry(cursor, struct rx_agg, list);
18944+ urb = agg->urb;
18945+ if (urb->actual_length < ETH_ZLEN)
18946+ goto submit;
18947+
18948+ rx_desc = agg->head;
18949+ rx_data = agg->head;
18950+ len_used += sizeof(struct rx_desc);
18951+
18952+ while (urb->actual_length > len_used) {
18953+ struct net_device *netdev = tp->netdev;
18954+ struct net_device_stats *stats = &netdev->stats;
18955+ unsigned int pkt_len;
18956+ struct sk_buff *skb;
18957+
18958+ pkt_len = le32_to_cpu(rx_desc->opts1) & RX_LEN_MASK;
18959+ if (pkt_len < ETH_ZLEN)
18960+ break;
18961+
18962+ len_used += pkt_len;
18963+ if (urb->actual_length < len_used)
18964+ break;
18965+
18966+ pkt_len -= CRC_SIZE;
18967+ rx_data += sizeof(struct rx_desc);
18968+
18969+ skb = netdev_alloc_skb_ip_align(netdev, pkt_len);
18970+ if (!skb) {
18971+ stats->rx_dropped++;
18972+ goto find_next_rx;
18973+ }
18974+
18975+ skb->ip_summed = r8152_rx_csum(tp, rx_desc);
18976+ memcpy(skb->data, rx_data, pkt_len);
18977+ skb_put(skb, pkt_len);
18978+ skb->protocol = eth_type_trans(skb, netdev);
18979+ rtl_rx_vlan_tag(rx_desc, skb);
18980+ netif_receive_skb(skb);
18981+ stats->rx_packets++;
18982+ stats->rx_bytes += pkt_len;
18983+
18984+find_next_rx:
18985+ rx_data = rx_agg_align(rx_data + pkt_len + CRC_SIZE);
18986+ rx_desc = (struct rx_desc *)rx_data;
18987+ len_used = (int)(rx_data - (u8 *)agg->head);
18988+ len_used += sizeof(struct rx_desc);
18989+ }
18990+
18991+submit:
18992+ ret = r8152_submit_rx(tp, agg, GFP_ATOMIC);
18993+ if (ret && ret != -ENODEV) {
18994+ spin_lock_irqsave(&tp->rx_lock, flags);
18995+ list_add_tail(&agg->list, &tp->rx_done);
18996+ spin_unlock_irqrestore(&tp->rx_lock, flags);
18997+ tasklet_schedule(&tp->tl);
18998+ }
18999+ }
19000+}
19001+
19002+static void tx_bottom(struct r8152 *tp)
19003+{
19004+ int res;
19005+
19006+ do {
19007+ struct tx_agg *agg;
19008+
19009+ if (skb_queue_empty(&tp->tx_queue))
19010+ break;
19011+
19012+ agg = r8152_get_tx_agg(tp);
19013+ if (!agg)
19014+ break;
19015+
19016+ res = r8152_tx_agg_fill(tp, agg);
19017+ if (res) {
19018+ struct net_device *netdev = tp->netdev;
19019+
19020+ if (res == -ENODEV) {
19021+ netif_device_detach(netdev);
19022+ } else {
19023+ struct net_device_stats *stats = &netdev->stats;
19024+ unsigned long flags;
19025+
19026+ netif_warn(tp, tx_err, netdev,
19027+ "failed tx_urb %d\n", res);
19028+ stats->tx_dropped += agg->skb_num;
19029+
19030+ spin_lock_irqsave(&tp->tx_lock, flags);
19031+ list_add_tail(&agg->list, &tp->tx_free);
19032+ spin_unlock_irqrestore(&tp->tx_lock, flags);
19033+ }
19034+ }
19035+ } while (res == 0);
19036+}
19037+
19038+static void bottom_half(unsigned long data)
19039+{
19040+ struct r8152 *tp;
19041+
19042+ tp = (struct r8152 *)data;
19043+
19044+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
19045+ return;
19046+
19047+ if (!test_bit(WORK_ENABLE, &tp->flags))
19048+ return;
19049+
19050+ /* When link down, the driver would cancel all bulks. */
19051+ /* This avoid the re-submitting bulk */
19052+ if (!netif_carrier_ok(tp->netdev))
19053+ return;
19054+
19055+ rx_bottom(tp);
19056+ tx_bottom(tp);
19057+}
19058+
19059+static
19060+int r8152_submit_rx(struct r8152 *tp, struct rx_agg *agg, gfp_t mem_flags)
19061+{
19062+ usb_fill_bulk_urb(agg->urb, tp->udev, usb_rcvbulkpipe(tp->udev, 1),
19063+ agg->head, agg_buf_sz,
19064+ (usb_complete_t)read_bulk_callback, agg);
19065+
19066+ return usb_submit_urb(agg->urb, mem_flags);
19067+}
19068+
19069+static void rtl_drop_queued_tx(struct r8152 *tp)
19070+{
19071+ struct net_device_stats *stats = &tp->netdev->stats;
19072+ struct sk_buff_head skb_head, *tx_queue = &tp->tx_queue;
19073+ struct sk_buff *skb;
19074+
19075+ if (skb_queue_empty(tx_queue))
19076+ return;
19077+
19078+ __skb_queue_head_init(&skb_head);
19079+ spin_lock_bh(&tx_queue->lock);
19080+ skb_queue_splice_init(tx_queue, &skb_head);
19081+ spin_unlock_bh(&tx_queue->lock);
19082+
19083+ while ((skb = __skb_dequeue(&skb_head))) {
19084+ dev_kfree_skb(skb);
19085+ stats->tx_dropped++;
19086+ }
19087+}
19088+
19089+static void rtl8152_tx_timeout(struct net_device *netdev)
19090+{
19091+ struct r8152 *tp = netdev_priv(netdev);
19092+ int i;
19093+
19094+ netif_warn(tp, tx_err, netdev, "Tx timeout\n");
19095+ for (i = 0; i < RTL8152_MAX_TX; i++)
19096+ usb_unlink_urb(tp->tx_info[i].urb);
19097+}
19098+
19099+static void rtl8152_set_rx_mode(struct net_device *netdev)
19100+{
19101+ struct r8152 *tp = netdev_priv(netdev);
19102+
19103+ if (tp->speed & LINK_STATUS) {
19104+ set_bit(RTL8152_SET_RX_MODE, &tp->flags);
19105+ schedule_delayed_work(&tp->schedule, 0);
19106+ }
19107+}
19108+
19109+static void _rtl8152_set_rx_mode(struct net_device *netdev)
19110+{
19111+ struct r8152 *tp = netdev_priv(netdev);
19112+ u32 mc_filter[2]; /* Multicast hash filter */
19113+ __le32 tmp[2];
19114+ u32 ocp_data;
19115+
19116+ clear_bit(RTL8152_SET_RX_MODE, &tp->flags);
19117+ netif_stop_queue(netdev);
19118+ ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
19119+ ocp_data &= ~RCR_ACPT_ALL;
19120+ ocp_data |= RCR_AB | RCR_APM;
19121+
19122+ if (netdev->flags & IFF_PROMISC) {
19123+ /* Unconditionally log net taps. */
19124+ netif_notice(tp, link, netdev, "Promiscuous mode enabled\n");
19125+ ocp_data |= RCR_AM | RCR_AAP;
19126+ mc_filter[1] = 0xffffffff;
19127+ mc_filter[0] = 0xffffffff;
19128+ } else if ((netdev_mc_count(netdev) > multicast_filter_limit) ||
19129+ (netdev->flags & IFF_ALLMULTI)) {
19130+ /* Too many to filter perfectly -- accept all multicasts. */
19131+ ocp_data |= RCR_AM;
19132+ mc_filter[1] = 0xffffffff;
19133+ mc_filter[0] = 0xffffffff;
19134+ } else {
19135+ struct netdev_hw_addr *ha;
19136+
19137+ mc_filter[1] = 0;
19138+ mc_filter[0] = 0;
19139+ netdev_for_each_mc_addr(ha, netdev) {
19140+ int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
19141+
19142+ mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
19143+ ocp_data |= RCR_AM;
19144+ }
19145+ }
19146+
19147+ tmp[0] = __cpu_to_le32(swab32(mc_filter[1]));
19148+ tmp[1] = __cpu_to_le32(swab32(mc_filter[0]));
19149+
19150+ pla_ocp_write(tp, PLA_MAR, BYTE_EN_DWORD, sizeof(tmp), tmp);
19151+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
19152+ netif_wake_queue(netdev);
19153+}
19154+
19155+static netdev_tx_t rtl8152_start_xmit(struct sk_buff *skb,
19156+ struct net_device *netdev)
19157+{
19158+ struct r8152 *tp = netdev_priv(netdev);
19159+
19160+ skb_tx_timestamp(skb);
19161+
19162+ skb_queue_tail(&tp->tx_queue, skb);
19163+
19164+ if (!list_empty(&tp->tx_free)) {
19165+ if (test_bit(SELECTIVE_SUSPEND, &tp->flags)) {
19166+ set_bit(SCHEDULE_TASKLET, &tp->flags);
19167+ schedule_delayed_work(&tp->schedule, 0);
19168+ } else {
19169+ usb_mark_last_busy(tp->udev);
19170+ tasklet_schedule(&tp->tl);
19171+ }
19172+ } else if (skb_queue_len(&tp->tx_queue) > tp->tx_qlen) {
19173+ netif_stop_queue(netdev);
19174+ }
19175+
19176+ return NETDEV_TX_OK;
19177+}
19178+
19179+static void r8152b_reset_packet_filter(struct r8152 *tp)
19180+{
19181+ u32 ocp_data;
19182+
19183+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_FMC);
19184+ ocp_data &= ~FMC_FCR_MCU_EN;
19185+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_FMC, ocp_data);
19186+ ocp_data |= FMC_FCR_MCU_EN;
19187+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_FMC, ocp_data);
19188+}
19189+
19190+static void rtl8152_nic_reset(struct r8152 *tp)
19191+{
19192+ int i;
19193+
19194+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, CR_RST);
19195+
19196+ for (i = 0; i < 1000; i++) {
19197+ if (!(ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CR) & CR_RST))
19198+ break;
19199+ usleep_range(100, 400);
19200+ }
19201+}
19202+
19203+static void set_tx_qlen(struct r8152 *tp)
19204+{
19205+ struct net_device *netdev = tp->netdev;
19206+
19207+ tp->tx_qlen = agg_buf_sz / (netdev->mtu + VLAN_ETH_HLEN + VLAN_HLEN +
19208+ sizeof(struct tx_desc));
19209+}
19210+
19211+static inline u8 rtl8152_get_speed(struct r8152 *tp)
19212+{
19213+ return ocp_read_byte(tp, MCU_TYPE_PLA, PLA_PHYSTATUS);
19214+}
19215+
19216+static void rtl_set_eee_plus(struct r8152 *tp)
19217+{
19218+ u32 ocp_data;
19219+ u8 speed;
19220+
19221+ speed = rtl8152_get_speed(tp);
19222+ if (speed & _10bps) {
19223+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR);
19224+ ocp_data |= EEEP_CR_EEEP_TX;
19225+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR, ocp_data);
19226+ } else {
19227+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR);
19228+ ocp_data &= ~EEEP_CR_EEEP_TX;
19229+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR, ocp_data);
19230+ }
19231+}
19232+
19233+static void rxdy_gated_en(struct r8152 *tp, bool enable)
19234+{
19235+ u32 ocp_data;
19236+
19237+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MISC_1);
19238+ if (enable)
19239+ ocp_data |= RXDY_GATED_EN;
19240+ else
19241+ ocp_data &= ~RXDY_GATED_EN;
19242+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_MISC_1, ocp_data);
19243+}
19244+
19245+static int rtl_start_rx(struct r8152 *tp)
19246+{
19247+ int i, ret = 0;
19248+
19249+ INIT_LIST_HEAD(&tp->rx_done);
19250+ for (i = 0; i < RTL8152_MAX_RX; i++) {
19251+ INIT_LIST_HEAD(&tp->rx_info[i].list);
19252+ ret = r8152_submit_rx(tp, &tp->rx_info[i], GFP_KERNEL);
19253+ if (ret)
19254+ break;
19255+ }
19256+
19257+ return ret;
19258+}
19259+
19260+static int rtl_stop_rx(struct r8152 *tp)
19261+{
19262+ int i;
19263+
19264+ for (i = 0; i < RTL8152_MAX_RX; i++)
19265+ usb_kill_urb(tp->rx_info[i].urb);
19266+
19267+ return 0;
19268+}
19269+
19270+static int rtl_enable(struct r8152 *tp)
19271+{
19272+ u32 ocp_data;
19273+
19274+ r8152b_reset_packet_filter(tp);
19275+
19276+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CR);
19277+ ocp_data |= CR_RE | CR_TE;
19278+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, ocp_data);
19279+
19280+ rxdy_gated_en(tp, false);
19281+
19282+ return rtl_start_rx(tp);
19283+}
19284+
19285+static int rtl8152_enable(struct r8152 *tp)
19286+{
19287+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
19288+ return -ENODEV;
19289+
19290+ set_tx_qlen(tp);
19291+ rtl_set_eee_plus(tp);
19292+
19293+ return rtl_enable(tp);
19294+}
19295+
19296+static void r8153_set_rx_agg(struct r8152 *tp)
19297+{
19298+ u8 speed;
19299+
19300+ speed = rtl8152_get_speed(tp);
19301+ if (speed & _1000bps) {
19302+ if (tp->udev->speed == USB_SPEED_SUPER) {
19303+ ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH,
19304+ RX_THR_SUPPER);
19305+ ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_EARLY_AGG,
19306+ EARLY_AGG_SUPPER);
19307+ } else {
19308+ ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH,
19309+ RX_THR_HIGH);
19310+ ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_EARLY_AGG,
19311+ EARLY_AGG_HIGH);
19312+ }
19313+ } else {
19314+ ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, RX_THR_SLOW);
19315+ ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_EARLY_AGG,
19316+ EARLY_AGG_SLOW);
19317+ }
19318+}
19319+
19320+static int rtl8153_enable(struct r8152 *tp)
19321+{
19322+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
19323+ return -ENODEV;
19324+
19325+ set_tx_qlen(tp);
19326+ rtl_set_eee_plus(tp);
19327+ r8153_set_rx_agg(tp);
19328+
19329+ return rtl_enable(tp);
19330+}
19331+
19332+static void rtl_disable(struct r8152 *tp)
19333+{
19334+ u32 ocp_data;
19335+ int i;
19336+
19337+ if (test_bit(RTL8152_UNPLUG, &tp->flags)) {
19338+ rtl_drop_queued_tx(tp);
19339+ return;
19340+ }
19341+
19342+ ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
19343+ ocp_data &= ~RCR_ACPT_ALL;
19344+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
19345+
19346+ rtl_drop_queued_tx(tp);
19347+
19348+ for (i = 0; i < RTL8152_MAX_TX; i++)
19349+ usb_kill_urb(tp->tx_info[i].urb);
19350+
19351+ rxdy_gated_en(tp, true);
19352+
19353+ for (i = 0; i < 1000; i++) {
19354+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19355+ if ((ocp_data & FIFO_EMPTY) == FIFO_EMPTY)
19356+ break;
19357+ usleep_range(1000, 2000);
19358+ }
19359+
19360+ for (i = 0; i < 1000; i++) {
19361+ if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0) & TCR0_TX_EMPTY)
19362+ break;
19363+ usleep_range(1000, 2000);
19364+ }
19365+
19366+ rtl_stop_rx(tp);
19367+
19368+ rtl8152_nic_reset(tp);
19369+}
19370+
19371+static void r8152_power_cut_en(struct r8152 *tp, bool enable)
19372+{
19373+ u32 ocp_data;
19374+
19375+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_UPS_CTRL);
19376+ if (enable)
19377+ ocp_data |= POWER_CUT;
19378+ else
19379+ ocp_data &= ~POWER_CUT;
19380+ ocp_write_word(tp, MCU_TYPE_USB, USB_UPS_CTRL, ocp_data);
19381+
19382+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_PM_CTRL_STATUS);
19383+ ocp_data &= ~RESUME_INDICATE;
19384+ ocp_write_word(tp, MCU_TYPE_USB, USB_PM_CTRL_STATUS, ocp_data);
19385+}
19386+
19387+static void rtl_rx_vlan_en(struct r8152 *tp, bool enable)
19388+{
19389+ u32 ocp_data;
19390+
19391+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CPCR);
19392+ if (enable)
19393+ ocp_data |= CPCR_RX_VLAN;
19394+ else
19395+ ocp_data &= ~CPCR_RX_VLAN;
19396+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_CPCR, ocp_data);
19397+}
19398+
19399+static int rtl8152_set_features(struct net_device *dev,
19400+ netdev_features_t features)
19401+{
19402+ netdev_features_t changed = features ^ dev->features;
19403+ struct r8152 *tp = netdev_priv(dev);
19404+ int ret;
19405+
19406+ ret = usb_autopm_get_interface(tp->intf);
19407+ if (ret < 0)
19408+ goto out;
19409+
19410+ mutex_lock(&tp->control);
19411+
19412+ if (changed & NETIF_F_HW_VLAN_CTAG_RX) {
19413+ if (features & NETIF_F_HW_VLAN_CTAG_RX)
19414+ rtl_rx_vlan_en(tp, true);
19415+ else
19416+ rtl_rx_vlan_en(tp, false);
19417+ }
19418+
19419+ mutex_unlock(&tp->control);
19420+
19421+ usb_autopm_put_interface(tp->intf);
19422+
19423+out:
19424+ return ret;
19425+}
19426+
19427+#define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST)
19428+
19429+static u32 __rtl_get_wol(struct r8152 *tp)
19430+{
19431+ u32 ocp_data;
19432+ u32 wolopts = 0;
19433+
19434+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CONFIG5);
19435+ if (!(ocp_data & LAN_WAKE_EN))
19436+ return 0;
19437+
19438+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
19439+ if (ocp_data & LINK_ON_WAKE_EN)
19440+ wolopts |= WAKE_PHY;
19441+
19442+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG5);
19443+ if (ocp_data & UWF_EN)
19444+ wolopts |= WAKE_UCAST;
19445+ if (ocp_data & BWF_EN)
19446+ wolopts |= WAKE_BCAST;
19447+ if (ocp_data & MWF_EN)
19448+ wolopts |= WAKE_MCAST;
19449+
19450+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CFG_WOL);
19451+ if (ocp_data & MAGIC_EN)
19452+ wolopts |= WAKE_MAGIC;
19453+
19454+ return wolopts;
19455+}
19456+
19457+static void __rtl_set_wol(struct r8152 *tp, u32 wolopts)
19458+{
19459+ u32 ocp_data;
19460+
19461+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
19462+
19463+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
19464+ ocp_data &= ~LINK_ON_WAKE_EN;
19465+ if (wolopts & WAKE_PHY)
19466+ ocp_data |= LINK_ON_WAKE_EN;
19467+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG34, ocp_data);
19468+
19469+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG5);
19470+ ocp_data &= ~(UWF_EN | BWF_EN | MWF_EN | LAN_WAKE_EN);
19471+ if (wolopts & WAKE_UCAST)
19472+ ocp_data |= UWF_EN;
19473+ if (wolopts & WAKE_BCAST)
19474+ ocp_data |= BWF_EN;
19475+ if (wolopts & WAKE_MCAST)
19476+ ocp_data |= MWF_EN;
19477+ if (wolopts & WAKE_ANY)
19478+ ocp_data |= LAN_WAKE_EN;
19479+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG5, ocp_data);
19480+
19481+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
19482+
19483+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CFG_WOL);
19484+ ocp_data &= ~MAGIC_EN;
19485+ if (wolopts & WAKE_MAGIC)
19486+ ocp_data |= MAGIC_EN;
19487+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_CFG_WOL, ocp_data);
19488+
19489+ if (wolopts & WAKE_ANY)
19490+ device_set_wakeup_enable(&tp->udev->dev, true);
19491+ else
19492+ device_set_wakeup_enable(&tp->udev->dev, false);
19493+}
19494+
19495+static void rtl_runtime_suspend_enable(struct r8152 *tp, bool enable)
19496+{
19497+ if (enable) {
19498+ u32 ocp_data;
19499+
19500+ __rtl_set_wol(tp, WAKE_ANY);
19501+
19502+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
19503+
19504+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CONFIG34);
19505+ ocp_data |= LINK_OFF_WAKE_EN;
19506+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_CONFIG34, ocp_data);
19507+
19508+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
19509+ } else {
19510+ __rtl_set_wol(tp, tp->saved_wolopts);
19511+ }
19512+}
19513+
19514+static void rtl_phy_reset(struct r8152 *tp)
19515+{
19516+ u16 data;
19517+ int i;
19518+
19519+ clear_bit(PHY_RESET, &tp->flags);
19520+
19521+ data = r8152_mdio_read(tp, MII_BMCR);
19522+
19523+ /* don't reset again before the previous one complete */
19524+ if (data & BMCR_RESET)
19525+ return;
19526+
19527+ data |= BMCR_RESET;
19528+ r8152_mdio_write(tp, MII_BMCR, data);
19529+
19530+ for (i = 0; i < 50; i++) {
19531+ msleep(20);
19532+ if ((r8152_mdio_read(tp, MII_BMCR) & BMCR_RESET) == 0)
19533+ break;
19534+ }
19535+}
19536+
19537+static void r8153_teredo_off(struct r8152 *tp)
19538+{
19539+ u32 ocp_data;
19540+
19541+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG);
19542+ ocp_data &= ~(TEREDO_SEL | TEREDO_RS_EVENT_MASK | OOB_TEREDO_EN);
19543+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data);
19544+
19545+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_WDT6_CTRL, WDT6_SET_MODE);
19546+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_REALWOW_TIMER, 0);
19547+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TEREDO_TIMER, 0);
19548+}
19549+
19550+static void r8152b_disable_aldps(struct r8152 *tp)
19551+{
19552+ ocp_reg_write(tp, OCP_ALDPS_CONFIG, ENPDNPS | LINKENA | DIS_SDSAVE);
19553+ msleep(20);
19554+}
19555+
19556+static inline void r8152b_enable_aldps(struct r8152 *tp)
19557+{
19558+ ocp_reg_write(tp, OCP_ALDPS_CONFIG, ENPWRSAVE | ENPDNPS |
19559+ LINKENA | DIS_SDSAVE);
19560+}
19561+
19562+static void rtl8152_disable(struct r8152 *tp)
19563+{
19564+ r8152b_disable_aldps(tp);
19565+ rtl_disable(tp);
19566+ r8152b_enable_aldps(tp);
19567+}
19568+
19569+static void r8152b_hw_phy_cfg(struct r8152 *tp)
19570+{
19571+ u16 data;
19572+
19573+ data = r8152_mdio_read(tp, MII_BMCR);
19574+ if (data & BMCR_PDOWN) {
19575+ data &= ~BMCR_PDOWN;
19576+ r8152_mdio_write(tp, MII_BMCR, data);
19577+ }
19578+
19579+ set_bit(PHY_RESET, &tp->flags);
19580+}
19581+
19582+static void r8152b_exit_oob(struct r8152 *tp)
19583+{
19584+ u32 ocp_data;
19585+ int i;
19586+
19587+ ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
19588+ ocp_data &= ~RCR_ACPT_ALL;
19589+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
19590+
19591+ rxdy_gated_en(tp, true);
19592+ r8153_teredo_off(tp);
19593+ r8152b_hw_phy_cfg(tp);
19594+
19595+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
19596+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, 0x00);
19597+
19598+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19599+ ocp_data &= ~NOW_IS_OOB;
19600+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
19601+
19602+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
19603+ ocp_data &= ~MCU_BORW_EN;
19604+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
19605+
19606+ for (i = 0; i < 1000; i++) {
19607+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19608+ if (ocp_data & LINK_LIST_READY)
19609+ break;
19610+ usleep_range(1000, 2000);
19611+ }
19612+
19613+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
19614+ ocp_data |= RE_INIT_LL;
19615+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
19616+
19617+ for (i = 0; i < 1000; i++) {
19618+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19619+ if (ocp_data & LINK_LIST_READY)
19620+ break;
19621+ usleep_range(1000, 2000);
19622+ }
19623+
19624+ rtl8152_nic_reset(tp);
19625+
19626+ /* rx share fifo credit full threshold */
19627+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_NORMAL);
19628+
19629+ if (tp->udev->speed == USB_SPEED_FULL ||
19630+ tp->udev->speed == USB_SPEED_LOW) {
19631+ /* rx share fifo credit near full threshold */
19632+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1,
19633+ RXFIFO_THR2_FULL);
19634+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2,
19635+ RXFIFO_THR3_FULL);
19636+ } else {
19637+ /* rx share fifo credit near full threshold */
19638+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1,
19639+ RXFIFO_THR2_HIGH);
19640+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2,
19641+ RXFIFO_THR3_HIGH);
19642+ }
19643+
19644+ /* TX share fifo free credit full threshold */
19645+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, TXFIFO_THR_NORMAL);
19646+
19647+ ocp_write_byte(tp, MCU_TYPE_USB, USB_TX_AGG, TX_AGG_MAX_THRESHOLD);
19648+ ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, RX_THR_HIGH);
19649+ ocp_write_dword(tp, MCU_TYPE_USB, USB_TX_DMA,
19650+ TEST_MODE_DISABLE | TX_SIZE_ADJUST1);
19651+
19652+ rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX);
19653+
19654+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8152_RMS);
19655+
19656+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0);
19657+ ocp_data |= TCR0_AUTO_FIFO;
19658+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR0, ocp_data);
19659+}
19660+
19661+static void r8152b_enter_oob(struct r8152 *tp)
19662+{
19663+ u32 ocp_data;
19664+ int i;
19665+
19666+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19667+ ocp_data &= ~NOW_IS_OOB;
19668+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
19669+
19670+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_OOB);
19671+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_OOB);
19672+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_OOB);
19673+
19674+ rtl_disable(tp);
19675+
19676+ for (i = 0; i < 1000; i++) {
19677+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19678+ if (ocp_data & LINK_LIST_READY)
19679+ break;
19680+ usleep_range(1000, 2000);
19681+ }
19682+
19683+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
19684+ ocp_data |= RE_INIT_LL;
19685+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
19686+
19687+ for (i = 0; i < 1000; i++) {
19688+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19689+ if (ocp_data & LINK_LIST_READY)
19690+ break;
19691+ usleep_range(1000, 2000);
19692+ }
19693+
19694+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8152_RMS);
19695+
19696+ rtl_rx_vlan_en(tp, true);
19697+
19698+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PAL_BDC_CR);
19699+ ocp_data |= ALDPS_PROXY_MODE;
19700+ ocp_write_word(tp, MCU_TYPE_PLA, PAL_BDC_CR, ocp_data);
19701+
19702+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19703+ ocp_data |= NOW_IS_OOB | DIS_MCU_CLROOB;
19704+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
19705+
19706+ rxdy_gated_en(tp, false);
19707+
19708+ ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
19709+ ocp_data |= RCR_APM | RCR_AM | RCR_AB;
19710+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
19711+}
19712+
19713+static void r8153_hw_phy_cfg(struct r8152 *tp)
19714+{
19715+ u32 ocp_data;
19716+ u16 data;
19717+
19718+ ocp_reg_write(tp, OCP_ADC_CFG, CKADSEL_L | ADC_EN | EN_EMI_L);
19719+ data = r8152_mdio_read(tp, MII_BMCR);
19720+ if (data & BMCR_PDOWN) {
19721+ data &= ~BMCR_PDOWN;
19722+ r8152_mdio_write(tp, MII_BMCR, data);
19723+ }
19724+
19725+ if (tp->version == RTL_VER_03) {
19726+ data = ocp_reg_read(tp, OCP_EEE_CFG);
19727+ data &= ~CTAP_SHORT_EN;
19728+ ocp_reg_write(tp, OCP_EEE_CFG, data);
19729+ }
19730+
19731+ data = ocp_reg_read(tp, OCP_POWER_CFG);
19732+ data |= EEE_CLKDIV_EN;
19733+ ocp_reg_write(tp, OCP_POWER_CFG, data);
19734+
19735+ data = ocp_reg_read(tp, OCP_DOWN_SPEED);
19736+ data |= EN_10M_BGOFF;
19737+ ocp_reg_write(tp, OCP_DOWN_SPEED, data);
19738+ data = ocp_reg_read(tp, OCP_POWER_CFG);
19739+ data |= EN_10M_PLLOFF;
19740+ ocp_reg_write(tp, OCP_POWER_CFG, data);
19741+ data = sram_read(tp, SRAM_IMPEDANCE);
19742+ data &= ~RX_DRIVING_MASK;
19743+ sram_write(tp, SRAM_IMPEDANCE, data);
19744+
19745+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
19746+ ocp_data |= PFM_PWM_SWITCH;
19747+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
19748+
19749+ data = sram_read(tp, SRAM_LPF_CFG);
19750+ data |= LPF_AUTO_TUNE;
19751+ sram_write(tp, SRAM_LPF_CFG, data);
19752+
19753+ data = sram_read(tp, SRAM_10M_AMP1);
19754+ data |= GDAC_IB_UPALL;
19755+ sram_write(tp, SRAM_10M_AMP1, data);
19756+ data = sram_read(tp, SRAM_10M_AMP2);
19757+ data |= AMP_DN;
19758+ sram_write(tp, SRAM_10M_AMP2, data);
19759+
19760+ set_bit(PHY_RESET, &tp->flags);
19761+}
19762+
19763+static void r8153_u1u2en(struct r8152 *tp, bool enable)
19764+{
19765+ u8 u1u2[8];
19766+
19767+ if (enable)
19768+ memset(u1u2, 0xff, sizeof(u1u2));
19769+ else
19770+ memset(u1u2, 0x00, sizeof(u1u2));
19771+
19772+ usb_ocp_write(tp, USB_TOLERANCE, BYTE_EN_SIX_BYTES, sizeof(u1u2), u1u2);
19773+}
19774+
19775+static void r8153_u2p3en(struct r8152 *tp, bool enable)
19776+{
19777+ u32 ocp_data;
19778+
19779+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL);
19780+ if (enable)
19781+ ocp_data |= U2P3_ENABLE;
19782+ else
19783+ ocp_data &= ~U2P3_ENABLE;
19784+ ocp_write_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL, ocp_data);
19785+}
19786+
19787+static void r8153_power_cut_en(struct r8152 *tp, bool enable)
19788+{
19789+ u32 ocp_data;
19790+
19791+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_POWER_CUT);
19792+ if (enable)
19793+ ocp_data |= PWR_EN | PHASE2_EN;
19794+ else
19795+ ocp_data &= ~(PWR_EN | PHASE2_EN);
19796+ ocp_write_word(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);
19797+
19798+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
19799+ ocp_data &= ~PCUT_STATUS;
19800+ ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data);
19801+}
19802+
19803+static void r8153_first_init(struct r8152 *tp)
19804+{
19805+ u32 ocp_data;
19806+ int i;
19807+
19808+ rxdy_gated_en(tp, true);
19809+ r8153_teredo_off(tp);
19810+
19811+ ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
19812+ ocp_data &= ~RCR_ACPT_ALL;
19813+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
19814+
19815+ r8153_hw_phy_cfg(tp);
19816+
19817+ rtl8152_nic_reset(tp);
19818+
19819+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19820+ ocp_data &= ~NOW_IS_OOB;
19821+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
19822+
19823+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
19824+ ocp_data &= ~MCU_BORW_EN;
19825+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
19826+
19827+ for (i = 0; i < 1000; i++) {
19828+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19829+ if (ocp_data & LINK_LIST_READY)
19830+ break;
19831+ usleep_range(1000, 2000);
19832+ }
19833+
19834+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
19835+ ocp_data |= RE_INIT_LL;
19836+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
19837+
19838+ for (i = 0; i < 1000; i++) {
19839+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19840+ if (ocp_data & LINK_LIST_READY)
19841+ break;
19842+ usleep_range(1000, 2000);
19843+ }
19844+
19845+ rtl_rx_vlan_en(tp, tp->netdev->features & NETIF_F_HW_VLAN_CTAG_RX);
19846+
19847+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8153_RMS);
19848+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, MTPS_JUMBO);
19849+
19850+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0);
19851+ ocp_data |= TCR0_AUTO_FIFO;
19852+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR0, ocp_data);
19853+
19854+ rtl8152_nic_reset(tp);
19855+
19856+ /* rx share fifo credit full threshold */
19857+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_NORMAL);
19858+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_NORMAL);
19859+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_NORMAL);
19860+ /* TX share fifo free credit full threshold */
19861+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, TXFIFO_THR_NORMAL2);
19862+
19863+ /* rx aggregation */
19864+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
19865+ ocp_data &= ~RX_AGG_DISABLE;
19866+ ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
19867+}
19868+
19869+static void r8153_enter_oob(struct r8152 *tp)
19870+{
19871+ u32 ocp_data;
19872+ int i;
19873+
19874+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19875+ ocp_data &= ~NOW_IS_OOB;
19876+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
19877+
19878+ rtl_disable(tp);
19879+
19880+ for (i = 0; i < 1000; i++) {
19881+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19882+ if (ocp_data & LINK_LIST_READY)
19883+ break;
19884+ usleep_range(1000, 2000);
19885+ }
19886+
19887+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
19888+ ocp_data |= RE_INIT_LL;
19889+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);
19890+
19891+ for (i = 0; i < 1000; i++) {
19892+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19893+ if (ocp_data & LINK_LIST_READY)
19894+ break;
19895+ usleep_range(1000, 2000);
19896+ }
19897+
19898+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8153_RMS);
19899+
19900+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG);
19901+ ocp_data &= ~TEREDO_WAKE_MASK;
19902+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data);
19903+
19904+ rtl_rx_vlan_en(tp, true);
19905+
19906+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PAL_BDC_CR);
19907+ ocp_data |= ALDPS_PROXY_MODE;
19908+ ocp_write_word(tp, MCU_TYPE_PLA, PAL_BDC_CR, ocp_data);
19909+
19910+ ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
19911+ ocp_data |= NOW_IS_OOB | DIS_MCU_CLROOB;
19912+ ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);
19913+
19914+ rxdy_gated_en(tp, false);
19915+
19916+ ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
19917+ ocp_data |= RCR_APM | RCR_AM | RCR_AB;
19918+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
19919+}
19920+
19921+static void r8153_disable_aldps(struct r8152 *tp)
19922+{
19923+ u16 data;
19924+
19925+ data = ocp_reg_read(tp, OCP_POWER_CFG);
19926+ data &= ~EN_ALDPS;
19927+ ocp_reg_write(tp, OCP_POWER_CFG, data);
19928+ msleep(20);
19929+}
19930+
19931+static void r8153_enable_aldps(struct r8152 *tp)
19932+{
19933+ u16 data;
19934+
19935+ data = ocp_reg_read(tp, OCP_POWER_CFG);
19936+ data |= EN_ALDPS;
19937+ ocp_reg_write(tp, OCP_POWER_CFG, data);
19938+}
19939+
19940+static void rtl8153_disable(struct r8152 *tp)
19941+{
19942+ r8153_disable_aldps(tp);
19943+ rtl_disable(tp);
19944+ r8153_enable_aldps(tp);
19945+}
19946+
19947+static int rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u16 speed, u8 duplex)
19948+{
19949+ u16 bmcr, anar, gbcr;
19950+ int ret = 0;
19951+
19952+ cancel_delayed_work_sync(&tp->schedule);
19953+ anar = r8152_mdio_read(tp, MII_ADVERTISE);
19954+ anar &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL |
19955+ ADVERTISE_100HALF | ADVERTISE_100FULL);
19956+ if (tp->mii.supports_gmii) {
19957+ gbcr = r8152_mdio_read(tp, MII_CTRL1000);
19958+ gbcr &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
19959+ } else {
19960+ gbcr = 0;
19961+ }
19962+
19963+ if (autoneg == AUTONEG_DISABLE) {
19964+ if (speed == SPEED_10) {
19965+ bmcr = 0;
19966+ anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
19967+ } else if (speed == SPEED_100) {
19968+ bmcr = BMCR_SPEED100;
19969+ anar |= ADVERTISE_100HALF | ADVERTISE_100FULL;
19970+ } else if (speed == SPEED_1000 && tp->mii.supports_gmii) {
19971+ bmcr = BMCR_SPEED1000;
19972+ gbcr |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
19973+ } else {
19974+ ret = -EINVAL;
19975+ goto out;
19976+ }
19977+
19978+ if (duplex == DUPLEX_FULL)
19979+ bmcr |= BMCR_FULLDPLX;
19980+ } else {
19981+ if (speed == SPEED_10) {
19982+ if (duplex == DUPLEX_FULL)
19983+ anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
19984+ else
19985+ anar |= ADVERTISE_10HALF;
19986+ } else if (speed == SPEED_100) {
19987+ if (duplex == DUPLEX_FULL) {
19988+ anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
19989+ anar |= ADVERTISE_100HALF | ADVERTISE_100FULL;
19990+ } else {
19991+ anar |= ADVERTISE_10HALF;
19992+ anar |= ADVERTISE_100HALF;
19993+ }
19994+ } else if (speed == SPEED_1000 && tp->mii.supports_gmii) {
19995+ if (duplex == DUPLEX_FULL) {
19996+ anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
19997+ anar |= ADVERTISE_100HALF | ADVERTISE_100FULL;
19998+ gbcr |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
19999+ } else {
20000+ anar |= ADVERTISE_10HALF;
20001+ anar |= ADVERTISE_100HALF;
20002+ gbcr |= ADVERTISE_1000HALF;
20003+ }
20004+ } else {
20005+ ret = -EINVAL;
20006+ goto out;
20007+ }
20008+
20009+ bmcr = BMCR_ANENABLE | BMCR_ANRESTART;
20010+ }
20011+
20012+ if (test_bit(PHY_RESET, &tp->flags))
20013+ bmcr |= BMCR_RESET;
20014+
20015+ if (tp->mii.supports_gmii)
20016+ r8152_mdio_write(tp, MII_CTRL1000, gbcr);
20017+
20018+ r8152_mdio_write(tp, MII_ADVERTISE, anar);
20019+ r8152_mdio_write(tp, MII_BMCR, bmcr);
20020+
20021+ if (test_bit(PHY_RESET, &tp->flags)) {
20022+ int i;
20023+
20024+ clear_bit(PHY_RESET, &tp->flags);
20025+ for (i = 0; i < 50; i++) {
20026+ msleep(20);
20027+ if ((r8152_mdio_read(tp, MII_BMCR) & BMCR_RESET) == 0)
20028+ break;
20029+ }
20030+ }
20031+
20032+out:
20033+
20034+ return ret;
20035+}
20036+
20037+static void rtl8152_up(struct r8152 *tp)
20038+{
20039+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20040+ return;
20041+
20042+ r8152b_disable_aldps(tp);
20043+ r8152b_exit_oob(tp);
20044+ r8152b_enable_aldps(tp);
20045+}
20046+
20047+static void rtl8152_down(struct r8152 *tp)
20048+{
20049+ if (test_bit(RTL8152_UNPLUG, &tp->flags)) {
20050+ rtl_drop_queued_tx(tp);
20051+ return;
20052+ }
20053+
20054+ r8152_power_cut_en(tp, false);
20055+ r8152b_disable_aldps(tp);
20056+ r8152b_enter_oob(tp);
20057+ r8152b_enable_aldps(tp);
20058+}
20059+
20060+static void rtl8153_up(struct r8152 *tp)
20061+{
20062+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20063+ return;
20064+
20065+ r8153_disable_aldps(tp);
20066+ r8153_first_init(tp);
20067+ r8153_enable_aldps(tp);
20068+}
20069+
20070+static void rtl8153_down(struct r8152 *tp)
20071+{
20072+ if (test_bit(RTL8152_UNPLUG, &tp->flags)) {
20073+ rtl_drop_queued_tx(tp);
20074+ return;
20075+ }
20076+
20077+ r8153_u1u2en(tp, false);
20078+ r8153_power_cut_en(tp, false);
20079+ r8153_disable_aldps(tp);
20080+ r8153_enter_oob(tp);
20081+ r8153_enable_aldps(tp);
20082+}
20083+
20084+static void set_carrier(struct r8152 *tp)
20085+{
20086+ struct net_device *netdev = tp->netdev;
20087+ u8 speed;
20088+
20089+ clear_bit(RTL8152_LINK_CHG, &tp->flags);
20090+ speed = rtl8152_get_speed(tp);
20091+
20092+ if (speed & LINK_STATUS) {
20093+ if (!(tp->speed & LINK_STATUS)) {
20094+ tp->rtl_ops.enable(tp);
20095+ set_bit(RTL8152_SET_RX_MODE, &tp->flags);
20096+ netif_carrier_on(netdev);
20097+ }
20098+ } else {
20099+ if (tp->speed & LINK_STATUS) {
20100+ netif_carrier_off(netdev);
20101+ tasklet_disable(&tp->tl);
20102+ tp->rtl_ops.disable(tp);
20103+ tasklet_enable(&tp->tl);
20104+ }
20105+ }
20106+ tp->speed = speed;
20107+}
20108+
20109+static void rtl_work_func_t(struct work_struct *work)
20110+{
20111+ struct r8152 *tp = container_of(work, struct r8152, schedule.work);
20112+
20113+ if (usb_autopm_get_interface(tp->intf) < 0)
20114+ return;
20115+
20116+ if (!test_bit(WORK_ENABLE, &tp->flags))
20117+ goto out1;
20118+
20119+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20120+ goto out1;
20121+
20122+ if (!mutex_trylock(&tp->control)) {
20123+ schedule_delayed_work(&tp->schedule, 0);
20124+ goto out1;
20125+ }
20126+
20127+ if (test_bit(RTL8152_LINK_CHG, &tp->flags))
20128+ set_carrier(tp);
20129+
20130+ if (test_bit(RTL8152_SET_RX_MODE, &tp->flags))
20131+ _rtl8152_set_rx_mode(tp->netdev);
20132+
20133+ if (test_bit(SCHEDULE_TASKLET, &tp->flags) &&
20134+ (tp->speed & LINK_STATUS)) {
20135+ clear_bit(SCHEDULE_TASKLET, &tp->flags);
20136+ tasklet_schedule(&tp->tl);
20137+ }
20138+
20139+ if (test_bit(PHY_RESET, &tp->flags))
20140+ rtl_phy_reset(tp);
20141+
20142+ mutex_unlock(&tp->control);
20143+
20144+out1:
20145+ usb_autopm_put_interface(tp->intf);
20146+}
20147+
20148+static int rtl8152_open(struct net_device *netdev)
20149+{
20150+ struct r8152 *tp = netdev_priv(netdev);
20151+ int res = 0;
20152+
20153+ res = alloc_all_mem(tp);
20154+ if (res)
20155+ goto out;
20156+
20157+ /* set speed to 0 to avoid autoresume try to submit rx */
20158+ tp->speed = 0;
20159+
20160+ res = usb_autopm_get_interface(tp->intf);
20161+ if (res < 0) {
20162+ free_all_mem(tp);
20163+ goto out;
20164+ }
20165+
20166+ mutex_lock(&tp->control);
20167+
20168+ /* The WORK_ENABLE may be set when autoresume occurs */
20169+ if (test_bit(WORK_ENABLE, &tp->flags)) {
20170+ clear_bit(WORK_ENABLE, &tp->flags);
20171+ usb_kill_urb(tp->intr_urb);
20172+ cancel_delayed_work_sync(&tp->schedule);
20173+
20174+ /* disable the tx/rx, if the workqueue has enabled them. */
20175+ if (tp->speed & LINK_STATUS)
20176+ tp->rtl_ops.disable(tp);
20177+ }
20178+
20179+ tp->rtl_ops.up(tp);
20180+
20181+ rtl8152_set_speed(tp, AUTONEG_ENABLE,
20182+ tp->mii.supports_gmii ? SPEED_1000 : SPEED_100,
20183+ DUPLEX_FULL);
20184+ tp->speed = 0;
20185+ netif_carrier_off(netdev);
20186+ netif_start_queue(netdev);
20187+ set_bit(WORK_ENABLE, &tp->flags);
20188+
20189+ res = usb_submit_urb(tp->intr_urb, GFP_KERNEL);
20190+ if (res) {
20191+ if (res == -ENODEV)
20192+ netif_device_detach(tp->netdev);
20193+ netif_warn(tp, ifup, netdev, "intr_urb submit failed: %d\n",
20194+ res);
20195+ free_all_mem(tp);
20196+ }
20197+
20198+ mutex_unlock(&tp->control);
20199+
20200+ usb_autopm_put_interface(tp->intf);
20201+
20202+out:
20203+ return res;
20204+}
20205+
20206+static int rtl8152_close(struct net_device *netdev)
20207+{
20208+ struct r8152 *tp = netdev_priv(netdev);
20209+ int res = 0;
20210+
20211+ clear_bit(WORK_ENABLE, &tp->flags);
20212+ usb_kill_urb(tp->intr_urb);
20213+ cancel_delayed_work_sync(&tp->schedule);
20214+ netif_stop_queue(netdev);
20215+
20216+ res = usb_autopm_get_interface(tp->intf);
20217+ if (res < 0) {
20218+ rtl_drop_queued_tx(tp);
20219+ } else {
20220+ mutex_lock(&tp->control);
20221+
20222+ /* The autosuspend may have been enabled and wouldn't
20223+ * be disable when autoresume occurs, because the
20224+ * netif_running() would be false.
20225+ */
20226+ rtl_runtime_suspend_enable(tp, false);
20227+
20228+ tasklet_disable(&tp->tl);
20229+ tp->rtl_ops.down(tp);
20230+ tasklet_enable(&tp->tl);
20231+
20232+ mutex_unlock(&tp->control);
20233+
20234+ usb_autopm_put_interface(tp->intf);
20235+ }
20236+
20237+ free_all_mem(tp);
20238+
20239+ return res;
20240+}
20241+
20242+static inline void r8152_mmd_indirect(struct r8152 *tp, u16 dev, u16 reg)
20243+{
20244+ ocp_reg_write(tp, OCP_EEE_AR, FUN_ADDR | dev);
20245+ ocp_reg_write(tp, OCP_EEE_DATA, reg);
20246+ ocp_reg_write(tp, OCP_EEE_AR, FUN_DATA | dev);
20247+}
20248+
20249+static u16 r8152_mmd_read(struct r8152 *tp, u16 dev, u16 reg)
20250+{
20251+ u16 data;
20252+
20253+ r8152_mmd_indirect(tp, dev, reg);
20254+ data = ocp_reg_read(tp, OCP_EEE_DATA);
20255+ ocp_reg_write(tp, OCP_EEE_AR, 0x0000);
20256+
20257+ return data;
20258+}
20259+
20260+static void r8152_mmd_write(struct r8152 *tp, u16 dev, u16 reg, u16 data)
20261+{
20262+ r8152_mmd_indirect(tp, dev, reg);
20263+ ocp_reg_write(tp, OCP_EEE_DATA, data);
20264+ ocp_reg_write(tp, OCP_EEE_AR, 0x0000);
20265+}
20266+
20267+static void r8152_eee_en(struct r8152 *tp, bool enable)
20268+{
20269+ u16 config1, config2, config3;
20270+ u32 ocp_data;
20271+
20272+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEE_CR);
20273+ config1 = ocp_reg_read(tp, OCP_EEE_CONFIG1) & ~sd_rise_time_mask;
20274+ config2 = ocp_reg_read(tp, OCP_EEE_CONFIG2);
20275+ config3 = ocp_reg_read(tp, OCP_EEE_CONFIG3) & ~fast_snr_mask;
20276+
20277+ if (enable) {
20278+ ocp_data |= EEE_RX_EN | EEE_TX_EN;
20279+ config1 |= EEE_10_CAP | EEE_NWAY_EN | TX_QUIET_EN | RX_QUIET_EN;
20280+ config1 |= sd_rise_time(1);
20281+ config2 |= RG_DACQUIET_EN | RG_LDVQUIET_EN;
20282+ config3 |= fast_snr(42);
20283+ } else {
20284+ ocp_data &= ~(EEE_RX_EN | EEE_TX_EN);
20285+ config1 &= ~(EEE_10_CAP | EEE_NWAY_EN | TX_QUIET_EN |
20286+ RX_QUIET_EN);
20287+ config1 |= sd_rise_time(7);
20288+ config2 &= ~(RG_DACQUIET_EN | RG_LDVQUIET_EN);
20289+ config3 |= fast_snr(511);
20290+ }
20291+
20292+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEE_CR, ocp_data);
20293+ ocp_reg_write(tp, OCP_EEE_CONFIG1, config1);
20294+ ocp_reg_write(tp, OCP_EEE_CONFIG2, config2);
20295+ ocp_reg_write(tp, OCP_EEE_CONFIG3, config3);
20296+}
20297+
20298+static void r8152b_enable_eee(struct r8152 *tp)
20299+{
20300+ r8152_eee_en(tp, true);
20301+ r8152_mmd_write(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, MDIO_EEE_100TX);
20302+}
20303+
20304+static void r8153_eee_en(struct r8152 *tp, bool enable)
20305+{
20306+ u32 ocp_data;
20307+ u16 config;
20308+
20309+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEE_CR);
20310+ config = ocp_reg_read(tp, OCP_EEE_CFG);
20311+
20312+ if (enable) {
20313+ ocp_data |= EEE_RX_EN | EEE_TX_EN;
20314+ config |= EEE10_EN;
20315+ } else {
20316+ ocp_data &= ~(EEE_RX_EN | EEE_TX_EN);
20317+ config &= ~EEE10_EN;
20318+ }
20319+
20320+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEE_CR, ocp_data);
20321+ ocp_reg_write(tp, OCP_EEE_CFG, config);
20322+}
20323+
20324+static void r8153_enable_eee(struct r8152 *tp)
20325+{
20326+ r8153_eee_en(tp, true);
20327+ ocp_reg_write(tp, OCP_EEE_ADV, MDIO_EEE_1000T | MDIO_EEE_100TX);
20328+}
20329+
20330+static void r8152b_enable_fc(struct r8152 *tp)
20331+{
20332+ u16 anar;
20333+
20334+ anar = r8152_mdio_read(tp, MII_ADVERTISE);
20335+ anar |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
20336+ r8152_mdio_write(tp, MII_ADVERTISE, anar);
20337+}
20338+
20339+static void rtl_tally_reset(struct r8152 *tp)
20340+{
20341+ u32 ocp_data;
20342+
20343+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_RSTTALLY);
20344+ ocp_data |= TALLY_RESET;
20345+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_RSTTALLY, ocp_data);
20346+}
20347+
20348+static void r8152b_init(struct r8152 *tp)
20349+{
20350+ u32 ocp_data;
20351+
20352+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20353+ return;
20354+
20355+ r8152b_disable_aldps(tp);
20356+
20357+ if (tp->version == RTL_VER_01) {
20358+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE);
20359+ ocp_data &= ~LED_MODE_MASK;
20360+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE, ocp_data);
20361+ }
20362+
20363+ r8152_power_cut_en(tp, false);
20364+
20365+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
20366+ ocp_data |= TX_10M_IDLE_EN | PFM_PWM_SWITCH;
20367+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
20368+ ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL);
20369+ ocp_data &= ~MCU_CLK_RATIO_MASK;
20370+ ocp_data |= MCU_CLK_RATIO | D3_CLK_GATED_EN;
20371+ ocp_write_dword(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL, ocp_data);
20372+ ocp_data = GPHY_STS_MSK | SPEED_DOWN_MSK |
20373+ SPDWN_RXDV_MSK | SPDWN_LINKCHG_MSK;
20374+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_GPHY_INTR_IMR, ocp_data);
20375+
20376+ r8152b_enable_eee(tp);
20377+ r8152b_enable_aldps(tp);
20378+ r8152b_enable_fc(tp);
20379+ rtl_tally_reset(tp);
20380+
20381+ /* enable rx aggregation */
20382+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
20383+ ocp_data &= ~RX_AGG_DISABLE;
20384+ ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
20385+}
20386+
20387+static void r8153_init(struct r8152 *tp)
20388+{
20389+ u32 ocp_data;
20390+ int i;
20391+
20392+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20393+ return;
20394+
20395+ r8153_disable_aldps(tp);
20396+ r8153_u1u2en(tp, false);
20397+
20398+ for (i = 0; i < 500; i++) {
20399+ if (ocp_read_word(tp, MCU_TYPE_PLA, PLA_BOOT_CTRL) &
20400+ AUTOLOAD_DONE)
20401+ break;
20402+ msleep(20);
20403+ }
20404+
20405+ for (i = 0; i < 500; i++) {
20406+ ocp_data = ocp_reg_read(tp, OCP_PHY_STATUS) & PHY_STAT_MASK;
20407+ if (ocp_data == PHY_STAT_LAN_ON || ocp_data == PHY_STAT_PWRDN)
20408+ break;
20409+ msleep(20);
20410+ }
20411+
20412+ r8153_u2p3en(tp, false);
20413+
20414+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_WDT11_CTRL);
20415+ ocp_data &= ~TIMER11_EN;
20416+ ocp_write_word(tp, MCU_TYPE_USB, USB_WDT11_CTRL, ocp_data);
20417+
20418+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE);
20419+ ocp_data &= ~LED_MODE_MASK;
20420+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE, ocp_data);
20421+
20422+ ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_LPM_CTRL);
20423+ ocp_data &= ~LPM_TIMER_MASK;
20424+ if (tp->udev->speed == USB_SPEED_SUPER)
20425+ ocp_data |= LPM_TIMER_500US;
20426+ else
20427+ ocp_data |= LPM_TIMER_500MS;
20428+ ocp_write_byte(tp, MCU_TYPE_USB, USB_LPM_CTRL, ocp_data);
20429+
20430+ ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_AFE_CTRL2);
20431+ ocp_data &= ~SEN_VAL_MASK;
20432+ ocp_data |= SEN_VAL_NORMAL | SEL_RXIDLE;
20433+ ocp_write_word(tp, MCU_TYPE_USB, USB_AFE_CTRL2, ocp_data);
20434+
20435+ r8153_power_cut_en(tp, false);
20436+ r8153_u1u2en(tp, true);
20437+
20438+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL, ALDPS_SPDWN_RATIO);
20439+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, EEE_SPDWN_RATIO);
20440+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3,
20441+ PKT_AVAIL_SPDWN_EN | SUSPEND_SPDWN_EN |
20442+ U1U2_SPDWN_EN | L1_SPDWN_EN);
20443+ ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL4,
20444+ PWRSAVE_SPDWN_EN | RXDV_SPDWN_EN | TX10MIDLE_EN |
20445+ TP100_SPDWN_EN | TP500_SPDWN_EN | TP1000_SPDWN_EN |
20446+ EEE_SPDWN_EN);
20447+
20448+ r8153_enable_eee(tp);
20449+ r8153_enable_aldps(tp);
20450+ r8152b_enable_fc(tp);
20451+ rtl_tally_reset(tp);
20452+}
20453+
20454+static int rtl8152_suspend(struct usb_interface *intf, pm_message_t message)
20455+{
20456+ struct r8152 *tp = usb_get_intfdata(intf);
20457+ struct net_device *netdev = tp->netdev;
20458+ int ret = 0;
20459+
20460+ mutex_lock(&tp->control);
20461+
20462+ if (PMSG_IS_AUTO(message)) {
20463+ if (netif_running(netdev) && work_busy(&tp->schedule.work)) {
20464+ ret = -EBUSY;
20465+ goto out1;
20466+ }
20467+
20468+ set_bit(SELECTIVE_SUSPEND, &tp->flags);
20469+ } else {
20470+ netif_device_detach(netdev);
20471+ }
20472+
20473+ if (netif_running(netdev) && test_bit(WORK_ENABLE, &tp->flags)) {
20474+ clear_bit(WORK_ENABLE, &tp->flags);
20475+ usb_kill_urb(tp->intr_urb);
20476+ tasklet_disable(&tp->tl);
20477+ if (test_bit(SELECTIVE_SUSPEND, &tp->flags)) {
20478+ rtl_stop_rx(tp);
20479+ rtl_runtime_suspend_enable(tp, true);
20480+ } else {
20481+ cancel_delayed_work_sync(&tp->schedule);
20482+ tp->rtl_ops.down(tp);
20483+ }
20484+ tasklet_enable(&tp->tl);
20485+ }
20486+out1:
20487+ mutex_unlock(&tp->control);
20488+
20489+ return ret;
20490+}
20491+
20492+static int rtl8152_resume(struct usb_interface *intf)
20493+{
20494+ struct r8152 *tp = usb_get_intfdata(intf);
20495+
20496+ mutex_lock(&tp->control);
20497+
20498+ if (!test_bit(SELECTIVE_SUSPEND, &tp->flags)) {
20499+ tp->rtl_ops.init(tp);
20500+ netif_device_attach(tp->netdev);
20501+ }
20502+
20503+ if (netif_running(tp->netdev)) {
20504+ if (test_bit(SELECTIVE_SUSPEND, &tp->flags)) {
20505+ rtl_runtime_suspend_enable(tp, false);
20506+ clear_bit(SELECTIVE_SUSPEND, &tp->flags);
20507+ set_bit(WORK_ENABLE, &tp->flags);
20508+ if (tp->speed & LINK_STATUS)
20509+ rtl_start_rx(tp);
20510+ } else {
20511+ tp->rtl_ops.up(tp);
20512+ rtl8152_set_speed(tp, AUTONEG_ENABLE,
20513+ tp->mii.supports_gmii ?
20514+ SPEED_1000 : SPEED_100,
20515+ DUPLEX_FULL);
20516+ tp->speed = 0;
20517+ netif_carrier_off(tp->netdev);
20518+ set_bit(WORK_ENABLE, &tp->flags);
20519+ }
20520+ usb_submit_urb(tp->intr_urb, GFP_KERNEL);
20521+ } else if (test_bit(SELECTIVE_SUSPEND, &tp->flags)) {
20522+ clear_bit(SELECTIVE_SUSPEND, &tp->flags);
20523+ }
20524+
20525+ mutex_unlock(&tp->control);
20526+
20527+ return 0;
20528+}
20529+
20530+static void rtl8152_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
20531+{
20532+ struct r8152 *tp = netdev_priv(dev);
20533+
20534+ if (usb_autopm_get_interface(tp->intf) < 0)
20535+ return;
20536+
20537+ mutex_lock(&tp->control);
20538+
20539+ wol->supported = WAKE_ANY;
20540+ wol->wolopts = __rtl_get_wol(tp);
20541+
20542+ mutex_unlock(&tp->control);
20543+
20544+ usb_autopm_put_interface(tp->intf);
20545+}
20546+
20547+static int rtl8152_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
20548+{
20549+ struct r8152 *tp = netdev_priv(dev);
20550+ int ret;
20551+
20552+ ret = usb_autopm_get_interface(tp->intf);
20553+ if (ret < 0)
20554+ goto out_set_wol;
20555+
20556+ mutex_lock(&tp->control);
20557+
20558+ __rtl_set_wol(tp, wol->wolopts);
20559+ tp->saved_wolopts = wol->wolopts & WAKE_ANY;
20560+
20561+ mutex_unlock(&tp->control);
20562+
20563+ usb_autopm_put_interface(tp->intf);
20564+
20565+out_set_wol:
20566+ return ret;
20567+}
20568+
20569+static u32 rtl8152_get_msglevel(struct net_device *dev)
20570+{
20571+ struct r8152 *tp = netdev_priv(dev);
20572+
20573+ return tp->msg_enable;
20574+}
20575+
20576+static void rtl8152_set_msglevel(struct net_device *dev, u32 value)
20577+{
20578+ struct r8152 *tp = netdev_priv(dev);
20579+
20580+ tp->msg_enable = value;
20581+}
20582+
20583+static void rtl8152_get_drvinfo(struct net_device *netdev,
20584+ struct ethtool_drvinfo *info)
20585+{
20586+ struct r8152 *tp = netdev_priv(netdev);
20587+
20588+ strlcpy(info->driver, MODULENAME, sizeof(info->driver));
20589+ strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
20590+ usb_make_path(tp->udev, info->bus_info, sizeof(info->bus_info));
20591+}
20592+
20593+static
20594+int rtl8152_get_settings(struct net_device *netdev, struct ethtool_cmd *cmd)
20595+{
20596+ struct r8152 *tp = netdev_priv(netdev);
20597+ int ret;
20598+
20599+ if (!tp->mii.mdio_read)
20600+ return -EOPNOTSUPP;
20601+
20602+ ret = usb_autopm_get_interface(tp->intf);
20603+ if (ret < 0)
20604+ goto out;
20605+
20606+ mutex_lock(&tp->control);
20607+
20608+ ret = mii_ethtool_gset(&tp->mii, cmd);
20609+
20610+ mutex_unlock(&tp->control);
20611+
20612+ usb_autopm_put_interface(tp->intf);
20613+
20614+out:
20615+ return ret;
20616+}
20617+
20618+static int rtl8152_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
20619+{
20620+ struct r8152 *tp = netdev_priv(dev);
20621+ int ret;
20622+
20623+ ret = usb_autopm_get_interface(tp->intf);
20624+ if (ret < 0)
20625+ goto out;
20626+
20627+ mutex_lock(&tp->control);
20628+
20629+ ret = rtl8152_set_speed(tp, cmd->autoneg, cmd->speed, cmd->duplex);
20630+
20631+ mutex_unlock(&tp->control);
20632+
20633+ usb_autopm_put_interface(tp->intf);
20634+
20635+out:
20636+ return ret;
20637+}
20638+
20639+static const char rtl8152_gstrings[][ETH_GSTRING_LEN] = {
20640+ "tx_packets",
20641+ "rx_packets",
20642+ "tx_errors",
20643+ "rx_errors",
20644+ "rx_missed",
20645+ "align_errors",
20646+ "tx_single_collisions",
20647+ "tx_multi_collisions",
20648+ "rx_unicast",
20649+ "rx_broadcast",
20650+ "rx_multicast",
20651+ "tx_aborted",
20652+ "tx_underrun",
20653+};
20654+
20655+static int rtl8152_get_sset_count(struct net_device *dev, int sset)
20656+{
20657+ switch (sset) {
20658+ case ETH_SS_STATS:
20659+ return ARRAY_SIZE(rtl8152_gstrings);
20660+ default:
20661+ return -EOPNOTSUPP;
20662+ }
20663+}
20664+
20665+static void rtl8152_get_ethtool_stats(struct net_device *dev,
20666+ struct ethtool_stats *stats, u64 *data)
20667+{
20668+ struct r8152 *tp = netdev_priv(dev);
20669+ struct tally_counter tally;
20670+
20671+ if (usb_autopm_get_interface(tp->intf) < 0)
20672+ return;
20673+
20674+ generic_ocp_read(tp, PLA_TALLYCNT, sizeof(tally), &tally, MCU_TYPE_PLA);
20675+
20676+ usb_autopm_put_interface(tp->intf);
20677+
20678+ data[0] = le64_to_cpu(tally.tx_packets);
20679+ data[1] = le64_to_cpu(tally.rx_packets);
20680+ data[2] = le64_to_cpu(tally.tx_errors);
20681+ data[3] = le32_to_cpu(tally.rx_errors);
20682+ data[4] = le16_to_cpu(tally.rx_missed);
20683+ data[5] = le16_to_cpu(tally.align_errors);
20684+ data[6] = le32_to_cpu(tally.tx_one_collision);
20685+ data[7] = le32_to_cpu(tally.tx_multi_collision);
20686+ data[8] = le64_to_cpu(tally.rx_unicast);
20687+ data[9] = le64_to_cpu(tally.rx_broadcast);
20688+ data[10] = le32_to_cpu(tally.rx_multicast);
20689+ data[11] = le16_to_cpu(tally.tx_aborted);
20690+ data[12] = le16_to_cpu(tally.tx_underun);
20691+}
20692+
20693+static void rtl8152_get_strings(struct net_device *dev, u32 stringset, u8 *data)
20694+{
20695+ switch (stringset) {
20696+ case ETH_SS_STATS:
20697+ memcpy(data, *rtl8152_gstrings, sizeof(rtl8152_gstrings));
20698+ break;
20699+ }
20700+}
20701+
20702+static int r8152_get_eee(struct r8152 *tp, struct ethtool_eee *eee)
20703+{
20704+ u32 ocp_data, lp, adv, supported = 0;
20705+ u16 val;
20706+
20707+ val = r8152_mmd_read(tp, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE);
20708+ supported = mmd_eee_cap_to_ethtool_sup_t(val);
20709+
20710+ val = r8152_mmd_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV);
20711+ adv = mmd_eee_adv_to_ethtool_adv_t(val);
20712+
20713+ val = r8152_mmd_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE);
20714+ lp = mmd_eee_adv_to_ethtool_adv_t(val);
20715+
20716+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEE_CR);
20717+ ocp_data &= EEE_RX_EN | EEE_TX_EN;
20718+
20719+ eee->eee_enabled = !!ocp_data;
20720+ eee->eee_active = !!(supported & adv & lp);
20721+ eee->supported = supported;
20722+ eee->advertised = adv;
20723+ eee->lp_advertised = lp;
20724+
20725+ return 0;
20726+}
20727+
20728+static int r8152_set_eee(struct r8152 *tp, struct ethtool_eee *eee)
20729+{
20730+ u16 val = ethtool_adv_to_mmd_eee_adv_t(eee->advertised);
20731+
20732+ r8152_eee_en(tp, eee->eee_enabled);
20733+
20734+ if (!eee->eee_enabled)
20735+ val = 0;
20736+
20737+ r8152_mmd_write(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, val);
20738+
20739+ return 0;
20740+}
20741+
20742+static int r8153_get_eee(struct r8152 *tp, struct ethtool_eee *eee)
20743+{
20744+ u32 ocp_data, lp, adv, supported = 0;
20745+ u16 val;
20746+
20747+ val = ocp_reg_read(tp, OCP_EEE_ABLE);
20748+ supported = mmd_eee_cap_to_ethtool_sup_t(val);
20749+
20750+ val = ocp_reg_read(tp, OCP_EEE_ADV);
20751+ adv = mmd_eee_adv_to_ethtool_adv_t(val);
20752+
20753+ val = ocp_reg_read(tp, OCP_EEE_LPABLE);
20754+ lp = mmd_eee_adv_to_ethtool_adv_t(val);
20755+
20756+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEE_CR);
20757+ ocp_data &= EEE_RX_EN | EEE_TX_EN;
20758+
20759+ eee->eee_enabled = !!ocp_data;
20760+ eee->eee_active = !!(supported & adv & lp);
20761+ eee->supported = supported;
20762+ eee->advertised = adv;
20763+ eee->lp_advertised = lp;
20764+
20765+ return 0;
20766+}
20767+
20768+static int r8153_set_eee(struct r8152 *tp, struct ethtool_eee *eee)
20769+{
20770+ u16 val = ethtool_adv_to_mmd_eee_adv_t(eee->advertised);
20771+
20772+ r8153_eee_en(tp, eee->eee_enabled);
20773+
20774+ if (!eee->eee_enabled)
20775+ val = 0;
20776+
20777+ ocp_reg_write(tp, OCP_EEE_ADV, val);
20778+
20779+ return 0;
20780+}
20781+
20782+static int
20783+rtl_ethtool_get_eee(struct net_device *net, struct ethtool_eee *edata)
20784+{
20785+ struct r8152 *tp = netdev_priv(net);
20786+ int ret;
20787+
20788+ ret = usb_autopm_get_interface(tp->intf);
20789+ if (ret < 0)
20790+ goto out;
20791+
20792+ mutex_lock(&tp->control);
20793+
20794+ ret = tp->rtl_ops.eee_get(tp, edata);
20795+
20796+ mutex_unlock(&tp->control);
20797+
20798+ usb_autopm_put_interface(tp->intf);
20799+
20800+out:
20801+ return ret;
20802+}
20803+
20804+static int
20805+rtl_ethtool_set_eee(struct net_device *net, struct ethtool_eee *edata)
20806+{
20807+ struct r8152 *tp = netdev_priv(net);
20808+ int ret;
20809+
20810+ ret = usb_autopm_get_interface(tp->intf);
20811+ if (ret < 0)
20812+ goto out;
20813+
20814+ mutex_lock(&tp->control);
20815+
20816+ ret = tp->rtl_ops.eee_set(tp, edata);
20817+ if (!ret)
20818+ ret = mii_nway_restart(&tp->mii);
20819+
20820+ mutex_unlock(&tp->control);
20821+
20822+ usb_autopm_put_interface(tp->intf);
20823+
20824+out:
20825+ return ret;
20826+}
20827+
20828+static struct ethtool_ops ops = {
20829+ .get_drvinfo = rtl8152_get_drvinfo,
20830+ .get_settings = rtl8152_get_settings,
20831+ .set_settings = rtl8152_set_settings,
20832+ .get_link = ethtool_op_get_link,
20833+ .get_msglevel = rtl8152_get_msglevel,
20834+ .set_msglevel = rtl8152_set_msglevel,
20835+ .get_wol = rtl8152_get_wol,
20836+ .set_wol = rtl8152_set_wol,
20837+ .get_strings = rtl8152_get_strings,
20838+ .get_sset_count = rtl8152_get_sset_count,
20839+ .get_ethtool_stats = rtl8152_get_ethtool_stats,
20840+ .get_eee = rtl_ethtool_get_eee,
20841+ .set_eee = rtl_ethtool_set_eee,
20842+};
20843+
20844+static int rtl8152_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
20845+{
20846+ struct r8152 *tp = netdev_priv(netdev);
20847+ struct mii_ioctl_data *data = if_mii(rq);
20848+ int res;
20849+
20850+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20851+ return -ENODEV;
20852+
20853+ res = usb_autopm_get_interface(tp->intf);
20854+ if (res < 0)
20855+ goto out;
20856+
20857+ switch (cmd) {
20858+ case SIOCGMIIPHY:
20859+ data->phy_id = R8152_PHY_ID; /* Internal PHY */
20860+ break;
20861+
20862+ case SIOCGMIIREG:
20863+ mutex_lock(&tp->control);
20864+ data->val_out = r8152_mdio_read(tp, data->reg_num);
20865+ mutex_unlock(&tp->control);
20866+ break;
20867+
20868+ case SIOCSMIIREG:
20869+ if (!capable(CAP_NET_ADMIN)) {
20870+ res = -EPERM;
20871+ break;
20872+ }
20873+ mutex_lock(&tp->control);
20874+ r8152_mdio_write(tp, data->reg_num, data->val_in);
20875+ mutex_unlock(&tp->control);
20876+ break;
20877+
20878+ default:
20879+ res = -EOPNOTSUPP;
20880+ }
20881+
20882+ usb_autopm_put_interface(tp->intf);
20883+
20884+out:
20885+ return res;
20886+}
20887+
20888+static int rtl8152_change_mtu(struct net_device *dev, int new_mtu)
20889+{
20890+ struct r8152 *tp = netdev_priv(dev);
20891+
20892+ switch (tp->version) {
20893+ case RTL_VER_01:
20894+ case RTL_VER_02:
20895+ return eth_change_mtu(dev, new_mtu);
20896+ default:
20897+ break;
20898+ }
20899+
20900+ if (new_mtu < 68 || new_mtu > RTL8153_MAX_MTU)
20901+ return -EINVAL;
20902+
20903+ dev->mtu = new_mtu;
20904+
20905+ return 0;
20906+}
20907+
20908+static const struct net_device_ops rtl8152_netdev_ops = {
20909+ .ndo_open = rtl8152_open,
20910+ .ndo_stop = rtl8152_close,
20911+ .ndo_do_ioctl = rtl8152_ioctl,
20912+ .ndo_start_xmit = rtl8152_start_xmit,
20913+ .ndo_tx_timeout = rtl8152_tx_timeout,
20914+ .ndo_set_features = rtl8152_set_features,
20915+ .ndo_set_rx_mode = rtl8152_set_rx_mode,
20916+ .ndo_set_mac_address = rtl8152_set_mac_address,
20917+ .ndo_change_mtu = rtl8152_change_mtu,
20918+ .ndo_validate_addr = eth_validate_addr,
20919+};
20920+
20921+static void r8152b_get_version(struct r8152 *tp)
20922+{
20923+ u32 ocp_data;
20924+ u16 version;
20925+
20926+ ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR1);
20927+ version = (u16)(ocp_data & VERSION_MASK);
20928+
20929+ switch (version) {
20930+ case 0x4c00:
20931+ tp->version = RTL_VER_01;
20932+ break;
20933+ case 0x4c10:
20934+ tp->version = RTL_VER_02;
20935+ break;
20936+ case 0x5c00:
20937+ tp->version = RTL_VER_03;
20938+ tp->mii.supports_gmii = 1;
20939+ break;
20940+ case 0x5c10:
20941+ tp->version = RTL_VER_04;
20942+ tp->mii.supports_gmii = 1;
20943+ break;
20944+ case 0x5c20:
20945+ tp->version = RTL_VER_05;
20946+ tp->mii.supports_gmii = 1;
20947+ break;
20948+ default:
20949+ netif_info(tp, probe, tp->netdev,
20950+ "Unknown version 0x%04x\n", version);
20951+ break;
20952+ }
20953+}
20954+
20955+static void rtl8152_unload(struct r8152 *tp)
20956+{
20957+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20958+ return;
20959+
20960+ if (tp->version != RTL_VER_01)
20961+ r8152_power_cut_en(tp, true);
20962+}
20963+
20964+static void rtl8153_unload(struct r8152 *tp)
20965+{
20966+ if (test_bit(RTL8152_UNPLUG, &tp->flags))
20967+ return;
20968+
20969+ r8153_power_cut_en(tp, false);
20970+}
20971+
20972+static int rtl_ops_init(struct r8152 *tp, const struct usb_device_id *id)
20973+{
20974+ struct rtl_ops *ops = &tp->rtl_ops;
20975+ int ret = -ENODEV;
20976+
20977+ switch (id->idVendor) {
20978+ case VENDOR_ID_REALTEK:
20979+ switch (id->idProduct) {
20980+ case PRODUCT_ID_RTL8152:
20981+ ops->init = r8152b_init;
20982+ ops->enable = rtl8152_enable;
20983+ ops->disable = rtl8152_disable;
20984+ ops->up = rtl8152_up;
20985+ ops->down = rtl8152_down;
20986+ ops->unload = rtl8152_unload;
20987+ ops->eee_get = r8152_get_eee;
20988+ ops->eee_set = r8152_set_eee;
20989+ ret = 0;
20990+ break;
20991+ case PRODUCT_ID_RTL8153:
20992+ ops->init = r8153_init;
20993+ ops->enable = rtl8153_enable;
20994+ ops->disable = rtl8153_disable;
20995+ ops->up = rtl8153_up;
20996+ ops->down = rtl8153_down;
20997+ ops->unload = rtl8153_unload;
20998+ ops->eee_get = r8153_get_eee;
20999+ ops->eee_set = r8153_set_eee;
21000+ ret = 0;
21001+ break;
21002+ default:
21003+ break;
21004+ }
21005+ break;
21006+
21007+ case VENDOR_ID_SAMSUNG:
21008+ switch (id->idProduct) {
21009+ case PRODUCT_ID_SAMSUNG:
21010+ ops->init = r8153_init;
21011+ ops->enable = rtl8153_enable;
21012+ ops->disable = rtl8153_disable;
21013+ ops->up = rtl8153_up;
21014+ ops->down = rtl8153_down;
21015+ ops->unload = rtl8153_unload;
21016+ ops->eee_get = r8153_get_eee;
21017+ ops->eee_set = r8153_set_eee;
21018+ ret = 0;
21019+ break;
21020+ default:
21021+ break;
21022+ }
21023+ break;
21024+
21025+ default:
21026+ break;
21027+ }
21028+
21029+ if (ret)
21030+ netif_err(tp, probe, tp->netdev, "Unknown Device\n");
21031+
21032+ return ret;
21033+}
21034+
21035+static int rtl8152_probe(struct usb_interface *intf,
21036+ const struct usb_device_id *id)
21037+{
21038+ struct usb_device *udev = interface_to_usbdev(intf);
21039+ struct r8152 *tp;
21040+ struct net_device *netdev;
21041+ int ret;
21042+
21043+ if (udev->actconfig->desc.bConfigurationValue != 1) {
21044+ usb_driver_set_configuration(udev, 1);
21045+ return -ENODEV;
21046+ }
21047+
21048+ usb_reset_device(udev);
21049+ netdev = alloc_etherdev(sizeof(struct r8152));
21050+ if (!netdev) {
21051+ dev_err(&intf->dev, "Out of memory\n");
21052+ return -ENOMEM;
21053+ }
21054+
21055+ SET_NETDEV_DEV(netdev, &intf->dev);
21056+ tp = netdev_priv(netdev);
21057+ tp->msg_enable = 0x7FFF;
21058+
21059+ tp->udev = udev;
21060+ tp->netdev = netdev;
21061+ tp->intf = intf;
21062+
21063+ ret = rtl_ops_init(tp, id);
21064+ if (ret)
21065+ goto out;
21066+
21067+ tasklet_init(&tp->tl, bottom_half, (unsigned long)tp);
21068+ mutex_init(&tp->control);
21069+ INIT_DELAYED_WORK(&tp->schedule, rtl_work_func_t);
21070+
21071+ netdev->netdev_ops = &rtl8152_netdev_ops;
21072+ netdev->watchdog_timeo = RTL8152_TX_TIMEOUT;
21073+
21074+ netdev->features |= NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG |
21075+ NETIF_F_TSO | NETIF_F_FRAGLIST | NETIF_F_IPV6_CSUM |
21076+ NETIF_F_TSO6 | NETIF_F_HW_VLAN_CTAG_RX |
21077+ NETIF_F_HW_VLAN_CTAG_TX;
21078+ netdev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM | NETIF_F_SG |
21079+ NETIF_F_TSO | NETIF_F_FRAGLIST |
21080+ NETIF_F_IPV6_CSUM | NETIF_F_TSO6 |
21081+ NETIF_F_HW_VLAN_CTAG_RX |
21082+ NETIF_F_HW_VLAN_CTAG_TX;
21083+ netdev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO |
21084+ NETIF_F_HIGHDMA | NETIF_F_FRAGLIST |
21085+ NETIF_F_IPV6_CSUM | NETIF_F_TSO6;
21086+
21087+ netdev->ethtool_ops = &ops;
21088+ netif_set_gso_max_size(netdev, RTL_LIMITED_TSO_SIZE);
21089+
21090+ tp->mii.dev = netdev;
21091+ tp->mii.mdio_read = read_mii_word;
21092+ tp->mii.mdio_write = write_mii_word;
21093+ tp->mii.phy_id_mask = 0x3f;
21094+ tp->mii.reg_num_mask = 0x1f;
21095+ tp->mii.phy_id = R8152_PHY_ID;
21096+ tp->mii.supports_gmii = 0;
21097+
21098+ intf->needs_remote_wakeup = 1;
21099+
21100+ r8152b_get_version(tp);
21101+ tp->rtl_ops.init(tp);
21102+ set_ethernet_addr(tp);
21103+
21104+ usb_set_intfdata(intf, tp);
21105+
21106+ ret = register_netdev(netdev);
21107+ if (ret != 0) {
21108+ netif_err(tp, probe, netdev, "couldn't register the device\n");
21109+ goto out1;
21110+ }
21111+
21112+ tp->saved_wolopts = __rtl_get_wol(tp);
21113+ if (tp->saved_wolopts)
21114+ device_set_wakeup_enable(&udev->dev, true);
21115+ else
21116+ device_set_wakeup_enable(&udev->dev, false);
21117+
21118+ netif_info(tp, probe, netdev, "%s\n", DRIVER_VERSION);
21119+
21120+ return 0;
21121+
21122+out1:
21123+ usb_set_intfdata(intf, NULL);
21124+out:
21125+ free_netdev(netdev);
21126+ return ret;
21127+}
21128+
21129+static void rtl8152_disconnect(struct usb_interface *intf)
21130+{
21131+ struct r8152 *tp = usb_get_intfdata(intf);
21132+
21133+ usb_set_intfdata(intf, NULL);
21134+ if (tp) {
21135+ struct usb_device *udev = tp->udev;
21136+
21137+ if (udev->state == USB_STATE_NOTATTACHED)
21138+ set_bit(RTL8152_UNPLUG, &tp->flags);
21139+
21140+ tasklet_kill(&tp->tl);
21141+ unregister_netdev(tp->netdev);
21142+ tp->rtl_ops.unload(tp);
21143+ free_netdev(tp->netdev);
21144+ }
21145+}
21146+
21147+/* table of devices that work with this driver */
21148+static struct usb_device_id rtl8152_table[] = {
21149+ {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8152)},
21150+ {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8153)},
21151+ {USB_DEVICE(VENDOR_ID_SAMSUNG, PRODUCT_ID_SAMSUNG)},
21152+ {}
21153+};
21154+
21155+MODULE_DEVICE_TABLE(usb, rtl8152_table);
21156+
21157+static struct usb_driver rtl8152_driver = {
21158+ .name = MODULENAME,
21159+ .id_table = rtl8152_table,
21160+ .probe = rtl8152_probe,
21161+ .disconnect = rtl8152_disconnect,
21162+ .suspend = rtl8152_suspend,
21163+ .resume = rtl8152_resume,
21164+ .reset_resume = rtl8152_resume,
21165+ .supports_autosuspend = 1,
21166+ .disable_hub_initiated_lpm = 1,
21167+};
21168+
21169+module_usb_driver(rtl8152_driver);
21170+
21171+MODULE_AUTHOR(DRIVER_AUTHOR);
21172+MODULE_DESCRIPTION(DRIVER_DESC);
21173+MODULE_LICENSE("GPL");
21174diff -Naur backports-3.18.1-1.org/drivers/net/usb/rtl8150.c backports-3.18.1-1/drivers/net/usb/rtl8150.c
21175--- backports-3.18.1-1.org/drivers/net/usb/rtl8150.c 1970-01-01 01:00:00.000000000 +0100
21176+++ backports-3.18.1-1/drivers/net/usb/rtl8150.c 2014-12-16 18:39:45.000000000 +0100
21177@@ -0,0 +1,950 @@
21178+/*
21179+ * Copyright (c) 2002 Petko Manolov (petkan@users.sourceforge.net)
21180+ *
21181+ * This program is free software; you can redistribute it and/or
21182+ * modify it under the terms of the GNU General Public License
21183+ * version 2 as published by the Free Software Foundation.
21184+ */
21185+
21186+#include <linux/signal.h>
21187+#include <linux/slab.h>
21188+#include <linux/module.h>
21189+#include <linux/netdevice.h>
21190+#include <linux/etherdevice.h>
21191+#include <linux/mii.h>
21192+#include <linux/ethtool.h>
21193+#include <linux/usb.h>
21194+#include <asm/uaccess.h>
21195+
21196+/* Version Information */
21197+#define DRIVER_VERSION "v0.6.2 (2004/08/27)"
21198+#define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
21199+#define DRIVER_DESC "rtl8150 based usb-ethernet driver"
21200+
21201+#define IDR 0x0120
21202+#define MAR 0x0126
21203+#define CR 0x012e
21204+#define TCR 0x012f
21205+#define RCR 0x0130
21206+#define TSR 0x0132
21207+#define RSR 0x0133
21208+#define CON0 0x0135
21209+#define CON1 0x0136
21210+#define MSR 0x0137
21211+#define PHYADD 0x0138
21212+#define PHYDAT 0x0139
21213+#define PHYCNT 0x013b
21214+#define GPPC 0x013d
21215+#define BMCR 0x0140
21216+#define BMSR 0x0142
21217+#define ANAR 0x0144
21218+#define ANLP 0x0146
21219+#define AER 0x0148
21220+#define CSCR 0x014C /* This one has the link status */
21221+#define CSCR_LINK_STATUS (1 << 3)
21222+
21223+#define IDR_EEPROM 0x1202
21224+
21225+#define PHY_READ 0
21226+#define PHY_WRITE 0x20
21227+#define PHY_GO 0x40
21228+
21229+#define MII_TIMEOUT 10
21230+#define INTBUFSIZE 8
21231+
21232+#define RTL8150_REQT_READ 0xc0
21233+#define RTL8150_REQT_WRITE 0x40
21234+#define RTL8150_REQ_GET_REGS 0x05
21235+#define RTL8150_REQ_SET_REGS 0x05
21236+
21237+
21238+/* Transmit status register errors */
21239+#define TSR_ECOL (1<<5)
21240+#define TSR_LCOL (1<<4)
21241+#define TSR_LOSS_CRS (1<<3)
21242+#define TSR_JBR (1<<2)
21243+#define TSR_ERRORS (TSR_ECOL | TSR_LCOL | TSR_LOSS_CRS | TSR_JBR)
21244+/* Receive status register errors */
21245+#define RSR_CRC (1<<2)
21246+#define RSR_FAE (1<<1)
21247+#define RSR_ERRORS (RSR_CRC | RSR_FAE)
21248+
21249+/* Media status register definitions */
21250+#define MSR_DUPLEX (1<<4)
21251+#define MSR_SPEED (1<<3)
21252+#define MSR_LINK (1<<2)
21253+
21254+/* Interrupt pipe data */
21255+#define INT_TSR 0x00
21256+#define INT_RSR 0x01
21257+#define INT_MSR 0x02
21258+#define INT_WAKSR 0x03
21259+#define INT_TXOK_CNT 0x04
21260+#define INT_RXLOST_CNT 0x05
21261+#define INT_CRERR_CNT 0x06
21262+#define INT_COL_CNT 0x07
21263+
21264+
21265+#define RTL8150_MTU 1540
21266+#define RTL8150_TX_TIMEOUT (HZ)
21267+#define RX_SKB_POOL_SIZE 4
21268+
21269+/* rtl8150 flags */
21270+#define RTL8150_HW_CRC 0
21271+#define RX_REG_SET 1
21272+#define RTL8150_UNPLUG 2
21273+#define RX_URB_FAIL 3
21274+
21275+/* Define these values to match your device */
21276+#define VENDOR_ID_REALTEK 0x0bda
21277+#define VENDOR_ID_MELCO 0x0411
21278+#define VENDOR_ID_MICRONET 0x3980
21279+#define VENDOR_ID_LONGSHINE 0x07b8
21280+#define VENDOR_ID_OQO 0x1557
21281+#define VENDOR_ID_ZYXEL 0x0586
21282+
21283+#define PRODUCT_ID_RTL8150 0x8150
21284+#define PRODUCT_ID_LUAKTX 0x0012
21285+#define PRODUCT_ID_LCS8138TX 0x401a
21286+#define PRODUCT_ID_SP128AR 0x0003
21287+#define PRODUCT_ID_PRESTIGE 0x401a
21288+
21289+#undef EEPROM_WRITE
21290+
21291+/* table of devices that work with this driver */
21292+static struct usb_device_id rtl8150_table[] = {
21293+ {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
21294+ {USB_DEVICE(VENDOR_ID_MELCO, PRODUCT_ID_LUAKTX)},
21295+ {USB_DEVICE(VENDOR_ID_MICRONET, PRODUCT_ID_SP128AR)},
21296+ {USB_DEVICE(VENDOR_ID_LONGSHINE, PRODUCT_ID_LCS8138TX)},
21297+ {USB_DEVICE(VENDOR_ID_OQO, PRODUCT_ID_RTL8150)},
21298+ {USB_DEVICE(VENDOR_ID_ZYXEL, PRODUCT_ID_PRESTIGE)},
21299+ {}
21300+};
21301+
21302+MODULE_DEVICE_TABLE(usb, rtl8150_table);
21303+
21304+struct rtl8150 {
21305+ unsigned long flags;
21306+ struct usb_device *udev;
21307+ struct tasklet_struct tl;
21308+ struct net_device *netdev;
21309+ struct urb *rx_urb, *tx_urb, *intr_urb;
21310+ struct sk_buff *tx_skb, *rx_skb;
21311+ struct sk_buff *rx_skb_pool[RX_SKB_POOL_SIZE];
21312+ spinlock_t rx_pool_lock;
21313+ struct usb_ctrlrequest dr;
21314+ int intr_interval;
21315+ u8 *intr_buff;
21316+ u8 phy;
21317+};
21318+
21319+typedef struct rtl8150 rtl8150_t;
21320+
21321+struct async_req {
21322+ struct usb_ctrlrequest dr;
21323+ u16 rx_creg;
21324+};
21325+
21326+static const char driver_name [] = "rtl8150";
21327+
21328+/*
21329+**
21330+** device related part of the code
21331+**
21332+*/
21333+static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
21334+{
21335+ return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
21336+ RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
21337+ indx, 0, data, size, 500);
21338+}
21339+
21340+static int set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
21341+{
21342+ return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
21343+ RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
21344+ indx, 0, data, size, 500);
21345+}
21346+
21347+static void async_set_reg_cb(struct urb *urb)
21348+{
21349+ struct async_req *req = (struct async_req *)urb->context;
21350+ int status = urb->status;
21351+
21352+ if (status < 0)
21353+ dev_dbg(&urb->dev->dev, "%s failed with %d", __func__, status);
21354+ kfree(req);
21355+ usb_free_urb(urb);
21356+}
21357+
21358+static int async_set_registers(rtl8150_t *dev, u16 indx, u16 size, u16 reg)
21359+{
21360+ int res = -ENOMEM;
21361+ struct urb *async_urb;
21362+ struct async_req *req;
21363+
21364+ req = kmalloc(sizeof(struct async_req), GFP_ATOMIC);
21365+ if (req == NULL)
21366+ return res;
21367+ async_urb = usb_alloc_urb(0, GFP_ATOMIC);
21368+ if (async_urb == NULL) {
21369+ kfree(req);
21370+ return res;
21371+ }
21372+ req->rx_creg = cpu_to_le16(reg);
21373+ req->dr.bRequestType = RTL8150_REQT_WRITE;
21374+ req->dr.bRequest = RTL8150_REQ_SET_REGS;
21375+ req->dr.wIndex = 0;
21376+ req->dr.wValue = cpu_to_le16(indx);
21377+ req->dr.wLength = cpu_to_le16(size);
21378+ usb_fill_control_urb(async_urb, dev->udev,
21379+ usb_sndctrlpipe(dev->udev, 0), (void *)&req->dr,
21380+ &req->rx_creg, size, async_set_reg_cb, req);
21381+ res = usb_submit_urb(async_urb, GFP_ATOMIC);
21382+ if (res) {
21383+ if (res == -ENODEV)
21384+ netif_device_detach(dev->netdev);
21385+ dev_err(&dev->udev->dev, "%s failed with %d\n", __func__, res);
21386+ }
21387+ return res;
21388+}
21389+
21390+static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
21391+{
21392+ int i;
21393+ u8 data[3], tmp;
21394+
21395+ data[0] = phy;
21396+ data[1] = data[2] = 0;
21397+ tmp = indx | PHY_READ | PHY_GO;
21398+ i = 0;
21399+
21400+ set_registers(dev, PHYADD, sizeof(data), data);
21401+ set_registers(dev, PHYCNT, 1, &tmp);
21402+ do {
21403+ get_registers(dev, PHYCNT, 1, data);
21404+ } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
21405+
21406+ if (i <= MII_TIMEOUT) {
21407+ get_registers(dev, PHYDAT, 2, data);
21408+ *reg = data[0] | (data[1] << 8);
21409+ return 0;
21410+ } else
21411+ return 1;
21412+}
21413+
21414+static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
21415+{
21416+ int i;
21417+ u8 data[3], tmp;
21418+
21419+ data[0] = phy;
21420+ data[1] = reg & 0xff;
21421+ data[2] = (reg >> 8) & 0xff;
21422+ tmp = indx | PHY_WRITE | PHY_GO;
21423+ i = 0;
21424+
21425+ set_registers(dev, PHYADD, sizeof(data), data);
21426+ set_registers(dev, PHYCNT, 1, &tmp);
21427+ do {
21428+ get_registers(dev, PHYCNT, 1, data);
21429+ } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
21430+
21431+ if (i <= MII_TIMEOUT)
21432+ return 0;
21433+ else
21434+ return 1;
21435+}
21436+
21437+static inline void set_ethernet_addr(rtl8150_t * dev)
21438+{
21439+ u8 node_id[6];
21440+
21441+ get_registers(dev, IDR, sizeof(node_id), node_id);
21442+ memcpy(dev->netdev->dev_addr, node_id, sizeof(node_id));
21443+}
21444+
21445+static int rtl8150_set_mac_address(struct net_device *netdev, void *p)
21446+{
21447+ struct sockaddr *addr = p;
21448+ rtl8150_t *dev = netdev_priv(netdev);
21449+
21450+ if (netif_running(netdev))
21451+ return -EBUSY;
21452+
21453+ memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
21454+ netdev_dbg(netdev, "Setting MAC address to %pM\n", netdev->dev_addr);
21455+ /* Set the IDR registers. */
21456+ set_registers(dev, IDR, netdev->addr_len, netdev->dev_addr);
21457+#ifdef EEPROM_WRITE
21458+ {
21459+ int i;
21460+ u8 cr;
21461+ /* Get the CR contents. */
21462+ get_registers(dev, CR, 1, &cr);
21463+ /* Set the WEPROM bit (eeprom write enable). */
21464+ cr |= 0x20;
21465+ set_registers(dev, CR, 1, &cr);
21466+ /* Write the MAC address into eeprom. Eeprom writes must be word-sized,
21467+ so we need to split them up. */
21468+ for (i = 0; i * 2 < netdev->addr_len; i++) {
21469+ set_registers(dev, IDR_EEPROM + (i * 2), 2,
21470+ netdev->dev_addr + (i * 2));
21471+ }
21472+ /* Clear the WEPROM bit (preventing accidental eeprom writes). */
21473+ cr &= 0xdf;
21474+ set_registers(dev, CR, 1, &cr);
21475+ }
21476+#endif
21477+ return 0;
21478+}
21479+
21480+static int rtl8150_reset(rtl8150_t * dev)
21481+{
21482+ u8 data = 0x10;
21483+ int i = HZ;
21484+
21485+ set_registers(dev, CR, 1, &data);
21486+ do {
21487+ get_registers(dev, CR, 1, &data);
21488+ } while ((data & 0x10) && --i);
21489+
21490+ return (i > 0) ? 1 : 0;
21491+}
21492+
21493+static int alloc_all_urbs(rtl8150_t * dev)
21494+{
21495+ dev->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
21496+ if (!dev->rx_urb)
21497+ return 0;
21498+ dev->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
21499+ if (!dev->tx_urb) {
21500+ usb_free_urb(dev->rx_urb);
21501+ return 0;
21502+ }
21503+ dev->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
21504+ if (!dev->intr_urb) {
21505+ usb_free_urb(dev->rx_urb);
21506+ usb_free_urb(dev->tx_urb);
21507+ return 0;
21508+ }
21509+
21510+ return 1;
21511+}
21512+
21513+static void free_all_urbs(rtl8150_t * dev)
21514+{
21515+ usb_free_urb(dev->rx_urb);
21516+ usb_free_urb(dev->tx_urb);
21517+ usb_free_urb(dev->intr_urb);
21518+}
21519+
21520+static void unlink_all_urbs(rtl8150_t * dev)
21521+{
21522+ usb_kill_urb(dev->rx_urb);
21523+ usb_kill_urb(dev->tx_urb);
21524+ usb_kill_urb(dev->intr_urb);
21525+}
21526+
21527+static inline struct sk_buff *pull_skb(rtl8150_t *dev)
21528+{
21529+ struct sk_buff *skb;
21530+ int i;
21531+
21532+ for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
21533+ if (dev->rx_skb_pool[i]) {
21534+ skb = dev->rx_skb_pool[i];
21535+ dev->rx_skb_pool[i] = NULL;
21536+ return skb;
21537+ }
21538+ }
21539+ return NULL;
21540+}
21541+
21542+static void read_bulk_callback(struct urb *urb)
21543+{
21544+ rtl8150_t *dev;
21545+ unsigned pkt_len, res;
21546+ struct sk_buff *skb;
21547+ struct net_device *netdev;
21548+ u16 rx_stat;
21549+ int status = urb->status;
21550+ int result;
21551+
21552+ dev = urb->context;
21553+ if (!dev)
21554+ return;
21555+ if (test_bit(RTL8150_UNPLUG, &dev->flags))
21556+ return;
21557+ netdev = dev->netdev;
21558+ if (!netif_device_present(netdev))
21559+ return;
21560+
21561+ switch (status) {
21562+ case 0:
21563+ break;
21564+ case -ENOENT:
21565+ return; /* the urb is in unlink state */
21566+ case -ETIME:
21567+ if (printk_ratelimit())
21568+ dev_warn(&urb->dev->dev, "may be reset is needed?..\n");
21569+ goto goon;
21570+ default:
21571+ if (printk_ratelimit())
21572+ dev_warn(&urb->dev->dev, "Rx status %d\n", status);
21573+ goto goon;
21574+ }
21575+
21576+ if (!dev->rx_skb)
21577+ goto resched;
21578+ /* protect against short packets (tell me why we got some?!?) */
21579+ if (urb->actual_length < 4)
21580+ goto goon;
21581+
21582+ res = urb->actual_length;
21583+ rx_stat = le16_to_cpu(*(__le16 *)(urb->transfer_buffer + res - 4));
21584+ pkt_len = res - 4;
21585+
21586+ skb_put(dev->rx_skb, pkt_len);
21587+ dev->rx_skb->protocol = eth_type_trans(dev->rx_skb, netdev);
21588+ netif_rx(dev->rx_skb);
21589+ netdev->stats.rx_packets++;
21590+ netdev->stats.rx_bytes += pkt_len;
21591+
21592+ spin_lock(&dev->rx_pool_lock);
21593+ skb = pull_skb(dev);
21594+ spin_unlock(&dev->rx_pool_lock);
21595+ if (!skb)
21596+ goto resched;
21597+
21598+ dev->rx_skb = skb;
21599+goon:
21600+ usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
21601+ dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
21602+ result = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
21603+ if (result == -ENODEV)
21604+ netif_device_detach(dev->netdev);
21605+ else if (result) {
21606+ set_bit(RX_URB_FAIL, &dev->flags);
21607+ goto resched;
21608+ } else {
21609+ clear_bit(RX_URB_FAIL, &dev->flags);
21610+ }
21611+
21612+ return;
21613+resched:
21614+ tasklet_schedule(&dev->tl);
21615+}
21616+
21617+static void write_bulk_callback(struct urb *urb)
21618+{
21619+ rtl8150_t *dev;
21620+ int status = urb->status;
21621+
21622+ dev = urb->context;
21623+ if (!dev)
21624+ return;
21625+ dev_kfree_skb_irq(dev->tx_skb);
21626+ if (!netif_device_present(dev->netdev))
21627+ return;
21628+ if (status)
21629+ dev_info(&urb->dev->dev, "%s: Tx status %d\n",
21630+ dev->netdev->name, status);
21631+ dev->netdev->trans_start = jiffies;
21632+ netif_wake_queue(dev->netdev);
21633+}
21634+
21635+static void intr_callback(struct urb *urb)
21636+{
21637+ rtl8150_t *dev;
21638+ __u8 *d;
21639+ int status = urb->status;
21640+ int res;
21641+
21642+ dev = urb->context;
21643+ if (!dev)
21644+ return;
21645+ switch (status) {
21646+ case 0: /* success */
21647+ break;
21648+ case -ECONNRESET: /* unlink */
21649+ case -ENOENT:
21650+ case -ESHUTDOWN:
21651+ return;
21652+ /* -EPIPE: should clear the halt */
21653+ default:
21654+ dev_info(&urb->dev->dev, "%s: intr status %d\n",
21655+ dev->netdev->name, status);
21656+ goto resubmit;
21657+ }
21658+
21659+ d = urb->transfer_buffer;
21660+ if (d[0] & TSR_ERRORS) {
21661+ dev->netdev->stats.tx_errors++;
21662+ if (d[INT_TSR] & (TSR_ECOL | TSR_JBR))
21663+ dev->netdev->stats.tx_aborted_errors++;
21664+ if (d[INT_TSR] & TSR_LCOL)
21665+ dev->netdev->stats.tx_window_errors++;
21666+ if (d[INT_TSR] & TSR_LOSS_CRS)
21667+ dev->netdev->stats.tx_carrier_errors++;
21668+ }
21669+ /* Report link status changes to the network stack */
21670+ if ((d[INT_MSR] & MSR_LINK) == 0) {
21671+ if (netif_carrier_ok(dev->netdev)) {
21672+ netif_carrier_off(dev->netdev);
21673+ netdev_dbg(dev->netdev, "%s: LINK LOST\n", __func__);
21674+ }
21675+ } else {
21676+ if (!netif_carrier_ok(dev->netdev)) {
21677+ netif_carrier_on(dev->netdev);
21678+ netdev_dbg(dev->netdev, "%s: LINK CAME BACK\n", __func__);
21679+ }
21680+ }
21681+
21682+resubmit:
21683+ res = usb_submit_urb (urb, GFP_ATOMIC);
21684+ if (res == -ENODEV)
21685+ netif_device_detach(dev->netdev);
21686+ else if (res)
21687+ dev_err(&dev->udev->dev,
21688+ "can't resubmit intr, %s-%s/input0, status %d\n",
21689+ dev->udev->bus->bus_name, dev->udev->devpath, res);
21690+}
21691+
21692+static int rtl8150_suspend(struct usb_interface *intf, pm_message_t message)
21693+{
21694+ rtl8150_t *dev = usb_get_intfdata(intf);
21695+
21696+ netif_device_detach(dev->netdev);
21697+
21698+ if (netif_running(dev->netdev)) {
21699+ usb_kill_urb(dev->rx_urb);
21700+ usb_kill_urb(dev->intr_urb);
21701+ }
21702+ return 0;
21703+}
21704+
21705+static int rtl8150_resume(struct usb_interface *intf)
21706+{
21707+ rtl8150_t *dev = usb_get_intfdata(intf);
21708+
21709+ netif_device_attach(dev->netdev);
21710+ if (netif_running(dev->netdev)) {
21711+ dev->rx_urb->status = 0;
21712+ dev->rx_urb->actual_length = 0;
21713+ read_bulk_callback(dev->rx_urb);
21714+
21715+ dev->intr_urb->status = 0;
21716+ dev->intr_urb->actual_length = 0;
21717+ intr_callback(dev->intr_urb);
21718+ }
21719+ return 0;
21720+}
21721+
21722+/*
21723+**
21724+** network related part of the code
21725+**
21726+*/
21727+
21728+static void fill_skb_pool(rtl8150_t *dev)
21729+{
21730+ struct sk_buff *skb;
21731+ int i;
21732+
21733+ for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
21734+ if (dev->rx_skb_pool[i])
21735+ continue;
21736+ skb = dev_alloc_skb(RTL8150_MTU + 2);
21737+ if (!skb) {
21738+ return;
21739+ }
21740+ skb_reserve(skb, 2);
21741+ dev->rx_skb_pool[i] = skb;
21742+ }
21743+}
21744+
21745+static void free_skb_pool(rtl8150_t *dev)
21746+{
21747+ int i;
21748+
21749+ for (i = 0; i < RX_SKB_POOL_SIZE; i++)
21750+ if (dev->rx_skb_pool[i])
21751+ dev_kfree_skb(dev->rx_skb_pool[i]);
21752+}
21753+
21754+static void rx_fixup(unsigned long data)
21755+{
21756+ struct rtl8150 *dev = (struct rtl8150 *)data;
21757+ struct sk_buff *skb;
21758+ int status;
21759+
21760+ spin_lock_irq(&dev->rx_pool_lock);
21761+ fill_skb_pool(dev);
21762+ spin_unlock_irq(&dev->rx_pool_lock);
21763+ if (test_bit(RX_URB_FAIL, &dev->flags))
21764+ if (dev->rx_skb)
21765+ goto try_again;
21766+ spin_lock_irq(&dev->rx_pool_lock);
21767+ skb = pull_skb(dev);
21768+ spin_unlock_irq(&dev->rx_pool_lock);
21769+ if (skb == NULL)
21770+ goto tlsched;
21771+ dev->rx_skb = skb;
21772+ usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
21773+ dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
21774+try_again:
21775+ status = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
21776+ if (status == -ENODEV) {
21777+ netif_device_detach(dev->netdev);
21778+ } else if (status) {
21779+ set_bit(RX_URB_FAIL, &dev->flags);
21780+ goto tlsched;
21781+ } else {
21782+ clear_bit(RX_URB_FAIL, &dev->flags);
21783+ }
21784+
21785+ return;
21786+tlsched:
21787+ tasklet_schedule(&dev->tl);
21788+}
21789+
21790+static int enable_net_traffic(rtl8150_t * dev)
21791+{
21792+ u8 cr, tcr, rcr, msr;
21793+
21794+ if (!rtl8150_reset(dev)) {
21795+ dev_warn(&dev->udev->dev, "device reset failed\n");
21796+ }
21797+ /* RCR bit7=1 attach Rx info at the end; =0 HW CRC (which is broken) */
21798+ rcr = 0x9e;
21799+ tcr = 0xd8;
21800+ cr = 0x0c;
21801+ if (!(rcr & 0x80))
21802+ set_bit(RTL8150_HW_CRC, &dev->flags);
21803+ set_registers(dev, RCR, 1, &rcr);
21804+ set_registers(dev, TCR, 1, &tcr);
21805+ set_registers(dev, CR, 1, &cr);
21806+ get_registers(dev, MSR, 1, &msr);
21807+
21808+ return 0;
21809+}
21810+
21811+static void disable_net_traffic(rtl8150_t * dev)
21812+{
21813+ u8 cr;
21814+
21815+ get_registers(dev, CR, 1, &cr);
21816+ cr &= 0xf3;
21817+ set_registers(dev, CR, 1, &cr);
21818+}
21819+
21820+static void rtl8150_tx_timeout(struct net_device *netdev)
21821+{
21822+ rtl8150_t *dev = netdev_priv(netdev);
21823+ dev_warn(&netdev->dev, "Tx timeout.\n");
21824+ usb_unlink_urb(dev->tx_urb);
21825+ netdev->stats.tx_errors++;
21826+}
21827+
21828+static void rtl8150_set_multicast(struct net_device *netdev)
21829+{
21830+ rtl8150_t *dev = netdev_priv(netdev);
21831+ u16 rx_creg = 0x9e;
21832+
21833+ netif_stop_queue(netdev);
21834+ if (netdev->flags & IFF_PROMISC) {
21835+ rx_creg |= 0x0001;
21836+ dev_info(&netdev->dev, "%s: promiscuous mode\n", netdev->name);
21837+ } else if (!netdev_mc_empty(netdev) ||
21838+ (netdev->flags & IFF_ALLMULTI)) {
21839+ rx_creg &= 0xfffe;
21840+ rx_creg |= 0x0002;
21841+ dev_info(&netdev->dev, "%s: allmulti set\n", netdev->name);
21842+ } else {
21843+ /* ~RX_MULTICAST, ~RX_PROMISCUOUS */
21844+ rx_creg &= 0x00fc;
21845+ }
21846+ async_set_registers(dev, RCR, sizeof(rx_creg), rx_creg);
21847+ netif_wake_queue(netdev);
21848+}
21849+
21850+static netdev_tx_t rtl8150_start_xmit(struct sk_buff *skb,
21851+ struct net_device *netdev)
21852+{
21853+ rtl8150_t *dev = netdev_priv(netdev);
21854+ int count, res;
21855+
21856+ netif_stop_queue(netdev);
21857+ count = (skb->len < 60) ? 60 : skb->len;
21858+ count = (count & 0x3f) ? count : count + 1;
21859+ dev->tx_skb = skb;
21860+ usb_fill_bulk_urb(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
21861+ skb->data, count, write_bulk_callback, dev);
21862+ if ((res = usb_submit_urb(dev->tx_urb, GFP_ATOMIC))) {
21863+ /* Can we get/handle EPIPE here? */
21864+ if (res == -ENODEV)
21865+ netif_device_detach(dev->netdev);
21866+ else {
21867+ dev_warn(&netdev->dev, "failed tx_urb %d\n", res);
21868+ netdev->stats.tx_errors++;
21869+ netif_start_queue(netdev);
21870+ }
21871+ } else {
21872+ netdev->stats.tx_packets++;
21873+ netdev->stats.tx_bytes += skb->len;
21874+ netdev->trans_start = jiffies;
21875+ }
21876+
21877+ return NETDEV_TX_OK;
21878+}
21879+
21880+
21881+static void set_carrier(struct net_device *netdev)
21882+{
21883+ rtl8150_t *dev = netdev_priv(netdev);
21884+ short tmp;
21885+
21886+ get_registers(dev, CSCR, 2, &tmp);
21887+ if (tmp & CSCR_LINK_STATUS)
21888+ netif_carrier_on(netdev);
21889+ else
21890+ netif_carrier_off(netdev);
21891+}
21892+
21893+static int rtl8150_open(struct net_device *netdev)
21894+{
21895+ rtl8150_t *dev = netdev_priv(netdev);
21896+ int res;
21897+
21898+ if (dev->rx_skb == NULL)
21899+ dev->rx_skb = pull_skb(dev);
21900+ if (!dev->rx_skb)
21901+ return -ENOMEM;
21902+
21903+ set_registers(dev, IDR, 6, netdev->dev_addr);
21904+
21905+ usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
21906+ dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
21907+ if ((res = usb_submit_urb(dev->rx_urb, GFP_KERNEL))) {
21908+ if (res == -ENODEV)
21909+ netif_device_detach(dev->netdev);
21910+ dev_warn(&netdev->dev, "rx_urb submit failed: %d\n", res);
21911+ return res;
21912+ }
21913+ usb_fill_int_urb(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
21914+ dev->intr_buff, INTBUFSIZE, intr_callback,
21915+ dev, dev->intr_interval);
21916+ if ((res = usb_submit_urb(dev->intr_urb, GFP_KERNEL))) {
21917+ if (res == -ENODEV)
21918+ netif_device_detach(dev->netdev);
21919+ dev_warn(&netdev->dev, "intr_urb submit failed: %d\n", res);
21920+ usb_kill_urb(dev->rx_urb);
21921+ return res;
21922+ }
21923+ enable_net_traffic(dev);
21924+ set_carrier(netdev);
21925+ netif_start_queue(netdev);
21926+
21927+ return res;
21928+}
21929+
21930+static int rtl8150_close(struct net_device *netdev)
21931+{
21932+ rtl8150_t *dev = netdev_priv(netdev);
21933+ int res = 0;
21934+
21935+ netif_stop_queue(netdev);
21936+ if (!test_bit(RTL8150_UNPLUG, &dev->flags))
21937+ disable_net_traffic(dev);
21938+ unlink_all_urbs(dev);
21939+
21940+ return res;
21941+}
21942+
21943+static void rtl8150_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
21944+{
21945+ rtl8150_t *dev = netdev_priv(netdev);
21946+
21947+ strlcpy(info->driver, driver_name, sizeof(info->driver));
21948+ strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
21949+ usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
21950+}
21951+
21952+static int rtl8150_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
21953+{
21954+ rtl8150_t *dev = netdev_priv(netdev);
21955+ short lpa, bmcr;
21956+
21957+ ecmd->supported = (SUPPORTED_10baseT_Half |
21958+ SUPPORTED_10baseT_Full |
21959+ SUPPORTED_100baseT_Half |
21960+ SUPPORTED_100baseT_Full |
21961+ SUPPORTED_Autoneg |
21962+ SUPPORTED_TP | SUPPORTED_MII);
21963+ ecmd->port = PORT_TP;
21964+ ecmd->transceiver = XCVR_INTERNAL;
21965+ ecmd->phy_address = dev->phy;
21966+ get_registers(dev, BMCR, 2, &bmcr);
21967+ get_registers(dev, ANLP, 2, &lpa);
21968+ if (bmcr & BMCR_ANENABLE) {
21969+ u32 speed = ((lpa & (LPA_100HALF | LPA_100FULL)) ?
21970+ SPEED_100 : SPEED_10);
21971+ ethtool_cmd_speed_set(ecmd, speed);
21972+ ecmd->autoneg = AUTONEG_ENABLE;
21973+ if (speed == SPEED_100)
21974+ ecmd->duplex = (lpa & LPA_100FULL) ?
21975+ DUPLEX_FULL : DUPLEX_HALF;
21976+ else
21977+ ecmd->duplex = (lpa & LPA_10FULL) ?
21978+ DUPLEX_FULL : DUPLEX_HALF;
21979+ } else {
21980+ ecmd->autoneg = AUTONEG_DISABLE;
21981+ ethtool_cmd_speed_set(ecmd, ((bmcr & BMCR_SPEED100) ?
21982+ SPEED_100 : SPEED_10));
21983+ ecmd->duplex = (bmcr & BMCR_FULLDPLX) ?
21984+ DUPLEX_FULL : DUPLEX_HALF;
21985+ }
21986+ return 0;
21987+}
21988+
21989+static const struct ethtool_ops ops = {
21990+ .get_drvinfo = rtl8150_get_drvinfo,
21991+ .get_settings = rtl8150_get_settings,
21992+ .get_link = ethtool_op_get_link
21993+};
21994+
21995+static int rtl8150_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
21996+{
21997+ rtl8150_t *dev = netdev_priv(netdev);
21998+ u16 *data = (u16 *) & rq->ifr_ifru;
21999+ int res = 0;
22000+
22001+ switch (cmd) {
22002+ case SIOCDEVPRIVATE:
22003+ data[0] = dev->phy;
22004+ case SIOCDEVPRIVATE + 1:
22005+ read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
22006+ break;
22007+ case SIOCDEVPRIVATE + 2:
22008+ if (!capable(CAP_NET_ADMIN))
22009+ return -EPERM;
22010+ write_mii_word(dev, dev->phy, (data[1] & 0x1f), data[2]);
22011+ break;
22012+ default:
22013+ res = -EOPNOTSUPP;
22014+ }
22015+
22016+ return res;
22017+}
22018+
22019+static const struct net_device_ops rtl8150_netdev_ops = {
22020+ .ndo_open = rtl8150_open,
22021+ .ndo_stop = rtl8150_close,
22022+ .ndo_do_ioctl = rtl8150_ioctl,
22023+ .ndo_start_xmit = rtl8150_start_xmit,
22024+ .ndo_tx_timeout = rtl8150_tx_timeout,
22025+ .ndo_set_rx_mode = rtl8150_set_multicast,
22026+ .ndo_set_mac_address = rtl8150_set_mac_address,
22027+
22028+ .ndo_change_mtu = eth_change_mtu,
22029+ .ndo_validate_addr = eth_validate_addr,
22030+};
22031+
22032+static int rtl8150_probe(struct usb_interface *intf,
22033+ const struct usb_device_id *id)
22034+{
22035+ struct usb_device *udev = interface_to_usbdev(intf);
22036+ rtl8150_t *dev;
22037+ struct net_device *netdev;
22038+
22039+ netdev = alloc_etherdev(sizeof(rtl8150_t));
22040+ if (!netdev)
22041+ return -ENOMEM;
22042+
22043+ dev = netdev_priv(netdev);
22044+
22045+ dev->intr_buff = kmalloc(INTBUFSIZE, GFP_KERNEL);
22046+ if (!dev->intr_buff) {
22047+ free_netdev(netdev);
22048+ return -ENOMEM;
22049+ }
22050+
22051+ tasklet_init(&dev->tl, rx_fixup, (unsigned long)dev);
22052+ spin_lock_init(&dev->rx_pool_lock);
22053+
22054+ dev->udev = udev;
22055+ dev->netdev = netdev;
22056+ netdev->netdev_ops = &rtl8150_netdev_ops;
22057+ netdev->watchdog_timeo = RTL8150_TX_TIMEOUT;
22058+ netdev->ethtool_ops = &ops;
22059+ dev->intr_interval = 100; /* 100ms */
22060+
22061+ if (!alloc_all_urbs(dev)) {
22062+ dev_err(&intf->dev, "out of memory\n");
22063+ goto out;
22064+ }
22065+ if (!rtl8150_reset(dev)) {
22066+ dev_err(&intf->dev, "couldn't reset the device\n");
22067+ goto out1;
22068+ }
22069+ fill_skb_pool(dev);
22070+ set_ethernet_addr(dev);
22071+
22072+ usb_set_intfdata(intf, dev);
22073+ SET_NETDEV_DEV(netdev, &intf->dev);
22074+ if (register_netdev(netdev) != 0) {
22075+ dev_err(&intf->dev, "couldn't register the device\n");
22076+ goto out2;
22077+ }
22078+
22079+ dev_info(&intf->dev, "%s: rtl8150 is detected\n", netdev->name);
22080+
22081+ return 0;
22082+
22083+out2:
22084+ usb_set_intfdata(intf, NULL);
22085+ free_skb_pool(dev);
22086+out1:
22087+ free_all_urbs(dev);
22088+out:
22089+ kfree(dev->intr_buff);
22090+ free_netdev(netdev);
22091+ return -EIO;
22092+}
22093+
22094+static void rtl8150_disconnect(struct usb_interface *intf)
22095+{
22096+ rtl8150_t *dev = usb_get_intfdata(intf);
22097+
22098+ usb_set_intfdata(intf, NULL);
22099+ if (dev) {
22100+ set_bit(RTL8150_UNPLUG, &dev->flags);
22101+ tasklet_kill(&dev->tl);
22102+ unregister_netdev(dev->netdev);
22103+ unlink_all_urbs(dev);
22104+ free_all_urbs(dev);
22105+ free_skb_pool(dev);
22106+ if (dev->rx_skb)
22107+ dev_kfree_skb(dev->rx_skb);
22108+ kfree(dev->intr_buff);
22109+ free_netdev(dev->netdev);
22110+ }
22111+}
22112+
22113+static struct usb_driver rtl8150_driver = {
22114+ .name = driver_name,
22115+ .probe = rtl8150_probe,
22116+ .disconnect = rtl8150_disconnect,
22117+ .id_table = rtl8150_table,
22118+ .suspend = rtl8150_suspend,
22119+ .resume = rtl8150_resume,
22120+ .disable_hub_initiated_lpm = 1,
22121+};
22122+
22123+module_usb_driver(rtl8150_driver);
22124+
22125+MODULE_AUTHOR(DRIVER_AUTHOR);
22126+MODULE_DESCRIPTION(DRIVER_DESC);
22127+MODULE_LICENSE("GPL");
22128diff -Naur backports-3.18.1-1.org/drivers/net/usb/smsc75xx.c backports-3.18.1-1/drivers/net/usb/smsc75xx.c
22129--- backports-3.18.1-1.org/drivers/net/usb/smsc75xx.c 1970-01-01 01:00:00.000000000 +0100
22130+++ backports-3.18.1-1/drivers/net/usb/smsc75xx.c 2014-12-16 18:39:45.000000000 +0100
22131@@ -0,0 +1,2286 @@
22132+ /***************************************************************************
22133+ *
22134+ * Copyright (C) 2007-2010 SMSC
22135+ *
22136+ * This program is free software; you can redistribute it and/or
22137+ * modify it under the terms of the GNU General Public License
22138+ * as published by the Free Software Foundation; either version 2
22139+ * of the License, or (at your option) any later version.
22140+ *
22141+ * This program is distributed in the hope that it will be useful,
22142+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
22143+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22144+ * GNU General Public License for more details.
22145+ *
22146+ * You should have received a copy of the GNU General Public License
22147+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
22148+ *
22149+ *****************************************************************************/
22150+
22151+#include <linux/module.h>
22152+#include <linux/kmod.h>
22153+#include <linux/netdevice.h>
22154+#include <linux/etherdevice.h>
22155+#include <linux/ethtool.h>
22156+#include <linux/mii.h>
22157+#include <linux/usb.h>
22158+#include <linux/bitrev.h>
22159+#include <linux/crc16.h>
22160+#include <linux/crc32.h>
22161+#include <linux/usb/usbnet.h>
22162+#include <linux/slab.h>
22163+#include "smsc75xx.h"
22164+
22165+#define SMSC_CHIPNAME "smsc75xx"
22166+#define SMSC_DRIVER_VERSION "1.0.0"
22167+#define HS_USB_PKT_SIZE (512)
22168+#define FS_USB_PKT_SIZE (64)
22169+#define DEFAULT_HS_BURST_CAP_SIZE (16 * 1024 + 5 * HS_USB_PKT_SIZE)
22170+#define DEFAULT_FS_BURST_CAP_SIZE (6 * 1024 + 33 * FS_USB_PKT_SIZE)
22171+#define DEFAULT_BULK_IN_DELAY (0x00002000)
22172+#define MAX_SINGLE_PACKET_SIZE (9000)
22173+#define LAN75XX_EEPROM_MAGIC (0x7500)
22174+#define EEPROM_MAC_OFFSET (0x01)
22175+#define DEFAULT_TX_CSUM_ENABLE (true)
22176+#define DEFAULT_RX_CSUM_ENABLE (true)
22177+#define SMSC75XX_INTERNAL_PHY_ID (1)
22178+#define SMSC75XX_TX_OVERHEAD (8)
22179+#define MAX_RX_FIFO_SIZE (20 * 1024)
22180+#define MAX_TX_FIFO_SIZE (12 * 1024)
22181+#define USB_VENDOR_ID_SMSC (0x0424)
22182+#define USB_PRODUCT_ID_LAN7500 (0x7500)
22183+#define USB_PRODUCT_ID_LAN7505 (0x7505)
22184+#define RXW_PADDING 2
22185+#define SUPPORTED_WAKE (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
22186+ WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
22187+
22188+#define SUSPEND_SUSPEND0 (0x01)
22189+#define SUSPEND_SUSPEND1 (0x02)
22190+#define SUSPEND_SUSPEND2 (0x04)
22191+#define SUSPEND_SUSPEND3 (0x08)
22192+#define SUSPEND_ALLMODES (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
22193+ SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)
22194+
22195+struct smsc75xx_priv {
22196+ struct usbnet *dev;
22197+ u32 rfe_ctl;
22198+ u32 wolopts;
22199+ u32 multicast_hash_table[DP_SEL_VHF_HASH_LEN];
22200+ struct mutex dataport_mutex;
22201+ spinlock_t rfe_ctl_lock;
22202+ struct work_struct set_multicast;
22203+ u8 suspend_flags;
22204+};
22205+
22206+struct usb_context {
22207+ struct usb_ctrlrequest req;
22208+ struct usbnet *dev;
22209+};
22210+
22211+static bool turbo_mode = true;
22212+module_param(turbo_mode, bool, 0644);
22213+MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
22214+
22215+static int __must_check __smsc75xx_read_reg(struct usbnet *dev, u32 index,
22216+ u32 *data, int in_pm)
22217+{
22218+ u32 buf;
22219+ int ret;
22220+ int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
22221+
22222+ BUG_ON(!dev);
22223+
22224+ if (!in_pm)
22225+ fn = usbnet_read_cmd;
22226+ else
22227+ fn = usbnet_read_cmd_nopm;
22228+
22229+ ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
22230+ | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
22231+ 0, index, &buf, 4);
22232+ if (unlikely(ret < 0))
22233+ netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
22234+ index, ret);
22235+
22236+ le32_to_cpus(&buf);
22237+ *data = buf;
22238+
22239+ return ret;
22240+}
22241+
22242+static int __must_check __smsc75xx_write_reg(struct usbnet *dev, u32 index,
22243+ u32 data, int in_pm)
22244+{
22245+ u32 buf;
22246+ int ret;
22247+ int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
22248+
22249+ BUG_ON(!dev);
22250+
22251+ if (!in_pm)
22252+ fn = usbnet_write_cmd;
22253+ else
22254+ fn = usbnet_write_cmd_nopm;
22255+
22256+ buf = data;
22257+ cpu_to_le32s(&buf);
22258+
22259+ ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
22260+ | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
22261+ 0, index, &buf, 4);
22262+ if (unlikely(ret < 0))
22263+ netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
22264+ index, ret);
22265+
22266+ return ret;
22267+}
22268+
22269+static int __must_check smsc75xx_read_reg_nopm(struct usbnet *dev, u32 index,
22270+ u32 *data)
22271+{
22272+ return __smsc75xx_read_reg(dev, index, data, 1);
22273+}
22274+
22275+static int __must_check smsc75xx_write_reg_nopm(struct usbnet *dev, u32 index,
22276+ u32 data)
22277+{
22278+ return __smsc75xx_write_reg(dev, index, data, 1);
22279+}
22280+
22281+static int __must_check smsc75xx_read_reg(struct usbnet *dev, u32 index,
22282+ u32 *data)
22283+{
22284+ return __smsc75xx_read_reg(dev, index, data, 0);
22285+}
22286+
22287+static int __must_check smsc75xx_write_reg(struct usbnet *dev, u32 index,
22288+ u32 data)
22289+{
22290+ return __smsc75xx_write_reg(dev, index, data, 0);
22291+}
22292+
22293+/* Loop until the read is completed with timeout
22294+ * called with phy_mutex held */
22295+static __must_check int __smsc75xx_phy_wait_not_busy(struct usbnet *dev,
22296+ int in_pm)
22297+{
22298+ unsigned long start_time = jiffies;
22299+ u32 val;
22300+ int ret;
22301+
22302+ do {
22303+ ret = __smsc75xx_read_reg(dev, MII_ACCESS, &val, in_pm);
22304+ if (ret < 0) {
22305+ netdev_warn(dev->net, "Error reading MII_ACCESS\n");
22306+ return ret;
22307+ }
22308+
22309+ if (!(val & MII_ACCESS_BUSY))
22310+ return 0;
22311+ } while (!time_after(jiffies, start_time + HZ));
22312+
22313+ return -EIO;
22314+}
22315+
22316+static int __smsc75xx_mdio_read(struct net_device *netdev, int phy_id, int idx,
22317+ int in_pm)
22318+{
22319+ struct usbnet *dev = netdev_priv(netdev);
22320+ u32 val, addr;
22321+ int ret;
22322+
22323+ mutex_lock(&dev->phy_mutex);
22324+
22325+ /* confirm MII not busy */
22326+ ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
22327+ if (ret < 0) {
22328+ netdev_warn(dev->net, "MII is busy in smsc75xx_mdio_read\n");
22329+ goto done;
22330+ }
22331+
22332+ /* set the address, index & direction (read from PHY) */
22333+ phy_id &= dev->mii.phy_id_mask;
22334+ idx &= dev->mii.reg_num_mask;
22335+ addr = ((phy_id << MII_ACCESS_PHY_ADDR_SHIFT) & MII_ACCESS_PHY_ADDR)
22336+ | ((idx << MII_ACCESS_REG_ADDR_SHIFT) & MII_ACCESS_REG_ADDR)
22337+ | MII_ACCESS_READ | MII_ACCESS_BUSY;
22338+ ret = __smsc75xx_write_reg(dev, MII_ACCESS, addr, in_pm);
22339+ if (ret < 0) {
22340+ netdev_warn(dev->net, "Error writing MII_ACCESS\n");
22341+ goto done;
22342+ }
22343+
22344+ ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
22345+ if (ret < 0) {
22346+ netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
22347+ goto done;
22348+ }
22349+
22350+ ret = __smsc75xx_read_reg(dev, MII_DATA, &val, in_pm);
22351+ if (ret < 0) {
22352+ netdev_warn(dev->net, "Error reading MII_DATA\n");
22353+ goto done;
22354+ }
22355+
22356+ ret = (u16)(val & 0xFFFF);
22357+
22358+done:
22359+ mutex_unlock(&dev->phy_mutex);
22360+ return ret;
22361+}
22362+
22363+static void __smsc75xx_mdio_write(struct net_device *netdev, int phy_id,
22364+ int idx, int regval, int in_pm)
22365+{
22366+ struct usbnet *dev = netdev_priv(netdev);
22367+ u32 val, addr;
22368+ int ret;
22369+
22370+ mutex_lock(&dev->phy_mutex);
22371+
22372+ /* confirm MII not busy */
22373+ ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
22374+ if (ret < 0) {
22375+ netdev_warn(dev->net, "MII is busy in smsc75xx_mdio_write\n");
22376+ goto done;
22377+ }
22378+
22379+ val = regval;
22380+ ret = __smsc75xx_write_reg(dev, MII_DATA, val, in_pm);
22381+ if (ret < 0) {
22382+ netdev_warn(dev->net, "Error writing MII_DATA\n");
22383+ goto done;
22384+ }
22385+
22386+ /* set the address, index & direction (write to PHY) */
22387+ phy_id &= dev->mii.phy_id_mask;
22388+ idx &= dev->mii.reg_num_mask;
22389+ addr = ((phy_id << MII_ACCESS_PHY_ADDR_SHIFT) & MII_ACCESS_PHY_ADDR)
22390+ | ((idx << MII_ACCESS_REG_ADDR_SHIFT) & MII_ACCESS_REG_ADDR)
22391+ | MII_ACCESS_WRITE | MII_ACCESS_BUSY;
22392+ ret = __smsc75xx_write_reg(dev, MII_ACCESS, addr, in_pm);
22393+ if (ret < 0) {
22394+ netdev_warn(dev->net, "Error writing MII_ACCESS\n");
22395+ goto done;
22396+ }
22397+
22398+ ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
22399+ if (ret < 0) {
22400+ netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
22401+ goto done;
22402+ }
22403+
22404+done:
22405+ mutex_unlock(&dev->phy_mutex);
22406+}
22407+
22408+static int smsc75xx_mdio_read_nopm(struct net_device *netdev, int phy_id,
22409+ int idx)
22410+{
22411+ return __smsc75xx_mdio_read(netdev, phy_id, idx, 1);
22412+}
22413+
22414+static void smsc75xx_mdio_write_nopm(struct net_device *netdev, int phy_id,
22415+ int idx, int regval)
22416+{
22417+ __smsc75xx_mdio_write(netdev, phy_id, idx, regval, 1);
22418+}
22419+
22420+static int smsc75xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
22421+{
22422+ return __smsc75xx_mdio_read(netdev, phy_id, idx, 0);
22423+}
22424+
22425+static void smsc75xx_mdio_write(struct net_device *netdev, int phy_id, int idx,
22426+ int regval)
22427+{
22428+ __smsc75xx_mdio_write(netdev, phy_id, idx, regval, 0);
22429+}
22430+
22431+static int smsc75xx_wait_eeprom(struct usbnet *dev)
22432+{
22433+ unsigned long start_time = jiffies;
22434+ u32 val;
22435+ int ret;
22436+
22437+ do {
22438+ ret = smsc75xx_read_reg(dev, E2P_CMD, &val);
22439+ if (ret < 0) {
22440+ netdev_warn(dev->net, "Error reading E2P_CMD\n");
22441+ return ret;
22442+ }
22443+
22444+ if (!(val & E2P_CMD_BUSY) || (val & E2P_CMD_TIMEOUT))
22445+ break;
22446+ udelay(40);
22447+ } while (!time_after(jiffies, start_time + HZ));
22448+
22449+ if (val & (E2P_CMD_TIMEOUT | E2P_CMD_BUSY)) {
22450+ netdev_warn(dev->net, "EEPROM read operation timeout\n");
22451+ return -EIO;
22452+ }
22453+
22454+ return 0;
22455+}
22456+
22457+static int smsc75xx_eeprom_confirm_not_busy(struct usbnet *dev)
22458+{
22459+ unsigned long start_time = jiffies;
22460+ u32 val;
22461+ int ret;
22462+
22463+ do {
22464+ ret = smsc75xx_read_reg(dev, E2P_CMD, &val);
22465+ if (ret < 0) {
22466+ netdev_warn(dev->net, "Error reading E2P_CMD\n");
22467+ return ret;
22468+ }
22469+
22470+ if (!(val & E2P_CMD_BUSY))
22471+ return 0;
22472+
22473+ udelay(40);
22474+ } while (!time_after(jiffies, start_time + HZ));
22475+
22476+ netdev_warn(dev->net, "EEPROM is busy\n");
22477+ return -EIO;
22478+}
22479+
22480+static int smsc75xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
22481+ u8 *data)
22482+{
22483+ u32 val;
22484+ int i, ret;
22485+
22486+ BUG_ON(!dev);
22487+ BUG_ON(!data);
22488+
22489+ ret = smsc75xx_eeprom_confirm_not_busy(dev);
22490+ if (ret)
22491+ return ret;
22492+
22493+ for (i = 0; i < length; i++) {
22494+ val = E2P_CMD_BUSY | E2P_CMD_READ | (offset & E2P_CMD_ADDR);
22495+ ret = smsc75xx_write_reg(dev, E2P_CMD, val);
22496+ if (ret < 0) {
22497+ netdev_warn(dev->net, "Error writing E2P_CMD\n");
22498+ return ret;
22499+ }
22500+
22501+ ret = smsc75xx_wait_eeprom(dev);
22502+ if (ret < 0)
22503+ return ret;
22504+
22505+ ret = smsc75xx_read_reg(dev, E2P_DATA, &val);
22506+ if (ret < 0) {
22507+ netdev_warn(dev->net, "Error reading E2P_DATA\n");
22508+ return ret;
22509+ }
22510+
22511+ data[i] = val & 0xFF;
22512+ offset++;
22513+ }
22514+
22515+ return 0;
22516+}
22517+
22518+static int smsc75xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
22519+ u8 *data)
22520+{
22521+ u32 val;
22522+ int i, ret;
22523+
22524+ BUG_ON(!dev);
22525+ BUG_ON(!data);
22526+
22527+ ret = smsc75xx_eeprom_confirm_not_busy(dev);
22528+ if (ret)
22529+ return ret;
22530+
22531+ /* Issue write/erase enable command */
22532+ val = E2P_CMD_BUSY | E2P_CMD_EWEN;
22533+ ret = smsc75xx_write_reg(dev, E2P_CMD, val);
22534+ if (ret < 0) {
22535+ netdev_warn(dev->net, "Error writing E2P_CMD\n");
22536+ return ret;
22537+ }
22538+
22539+ ret = smsc75xx_wait_eeprom(dev);
22540+ if (ret < 0)
22541+ return ret;
22542+
22543+ for (i = 0; i < length; i++) {
22544+
22545+ /* Fill data register */
22546+ val = data[i];
22547+ ret = smsc75xx_write_reg(dev, E2P_DATA, val);
22548+ if (ret < 0) {
22549+ netdev_warn(dev->net, "Error writing E2P_DATA\n");
22550+ return ret;
22551+ }
22552+
22553+ /* Send "write" command */
22554+ val = E2P_CMD_BUSY | E2P_CMD_WRITE | (offset & E2P_CMD_ADDR);
22555+ ret = smsc75xx_write_reg(dev, E2P_CMD, val);
22556+ if (ret < 0) {
22557+ netdev_warn(dev->net, "Error writing E2P_CMD\n");
22558+ return ret;
22559+ }
22560+
22561+ ret = smsc75xx_wait_eeprom(dev);
22562+ if (ret < 0)
22563+ return ret;
22564+
22565+ offset++;
22566+ }
22567+
22568+ return 0;
22569+}
22570+
22571+static int smsc75xx_dataport_wait_not_busy(struct usbnet *dev)
22572+{
22573+ int i, ret;
22574+
22575+ for (i = 0; i < 100; i++) {
22576+ u32 dp_sel;
22577+ ret = smsc75xx_read_reg(dev, DP_SEL, &dp_sel);
22578+ if (ret < 0) {
22579+ netdev_warn(dev->net, "Error reading DP_SEL\n");
22580+ return ret;
22581+ }
22582+
22583+ if (dp_sel & DP_SEL_DPRDY)
22584+ return 0;
22585+
22586+ udelay(40);
22587+ }
22588+
22589+ netdev_warn(dev->net, "smsc75xx_dataport_wait_not_busy timed out\n");
22590+
22591+ return -EIO;
22592+}
22593+
22594+static int smsc75xx_dataport_write(struct usbnet *dev, u32 ram_select, u32 addr,
22595+ u32 length, u32 *buf)
22596+{
22597+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
22598+ u32 dp_sel;
22599+ int i, ret;
22600+
22601+ mutex_lock(&pdata->dataport_mutex);
22602+
22603+ ret = smsc75xx_dataport_wait_not_busy(dev);
22604+ if (ret < 0) {
22605+ netdev_warn(dev->net, "smsc75xx_dataport_write busy on entry\n");
22606+ goto done;
22607+ }
22608+
22609+ ret = smsc75xx_read_reg(dev, DP_SEL, &dp_sel);
22610+ if (ret < 0) {
22611+ netdev_warn(dev->net, "Error reading DP_SEL\n");
22612+ goto done;
22613+ }
22614+
22615+ dp_sel &= ~DP_SEL_RSEL;
22616+ dp_sel |= ram_select;
22617+ ret = smsc75xx_write_reg(dev, DP_SEL, dp_sel);
22618+ if (ret < 0) {
22619+ netdev_warn(dev->net, "Error writing DP_SEL\n");
22620+ goto done;
22621+ }
22622+
22623+ for (i = 0; i < length; i++) {
22624+ ret = smsc75xx_write_reg(dev, DP_ADDR, addr + i);
22625+ if (ret < 0) {
22626+ netdev_warn(dev->net, "Error writing DP_ADDR\n");
22627+ goto done;
22628+ }
22629+
22630+ ret = smsc75xx_write_reg(dev, DP_DATA, buf[i]);
22631+ if (ret < 0) {
22632+ netdev_warn(dev->net, "Error writing DP_DATA\n");
22633+ goto done;
22634+ }
22635+
22636+ ret = smsc75xx_write_reg(dev, DP_CMD, DP_CMD_WRITE);
22637+ if (ret < 0) {
22638+ netdev_warn(dev->net, "Error writing DP_CMD\n");
22639+ goto done;
22640+ }
22641+
22642+ ret = smsc75xx_dataport_wait_not_busy(dev);
22643+ if (ret < 0) {
22644+ netdev_warn(dev->net, "smsc75xx_dataport_write timeout\n");
22645+ goto done;
22646+ }
22647+ }
22648+
22649+done:
22650+ mutex_unlock(&pdata->dataport_mutex);
22651+ return ret;
22652+}
22653+
22654+/* returns hash bit number for given MAC address */
22655+static u32 smsc75xx_hash(char addr[ETH_ALEN])
22656+{
22657+ return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
22658+}
22659+
22660+static void smsc75xx_deferred_multicast_write(struct work_struct *param)
22661+{
22662+ struct smsc75xx_priv *pdata =
22663+ container_of(param, struct smsc75xx_priv, set_multicast);
22664+ struct usbnet *dev = pdata->dev;
22665+ int ret;
22666+
22667+ netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
22668+ pdata->rfe_ctl);
22669+
22670+ smsc75xx_dataport_write(dev, DP_SEL_VHF, DP_SEL_VHF_VLAN_LEN,
22671+ DP_SEL_VHF_HASH_LEN, pdata->multicast_hash_table);
22672+
22673+ ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
22674+ if (ret < 0)
22675+ netdev_warn(dev->net, "Error writing RFE_CRL\n");
22676+}
22677+
22678+static void smsc75xx_set_multicast(struct net_device *netdev)
22679+{
22680+ struct usbnet *dev = netdev_priv(netdev);
22681+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
22682+ unsigned long flags;
22683+ int i;
22684+
22685+ spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
22686+
22687+ pdata->rfe_ctl &=
22688+ ~(RFE_CTL_AU | RFE_CTL_AM | RFE_CTL_DPF | RFE_CTL_MHF);
22689+ pdata->rfe_ctl |= RFE_CTL_AB;
22690+
22691+ for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
22692+ pdata->multicast_hash_table[i] = 0;
22693+
22694+ if (dev->net->flags & IFF_PROMISC) {
22695+ netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
22696+ pdata->rfe_ctl |= RFE_CTL_AM | RFE_CTL_AU;
22697+ } else if (dev->net->flags & IFF_ALLMULTI) {
22698+ netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
22699+ pdata->rfe_ctl |= RFE_CTL_AM | RFE_CTL_DPF;
22700+ } else if (!netdev_mc_empty(dev->net)) {
22701+ struct netdev_hw_addr *ha;
22702+
22703+ netif_dbg(dev, drv, dev->net, "receive multicast hash filter\n");
22704+
22705+ pdata->rfe_ctl |= RFE_CTL_MHF | RFE_CTL_DPF;
22706+
22707+ netdev_for_each_mc_addr(ha, netdev) {
22708+ u32 bitnum = smsc75xx_hash(ha->addr);
22709+ pdata->multicast_hash_table[bitnum / 32] |=
22710+ (1 << (bitnum % 32));
22711+ }
22712+ } else {
22713+ netif_dbg(dev, drv, dev->net, "receive own packets only\n");
22714+ pdata->rfe_ctl |= RFE_CTL_DPF;
22715+ }
22716+
22717+ spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
22718+
22719+ /* defer register writes to a sleepable context */
22720+ schedule_work(&pdata->set_multicast);
22721+}
22722+
22723+static int smsc75xx_update_flowcontrol(struct usbnet *dev, u8 duplex,
22724+ u16 lcladv, u16 rmtadv)
22725+{
22726+ u32 flow = 0, fct_flow = 0;
22727+ int ret;
22728+
22729+ if (duplex == DUPLEX_FULL) {
22730+ u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
22731+
22732+ if (cap & FLOW_CTRL_TX) {
22733+ flow = (FLOW_TX_FCEN | 0xFFFF);
22734+ /* set fct_flow thresholds to 20% and 80% */
22735+ fct_flow = (8 << 8) | 32;
22736+ }
22737+
22738+ if (cap & FLOW_CTRL_RX)
22739+ flow |= FLOW_RX_FCEN;
22740+
22741+ netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
22742+ (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
22743+ (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
22744+ } else {
22745+ netif_dbg(dev, link, dev->net, "half duplex\n");
22746+ }
22747+
22748+ ret = smsc75xx_write_reg(dev, FLOW, flow);
22749+ if (ret < 0) {
22750+ netdev_warn(dev->net, "Error writing FLOW\n");
22751+ return ret;
22752+ }
22753+
22754+ ret = smsc75xx_write_reg(dev, FCT_FLOW, fct_flow);
22755+ if (ret < 0) {
22756+ netdev_warn(dev->net, "Error writing FCT_FLOW\n");
22757+ return ret;
22758+ }
22759+
22760+ return 0;
22761+}
22762+
22763+static int smsc75xx_link_reset(struct usbnet *dev)
22764+{
22765+ struct mii_if_info *mii = &dev->mii;
22766+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
22767+ u16 lcladv, rmtadv;
22768+ int ret;
22769+
22770+ /* write to clear phy interrupt status */
22771+ smsc75xx_mdio_write(dev->net, mii->phy_id, PHY_INT_SRC,
22772+ PHY_INT_SRC_CLEAR_ALL);
22773+
22774+ ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
22775+ if (ret < 0) {
22776+ netdev_warn(dev->net, "Error writing INT_STS\n");
22777+ return ret;
22778+ }
22779+
22780+ mii_check_media(mii, 1, 1);
22781+ mii_ethtool_gset(&dev->mii, &ecmd);
22782+ lcladv = smsc75xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
22783+ rmtadv = smsc75xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
22784+
22785+ netif_dbg(dev, link, dev->net, "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",
22786+ ethtool_cmd_speed(&ecmd), ecmd.duplex, lcladv, rmtadv);
22787+
22788+ return smsc75xx_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
22789+}
22790+
22791+static void smsc75xx_status(struct usbnet *dev, struct urb *urb)
22792+{
22793+ u32 intdata;
22794+
22795+ if (urb->actual_length != 4) {
22796+ netdev_warn(dev->net, "unexpected urb length %d\n",
22797+ urb->actual_length);
22798+ return;
22799+ }
22800+
22801+ memcpy(&intdata, urb->transfer_buffer, 4);
22802+ le32_to_cpus(&intdata);
22803+
22804+ netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
22805+
22806+ if (intdata & INT_ENP_PHY_INT)
22807+ usbnet_defer_kevent(dev, EVENT_LINK_RESET);
22808+ else
22809+ netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
22810+ intdata);
22811+}
22812+
22813+static int smsc75xx_ethtool_get_eeprom_len(struct net_device *net)
22814+{
22815+ return MAX_EEPROM_SIZE;
22816+}
22817+
22818+static int smsc75xx_ethtool_get_eeprom(struct net_device *netdev,
22819+ struct ethtool_eeprom *ee, u8 *data)
22820+{
22821+ struct usbnet *dev = netdev_priv(netdev);
22822+
22823+ ee->magic = LAN75XX_EEPROM_MAGIC;
22824+
22825+ return smsc75xx_read_eeprom(dev, ee->offset, ee->len, data);
22826+}
22827+
22828+static int smsc75xx_ethtool_set_eeprom(struct net_device *netdev,
22829+ struct ethtool_eeprom *ee, u8 *data)
22830+{
22831+ struct usbnet *dev = netdev_priv(netdev);
22832+
22833+ if (ee->magic != LAN75XX_EEPROM_MAGIC) {
22834+ netdev_warn(dev->net, "EEPROM: magic value mismatch: 0x%x\n",
22835+ ee->magic);
22836+ return -EINVAL;
22837+ }
22838+
22839+ return smsc75xx_write_eeprom(dev, ee->offset, ee->len, data);
22840+}
22841+
22842+static void smsc75xx_ethtool_get_wol(struct net_device *net,
22843+ struct ethtool_wolinfo *wolinfo)
22844+{
22845+ struct usbnet *dev = netdev_priv(net);
22846+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
22847+
22848+ wolinfo->supported = SUPPORTED_WAKE;
22849+ wolinfo->wolopts = pdata->wolopts;
22850+}
22851+
22852+static int smsc75xx_ethtool_set_wol(struct net_device *net,
22853+ struct ethtool_wolinfo *wolinfo)
22854+{
22855+ struct usbnet *dev = netdev_priv(net);
22856+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
22857+ int ret;
22858+
22859+ pdata->wolopts = wolinfo->wolopts & SUPPORTED_WAKE;
22860+
22861+ ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
22862+ if (ret < 0)
22863+ netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
22864+
22865+ return ret;
22866+}
22867+
22868+static const struct ethtool_ops smsc75xx_ethtool_ops = {
22869+ .get_link = usbnet_get_link,
22870+ .nway_reset = usbnet_nway_reset,
22871+ .get_drvinfo = usbnet_get_drvinfo,
22872+ .get_msglevel = usbnet_get_msglevel,
22873+ .set_msglevel = usbnet_set_msglevel,
22874+ .get_settings = usbnet_get_settings,
22875+ .set_settings = usbnet_set_settings,
22876+ .get_eeprom_len = smsc75xx_ethtool_get_eeprom_len,
22877+ .get_eeprom = smsc75xx_ethtool_get_eeprom,
22878+ .set_eeprom = smsc75xx_ethtool_set_eeprom,
22879+ .get_wol = smsc75xx_ethtool_get_wol,
22880+ .set_wol = smsc75xx_ethtool_set_wol,
22881+};
22882+
22883+static int smsc75xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
22884+{
22885+ struct usbnet *dev = netdev_priv(netdev);
22886+
22887+ if (!netif_running(netdev))
22888+ return -EINVAL;
22889+
22890+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
22891+}
22892+
22893+static void smsc75xx_init_mac_address(struct usbnet *dev)
22894+{
22895+ /* try reading mac address from EEPROM */
22896+ if (smsc75xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
22897+ dev->net->dev_addr) == 0) {
22898+ if (is_valid_ether_addr(dev->net->dev_addr)) {
22899+ /* eeprom values are valid so use them */
22900+ netif_dbg(dev, ifup, dev->net,
22901+ "MAC address read from EEPROM\n");
22902+ return;
22903+ }
22904+ }
22905+
22906+ /* no eeprom, or eeprom values are invalid. generate random MAC */
22907+ eth_hw_addr_random(dev->net);
22908+ netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
22909+}
22910+
22911+static int smsc75xx_set_mac_address(struct usbnet *dev)
22912+{
22913+ u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
22914+ dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
22915+ u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
22916+
22917+ int ret = smsc75xx_write_reg(dev, RX_ADDRH, addr_hi);
22918+ if (ret < 0) {
22919+ netdev_warn(dev->net, "Failed to write RX_ADDRH: %d\n", ret);
22920+ return ret;
22921+ }
22922+
22923+ ret = smsc75xx_write_reg(dev, RX_ADDRL, addr_lo);
22924+ if (ret < 0) {
22925+ netdev_warn(dev->net, "Failed to write RX_ADDRL: %d\n", ret);
22926+ return ret;
22927+ }
22928+
22929+ addr_hi |= ADDR_FILTX_FB_VALID;
22930+ ret = smsc75xx_write_reg(dev, ADDR_FILTX, addr_hi);
22931+ if (ret < 0) {
22932+ netdev_warn(dev->net, "Failed to write ADDR_FILTX: %d\n", ret);
22933+ return ret;
22934+ }
22935+
22936+ ret = smsc75xx_write_reg(dev, ADDR_FILTX + 4, addr_lo);
22937+ if (ret < 0)
22938+ netdev_warn(dev->net, "Failed to write ADDR_FILTX+4: %d\n", ret);
22939+
22940+ return ret;
22941+}
22942+
22943+static int smsc75xx_phy_initialize(struct usbnet *dev)
22944+{
22945+ int bmcr, ret, timeout = 0;
22946+
22947+ /* Initialize MII structure */
22948+ dev->mii.dev = dev->net;
22949+ dev->mii.mdio_read = smsc75xx_mdio_read;
22950+ dev->mii.mdio_write = smsc75xx_mdio_write;
22951+ dev->mii.phy_id_mask = 0x1f;
22952+ dev->mii.reg_num_mask = 0x1f;
22953+ dev->mii.supports_gmii = 1;
22954+ dev->mii.phy_id = SMSC75XX_INTERNAL_PHY_ID;
22955+
22956+ /* reset phy and wait for reset to complete */
22957+ smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
22958+
22959+ do {
22960+ msleep(10);
22961+ bmcr = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
22962+ if (bmcr < 0) {
22963+ netdev_warn(dev->net, "Error reading MII_BMCR\n");
22964+ return bmcr;
22965+ }
22966+ timeout++;
22967+ } while ((bmcr & BMCR_RESET) && (timeout < 100));
22968+
22969+ if (timeout >= 100) {
22970+ netdev_warn(dev->net, "timeout on PHY Reset\n");
22971+ return -EIO;
22972+ }
22973+
22974+ smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
22975+ ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP |
22976+ ADVERTISE_PAUSE_ASYM);
22977+ smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_CTRL1000,
22978+ ADVERTISE_1000FULL);
22979+
22980+ /* read and write to clear phy interrupt status */
22981+ ret = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
22982+ if (ret < 0) {
22983+ netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
22984+ return ret;
22985+ }
22986+
22987+ smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_SRC, 0xffff);
22988+
22989+ smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
22990+ PHY_INT_MASK_DEFAULT);
22991+ mii_nway_restart(&dev->mii);
22992+
22993+ netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
22994+ return 0;
22995+}
22996+
22997+static int smsc75xx_set_rx_max_frame_length(struct usbnet *dev, int size)
22998+{
22999+ int ret = 0;
23000+ u32 buf;
23001+ bool rxenabled;
23002+
23003+ ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
23004+ if (ret < 0) {
23005+ netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
23006+ return ret;
23007+ }
23008+
23009+ rxenabled = ((buf & MAC_RX_RXEN) != 0);
23010+
23011+ if (rxenabled) {
23012+ buf &= ~MAC_RX_RXEN;
23013+ ret = smsc75xx_write_reg(dev, MAC_RX, buf);
23014+ if (ret < 0) {
23015+ netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
23016+ return ret;
23017+ }
23018+ }
23019+
23020+ /* add 4 to size for FCS */
23021+ buf &= ~MAC_RX_MAX_SIZE;
23022+ buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT) & MAC_RX_MAX_SIZE);
23023+
23024+ ret = smsc75xx_write_reg(dev, MAC_RX, buf);
23025+ if (ret < 0) {
23026+ netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
23027+ return ret;
23028+ }
23029+
23030+ if (rxenabled) {
23031+ buf |= MAC_RX_RXEN;
23032+ ret = smsc75xx_write_reg(dev, MAC_RX, buf);
23033+ if (ret < 0) {
23034+ netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
23035+ return ret;
23036+ }
23037+ }
23038+
23039+ return 0;
23040+}
23041+
23042+static int smsc75xx_change_mtu(struct net_device *netdev, int new_mtu)
23043+{
23044+ struct usbnet *dev = netdev_priv(netdev);
23045+ int ret;
23046+
23047+ if (new_mtu > MAX_SINGLE_PACKET_SIZE)
23048+ return -EINVAL;
23049+
23050+ ret = smsc75xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
23051+ if (ret < 0) {
23052+ netdev_warn(dev->net, "Failed to set mac rx frame length\n");
23053+ return ret;
23054+ }
23055+
23056+ return usbnet_change_mtu(netdev, new_mtu);
23057+}
23058+
23059+/* Enable or disable Rx checksum offload engine */
23060+static int smsc75xx_set_features(struct net_device *netdev,
23061+ netdev_features_t features)
23062+{
23063+ struct usbnet *dev = netdev_priv(netdev);
23064+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23065+ unsigned long flags;
23066+ int ret;
23067+
23068+ spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
23069+
23070+ if (features & NETIF_F_RXCSUM)
23071+ pdata->rfe_ctl |= RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM;
23072+ else
23073+ pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM);
23074+
23075+ spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
23076+ /* it's racing here! */
23077+
23078+ ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
23079+ if (ret < 0)
23080+ netdev_warn(dev->net, "Error writing RFE_CTL\n");
23081+
23082+ return ret;
23083+}
23084+
23085+static int smsc75xx_wait_ready(struct usbnet *dev, int in_pm)
23086+{
23087+ int timeout = 0;
23088+
23089+ do {
23090+ u32 buf;
23091+ int ret;
23092+
23093+ ret = __smsc75xx_read_reg(dev, PMT_CTL, &buf, in_pm);
23094+
23095+ if (ret < 0) {
23096+ netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
23097+ return ret;
23098+ }
23099+
23100+ if (buf & PMT_CTL_DEV_RDY)
23101+ return 0;
23102+
23103+ msleep(10);
23104+ timeout++;
23105+ } while (timeout < 100);
23106+
23107+ netdev_warn(dev->net, "timeout waiting for device ready\n");
23108+ return -EIO;
23109+}
23110+
23111+static int smsc75xx_reset(struct usbnet *dev)
23112+{
23113+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23114+ u32 buf;
23115+ int ret = 0, timeout;
23116+
23117+ netif_dbg(dev, ifup, dev->net, "entering smsc75xx_reset\n");
23118+
23119+ ret = smsc75xx_wait_ready(dev, 0);
23120+ if (ret < 0) {
23121+ netdev_warn(dev->net, "device not ready in smsc75xx_reset\n");
23122+ return ret;
23123+ }
23124+
23125+ ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
23126+ if (ret < 0) {
23127+ netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
23128+ return ret;
23129+ }
23130+
23131+ buf |= HW_CFG_LRST;
23132+
23133+ ret = smsc75xx_write_reg(dev, HW_CFG, buf);
23134+ if (ret < 0) {
23135+ netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
23136+ return ret;
23137+ }
23138+
23139+ timeout = 0;
23140+ do {
23141+ msleep(10);
23142+ ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
23143+ if (ret < 0) {
23144+ netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
23145+ return ret;
23146+ }
23147+ timeout++;
23148+ } while ((buf & HW_CFG_LRST) && (timeout < 100));
23149+
23150+ if (timeout >= 100) {
23151+ netdev_warn(dev->net, "timeout on completion of Lite Reset\n");
23152+ return -EIO;
23153+ }
23154+
23155+ netif_dbg(dev, ifup, dev->net, "Lite reset complete, resetting PHY\n");
23156+
23157+ ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
23158+ if (ret < 0) {
23159+ netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
23160+ return ret;
23161+ }
23162+
23163+ buf |= PMT_CTL_PHY_RST;
23164+
23165+ ret = smsc75xx_write_reg(dev, PMT_CTL, buf);
23166+ if (ret < 0) {
23167+ netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
23168+ return ret;
23169+ }
23170+
23171+ timeout = 0;
23172+ do {
23173+ msleep(10);
23174+ ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
23175+ if (ret < 0) {
23176+ netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
23177+ return ret;
23178+ }
23179+ timeout++;
23180+ } while ((buf & PMT_CTL_PHY_RST) && (timeout < 100));
23181+
23182+ if (timeout >= 100) {
23183+ netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
23184+ return -EIO;
23185+ }
23186+
23187+ netif_dbg(dev, ifup, dev->net, "PHY reset complete\n");
23188+
23189+ ret = smsc75xx_set_mac_address(dev);
23190+ if (ret < 0) {
23191+ netdev_warn(dev->net, "Failed to set mac address\n");
23192+ return ret;
23193+ }
23194+
23195+ netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
23196+ dev->net->dev_addr);
23197+
23198+ ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
23199+ if (ret < 0) {
23200+ netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
23201+ return ret;
23202+ }
23203+
23204+ netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
23205+ buf);
23206+
23207+ buf |= HW_CFG_BIR;
23208+
23209+ ret = smsc75xx_write_reg(dev, HW_CFG, buf);
23210+ if (ret < 0) {
23211+ netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
23212+ return ret;
23213+ }
23214+
23215+ ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
23216+ if (ret < 0) {
23217+ netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
23218+ return ret;
23219+ }
23220+
23221+ netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG after writing HW_CFG_BIR: 0x%08x\n",
23222+ buf);
23223+
23224+ if (!turbo_mode) {
23225+ buf = 0;
23226+ dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
23227+ } else if (dev->udev->speed == USB_SPEED_HIGH) {
23228+ buf = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
23229+ dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
23230+ } else {
23231+ buf = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
23232+ dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
23233+ }
23234+
23235+ netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
23236+ (ulong)dev->rx_urb_size);
23237+
23238+ ret = smsc75xx_write_reg(dev, BURST_CAP, buf);
23239+ if (ret < 0) {
23240+ netdev_warn(dev->net, "Failed to write BURST_CAP: %d\n", ret);
23241+ return ret;
23242+ }
23243+
23244+ ret = smsc75xx_read_reg(dev, BURST_CAP, &buf);
23245+ if (ret < 0) {
23246+ netdev_warn(dev->net, "Failed to read BURST_CAP: %d\n", ret);
23247+ return ret;
23248+ }
23249+
23250+ netif_dbg(dev, ifup, dev->net,
23251+ "Read Value from BURST_CAP after writing: 0x%08x\n", buf);
23252+
23253+ ret = smsc75xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
23254+ if (ret < 0) {
23255+ netdev_warn(dev->net, "Failed to write BULK_IN_DLY: %d\n", ret);
23256+ return ret;
23257+ }
23258+
23259+ ret = smsc75xx_read_reg(dev, BULK_IN_DLY, &buf);
23260+ if (ret < 0) {
23261+ netdev_warn(dev->net, "Failed to read BULK_IN_DLY: %d\n", ret);
23262+ return ret;
23263+ }
23264+
23265+ netif_dbg(dev, ifup, dev->net,
23266+ "Read Value from BULK_IN_DLY after writing: 0x%08x\n", buf);
23267+
23268+ if (turbo_mode) {
23269+ ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
23270+ if (ret < 0) {
23271+ netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
23272+ return ret;
23273+ }
23274+
23275+ netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
23276+
23277+ buf |= (HW_CFG_MEF | HW_CFG_BCE);
23278+
23279+ ret = smsc75xx_write_reg(dev, HW_CFG, buf);
23280+ if (ret < 0) {
23281+ netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
23282+ return ret;
23283+ }
23284+
23285+ ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
23286+ if (ret < 0) {
23287+ netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
23288+ return ret;
23289+ }
23290+
23291+ netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
23292+ }
23293+
23294+ /* set FIFO sizes */
23295+ buf = (MAX_RX_FIFO_SIZE - 512) / 512;
23296+ ret = smsc75xx_write_reg(dev, FCT_RX_FIFO_END, buf);
23297+ if (ret < 0) {
23298+ netdev_warn(dev->net, "Failed to write FCT_RX_FIFO_END: %d\n", ret);
23299+ return ret;
23300+ }
23301+
23302+ netif_dbg(dev, ifup, dev->net, "FCT_RX_FIFO_END set to 0x%08x\n", buf);
23303+
23304+ buf = (MAX_TX_FIFO_SIZE - 512) / 512;
23305+ ret = smsc75xx_write_reg(dev, FCT_TX_FIFO_END, buf);
23306+ if (ret < 0) {
23307+ netdev_warn(dev->net, "Failed to write FCT_TX_FIFO_END: %d\n", ret);
23308+ return ret;
23309+ }
23310+
23311+ netif_dbg(dev, ifup, dev->net, "FCT_TX_FIFO_END set to 0x%08x\n", buf);
23312+
23313+ ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
23314+ if (ret < 0) {
23315+ netdev_warn(dev->net, "Failed to write INT_STS: %d\n", ret);
23316+ return ret;
23317+ }
23318+
23319+ ret = smsc75xx_read_reg(dev, ID_REV, &buf);
23320+ if (ret < 0) {
23321+ netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
23322+ return ret;
23323+ }
23324+
23325+ netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", buf);
23326+
23327+ ret = smsc75xx_read_reg(dev, E2P_CMD, &buf);
23328+ if (ret < 0) {
23329+ netdev_warn(dev->net, "Failed to read E2P_CMD: %d\n", ret);
23330+ return ret;
23331+ }
23332+
23333+ /* only set default GPIO/LED settings if no EEPROM is detected */
23334+ if (!(buf & E2P_CMD_LOADED)) {
23335+ ret = smsc75xx_read_reg(dev, LED_GPIO_CFG, &buf);
23336+ if (ret < 0) {
23337+ netdev_warn(dev->net, "Failed to read LED_GPIO_CFG: %d\n", ret);
23338+ return ret;
23339+ }
23340+
23341+ buf &= ~(LED_GPIO_CFG_LED2_FUN_SEL | LED_GPIO_CFG_LED10_FUN_SEL);
23342+ buf |= LED_GPIO_CFG_LEDGPIO_EN | LED_GPIO_CFG_LED2_FUN_SEL;
23343+
23344+ ret = smsc75xx_write_reg(dev, LED_GPIO_CFG, buf);
23345+ if (ret < 0) {
23346+ netdev_warn(dev->net, "Failed to write LED_GPIO_CFG: %d\n", ret);
23347+ return ret;
23348+ }
23349+ }
23350+
23351+ ret = smsc75xx_write_reg(dev, FLOW, 0);
23352+ if (ret < 0) {
23353+ netdev_warn(dev->net, "Failed to write FLOW: %d\n", ret);
23354+ return ret;
23355+ }
23356+
23357+ ret = smsc75xx_write_reg(dev, FCT_FLOW, 0);
23358+ if (ret < 0) {
23359+ netdev_warn(dev->net, "Failed to write FCT_FLOW: %d\n", ret);
23360+ return ret;
23361+ }
23362+
23363+ /* Don't need rfe_ctl_lock during initialisation */
23364+ ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
23365+ if (ret < 0) {
23366+ netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
23367+ return ret;
23368+ }
23369+
23370+ pdata->rfe_ctl |= RFE_CTL_AB | RFE_CTL_DPF;
23371+
23372+ ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
23373+ if (ret < 0) {
23374+ netdev_warn(dev->net, "Failed to write RFE_CTL: %d\n", ret);
23375+ return ret;
23376+ }
23377+
23378+ ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
23379+ if (ret < 0) {
23380+ netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
23381+ return ret;
23382+ }
23383+
23384+ netif_dbg(dev, ifup, dev->net, "RFE_CTL set to 0x%08x\n",
23385+ pdata->rfe_ctl);
23386+
23387+ /* Enable or disable checksum offload engines */
23388+ smsc75xx_set_features(dev->net, dev->net->features);
23389+
23390+ smsc75xx_set_multicast(dev->net);
23391+
23392+ ret = smsc75xx_phy_initialize(dev);
23393+ if (ret < 0) {
23394+ netdev_warn(dev->net, "Failed to initialize PHY: %d\n", ret);
23395+ return ret;
23396+ }
23397+
23398+ ret = smsc75xx_read_reg(dev, INT_EP_CTL, &buf);
23399+ if (ret < 0) {
23400+ netdev_warn(dev->net, "Failed to read INT_EP_CTL: %d\n", ret);
23401+ return ret;
23402+ }
23403+
23404+ /* enable PHY interrupts */
23405+ buf |= INT_ENP_PHY_INT;
23406+
23407+ ret = smsc75xx_write_reg(dev, INT_EP_CTL, buf);
23408+ if (ret < 0) {
23409+ netdev_warn(dev->net, "Failed to write INT_EP_CTL: %d\n", ret);
23410+ return ret;
23411+ }
23412+
23413+ /* allow mac to detect speed and duplex from phy */
23414+ ret = smsc75xx_read_reg(dev, MAC_CR, &buf);
23415+ if (ret < 0) {
23416+ netdev_warn(dev->net, "Failed to read MAC_CR: %d\n", ret);
23417+ return ret;
23418+ }
23419+
23420+ buf |= (MAC_CR_ADD | MAC_CR_ASD);
23421+ ret = smsc75xx_write_reg(dev, MAC_CR, buf);
23422+ if (ret < 0) {
23423+ netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
23424+ return ret;
23425+ }
23426+
23427+ ret = smsc75xx_read_reg(dev, MAC_TX, &buf);
23428+ if (ret < 0) {
23429+ netdev_warn(dev->net, "Failed to read MAC_TX: %d\n", ret);
23430+ return ret;
23431+ }
23432+
23433+ buf |= MAC_TX_TXEN;
23434+
23435+ ret = smsc75xx_write_reg(dev, MAC_TX, buf);
23436+ if (ret < 0) {
23437+ netdev_warn(dev->net, "Failed to write MAC_TX: %d\n", ret);
23438+ return ret;
23439+ }
23440+
23441+ netif_dbg(dev, ifup, dev->net, "MAC_TX set to 0x%08x\n", buf);
23442+
23443+ ret = smsc75xx_read_reg(dev, FCT_TX_CTL, &buf);
23444+ if (ret < 0) {
23445+ netdev_warn(dev->net, "Failed to read FCT_TX_CTL: %d\n", ret);
23446+ return ret;
23447+ }
23448+
23449+ buf |= FCT_TX_CTL_EN;
23450+
23451+ ret = smsc75xx_write_reg(dev, FCT_TX_CTL, buf);
23452+ if (ret < 0) {
23453+ netdev_warn(dev->net, "Failed to write FCT_TX_CTL: %d\n", ret);
23454+ return ret;
23455+ }
23456+
23457+ netif_dbg(dev, ifup, dev->net, "FCT_TX_CTL set to 0x%08x\n", buf);
23458+
23459+ ret = smsc75xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
23460+ if (ret < 0) {
23461+ netdev_warn(dev->net, "Failed to set max rx frame length\n");
23462+ return ret;
23463+ }
23464+
23465+ ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
23466+ if (ret < 0) {
23467+ netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
23468+ return ret;
23469+ }
23470+
23471+ buf |= MAC_RX_RXEN;
23472+
23473+ ret = smsc75xx_write_reg(dev, MAC_RX, buf);
23474+ if (ret < 0) {
23475+ netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
23476+ return ret;
23477+ }
23478+
23479+ netif_dbg(dev, ifup, dev->net, "MAC_RX set to 0x%08x\n", buf);
23480+
23481+ ret = smsc75xx_read_reg(dev, FCT_RX_CTL, &buf);
23482+ if (ret < 0) {
23483+ netdev_warn(dev->net, "Failed to read FCT_RX_CTL: %d\n", ret);
23484+ return ret;
23485+ }
23486+
23487+ buf |= FCT_RX_CTL_EN;
23488+
23489+ ret = smsc75xx_write_reg(dev, FCT_RX_CTL, buf);
23490+ if (ret < 0) {
23491+ netdev_warn(dev->net, "Failed to write FCT_RX_CTL: %d\n", ret);
23492+ return ret;
23493+ }
23494+
23495+ netif_dbg(dev, ifup, dev->net, "FCT_RX_CTL set to 0x%08x\n", buf);
23496+
23497+ netif_dbg(dev, ifup, dev->net, "smsc75xx_reset, return 0\n");
23498+ return 0;
23499+}
23500+
23501+static const struct net_device_ops smsc75xx_netdev_ops = {
23502+ .ndo_open = usbnet_open,
23503+ .ndo_stop = usbnet_stop,
23504+ .ndo_start_xmit = usbnet_start_xmit,
23505+ .ndo_tx_timeout = usbnet_tx_timeout,
23506+ .ndo_change_mtu = smsc75xx_change_mtu,
23507+ .ndo_set_mac_address = eth_mac_addr,
23508+ .ndo_validate_addr = eth_validate_addr,
23509+ .ndo_do_ioctl = smsc75xx_ioctl,
23510+ .ndo_set_rx_mode = smsc75xx_set_multicast,
23511+ .ndo_set_features = smsc75xx_set_features,
23512+};
23513+
23514+static int smsc75xx_bind(struct usbnet *dev, struct usb_interface *intf)
23515+{
23516+ struct smsc75xx_priv *pdata = NULL;
23517+ int ret;
23518+
23519+ printk(KERN_INFO SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n");
23520+
23521+ ret = usbnet_get_endpoints(dev, intf);
23522+ if (ret < 0) {
23523+ netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
23524+ return ret;
23525+ }
23526+
23527+ dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc75xx_priv),
23528+ GFP_KERNEL);
23529+
23530+ pdata = (struct smsc75xx_priv *)(dev->data[0]);
23531+ if (!pdata)
23532+ return -ENOMEM;
23533+
23534+ pdata->dev = dev;
23535+
23536+ spin_lock_init(&pdata->rfe_ctl_lock);
23537+ mutex_init(&pdata->dataport_mutex);
23538+
23539+ INIT_WORK(&pdata->set_multicast, smsc75xx_deferred_multicast_write);
23540+
23541+ if (DEFAULT_TX_CSUM_ENABLE)
23542+ dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
23543+
23544+ if (DEFAULT_RX_CSUM_ENABLE)
23545+ dev->net->features |= NETIF_F_RXCSUM;
23546+
23547+ dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
23548+ NETIF_F_RXCSUM;
23549+
23550+ ret = smsc75xx_wait_ready(dev, 0);
23551+ if (ret < 0) {
23552+ netdev_warn(dev->net, "device not ready in smsc75xx_bind\n");
23553+ return ret;
23554+ }
23555+
23556+ smsc75xx_init_mac_address(dev);
23557+
23558+ /* Init all registers */
23559+ ret = smsc75xx_reset(dev);
23560+ if (ret < 0) {
23561+ netdev_warn(dev->net, "smsc75xx_reset error %d\n", ret);
23562+ return ret;
23563+ }
23564+
23565+ dev->net->netdev_ops = &smsc75xx_netdev_ops;
23566+ dev->net->ethtool_ops = &smsc75xx_ethtool_ops;
23567+ dev->net->flags |= IFF_MULTICAST;
23568+ dev->net->hard_header_len += SMSC75XX_TX_OVERHEAD;
23569+ dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
23570+ return 0;
23571+}
23572+
23573+static void smsc75xx_unbind(struct usbnet *dev, struct usb_interface *intf)
23574+{
23575+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23576+ if (pdata) {
23577+ netif_dbg(dev, ifdown, dev->net, "free pdata\n");
23578+ kfree(pdata);
23579+ pdata = NULL;
23580+ dev->data[0] = 0;
23581+ }
23582+}
23583+
23584+static u16 smsc_crc(const u8 *buffer, size_t len)
23585+{
23586+ return bitrev16(crc16(0xFFFF, buffer, len));
23587+}
23588+
23589+static int smsc75xx_write_wuff(struct usbnet *dev, int filter, u32 wuf_cfg,
23590+ u32 wuf_mask1)
23591+{
23592+ int cfg_base = WUF_CFGX + filter * 4;
23593+ int mask_base = WUF_MASKX + filter * 16;
23594+ int ret;
23595+
23596+ ret = smsc75xx_write_reg(dev, cfg_base, wuf_cfg);
23597+ if (ret < 0) {
23598+ netdev_warn(dev->net, "Error writing WUF_CFGX\n");
23599+ return ret;
23600+ }
23601+
23602+ ret = smsc75xx_write_reg(dev, mask_base, wuf_mask1);
23603+ if (ret < 0) {
23604+ netdev_warn(dev->net, "Error writing WUF_MASKX\n");
23605+ return ret;
23606+ }
23607+
23608+ ret = smsc75xx_write_reg(dev, mask_base + 4, 0);
23609+ if (ret < 0) {
23610+ netdev_warn(dev->net, "Error writing WUF_MASKX\n");
23611+ return ret;
23612+ }
23613+
23614+ ret = smsc75xx_write_reg(dev, mask_base + 8, 0);
23615+ if (ret < 0) {
23616+ netdev_warn(dev->net, "Error writing WUF_MASKX\n");
23617+ return ret;
23618+ }
23619+
23620+ ret = smsc75xx_write_reg(dev, mask_base + 12, 0);
23621+ if (ret < 0) {
23622+ netdev_warn(dev->net, "Error writing WUF_MASKX\n");
23623+ return ret;
23624+ }
23625+
23626+ return 0;
23627+}
23628+
23629+static int smsc75xx_enter_suspend0(struct usbnet *dev)
23630+{
23631+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23632+ u32 val;
23633+ int ret;
23634+
23635+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
23636+ if (ret < 0) {
23637+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
23638+ return ret;
23639+ }
23640+
23641+ val &= (~(PMT_CTL_SUS_MODE | PMT_CTL_PHY_RST));
23642+ val |= PMT_CTL_SUS_MODE_0 | PMT_CTL_WOL_EN | PMT_CTL_WUPS;
23643+
23644+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
23645+ if (ret < 0) {
23646+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
23647+ return ret;
23648+ }
23649+
23650+ pdata->suspend_flags |= SUSPEND_SUSPEND0;
23651+
23652+ return 0;
23653+}
23654+
23655+static int smsc75xx_enter_suspend1(struct usbnet *dev)
23656+{
23657+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23658+ u32 val;
23659+ int ret;
23660+
23661+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
23662+ if (ret < 0) {
23663+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
23664+ return ret;
23665+ }
23666+
23667+ val &= ~(PMT_CTL_SUS_MODE | PMT_CTL_WUPS | PMT_CTL_PHY_RST);
23668+ val |= PMT_CTL_SUS_MODE_1;
23669+
23670+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
23671+ if (ret < 0) {
23672+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
23673+ return ret;
23674+ }
23675+
23676+ /* clear wol status, enable energy detection */
23677+ val &= ~PMT_CTL_WUPS;
23678+ val |= (PMT_CTL_WUPS_ED | PMT_CTL_ED_EN);
23679+
23680+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
23681+ if (ret < 0) {
23682+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
23683+ return ret;
23684+ }
23685+
23686+ pdata->suspend_flags |= SUSPEND_SUSPEND1;
23687+
23688+ return 0;
23689+}
23690+
23691+static int smsc75xx_enter_suspend2(struct usbnet *dev)
23692+{
23693+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23694+ u32 val;
23695+ int ret;
23696+
23697+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
23698+ if (ret < 0) {
23699+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
23700+ return ret;
23701+ }
23702+
23703+ val &= ~(PMT_CTL_SUS_MODE | PMT_CTL_WUPS | PMT_CTL_PHY_RST);
23704+ val |= PMT_CTL_SUS_MODE_2;
23705+
23706+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
23707+ if (ret < 0) {
23708+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
23709+ return ret;
23710+ }
23711+
23712+ pdata->suspend_flags |= SUSPEND_SUSPEND2;
23713+
23714+ return 0;
23715+}
23716+
23717+static int smsc75xx_enter_suspend3(struct usbnet *dev)
23718+{
23719+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23720+ u32 val;
23721+ int ret;
23722+
23723+ ret = smsc75xx_read_reg_nopm(dev, FCT_RX_CTL, &val);
23724+ if (ret < 0) {
23725+ netdev_warn(dev->net, "Error reading FCT_RX_CTL\n");
23726+ return ret;
23727+ }
23728+
23729+ if (val & FCT_RX_CTL_RXUSED) {
23730+ netdev_dbg(dev->net, "rx fifo not empty in autosuspend\n");
23731+ return -EBUSY;
23732+ }
23733+
23734+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
23735+ if (ret < 0) {
23736+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
23737+ return ret;
23738+ }
23739+
23740+ val &= ~(PMT_CTL_SUS_MODE | PMT_CTL_WUPS | PMT_CTL_PHY_RST);
23741+ val |= PMT_CTL_SUS_MODE_3 | PMT_CTL_RES_CLR_WKP_EN;
23742+
23743+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
23744+ if (ret < 0) {
23745+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
23746+ return ret;
23747+ }
23748+
23749+ /* clear wol status */
23750+ val &= ~PMT_CTL_WUPS;
23751+ val |= PMT_CTL_WUPS_WOL;
23752+
23753+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
23754+ if (ret < 0) {
23755+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
23756+ return ret;
23757+ }
23758+
23759+ pdata->suspend_flags |= SUSPEND_SUSPEND3;
23760+
23761+ return 0;
23762+}
23763+
23764+static int smsc75xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
23765+{
23766+ struct mii_if_info *mii = &dev->mii;
23767+ int ret;
23768+
23769+ netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
23770+
23771+ /* read to clear */
23772+ ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
23773+ if (ret < 0) {
23774+ netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
23775+ return ret;
23776+ }
23777+
23778+ /* enable interrupt source */
23779+ ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
23780+ if (ret < 0) {
23781+ netdev_warn(dev->net, "Error reading PHY_INT_MASK\n");
23782+ return ret;
23783+ }
23784+
23785+ ret |= mask;
23786+
23787+ smsc75xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
23788+
23789+ return 0;
23790+}
23791+
23792+static int smsc75xx_link_ok_nopm(struct usbnet *dev)
23793+{
23794+ struct mii_if_info *mii = &dev->mii;
23795+ int ret;
23796+
23797+ /* first, a dummy read, needed to latch some MII phys */
23798+ ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
23799+ if (ret < 0) {
23800+ netdev_warn(dev->net, "Error reading MII_BMSR\n");
23801+ return ret;
23802+ }
23803+
23804+ ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
23805+ if (ret < 0) {
23806+ netdev_warn(dev->net, "Error reading MII_BMSR\n");
23807+ return ret;
23808+ }
23809+
23810+ return !!(ret & BMSR_LSTATUS);
23811+}
23812+
23813+static int smsc75xx_autosuspend(struct usbnet *dev, u32 link_up)
23814+{
23815+ int ret;
23816+
23817+ if (!netif_running(dev->net)) {
23818+ /* interface is ifconfig down so fully power down hw */
23819+ netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
23820+ return smsc75xx_enter_suspend2(dev);
23821+ }
23822+
23823+ if (!link_up) {
23824+ /* link is down so enter EDPD mode */
23825+ netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
23826+
23827+ /* enable PHY wakeup events for if cable is attached */
23828+ ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
23829+ PHY_INT_MASK_ANEG_COMP);
23830+ if (ret < 0) {
23831+ netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
23832+ return ret;
23833+ }
23834+
23835+ netdev_info(dev->net, "entering SUSPEND1 mode\n");
23836+ return smsc75xx_enter_suspend1(dev);
23837+ }
23838+
23839+ /* enable PHY wakeup events so we remote wakeup if cable is pulled */
23840+ ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
23841+ PHY_INT_MASK_LINK_DOWN);
23842+ if (ret < 0) {
23843+ netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
23844+ return ret;
23845+ }
23846+
23847+ netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
23848+ return smsc75xx_enter_suspend3(dev);
23849+}
23850+
23851+static int smsc75xx_suspend(struct usb_interface *intf, pm_message_t message)
23852+{
23853+ struct usbnet *dev = usb_get_intfdata(intf);
23854+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
23855+ u32 val, link_up;
23856+ int ret;
23857+
23858+ ret = usbnet_suspend(intf, message);
23859+ if (ret < 0) {
23860+ netdev_warn(dev->net, "usbnet_suspend error\n");
23861+ return ret;
23862+ }
23863+
23864+ if (pdata->suspend_flags) {
23865+ netdev_warn(dev->net, "error during last resume\n");
23866+ pdata->suspend_flags = 0;
23867+ }
23868+
23869+ /* determine if link is up using only _nopm functions */
23870+ link_up = smsc75xx_link_ok_nopm(dev);
23871+
23872+ if (message.event == PM_EVENT_AUTO_SUSPEND) {
23873+ ret = smsc75xx_autosuspend(dev, link_up);
23874+ goto done;
23875+ }
23876+
23877+ /* if we get this far we're not autosuspending */
23878+ /* if no wol options set, or if link is down and we're not waking on
23879+ * PHY activity, enter lowest power SUSPEND2 mode
23880+ */
23881+ if (!(pdata->wolopts & SUPPORTED_WAKE) ||
23882+ !(link_up || (pdata->wolopts & WAKE_PHY))) {
23883+ netdev_info(dev->net, "entering SUSPEND2 mode\n");
23884+
23885+ /* disable energy detect (link up) & wake up events */
23886+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
23887+ if (ret < 0) {
23888+ netdev_warn(dev->net, "Error reading WUCSR\n");
23889+ goto done;
23890+ }
23891+
23892+ val &= ~(WUCSR_MPEN | WUCSR_WUEN);
23893+
23894+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
23895+ if (ret < 0) {
23896+ netdev_warn(dev->net, "Error writing WUCSR\n");
23897+ goto done;
23898+ }
23899+
23900+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
23901+ if (ret < 0) {
23902+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
23903+ goto done;
23904+ }
23905+
23906+ val &= ~(PMT_CTL_ED_EN | PMT_CTL_WOL_EN);
23907+
23908+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
23909+ if (ret < 0) {
23910+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
23911+ goto done;
23912+ }
23913+
23914+ ret = smsc75xx_enter_suspend2(dev);
23915+ goto done;
23916+ }
23917+
23918+ if (pdata->wolopts & WAKE_PHY) {
23919+ ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
23920+ (PHY_INT_MASK_ANEG_COMP | PHY_INT_MASK_LINK_DOWN));
23921+ if (ret < 0) {
23922+ netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
23923+ goto done;
23924+ }
23925+
23926+ /* if link is down then configure EDPD and enter SUSPEND1,
23927+ * otherwise enter SUSPEND0 below
23928+ */
23929+ if (!link_up) {
23930+ struct mii_if_info *mii = &dev->mii;
23931+ netdev_info(dev->net, "entering SUSPEND1 mode\n");
23932+
23933+ /* enable energy detect power-down mode */
23934+ ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id,
23935+ PHY_MODE_CTRL_STS);
23936+ if (ret < 0) {
23937+ netdev_warn(dev->net, "Error reading PHY_MODE_CTRL_STS\n");
23938+ goto done;
23939+ }
23940+
23941+ ret |= MODE_CTRL_STS_EDPWRDOWN;
23942+
23943+ smsc75xx_mdio_write_nopm(dev->net, mii->phy_id,
23944+ PHY_MODE_CTRL_STS, ret);
23945+
23946+ /* enter SUSPEND1 mode */
23947+ ret = smsc75xx_enter_suspend1(dev);
23948+ goto done;
23949+ }
23950+ }
23951+
23952+ if (pdata->wolopts & (WAKE_MCAST | WAKE_ARP)) {
23953+ int i, filter = 0;
23954+
23955+ /* disable all filters */
23956+ for (i = 0; i < WUF_NUM; i++) {
23957+ ret = smsc75xx_write_reg_nopm(dev, WUF_CFGX + i * 4, 0);
23958+ if (ret < 0) {
23959+ netdev_warn(dev->net, "Error writing WUF_CFGX\n");
23960+ goto done;
23961+ }
23962+ }
23963+
23964+ if (pdata->wolopts & WAKE_MCAST) {
23965+ const u8 mcast[] = {0x01, 0x00, 0x5E};
23966+ netdev_info(dev->net, "enabling multicast detection\n");
23967+
23968+ val = WUF_CFGX_EN | WUF_CFGX_ATYPE_MULTICAST
23969+ | smsc_crc(mcast, 3);
23970+ ret = smsc75xx_write_wuff(dev, filter++, val, 0x0007);
23971+ if (ret < 0) {
23972+ netdev_warn(dev->net, "Error writing wakeup filter\n");
23973+ goto done;
23974+ }
23975+ }
23976+
23977+ if (pdata->wolopts & WAKE_ARP) {
23978+ const u8 arp[] = {0x08, 0x06};
23979+ netdev_info(dev->net, "enabling ARP detection\n");
23980+
23981+ val = WUF_CFGX_EN | WUF_CFGX_ATYPE_ALL | (0x0C << 16)
23982+ | smsc_crc(arp, 2);
23983+ ret = smsc75xx_write_wuff(dev, filter++, val, 0x0003);
23984+ if (ret < 0) {
23985+ netdev_warn(dev->net, "Error writing wakeup filter\n");
23986+ goto done;
23987+ }
23988+ }
23989+
23990+ /* clear any pending pattern match packet status */
23991+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
23992+ if (ret < 0) {
23993+ netdev_warn(dev->net, "Error reading WUCSR\n");
23994+ goto done;
23995+ }
23996+
23997+ val |= WUCSR_WUFR;
23998+
23999+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24000+ if (ret < 0) {
24001+ netdev_warn(dev->net, "Error writing WUCSR\n");
24002+ goto done;
24003+ }
24004+
24005+ netdev_info(dev->net, "enabling packet match detection\n");
24006+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
24007+ if (ret < 0) {
24008+ netdev_warn(dev->net, "Error reading WUCSR\n");
24009+ goto done;
24010+ }
24011+
24012+ val |= WUCSR_WUEN;
24013+
24014+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24015+ if (ret < 0) {
24016+ netdev_warn(dev->net, "Error writing WUCSR\n");
24017+ goto done;
24018+ }
24019+ } else {
24020+ netdev_info(dev->net, "disabling packet match detection\n");
24021+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
24022+ if (ret < 0) {
24023+ netdev_warn(dev->net, "Error reading WUCSR\n");
24024+ goto done;
24025+ }
24026+
24027+ val &= ~WUCSR_WUEN;
24028+
24029+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24030+ if (ret < 0) {
24031+ netdev_warn(dev->net, "Error writing WUCSR\n");
24032+ goto done;
24033+ }
24034+ }
24035+
24036+ /* disable magic, bcast & unicast wakeup sources */
24037+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
24038+ if (ret < 0) {
24039+ netdev_warn(dev->net, "Error reading WUCSR\n");
24040+ goto done;
24041+ }
24042+
24043+ val &= ~(WUCSR_MPEN | WUCSR_BCST_EN | WUCSR_PFDA_EN);
24044+
24045+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24046+ if (ret < 0) {
24047+ netdev_warn(dev->net, "Error writing WUCSR\n");
24048+ goto done;
24049+ }
24050+
24051+ if (pdata->wolopts & WAKE_PHY) {
24052+ netdev_info(dev->net, "enabling PHY wakeup\n");
24053+
24054+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
24055+ if (ret < 0) {
24056+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
24057+ goto done;
24058+ }
24059+
24060+ /* clear wol status, enable energy detection */
24061+ val &= ~PMT_CTL_WUPS;
24062+ val |= (PMT_CTL_WUPS_ED | PMT_CTL_ED_EN);
24063+
24064+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
24065+ if (ret < 0) {
24066+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
24067+ goto done;
24068+ }
24069+ }
24070+
24071+ if (pdata->wolopts & WAKE_MAGIC) {
24072+ netdev_info(dev->net, "enabling magic packet wakeup\n");
24073+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
24074+ if (ret < 0) {
24075+ netdev_warn(dev->net, "Error reading WUCSR\n");
24076+ goto done;
24077+ }
24078+
24079+ /* clear any pending magic packet status */
24080+ val |= WUCSR_MPR | WUCSR_MPEN;
24081+
24082+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24083+ if (ret < 0) {
24084+ netdev_warn(dev->net, "Error writing WUCSR\n");
24085+ goto done;
24086+ }
24087+ }
24088+
24089+ if (pdata->wolopts & WAKE_BCAST) {
24090+ netdev_info(dev->net, "enabling broadcast detection\n");
24091+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
24092+ if (ret < 0) {
24093+ netdev_warn(dev->net, "Error reading WUCSR\n");
24094+ goto done;
24095+ }
24096+
24097+ val |= WUCSR_BCAST_FR | WUCSR_BCST_EN;
24098+
24099+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24100+ if (ret < 0) {
24101+ netdev_warn(dev->net, "Error writing WUCSR\n");
24102+ goto done;
24103+ }
24104+ }
24105+
24106+ if (pdata->wolopts & WAKE_UCAST) {
24107+ netdev_info(dev->net, "enabling unicast detection\n");
24108+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
24109+ if (ret < 0) {
24110+ netdev_warn(dev->net, "Error reading WUCSR\n");
24111+ goto done;
24112+ }
24113+
24114+ val |= WUCSR_WUFR | WUCSR_PFDA_EN;
24115+
24116+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24117+ if (ret < 0) {
24118+ netdev_warn(dev->net, "Error writing WUCSR\n");
24119+ goto done;
24120+ }
24121+ }
24122+
24123+ /* enable receiver to enable frame reception */
24124+ ret = smsc75xx_read_reg_nopm(dev, MAC_RX, &val);
24125+ if (ret < 0) {
24126+ netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
24127+ goto done;
24128+ }
24129+
24130+ val |= MAC_RX_RXEN;
24131+
24132+ ret = smsc75xx_write_reg_nopm(dev, MAC_RX, val);
24133+ if (ret < 0) {
24134+ netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
24135+ goto done;
24136+ }
24137+
24138+ /* some wol options are enabled, so enter SUSPEND0 */
24139+ netdev_info(dev->net, "entering SUSPEND0 mode\n");
24140+ ret = smsc75xx_enter_suspend0(dev);
24141+
24142+done:
24143+ /*
24144+ * TODO: resume() might need to handle the suspend failure
24145+ * in system sleep
24146+ */
24147+ if (ret && PMSG_IS_AUTO(message))
24148+ usbnet_resume(intf);
24149+ return ret;
24150+}
24151+
24152+static int smsc75xx_resume(struct usb_interface *intf)
24153+{
24154+ struct usbnet *dev = usb_get_intfdata(intf);
24155+ struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
24156+ u8 suspend_flags = pdata->suspend_flags;
24157+ int ret;
24158+ u32 val;
24159+
24160+ netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
24161+
24162+ /* do this first to ensure it's cleared even in error case */
24163+ pdata->suspend_flags = 0;
24164+
24165+ if (suspend_flags & SUSPEND_ALLMODES) {
24166+ /* Disable wakeup sources */
24167+ ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
24168+ if (ret < 0) {
24169+ netdev_warn(dev->net, "Error reading WUCSR\n");
24170+ return ret;
24171+ }
24172+
24173+ val &= ~(WUCSR_WUEN | WUCSR_MPEN | WUCSR_PFDA_EN
24174+ | WUCSR_BCST_EN);
24175+
24176+ ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
24177+ if (ret < 0) {
24178+ netdev_warn(dev->net, "Error writing WUCSR\n");
24179+ return ret;
24180+ }
24181+
24182+ /* clear wake-up status */
24183+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
24184+ if (ret < 0) {
24185+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
24186+ return ret;
24187+ }
24188+
24189+ val &= ~PMT_CTL_WOL_EN;
24190+ val |= PMT_CTL_WUPS;
24191+
24192+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
24193+ if (ret < 0) {
24194+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
24195+ return ret;
24196+ }
24197+ }
24198+
24199+ if (suspend_flags & SUSPEND_SUSPEND2) {
24200+ netdev_info(dev->net, "resuming from SUSPEND2\n");
24201+
24202+ ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
24203+ if (ret < 0) {
24204+ netdev_warn(dev->net, "Error reading PMT_CTL\n");
24205+ return ret;
24206+ }
24207+
24208+ val |= PMT_CTL_PHY_PWRUP;
24209+
24210+ ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
24211+ if (ret < 0) {
24212+ netdev_warn(dev->net, "Error writing PMT_CTL\n");
24213+ return ret;
24214+ }
24215+ }
24216+
24217+ ret = smsc75xx_wait_ready(dev, 1);
24218+ if (ret < 0) {
24219+ netdev_warn(dev->net, "device not ready in smsc75xx_resume\n");
24220+ return ret;
24221+ }
24222+
24223+ return usbnet_resume(intf);
24224+}
24225+
24226+static void smsc75xx_rx_csum_offload(struct usbnet *dev, struct sk_buff *skb,
24227+ u32 rx_cmd_a, u32 rx_cmd_b)
24228+{
24229+ if (!(dev->net->features & NETIF_F_RXCSUM) ||
24230+ unlikely(rx_cmd_a & RX_CMD_A_LCSM)) {
24231+ skb->ip_summed = CHECKSUM_NONE;
24232+ } else {
24233+ skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT));
24234+ skb->ip_summed = CHECKSUM_COMPLETE;
24235+ }
24236+}
24237+
24238+static int smsc75xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
24239+{
24240+ /* This check is no longer done by usbnet */
24241+ if (skb->len < dev->net->hard_header_len)
24242+ return 0;
24243+
24244+ while (skb->len > 0) {
24245+ u32 rx_cmd_a, rx_cmd_b, align_count, size;
24246+ struct sk_buff *ax_skb;
24247+ unsigned char *packet;
24248+
24249+ memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
24250+ le32_to_cpus(&rx_cmd_a);
24251+ skb_pull(skb, 4);
24252+
24253+ memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
24254+ le32_to_cpus(&rx_cmd_b);
24255+ skb_pull(skb, 4 + RXW_PADDING);
24256+
24257+ packet = skb->data;
24258+
24259+ /* get the packet length */
24260+ size = (rx_cmd_a & RX_CMD_A_LEN) - RXW_PADDING;
24261+ align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
24262+
24263+ if (unlikely(rx_cmd_a & RX_CMD_A_RED)) {
24264+ netif_dbg(dev, rx_err, dev->net,
24265+ "Error rx_cmd_a=0x%08x\n", rx_cmd_a);
24266+ dev->net->stats.rx_errors++;
24267+ dev->net->stats.rx_dropped++;
24268+
24269+ if (rx_cmd_a & RX_CMD_A_FCS)
24270+ dev->net->stats.rx_crc_errors++;
24271+ else if (rx_cmd_a & (RX_CMD_A_LONG | RX_CMD_A_RUNT))
24272+ dev->net->stats.rx_frame_errors++;
24273+ } else {
24274+ /* MAX_SINGLE_PACKET_SIZE + 4(CRC) + 2(COE) + 4(Vlan) */
24275+ if (unlikely(size > (MAX_SINGLE_PACKET_SIZE + ETH_HLEN + 12))) {
24276+ netif_dbg(dev, rx_err, dev->net,
24277+ "size err rx_cmd_a=0x%08x\n",
24278+ rx_cmd_a);
24279+ return 0;
24280+ }
24281+
24282+ /* last frame in this batch */
24283+ if (skb->len == size) {
24284+ smsc75xx_rx_csum_offload(dev, skb, rx_cmd_a,
24285+ rx_cmd_b);
24286+
24287+ skb_trim(skb, skb->len - 4); /* remove fcs */
24288+ skb->truesize = size + sizeof(struct sk_buff);
24289+
24290+ return 1;
24291+ }
24292+
24293+ ax_skb = skb_clone(skb, GFP_ATOMIC);
24294+ if (unlikely(!ax_skb)) {
24295+ netdev_warn(dev->net, "Error allocating skb\n");
24296+ return 0;
24297+ }
24298+
24299+ ax_skb->len = size;
24300+ ax_skb->data = packet;
24301+ skb_set_tail_pointer(ax_skb, size);
24302+
24303+ smsc75xx_rx_csum_offload(dev, ax_skb, rx_cmd_a,
24304+ rx_cmd_b);
24305+
24306+ skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
24307+ ax_skb->truesize = size + sizeof(struct sk_buff);
24308+
24309+ usbnet_skb_return(dev, ax_skb);
24310+ }
24311+
24312+ skb_pull(skb, size);
24313+
24314+ /* padding bytes before the next frame starts */
24315+ if (skb->len)
24316+ skb_pull(skb, align_count);
24317+ }
24318+
24319+ if (unlikely(skb->len < 0)) {
24320+ netdev_warn(dev->net, "invalid rx length<0 %d\n", skb->len);
24321+ return 0;
24322+ }
24323+
24324+ return 1;
24325+}
24326+
24327+static struct sk_buff *smsc75xx_tx_fixup(struct usbnet *dev,
24328+ struct sk_buff *skb, gfp_t flags)
24329+{
24330+ u32 tx_cmd_a, tx_cmd_b;
24331+
24332+ if (skb_headroom(skb) < SMSC75XX_TX_OVERHEAD) {
24333+ struct sk_buff *skb2 =
24334+ skb_copy_expand(skb, SMSC75XX_TX_OVERHEAD, 0, flags);
24335+ dev_kfree_skb_any(skb);
24336+ skb = skb2;
24337+ if (!skb)
24338+ return NULL;
24339+ }
24340+
24341+ tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN) | TX_CMD_A_FCS;
24342+
24343+ if (skb->ip_summed == CHECKSUM_PARTIAL)
24344+ tx_cmd_a |= TX_CMD_A_IPE | TX_CMD_A_TPE;
24345+
24346+ if (skb_is_gso(skb)) {
24347+ u16 mss = max(skb_shinfo(skb)->gso_size, TX_MSS_MIN);
24348+ tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT) & TX_CMD_B_MSS;
24349+
24350+ tx_cmd_a |= TX_CMD_A_LSO;
24351+ } else {
24352+ tx_cmd_b = 0;
24353+ }
24354+
24355+ skb_push(skb, 4);
24356+ cpu_to_le32s(&tx_cmd_b);
24357+ memcpy(skb->data, &tx_cmd_b, 4);
24358+
24359+ skb_push(skb, 4);
24360+ cpu_to_le32s(&tx_cmd_a);
24361+ memcpy(skb->data, &tx_cmd_a, 4);
24362+
24363+ return skb;
24364+}
24365+
24366+static int smsc75xx_manage_power(struct usbnet *dev, int on)
24367+{
24368+ dev->intf->needs_remote_wakeup = on;
24369+ return 0;
24370+}
24371+
24372+static const struct driver_info smsc75xx_info = {
24373+ .description = "smsc75xx USB 2.0 Gigabit Ethernet",
24374+ .bind = smsc75xx_bind,
24375+ .unbind = smsc75xx_unbind,
24376+ .link_reset = smsc75xx_link_reset,
24377+ .reset = smsc75xx_reset,
24378+ .rx_fixup = smsc75xx_rx_fixup,
24379+ .tx_fixup = smsc75xx_tx_fixup,
24380+ .status = smsc75xx_status,
24381+ .manage_power = smsc75xx_manage_power,
24382+ .flags = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
24383+};
24384+
24385+static const struct usb_device_id products[] = {
24386+ {
24387+ /* SMSC7500 USB Gigabit Ethernet Device */
24388+ USB_DEVICE(USB_VENDOR_ID_SMSC, USB_PRODUCT_ID_LAN7500),
24389+ .driver_info = (unsigned long) &smsc75xx_info,
24390+ },
24391+ {
24392+ /* SMSC7500 USB Gigabit Ethernet Device */
24393+ USB_DEVICE(USB_VENDOR_ID_SMSC, USB_PRODUCT_ID_LAN7505),
24394+ .driver_info = (unsigned long) &smsc75xx_info,
24395+ },
24396+ { }, /* END */
24397+};
24398+MODULE_DEVICE_TABLE(usb, products);
24399+
24400+static struct usb_driver smsc75xx_driver = {
24401+ .name = SMSC_CHIPNAME,
24402+ .id_table = products,
24403+ .probe = usbnet_probe,
24404+ .suspend = smsc75xx_suspend,
24405+ .resume = smsc75xx_resume,
24406+ .reset_resume = smsc75xx_resume,
24407+ .disconnect = usbnet_disconnect,
24408+ .disable_hub_initiated_lpm = 1,
24409+ .supports_autosuspend = 1,
24410+};
24411+
24412+module_usb_driver(smsc75xx_driver);
24413+
24414+MODULE_AUTHOR("Nancy Lin");
24415+MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
24416+MODULE_DESCRIPTION("SMSC75XX USB 2.0 Gigabit Ethernet Devices");
24417+MODULE_LICENSE("GPL");
24418diff -Naur backports-3.18.1-1.org/drivers/net/usb/smsc75xx.h backports-3.18.1-1/drivers/net/usb/smsc75xx.h
24419--- backports-3.18.1-1.org/drivers/net/usb/smsc75xx.h 1970-01-01 01:00:00.000000000 +0100
24420+++ backports-3.18.1-1/drivers/net/usb/smsc75xx.h 2014-12-16 18:39:45.000000000 +0100
24421@@ -0,0 +1,421 @@
24422+ /***************************************************************************
24423+ *
24424+ * Copyright (C) 2007-2010 SMSC
24425+ *
24426+ * This program is free software; you can redistribute it and/or
24427+ * modify it under the terms of the GNU General Public License
24428+ * as published by the Free Software Foundation; either version 2
24429+ * of the License, or (at your option) any later version.
24430+ *
24431+ * This program is distributed in the hope that it will be useful,
24432+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
24433+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24434+ * GNU General Public License for more details.
24435+ *
24436+ * You should have received a copy of the GNU General Public License
24437+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
24438+ *
24439+ *****************************************************************************/
24440+
24441+#ifndef _SMSC75XX_H
24442+#define _SMSC75XX_H
24443+
24444+/* Tx command words */
24445+#define TX_CMD_A_LSO (0x08000000)
24446+#define TX_CMD_A_IPE (0x04000000)
24447+#define TX_CMD_A_TPE (0x02000000)
24448+#define TX_CMD_A_IVTG (0x01000000)
24449+#define TX_CMD_A_RVTG (0x00800000)
24450+#define TX_CMD_A_FCS (0x00400000)
24451+#define TX_CMD_A_LEN (0x000FFFFF)
24452+
24453+#define TX_CMD_B_MSS (0x3FFF0000)
24454+#define TX_CMD_B_MSS_SHIFT (16)
24455+#define TX_MSS_MIN ((u16)8)
24456+#define TX_CMD_B_VTAG (0x0000FFFF)
24457+
24458+/* Rx command words */
24459+#define RX_CMD_A_ICE (0x80000000)
24460+#define RX_CMD_A_TCE (0x40000000)
24461+#define RX_CMD_A_IPV (0x20000000)
24462+#define RX_CMD_A_PID (0x18000000)
24463+#define RX_CMD_A_PID_NIP (0x00000000)
24464+#define RX_CMD_A_PID_TCP (0x08000000)
24465+#define RX_CMD_A_PID_UDP (0x10000000)
24466+#define RX_CMD_A_PID_PP (0x18000000)
24467+#define RX_CMD_A_PFF (0x04000000)
24468+#define RX_CMD_A_BAM (0x02000000)
24469+#define RX_CMD_A_MAM (0x01000000)
24470+#define RX_CMD_A_FVTG (0x00800000)
24471+#define RX_CMD_A_RED (0x00400000)
24472+#define RX_CMD_A_RWT (0x00200000)
24473+#define RX_CMD_A_RUNT (0x00100000)
24474+#define RX_CMD_A_LONG (0x00080000)
24475+#define RX_CMD_A_RXE (0x00040000)
24476+#define RX_CMD_A_DRB (0x00020000)
24477+#define RX_CMD_A_FCS (0x00010000)
24478+#define RX_CMD_A_UAM (0x00008000)
24479+#define RX_CMD_A_LCSM (0x00004000)
24480+#define RX_CMD_A_LEN (0x00003FFF)
24481+
24482+#define RX_CMD_B_CSUM (0xFFFF0000)
24483+#define RX_CMD_B_CSUM_SHIFT (16)
24484+#define RX_CMD_B_VTAG (0x0000FFFF)
24485+
24486+/* SCSRs */
24487+#define ID_REV (0x0000)
24488+
24489+#define FPGA_REV (0x0004)
24490+
24491+#define BOND_CTL (0x0008)
24492+
24493+#define INT_STS (0x000C)
24494+#define INT_STS_RDFO_INT (0x00400000)
24495+#define INT_STS_TXE_INT (0x00200000)
24496+#define INT_STS_MACRTO_INT (0x00100000)
24497+#define INT_STS_TX_DIS_INT (0x00080000)
24498+#define INT_STS_RX_DIS_INT (0x00040000)
24499+#define INT_STS_PHY_INT_ (0x00020000)
24500+#define INT_STS_MAC_ERR_INT (0x00008000)
24501+#define INT_STS_TDFU (0x00004000)
24502+#define INT_STS_TDFO (0x00002000)
24503+#define INT_STS_GPIOS (0x00000FFF)
24504+#define INT_STS_CLEAR_ALL (0xFFFFFFFF)
24505+
24506+#define HW_CFG (0x0010)
24507+#define HW_CFG_SMDET_STS (0x00008000)
24508+#define HW_CFG_SMDET_EN (0x00004000)
24509+#define HW_CFG_EEM (0x00002000)
24510+#define HW_CFG_RST_PROTECT (0x00001000)
24511+#define HW_CFG_PORT_SWAP (0x00000800)
24512+#define HW_CFG_PHY_BOOST (0x00000600)
24513+#define HW_CFG_PHY_BOOST_NORMAL (0x00000000)
24514+#define HW_CFG_PHY_BOOST_4 (0x00002000)
24515+#define HW_CFG_PHY_BOOST_8 (0x00004000)
24516+#define HW_CFG_PHY_BOOST_12 (0x00006000)
24517+#define HW_CFG_LEDB (0x00000100)
24518+#define HW_CFG_BIR (0x00000080)
24519+#define HW_CFG_SBP (0x00000040)
24520+#define HW_CFG_IME (0x00000020)
24521+#define HW_CFG_MEF (0x00000010)
24522+#define HW_CFG_ETC (0x00000008)
24523+#define HW_CFG_BCE (0x00000004)
24524+#define HW_CFG_LRST (0x00000002)
24525+#define HW_CFG_SRST (0x00000001)
24526+
24527+#define PMT_CTL (0x0014)
24528+#define PMT_CTL_PHY_PWRUP (0x00000400)
24529+#define PMT_CTL_RES_CLR_WKP_EN (0x00000100)
24530+#define PMT_CTL_DEV_RDY (0x00000080)
24531+#define PMT_CTL_SUS_MODE (0x00000060)
24532+#define PMT_CTL_SUS_MODE_0 (0x00000000)
24533+#define PMT_CTL_SUS_MODE_1 (0x00000020)
24534+#define PMT_CTL_SUS_MODE_2 (0x00000040)
24535+#define PMT_CTL_SUS_MODE_3 (0x00000060)
24536+#define PMT_CTL_PHY_RST (0x00000010)
24537+#define PMT_CTL_WOL_EN (0x00000008)
24538+#define PMT_CTL_ED_EN (0x00000004)
24539+#define PMT_CTL_WUPS (0x00000003)
24540+#define PMT_CTL_WUPS_NO (0x00000000)
24541+#define PMT_CTL_WUPS_ED (0x00000001)
24542+#define PMT_CTL_WUPS_WOL (0x00000002)
24543+#define PMT_CTL_WUPS_MULTI (0x00000003)
24544+
24545+#define LED_GPIO_CFG (0x0018)
24546+#define LED_GPIO_CFG_LED2_FUN_SEL (0x80000000)
24547+#define LED_GPIO_CFG_LED10_FUN_SEL (0x40000000)
24548+#define LED_GPIO_CFG_LEDGPIO_EN (0x0000F000)
24549+#define LED_GPIO_CFG_LEDGPIO_EN_0 (0x00001000)
24550+#define LED_GPIO_CFG_LEDGPIO_EN_1 (0x00002000)
24551+#define LED_GPIO_CFG_LEDGPIO_EN_2 (0x00004000)
24552+#define LED_GPIO_CFG_LEDGPIO_EN_3 (0x00008000)
24553+#define LED_GPIO_CFG_GPBUF (0x00000F00)
24554+#define LED_GPIO_CFG_GPBUF_0 (0x00000100)
24555+#define LED_GPIO_CFG_GPBUF_1 (0x00000200)
24556+#define LED_GPIO_CFG_GPBUF_2 (0x00000400)
24557+#define LED_GPIO_CFG_GPBUF_3 (0x00000800)
24558+#define LED_GPIO_CFG_GPDIR (0x000000F0)
24559+#define LED_GPIO_CFG_GPDIR_0 (0x00000010)
24560+#define LED_GPIO_CFG_GPDIR_1 (0x00000020)
24561+#define LED_GPIO_CFG_GPDIR_2 (0x00000040)
24562+#define LED_GPIO_CFG_GPDIR_3 (0x00000080)
24563+#define LED_GPIO_CFG_GPDATA (0x0000000F)
24564+#define LED_GPIO_CFG_GPDATA_0 (0x00000001)
24565+#define LED_GPIO_CFG_GPDATA_1 (0x00000002)
24566+#define LED_GPIO_CFG_GPDATA_2 (0x00000004)
24567+#define LED_GPIO_CFG_GPDATA_3 (0x00000008)
24568+
24569+#define GPIO_CFG (0x001C)
24570+#define GPIO_CFG_SHIFT (24)
24571+#define GPIO_CFG_GPEN (0xFF000000)
24572+#define GPIO_CFG_GPBUF (0x00FF0000)
24573+#define GPIO_CFG_GPDIR (0x0000FF00)
24574+#define GPIO_CFG_GPDATA (0x000000FF)
24575+
24576+#define GPIO_WAKE (0x0020)
24577+#define GPIO_WAKE_PHY_LINKUP_EN (0x80000000)
24578+#define GPIO_WAKE_POL (0x0FFF0000)
24579+#define GPIO_WAKE_POL_SHIFT (16)
24580+#define GPIO_WAKE_WK (0x00000FFF)
24581+
24582+#define DP_SEL (0x0024)
24583+#define DP_SEL_DPRDY (0x80000000)
24584+#define DP_SEL_RSEL (0x0000000F)
24585+#define DP_SEL_URX (0x00000000)
24586+#define DP_SEL_VHF (0x00000001)
24587+#define DP_SEL_VHF_HASH_LEN (16)
24588+#define DP_SEL_VHF_VLAN_LEN (128)
24589+#define DP_SEL_LSO_HEAD (0x00000002)
24590+#define DP_SEL_FCT_RX (0x00000003)
24591+#define DP_SEL_FCT_TX (0x00000004)
24592+#define DP_SEL_DESCRIPTOR (0x00000005)
24593+#define DP_SEL_WOL (0x00000006)
24594+
24595+#define DP_CMD (0x0028)
24596+#define DP_CMD_WRITE (0x01)
24597+#define DP_CMD_READ (0x00)
24598+
24599+#define DP_ADDR (0x002C)
24600+
24601+#define DP_DATA (0x0030)
24602+
24603+#define BURST_CAP (0x0034)
24604+#define BURST_CAP_MASK (0x0000000F)
24605+
24606+#define INT_EP_CTL (0x0038)
24607+#define INT_EP_CTL_INTEP_ON (0x80000000)
24608+#define INT_EP_CTL_RDFO_EN (0x00400000)
24609+#define INT_EP_CTL_TXE_EN (0x00200000)
24610+#define INT_EP_CTL_MACROTO_EN (0x00100000)
24611+#define INT_EP_CTL_TX_DIS_EN (0x00080000)
24612+#define INT_EP_CTL_RX_DIS_EN (0x00040000)
24613+#define INT_EP_CTL_PHY_EN_ (0x00020000)
24614+#define INT_EP_CTL_MAC_ERR_EN (0x00008000)
24615+#define INT_EP_CTL_TDFU_EN (0x00004000)
24616+#define INT_EP_CTL_TDFO_EN (0x00002000)
24617+#define INT_EP_CTL_RX_FIFO_EN (0x00001000)
24618+#define INT_EP_CTL_GPIOX_EN (0x00000FFF)
24619+
24620+#define BULK_IN_DLY (0x003C)
24621+#define BULK_IN_DLY_MASK (0xFFFF)
24622+
24623+#define E2P_CMD (0x0040)
24624+#define E2P_CMD_BUSY (0x80000000)
24625+#define E2P_CMD_MASK (0x70000000)
24626+#define E2P_CMD_READ (0x00000000)
24627+#define E2P_CMD_EWDS (0x10000000)
24628+#define E2P_CMD_EWEN (0x20000000)
24629+#define E2P_CMD_WRITE (0x30000000)
24630+#define E2P_CMD_WRAL (0x40000000)
24631+#define E2P_CMD_ERASE (0x50000000)
24632+#define E2P_CMD_ERAL (0x60000000)
24633+#define E2P_CMD_RELOAD (0x70000000)
24634+#define E2P_CMD_TIMEOUT (0x00000400)
24635+#define E2P_CMD_LOADED (0x00000200)
24636+#define E2P_CMD_ADDR (0x000001FF)
24637+
24638+#define MAX_EEPROM_SIZE (512)
24639+
24640+#define E2P_DATA (0x0044)
24641+#define E2P_DATA_MASK_ (0x000000FF)
24642+
24643+#define RFE_CTL (0x0060)
24644+#define RFE_CTL_TCPUDP_CKM (0x00001000)
24645+#define RFE_CTL_IP_CKM (0x00000800)
24646+#define RFE_CTL_AB (0x00000400)
24647+#define RFE_CTL_AM (0x00000200)
24648+#define RFE_CTL_AU (0x00000100)
24649+#define RFE_CTL_VS (0x00000080)
24650+#define RFE_CTL_UF (0x00000040)
24651+#define RFE_CTL_VF (0x00000020)
24652+#define RFE_CTL_SPF (0x00000010)
24653+#define RFE_CTL_MHF (0x00000008)
24654+#define RFE_CTL_DHF (0x00000004)
24655+#define RFE_CTL_DPF (0x00000002)
24656+#define RFE_CTL_RST_RF (0x00000001)
24657+
24658+#define VLAN_TYPE (0x0064)
24659+#define VLAN_TYPE_MASK (0x0000FFFF)
24660+
24661+#define FCT_RX_CTL (0x0090)
24662+#define FCT_RX_CTL_EN (0x80000000)
24663+#define FCT_RX_CTL_RST (0x40000000)
24664+#define FCT_RX_CTL_SBF (0x02000000)
24665+#define FCT_RX_CTL_OVERFLOW (0x01000000)
24666+#define FCT_RX_CTL_FRM_DROP (0x00800000)
24667+#define FCT_RX_CTL_RX_NOT_EMPTY (0x00400000)
24668+#define FCT_RX_CTL_RX_EMPTY (0x00200000)
24669+#define FCT_RX_CTL_RX_DISABLED (0x00100000)
24670+#define FCT_RX_CTL_RXUSED (0x0000FFFF)
24671+
24672+#define FCT_TX_CTL (0x0094)
24673+#define FCT_TX_CTL_EN (0x80000000)
24674+#define FCT_TX_CTL_RST (0x40000000)
24675+#define FCT_TX_CTL_TX_NOT_EMPTY (0x00400000)
24676+#define FCT_TX_CTL_TX_EMPTY (0x00200000)
24677+#define FCT_TX_CTL_TX_DISABLED (0x00100000)
24678+#define FCT_TX_CTL_TXUSED (0x0000FFFF)
24679+
24680+#define FCT_RX_FIFO_END (0x0098)
24681+#define FCT_RX_FIFO_END_MASK (0x0000007F)
24682+
24683+#define FCT_TX_FIFO_END (0x009C)
24684+#define FCT_TX_FIFO_END_MASK (0x0000003F)
24685+
24686+#define FCT_FLOW (0x00A0)
24687+#define FCT_FLOW_THRESHOLD_OFF (0x00007F00)
24688+#define FCT_FLOW_THRESHOLD_OFF_SHIFT (8)
24689+#define FCT_FLOW_THRESHOLD_ON (0x0000007F)
24690+
24691+/* MAC CSRs */
24692+#define MAC_CR (0x100)
24693+#define MAC_CR_ADP (0x00002000)
24694+#define MAC_CR_ADD (0x00001000)
24695+#define MAC_CR_ASD (0x00000800)
24696+#define MAC_CR_INT_LOOP (0x00000400)
24697+#define MAC_CR_BOLMT (0x000000C0)
24698+#define MAC_CR_FDPX (0x00000008)
24699+#define MAC_CR_CFG (0x00000006)
24700+#define MAC_CR_CFG_10 (0x00000000)
24701+#define MAC_CR_CFG_100 (0x00000002)
24702+#define MAC_CR_CFG_1000 (0x00000004)
24703+#define MAC_CR_RST (0x00000001)
24704+
24705+#define MAC_RX (0x104)
24706+#define MAC_RX_MAX_SIZE (0x3FFF0000)
24707+#define MAC_RX_MAX_SIZE_SHIFT (16)
24708+#define MAC_RX_FCS_STRIP (0x00000010)
24709+#define MAC_RX_FSE (0x00000004)
24710+#define MAC_RX_RXD (0x00000002)
24711+#define MAC_RX_RXEN (0x00000001)
24712+
24713+#define MAC_TX (0x108)
24714+#define MAC_TX_BFCS (0x00000004)
24715+#define MAC_TX_TXD (0x00000002)
24716+#define MAC_TX_TXEN (0x00000001)
24717+
24718+#define FLOW (0x10C)
24719+#define FLOW_FORCE_FC (0x80000000)
24720+#define FLOW_TX_FCEN (0x40000000)
24721+#define FLOW_RX_FCEN (0x20000000)
24722+#define FLOW_FPF (0x10000000)
24723+#define FLOW_PAUSE_TIME (0x0000FFFF)
24724+
24725+#define RAND_SEED (0x110)
24726+#define RAND_SEED_MASK (0x0000FFFF)
24727+
24728+#define ERR_STS (0x114)
24729+#define ERR_STS_FCS_ERR (0x00000100)
24730+#define ERR_STS_LFRM_ERR (0x00000080)
24731+#define ERR_STS_RUNT_ERR (0x00000040)
24732+#define ERR_STS_COLLISION_ERR (0x00000010)
24733+#define ERR_STS_ALIGN_ERR (0x00000008)
24734+#define ERR_STS_URUN_ERR (0x00000004)
24735+
24736+#define RX_ADDRH (0x118)
24737+#define RX_ADDRH_MASK (0x0000FFFF)
24738+
24739+#define RX_ADDRL (0x11C)
24740+
24741+#define MII_ACCESS (0x120)
24742+#define MII_ACCESS_PHY_ADDR (0x0000F800)
24743+#define MII_ACCESS_PHY_ADDR_SHIFT (11)
24744+#define MII_ACCESS_REG_ADDR (0x000007C0)
24745+#define MII_ACCESS_REG_ADDR_SHIFT (6)
24746+#define MII_ACCESS_READ (0x00000000)
24747+#define MII_ACCESS_WRITE (0x00000002)
24748+#define MII_ACCESS_BUSY (0x00000001)
24749+
24750+#define MII_DATA (0x124)
24751+#define MII_DATA_MASK (0x0000FFFF)
24752+
24753+#define WUCSR (0x140)
24754+#define WUCSR_PFDA_FR (0x00000080)
24755+#define WUCSR_WUFR (0x00000040)
24756+#define WUCSR_MPR (0x00000020)
24757+#define WUCSR_BCAST_FR (0x00000010)
24758+#define WUCSR_PFDA_EN (0x00000008)
24759+#define WUCSR_WUEN (0x00000004)
24760+#define WUCSR_MPEN (0x00000002)
24761+#define WUCSR_BCST_EN (0x00000001)
24762+
24763+#define WUF_CFGX (0x144)
24764+#define WUF_CFGX_EN (0x80000000)
24765+#define WUF_CFGX_ATYPE (0x03000000)
24766+#define WUF_CFGX_ATYPE_UNICAST (0x00000000)
24767+#define WUF_CFGX_ATYPE_MULTICAST (0x02000000)
24768+#define WUF_CFGX_ATYPE_ALL (0x03000000)
24769+#define WUF_CFGX_PATTERN_OFFSET (0x007F0000)
24770+#define WUF_CFGX_PATTERN_OFFSET_SHIFT (16)
24771+#define WUF_CFGX_CRC16 (0x0000FFFF)
24772+#define WUF_NUM (8)
24773+
24774+#define WUF_MASKX (0x170)
24775+#define WUF_MASKX_AVALID (0x80000000)
24776+#define WUF_MASKX_ATYPE (0x40000000)
24777+
24778+#define ADDR_FILTX (0x300)
24779+#define ADDR_FILTX_FB_VALID (0x80000000)
24780+#define ADDR_FILTX_FB_TYPE (0x40000000)
24781+#define ADDR_FILTX_FB_ADDRHI (0x0000FFFF)
24782+#define ADDR_FILTX_SB_ADDRLO (0xFFFFFFFF)
24783+
24784+#define WUCSR2 (0x500)
24785+#define WUCSR2_NS_RCD (0x00000040)
24786+#define WUCSR2_ARP_RCD (0x00000020)
24787+#define WUCSR2_TCPSYN_RCD (0x00000010)
24788+#define WUCSR2_NS_OFFLOAD (0x00000004)
24789+#define WUCSR2_ARP_OFFLOAD (0x00000002)
24790+#define WUCSR2_TCPSYN_OFFLOAD (0x00000001)
24791+
24792+#define WOL_FIFO_STS (0x504)
24793+
24794+#define IPV6_ADDRX (0x510)
24795+
24796+#define IPV4_ADDRX (0x590)
24797+
24798+
24799+/* Vendor-specific PHY Definitions */
24800+
24801+/* Mode Control/Status Register */
24802+#define PHY_MODE_CTRL_STS (17)
24803+#define MODE_CTRL_STS_EDPWRDOWN ((u16)0x2000)
24804+#define MODE_CTRL_STS_ENERGYON ((u16)0x0002)
24805+
24806+#define PHY_INT_SRC (29)
24807+#define PHY_INT_SRC_ENERGY_ON ((u16)0x0080)
24808+#define PHY_INT_SRC_ANEG_COMP ((u16)0x0040)
24809+#define PHY_INT_SRC_REMOTE_FAULT ((u16)0x0020)
24810+#define PHY_INT_SRC_LINK_DOWN ((u16)0x0010)
24811+#define PHY_INT_SRC_CLEAR_ALL ((u16)0xffff)
24812+
24813+#define PHY_INT_MASK (30)
24814+#define PHY_INT_MASK_ENERGY_ON ((u16)0x0080)
24815+#define PHY_INT_MASK_ANEG_COMP ((u16)0x0040)
24816+#define PHY_INT_MASK_REMOTE_FAULT ((u16)0x0020)
24817+#define PHY_INT_MASK_LINK_DOWN ((u16)0x0010)
24818+#define PHY_INT_MASK_DEFAULT (PHY_INT_MASK_ANEG_COMP | \
24819+ PHY_INT_MASK_LINK_DOWN)
24820+
24821+#define PHY_SPECIAL (31)
24822+#define PHY_SPECIAL_SPD ((u16)0x001C)
24823+#define PHY_SPECIAL_SPD_10HALF ((u16)0x0004)
24824+#define PHY_SPECIAL_SPD_10FULL ((u16)0x0014)
24825+#define PHY_SPECIAL_SPD_100HALF ((u16)0x0008)
24826+#define PHY_SPECIAL_SPD_100FULL ((u16)0x0018)
24827+
24828+/* USB Vendor Requests */
24829+#define USB_VENDOR_REQUEST_WRITE_REGISTER 0xA0
24830+#define USB_VENDOR_REQUEST_READ_REGISTER 0xA1
24831+#define USB_VENDOR_REQUEST_GET_STATS 0xA2
24832+
24833+/* Interrupt Endpoint status word bitfields */
24834+#define INT_ENP_RDFO_INT ((u32)BIT(22))
24835+#define INT_ENP_TXE_INT ((u32)BIT(21))
24836+#define INT_ENP_TX_DIS_INT ((u32)BIT(19))
24837+#define INT_ENP_RX_DIS_INT ((u32)BIT(18))
24838+#define INT_ENP_PHY_INT ((u32)BIT(17))
24839+#define INT_ENP_MAC_ERR_INT ((u32)BIT(15))
24840+#define INT_ENP_RX_FIFO_DATA_INT ((u32)BIT(12))
24841+
24842+#endif /* _SMSC75XX_H */
24843diff -Naur backports-3.18.1-1.org/drivers/net/usb/smsc95xx.c backports-3.18.1-1/drivers/net/usb/smsc95xx.c
24844--- backports-3.18.1-1.org/drivers/net/usb/smsc95xx.c 1970-01-01 01:00:00.000000000 +0100
24845+++ backports-3.18.1-1/drivers/net/usb/smsc95xx.c 2014-12-16 18:39:45.000000000 +0100
24846@@ -0,0 +1,2030 @@
24847+ /***************************************************************************
24848+ *
24849+ * Copyright (C) 2007-2008 SMSC
24850+ *
24851+ * This program is free software; you can redistribute it and/or
24852+ * modify it under the terms of the GNU General Public License
24853+ * as published by the Free Software Foundation; either version 2
24854+ * of the License, or (at your option) any later version.
24855+ *
24856+ * This program is distributed in the hope that it will be useful,
24857+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
24858+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24859+ * GNU General Public License for more details.
24860+ *
24861+ * You should have received a copy of the GNU General Public License
24862+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
24863+ *
24864+ *****************************************************************************/
24865+
24866+#include <linux/module.h>
24867+#include <linux/kmod.h>
24868+#include <linux/netdevice.h>
24869+#include <linux/etherdevice.h>
24870+#include <linux/ethtool.h>
24871+#include <linux/mii.h>
24872+#include <linux/usb.h>
24873+#include <linux/bitrev.h>
24874+#include <linux/crc16.h>
24875+#include <linux/crc32.h>
24876+#include <linux/usb/usbnet.h>
24877+#include <linux/slab.h>
24878+#include "smsc95xx.h"
24879+
24880+#define SMSC_CHIPNAME "smsc95xx"
24881+#define SMSC_DRIVER_VERSION "1.0.4"
24882+#define HS_USB_PKT_SIZE (512)
24883+#define FS_USB_PKT_SIZE (64)
24884+#define DEFAULT_HS_BURST_CAP_SIZE (16 * 1024 + 5 * HS_USB_PKT_SIZE)
24885+#define DEFAULT_FS_BURST_CAP_SIZE (6 * 1024 + 33 * FS_USB_PKT_SIZE)
24886+#define DEFAULT_BULK_IN_DELAY (0x00002000)
24887+#define MAX_SINGLE_PACKET_SIZE (2048)
24888+#define LAN95XX_EEPROM_MAGIC (0x9500)
24889+#define EEPROM_MAC_OFFSET (0x01)
24890+#define DEFAULT_TX_CSUM_ENABLE (true)
24891+#define DEFAULT_RX_CSUM_ENABLE (true)
24892+#define SMSC95XX_INTERNAL_PHY_ID (1)
24893+#define SMSC95XX_TX_OVERHEAD (8)
24894+#define SMSC95XX_TX_OVERHEAD_CSUM (12)
24895+#define SUPPORTED_WAKE (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
24896+ WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
24897+
24898+#define FEATURE_8_WAKEUP_FILTERS (0x01)
24899+#define FEATURE_PHY_NLP_CROSSOVER (0x02)
24900+#define FEATURE_REMOTE_WAKEUP (0x04)
24901+
24902+#define SUSPEND_SUSPEND0 (0x01)
24903+#define SUSPEND_SUSPEND1 (0x02)
24904+#define SUSPEND_SUSPEND2 (0x04)
24905+#define SUSPEND_SUSPEND3 (0x08)
24906+#define SUSPEND_ALLMODES (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
24907+ SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)
24908+
24909+struct smsc95xx_priv {
24910+ u32 mac_cr;
24911+ u32 hash_hi;
24912+ u32 hash_lo;
24913+ u32 wolopts;
24914+ spinlock_t mac_cr_lock;
24915+ u8 features;
24916+ u8 suspend_flags;
24917+};
24918+
24919+static bool turbo_mode = true;
24920+module_param(turbo_mode, bool, 0644);
24921+MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
24922+
24923+static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
24924+ u32 *data, int in_pm)
24925+{
24926+ u32 buf;
24927+ int ret;
24928+ int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
24929+
24930+ BUG_ON(!dev);
24931+
24932+ if (!in_pm)
24933+ fn = usbnet_read_cmd;
24934+ else
24935+ fn = usbnet_read_cmd_nopm;
24936+
24937+ ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
24938+ | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
24939+ 0, index, &buf, 4);
24940+ if (unlikely(ret < 0))
24941+ netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
24942+ index, ret);
24943+
24944+ le32_to_cpus(&buf);
24945+ *data = buf;
24946+
24947+ return ret;
24948+}
24949+
24950+static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index,
24951+ u32 data, int in_pm)
24952+{
24953+ u32 buf;
24954+ int ret;
24955+ int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
24956+
24957+ BUG_ON(!dev);
24958+
24959+ if (!in_pm)
24960+ fn = usbnet_write_cmd;
24961+ else
24962+ fn = usbnet_write_cmd_nopm;
24963+
24964+ buf = data;
24965+ cpu_to_le32s(&buf);
24966+
24967+ ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
24968+ | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
24969+ 0, index, &buf, 4);
24970+ if (unlikely(ret < 0))
24971+ netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
24972+ index, ret);
24973+
24974+ return ret;
24975+}
24976+
24977+static int __must_check smsc95xx_read_reg_nopm(struct usbnet *dev, u32 index,
24978+ u32 *data)
24979+{
24980+ return __smsc95xx_read_reg(dev, index, data, 1);
24981+}
24982+
24983+static int __must_check smsc95xx_write_reg_nopm(struct usbnet *dev, u32 index,
24984+ u32 data)
24985+{
24986+ return __smsc95xx_write_reg(dev, index, data, 1);
24987+}
24988+
24989+static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index,
24990+ u32 *data)
24991+{
24992+ return __smsc95xx_read_reg(dev, index, data, 0);
24993+}
24994+
24995+static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index,
24996+ u32 data)
24997+{
24998+ return __smsc95xx_write_reg(dev, index, data, 0);
24999+}
25000+
25001+/* Loop until the read is completed with timeout
25002+ * called with phy_mutex held */
25003+static int __must_check __smsc95xx_phy_wait_not_busy(struct usbnet *dev,
25004+ int in_pm)
25005+{
25006+ unsigned long start_time = jiffies;
25007+ u32 val;
25008+ int ret;
25009+
25010+ do {
25011+ ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm);
25012+ if (ret < 0) {
25013+ netdev_warn(dev->net, "Error reading MII_ACCESS\n");
25014+ return ret;
25015+ }
25016+
25017+ if (!(val & MII_BUSY_))
25018+ return 0;
25019+ } while (!time_after(jiffies, start_time + HZ));
25020+
25021+ return -EIO;
25022+}
25023+
25024+static int __smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx,
25025+ int in_pm)
25026+{
25027+ struct usbnet *dev = netdev_priv(netdev);
25028+ u32 val, addr;
25029+ int ret;
25030+
25031+ mutex_lock(&dev->phy_mutex);
25032+
25033+ /* confirm MII not busy */
25034+ ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
25035+ if (ret < 0) {
25036+ netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_read\n");
25037+ goto done;
25038+ }
25039+
25040+ /* set the address, index & direction (read from PHY) */
25041+ phy_id &= dev->mii.phy_id_mask;
25042+ idx &= dev->mii.reg_num_mask;
25043+ addr = (phy_id << 11) | (idx << 6) | MII_READ_ | MII_BUSY_;
25044+ ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
25045+ if (ret < 0) {
25046+ netdev_warn(dev->net, "Error writing MII_ADDR\n");
25047+ goto done;
25048+ }
25049+
25050+ ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
25051+ if (ret < 0) {
25052+ netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
25053+ goto done;
25054+ }
25055+
25056+ ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm);
25057+ if (ret < 0) {
25058+ netdev_warn(dev->net, "Error reading MII_DATA\n");
25059+ goto done;
25060+ }
25061+
25062+ ret = (u16)(val & 0xFFFF);
25063+
25064+done:
25065+ mutex_unlock(&dev->phy_mutex);
25066+ return ret;
25067+}
25068+
25069+static void __smsc95xx_mdio_write(struct net_device *netdev, int phy_id,
25070+ int idx, int regval, int in_pm)
25071+{
25072+ struct usbnet *dev = netdev_priv(netdev);
25073+ u32 val, addr;
25074+ int ret;
25075+
25076+ mutex_lock(&dev->phy_mutex);
25077+
25078+ /* confirm MII not busy */
25079+ ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
25080+ if (ret < 0) {
25081+ netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_write\n");
25082+ goto done;
25083+ }
25084+
25085+ val = regval;
25086+ ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm);
25087+ if (ret < 0) {
25088+ netdev_warn(dev->net, "Error writing MII_DATA\n");
25089+ goto done;
25090+ }
25091+
25092+ /* set the address, index & direction (write to PHY) */
25093+ phy_id &= dev->mii.phy_id_mask;
25094+ idx &= dev->mii.reg_num_mask;
25095+ addr = (phy_id << 11) | (idx << 6) | MII_WRITE_ | MII_BUSY_;
25096+ ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
25097+ if (ret < 0) {
25098+ netdev_warn(dev->net, "Error writing MII_ADDR\n");
25099+ goto done;
25100+ }
25101+
25102+ ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
25103+ if (ret < 0) {
25104+ netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
25105+ goto done;
25106+ }
25107+
25108+done:
25109+ mutex_unlock(&dev->phy_mutex);
25110+}
25111+
25112+static int smsc95xx_mdio_read_nopm(struct net_device *netdev, int phy_id,
25113+ int idx)
25114+{
25115+ return __smsc95xx_mdio_read(netdev, phy_id, idx, 1);
25116+}
25117+
25118+static void smsc95xx_mdio_write_nopm(struct net_device *netdev, int phy_id,
25119+ int idx, int regval)
25120+{
25121+ __smsc95xx_mdio_write(netdev, phy_id, idx, regval, 1);
25122+}
25123+
25124+static int smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
25125+{
25126+ return __smsc95xx_mdio_read(netdev, phy_id, idx, 0);
25127+}
25128+
25129+static void smsc95xx_mdio_write(struct net_device *netdev, int phy_id, int idx,
25130+ int regval)
25131+{
25132+ __smsc95xx_mdio_write(netdev, phy_id, idx, regval, 0);
25133+}
25134+
25135+static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
25136+{
25137+ unsigned long start_time = jiffies;
25138+ u32 val;
25139+ int ret;
25140+
25141+ do {
25142+ ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
25143+ if (ret < 0) {
25144+ netdev_warn(dev->net, "Error reading E2P_CMD\n");
25145+ return ret;
25146+ }
25147+
25148+ if (!(val & E2P_CMD_BUSY_) || (val & E2P_CMD_TIMEOUT_))
25149+ break;
25150+ udelay(40);
25151+ } while (!time_after(jiffies, start_time + HZ));
25152+
25153+ if (val & (E2P_CMD_TIMEOUT_ | E2P_CMD_BUSY_)) {
25154+ netdev_warn(dev->net, "EEPROM read operation timeout\n");
25155+ return -EIO;
25156+ }
25157+
25158+ return 0;
25159+}
25160+
25161+static int __must_check smsc95xx_eeprom_confirm_not_busy(struct usbnet *dev)
25162+{
25163+ unsigned long start_time = jiffies;
25164+ u32 val;
25165+ int ret;
25166+
25167+ do {
25168+ ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
25169+ if (ret < 0) {
25170+ netdev_warn(dev->net, "Error reading E2P_CMD\n");
25171+ return ret;
25172+ }
25173+
25174+ if (!(val & E2P_CMD_BUSY_))
25175+ return 0;
25176+
25177+ udelay(40);
25178+ } while (!time_after(jiffies, start_time + HZ));
25179+
25180+ netdev_warn(dev->net, "EEPROM is busy\n");
25181+ return -EIO;
25182+}
25183+
25184+static int smsc95xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
25185+ u8 *data)
25186+{
25187+ u32 val;
25188+ int i, ret;
25189+
25190+ BUG_ON(!dev);
25191+ BUG_ON(!data);
25192+
25193+ ret = smsc95xx_eeprom_confirm_not_busy(dev);
25194+ if (ret)
25195+ return ret;
25196+
25197+ for (i = 0; i < length; i++) {
25198+ val = E2P_CMD_BUSY_ | E2P_CMD_READ_ | (offset & E2P_CMD_ADDR_);
25199+ ret = smsc95xx_write_reg(dev, E2P_CMD, val);
25200+ if (ret < 0) {
25201+ netdev_warn(dev->net, "Error writing E2P_CMD\n");
25202+ return ret;
25203+ }
25204+
25205+ ret = smsc95xx_wait_eeprom(dev);
25206+ if (ret < 0)
25207+ return ret;
25208+
25209+ ret = smsc95xx_read_reg(dev, E2P_DATA, &val);
25210+ if (ret < 0) {
25211+ netdev_warn(dev->net, "Error reading E2P_DATA\n");
25212+ return ret;
25213+ }
25214+
25215+ data[i] = val & 0xFF;
25216+ offset++;
25217+ }
25218+
25219+ return 0;
25220+}
25221+
25222+static int smsc95xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
25223+ u8 *data)
25224+{
25225+ u32 val;
25226+ int i, ret;
25227+
25228+ BUG_ON(!dev);
25229+ BUG_ON(!data);
25230+
25231+ ret = smsc95xx_eeprom_confirm_not_busy(dev);
25232+ if (ret)
25233+ return ret;
25234+
25235+ /* Issue write/erase enable command */
25236+ val = E2P_CMD_BUSY_ | E2P_CMD_EWEN_;
25237+ ret = smsc95xx_write_reg(dev, E2P_CMD, val);
25238+ if (ret < 0) {
25239+ netdev_warn(dev->net, "Error writing E2P_DATA\n");
25240+ return ret;
25241+ }
25242+
25243+ ret = smsc95xx_wait_eeprom(dev);
25244+ if (ret < 0)
25245+ return ret;
25246+
25247+ for (i = 0; i < length; i++) {
25248+
25249+ /* Fill data register */
25250+ val = data[i];
25251+ ret = smsc95xx_write_reg(dev, E2P_DATA, val);
25252+ if (ret < 0) {
25253+ netdev_warn(dev->net, "Error writing E2P_DATA\n");
25254+ return ret;
25255+ }
25256+
25257+ /* Send "write" command */
25258+ val = E2P_CMD_BUSY_ | E2P_CMD_WRITE_ | (offset & E2P_CMD_ADDR_);
25259+ ret = smsc95xx_write_reg(dev, E2P_CMD, val);
25260+ if (ret < 0) {
25261+ netdev_warn(dev->net, "Error writing E2P_CMD\n");
25262+ return ret;
25263+ }
25264+
25265+ ret = smsc95xx_wait_eeprom(dev);
25266+ if (ret < 0)
25267+ return ret;
25268+
25269+ offset++;
25270+ }
25271+
25272+ return 0;
25273+}
25274+
25275+static int __must_check smsc95xx_write_reg_async(struct usbnet *dev, u16 index,
25276+ u32 data)
25277+{
25278+ const u16 size = 4;
25279+ u32 buf;
25280+ int ret;
25281+
25282+ buf = data;
25283+ cpu_to_le32s(&buf);
25284+
25285+ ret = usbnet_write_cmd_async(dev, USB_VENDOR_REQUEST_WRITE_REGISTER,
25286+ USB_DIR_OUT | USB_TYPE_VENDOR |
25287+ USB_RECIP_DEVICE,
25288+ 0, index, &buf, size);
25289+ if (ret < 0)
25290+ netdev_warn(dev->net, "Error write async cmd, sts=%d\n",
25291+ ret);
25292+ return ret;
25293+}
25294+
25295+/* returns hash bit number for given MAC address
25296+ * example:
25297+ * 01 00 5E 00 00 01 -> returns bit number 31 */
25298+static unsigned int smsc95xx_hash(char addr[ETH_ALEN])
25299+{
25300+ return (ether_crc(ETH_ALEN, addr) >> 26) & 0x3f;
25301+}
25302+
25303+static void smsc95xx_set_multicast(struct net_device *netdev)
25304+{
25305+ struct usbnet *dev = netdev_priv(netdev);
25306+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
25307+ unsigned long flags;
25308+ int ret;
25309+
25310+ pdata->hash_hi = 0;
25311+ pdata->hash_lo = 0;
25312+
25313+ spin_lock_irqsave(&pdata->mac_cr_lock, flags);
25314+
25315+ if (dev->net->flags & IFF_PROMISC) {
25316+ netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
25317+ pdata->mac_cr |= MAC_CR_PRMS_;
25318+ pdata->mac_cr &= ~(MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
25319+ } else if (dev->net->flags & IFF_ALLMULTI) {
25320+ netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
25321+ pdata->mac_cr |= MAC_CR_MCPAS_;
25322+ pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_HPFILT_);
25323+ } else if (!netdev_mc_empty(dev->net)) {
25324+ struct netdev_hw_addr *ha;
25325+
25326+ pdata->mac_cr |= MAC_CR_HPFILT_;
25327+ pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);
25328+
25329+ netdev_for_each_mc_addr(ha, netdev) {
25330+ u32 bitnum = smsc95xx_hash(ha->addr);
25331+ u32 mask = 0x01 << (bitnum & 0x1F);
25332+ if (bitnum & 0x20)
25333+ pdata->hash_hi |= mask;
25334+ else
25335+ pdata->hash_lo |= mask;
25336+ }
25337+
25338+ netif_dbg(dev, drv, dev->net, "HASHH=0x%08X, HASHL=0x%08X\n",
25339+ pdata->hash_hi, pdata->hash_lo);
25340+ } else {
25341+ netif_dbg(dev, drv, dev->net, "receive own packets only\n");
25342+ pdata->mac_cr &=
25343+ ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
25344+ }
25345+
25346+ spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
25347+
25348+ /* Initiate async writes, as we can't wait for completion here */
25349+ ret = smsc95xx_write_reg_async(dev, HASHH, pdata->hash_hi);
25350+ if (ret < 0)
25351+ netdev_warn(dev->net, "failed to initiate async write to HASHH\n");
25352+
25353+ ret = smsc95xx_write_reg_async(dev, HASHL, pdata->hash_lo);
25354+ if (ret < 0)
25355+ netdev_warn(dev->net, "failed to initiate async write to HASHL\n");
25356+
25357+ ret = smsc95xx_write_reg_async(dev, MAC_CR, pdata->mac_cr);
25358+ if (ret < 0)
25359+ netdev_warn(dev->net, "failed to initiate async write to MAC_CR\n");
25360+}
25361+
25362+static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
25363+ u16 lcladv, u16 rmtadv)
25364+{
25365+ u32 flow, afc_cfg = 0;
25366+
25367+ int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
25368+ if (ret < 0)
25369+ return ret;
25370+
25371+ if (duplex == DUPLEX_FULL) {
25372+ u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
25373+
25374+ if (cap & FLOW_CTRL_RX)
25375+ flow = 0xFFFF0002;
25376+ else
25377+ flow = 0;
25378+
25379+ if (cap & FLOW_CTRL_TX)
25380+ afc_cfg |= 0xF;
25381+ else
25382+ afc_cfg &= ~0xF;
25383+
25384+ netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
25385+ cap & FLOW_CTRL_RX ? "enabled" : "disabled",
25386+ cap & FLOW_CTRL_TX ? "enabled" : "disabled");
25387+ } else {
25388+ netif_dbg(dev, link, dev->net, "half duplex\n");
25389+ flow = 0;
25390+ afc_cfg |= 0xF;
25391+ }
25392+
25393+ ret = smsc95xx_write_reg(dev, FLOW, flow);
25394+ if (ret < 0)
25395+ return ret;
25396+
25397+ return smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
25398+}
25399+
25400+static int smsc95xx_link_reset(struct usbnet *dev)
25401+{
25402+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
25403+ struct mii_if_info *mii = &dev->mii;
25404+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
25405+ unsigned long flags;
25406+ u16 lcladv, rmtadv;
25407+ int ret;
25408+
25409+ /* clear interrupt status */
25410+ ret = smsc95xx_mdio_read(dev->net, mii->phy_id, PHY_INT_SRC);
25411+ if (ret < 0)
25412+ return ret;
25413+
25414+ ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
25415+ if (ret < 0)
25416+ return ret;
25417+
25418+ mii_check_media(mii, 1, 1);
25419+ mii_ethtool_gset(&dev->mii, &ecmd);
25420+ lcladv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
25421+ rmtadv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
25422+
25423+ netif_dbg(dev, link, dev->net,
25424+ "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",
25425+ ethtool_cmd_speed(&ecmd), ecmd.duplex, lcladv, rmtadv);
25426+
25427+ spin_lock_irqsave(&pdata->mac_cr_lock, flags);
25428+ if (ecmd.duplex != DUPLEX_FULL) {
25429+ pdata->mac_cr &= ~MAC_CR_FDPX_;
25430+ pdata->mac_cr |= MAC_CR_RCVOWN_;
25431+ } else {
25432+ pdata->mac_cr &= ~MAC_CR_RCVOWN_;
25433+ pdata->mac_cr |= MAC_CR_FDPX_;
25434+ }
25435+ spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
25436+
25437+ ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
25438+ if (ret < 0)
25439+ return ret;
25440+
25441+ ret = smsc95xx_phy_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
25442+ if (ret < 0)
25443+ netdev_warn(dev->net, "Error updating PHY flow control\n");
25444+
25445+ return ret;
25446+}
25447+
25448+static void smsc95xx_status(struct usbnet *dev, struct urb *urb)
25449+{
25450+ u32 intdata;
25451+
25452+ if (urb->actual_length != 4) {
25453+ netdev_warn(dev->net, "unexpected urb length %d\n",
25454+ urb->actual_length);
25455+ return;
25456+ }
25457+
25458+ memcpy(&intdata, urb->transfer_buffer, 4);
25459+ le32_to_cpus(&intdata);
25460+
25461+ netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
25462+
25463+ if (intdata & INT_ENP_PHY_INT_)
25464+ usbnet_defer_kevent(dev, EVENT_LINK_RESET);
25465+ else
25466+ netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
25467+ intdata);
25468+}
25469+
25470+/* Enable or disable Tx & Rx checksum offload engines */
25471+static int smsc95xx_set_features(struct net_device *netdev,
25472+ netdev_features_t features)
25473+{
25474+ struct usbnet *dev = netdev_priv(netdev);
25475+ u32 read_buf;
25476+ int ret;
25477+
25478+ ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
25479+ if (ret < 0)
25480+ return ret;
25481+
25482+ if (features & NETIF_F_HW_CSUM)
25483+ read_buf |= Tx_COE_EN_;
25484+ else
25485+ read_buf &= ~Tx_COE_EN_;
25486+
25487+ if (features & NETIF_F_RXCSUM)
25488+ read_buf |= Rx_COE_EN_;
25489+ else
25490+ read_buf &= ~Rx_COE_EN_;
25491+
25492+ ret = smsc95xx_write_reg(dev, COE_CR, read_buf);
25493+ if (ret < 0)
25494+ return ret;
25495+
25496+ netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf);
25497+ return 0;
25498+}
25499+
25500+static int smsc95xx_ethtool_get_eeprom_len(struct net_device *net)
25501+{
25502+ return MAX_EEPROM_SIZE;
25503+}
25504+
25505+static int smsc95xx_ethtool_get_eeprom(struct net_device *netdev,
25506+ struct ethtool_eeprom *ee, u8 *data)
25507+{
25508+ struct usbnet *dev = netdev_priv(netdev);
25509+
25510+ ee->magic = LAN95XX_EEPROM_MAGIC;
25511+
25512+ return smsc95xx_read_eeprom(dev, ee->offset, ee->len, data);
25513+}
25514+
25515+static int smsc95xx_ethtool_set_eeprom(struct net_device *netdev,
25516+ struct ethtool_eeprom *ee, u8 *data)
25517+{
25518+ struct usbnet *dev = netdev_priv(netdev);
25519+
25520+ if (ee->magic != LAN95XX_EEPROM_MAGIC) {
25521+ netdev_warn(dev->net, "EEPROM: magic value mismatch, magic = 0x%x\n",
25522+ ee->magic);
25523+ return -EINVAL;
25524+ }
25525+
25526+ return smsc95xx_write_eeprom(dev, ee->offset, ee->len, data);
25527+}
25528+
25529+static int smsc95xx_ethtool_getregslen(struct net_device *netdev)
25530+{
25531+ /* all smsc95xx registers */
25532+ return COE_CR - ID_REV + sizeof(u32);
25533+}
25534+
25535+static void
25536+smsc95xx_ethtool_getregs(struct net_device *netdev, struct ethtool_regs *regs,
25537+ void *buf)
25538+{
25539+ struct usbnet *dev = netdev_priv(netdev);
25540+ unsigned int i, j;
25541+ int retval;
25542+ u32 *data = buf;
25543+
25544+ retval = smsc95xx_read_reg(dev, ID_REV, &regs->version);
25545+ if (retval < 0) {
25546+ netdev_warn(netdev, "REGS: cannot read ID_REV\n");
25547+ return;
25548+ }
25549+
25550+ for (i = ID_REV, j = 0; i <= COE_CR; i += (sizeof(u32)), j++) {
25551+ retval = smsc95xx_read_reg(dev, i, &data[j]);
25552+ if (retval < 0) {
25553+ netdev_warn(netdev, "REGS: cannot read reg[%x]\n", i);
25554+ return;
25555+ }
25556+ }
25557+}
25558+
25559+static void smsc95xx_ethtool_get_wol(struct net_device *net,
25560+ struct ethtool_wolinfo *wolinfo)
25561+{
25562+ struct usbnet *dev = netdev_priv(net);
25563+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
25564+
25565+ wolinfo->supported = SUPPORTED_WAKE;
25566+ wolinfo->wolopts = pdata->wolopts;
25567+}
25568+
25569+static int smsc95xx_ethtool_set_wol(struct net_device *net,
25570+ struct ethtool_wolinfo *wolinfo)
25571+{
25572+ struct usbnet *dev = netdev_priv(net);
25573+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
25574+ int ret;
25575+
25576+ pdata->wolopts = wolinfo->wolopts & SUPPORTED_WAKE;
25577+
25578+ ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
25579+ if (ret < 0)
25580+ netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
25581+
25582+ return ret;
25583+}
25584+
25585+static const struct ethtool_ops smsc95xx_ethtool_ops = {
25586+ .get_link = usbnet_get_link,
25587+ .nway_reset = usbnet_nway_reset,
25588+ .get_drvinfo = usbnet_get_drvinfo,
25589+ .get_msglevel = usbnet_get_msglevel,
25590+ .set_msglevel = usbnet_set_msglevel,
25591+ .get_settings = usbnet_get_settings,
25592+ .set_settings = usbnet_set_settings,
25593+ .get_eeprom_len = smsc95xx_ethtool_get_eeprom_len,
25594+ .get_eeprom = smsc95xx_ethtool_get_eeprom,
25595+ .set_eeprom = smsc95xx_ethtool_set_eeprom,
25596+ .get_regs_len = smsc95xx_ethtool_getregslen,
25597+ .get_regs = smsc95xx_ethtool_getregs,
25598+ .get_wol = smsc95xx_ethtool_get_wol,
25599+ .set_wol = smsc95xx_ethtool_set_wol,
25600+};
25601+
25602+static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
25603+{
25604+ struct usbnet *dev = netdev_priv(netdev);
25605+
25606+ if (!netif_running(netdev))
25607+ return -EINVAL;
25608+
25609+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
25610+}
25611+
25612+static void smsc95xx_init_mac_address(struct usbnet *dev)
25613+{
25614+ /* try reading mac address from EEPROM */
25615+ if (smsc95xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
25616+ dev->net->dev_addr) == 0) {
25617+ if (is_valid_ether_addr(dev->net->dev_addr)) {
25618+ /* eeprom values are valid so use them */
25619+ netif_dbg(dev, ifup, dev->net, "MAC address read from EEPROM\n");
25620+ return;
25621+ }
25622+ }
25623+
25624+ /* no eeprom, or eeprom values are invalid. generate random MAC */
25625+ eth_hw_addr_random(dev->net);
25626+ netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
25627+}
25628+
25629+static int smsc95xx_set_mac_address(struct usbnet *dev)
25630+{
25631+ u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
25632+ dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
25633+ u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
25634+ int ret;
25635+
25636+ ret = smsc95xx_write_reg(dev, ADDRL, addr_lo);
25637+ if (ret < 0)
25638+ return ret;
25639+
25640+ return smsc95xx_write_reg(dev, ADDRH, addr_hi);
25641+}
25642+
25643+/* starts the TX path */
25644+static int smsc95xx_start_tx_path(struct usbnet *dev)
25645+{
25646+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
25647+ unsigned long flags;
25648+ int ret;
25649+
25650+ /* Enable Tx at MAC */
25651+ spin_lock_irqsave(&pdata->mac_cr_lock, flags);
25652+ pdata->mac_cr |= MAC_CR_TXEN_;
25653+ spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
25654+
25655+ ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
25656+ if (ret < 0)
25657+ return ret;
25658+
25659+ /* Enable Tx at SCSRs */
25660+ return smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
25661+}
25662+
25663+/* Starts the Receive path */
25664+static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
25665+{
25666+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
25667+ unsigned long flags;
25668+
25669+ spin_lock_irqsave(&pdata->mac_cr_lock, flags);
25670+ pdata->mac_cr |= MAC_CR_RXEN_;
25671+ spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
25672+
25673+ return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
25674+}
25675+
25676+static int smsc95xx_phy_initialize(struct usbnet *dev)
25677+{
25678+ int bmcr, ret, timeout = 0;
25679+
25680+ /* Initialize MII structure */
25681+ dev->mii.dev = dev->net;
25682+ dev->mii.mdio_read = smsc95xx_mdio_read;
25683+ dev->mii.mdio_write = smsc95xx_mdio_write;
25684+ dev->mii.phy_id_mask = 0x1f;
25685+ dev->mii.reg_num_mask = 0x1f;
25686+ dev->mii.phy_id = SMSC95XX_INTERNAL_PHY_ID;
25687+
25688+ /* reset phy and wait for reset to complete */
25689+ smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
25690+
25691+ do {
25692+ msleep(10);
25693+ bmcr = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
25694+ timeout++;
25695+ } while ((bmcr & BMCR_RESET) && (timeout < 100));
25696+
25697+ if (timeout >= 100) {
25698+ netdev_warn(dev->net, "timeout on PHY Reset");
25699+ return -EIO;
25700+ }
25701+
25702+ smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
25703+ ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP |
25704+ ADVERTISE_PAUSE_ASYM);
25705+
25706+ /* read to clear */
25707+ ret = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
25708+ if (ret < 0) {
25709+ netdev_warn(dev->net, "Failed to read PHY_INT_SRC during init\n");
25710+ return ret;
25711+ }
25712+
25713+ smsc95xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
25714+ PHY_INT_MASK_DEFAULT_);
25715+ mii_nway_restart(&dev->mii);
25716+
25717+ netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
25718+ return 0;
25719+}
25720+
25721+static int smsc95xx_reset(struct usbnet *dev)
25722+{
25723+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
25724+ u32 read_buf, write_buf, burst_cap;
25725+ int ret = 0, timeout;
25726+
25727+ netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n");
25728+
25729+ ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_);
25730+ if (ret < 0)
25731+ return ret;
25732+
25733+ timeout = 0;
25734+ do {
25735+ msleep(10);
25736+ ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
25737+ if (ret < 0)
25738+ return ret;
25739+ timeout++;
25740+ } while ((read_buf & HW_CFG_LRST_) && (timeout < 100));
25741+
25742+ if (timeout >= 100) {
25743+ netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n");
25744+ return ret;
25745+ }
25746+
25747+ ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_);
25748+ if (ret < 0)
25749+ return ret;
25750+
25751+ timeout = 0;
25752+ do {
25753+ msleep(10);
25754+ ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf);
25755+ if (ret < 0)
25756+ return ret;
25757+ timeout++;
25758+ } while ((read_buf & PM_CTL_PHY_RST_) && (timeout < 100));
25759+
25760+ if (timeout >= 100) {
25761+ netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
25762+ return ret;
25763+ }
25764+
25765+ ret = smsc95xx_set_mac_address(dev);
25766+ if (ret < 0)
25767+ return ret;
25768+
25769+ netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
25770+ dev->net->dev_addr);
25771+
25772+ ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
25773+ if (ret < 0)
25774+ return ret;
25775+
25776+ netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
25777+ read_buf);
25778+
25779+ read_buf |= HW_CFG_BIR_;
25780+
25781+ ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
25782+ if (ret < 0)
25783+ return ret;
25784+
25785+ ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
25786+ if (ret < 0)
25787+ return ret;
25788+
25789+ netif_dbg(dev, ifup, dev->net,
25790+ "Read Value from HW_CFG after writing HW_CFG_BIR_: 0x%08x\n",
25791+ read_buf);
25792+
25793+ if (!turbo_mode) {
25794+ burst_cap = 0;
25795+ dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
25796+ } else if (dev->udev->speed == USB_SPEED_HIGH) {
25797+ burst_cap = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
25798+ dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
25799+ } else {
25800+ burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
25801+ dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
25802+ }
25803+
25804+ netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
25805+ (ulong)dev->rx_urb_size);
25806+
25807+ ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap);
25808+ if (ret < 0)
25809+ return ret;
25810+
25811+ ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf);
25812+ if (ret < 0)
25813+ return ret;
25814+
25815+ netif_dbg(dev, ifup, dev->net,
25816+ "Read Value from BURST_CAP after writing: 0x%08x\n",
25817+ read_buf);
25818+
25819+ ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
25820+ if (ret < 0)
25821+ return ret;
25822+
25823+ ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf);
25824+ if (ret < 0)
25825+ return ret;
25826+
25827+ netif_dbg(dev, ifup, dev->net,
25828+ "Read Value from BULK_IN_DLY after writing: 0x%08x\n",
25829+ read_buf);
25830+
25831+ ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
25832+ if (ret < 0)
25833+ return ret;
25834+
25835+ netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n",
25836+ read_buf);
25837+
25838+ if (turbo_mode)
25839+ read_buf |= (HW_CFG_MEF_ | HW_CFG_BCE_);
25840+
25841+ read_buf &= ~HW_CFG_RXDOFF_;
25842+
25843+ /* set Rx data offset=2, Make IP header aligns on word boundary. */
25844+ read_buf |= NET_IP_ALIGN << 9;
25845+
25846+ ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
25847+ if (ret < 0)
25848+ return ret;
25849+
25850+ ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
25851+ if (ret < 0)
25852+ return ret;
25853+
25854+ netif_dbg(dev, ifup, dev->net,
25855+ "Read Value from HW_CFG after writing: 0x%08x\n", read_buf);
25856+
25857+ ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
25858+ if (ret < 0)
25859+ return ret;
25860+
25861+ ret = smsc95xx_read_reg(dev, ID_REV, &read_buf);
25862+ if (ret < 0)
25863+ return ret;
25864+ netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf);
25865+
25866+ /* Configure GPIO pins as LED outputs */
25867+ write_buf = LED_GPIO_CFG_SPD_LED | LED_GPIO_CFG_LNK_LED |
25868+ LED_GPIO_CFG_FDX_LED;
25869+ ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf);
25870+ if (ret < 0)
25871+ return ret;
25872+
25873+ /* Init Tx */
25874+ ret = smsc95xx_write_reg(dev, FLOW, 0);
25875+ if (ret < 0)
25876+ return ret;
25877+
25878+ ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT);
25879+ if (ret < 0)
25880+ return ret;
25881+
25882+ /* Don't need mac_cr_lock during initialisation */
25883+ ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr);
25884+ if (ret < 0)
25885+ return ret;
25886+
25887+ /* Init Rx */
25888+ /* Set Vlan */
25889+ ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q);
25890+ if (ret < 0)
25891+ return ret;
25892+
25893+ /* Enable or disable checksum offload engines */
25894+ ret = smsc95xx_set_features(dev->net, dev->net->features);
25895+ if (ret < 0) {
25896+ netdev_warn(dev->net, "Failed to set checksum offload features\n");
25897+ return ret;
25898+ }
25899+
25900+ smsc95xx_set_multicast(dev->net);
25901+
25902+ ret = smsc95xx_phy_initialize(dev);
25903+ if (ret < 0) {
25904+ netdev_warn(dev->net, "Failed to init PHY\n");
25905+ return ret;
25906+ }
25907+
25908+ ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
25909+ if (ret < 0)
25910+ return ret;
25911+
25912+ /* enable PHY interrupts */
25913+ read_buf |= INT_EP_CTL_PHY_INT_;
25914+
25915+ ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf);
25916+ if (ret < 0)
25917+ return ret;
25918+
25919+ ret = smsc95xx_start_tx_path(dev);
25920+ if (ret < 0) {
25921+ netdev_warn(dev->net, "Failed to start TX path\n");
25922+ return ret;
25923+ }
25924+
25925+ ret = smsc95xx_start_rx_path(dev, 0);
25926+ if (ret < 0) {
25927+ netdev_warn(dev->net, "Failed to start RX path\n");
25928+ return ret;
25929+ }
25930+
25931+ netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n");
25932+ return 0;
25933+}
25934+
25935+static const struct net_device_ops smsc95xx_netdev_ops = {
25936+ .ndo_open = usbnet_open,
25937+ .ndo_stop = usbnet_stop,
25938+ .ndo_start_xmit = usbnet_start_xmit,
25939+ .ndo_tx_timeout = usbnet_tx_timeout,
25940+ .ndo_change_mtu = usbnet_change_mtu,
25941+ .ndo_set_mac_address = eth_mac_addr,
25942+ .ndo_validate_addr = eth_validate_addr,
25943+ .ndo_do_ioctl = smsc95xx_ioctl,
25944+ .ndo_set_rx_mode = smsc95xx_set_multicast,
25945+ .ndo_set_features = smsc95xx_set_features,
25946+};
25947+
25948+static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
25949+{
25950+ struct smsc95xx_priv *pdata = NULL;
25951+ u32 val;
25952+ int ret;
25953+
25954+ printk(KERN_INFO SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n");
25955+
25956+ ret = usbnet_get_endpoints(dev, intf);
25957+ if (ret < 0) {
25958+ netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
25959+ return ret;
25960+ }
25961+
25962+ dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc95xx_priv),
25963+ GFP_KERNEL);
25964+
25965+ pdata = (struct smsc95xx_priv *)(dev->data[0]);
25966+ if (!pdata)
25967+ return -ENOMEM;
25968+
25969+ spin_lock_init(&pdata->mac_cr_lock);
25970+
25971+ if (DEFAULT_TX_CSUM_ENABLE)
25972+ dev->net->features |= NETIF_F_HW_CSUM;
25973+ if (DEFAULT_RX_CSUM_ENABLE)
25974+ dev->net->features |= NETIF_F_RXCSUM;
25975+
25976+ dev->net->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
25977+
25978+ smsc95xx_init_mac_address(dev);
25979+
25980+ /* Init all registers */
25981+ ret = smsc95xx_reset(dev);
25982+
25983+ /* detect device revision as different features may be available */
25984+ ret = smsc95xx_read_reg(dev, ID_REV, &val);
25985+ if (ret < 0)
25986+ return ret;
25987+ val >>= 16;
25988+
25989+ if ((val == ID_REV_CHIP_ID_9500A_) || (val == ID_REV_CHIP_ID_9530_) ||
25990+ (val == ID_REV_CHIP_ID_89530_) || (val == ID_REV_CHIP_ID_9730_))
25991+ pdata->features = (FEATURE_8_WAKEUP_FILTERS |
25992+ FEATURE_PHY_NLP_CROSSOVER |
25993+ FEATURE_REMOTE_WAKEUP);
25994+ else if (val == ID_REV_CHIP_ID_9512_)
25995+ pdata->features = FEATURE_8_WAKEUP_FILTERS;
25996+
25997+ dev->net->netdev_ops = &smsc95xx_netdev_ops;
25998+ dev->net->ethtool_ops = &smsc95xx_ethtool_ops;
25999+ dev->net->flags |= IFF_MULTICAST;
26000+ dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM;
26001+ dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
26002+ return 0;
26003+}
26004+
26005+static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf)
26006+{
26007+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26008+ if (pdata) {
26009+ netif_dbg(dev, ifdown, dev->net, "free pdata\n");
26010+ kfree(pdata);
26011+ pdata = NULL;
26012+ dev->data[0] = 0;
26013+ }
26014+}
26015+
26016+static u32 smsc_crc(const u8 *buffer, size_t len, int filter)
26017+{
26018+ u32 crc = bitrev16(crc16(0xFFFF, buffer, len));
26019+ return crc << ((filter % 2) * 16);
26020+}
26021+
26022+static int smsc95xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
26023+{
26024+ struct mii_if_info *mii = &dev->mii;
26025+ int ret;
26026+
26027+ netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
26028+
26029+ /* read to clear */
26030+ ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
26031+ if (ret < 0)
26032+ return ret;
26033+
26034+ /* enable interrupt source */
26035+ ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
26036+ if (ret < 0)
26037+ return ret;
26038+
26039+ ret |= mask;
26040+
26041+ smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
26042+
26043+ return 0;
26044+}
26045+
26046+static int smsc95xx_link_ok_nopm(struct usbnet *dev)
26047+{
26048+ struct mii_if_info *mii = &dev->mii;
26049+ int ret;
26050+
26051+ /* first, a dummy read, needed to latch some MII phys */
26052+ ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
26053+ if (ret < 0)
26054+ return ret;
26055+
26056+ ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
26057+ if (ret < 0)
26058+ return ret;
26059+
26060+ return !!(ret & BMSR_LSTATUS);
26061+}
26062+
26063+static int smsc95xx_enter_suspend0(struct usbnet *dev)
26064+{
26065+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26066+ u32 val;
26067+ int ret;
26068+
26069+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26070+ if (ret < 0)
26071+ return ret;
26072+
26073+ val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
26074+ val |= PM_CTL_SUS_MODE_0;
26075+
26076+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26077+ if (ret < 0)
26078+ return ret;
26079+
26080+ /* clear wol status */
26081+ val &= ~PM_CTL_WUPS_;
26082+ val |= PM_CTL_WUPS_WOL_;
26083+
26084+ /* enable energy detection */
26085+ if (pdata->wolopts & WAKE_PHY)
26086+ val |= PM_CTL_WUPS_ED_;
26087+
26088+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26089+ if (ret < 0)
26090+ return ret;
26091+
26092+ /* read back PM_CTRL */
26093+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26094+ if (ret < 0)
26095+ return ret;
26096+
26097+ pdata->suspend_flags |= SUSPEND_SUSPEND0;
26098+
26099+ return 0;
26100+}
26101+
26102+static int smsc95xx_enter_suspend1(struct usbnet *dev)
26103+{
26104+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26105+ struct mii_if_info *mii = &dev->mii;
26106+ u32 val;
26107+ int ret;
26108+
26109+ /* reconfigure link pulse detection timing for
26110+ * compatibility with non-standard link partners
26111+ */
26112+ if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
26113+ smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_EDPD_CONFIG,
26114+ PHY_EDPD_CONFIG_DEFAULT);
26115+
26116+ /* enable energy detect power-down mode */
26117+ ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS);
26118+ if (ret < 0)
26119+ return ret;
26120+
26121+ ret |= MODE_CTRL_STS_EDPWRDOWN_;
26122+
26123+ smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS, ret);
26124+
26125+ /* enter SUSPEND1 mode */
26126+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26127+ if (ret < 0)
26128+ return ret;
26129+
26130+ val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
26131+ val |= PM_CTL_SUS_MODE_1;
26132+
26133+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26134+ if (ret < 0)
26135+ return ret;
26136+
26137+ /* clear wol status, enable energy detection */
26138+ val &= ~PM_CTL_WUPS_;
26139+ val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);
26140+
26141+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26142+ if (ret < 0)
26143+ return ret;
26144+
26145+ pdata->suspend_flags |= SUSPEND_SUSPEND1;
26146+
26147+ return 0;
26148+}
26149+
26150+static int smsc95xx_enter_suspend2(struct usbnet *dev)
26151+{
26152+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26153+ u32 val;
26154+ int ret;
26155+
26156+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26157+ if (ret < 0)
26158+ return ret;
26159+
26160+ val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
26161+ val |= PM_CTL_SUS_MODE_2;
26162+
26163+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26164+ if (ret < 0)
26165+ return ret;
26166+
26167+ pdata->suspend_flags |= SUSPEND_SUSPEND2;
26168+
26169+ return 0;
26170+}
26171+
26172+static int smsc95xx_enter_suspend3(struct usbnet *dev)
26173+{
26174+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26175+ u32 val;
26176+ int ret;
26177+
26178+ ret = smsc95xx_read_reg_nopm(dev, RX_FIFO_INF, &val);
26179+ if (ret < 0)
26180+ return ret;
26181+
26182+ if (val & 0xFFFF) {
26183+ netdev_info(dev->net, "rx fifo not empty in autosuspend\n");
26184+ return -EBUSY;
26185+ }
26186+
26187+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26188+ if (ret < 0)
26189+ return ret;
26190+
26191+ val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
26192+ val |= PM_CTL_SUS_MODE_3 | PM_CTL_RES_CLR_WKP_STS;
26193+
26194+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26195+ if (ret < 0)
26196+ return ret;
26197+
26198+ /* clear wol status */
26199+ val &= ~PM_CTL_WUPS_;
26200+ val |= PM_CTL_WUPS_WOL_;
26201+
26202+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26203+ if (ret < 0)
26204+ return ret;
26205+
26206+ pdata->suspend_flags |= SUSPEND_SUSPEND3;
26207+
26208+ return 0;
26209+}
26210+
26211+static int smsc95xx_autosuspend(struct usbnet *dev, u32 link_up)
26212+{
26213+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26214+ int ret;
26215+
26216+ if (!netif_running(dev->net)) {
26217+ /* interface is ifconfig down so fully power down hw */
26218+ netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
26219+ return smsc95xx_enter_suspend2(dev);
26220+ }
26221+
26222+ if (!link_up) {
26223+ /* link is down so enter EDPD mode, but only if device can
26224+ * reliably resume from it. This check should be redundant
26225+ * as current FEATURE_REMOTE_WAKEUP parts also support
26226+ * FEATURE_PHY_NLP_CROSSOVER but it's included for clarity */
26227+ if (!(pdata->features & FEATURE_PHY_NLP_CROSSOVER)) {
26228+ netdev_warn(dev->net, "EDPD not supported\n");
26229+ return -EBUSY;
26230+ }
26231+
26232+ netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
26233+
26234+ /* enable PHY wakeup events for if cable is attached */
26235+ ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
26236+ PHY_INT_MASK_ANEG_COMP_);
26237+ if (ret < 0) {
26238+ netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
26239+ return ret;
26240+ }
26241+
26242+ netdev_info(dev->net, "entering SUSPEND1 mode\n");
26243+ return smsc95xx_enter_suspend1(dev);
26244+ }
26245+
26246+ /* enable PHY wakeup events so we remote wakeup if cable is pulled */
26247+ ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
26248+ PHY_INT_MASK_LINK_DOWN_);
26249+ if (ret < 0) {
26250+ netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
26251+ return ret;
26252+ }
26253+
26254+ netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
26255+ return smsc95xx_enter_suspend3(dev);
26256+}
26257+
26258+static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
26259+{
26260+ struct usbnet *dev = usb_get_intfdata(intf);
26261+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26262+ u32 val, link_up;
26263+ int ret;
26264+
26265+ ret = usbnet_suspend(intf, message);
26266+ if (ret < 0) {
26267+ netdev_warn(dev->net, "usbnet_suspend error\n");
26268+ return ret;
26269+ }
26270+
26271+ if (pdata->suspend_flags) {
26272+ netdev_warn(dev->net, "error during last resume\n");
26273+ pdata->suspend_flags = 0;
26274+ }
26275+
26276+ /* determine if link is up using only _nopm functions */
26277+ link_up = smsc95xx_link_ok_nopm(dev);
26278+
26279+ if (message.event == PM_EVENT_AUTO_SUSPEND &&
26280+ (pdata->features & FEATURE_REMOTE_WAKEUP)) {
26281+ ret = smsc95xx_autosuspend(dev, link_up);
26282+ goto done;
26283+ }
26284+
26285+ /* if we get this far we're not autosuspending */
26286+ /* if no wol options set, or if link is down and we're not waking on
26287+ * PHY activity, enter lowest power SUSPEND2 mode
26288+ */
26289+ if (!(pdata->wolopts & SUPPORTED_WAKE) ||
26290+ !(link_up || (pdata->wolopts & WAKE_PHY))) {
26291+ netdev_info(dev->net, "entering SUSPEND2 mode\n");
26292+
26293+ /* disable energy detect (link up) & wake up events */
26294+ ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
26295+ if (ret < 0)
26296+ goto done;
26297+
26298+ val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);
26299+
26300+ ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
26301+ if (ret < 0)
26302+ goto done;
26303+
26304+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26305+ if (ret < 0)
26306+ goto done;
26307+
26308+ val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);
26309+
26310+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26311+ if (ret < 0)
26312+ goto done;
26313+
26314+ ret = smsc95xx_enter_suspend2(dev);
26315+ goto done;
26316+ }
26317+
26318+ if (pdata->wolopts & WAKE_PHY) {
26319+ ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
26320+ (PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_LINK_DOWN_));
26321+ if (ret < 0) {
26322+ netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
26323+ goto done;
26324+ }
26325+
26326+ /* if link is down then configure EDPD and enter SUSPEND1,
26327+ * otherwise enter SUSPEND0 below
26328+ */
26329+ if (!link_up) {
26330+ netdev_info(dev->net, "entering SUSPEND1 mode\n");
26331+ ret = smsc95xx_enter_suspend1(dev);
26332+ goto done;
26333+ }
26334+ }
26335+
26336+ if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
26337+ u32 *filter_mask = kzalloc(sizeof(u32) * 32, GFP_KERNEL);
26338+ u32 command[2];
26339+ u32 offset[2];
26340+ u32 crc[4];
26341+ int wuff_filter_count =
26342+ (pdata->features & FEATURE_8_WAKEUP_FILTERS) ?
26343+ LAN9500A_WUFF_NUM : LAN9500_WUFF_NUM;
26344+ int i, filter = 0;
26345+
26346+ if (!filter_mask) {
26347+ netdev_warn(dev->net, "Unable to allocate filter_mask\n");
26348+ ret = -ENOMEM;
26349+ goto done;
26350+ }
26351+
26352+ memset(command, 0, sizeof(command));
26353+ memset(offset, 0, sizeof(offset));
26354+ memset(crc, 0, sizeof(crc));
26355+
26356+ if (pdata->wolopts & WAKE_BCAST) {
26357+ const u8 bcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
26358+ netdev_info(dev->net, "enabling broadcast detection\n");
26359+ filter_mask[filter * 4] = 0x003F;
26360+ filter_mask[filter * 4 + 1] = 0x00;
26361+ filter_mask[filter * 4 + 2] = 0x00;
26362+ filter_mask[filter * 4 + 3] = 0x00;
26363+ command[filter/4] |= 0x05UL << ((filter % 4) * 8);
26364+ offset[filter/4] |= 0x00 << ((filter % 4) * 8);
26365+ crc[filter/2] |= smsc_crc(bcast, 6, filter);
26366+ filter++;
26367+ }
26368+
26369+ if (pdata->wolopts & WAKE_MCAST) {
26370+ const u8 mcast[] = {0x01, 0x00, 0x5E};
26371+ netdev_info(dev->net, "enabling multicast detection\n");
26372+ filter_mask[filter * 4] = 0x0007;
26373+ filter_mask[filter * 4 + 1] = 0x00;
26374+ filter_mask[filter * 4 + 2] = 0x00;
26375+ filter_mask[filter * 4 + 3] = 0x00;
26376+ command[filter/4] |= 0x09UL << ((filter % 4) * 8);
26377+ offset[filter/4] |= 0x00 << ((filter % 4) * 8);
26378+ crc[filter/2] |= smsc_crc(mcast, 3, filter);
26379+ filter++;
26380+ }
26381+
26382+ if (pdata->wolopts & WAKE_ARP) {
26383+ const u8 arp[] = {0x08, 0x06};
26384+ netdev_info(dev->net, "enabling ARP detection\n");
26385+ filter_mask[filter * 4] = 0x0003;
26386+ filter_mask[filter * 4 + 1] = 0x00;
26387+ filter_mask[filter * 4 + 2] = 0x00;
26388+ filter_mask[filter * 4 + 3] = 0x00;
26389+ command[filter/4] |= 0x05UL << ((filter % 4) * 8);
26390+ offset[filter/4] |= 0x0C << ((filter % 4) * 8);
26391+ crc[filter/2] |= smsc_crc(arp, 2, filter);
26392+ filter++;
26393+ }
26394+
26395+ if (pdata->wolopts & WAKE_UCAST) {
26396+ netdev_info(dev->net, "enabling unicast detection\n");
26397+ filter_mask[filter * 4] = 0x003F;
26398+ filter_mask[filter * 4 + 1] = 0x00;
26399+ filter_mask[filter * 4 + 2] = 0x00;
26400+ filter_mask[filter * 4 + 3] = 0x00;
26401+ command[filter/4] |= 0x01UL << ((filter % 4) * 8);
26402+ offset[filter/4] |= 0x00 << ((filter % 4) * 8);
26403+ crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
26404+ filter++;
26405+ }
26406+
26407+ for (i = 0; i < (wuff_filter_count * 4); i++) {
26408+ ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
26409+ if (ret < 0) {
26410+ kfree(filter_mask);
26411+ goto done;
26412+ }
26413+ }
26414+ kfree(filter_mask);
26415+
26416+ for (i = 0; i < (wuff_filter_count / 4); i++) {
26417+ ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
26418+ if (ret < 0)
26419+ goto done;
26420+ }
26421+
26422+ for (i = 0; i < (wuff_filter_count / 4); i++) {
26423+ ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
26424+ if (ret < 0)
26425+ goto done;
26426+ }
26427+
26428+ for (i = 0; i < (wuff_filter_count / 2); i++) {
26429+ ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
26430+ if (ret < 0)
26431+ goto done;
26432+ }
26433+
26434+ /* clear any pending pattern match packet status */
26435+ ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
26436+ if (ret < 0)
26437+ goto done;
26438+
26439+ val |= WUCSR_WUFR_;
26440+
26441+ ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
26442+ if (ret < 0)
26443+ goto done;
26444+ }
26445+
26446+ if (pdata->wolopts & WAKE_MAGIC) {
26447+ /* clear any pending magic packet status */
26448+ ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
26449+ if (ret < 0)
26450+ goto done;
26451+
26452+ val |= WUCSR_MPR_;
26453+
26454+ ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
26455+ if (ret < 0)
26456+ goto done;
26457+ }
26458+
26459+ /* enable/disable wakeup sources */
26460+ ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
26461+ if (ret < 0)
26462+ goto done;
26463+
26464+ if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
26465+ netdev_info(dev->net, "enabling pattern match wakeup\n");
26466+ val |= WUCSR_WAKE_EN_;
26467+ } else {
26468+ netdev_info(dev->net, "disabling pattern match wakeup\n");
26469+ val &= ~WUCSR_WAKE_EN_;
26470+ }
26471+
26472+ if (pdata->wolopts & WAKE_MAGIC) {
26473+ netdev_info(dev->net, "enabling magic packet wakeup\n");
26474+ val |= WUCSR_MPEN_;
26475+ } else {
26476+ netdev_info(dev->net, "disabling magic packet wakeup\n");
26477+ val &= ~WUCSR_MPEN_;
26478+ }
26479+
26480+ ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
26481+ if (ret < 0)
26482+ goto done;
26483+
26484+ /* enable wol wakeup source */
26485+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26486+ if (ret < 0)
26487+ goto done;
26488+
26489+ val |= PM_CTL_WOL_EN_;
26490+
26491+ /* phy energy detect wakeup source */
26492+ if (pdata->wolopts & WAKE_PHY)
26493+ val |= PM_CTL_ED_EN_;
26494+
26495+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26496+ if (ret < 0)
26497+ goto done;
26498+
26499+ /* enable receiver to enable frame reception */
26500+ smsc95xx_start_rx_path(dev, 1);
26501+
26502+ /* some wol options are enabled, so enter SUSPEND0 */
26503+ netdev_info(dev->net, "entering SUSPEND0 mode\n");
26504+ ret = smsc95xx_enter_suspend0(dev);
26505+
26506+done:
26507+ /*
26508+ * TODO: resume() might need to handle the suspend failure
26509+ * in system sleep
26510+ */
26511+ if (ret && PMSG_IS_AUTO(message))
26512+ usbnet_resume(intf);
26513+ return ret;
26514+}
26515+
26516+static int smsc95xx_resume(struct usb_interface *intf)
26517+{
26518+ struct usbnet *dev = usb_get_intfdata(intf);
26519+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26520+ u8 suspend_flags = pdata->suspend_flags;
26521+ int ret;
26522+ u32 val;
26523+
26524+ BUG_ON(!dev);
26525+
26526+ netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
26527+
26528+ /* do this first to ensure it's cleared even in error case */
26529+ pdata->suspend_flags = 0;
26530+
26531+ if (suspend_flags & SUSPEND_ALLMODES) {
26532+ /* clear wake-up sources */
26533+ ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
26534+ if (ret < 0)
26535+ return ret;
26536+
26537+ val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
26538+
26539+ ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
26540+ if (ret < 0)
26541+ return ret;
26542+
26543+ /* clear wake-up status */
26544+ ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
26545+ if (ret < 0)
26546+ return ret;
26547+
26548+ val &= ~PM_CTL_WOL_EN_;
26549+ val |= PM_CTL_WUPS_;
26550+
26551+ ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
26552+ if (ret < 0)
26553+ return ret;
26554+ }
26555+
26556+ ret = usbnet_resume(intf);
26557+ if (ret < 0)
26558+ netdev_warn(dev->net, "usbnet_resume error\n");
26559+
26560+ return ret;
26561+}
26562+
26563+static int smsc95xx_reset_resume(struct usb_interface *intf)
26564+{
26565+ struct usbnet *dev = usb_get_intfdata(intf);
26566+ int ret;
26567+
26568+ ret = smsc95xx_reset(dev);
26569+ if (ret < 0)
26570+ return ret;
26571+
26572+ return smsc95xx_resume(intf);
26573+}
26574+
26575+static void smsc95xx_rx_csum_offload(struct sk_buff *skb)
26576+{
26577+ skb->csum = *(u16 *)(skb_tail_pointer(skb) - 2);
26578+ skb->ip_summed = CHECKSUM_COMPLETE;
26579+ skb_trim(skb, skb->len - 2);
26580+}
26581+
26582+static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
26583+{
26584+ /* This check is no longer done by usbnet */
26585+ if (skb->len < dev->net->hard_header_len)
26586+ return 0;
26587+
26588+ while (skb->len > 0) {
26589+ u32 header, align_count;
26590+ struct sk_buff *ax_skb;
26591+ unsigned char *packet;
26592+ u16 size;
26593+
26594+ memcpy(&header, skb->data, sizeof(header));
26595+ le32_to_cpus(&header);
26596+ skb_pull(skb, 4 + NET_IP_ALIGN);
26597+ packet = skb->data;
26598+
26599+ /* get the packet length */
26600+ size = (u16)((header & RX_STS_FL_) >> 16);
26601+ align_count = (4 - ((size + NET_IP_ALIGN) % 4)) % 4;
26602+
26603+ if (unlikely(header & RX_STS_ES_)) {
26604+ netif_dbg(dev, rx_err, dev->net,
26605+ "Error header=0x%08x\n", header);
26606+ dev->net->stats.rx_errors++;
26607+ dev->net->stats.rx_dropped++;
26608+
26609+ if (header & RX_STS_CRC_) {
26610+ dev->net->stats.rx_crc_errors++;
26611+ } else {
26612+ if (header & (RX_STS_TL_ | RX_STS_RF_))
26613+ dev->net->stats.rx_frame_errors++;
26614+
26615+ if ((header & RX_STS_LE_) &&
26616+ (!(header & RX_STS_FT_)))
26617+ dev->net->stats.rx_length_errors++;
26618+ }
26619+ } else {
26620+ /* ETH_FRAME_LEN + 4(CRC) + 2(COE) + 4(Vlan) */
26621+ if (unlikely(size > (ETH_FRAME_LEN + 12))) {
26622+ netif_dbg(dev, rx_err, dev->net,
26623+ "size err header=0x%08x\n", header);
26624+ return 0;
26625+ }
26626+
26627+ /* last frame in this batch */
26628+ if (skb->len == size) {
26629+ if (dev->net->features & NETIF_F_RXCSUM)
26630+ smsc95xx_rx_csum_offload(skb);
26631+ skb_trim(skb, skb->len - 4); /* remove fcs */
26632+ skb->truesize = size + sizeof(struct sk_buff);
26633+
26634+ return 1;
26635+ }
26636+
26637+ ax_skb = skb_clone(skb, GFP_ATOMIC);
26638+ if (unlikely(!ax_skb)) {
26639+ netdev_warn(dev->net, "Error allocating skb\n");
26640+ return 0;
26641+ }
26642+
26643+ ax_skb->len = size;
26644+ ax_skb->data = packet;
26645+ skb_set_tail_pointer(ax_skb, size);
26646+
26647+ if (dev->net->features & NETIF_F_RXCSUM)
26648+ smsc95xx_rx_csum_offload(ax_skb);
26649+ skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
26650+ ax_skb->truesize = size + sizeof(struct sk_buff);
26651+
26652+ usbnet_skb_return(dev, ax_skb);
26653+ }
26654+
26655+ skb_pull(skb, size);
26656+
26657+ /* padding bytes before the next frame starts */
26658+ if (skb->len)
26659+ skb_pull(skb, align_count);
26660+ }
26661+
26662+ if (unlikely(skb->len < 0)) {
26663+ netdev_warn(dev->net, "invalid rx length<0 %d\n", skb->len);
26664+ return 0;
26665+ }
26666+
26667+ return 1;
26668+}
26669+
26670+static u32 smsc95xx_calc_csum_preamble(struct sk_buff *skb)
26671+{
26672+ u16 low_16 = (u16)skb_checksum_start_offset(skb);
26673+ u16 high_16 = low_16 + skb->csum_offset;
26674+ return (high_16 << 16) | low_16;
26675+}
26676+
26677+static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev,
26678+ struct sk_buff *skb, gfp_t flags)
26679+{
26680+ bool csum = skb->ip_summed == CHECKSUM_PARTIAL;
26681+ int overhead = csum ? SMSC95XX_TX_OVERHEAD_CSUM : SMSC95XX_TX_OVERHEAD;
26682+ u32 tx_cmd_a, tx_cmd_b;
26683+
26684+ /* We do not advertise SG, so skbs should be already linearized */
26685+ BUG_ON(skb_shinfo(skb)->nr_frags);
26686+
26687+ if (skb_headroom(skb) < overhead) {
26688+ struct sk_buff *skb2 = skb_copy_expand(skb,
26689+ overhead, 0, flags);
26690+ dev_kfree_skb_any(skb);
26691+ skb = skb2;
26692+ if (!skb)
26693+ return NULL;
26694+ }
26695+
26696+ if (csum) {
26697+ if (skb->len <= 45) {
26698+ /* workaround - hardware tx checksum does not work
26699+ * properly with extremely small packets */
26700+ long csstart = skb_checksum_start_offset(skb);
26701+ __wsum calc = csum_partial(skb->data + csstart,
26702+ skb->len - csstart, 0);
26703+ *((__sum16 *)(skb->data + csstart
26704+ + skb->csum_offset)) = csum_fold(calc);
26705+
26706+ csum = false;
26707+ } else {
26708+ u32 csum_preamble = smsc95xx_calc_csum_preamble(skb);
26709+ skb_push(skb, 4);
26710+ cpu_to_le32s(&csum_preamble);
26711+ memcpy(skb->data, &csum_preamble, 4);
26712+ }
26713+ }
26714+
26715+ skb_push(skb, 4);
26716+ tx_cmd_b = (u32)(skb->len - 4);
26717+ if (csum)
26718+ tx_cmd_b |= TX_CMD_B_CSUM_ENABLE;
26719+ cpu_to_le32s(&tx_cmd_b);
26720+ memcpy(skb->data, &tx_cmd_b, 4);
26721+
26722+ skb_push(skb, 4);
26723+ tx_cmd_a = (u32)(skb->len - 8) | TX_CMD_A_FIRST_SEG_ |
26724+ TX_CMD_A_LAST_SEG_;
26725+ cpu_to_le32s(&tx_cmd_a);
26726+ memcpy(skb->data, &tx_cmd_a, 4);
26727+
26728+ return skb;
26729+}
26730+
26731+static int smsc95xx_manage_power(struct usbnet *dev, int on)
26732+{
26733+ struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
26734+
26735+ dev->intf->needs_remote_wakeup = on;
26736+
26737+ if (pdata->features & FEATURE_REMOTE_WAKEUP)
26738+ return 0;
26739+
26740+ /* this chip revision isn't capable of remote wakeup */
26741+ netdev_info(dev->net, "hardware isn't capable of remote wakeup\n");
26742+
26743+ if (on)
26744+ usb_autopm_get_interface_no_resume(dev->intf);
26745+ else
26746+ usb_autopm_put_interface(dev->intf);
26747+
26748+ return 0;
26749+}
26750+
26751+static const struct driver_info smsc95xx_info = {
26752+ .description = "smsc95xx USB 2.0 Ethernet",
26753+ .bind = smsc95xx_bind,
26754+ .unbind = smsc95xx_unbind,
26755+ .link_reset = smsc95xx_link_reset,
26756+ .reset = smsc95xx_reset,
26757+ .rx_fixup = smsc95xx_rx_fixup,
26758+ .tx_fixup = smsc95xx_tx_fixup,
26759+ .status = smsc95xx_status,
26760+ .manage_power = smsc95xx_manage_power,
26761+ .flags = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
26762+};
26763+
26764+static const struct usb_device_id products[] = {
26765+ {
26766+ /* SMSC9500 USB Ethernet Device */
26767+ USB_DEVICE(0x0424, 0x9500),
26768+ .driver_info = (unsigned long) &smsc95xx_info,
26769+ },
26770+ {
26771+ /* SMSC9505 USB Ethernet Device */
26772+ USB_DEVICE(0x0424, 0x9505),
26773+ .driver_info = (unsigned long) &smsc95xx_info,
26774+ },
26775+ {
26776+ /* SMSC9500A USB Ethernet Device */
26777+ USB_DEVICE(0x0424, 0x9E00),
26778+ .driver_info = (unsigned long) &smsc95xx_info,
26779+ },
26780+ {
26781+ /* SMSC9505A USB Ethernet Device */
26782+ USB_DEVICE(0x0424, 0x9E01),
26783+ .driver_info = (unsigned long) &smsc95xx_info,
26784+ },
26785+ {
26786+ /* SMSC9512/9514 USB Hub & Ethernet Device */
26787+ USB_DEVICE(0x0424, 0xec00),
26788+ .driver_info = (unsigned long) &smsc95xx_info,
26789+ },
26790+ {
26791+ /* SMSC9500 USB Ethernet Device (SAL10) */
26792+ USB_DEVICE(0x0424, 0x9900),
26793+ .driver_info = (unsigned long) &smsc95xx_info,
26794+ },
26795+ {
26796+ /* SMSC9505 USB Ethernet Device (SAL10) */
26797+ USB_DEVICE(0x0424, 0x9901),
26798+ .driver_info = (unsigned long) &smsc95xx_info,
26799+ },
26800+ {
26801+ /* SMSC9500A USB Ethernet Device (SAL10) */
26802+ USB_DEVICE(0x0424, 0x9902),
26803+ .driver_info = (unsigned long) &smsc95xx_info,
26804+ },
26805+ {
26806+ /* SMSC9505A USB Ethernet Device (SAL10) */
26807+ USB_DEVICE(0x0424, 0x9903),
26808+ .driver_info = (unsigned long) &smsc95xx_info,
26809+ },
26810+ {
26811+ /* SMSC9512/9514 USB Hub & Ethernet Device (SAL10) */
26812+ USB_DEVICE(0x0424, 0x9904),
26813+ .driver_info = (unsigned long) &smsc95xx_info,
26814+ },
26815+ {
26816+ /* SMSC9500A USB Ethernet Device (HAL) */
26817+ USB_DEVICE(0x0424, 0x9905),
26818+ .driver_info = (unsigned long) &smsc95xx_info,
26819+ },
26820+ {
26821+ /* SMSC9505A USB Ethernet Device (HAL) */
26822+ USB_DEVICE(0x0424, 0x9906),
26823+ .driver_info = (unsigned long) &smsc95xx_info,
26824+ },
26825+ {
26826+ /* SMSC9500 USB Ethernet Device (Alternate ID) */
26827+ USB_DEVICE(0x0424, 0x9907),
26828+ .driver_info = (unsigned long) &smsc95xx_info,
26829+ },
26830+ {
26831+ /* SMSC9500A USB Ethernet Device (Alternate ID) */
26832+ USB_DEVICE(0x0424, 0x9908),
26833+ .driver_info = (unsigned long) &smsc95xx_info,
26834+ },
26835+ {
26836+ /* SMSC9512/9514 USB Hub & Ethernet Device (Alternate ID) */
26837+ USB_DEVICE(0x0424, 0x9909),
26838+ .driver_info = (unsigned long) &smsc95xx_info,
26839+ },
26840+ {
26841+ /* SMSC LAN9530 USB Ethernet Device */
26842+ USB_DEVICE(0x0424, 0x9530),
26843+ .driver_info = (unsigned long) &smsc95xx_info,
26844+ },
26845+ {
26846+ /* SMSC LAN9730 USB Ethernet Device */
26847+ USB_DEVICE(0x0424, 0x9730),
26848+ .driver_info = (unsigned long) &smsc95xx_info,
26849+ },
26850+ {
26851+ /* SMSC LAN89530 USB Ethernet Device */
26852+ USB_DEVICE(0x0424, 0x9E08),
26853+ .driver_info = (unsigned long) &smsc95xx_info,
26854+ },
26855+ { }, /* END */
26856+};
26857+MODULE_DEVICE_TABLE(usb, products);
26858+
26859+static struct usb_driver smsc95xx_driver = {
26860+ .name = "smsc95xx",
26861+ .id_table = products,
26862+ .probe = usbnet_probe,
26863+ .suspend = smsc95xx_suspend,
26864+ .resume = smsc95xx_resume,
26865+ .reset_resume = smsc95xx_reset_resume,
26866+ .disconnect = usbnet_disconnect,
26867+ .disable_hub_initiated_lpm = 1,
26868+ .supports_autosuspend = 1,
26869+};
26870+
26871+module_usb_driver(smsc95xx_driver);
26872+
26873+MODULE_AUTHOR("Nancy Lin");
26874+MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
26875+MODULE_DESCRIPTION("SMSC95XX USB 2.0 Ethernet Devices");
26876+MODULE_LICENSE("GPL");
26877diff -Naur backports-3.18.1-1.org/drivers/net/usb/smsc95xx.h backports-3.18.1-1/drivers/net/usb/smsc95xx.h
26878--- backports-3.18.1-1.org/drivers/net/usb/smsc95xx.h 1970-01-01 01:00:00.000000000 +0100
26879+++ backports-3.18.1-1/drivers/net/usb/smsc95xx.h 2014-12-16 18:39:45.000000000 +0100
26880@@ -0,0 +1,290 @@
26881+ /***************************************************************************
26882+ *
26883+ * Copyright (C) 2007-2008 SMSC
26884+ *
26885+ * This program is free software; you can redistribute it and/or
26886+ * modify it under the terms of the GNU General Public License
26887+ * as published by the Free Software Foundation; either version 2
26888+ * of the License, or (at your option) any later version.
26889+ *
26890+ * This program is distributed in the hope that it will be useful,
26891+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
26892+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26893+ * GNU General Public License for more details.
26894+ *
26895+ * You should have received a copy of the GNU General Public License
26896+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
26897+ *
26898+ *****************************************************************************/
26899+
26900+#ifndef _SMSC95XX_H
26901+#define _SMSC95XX_H
26902+
26903+/* Tx command words */
26904+#define TX_CMD_A_DATA_OFFSET_ (0x001F0000)
26905+#define TX_CMD_A_FIRST_SEG_ (0x00002000)
26906+#define TX_CMD_A_LAST_SEG_ (0x00001000)
26907+#define TX_CMD_A_BUF_SIZE_ (0x000007FF)
26908+
26909+#define TX_CMD_B_CSUM_ENABLE (0x00004000)
26910+#define TX_CMD_B_ADD_CRC_DISABLE_ (0x00002000)
26911+#define TX_CMD_B_DISABLE_PADDING_ (0x00001000)
26912+#define TX_CMD_B_PKT_BYTE_LENGTH_ (0x000007FF)
26913+
26914+/* Rx status word */
26915+#define RX_STS_FF_ (0x40000000) /* Filter Fail */
26916+#define RX_STS_FL_ (0x3FFF0000) /* Frame Length */
26917+#define RX_STS_ES_ (0x00008000) /* Error Summary */
26918+#define RX_STS_BF_ (0x00002000) /* Broadcast Frame */
26919+#define RX_STS_LE_ (0x00001000) /* Length Error */
26920+#define RX_STS_RF_ (0x00000800) /* Runt Frame */
26921+#define RX_STS_MF_ (0x00000400) /* Multicast Frame */
26922+#define RX_STS_TL_ (0x00000080) /* Frame too long */
26923+#define RX_STS_CS_ (0x00000040) /* Collision Seen */
26924+#define RX_STS_FT_ (0x00000020) /* Frame Type */
26925+#define RX_STS_RW_ (0x00000010) /* Receive Watchdog */
26926+#define RX_STS_ME_ (0x00000008) /* Mii Error */
26927+#define RX_STS_DB_ (0x00000004) /* Dribbling */
26928+#define RX_STS_CRC_ (0x00000002) /* CRC Error */
26929+
26930+/* SCSRs */
26931+#define ID_REV (0x00)
26932+#define ID_REV_CHIP_ID_MASK_ (0xFFFF0000)
26933+#define ID_REV_CHIP_REV_MASK_ (0x0000FFFF)
26934+#define ID_REV_CHIP_ID_9500_ (0x9500)
26935+#define ID_REV_CHIP_ID_9500A_ (0x9E00)
26936+#define ID_REV_CHIP_ID_9512_ (0xEC00)
26937+#define ID_REV_CHIP_ID_9530_ (0x9530)
26938+#define ID_REV_CHIP_ID_89530_ (0x9E08)
26939+#define ID_REV_CHIP_ID_9730_ (0x9730)
26940+
26941+#define INT_STS (0x08)
26942+#define INT_STS_TX_STOP_ (0x00020000)
26943+#define INT_STS_RX_STOP_ (0x00010000)
26944+#define INT_STS_PHY_INT_ (0x00008000)
26945+#define INT_STS_TXE_ (0x00004000)
26946+#define INT_STS_TDFU_ (0x00002000)
26947+#define INT_STS_TDFO_ (0x00001000)
26948+#define INT_STS_RXDF_ (0x00000800)
26949+#define INT_STS_GPIOS_ (0x000007FF)
26950+#define INT_STS_CLEAR_ALL_ (0xFFFFFFFF)
26951+
26952+#define RX_CFG (0x0C)
26953+#define RX_FIFO_FLUSH_ (0x00000001)
26954+
26955+#define TX_CFG (0x10)
26956+#define TX_CFG_ON_ (0x00000004)
26957+#define TX_CFG_STOP_ (0x00000002)
26958+#define TX_CFG_FIFO_FLUSH_ (0x00000001)
26959+
26960+#define HW_CFG (0x14)
26961+#define HW_CFG_BIR_ (0x00001000)
26962+#define HW_CFG_LEDB_ (0x00000800)
26963+#define HW_CFG_RXDOFF_ (0x00000600)
26964+#define HW_CFG_DRP_ (0x00000040)
26965+#define HW_CFG_MEF_ (0x00000020)
26966+#define HW_CFG_LRST_ (0x00000008)
26967+#define HW_CFG_PSEL_ (0x00000004)
26968+#define HW_CFG_BCE_ (0x00000002)
26969+#define HW_CFG_SRST_ (0x00000001)
26970+
26971+#define RX_FIFO_INF (0x18)
26972+
26973+#define PM_CTRL (0x20)
26974+#define PM_CTL_RES_CLR_WKP_STS (0x00000200)
26975+#define PM_CTL_DEV_RDY_ (0x00000080)
26976+#define PM_CTL_SUS_MODE_ (0x00000060)
26977+#define PM_CTL_SUS_MODE_0 (0x00000000)
26978+#define PM_CTL_SUS_MODE_1 (0x00000020)
26979+#define PM_CTL_SUS_MODE_2 (0x00000040)
26980+#define PM_CTL_SUS_MODE_3 (0x00000060)
26981+#define PM_CTL_PHY_RST_ (0x00000010)
26982+#define PM_CTL_WOL_EN_ (0x00000008)
26983+#define PM_CTL_ED_EN_ (0x00000004)
26984+#define PM_CTL_WUPS_ (0x00000003)
26985+#define PM_CTL_WUPS_NO_ (0x00000000)
26986+#define PM_CTL_WUPS_ED_ (0x00000001)
26987+#define PM_CTL_WUPS_WOL_ (0x00000002)
26988+#define PM_CTL_WUPS_MULTI_ (0x00000003)
26989+
26990+#define LED_GPIO_CFG (0x24)
26991+#define LED_GPIO_CFG_SPD_LED (0x01000000)
26992+#define LED_GPIO_CFG_LNK_LED (0x00100000)
26993+#define LED_GPIO_CFG_FDX_LED (0x00010000)
26994+
26995+#define GPIO_CFG (0x28)
26996+
26997+#define AFC_CFG (0x2C)
26998+
26999+/* Hi watermark = 15.5Kb (~10 mtu pkts) */
27000+/* low watermark = 3k (~2 mtu pkts) */
27001+/* backpressure duration = ~ 350us */
27002+/* Apply FC on any frame. */
27003+#define AFC_CFG_DEFAULT (0x00F830A1)
27004+
27005+#define E2P_CMD (0x30)
27006+#define E2P_CMD_BUSY_ (0x80000000)
27007+#define E2P_CMD_MASK_ (0x70000000)
27008+#define E2P_CMD_READ_ (0x00000000)
27009+#define E2P_CMD_EWDS_ (0x10000000)
27010+#define E2P_CMD_EWEN_ (0x20000000)
27011+#define E2P_CMD_WRITE_ (0x30000000)
27012+#define E2P_CMD_WRAL_ (0x40000000)
27013+#define E2P_CMD_ERASE_ (0x50000000)
27014+#define E2P_CMD_ERAL_ (0x60000000)
27015+#define E2P_CMD_RELOAD_ (0x70000000)
27016+#define E2P_CMD_TIMEOUT_ (0x00000400)
27017+#define E2P_CMD_LOADED_ (0x00000200)
27018+#define E2P_CMD_ADDR_ (0x000001FF)
27019+
27020+#define MAX_EEPROM_SIZE (512)
27021+
27022+#define E2P_DATA (0x34)
27023+#define E2P_DATA_MASK_ (0x000000FF)
27024+
27025+#define BURST_CAP (0x38)
27026+
27027+#define GPIO_WAKE (0x64)
27028+
27029+#define INT_EP_CTL (0x68)
27030+#define INT_EP_CTL_INTEP_ (0x80000000)
27031+#define INT_EP_CTL_MACRTO_ (0x00080000)
27032+#define INT_EP_CTL_TX_STOP_ (0x00020000)
27033+#define INT_EP_CTL_RX_STOP_ (0x00010000)
27034+#define INT_EP_CTL_PHY_INT_ (0x00008000)
27035+#define INT_EP_CTL_TXE_ (0x00004000)
27036+#define INT_EP_CTL_TDFU_ (0x00002000)
27037+#define INT_EP_CTL_TDFO_ (0x00001000)
27038+#define INT_EP_CTL_RXDF_ (0x00000800)
27039+#define INT_EP_CTL_GPIOS_ (0x000007FF)
27040+
27041+#define BULK_IN_DLY (0x6C)
27042+
27043+/* MAC CSRs */
27044+#define MAC_CR (0x100)
27045+#define MAC_CR_RXALL_ (0x80000000)
27046+#define MAC_CR_RCVOWN_ (0x00800000)
27047+#define MAC_CR_LOOPBK_ (0x00200000)
27048+#define MAC_CR_FDPX_ (0x00100000)
27049+#define MAC_CR_MCPAS_ (0x00080000)
27050+#define MAC_CR_PRMS_ (0x00040000)
27051+#define MAC_CR_INVFILT_ (0x00020000)
27052+#define MAC_CR_PASSBAD_ (0x00010000)
27053+#define MAC_CR_HFILT_ (0x00008000)
27054+#define MAC_CR_HPFILT_ (0x00002000)
27055+#define MAC_CR_LCOLL_ (0x00001000)
27056+#define MAC_CR_BCAST_ (0x00000800)
27057+#define MAC_CR_DISRTY_ (0x00000400)
27058+#define MAC_CR_PADSTR_ (0x00000100)
27059+#define MAC_CR_BOLMT_MASK (0x000000C0)
27060+#define MAC_CR_DFCHK_ (0x00000020)
27061+#define MAC_CR_TXEN_ (0x00000008)
27062+#define MAC_CR_RXEN_ (0x00000004)
27063+
27064+#define ADDRH (0x104)
27065+
27066+#define ADDRL (0x108)
27067+
27068+#define HASHH (0x10C)
27069+
27070+#define HASHL (0x110)
27071+
27072+#define MII_ADDR (0x114)
27073+#define MII_WRITE_ (0x02)
27074+#define MII_BUSY_ (0x01)
27075+#define MII_READ_ (0x00) /* ~of MII Write bit */
27076+
27077+#define MII_DATA (0x118)
27078+
27079+#define FLOW (0x11C)
27080+#define FLOW_FCPT_ (0xFFFF0000)
27081+#define FLOW_FCPASS_ (0x00000004)
27082+#define FLOW_FCEN_ (0x00000002)
27083+#define FLOW_FCBSY_ (0x00000001)
27084+
27085+#define VLAN1 (0x120)
27086+
27087+#define VLAN2 (0x124)
27088+
27089+#define WUFF (0x128)
27090+#define LAN9500_WUFF_NUM (4)
27091+#define LAN9500A_WUFF_NUM (8)
27092+
27093+#define WUCSR (0x12C)
27094+#define WUCSR_WFF_PTR_RST_ (0x80000000)
27095+#define WUCSR_GUE_ (0x00000200)
27096+#define WUCSR_WUFR_ (0x00000040)
27097+#define WUCSR_MPR_ (0x00000020)
27098+#define WUCSR_WAKE_EN_ (0x00000004)
27099+#define WUCSR_MPEN_ (0x00000002)
27100+
27101+#define COE_CR (0x130)
27102+#define Tx_COE_EN_ (0x00010000)
27103+#define Rx_COE_MODE_ (0x00000002)
27104+#define Rx_COE_EN_ (0x00000001)
27105+
27106+/* Vendor-specific PHY Definitions */
27107+
27108+/* EDPD NLP / crossover time configuration (LAN9500A only) */
27109+#define PHY_EDPD_CONFIG (16)
27110+#define PHY_EDPD_CONFIG_TX_NLP_EN_ ((u16)0x8000)
27111+#define PHY_EDPD_CONFIG_TX_NLP_1000_ ((u16)0x0000)
27112+#define PHY_EDPD_CONFIG_TX_NLP_768_ ((u16)0x2000)
27113+#define PHY_EDPD_CONFIG_TX_NLP_512_ ((u16)0x4000)
27114+#define PHY_EDPD_CONFIG_TX_NLP_256_ ((u16)0x6000)
27115+#define PHY_EDPD_CONFIG_RX_1_NLP_ ((u16)0x1000)
27116+#define PHY_EDPD_CONFIG_RX_NLP_64_ ((u16)0x0000)
27117+#define PHY_EDPD_CONFIG_RX_NLP_256_ ((u16)0x0400)
27118+#define PHY_EDPD_CONFIG_RX_NLP_512_ ((u16)0x0800)
27119+#define PHY_EDPD_CONFIG_RX_NLP_1000_ ((u16)0x0C00)
27120+#define PHY_EDPD_CONFIG_EXT_CROSSOVER_ ((u16)0x0001)
27121+#define PHY_EDPD_CONFIG_DEFAULT (PHY_EDPD_CONFIG_TX_NLP_EN_ | \
27122+ PHY_EDPD_CONFIG_TX_NLP_768_ | \
27123+ PHY_EDPD_CONFIG_RX_1_NLP_)
27124+
27125+/* Mode Control/Status Register */
27126+#define PHY_MODE_CTRL_STS (17)
27127+#define MODE_CTRL_STS_EDPWRDOWN_ ((u16)0x2000)
27128+#define MODE_CTRL_STS_ENERGYON_ ((u16)0x0002)
27129+
27130+#define SPECIAL_CTRL_STS (27)
27131+#define SPECIAL_CTRL_STS_OVRRD_AMDIX_ ((u16)0x8000)
27132+#define SPECIAL_CTRL_STS_AMDIX_ENABLE_ ((u16)0x4000)
27133+#define SPECIAL_CTRL_STS_AMDIX_STATE_ ((u16)0x2000)
27134+
27135+#define PHY_INT_SRC (29)
27136+#define PHY_INT_SRC_ENERGY_ON_ ((u16)0x0080)
27137+#define PHY_INT_SRC_ANEG_COMP_ ((u16)0x0040)
27138+#define PHY_INT_SRC_REMOTE_FAULT_ ((u16)0x0020)
27139+#define PHY_INT_SRC_LINK_DOWN_ ((u16)0x0010)
27140+
27141+#define PHY_INT_MASK (30)
27142+#define PHY_INT_MASK_ENERGY_ON_ ((u16)0x0080)
27143+#define PHY_INT_MASK_ANEG_COMP_ ((u16)0x0040)
27144+#define PHY_INT_MASK_REMOTE_FAULT_ ((u16)0x0020)
27145+#define PHY_INT_MASK_LINK_DOWN_ ((u16)0x0010)
27146+#define PHY_INT_MASK_DEFAULT_ (PHY_INT_MASK_ANEG_COMP_ | \
27147+ PHY_INT_MASK_LINK_DOWN_)
27148+
27149+#define PHY_SPECIAL (31)
27150+#define PHY_SPECIAL_SPD_ ((u16)0x001C)
27151+#define PHY_SPECIAL_SPD_10HALF_ ((u16)0x0004)
27152+#define PHY_SPECIAL_SPD_10FULL_ ((u16)0x0014)
27153+#define PHY_SPECIAL_SPD_100HALF_ ((u16)0x0008)
27154+#define PHY_SPECIAL_SPD_100FULL_ ((u16)0x0018)
27155+
27156+/* USB Vendor Requests */
27157+#define USB_VENDOR_REQUEST_WRITE_REGISTER 0xA0
27158+#define USB_VENDOR_REQUEST_READ_REGISTER 0xA1
27159+#define USB_VENDOR_REQUEST_GET_STATS 0xA2
27160+
27161+/* Interrupt Endpoint status word bitfields */
27162+#define INT_ENP_TX_STOP_ ((u32)BIT(17))
27163+#define INT_ENP_RX_STOP_ ((u32)BIT(16))
27164+#define INT_ENP_PHY_INT_ ((u32)BIT(15))
27165+#define INT_ENP_TXE_ ((u32)BIT(14))
27166+#define INT_ENP_TDFU_ ((u32)BIT(13))
27167+#define INT_ENP_TDFO_ ((u32)BIT(12))
27168+#define INT_ENP_RXDF_ ((u32)BIT(11))
27169+
27170+#endif /* _SMSC95XX_H */
27171diff -Naur backports-3.18.1-1.org/drivers/net/usb/sr9700.c backports-3.18.1-1/drivers/net/usb/sr9700.c
27172--- backports-3.18.1-1.org/drivers/net/usb/sr9700.c 1970-01-01 01:00:00.000000000 +0100
27173+++ backports-3.18.1-1/drivers/net/usb/sr9700.c 2014-12-16 18:39:45.000000000 +0100
27174@@ -0,0 +1,559 @@
27175+/*
27176+ * CoreChip-sz SR9700 one chip USB 1.1 Ethernet Devices
27177+ *
27178+ * Author : Liu Junliang <liujunliang_ljl@163.com>
27179+ *
27180+ * Based on dm9601.c
27181+ *
27182+ * This file is licensed under the terms of the GNU General Public License
27183+ * version 2. This program is licensed "as is" without any warranty of any
27184+ * kind, whether express or implied.
27185+ */
27186+
27187+#include <linux/module.h>
27188+#include <linux/sched.h>
27189+#include <linux/stddef.h>
27190+#include <linux/netdevice.h>
27191+#include <linux/etherdevice.h>
27192+#include <linux/ethtool.h>
27193+#include <linux/mii.h>
27194+#include <linux/usb.h>
27195+#include <linux/crc32.h>
27196+#include <linux/usb/usbnet.h>
27197+
27198+#include "sr9700.h"
27199+
27200+static int sr_read(struct usbnet *dev, u8 reg, u16 length, void *data)
27201+{
27202+ int err;
27203+
27204+ err = usbnet_read_cmd(dev, SR_RD_REGS, SR_REQ_RD_REG, 0, reg, data,
27205+ length);
27206+ if ((err != length) && (err >= 0))
27207+ err = -EINVAL;
27208+ return err;
27209+}
27210+
27211+static int sr_write(struct usbnet *dev, u8 reg, u16 length, void *data)
27212+{
27213+ int err;
27214+
27215+ err = usbnet_write_cmd(dev, SR_WR_REGS, SR_REQ_WR_REG, 0, reg, data,
27216+ length);
27217+ if ((err >= 0) && (err < length))
27218+ err = -EINVAL;
27219+ return err;
27220+}
27221+
27222+static int sr_read_reg(struct usbnet *dev, u8 reg, u8 *value)
27223+{
27224+ return sr_read(dev, reg, 1, value);
27225+}
27226+
27227+static int sr_write_reg(struct usbnet *dev, u8 reg, u8 value)
27228+{
27229+ return usbnet_write_cmd(dev, SR_WR_REGS, SR_REQ_WR_REG,
27230+ value, reg, NULL, 0);
27231+}
27232+
27233+static void sr_write_async(struct usbnet *dev, u8 reg, u16 length, void *data)
27234+{
27235+ usbnet_write_cmd_async(dev, SR_WR_REGS, SR_REQ_WR_REG,
27236+ 0, reg, data, length);
27237+}
27238+
27239+static void sr_write_reg_async(struct usbnet *dev, u8 reg, u8 value)
27240+{
27241+ usbnet_write_cmd_async(dev, SR_WR_REGS, SR_REQ_WR_REG,
27242+ value, reg, NULL, 0);
27243+}
27244+
27245+static int wait_phy_eeprom_ready(struct usbnet *dev, int phy)
27246+{
27247+ int i;
27248+
27249+ for (i = 0; i < SR_SHARE_TIMEOUT; i++) {
27250+ u8 tmp = 0;
27251+ int ret;
27252+
27253+ udelay(1);
27254+ ret = sr_read_reg(dev, EPCR, &tmp);
27255+ if (ret < 0)
27256+ return ret;
27257+
27258+ /* ready */
27259+ if (!(tmp & EPCR_ERRE))
27260+ return 0;
27261+ }
27262+
27263+ netdev_err(dev->net, "%s write timed out!\n", phy ? "phy" : "eeprom");
27264+
27265+ return -EIO;
27266+}
27267+
27268+static int sr_share_read_word(struct usbnet *dev, int phy, u8 reg,
27269+ __le16 *value)
27270+{
27271+ int ret;
27272+
27273+ mutex_lock(&dev->phy_mutex);
27274+
27275+ sr_write_reg(dev, EPAR, phy ? (reg | EPAR_PHY_ADR) : reg);
27276+ sr_write_reg(dev, EPCR, phy ? (EPCR_EPOS | EPCR_ERPRR) : EPCR_ERPRR);
27277+
27278+ ret = wait_phy_eeprom_ready(dev, phy);
27279+ if (ret < 0)
27280+ goto out_unlock;
27281+
27282+ sr_write_reg(dev, EPCR, 0x0);
27283+ ret = sr_read(dev, EPDR, 2, value);
27284+
27285+ netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d\n",
27286+ phy, reg, *value, ret);
27287+
27288+out_unlock:
27289+ mutex_unlock(&dev->phy_mutex);
27290+ return ret;
27291+}
27292+
27293+static int sr_share_write_word(struct usbnet *dev, int phy, u8 reg,
27294+ __le16 value)
27295+{
27296+ int ret;
27297+
27298+ mutex_lock(&dev->phy_mutex);
27299+
27300+ ret = sr_write(dev, EPDR, 2, &value);
27301+ if (ret < 0)
27302+ goto out_unlock;
27303+
27304+ sr_write_reg(dev, EPAR, phy ? (reg | EPAR_PHY_ADR) : reg);
27305+ sr_write_reg(dev, EPCR, phy ? (EPCR_WEP | EPCR_EPOS | EPCR_ERPRW) :
27306+ (EPCR_WEP | EPCR_ERPRW));
27307+
27308+ ret = wait_phy_eeprom_ready(dev, phy);
27309+ if (ret < 0)
27310+ goto out_unlock;
27311+
27312+ sr_write_reg(dev, EPCR, 0x0);
27313+
27314+out_unlock:
27315+ mutex_unlock(&dev->phy_mutex);
27316+ return ret;
27317+}
27318+
27319+static int sr_read_eeprom_word(struct usbnet *dev, u8 offset, void *value)
27320+{
27321+ return sr_share_read_word(dev, 0, offset, value);
27322+}
27323+
27324+static int sr9700_get_eeprom_len(struct net_device *netdev)
27325+{
27326+ return SR_EEPROM_LEN;
27327+}
27328+
27329+static int sr9700_get_eeprom(struct net_device *netdev,
27330+ struct ethtool_eeprom *eeprom, u8 *data)
27331+{
27332+ struct usbnet *dev = netdev_priv(netdev);
27333+ __le16 *buf = (__le16 *)data;
27334+ int ret = 0;
27335+ int i;
27336+
27337+ /* access is 16bit */
27338+ if ((eeprom->offset & 0x01) || (eeprom->len & 0x01))
27339+ return -EINVAL;
27340+
27341+ for (i = 0; i < eeprom->len / 2; i++) {
27342+ ret = sr_read_eeprom_word(dev, eeprom->offset / 2 + i, buf + i);
27343+ if (ret < 0)
27344+ break;
27345+ }
27346+
27347+ return ret;
27348+}
27349+
27350+static int sr_mdio_read(struct net_device *netdev, int phy_id, int loc)
27351+{
27352+ struct usbnet *dev = netdev_priv(netdev);
27353+ __le16 res;
27354+ int rc = 0;
27355+
27356+ if (phy_id) {
27357+ netdev_dbg(netdev, "Only internal phy supported\n");
27358+ return 0;
27359+ }
27360+
27361+ /* Access NSR_LINKST bit for link status instead of MII_BMSR */
27362+ if (loc == MII_BMSR) {
27363+ u8 value;
27364+
27365+ sr_read_reg(dev, NSR, &value);
27366+ if (value & NSR_LINKST)
27367+ rc = 1;
27368+ }
27369+ sr_share_read_word(dev, 1, loc, &res);
27370+ if (rc == 1)
27371+ res = le16_to_cpu(res) | BMSR_LSTATUS;
27372+ else
27373+ res = le16_to_cpu(res) & ~BMSR_LSTATUS;
27374+
27375+ netdev_dbg(netdev, "sr_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
27376+ phy_id, loc, res);
27377+
27378+ return res;
27379+}
27380+
27381+static void sr_mdio_write(struct net_device *netdev, int phy_id, int loc,
27382+ int val)
27383+{
27384+ struct usbnet *dev = netdev_priv(netdev);
27385+ __le16 res = cpu_to_le16(val);
27386+
27387+ if (phy_id) {
27388+ netdev_dbg(netdev, "Only internal phy supported\n");
27389+ return;
27390+ }
27391+
27392+ netdev_dbg(netdev, "sr_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
27393+ phy_id, loc, val);
27394+
27395+ sr_share_write_word(dev, 1, loc, res);
27396+}
27397+
27398+static u32 sr9700_get_link(struct net_device *netdev)
27399+{
27400+ struct usbnet *dev = netdev_priv(netdev);
27401+ u8 value = 0;
27402+ int rc = 0;
27403+
27404+ /* Get the Link Status directly */
27405+ sr_read_reg(dev, NSR, &value);
27406+ if (value & NSR_LINKST)
27407+ rc = 1;
27408+
27409+ return rc;
27410+}
27411+
27412+static int sr9700_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
27413+{
27414+ struct usbnet *dev = netdev_priv(netdev);
27415+
27416+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
27417+}
27418+
27419+static const struct ethtool_ops sr9700_ethtool_ops = {
27420+ .get_drvinfo = usbnet_get_drvinfo,
27421+ .get_link = sr9700_get_link,
27422+ .get_msglevel = usbnet_get_msglevel,
27423+ .set_msglevel = usbnet_set_msglevel,
27424+ .get_eeprom_len = sr9700_get_eeprom_len,
27425+ .get_eeprom = sr9700_get_eeprom,
27426+ .get_settings = usbnet_get_settings,
27427+ .set_settings = usbnet_set_settings,
27428+ .nway_reset = usbnet_nway_reset,
27429+};
27430+
27431+static void sr9700_set_multicast(struct net_device *netdev)
27432+{
27433+ struct usbnet *dev = netdev_priv(netdev);
27434+ /* We use the 20 byte dev->data for our 8 byte filter buffer
27435+ * to avoid allocating memory that is tricky to free later
27436+ */
27437+ u8 *hashes = (u8 *)&dev->data;
27438+ /* rx_ctl setting : enable, disable_long, disable_crc */
27439+ u8 rx_ctl = RCR_RXEN | RCR_DIS_CRC | RCR_DIS_LONG;
27440+
27441+ memset(hashes, 0x00, SR_MCAST_SIZE);
27442+ /* broadcast address */
27443+ hashes[SR_MCAST_SIZE - 1] |= SR_MCAST_ADDR_FLAG;
27444+ if (netdev->flags & IFF_PROMISC) {
27445+ rx_ctl |= RCR_PRMSC;
27446+ } else if (netdev->flags & IFF_ALLMULTI ||
27447+ netdev_mc_count(netdev) > SR_MCAST_MAX) {
27448+ rx_ctl |= RCR_RUNT;
27449+ } else if (!netdev_mc_empty(netdev)) {
27450+ struct netdev_hw_addr *ha;
27451+
27452+ netdev_for_each_mc_addr(ha, netdev) {
27453+ u32 crc = ether_crc(ETH_ALEN, ha->addr) >> 26;
27454+ hashes[crc >> 3] |= 1 << (crc & 0x7);
27455+ }
27456+ }
27457+
27458+ sr_write_async(dev, MAR, SR_MCAST_SIZE, hashes);
27459+ sr_write_reg_async(dev, RCR, rx_ctl);
27460+}
27461+
27462+static int sr9700_set_mac_address(struct net_device *netdev, void *p)
27463+{
27464+ struct usbnet *dev = netdev_priv(netdev);
27465+ struct sockaddr *addr = p;
27466+
27467+ if (!is_valid_ether_addr(addr->sa_data)) {
27468+ netdev_err(netdev, "not setting invalid mac address %pM\n",
27469+ addr->sa_data);
27470+ return -EINVAL;
27471+ }
27472+
27473+ memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
27474+ sr_write_async(dev, PAR, 6, netdev->dev_addr);
27475+
27476+ return 0;
27477+}
27478+
27479+static const struct net_device_ops sr9700_netdev_ops = {
27480+ .ndo_open = usbnet_open,
27481+ .ndo_stop = usbnet_stop,
27482+ .ndo_start_xmit = usbnet_start_xmit,
27483+ .ndo_tx_timeout = usbnet_tx_timeout,
27484+ .ndo_change_mtu = usbnet_change_mtu,
27485+ .ndo_validate_addr = eth_validate_addr,
27486+ .ndo_do_ioctl = sr9700_ioctl,
27487+ .ndo_set_rx_mode = sr9700_set_multicast,
27488+ .ndo_set_mac_address = sr9700_set_mac_address,
27489+};
27490+
27491+static int sr9700_bind(struct usbnet *dev, struct usb_interface *intf)
27492+{
27493+ struct net_device *netdev;
27494+ struct mii_if_info *mii;
27495+ int ret;
27496+
27497+ ret = usbnet_get_endpoints(dev, intf);
27498+ if (ret)
27499+ goto out;
27500+
27501+ netdev = dev->net;
27502+
27503+ netdev->netdev_ops = &sr9700_netdev_ops;
27504+ netdev->ethtool_ops = &sr9700_ethtool_ops;
27505+ netdev->hard_header_len += SR_TX_OVERHEAD;
27506+ dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
27507+ /* bulkin buffer is preferably not less than 3K */
27508+ dev->rx_urb_size = 3072;
27509+
27510+ mii = &dev->mii;
27511+ mii->dev = netdev;
27512+ mii->mdio_read = sr_mdio_read;
27513+ mii->mdio_write = sr_mdio_write;
27514+ mii->phy_id_mask = 0x1f;
27515+ mii->reg_num_mask = 0x1f;
27516+
27517+ sr_write_reg(dev, NCR, NCR_RST);
27518+ udelay(20);
27519+
27520+ /* read MAC
27521+ * After Chip Power on, the Chip will reload the MAC from
27522+ * EEPROM automatically to PAR. In case there is no EEPROM externally,
27523+ * a default MAC address is stored in PAR for making chip work properly.
27524+ */
27525+ if (sr_read(dev, PAR, ETH_ALEN, netdev->dev_addr) < 0) {
27526+ netdev_err(netdev, "Error reading MAC address\n");
27527+ ret = -ENODEV;
27528+ goto out;
27529+ }
27530+
27531+ /* power up and reset phy */
27532+ sr_write_reg(dev, PRR, PRR_PHY_RST);
27533+ /* at least 10ms, here 20ms for safe */
27534+ mdelay(20);
27535+ sr_write_reg(dev, PRR, 0);
27536+ /* at least 1ms, here 2ms for reading right register */
27537+ udelay(2 * 1000);
27538+
27539+ /* receive broadcast packets */
27540+ sr9700_set_multicast(netdev);
27541+
27542+ sr_mdio_write(netdev, mii->phy_id, MII_BMCR, BMCR_RESET);
27543+ sr_mdio_write(netdev, mii->phy_id, MII_ADVERTISE, ADVERTISE_ALL |
27544+ ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
27545+ mii_nway_restart(mii);
27546+
27547+out:
27548+ return ret;
27549+}
27550+
27551+static int sr9700_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
27552+{
27553+ struct sk_buff *sr_skb;
27554+ int len;
27555+
27556+ /* skb content (packets) format :
27557+ * p0 p1 p2 ...... pm
27558+ * / \
27559+ * / \
27560+ * / \
27561+ * / \
27562+ * p0b0 p0b1 p0b2 p0b3 ...... p0b(n-4) p0b(n-3)...p0bn
27563+ *
27564+ * p0 : packet 0
27565+ * p0b0 : packet 0 byte 0
27566+ *
27567+ * b0: rx status
27568+ * b1: packet length (incl crc) low
27569+ * b2: packet length (incl crc) high
27570+ * b3..n-4: packet data
27571+ * bn-3..bn: ethernet packet crc
27572+ */
27573+ if (unlikely(skb->len < SR_RX_OVERHEAD)) {
27574+ netdev_err(dev->net, "unexpected tiny rx frame\n");
27575+ return 0;
27576+ }
27577+
27578+ /* one skb may contains multiple packets */
27579+ while (skb->len > SR_RX_OVERHEAD) {
27580+ if (skb->data[0] != 0x40)
27581+ return 0;
27582+
27583+ /* ignore the CRC length */
27584+ len = (skb->data[1] | (skb->data[2] << 8)) - 4;
27585+
27586+ if (len > ETH_FRAME_LEN)
27587+ return 0;
27588+
27589+ /* the last packet of current skb */
27590+ if (skb->len == (len + SR_RX_OVERHEAD)) {
27591+ skb_pull(skb, 3);
27592+ skb->len = len;
27593+ skb_set_tail_pointer(skb, len);
27594+ skb->truesize = len + sizeof(struct sk_buff);
27595+ return 2;
27596+ }
27597+
27598+ /* skb_clone is used for address align */
27599+ sr_skb = skb_clone(skb, GFP_ATOMIC);
27600+ if (!sr_skb)
27601+ return 0;
27602+
27603+ sr_skb->len = len;
27604+ sr_skb->data = skb->data + 3;
27605+ skb_set_tail_pointer(sr_skb, len);
27606+ sr_skb->truesize = len + sizeof(struct sk_buff);
27607+ usbnet_skb_return(dev, sr_skb);
27608+
27609+ skb_pull(skb, len + SR_RX_OVERHEAD);
27610+ };
27611+
27612+ return 0;
27613+}
27614+
27615+static struct sk_buff *sr9700_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
27616+ gfp_t flags)
27617+{
27618+ int len;
27619+
27620+ /* SR9700 can only send out one ethernet packet at once.
27621+ *
27622+ * b0 b1 b2 b3 ...... b(n-4) b(n-3)...bn
27623+ *
27624+ * b0: rx status
27625+ * b1: packet length (incl crc) low
27626+ * b2: packet length (incl crc) high
27627+ * b3..n-4: packet data
27628+ * bn-3..bn: ethernet packet crc
27629+ */
27630+
27631+ len = skb->len;
27632+
27633+ if (skb_headroom(skb) < SR_TX_OVERHEAD) {
27634+ struct sk_buff *skb2;
27635+
27636+ skb2 = skb_copy_expand(skb, SR_TX_OVERHEAD, 0, flags);
27637+ dev_kfree_skb_any(skb);
27638+ skb = skb2;
27639+ if (!skb)
27640+ return NULL;
27641+ }
27642+
27643+ __skb_push(skb, SR_TX_OVERHEAD);
27644+
27645+ /* usbnet adds padding if length is a multiple of packet size
27646+ * if so, adjust length value in header
27647+ */
27648+ if ((skb->len % dev->maxpacket) == 0)
27649+ len++;
27650+
27651+ skb->data[0] = len;
27652+ skb->data[1] = len >> 8;
27653+
27654+ return skb;
27655+}
27656+
27657+static void sr9700_status(struct usbnet *dev, struct urb *urb)
27658+{
27659+ int link;
27660+ u8 *buf;
27661+
27662+ /* format:
27663+ b0: net status
27664+ b1: tx status 1
27665+ b2: tx status 2
27666+ b3: rx status
27667+ b4: rx overflow
27668+ b5: rx count
27669+ b6: tx count
27670+ b7: gpr
27671+ */
27672+
27673+ if (urb->actual_length < 8)
27674+ return;
27675+
27676+ buf = urb->transfer_buffer;
27677+
27678+ link = !!(buf[0] & 0x40);
27679+ if (netif_carrier_ok(dev->net) != link) {
27680+ usbnet_link_change(dev, link, 1);
27681+ netdev_dbg(dev->net, "Link Status is: %d\n", link);
27682+ }
27683+}
27684+
27685+static int sr9700_link_reset(struct usbnet *dev)
27686+{
27687+ struct ethtool_cmd ecmd;
27688+
27689+ mii_check_media(&dev->mii, 1, 1);
27690+ mii_ethtool_gset(&dev->mii, &ecmd);
27691+
27692+ netdev_dbg(dev->net, "link_reset() speed: %d duplex: %d\n",
27693+ ecmd.speed, ecmd.duplex);
27694+
27695+ return 0;
27696+}
27697+
27698+static const struct driver_info sr9700_driver_info = {
27699+ .description = "CoreChip SR9700 USB Ethernet",
27700+ .flags = FLAG_ETHER,
27701+ .bind = sr9700_bind,
27702+ .rx_fixup = sr9700_rx_fixup,
27703+ .tx_fixup = sr9700_tx_fixup,
27704+ .status = sr9700_status,
27705+ .link_reset = sr9700_link_reset,
27706+ .reset = sr9700_link_reset,
27707+};
27708+
27709+static const struct usb_device_id products[] = {
27710+ {
27711+ USB_DEVICE(0x0fe6, 0x9700), /* SR9700 device */
27712+ .driver_info = (unsigned long)&sr9700_driver_info,
27713+ },
27714+ {}, /* END */
27715+};
27716+
27717+MODULE_DEVICE_TABLE(usb, products);
27718+
27719+static struct usb_driver sr9700_usb_driver = {
27720+ .name = "sr9700",
27721+ .id_table = products,
27722+ .probe = usbnet_probe,
27723+ .disconnect = usbnet_disconnect,
27724+ .suspend = usbnet_suspend,
27725+ .resume = usbnet_resume,
27726+ .disable_hub_initiated_lpm = 1,
27727+};
27728+
27729+module_usb_driver(sr9700_usb_driver);
27730+
27731+MODULE_AUTHOR("liujl <liujunliang_ljl@163.com>");
27732+MODULE_DESCRIPTION("SR9700 one chip USB 1.1 USB to Ethernet device from http://www.corechip-sz.com/");
27733+MODULE_LICENSE("GPL");
27734diff -Naur backports-3.18.1-1.org/drivers/net/usb/sr9700.h backports-3.18.1-1/drivers/net/usb/sr9700.h
27735--- backports-3.18.1-1.org/drivers/net/usb/sr9700.h 1970-01-01 01:00:00.000000000 +0100
27736+++ backports-3.18.1-1/drivers/net/usb/sr9700.h 2014-12-16 18:39:45.000000000 +0100
27737@@ -0,0 +1,173 @@
27738+/*
27739+ * CoreChip-sz SR9700 one chip USB 1.1 Ethernet Devices
27740+ *
27741+ * Author : Liu Junliang <liujunliang_ljl@163.com>
27742+ *
27743+ * This program is free software; you can redistribute it and/or
27744+ * modify it under the terms of the GNU General Public License
27745+ * version 2 as published by the Free Software Foundation.
27746+ */
27747+
27748+#ifndef _SR9700_H
27749+#define _SR9700_H
27750+
27751+/* sr9700 spec. register table on Linux platform */
27752+
27753+/* Network Control Reg */
27754+#define NCR 0x00
27755+#define NCR_RST (1 << 0)
27756+#define NCR_LBK (3 << 1)
27757+#define NCR_FDX (1 << 3)
27758+#define NCR_WAKEEN (1 << 6)
27759+/* Network Status Reg */
27760+#define NSR 0x01
27761+#define NSR_RXRDY (1 << 0)
27762+#define NSR_RXOV (1 << 1)
27763+#define NSR_TX1END (1 << 2)
27764+#define NSR_TX2END (1 << 3)
27765+#define NSR_TXFULL (1 << 4)
27766+#define NSR_WAKEST (1 << 5)
27767+#define NSR_LINKST (1 << 6)
27768+#define NSR_SPEED (1 << 7)
27769+/* Tx Control Reg */
27770+#define TCR 0x02
27771+#define TCR_CRC_DIS (1 << 1)
27772+#define TCR_PAD_DIS (1 << 2)
27773+#define TCR_LC_CARE (1 << 3)
27774+#define TCR_CRS_CARE (1 << 4)
27775+#define TCR_EXCECM (1 << 5)
27776+#define TCR_LF_EN (1 << 6)
27777+/* Tx Status Reg for Packet Index 1 */
27778+#define TSR1 0x03
27779+#define TSR1_EC (1 << 2)
27780+#define TSR1_COL (1 << 3)
27781+#define TSR1_LC (1 << 4)
27782+#define TSR1_NC (1 << 5)
27783+#define TSR1_LOC (1 << 6)
27784+#define TSR1_TLF (1 << 7)
27785+/* Tx Status Reg for Packet Index 2 */
27786+#define TSR2 0x04
27787+#define TSR2_EC (1 << 2)
27788+#define TSR2_COL (1 << 3)
27789+#define TSR2_LC (1 << 4)
27790+#define TSR2_NC (1 << 5)
27791+#define TSR2_LOC (1 << 6)
27792+#define TSR2_TLF (1 << 7)
27793+/* Rx Control Reg*/
27794+#define RCR 0x05
27795+#define RCR_RXEN (1 << 0)
27796+#define RCR_PRMSC (1 << 1)
27797+#define RCR_RUNT (1 << 2)
27798+#define RCR_ALL (1 << 3)
27799+#define RCR_DIS_CRC (1 << 4)
27800+#define RCR_DIS_LONG (1 << 5)
27801+/* Rx Status Reg */
27802+#define RSR 0x06
27803+#define RSR_AE (1 << 2)
27804+#define RSR_MF (1 << 6)
27805+#define RSR_RF (1 << 7)
27806+/* Rx Overflow Counter Reg */
27807+#define ROCR 0x07
27808+#define ROCR_ROC (0x7F << 0)
27809+#define ROCR_RXFU (1 << 7)
27810+/* Back Pressure Threshold Reg */
27811+#define BPTR 0x08
27812+#define BPTR_JPT (0x0F << 0)
27813+#define BPTR_BPHW (0x0F << 4)
27814+/* Flow Control Threshold Reg */
27815+#define FCTR 0x09
27816+#define FCTR_LWOT (0x0F << 0)
27817+#define FCTR_HWOT (0x0F << 4)
27818+/* rx/tx Flow Control Reg */
27819+#define FCR 0x0A
27820+#define FCR_FLCE (1 << 0)
27821+#define FCR_BKPA (1 << 4)
27822+#define FCR_TXPEN (1 << 5)
27823+#define FCR_TXPF (1 << 6)
27824+#define FCR_TXP0 (1 << 7)
27825+/* Eeprom & Phy Control Reg */
27826+#define EPCR 0x0B
27827+#define EPCR_ERRE (1 << 0)
27828+#define EPCR_ERPRW (1 << 1)
27829+#define EPCR_ERPRR (1 << 2)
27830+#define EPCR_EPOS (1 << 3)
27831+#define EPCR_WEP (1 << 4)
27832+/* Eeprom & Phy Address Reg */
27833+#define EPAR 0x0C
27834+#define EPAR_EROA (0x3F << 0)
27835+#define EPAR_PHY_ADR_MASK (0x03 << 6)
27836+#define EPAR_PHY_ADR (0x01 << 6)
27837+/* Eeprom & Phy Data Reg */
27838+#define EPDR 0x0D /* 0x0D ~ 0x0E for Data Reg Low & High */
27839+/* Wakeup Control Reg */
27840+#define WCR 0x0F
27841+#define WCR_MAGICST (1 << 0)
27842+#define WCR_LINKST (1 << 2)
27843+#define WCR_MAGICEN (1 << 3)
27844+#define WCR_LINKEN (1 << 5)
27845+/* Physical Address Reg */
27846+#define PAR 0x10 /* 0x10 ~ 0x15 6 bytes for PAR */
27847+/* Multicast Address Reg */
27848+#define MAR 0x16 /* 0x16 ~ 0x1D 8 bytes for MAR */
27849+/* 0x1e unused */
27850+/* Phy Reset Reg */
27851+#define PRR 0x1F
27852+#define PRR_PHY_RST (1 << 0)
27853+/* Tx sdram Write Pointer Address Low */
27854+#define TWPAL 0x20
27855+/* Tx sdram Write Pointer Address High */
27856+#define TWPAH 0x21
27857+/* Tx sdram Read Pointer Address Low */
27858+#define TRPAL 0x22
27859+/* Tx sdram Read Pointer Address High */
27860+#define TRPAH 0x23
27861+/* Rx sdram Write Pointer Address Low */
27862+#define RWPAL 0x24
27863+/* Rx sdram Write Pointer Address High */
27864+#define RWPAH 0x25
27865+/* Rx sdram Read Pointer Address Low */
27866+#define RRPAL 0x26
27867+/* Rx sdram Read Pointer Address High */
27868+#define RRPAH 0x27
27869+/* Vendor ID register */
27870+#define VID 0x28 /* 0x28 ~ 0x29 2 bytes for VID */
27871+/* Product ID register */
27872+#define PID 0x2A /* 0x2A ~ 0x2B 2 bytes for PID */
27873+/* CHIP Revision register */
27874+#define CHIPR 0x2C
27875+/* 0x2D --> 0xEF unused */
27876+/* USB Device Address */
27877+#define USBDA 0xF0
27878+#define USBDA_USBFA (0x7F << 0)
27879+/* RX packet Counter Reg */
27880+#define RXC 0xF1
27881+/* Tx packet Counter & USB Status Reg */
27882+#define TXC_USBS 0xF2
27883+#define TXC_USBS_TXC0 (1 << 0)
27884+#define TXC_USBS_TXC1 (1 << 1)
27885+#define TXC_USBS_TXC2 (1 << 2)
27886+#define TXC_USBS_EP1RDY (1 << 5)
27887+#define TXC_USBS_SUSFLAG (1 << 6)
27888+#define TXC_USBS_RXFAULT (1 << 7)
27889+/* USB Control register */
27890+#define USBC 0xF4
27891+#define USBC_EP3NAK (1 << 4)
27892+#define USBC_EP3ACK (1 << 5)
27893+
27894+/* Register access commands and flags */
27895+#define SR_RD_REGS 0x00
27896+#define SR_WR_REGS 0x01
27897+#define SR_WR_REG 0x03
27898+#define SR_REQ_RD_REG (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
27899+#define SR_REQ_WR_REG (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
27900+
27901+/* parameters */
27902+#define SR_SHARE_TIMEOUT 1000
27903+#define SR_EEPROM_LEN 256
27904+#define SR_MCAST_SIZE 8
27905+#define SR_MCAST_ADDR_FLAG 0x80
27906+#define SR_MCAST_MAX 64
27907+#define SR_TX_OVERHEAD 2 /* 2bytes header */
27908+#define SR_RX_OVERHEAD 7 /* 3bytes header + 4crc tail */
27909+
27910+#endif /* _SR9700_H */
27911diff -Naur backports-3.18.1-1.org/drivers/net/usb/sr9800.c backports-3.18.1-1/drivers/net/usb/sr9800.c
27912--- backports-3.18.1-1.org/drivers/net/usb/sr9800.c 1970-01-01 01:00:00.000000000 +0100
27913+++ backports-3.18.1-1/drivers/net/usb/sr9800.c 2014-12-16 18:39:45.000000000 +0100
27914@@ -0,0 +1,874 @@
27915+/* CoreChip-sz SR9800 one chip USB 2.0 Ethernet Devices
27916+ *
27917+ * Author : Liu Junliang <liujunliang_ljl@163.com>
27918+ *
27919+ * Based on asix_common.c, asix_devices.c
27920+ *
27921+ * This file is licensed under the terms of the GNU General Public License
27922+ * version 2. This program is licensed "as is" without any warranty of any
27923+ * kind, whether express or implied.*
27924+ */
27925+
27926+#include <linux/module.h>
27927+#include <linux/kmod.h>
27928+#include <linux/init.h>
27929+#include <linux/netdevice.h>
27930+#include <linux/etherdevice.h>
27931+#include <linux/ethtool.h>
27932+#include <linux/workqueue.h>
27933+#include <linux/mii.h>
27934+#include <linux/usb.h>
27935+#include <linux/crc32.h>
27936+#include <linux/usb/usbnet.h>
27937+#include <linux/slab.h>
27938+#include <linux/if_vlan.h>
27939+
27940+#include "sr9800.h"
27941+
27942+static int sr_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
27943+ u16 size, void *data)
27944+{
27945+ int err;
27946+
27947+ err = usbnet_read_cmd(dev, cmd, SR_REQ_RD_REG, value, index,
27948+ data, size);
27949+ if ((err != size) && (err >= 0))
27950+ err = -EINVAL;
27951+
27952+ return err;
27953+}
27954+
27955+static int sr_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
27956+ u16 size, void *data)
27957+{
27958+ int err;
27959+
27960+ err = usbnet_write_cmd(dev, cmd, SR_REQ_WR_REG, value, index,
27961+ data, size);
27962+ if ((err != size) && (err >= 0))
27963+ err = -EINVAL;
27964+
27965+ return err;
27966+}
27967+
27968+static void
27969+sr_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
27970+ u16 size, void *data)
27971+{
27972+ usbnet_write_cmd_async(dev, cmd, SR_REQ_WR_REG, value, index, data,
27973+ size);
27974+}
27975+
27976+static int sr_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
27977+{
27978+ int offset = 0;
27979+
27980+ /* This check is no longer done by usbnet */
27981+ if (skb->len < dev->net->hard_header_len)
27982+ return 0;
27983+
27984+ while (offset + sizeof(u32) < skb->len) {
27985+ struct sk_buff *sr_skb;
27986+ u16 size;
27987+ u32 header = get_unaligned_le32(skb->data + offset);
27988+
27989+ offset += sizeof(u32);
27990+ /* get the packet length */
27991+ size = (u16) (header & 0x7ff);
27992+ if (size != ((~header >> 16) & 0x07ff)) {
27993+ netdev_err(dev->net, "%s : Bad Header Length\n",
27994+ __func__);
27995+ return 0;
27996+ }
27997+
27998+ if ((size > dev->net->mtu + ETH_HLEN + VLAN_HLEN) ||
27999+ (size + offset > skb->len)) {
28000+ netdev_err(dev->net, "%s : Bad RX Length %d\n",
28001+ __func__, size);
28002+ return 0;
28003+ }
28004+ sr_skb = netdev_alloc_skb_ip_align(dev->net, size);
28005+ if (!sr_skb)
28006+ return 0;
28007+
28008+ skb_put(sr_skb, size);
28009+ memcpy(sr_skb->data, skb->data + offset, size);
28010+ usbnet_skb_return(dev, sr_skb);
28011+
28012+ offset += (size + 1) & 0xfffe;
28013+ }
28014+
28015+ if (skb->len != offset) {
28016+ netdev_err(dev->net, "%s : Bad SKB Length %d\n", __func__,
28017+ skb->len);
28018+ return 0;
28019+ }
28020+
28021+ return 1;
28022+}
28023+
28024+static struct sk_buff *sr_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
28025+ gfp_t flags)
28026+{
28027+ int headroom = skb_headroom(skb);
28028+ int tailroom = skb_tailroom(skb);
28029+ u32 padbytes = 0xffff0000;
28030+ u32 packet_len;
28031+ int padlen;
28032+
28033+ padlen = ((skb->len + 4) % (dev->maxpacket - 1)) ? 0 : 4;
28034+
28035+ if ((!skb_cloned(skb)) && ((headroom + tailroom) >= (4 + padlen))) {
28036+ if ((headroom < 4) || (tailroom < padlen)) {
28037+ skb->data = memmove(skb->head + 4, skb->data,
28038+ skb->len);
28039+ skb_set_tail_pointer(skb, skb->len);
28040+ }
28041+ } else {
28042+ struct sk_buff *skb2;
28043+ skb2 = skb_copy_expand(skb, 4, padlen, flags);
28044+ dev_kfree_skb_any(skb);
28045+ skb = skb2;
28046+ if (!skb)
28047+ return NULL;
28048+ }
28049+
28050+ skb_push(skb, 4);
28051+ packet_len = (((skb->len - 4) ^ 0x0000ffff) << 16) + (skb->len - 4);
28052+ cpu_to_le32s(&packet_len);
28053+ skb_copy_to_linear_data(skb, &packet_len, sizeof(packet_len));
28054+
28055+ if (padlen) {
28056+ cpu_to_le32s(&padbytes);
28057+ memcpy(skb_tail_pointer(skb), &padbytes, sizeof(padbytes));
28058+ skb_put(skb, sizeof(padbytes));
28059+ }
28060+
28061+ return skb;
28062+}
28063+
28064+static void sr_status(struct usbnet *dev, struct urb *urb)
28065+{
28066+ struct sr9800_int_data *event;
28067+ int link;
28068+
28069+ if (urb->actual_length < 8)
28070+ return;
28071+
28072+ event = urb->transfer_buffer;
28073+ link = event->link & 0x01;
28074+ if (netif_carrier_ok(dev->net) != link) {
28075+ usbnet_link_change(dev, link, 1);
28076+ netdev_dbg(dev->net, "Link Status is: %d\n", link);
28077+ }
28078+
28079+ return;
28080+}
28081+
28082+static inline int sr_set_sw_mii(struct usbnet *dev)
28083+{
28084+ int ret;
28085+
28086+ ret = sr_write_cmd(dev, SR_CMD_SET_SW_MII, 0x0000, 0, 0, NULL);
28087+ if (ret < 0)
28088+ netdev_err(dev->net, "Failed to enable software MII access\n");
28089+ return ret;
28090+}
28091+
28092+static inline int sr_set_hw_mii(struct usbnet *dev)
28093+{
28094+ int ret;
28095+
28096+ ret = sr_write_cmd(dev, SR_CMD_SET_HW_MII, 0x0000, 0, 0, NULL);
28097+ if (ret < 0)
28098+ netdev_err(dev->net, "Failed to enable hardware MII access\n");
28099+ return ret;
28100+}
28101+
28102+static inline int sr_get_phy_addr(struct usbnet *dev)
28103+{
28104+ u8 buf[2];
28105+ int ret;
28106+
28107+ ret = sr_read_cmd(dev, SR_CMD_READ_PHY_ID, 0, 0, 2, buf);
28108+ if (ret < 0) {
28109+ netdev_err(dev->net, "%s : Error reading PHYID register:%02x\n",
28110+ __func__, ret);
28111+ goto out;
28112+ }
28113+ netdev_dbg(dev->net, "%s : returning 0x%04x\n", __func__,
28114+ *((__le16 *)buf));
28115+
28116+ ret = buf[1];
28117+
28118+out:
28119+ return ret;
28120+}
28121+
28122+static int sr_sw_reset(struct usbnet *dev, u8 flags)
28123+{
28124+ int ret;
28125+
28126+ ret = sr_write_cmd(dev, SR_CMD_SW_RESET, flags, 0, 0, NULL);
28127+ if (ret < 0)
28128+ netdev_err(dev->net, "Failed to send software reset:%02x\n",
28129+ ret);
28130+
28131+ return ret;
28132+}
28133+
28134+static u16 sr_read_rx_ctl(struct usbnet *dev)
28135+{
28136+ __le16 v;
28137+ int ret;
28138+
28139+ ret = sr_read_cmd(dev, SR_CMD_READ_RX_CTL, 0, 0, 2, &v);
28140+ if (ret < 0) {
28141+ netdev_err(dev->net, "Error reading RX_CTL register:%02x\n",
28142+ ret);
28143+ goto out;
28144+ }
28145+
28146+ ret = le16_to_cpu(v);
28147+out:
28148+ return ret;
28149+}
28150+
28151+static int sr_write_rx_ctl(struct usbnet *dev, u16 mode)
28152+{
28153+ int ret;
28154+
28155+ netdev_dbg(dev->net, "%s : mode = 0x%04x\n", __func__, mode);
28156+ ret = sr_write_cmd(dev, SR_CMD_WRITE_RX_CTL, mode, 0, 0, NULL);
28157+ if (ret < 0)
28158+ netdev_err(dev->net,
28159+ "Failed to write RX_CTL mode to 0x%04x:%02x\n",
28160+ mode, ret);
28161+
28162+ return ret;
28163+}
28164+
28165+static u16 sr_read_medium_status(struct usbnet *dev)
28166+{
28167+ __le16 v;
28168+ int ret;
28169+
28170+ ret = sr_read_cmd(dev, SR_CMD_READ_MEDIUM_STATUS, 0, 0, 2, &v);
28171+ if (ret < 0) {
28172+ netdev_err(dev->net,
28173+ "Error reading Medium Status register:%02x\n", ret);
28174+ return ret; /* TODO: callers not checking for error ret */
28175+ }
28176+
28177+ return le16_to_cpu(v);
28178+}
28179+
28180+static int sr_write_medium_mode(struct usbnet *dev, u16 mode)
28181+{
28182+ int ret;
28183+
28184+ netdev_dbg(dev->net, "%s : mode = 0x%04x\n", __func__, mode);
28185+ ret = sr_write_cmd(dev, SR_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
28186+ if (ret < 0)
28187+ netdev_err(dev->net,
28188+ "Failed to write Medium Mode mode to 0x%04x:%02x\n",
28189+ mode, ret);
28190+ return ret;
28191+}
28192+
28193+static int sr_write_gpio(struct usbnet *dev, u16 value, int sleep)
28194+{
28195+ int ret;
28196+
28197+ netdev_dbg(dev->net, "%s : value = 0x%04x\n", __func__, value);
28198+ ret = sr_write_cmd(dev, SR_CMD_WRITE_GPIOS, value, 0, 0, NULL);
28199+ if (ret < 0)
28200+ netdev_err(dev->net, "Failed to write GPIO value 0x%04x:%02x\n",
28201+ value, ret);
28202+ if (sleep)
28203+ msleep(sleep);
28204+
28205+ return ret;
28206+}
28207+
28208+/* SR9800 have a 16-bit RX_CTL value */
28209+static void sr_set_multicast(struct net_device *net)
28210+{
28211+ struct usbnet *dev = netdev_priv(net);
28212+ struct sr_data *data = (struct sr_data *)&dev->data;
28213+ u16 rx_ctl = SR_DEFAULT_RX_CTL;
28214+
28215+ if (net->flags & IFF_PROMISC) {
28216+ rx_ctl |= SR_RX_CTL_PRO;
28217+ } else if (net->flags & IFF_ALLMULTI ||
28218+ netdev_mc_count(net) > SR_MAX_MCAST) {
28219+ rx_ctl |= SR_RX_CTL_AMALL;
28220+ } else if (netdev_mc_empty(net)) {
28221+ /* just broadcast and directed */
28222+ } else {
28223+ /* We use the 20 byte dev->data
28224+ * for our 8 byte filter buffer
28225+ * to avoid allocating memory that
28226+ * is tricky to free later
28227+ */
28228+ struct netdev_hw_addr *ha;
28229+ u32 crc_bits;
28230+
28231+ memset(data->multi_filter, 0, SR_MCAST_FILTER_SIZE);
28232+
28233+ /* Build the multicast hash filter. */
28234+ netdev_for_each_mc_addr(ha, net) {
28235+ crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
28236+ data->multi_filter[crc_bits >> 3] |=
28237+ 1 << (crc_bits & 7);
28238+ }
28239+
28240+ sr_write_cmd_async(dev, SR_CMD_WRITE_MULTI_FILTER, 0, 0,
28241+ SR_MCAST_FILTER_SIZE, data->multi_filter);
28242+
28243+ rx_ctl |= SR_RX_CTL_AM;
28244+ }
28245+
28246+ sr_write_cmd_async(dev, SR_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
28247+}
28248+
28249+static int sr_mdio_read(struct net_device *net, int phy_id, int loc)
28250+{
28251+ struct usbnet *dev = netdev_priv(net);
28252+ __le16 res;
28253+
28254+ mutex_lock(&dev->phy_mutex);
28255+ sr_set_sw_mii(dev);
28256+ sr_read_cmd(dev, SR_CMD_READ_MII_REG, phy_id, (__u16)loc, 2, &res);
28257+ sr_set_hw_mii(dev);
28258+ mutex_unlock(&dev->phy_mutex);
28259+
28260+ netdev_dbg(dev->net,
28261+ "%s : phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n", __func__,
28262+ phy_id, loc, le16_to_cpu(res));
28263+
28264+ return le16_to_cpu(res);
28265+}
28266+
28267+static void
28268+sr_mdio_write(struct net_device *net, int phy_id, int loc, int val)
28269+{
28270+ struct usbnet *dev = netdev_priv(net);
28271+ __le16 res = cpu_to_le16(val);
28272+
28273+ netdev_dbg(dev->net,
28274+ "%s : phy_id=0x%02x, loc=0x%02x, val=0x%04x\n", __func__,
28275+ phy_id, loc, val);
28276+ mutex_lock(&dev->phy_mutex);
28277+ sr_set_sw_mii(dev);
28278+ sr_write_cmd(dev, SR_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2, &res);
28279+ sr_set_hw_mii(dev);
28280+ mutex_unlock(&dev->phy_mutex);
28281+}
28282+
28283+/* Get the PHY Identifier from the PHYSID1 & PHYSID2 MII registers */
28284+static u32 sr_get_phyid(struct usbnet *dev)
28285+{
28286+ int phy_reg;
28287+ u32 phy_id;
28288+ int i;
28289+
28290+ /* Poll for the rare case the FW or phy isn't ready yet. */
28291+ for (i = 0; i < 100; i++) {
28292+ phy_reg = sr_mdio_read(dev->net, dev->mii.phy_id, MII_PHYSID1);
28293+ if (phy_reg != 0 && phy_reg != 0xFFFF)
28294+ break;
28295+ mdelay(1);
28296+ }
28297+
28298+ if (phy_reg <= 0 || phy_reg == 0xFFFF)
28299+ return 0;
28300+
28301+ phy_id = (phy_reg & 0xffff) << 16;
28302+
28303+ phy_reg = sr_mdio_read(dev->net, dev->mii.phy_id, MII_PHYSID2);
28304+ if (phy_reg < 0)
28305+ return 0;
28306+
28307+ phy_id |= (phy_reg & 0xffff);
28308+
28309+ return phy_id;
28310+}
28311+
28312+static void
28313+sr_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
28314+{
28315+ struct usbnet *dev = netdev_priv(net);
28316+ u8 opt;
28317+
28318+ if (sr_read_cmd(dev, SR_CMD_READ_MONITOR_MODE, 0, 0, 1, &opt) < 0) {
28319+ wolinfo->supported = 0;
28320+ wolinfo->wolopts = 0;
28321+ return;
28322+ }
28323+ wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
28324+ wolinfo->wolopts = 0;
28325+ if (opt & SR_MONITOR_LINK)
28326+ wolinfo->wolopts |= WAKE_PHY;
28327+ if (opt & SR_MONITOR_MAGIC)
28328+ wolinfo->wolopts |= WAKE_MAGIC;
28329+}
28330+
28331+static int
28332+sr_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
28333+{
28334+ struct usbnet *dev = netdev_priv(net);
28335+ u8 opt = 0;
28336+
28337+ if (wolinfo->wolopts & WAKE_PHY)
28338+ opt |= SR_MONITOR_LINK;
28339+ if (wolinfo->wolopts & WAKE_MAGIC)
28340+ opt |= SR_MONITOR_MAGIC;
28341+
28342+ if (sr_write_cmd(dev, SR_CMD_WRITE_MONITOR_MODE,
28343+ opt, 0, 0, NULL) < 0)
28344+ return -EINVAL;
28345+
28346+ return 0;
28347+}
28348+
28349+static int sr_get_eeprom_len(struct net_device *net)
28350+{
28351+ struct usbnet *dev = netdev_priv(net);
28352+ struct sr_data *data = (struct sr_data *)&dev->data;
28353+
28354+ return data->eeprom_len;
28355+}
28356+
28357+static int sr_get_eeprom(struct net_device *net,
28358+ struct ethtool_eeprom *eeprom, u8 *data)
28359+{
28360+ struct usbnet *dev = netdev_priv(net);
28361+ __le16 *ebuf = (__le16 *)data;
28362+ int ret;
28363+ int i;
28364+
28365+ /* Crude hack to ensure that we don't overwrite memory
28366+ * if an odd length is supplied
28367+ */
28368+ if (eeprom->len % 2)
28369+ return -EINVAL;
28370+
28371+ eeprom->magic = SR_EEPROM_MAGIC;
28372+
28373+ /* sr9800 returns 2 bytes from eeprom on read */
28374+ for (i = 0; i < eeprom->len / 2; i++) {
28375+ ret = sr_read_cmd(dev, SR_CMD_READ_EEPROM, eeprom->offset + i,
28376+ 0, 2, &ebuf[i]);
28377+ if (ret < 0)
28378+ return -EINVAL;
28379+ }
28380+ return 0;
28381+}
28382+
28383+static void sr_get_drvinfo(struct net_device *net,
28384+ struct ethtool_drvinfo *info)
28385+{
28386+ struct usbnet *dev = netdev_priv(net);
28387+ struct sr_data *data = (struct sr_data *)&dev->data;
28388+
28389+ /* Inherit standard device info */
28390+ usbnet_get_drvinfo(net, info);
28391+ strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
28392+ strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
28393+ info->eedump_len = data->eeprom_len;
28394+}
28395+
28396+static u32 sr_get_link(struct net_device *net)
28397+{
28398+ struct usbnet *dev = netdev_priv(net);
28399+
28400+ return mii_link_ok(&dev->mii);
28401+}
28402+
28403+static int sr_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
28404+{
28405+ struct usbnet *dev = netdev_priv(net);
28406+
28407+ return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
28408+}
28409+
28410+static int sr_set_mac_address(struct net_device *net, void *p)
28411+{
28412+ struct usbnet *dev = netdev_priv(net);
28413+ struct sr_data *data = (struct sr_data *)&dev->data;
28414+ struct sockaddr *addr = p;
28415+
28416+ if (netif_running(net))
28417+ return -EBUSY;
28418+ if (!is_valid_ether_addr(addr->sa_data))
28419+ return -EADDRNOTAVAIL;
28420+
28421+ memcpy(net->dev_addr, addr->sa_data, ETH_ALEN);
28422+
28423+ /* We use the 20 byte dev->data
28424+ * for our 6 byte mac buffer
28425+ * to avoid allocating memory that
28426+ * is tricky to free later
28427+ */
28428+ memcpy(data->mac_addr, addr->sa_data, ETH_ALEN);
28429+ sr_write_cmd_async(dev, SR_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
28430+ data->mac_addr);
28431+
28432+ return 0;
28433+}
28434+
28435+static const struct ethtool_ops sr9800_ethtool_ops = {
28436+ .get_drvinfo = sr_get_drvinfo,
28437+ .get_link = sr_get_link,
28438+ .get_msglevel = usbnet_get_msglevel,
28439+ .set_msglevel = usbnet_set_msglevel,
28440+ .get_wol = sr_get_wol,
28441+ .set_wol = sr_set_wol,
28442+ .get_eeprom_len = sr_get_eeprom_len,
28443+ .get_eeprom = sr_get_eeprom,
28444+ .get_settings = usbnet_get_settings,
28445+ .set_settings = usbnet_set_settings,
28446+ .nway_reset = usbnet_nway_reset,
28447+};
28448+
28449+static int sr9800_link_reset(struct usbnet *dev)
28450+{
28451+ struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
28452+ u16 mode;
28453+
28454+ mii_check_media(&dev->mii, 1, 1);
28455+ mii_ethtool_gset(&dev->mii, &ecmd);
28456+ mode = SR9800_MEDIUM_DEFAULT;
28457+
28458+ if (ethtool_cmd_speed(&ecmd) != SPEED_100)
28459+ mode &= ~SR_MEDIUM_PS;
28460+
28461+ if (ecmd.duplex != DUPLEX_FULL)
28462+ mode &= ~SR_MEDIUM_FD;
28463+
28464+ netdev_dbg(dev->net, "%s : speed: %u duplex: %d mode: 0x%04x\n",
28465+ __func__, ethtool_cmd_speed(&ecmd), ecmd.duplex, mode);
28466+
28467+ sr_write_medium_mode(dev, mode);
28468+
28469+ return 0;
28470+}
28471+
28472+
28473+static int sr9800_set_default_mode(struct usbnet *dev)
28474+{
28475+ u16 rx_ctl;
28476+ int ret;
28477+
28478+ sr_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
28479+ sr_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
28480+ ADVERTISE_ALL | ADVERTISE_CSMA);
28481+ mii_nway_restart(&dev->mii);
28482+
28483+ ret = sr_write_medium_mode(dev, SR9800_MEDIUM_DEFAULT);
28484+ if (ret < 0)
28485+ goto out;
28486+
28487+ ret = sr_write_cmd(dev, SR_CMD_WRITE_IPG012,
28488+ SR9800_IPG0_DEFAULT | SR9800_IPG1_DEFAULT,
28489+ SR9800_IPG2_DEFAULT, 0, NULL);
28490+ if (ret < 0) {
28491+ netdev_dbg(dev->net, "Write IPG,IPG1,IPG2 failed: %d\n", ret);
28492+ goto out;
28493+ }
28494+
28495+ /* Set RX_CTL to default values with 2k buffer, and enable cactus */
28496+ ret = sr_write_rx_ctl(dev, SR_DEFAULT_RX_CTL);
28497+ if (ret < 0)
28498+ goto out;
28499+
28500+ rx_ctl = sr_read_rx_ctl(dev);
28501+ netdev_dbg(dev->net, "RX_CTL is 0x%04x after all initializations\n",
28502+ rx_ctl);
28503+
28504+ rx_ctl = sr_read_medium_status(dev);
28505+ netdev_dbg(dev->net, "Medium Status:0x%04x after all initializations\n",
28506+ rx_ctl);
28507+
28508+ return 0;
28509+out:
28510+ return ret;
28511+}
28512+
28513+static int sr9800_reset(struct usbnet *dev)
28514+{
28515+ struct sr_data *data = (struct sr_data *)&dev->data;
28516+ int ret, embd_phy;
28517+ u16 rx_ctl;
28518+
28519+ ret = sr_write_gpio(dev,
28520+ SR_GPIO_RSE | SR_GPIO_GPO_2 | SR_GPIO_GPO2EN, 5);
28521+ if (ret < 0)
28522+ goto out;
28523+
28524+ embd_phy = ((sr_get_phy_addr(dev) & 0x1f) == 0x10 ? 1 : 0);
28525+
28526+ ret = sr_write_cmd(dev, SR_CMD_SW_PHY_SELECT, embd_phy, 0, 0, NULL);
28527+ if (ret < 0) {
28528+ netdev_dbg(dev->net, "Select PHY #1 failed: %d\n", ret);
28529+ goto out;
28530+ }
28531+
28532+ ret = sr_sw_reset(dev, SR_SWRESET_IPPD | SR_SWRESET_PRL);
28533+ if (ret < 0)
28534+ goto out;
28535+
28536+ msleep(150);
28537+
28538+ ret = sr_sw_reset(dev, SR_SWRESET_CLEAR);
28539+ if (ret < 0)
28540+ goto out;
28541+
28542+ msleep(150);
28543+
28544+ if (embd_phy) {
28545+ ret = sr_sw_reset(dev, SR_SWRESET_IPRL);
28546+ if (ret < 0)
28547+ goto out;
28548+ } else {
28549+ ret = sr_sw_reset(dev, SR_SWRESET_PRTE);
28550+ if (ret < 0)
28551+ goto out;
28552+ }
28553+
28554+ msleep(150);
28555+ rx_ctl = sr_read_rx_ctl(dev);
28556+ netdev_dbg(dev->net, "RX_CTL is 0x%04x after software reset\n", rx_ctl);
28557+ ret = sr_write_rx_ctl(dev, 0x0000);
28558+ if (ret < 0)
28559+ goto out;
28560+
28561+ rx_ctl = sr_read_rx_ctl(dev);
28562+ netdev_dbg(dev->net, "RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl);
28563+
28564+ ret = sr_sw_reset(dev, SR_SWRESET_PRL);
28565+ if (ret < 0)
28566+ goto out;
28567+
28568+ msleep(150);
28569+
28570+ ret = sr_sw_reset(dev, SR_SWRESET_IPRL | SR_SWRESET_PRL);
28571+ if (ret < 0)
28572+ goto out;
28573+
28574+ msleep(150);
28575+
28576+ ret = sr9800_set_default_mode(dev);
28577+ if (ret < 0)
28578+ goto out;
28579+
28580+ /* Rewrite MAC address */
28581+ memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN);
28582+ ret = sr_write_cmd(dev, SR_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
28583+ data->mac_addr);
28584+ if (ret < 0)
28585+ goto out;
28586+
28587+ return 0;
28588+
28589+out:
28590+ return ret;
28591+}
28592+
28593+static const struct net_device_ops sr9800_netdev_ops = {
28594+ .ndo_open = usbnet_open,
28595+ .ndo_stop = usbnet_stop,
28596+ .ndo_start_xmit = usbnet_start_xmit,
28597+ .ndo_tx_timeout = usbnet_tx_timeout,
28598+ .ndo_change_mtu = usbnet_change_mtu,
28599+ .ndo_set_mac_address = sr_set_mac_address,
28600+ .ndo_validate_addr = eth_validate_addr,
28601+ .ndo_do_ioctl = sr_ioctl,
28602+ .ndo_set_rx_mode = sr_set_multicast,
28603+};
28604+
28605+static int sr9800_phy_powerup(struct usbnet *dev)
28606+{
28607+ int ret;
28608+
28609+ /* set the embedded Ethernet PHY in power-down state */
28610+ ret = sr_sw_reset(dev, SR_SWRESET_IPPD | SR_SWRESET_IPRL);
28611+ if (ret < 0) {
28612+ netdev_err(dev->net, "Failed to power down PHY : %d\n", ret);
28613+ return ret;
28614+ }
28615+ msleep(20);
28616+
28617+ /* set the embedded Ethernet PHY in power-up state */
28618+ ret = sr_sw_reset(dev, SR_SWRESET_IPRL);
28619+ if (ret < 0) {
28620+ netdev_err(dev->net, "Failed to reset PHY: %d\n", ret);
28621+ return ret;
28622+ }
28623+ msleep(600);
28624+
28625+ /* set the embedded Ethernet PHY in reset state */
28626+ ret = sr_sw_reset(dev, SR_SWRESET_CLEAR);
28627+ if (ret < 0) {
28628+ netdev_err(dev->net, "Failed to power up PHY: %d\n", ret);
28629+ return ret;
28630+ }
28631+ msleep(20);
28632+
28633+ /* set the embedded Ethernet PHY in power-up state */
28634+ ret = sr_sw_reset(dev, SR_SWRESET_IPRL);
28635+ if (ret < 0) {
28636+ netdev_err(dev->net, "Failed to reset PHY: %d\n", ret);
28637+ return ret;
28638+ }
28639+
28640+ return 0;
28641+}
28642+
28643+static int sr9800_bind(struct usbnet *dev, struct usb_interface *intf)
28644+{
28645+ struct sr_data *data = (struct sr_data *)&dev->data;
28646+ u16 led01_mux, led23_mux;
28647+ int ret, embd_phy;
28648+ u32 phyid;
28649+ u16 rx_ctl;
28650+
28651+ data->eeprom_len = SR9800_EEPROM_LEN;
28652+
28653+ usbnet_get_endpoints(dev, intf);
28654+
28655+ /* LED Setting Rule :
28656+ * AABB:CCDD
28657+ * AA : MFA0(LED0)
28658+ * BB : MFA1(LED1)
28659+ * CC : MFA2(LED2), Reserved for SR9800
28660+ * DD : MFA3(LED3), Reserved for SR9800
28661+ */
28662+ led01_mux = (SR_LED_MUX_LINK_ACTIVE << 8) | SR_LED_MUX_LINK;
28663+ led23_mux = (SR_LED_MUX_LINK_ACTIVE << 8) | SR_LED_MUX_TX_ACTIVE;
28664+ ret = sr_write_cmd(dev, SR_CMD_LED_MUX, led01_mux, led23_mux, 0, NULL);
28665+ if (ret < 0) {
28666+ netdev_err(dev->net, "set LINK LED failed : %d\n", ret);
28667+ goto out;
28668+ }
28669+
28670+ /* Get the MAC address */
28671+ ret = sr_read_cmd(dev, SR_CMD_READ_NODE_ID, 0, 0, ETH_ALEN,
28672+ dev->net->dev_addr);
28673+ if (ret < 0) {
28674+ netdev_dbg(dev->net, "Failed to read MAC address: %d\n", ret);
28675+ return ret;
28676+ }
28677+ netdev_dbg(dev->net, "mac addr : %pM\n", dev->net->dev_addr);
28678+
28679+ /* Initialize MII structure */
28680+ dev->mii.dev = dev->net;
28681+ dev->mii.mdio_read = sr_mdio_read;
28682+ dev->mii.mdio_write = sr_mdio_write;
28683+ dev->mii.phy_id_mask = 0x1f;
28684+ dev->mii.reg_num_mask = 0x1f;
28685+ dev->mii.phy_id = sr_get_phy_addr(dev);
28686+
28687+ dev->net->netdev_ops = &sr9800_netdev_ops;
28688+ dev->net->ethtool_ops = &sr9800_ethtool_ops;
28689+
28690+ embd_phy = ((dev->mii.phy_id & 0x1f) == 0x10 ? 1 : 0);
28691+ /* Reset the PHY to normal operation mode */
28692+ ret = sr_write_cmd(dev, SR_CMD_SW_PHY_SELECT, embd_phy, 0, 0, NULL);
28693+ if (ret < 0) {
28694+ netdev_dbg(dev->net, "Select PHY #1 failed: %d\n", ret);
28695+ return ret;
28696+ }
28697+
28698+ /* Init PHY routine */
28699+ ret = sr9800_phy_powerup(dev);
28700+ if (ret < 0)
28701+ goto out;
28702+
28703+ rx_ctl = sr_read_rx_ctl(dev);
28704+ netdev_dbg(dev->net, "RX_CTL is 0x%04x after software reset\n", rx_ctl);
28705+ ret = sr_write_rx_ctl(dev, 0x0000);
28706+ if (ret < 0)
28707+ goto out;
28708+
28709+ rx_ctl = sr_read_rx_ctl(dev);
28710+ netdev_dbg(dev->net, "RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl);
28711+
28712+ /* Read PHYID register *AFTER* the PHY was reset properly */
28713+ phyid = sr_get_phyid(dev);
28714+ netdev_dbg(dev->net, "PHYID=0x%08x\n", phyid);
28715+
28716+ /* medium mode setting */
28717+ ret = sr9800_set_default_mode(dev);
28718+ if (ret < 0)
28719+ goto out;
28720+
28721+ if (dev->udev->speed == USB_SPEED_HIGH) {
28722+ ret = sr_write_cmd(dev, SR_CMD_BULKIN_SIZE,
28723+ SR9800_BULKIN_SIZE[SR9800_MAX_BULKIN_4K].byte_cnt,
28724+ SR9800_BULKIN_SIZE[SR9800_MAX_BULKIN_4K].threshold,
28725+ 0, NULL);
28726+ if (ret < 0) {
28727+ netdev_err(dev->net, "Reset RX_CTL failed: %d\n", ret);
28728+ goto out;
28729+ }
28730+ dev->rx_urb_size =
28731+ SR9800_BULKIN_SIZE[SR9800_MAX_BULKIN_4K].size;
28732+ } else {
28733+ ret = sr_write_cmd(dev, SR_CMD_BULKIN_SIZE,
28734+ SR9800_BULKIN_SIZE[SR9800_MAX_BULKIN_2K].byte_cnt,
28735+ SR9800_BULKIN_SIZE[SR9800_MAX_BULKIN_2K].threshold,
28736+ 0, NULL);
28737+ if (ret < 0) {
28738+ netdev_err(dev->net, "Reset RX_CTL failed: %d\n", ret);
28739+ goto out;
28740+ }
28741+ dev->rx_urb_size =
28742+ SR9800_BULKIN_SIZE[SR9800_MAX_BULKIN_2K].size;
28743+ }
28744+ netdev_dbg(dev->net, "%s : setting rx_urb_size with : %zu\n", __func__,
28745+ dev->rx_urb_size);
28746+ return 0;
28747+
28748+out:
28749+ return ret;
28750+}
28751+
28752+static const struct driver_info sr9800_driver_info = {
28753+ .description = "CoreChip SR9800 USB 2.0 Ethernet",
28754+ .bind = sr9800_bind,
28755+ .status = sr_status,
28756+ .link_reset = sr9800_link_reset,
28757+ .reset = sr9800_reset,
28758+ .flags = DRIVER_FLAG,
28759+ .rx_fixup = sr_rx_fixup,
28760+ .tx_fixup = sr_tx_fixup,
28761+};
28762+
28763+static const struct usb_device_id products[] = {
28764+ {
28765+ USB_DEVICE(0x0fe6, 0x9800), /* SR9800 Device */
28766+ .driver_info = (unsigned long) &sr9800_driver_info,
28767+ },
28768+ {}, /* END */
28769+};
28770+
28771+MODULE_DEVICE_TABLE(usb, products);
28772+
28773+static struct usb_driver sr_driver = {
28774+ .name = DRIVER_NAME,
28775+ .id_table = products,
28776+ .probe = usbnet_probe,
28777+ .suspend = usbnet_suspend,
28778+ .resume = usbnet_resume,
28779+ .disconnect = usbnet_disconnect,
28780+ .supports_autosuspend = 1,
28781+};
28782+
28783+module_usb_driver(sr_driver);
28784+
28785+MODULE_AUTHOR("Liu Junliang <liujunliang_ljl@163.com");
28786+MODULE_VERSION(DRIVER_VERSION);
28787+MODULE_DESCRIPTION("SR9800 USB 2.0 USB2NET Dev : http://www.corechip-sz.com");
28788+MODULE_LICENSE("GPL");
28789diff -Naur backports-3.18.1-1.org/drivers/net/usb/sr9800.h backports-3.18.1-1/drivers/net/usb/sr9800.h
28790--- backports-3.18.1-1.org/drivers/net/usb/sr9800.h 1970-01-01 01:00:00.000000000 +0100
28791+++ backports-3.18.1-1/drivers/net/usb/sr9800.h 2014-12-16 18:39:45.000000000 +0100
28792@@ -0,0 +1,202 @@
28793+/* CoreChip-sz SR9800 one chip USB 2.0 Ethernet Devices
28794+ *
28795+ * Author : Liu Junliang <liujunliang_ljl@163.com>
28796+ *
28797+ * This file is licensed under the terms of the GNU General Public License
28798+ * version 2. This program is licensed "as is" without any warranty of any
28799+ * kind, whether express or implied.
28800+ */
28801+
28802+#ifndef _SR9800_H
28803+#define _SR9800_H
28804+
28805+/* SR9800 spec. command table on Linux Platform */
28806+
28807+/* command : Software Station Management Control Reg */
28808+#define SR_CMD_SET_SW_MII 0x06
28809+/* command : PHY Read Reg */
28810+#define SR_CMD_READ_MII_REG 0x07
28811+/* command : PHY Write Reg */
28812+#define SR_CMD_WRITE_MII_REG 0x08
28813+/* command : Hardware Station Management Control Reg */
28814+#define SR_CMD_SET_HW_MII 0x0a
28815+/* command : SROM Read Reg */
28816+#define SR_CMD_READ_EEPROM 0x0b
28817+/* command : SROM Write Reg */
28818+#define SR_CMD_WRITE_EEPROM 0x0c
28819+/* command : SROM Write Enable Reg */
28820+#define SR_CMD_WRITE_ENABLE 0x0d
28821+/* command : SROM Write Disable Reg */
28822+#define SR_CMD_WRITE_DISABLE 0x0e
28823+/* command : RX Control Read Reg */
28824+#define SR_CMD_READ_RX_CTL 0x0f
28825+#define SR_RX_CTL_PRO (1 << 0)
28826+#define SR_RX_CTL_AMALL (1 << 1)
28827+#define SR_RX_CTL_SEP (1 << 2)
28828+#define SR_RX_CTL_AB (1 << 3)
28829+#define SR_RX_CTL_AM (1 << 4)
28830+#define SR_RX_CTL_AP (1 << 5)
28831+#define SR_RX_CTL_ARP (1 << 6)
28832+#define SR_RX_CTL_SO (1 << 7)
28833+#define SR_RX_CTL_RH1M (1 << 8)
28834+#define SR_RX_CTL_RH2M (1 << 9)
28835+#define SR_RX_CTL_RH3M (1 << 10)
28836+/* command : RX Control Write Reg */
28837+#define SR_CMD_WRITE_RX_CTL 0x10
28838+/* command : IPG0/IPG1/IPG2 Control Read Reg */
28839+#define SR_CMD_READ_IPG012 0x11
28840+/* command : IPG0/IPG1/IPG2 Control Write Reg */
28841+#define SR_CMD_WRITE_IPG012 0x12
28842+/* command : Node ID Read Reg */
28843+#define SR_CMD_READ_NODE_ID 0x13
28844+/* command : Node ID Write Reg */
28845+#define SR_CMD_WRITE_NODE_ID 0x14
28846+/* command : Multicast Filter Array Read Reg */
28847+#define SR_CMD_READ_MULTI_FILTER 0x15
28848+/* command : Multicast Filter Array Write Reg */
28849+#define SR_CMD_WRITE_MULTI_FILTER 0x16
28850+/* command : Eth/HomePNA PHY Address Reg */
28851+#define SR_CMD_READ_PHY_ID 0x19
28852+/* command : Medium Status Read Reg */
28853+#define SR_CMD_READ_MEDIUM_STATUS 0x1a
28854+#define SR_MONITOR_LINK (1 << 1)
28855+#define SR_MONITOR_MAGIC (1 << 2)
28856+#define SR_MONITOR_HSFS (1 << 4)
28857+/* command : Medium Status Write Reg */
28858+#define SR_CMD_WRITE_MEDIUM_MODE 0x1b
28859+#define SR_MEDIUM_GM (1 << 0)
28860+#define SR_MEDIUM_FD (1 << 1)
28861+#define SR_MEDIUM_AC (1 << 2)
28862+#define SR_MEDIUM_ENCK (1 << 3)
28863+#define SR_MEDIUM_RFC (1 << 4)
28864+#define SR_MEDIUM_TFC (1 << 5)
28865+#define SR_MEDIUM_JFE (1 << 6)
28866+#define SR_MEDIUM_PF (1 << 7)
28867+#define SR_MEDIUM_RE (1 << 8)
28868+#define SR_MEDIUM_PS (1 << 9)
28869+#define SR_MEDIUM_RSV (1 << 10)
28870+#define SR_MEDIUM_SBP (1 << 11)
28871+#define SR_MEDIUM_SM (1 << 12)
28872+/* command : Monitor Mode Status Read Reg */
28873+#define SR_CMD_READ_MONITOR_MODE 0x1c
28874+/* command : Monitor Mode Status Write Reg */
28875+#define SR_CMD_WRITE_MONITOR_MODE 0x1d
28876+/* command : GPIO Status Read Reg */
28877+#define SR_CMD_READ_GPIOS 0x1e
28878+#define SR_GPIO_GPO0EN (1 << 0) /* GPIO0 Output enable */
28879+#define SR_GPIO_GPO_0 (1 << 1) /* GPIO0 Output value */
28880+#define SR_GPIO_GPO1EN (1 << 2) /* GPIO1 Output enable */
28881+#define SR_GPIO_GPO_1 (1 << 3) /* GPIO1 Output value */
28882+#define SR_GPIO_GPO2EN (1 << 4) /* GPIO2 Output enable */
28883+#define SR_GPIO_GPO_2 (1 << 5) /* GPIO2 Output value */
28884+#define SR_GPIO_RESERVED (1 << 6) /* Reserved */
28885+#define SR_GPIO_RSE (1 << 7) /* Reload serial EEPROM */
28886+/* command : GPIO Status Write Reg */
28887+#define SR_CMD_WRITE_GPIOS 0x1f
28888+/* command : Eth PHY Power and Reset Control Reg */
28889+#define SR_CMD_SW_RESET 0x20
28890+#define SR_SWRESET_CLEAR 0x00
28891+#define SR_SWRESET_RR (1 << 0)
28892+#define SR_SWRESET_RT (1 << 1)
28893+#define SR_SWRESET_PRTE (1 << 2)
28894+#define SR_SWRESET_PRL (1 << 3)
28895+#define SR_SWRESET_BZ (1 << 4)
28896+#define SR_SWRESET_IPRL (1 << 5)
28897+#define SR_SWRESET_IPPD (1 << 6)
28898+/* command : Software Interface Selection Status Read Reg */
28899+#define SR_CMD_SW_PHY_STATUS 0x21
28900+/* command : Software Interface Selection Status Write Reg */
28901+#define SR_CMD_SW_PHY_SELECT 0x22
28902+/* command : BULK in Buffer Size Reg */
28903+#define SR_CMD_BULKIN_SIZE 0x2A
28904+/* command : LED_MUX Control Reg */
28905+#define SR_CMD_LED_MUX 0x70
28906+#define SR_LED_MUX_TX_ACTIVE (1 << 0)
28907+#define SR_LED_MUX_RX_ACTIVE (1 << 1)
28908+#define SR_LED_MUX_COLLISION (1 << 2)
28909+#define SR_LED_MUX_DUP_COL (1 << 3)
28910+#define SR_LED_MUX_DUP (1 << 4)
28911+#define SR_LED_MUX_SPEED (1 << 5)
28912+#define SR_LED_MUX_LINK_ACTIVE (1 << 6)
28913+#define SR_LED_MUX_LINK (1 << 7)
28914+
28915+/* Register Access Flags */
28916+#define SR_REQ_RD_REG (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
28917+#define SR_REQ_WR_REG (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
28918+
28919+/* Multicast Filter Array size & Max Number */
28920+#define SR_MCAST_FILTER_SIZE 8
28921+#define SR_MAX_MCAST 64
28922+
28923+/* IPG0/1/2 Default Value */
28924+#define SR9800_IPG0_DEFAULT 0x15
28925+#define SR9800_IPG1_DEFAULT 0x0c
28926+#define SR9800_IPG2_DEFAULT 0x12
28927+
28928+/* Medium Status Default Mode */
28929+#define SR9800_MEDIUM_DEFAULT \
28930+ (SR_MEDIUM_FD | SR_MEDIUM_RFC | \
28931+ SR_MEDIUM_TFC | SR_MEDIUM_PS | \
28932+ SR_MEDIUM_AC | SR_MEDIUM_RE)
28933+
28934+/* RX Control Default Setting */
28935+#define SR_DEFAULT_RX_CTL \
28936+ (SR_RX_CTL_SO | SR_RX_CTL_AB | SR_RX_CTL_RH1M)
28937+
28938+/* EEPROM Magic Number & EEPROM Size */
28939+#define SR_EEPROM_MAGIC 0xdeadbeef
28940+#define SR9800_EEPROM_LEN 0xff
28941+
28942+/* SR9800 Driver Version and Driver Name */
28943+#define DRIVER_VERSION "11-Nov-2013"
28944+#define DRIVER_NAME "CoreChips"
28945+#define DRIVER_FLAG \
28946+ (FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR | FLAG_MULTI_PACKET)
28947+
28948+/* SR9800 BULKIN Buffer Size */
28949+#define SR9800_MAX_BULKIN_2K 0
28950+#define SR9800_MAX_BULKIN_4K 1
28951+#define SR9800_MAX_BULKIN_6K 2
28952+#define SR9800_MAX_BULKIN_8K 3
28953+#define SR9800_MAX_BULKIN_16K 4
28954+#define SR9800_MAX_BULKIN_20K 5
28955+#define SR9800_MAX_BULKIN_24K 6
28956+#define SR9800_MAX_BULKIN_32K 7
28957+
28958+struct {unsigned short size, byte_cnt, threshold; } SR9800_BULKIN_SIZE[] = {
28959+ /* 2k */
28960+ {2048, 0x8000, 0x8001},
28961+ /* 4k */
28962+ {4096, 0x8100, 0x8147},
28963+ /* 6k */
28964+ {6144, 0x8200, 0x81EB},
28965+ /* 8k */
28966+ {8192, 0x8300, 0x83D7},
28967+ /* 16 */
28968+ {16384, 0x8400, 0x851E},
28969+ /* 20k */
28970+ {20480, 0x8500, 0x8666},
28971+ /* 24k */
28972+ {24576, 0x8600, 0x87AE},
28973+ /* 32k */
28974+ {32768, 0x8700, 0x8A3D},
28975+};
28976+
28977+/* This structure cannot exceed sizeof(unsigned long [5]) AKA 20 bytes */
28978+struct sr_data {
28979+ u8 multi_filter[SR_MCAST_FILTER_SIZE];
28980+ u8 mac_addr[ETH_ALEN];
28981+ u8 phymode;
28982+ u8 ledmode;
28983+ u8 eeprom_len;
28984+};
28985+
28986+struct sr9800_int_data {
28987+ __le16 res1;
28988+ u8 link;
28989+ __le16 res2;
28990+ u8 status;
28991+ __le16 res3;
28992+} __packed;
28993+
28994+#endif /* _SR9800_H */
28995diff -Naur backports-3.18.1-1.org/drivers/net/usb/zaurus.c backports-3.18.1-1/drivers/net/usb/zaurus.c
28996--- backports-3.18.1-1.org/drivers/net/usb/zaurus.c 1970-01-01 01:00:00.000000000 +0100
28997+++ backports-3.18.1-1/drivers/net/usb/zaurus.c 2014-12-16 18:39:45.000000000 +0100
28998@@ -0,0 +1,385 @@
28999+/*
29000+ * Copyright (C) 2002 Pavel Machek <pavel@ucw.cz>
29001+ * Copyright (C) 2002-2005 by David Brownell
29002+ *
29003+ * This program is free software; you can redistribute it and/or modify
29004+ * it under the terms of the GNU General Public License as published by
29005+ * the Free Software Foundation; either version 2 of the License, or
29006+ * (at your option) any later version.
29007+ *
29008+ * This program is distributed in the hope that it will be useful,
29009+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
29010+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29011+ * GNU General Public License for more details.
29012+ *
29013+ * You should have received a copy of the GNU General Public License
29014+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
29015+ */
29016+
29017+// #define DEBUG // error path messages, extra info
29018+// #define VERBOSE // more; success messages
29019+
29020+#include <linux/module.h>
29021+#include <linux/netdevice.h>
29022+#include <linux/ethtool.h>
29023+#include <linux/workqueue.h>
29024+#include <linux/mii.h>
29025+#include <linux/crc32.h>
29026+#include <linux/usb.h>
29027+#include <linux/usb/cdc.h>
29028+#include <linux/usb/usbnet.h>
29029+
29030+
29031+/*
29032+ * All known Zaurii lie about their standards conformance. At least
29033+ * the earliest SA-1100 models lie by saying they support CDC Ethernet.
29034+ * Some later models (especially PXA-25x and PXA-27x based ones) lie
29035+ * and say they support CDC MDLM (for access to cell phone modems).
29036+ *
29037+ * There are non-Zaurus products that use these same protocols too.
29038+ *
29039+ * The annoying thing is that at the same time Sharp was developing
29040+ * that annoying standards-breaking software, the Linux community had
29041+ * a simple "CDC Subset" working reliably on the same SA-1100 hardware.
29042+ * That is, the same functionality but not violating standards.
29043+ *
29044+ * The CDC Ethernet nonconformance points are troublesome to hosts
29045+ * with a true CDC Ethernet implementation:
29046+ * - Framing appends a CRC, which the spec says drivers "must not" do;
29047+ * - Transfers data in altsetting zero, instead of altsetting 1;
29048+ * - All these peripherals use the same ethernet address.
29049+ *
29050+ * The CDC MDLM nonconformance is less immediately troublesome, since all
29051+ * MDLM implementations are quasi-proprietary anyway.
29052+ */
29053+
29054+static struct sk_buff *
29055+zaurus_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
29056+{
29057+ int padlen;
29058+ struct sk_buff *skb2;
29059+
29060+ padlen = 2;
29061+ if (!skb_cloned(skb)) {
29062+ int tailroom = skb_tailroom(skb);
29063+ if ((padlen + 4) <= tailroom)
29064+ goto done;
29065+ }
29066+ skb2 = skb_copy_expand(skb, 0, 4 + padlen, flags);
29067+ dev_kfree_skb_any(skb);
29068+ skb = skb2;
29069+ if (skb) {
29070+ u32 fcs;
29071+done:
29072+ fcs = crc32_le(~0, skb->data, skb->len);
29073+ fcs = ~fcs;
29074+
29075+ *skb_put (skb, 1) = fcs & 0xff;
29076+ *skb_put (skb, 1) = (fcs>> 8) & 0xff;
29077+ *skb_put (skb, 1) = (fcs>>16) & 0xff;
29078+ *skb_put (skb, 1) = (fcs>>24) & 0xff;
29079+ }
29080+ return skb;
29081+}
29082+
29083+static int zaurus_bind(struct usbnet *dev, struct usb_interface *intf)
29084+{
29085+ /* Belcarra's funky framing has other options; mostly
29086+ * TRAILERS (!) with 4 bytes CRC, and maybe 2 pad bytes.
29087+ */
29088+ dev->net->hard_header_len += 6;
29089+ dev->rx_urb_size = dev->net->hard_header_len + dev->net->mtu;
29090+ return usbnet_generic_cdc_bind(dev, intf);
29091+}
29092+
29093+/* PDA style devices are always connected if present */
29094+static int always_connected (struct usbnet *dev)
29095+{
29096+ return 0;
29097+}
29098+
29099+static const struct driver_info zaurus_sl5x00_info = {
29100+ .description = "Sharp Zaurus SL-5x00",
29101+ .flags = FLAG_POINTTOPOINT | FLAG_FRAMING_Z,
29102+ .check_connect = always_connected,
29103+ .bind = zaurus_bind,
29104+ .unbind = usbnet_cdc_unbind,
29105+ .tx_fixup = zaurus_tx_fixup,
29106+};
29107+#define ZAURUS_STRONGARM_INFO ((unsigned long)&zaurus_sl5x00_info)
29108+
29109+static const struct driver_info zaurus_pxa_info = {
29110+ .description = "Sharp Zaurus, PXA-2xx based",
29111+ .flags = FLAG_POINTTOPOINT | FLAG_FRAMING_Z,
29112+ .check_connect = always_connected,
29113+ .bind = zaurus_bind,
29114+ .unbind = usbnet_cdc_unbind,
29115+ .tx_fixup = zaurus_tx_fixup,
29116+};
29117+#define ZAURUS_PXA_INFO ((unsigned long)&zaurus_pxa_info)
29118+
29119+static const struct driver_info olympus_mxl_info = {
29120+ .description = "Olympus R1000",
29121+ .flags = FLAG_POINTTOPOINT | FLAG_FRAMING_Z,
29122+ .check_connect = always_connected,
29123+ .bind = zaurus_bind,
29124+ .unbind = usbnet_cdc_unbind,
29125+ .tx_fixup = zaurus_tx_fixup,
29126+};
29127+#define OLYMPUS_MXL_INFO ((unsigned long)&olympus_mxl_info)
29128+
29129+
29130+/* Some more recent products using Lineo/Belcarra code will wrongly claim
29131+ * CDC MDLM conformance. They aren't conformant: data endpoints live
29132+ * in the control interface, there's no data interface, and it's not used
29133+ * to talk to a cell phone radio. But at least we can detect these two
29134+ * pseudo-classes, rather than growing this product list with entries for
29135+ * each new nonconformant product (sigh).
29136+ */
29137+static const u8 safe_guid[16] = {
29138+ 0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
29139+ 0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
29140+};
29141+static const u8 blan_guid[16] = {
29142+ 0x74, 0xf0, 0x3d, 0xbd, 0x1e, 0xc1, 0x44, 0x70,
29143+ 0xa3, 0x67, 0x71, 0x34, 0xc9, 0xf5, 0x54, 0x37,
29144+};
29145+
29146+static int blan_mdlm_bind(struct usbnet *dev, struct usb_interface *intf)
29147+{
29148+ u8 *buf = intf->cur_altsetting->extra;
29149+ int len = intf->cur_altsetting->extralen;
29150+ struct usb_cdc_mdlm_desc *desc = NULL;
29151+ struct usb_cdc_mdlm_detail_desc *detail = NULL;
29152+
29153+ while (len > 3) {
29154+ if (buf [1] != USB_DT_CS_INTERFACE)
29155+ goto next_desc;
29156+
29157+ /* use bDescriptorSubType, and just verify that we get a
29158+ * "BLAN" (or "SAFE") descriptor.
29159+ */
29160+ switch (buf [2]) {
29161+ case USB_CDC_MDLM_TYPE:
29162+ if (desc) {
29163+ dev_dbg(&intf->dev, "extra MDLM\n");
29164+ goto bad_desc;
29165+ }
29166+ desc = (void *) buf;
29167+ if (desc->bLength != sizeof *desc) {
29168+ dev_dbg(&intf->dev, "MDLM len %u\n",
29169+ desc->bLength);
29170+ goto bad_desc;
29171+ }
29172+ /* expect bcdVersion 1.0, ignore */
29173+ if (memcmp(&desc->bGUID, blan_guid, 16) &&
29174+ memcmp(&desc->bGUID, safe_guid, 16)) {
29175+ /* hey, this one might _really_ be MDLM! */
29176+ dev_dbg(&intf->dev, "MDLM guid\n");
29177+ goto bad_desc;
29178+ }
29179+ break;
29180+ case USB_CDC_MDLM_DETAIL_TYPE:
29181+ if (detail) {
29182+ dev_dbg(&intf->dev, "extra MDLM detail\n");
29183+ goto bad_desc;
29184+ }
29185+ detail = (void *) buf;
29186+ switch (detail->bGuidDescriptorType) {
29187+ case 0: /* "SAFE" */
29188+ if (detail->bLength != (sizeof *detail + 2))
29189+ goto bad_detail;
29190+ break;
29191+ case 1: /* "BLAN" */
29192+ if (detail->bLength != (sizeof *detail + 3))
29193+ goto bad_detail;
29194+ break;
29195+ default:
29196+ goto bad_detail;
29197+ }
29198+
29199+ /* assuming we either noticed BLAN already, or will
29200+ * find it soon, there are some data bytes here:
29201+ * - bmNetworkCapabilities (unused)
29202+ * - bmDataCapabilities (bits, see below)
29203+ * - bPad (ignored, for PADAFTER -- BLAN-only)
29204+ * bits are:
29205+ * - 0x01 -- Zaurus framing (add CRC)
29206+ * - 0x02 -- PADBEFORE (CRC includes some padding)
29207+ * - 0x04 -- PADAFTER (some padding after CRC)
29208+ * - 0x08 -- "fermat" packet mangling (for hw bugs)
29209+ * the PADBEFORE appears not to matter; we interop
29210+ * with devices that use it and those that don't.
29211+ */
29212+ if ((detail->bDetailData[1] & ~0x02) != 0x01) {
29213+ /* bmDataCapabilities == 0 would be fine too,
29214+ * but framing is minidriver-coupled for now.
29215+ */
29216+bad_detail:
29217+ dev_dbg(&intf->dev,
29218+ "bad MDLM detail, %d %d %d\n",
29219+ detail->bLength,
29220+ detail->bDetailData[0],
29221+ detail->bDetailData[2]);
29222+ goto bad_desc;
29223+ }
29224+
29225+ /* same extra framing as for non-BLAN mode */
29226+ dev->net->hard_header_len += 6;
29227+ dev->rx_urb_size = dev->net->hard_header_len
29228+ + dev->net->mtu;
29229+ break;
29230+ }
29231+next_desc:
29232+ len -= buf [0]; /* bLength */
29233+ buf += buf [0];
29234+ }
29235+
29236+ if (!desc || !detail) {
29237+ dev_dbg(&intf->dev, "missing cdc mdlm %s%sdescriptor\n",
29238+ desc ? "" : "func ",
29239+ detail ? "" : "detail ");
29240+ goto bad_desc;
29241+ }
29242+
29243+ /* There's probably a CDC Ethernet descriptor there, but we can't
29244+ * rely on the Ethernet address it provides since not all vendors
29245+ * bother to make it unique. Likewise there's no point in tracking
29246+ * of the CDC event notifications.
29247+ */
29248+ return usbnet_get_endpoints(dev, intf);
29249+
29250+bad_desc:
29251+ dev_info(&dev->udev->dev, "unsupported MDLM descriptors\n");
29252+ return -ENODEV;
29253+}
29254+
29255+static const struct driver_info bogus_mdlm_info = {
29256+ .description = "pseudo-MDLM (BLAN) device",
29257+ .flags = FLAG_POINTTOPOINT | FLAG_FRAMING_Z,
29258+ .check_connect = always_connected,
29259+ .tx_fixup = zaurus_tx_fixup,
29260+ .bind = blan_mdlm_bind,
29261+};
29262+
29263+static const struct usb_device_id products [] = {
29264+#define ZAURUS_MASTER_INTERFACE \
29265+ .bInterfaceClass = USB_CLASS_COMM, \
29266+ .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, \
29267+ .bInterfaceProtocol = USB_CDC_PROTO_NONE
29268+
29269+/* SA-1100 based Sharp Zaurus ("collie"), or compatible. */
29270+{
29271+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29272+ | USB_DEVICE_ID_MATCH_DEVICE,
29273+ .idVendor = 0x04DD,
29274+ .idProduct = 0x8004,
29275+ ZAURUS_MASTER_INTERFACE,
29276+ .driver_info = ZAURUS_STRONGARM_INFO,
29277+},
29278+
29279+/* PXA-2xx based models are also lying-about-cdc. If you add any
29280+ * more devices that claim to be CDC Ethernet, make sure they get
29281+ * added to the blacklist in cdc_ether too.
29282+ *
29283+ * NOTE: OpenZaurus versions with 2.6 kernels won't use these entries,
29284+ * unlike the older ones with 2.4 "embedix" kernels.
29285+ */
29286+{
29287+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29288+ | USB_DEVICE_ID_MATCH_DEVICE,
29289+ .idVendor = 0x04DD,
29290+ .idProduct = 0x8005, /* A-300 */
29291+ ZAURUS_MASTER_INTERFACE,
29292+ .driver_info = ZAURUS_PXA_INFO,
29293+}, {
29294+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29295+ | USB_DEVICE_ID_MATCH_DEVICE,
29296+ .idVendor = 0x04DD,
29297+ .idProduct = 0x8006, /* B-500/SL-5600 */
29298+ ZAURUS_MASTER_INTERFACE,
29299+ .driver_info = ZAURUS_PXA_INFO,
29300+}, {
29301+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29302+ | USB_DEVICE_ID_MATCH_DEVICE,
29303+ .idVendor = 0x04DD,
29304+ .idProduct = 0x8007, /* C-700 */
29305+ ZAURUS_MASTER_INTERFACE,
29306+ .driver_info = ZAURUS_PXA_INFO,
29307+}, {
29308+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29309+ | USB_DEVICE_ID_MATCH_DEVICE,
29310+ .idVendor = 0x04DD,
29311+ .idProduct = 0x9031, /* C-750 C-760 */
29312+ ZAURUS_MASTER_INTERFACE,
29313+ .driver_info = ZAURUS_PXA_INFO,
29314+}, {
29315+ /* C-750/C-760/C-860/SL-C3000 PDA in MDLM mode */
29316+ USB_DEVICE_AND_INTERFACE_INFO(0x04DD, 0x9031, USB_CLASS_COMM,
29317+ USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
29318+ .driver_info = (unsigned long) &bogus_mdlm_info,
29319+}, {
29320+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29321+ | USB_DEVICE_ID_MATCH_DEVICE,
29322+ .idVendor = 0x04DD,
29323+ .idProduct = 0x9032, /* SL-6000 */
29324+ ZAURUS_MASTER_INTERFACE,
29325+ .driver_info = ZAURUS_PXA_INFO,
29326+}, {
29327+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29328+ | USB_DEVICE_ID_MATCH_DEVICE,
29329+ .idVendor = 0x04DD,
29330+ /* reported with some C860 units */
29331+ .idProduct = 0x9050, /* C-860 */
29332+ ZAURUS_MASTER_INTERFACE,
29333+ .driver_info = ZAURUS_PXA_INFO,
29334+},
29335+{
29336+ /* Motorola Rokr E6 */
29337+ USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x6027, USB_CLASS_COMM,
29338+ USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
29339+ .driver_info = (unsigned long) &bogus_mdlm_info,
29340+}, {
29341+ /* Motorola MOTOMAGX phones */
29342+ USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x6425, USB_CLASS_COMM,
29343+ USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
29344+ .driver_info = (unsigned long) &bogus_mdlm_info,
29345+},
29346+
29347+/* Olympus has some models with a Zaurus-compatible option.
29348+ * R-1000 uses a FreeScale i.MXL cpu (ARMv4T)
29349+ */
29350+{
29351+ .match_flags = USB_DEVICE_ID_MATCH_INT_INFO
29352+ | USB_DEVICE_ID_MATCH_DEVICE,
29353+ .idVendor = 0x07B4,
29354+ .idProduct = 0x0F02, /* R-1000 */
29355+ ZAURUS_MASTER_INTERFACE,
29356+ .driver_info = OLYMPUS_MXL_INFO,
29357+},
29358+
29359+/* Logitech Harmony 900 - uses the pseudo-MDLM (BLAN) driver */
29360+{
29361+ USB_DEVICE_AND_INTERFACE_INFO(0x046d, 0xc11f, USB_CLASS_COMM,
29362+ USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
29363+ .driver_info = (unsigned long) &bogus_mdlm_info,
29364+},
29365+ { }, // END
29366+};
29367+MODULE_DEVICE_TABLE(usb, products);
29368+
29369+static struct usb_driver zaurus_driver = {
29370+ .name = "zaurus",
29371+ .id_table = products,
29372+ .probe = usbnet_probe,
29373+ .disconnect = usbnet_disconnect,
29374+ .suspend = usbnet_suspend,
29375+ .resume = usbnet_resume,
29376+ .disable_hub_initiated_lpm = 1,
29377+};
29378+
29379+module_usb_driver(zaurus_driver);
29380+
29381+MODULE_AUTHOR("Pavel Machek, David Brownell");
29382+MODULE_DESCRIPTION("Sharp Zaurus PDA, and compatible products");
29383+MODULE_LICENSE("GPL");
IPFire 2.x development tree