Merge branch 'master' of git://www.denx.de/git/u-boot-mmc
[pandora-u-boot.git] / drivers / usb / eth / asix.c
1 /*
2  * Copyright (c) 2011 The Chromium OS Authors.
3  * See file CREDITS for list of people who contributed to this
4  * project.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation; either version 2 of
9  * the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
19  * MA 02111-1307 USA
20  */
21
22 #include <common.h>
23 #include <usb.h>
24 #include <linux/mii.h>
25 #include "usb_ether.h"
26 #include <malloc.h>
27
28
29 /* ASIX AX8817X based USB 2.0 Ethernet Devices */
30
31 #define AX_CMD_SET_SW_MII               0x06
32 #define AX_CMD_READ_MII_REG             0x07
33 #define AX_CMD_WRITE_MII_REG            0x08
34 #define AX_CMD_SET_HW_MII               0x0a
35 #define AX_CMD_READ_EEPROM              0x0b
36 #define AX_CMD_READ_RX_CTL              0x0f
37 #define AX_CMD_WRITE_RX_CTL             0x10
38 #define AX_CMD_WRITE_IPG0               0x12
39 #define AX_CMD_READ_NODE_ID             0x13
40 #define AX_CMD_WRITE_NODE_ID    0x14
41 #define AX_CMD_READ_PHY_ID              0x19
42 #define AX_CMD_WRITE_MEDIUM_MODE        0x1b
43 #define AX_CMD_WRITE_GPIOS              0x1f
44 #define AX_CMD_SW_RESET                 0x20
45 #define AX_CMD_SW_PHY_SELECT            0x22
46
47 #define AX_SWRESET_CLEAR                0x00
48 #define AX_SWRESET_PRTE                 0x04
49 #define AX_SWRESET_PRL                  0x08
50 #define AX_SWRESET_IPRL                 0x20
51 #define AX_SWRESET_IPPD                 0x40
52
53 #define AX88772_IPG0_DEFAULT            0x15
54 #define AX88772_IPG1_DEFAULT            0x0c
55 #define AX88772_IPG2_DEFAULT            0x12
56
57 /* AX88772 & AX88178 Medium Mode Register */
58 #define AX_MEDIUM_PF            0x0080
59 #define AX_MEDIUM_JFE           0x0040
60 #define AX_MEDIUM_TFC           0x0020
61 #define AX_MEDIUM_RFC           0x0010
62 #define AX_MEDIUM_ENCK          0x0008
63 #define AX_MEDIUM_AC            0x0004
64 #define AX_MEDIUM_FD            0x0002
65 #define AX_MEDIUM_GM            0x0001
66 #define AX_MEDIUM_SM            0x1000
67 #define AX_MEDIUM_SBP           0x0800
68 #define AX_MEDIUM_PS            0x0200
69 #define AX_MEDIUM_RE            0x0100
70
71 #define AX88178_MEDIUM_DEFAULT  \
72         (AX_MEDIUM_PS | AX_MEDIUM_FD | AX_MEDIUM_AC | \
73          AX_MEDIUM_RFC | AX_MEDIUM_TFC | AX_MEDIUM_JFE | \
74          AX_MEDIUM_RE)
75
76 #define AX88772_MEDIUM_DEFAULT  \
77         (AX_MEDIUM_FD | AX_MEDIUM_RFC | \
78          AX_MEDIUM_TFC | AX_MEDIUM_PS | \
79          AX_MEDIUM_AC | AX_MEDIUM_RE)
80
81 /* AX88772 & AX88178 RX_CTL values */
82 #define AX_RX_CTL_SO                    0x0080
83 #define AX_RX_CTL_AB                    0x0008
84
85 #define AX_DEFAULT_RX_CTL       \
86         (AX_RX_CTL_SO | AX_RX_CTL_AB)
87
88 /* GPIO 2 toggles */
89 #define AX_GPIO_GPO2EN          0x10    /* GPIO2 Output enable */
90 #define AX_GPIO_GPO_2           0x20    /* GPIO2 Output value */
91 #define AX_GPIO_RSE             0x80    /* Reload serial EEPROM */
92
93 /* local defines */
94 #define ASIX_BASE_NAME "asx"
95 #define USB_CTRL_SET_TIMEOUT 5000
96 #define USB_CTRL_GET_TIMEOUT 5000
97 #define USB_BULK_SEND_TIMEOUT 5000
98 #define USB_BULK_RECV_TIMEOUT 5000
99
100 #define AX_RX_URB_SIZE 2048
101 #define PHY_CONNECT_TIMEOUT 5000
102
103 /* asix_flags defines */
104 #define FLAG_NONE                       0
105 #define FLAG_TYPE_AX88172       (1U << 0)
106 #define FLAG_TYPE_AX88772       (1U << 1)
107 #define FLAG_TYPE_AX88772B      (1U << 2)
108 #define FLAG_EEPROM_MAC         (1U << 3) /* initial mac address in eeprom */
109
110 /* local vars */
111 static int curr_eth_dev; /* index for name of next device detected */
112
113 /* driver private */
114 struct asix_private {
115         int flags;
116 };
117
118 /*
119  * Asix infrastructure commands
120  */
121 static int asix_write_cmd(struct ueth_data *dev, u8 cmd, u16 value, u16 index,
122                              u16 size, void *data)
123 {
124         int len;
125
126         debug("asix_write_cmd() cmd=0x%02x value=0x%04x index=0x%04x "
127                 "size=%d\n", cmd, value, index, size);
128
129         len = usb_control_msg(
130                 dev->pusb_dev,
131                 usb_sndctrlpipe(dev->pusb_dev, 0),
132                 cmd,
133                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
134                 value,
135                 index,
136                 data,
137                 size,
138                 USB_CTRL_SET_TIMEOUT);
139
140         return len == size ? 0 : -1;
141 }
142
143 static int asix_read_cmd(struct ueth_data *dev, u8 cmd, u16 value, u16 index,
144                             u16 size, void *data)
145 {
146         int len;
147
148         debug("asix_read_cmd() cmd=0x%02x value=0x%04x index=0x%04x size=%d\n",
149                 cmd, value, index, size);
150
151         len = usb_control_msg(
152                 dev->pusb_dev,
153                 usb_rcvctrlpipe(dev->pusb_dev, 0),
154                 cmd,
155                 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
156                 value,
157                 index,
158                 data,
159                 size,
160                 USB_CTRL_GET_TIMEOUT);
161         return len == size ? 0 : -1;
162 }
163
164 static inline int asix_set_sw_mii(struct ueth_data *dev)
165 {
166         int ret;
167
168         ret = asix_write_cmd(dev, AX_CMD_SET_SW_MII, 0x0000, 0, 0, NULL);
169         if (ret < 0)
170                 debug("Failed to enable software MII access\n");
171         return ret;
172 }
173
174 static inline int asix_set_hw_mii(struct ueth_data *dev)
175 {
176         int ret;
177
178         ret = asix_write_cmd(dev, AX_CMD_SET_HW_MII, 0x0000, 0, 0, NULL);
179         if (ret < 0)
180                 debug("Failed to enable hardware MII access\n");
181         return ret;
182 }
183
184 static int asix_mdio_read(struct ueth_data *dev, int phy_id, int loc)
185 {
186         ALLOC_CACHE_ALIGN_BUFFER(__le16, res, 1);
187
188         asix_set_sw_mii(dev);
189         asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id, (__u16)loc, 2, res);
190         asix_set_hw_mii(dev);
191
192         debug("asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
193                         phy_id, loc, le16_to_cpu(*res));
194
195         return le16_to_cpu(*res);
196 }
197
198 static void
199 asix_mdio_write(struct ueth_data *dev, int phy_id, int loc, int val)
200 {
201         ALLOC_CACHE_ALIGN_BUFFER(__le16, res, 1);
202         *res = cpu_to_le16(val);
203
204         debug("asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
205                         phy_id, loc, val);
206         asix_set_sw_mii(dev);
207         asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2, res);
208         asix_set_hw_mii(dev);
209 }
210
211 /*
212  * Asix "high level" commands
213  */
214 static int asix_sw_reset(struct ueth_data *dev, u8 flags)
215 {
216         int ret;
217
218         ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL);
219         if (ret < 0)
220                 debug("Failed to send software reset: %02x\n", ret);
221         else
222                 udelay(150 * 1000);
223
224         return ret;
225 }
226
227 static inline int asix_get_phy_addr(struct ueth_data *dev)
228 {
229         ALLOC_CACHE_ALIGN_BUFFER(u8, buf, 2);
230
231         int ret = asix_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf);
232
233         debug("asix_get_phy_addr()\n");
234
235         if (ret < 0) {
236                 debug("Error reading PHYID register: %02x\n", ret);
237                 goto out;
238         }
239         debug("asix_get_phy_addr() returning 0x%02x%02x\n", buf[0], buf[1]);
240         ret = buf[1];
241
242 out:
243         return ret;
244 }
245
246 static int asix_write_medium_mode(struct ueth_data *dev, u16 mode)
247 {
248         int ret;
249
250         debug("asix_write_medium_mode() - mode = 0x%04x\n", mode);
251         ret = asix_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode,
252                         0, 0, NULL);
253         if (ret < 0) {
254                 debug("Failed to write Medium Mode mode to 0x%04x: %02x\n",
255                         mode, ret);
256         }
257         return ret;
258 }
259
260 static u16 asix_read_rx_ctl(struct ueth_data *dev)
261 {
262         ALLOC_CACHE_ALIGN_BUFFER(__le16, v, 1);
263
264         int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, v);
265
266         if (ret < 0)
267                 debug("Error reading RX_CTL register: %02x\n", ret);
268         else
269                 ret = le16_to_cpu(*v);
270         return ret;
271 }
272
273 static int asix_write_rx_ctl(struct ueth_data *dev, u16 mode)
274 {
275         int ret;
276
277         debug("asix_write_rx_ctl() - mode = 0x%04x\n", mode);
278         ret = asix_write_cmd(dev, AX_CMD_WRITE_RX_CTL, mode, 0, 0, NULL);
279         if (ret < 0) {
280                 debug("Failed to write RX_CTL mode to 0x%04x: %02x\n",
281                                 mode, ret);
282         }
283         return ret;
284 }
285
286 static int asix_write_gpio(struct ueth_data *dev, u16 value, int sleep)
287 {
288         int ret;
289
290         debug("asix_write_gpio() - value = 0x%04x\n", value);
291         ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS, value, 0, 0, NULL);
292         if (ret < 0) {
293                 debug("Failed to write GPIO value 0x%04x: %02x\n",
294                         value, ret);
295         }
296         if (sleep)
297                 udelay(sleep * 1000);
298
299         return ret;
300 }
301
302 static int asix_write_hwaddr(struct eth_device *eth)
303 {
304         struct ueth_data *dev = (struct ueth_data *)eth->priv;
305         int ret;
306         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buf, ETH_ALEN);
307
308         memcpy(buf, eth->enetaddr, ETH_ALEN);
309
310         ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN, buf);
311         if (ret < 0)
312                 debug("Failed to set MAC address: %02x\n", ret);
313
314         return ret;
315 }
316
317 /*
318  * mii commands
319  */
320
321 /*
322  * mii_nway_restart - restart NWay (autonegotiation) for this interface
323  *
324  * Returns 0 on success, negative on error.
325  */
326 static int mii_nway_restart(struct ueth_data *dev)
327 {
328         int bmcr;
329         int r = -1;
330
331         /* if autoneg is off, it's an error */
332         bmcr = asix_mdio_read(dev, dev->phy_id, MII_BMCR);
333
334         if (bmcr & BMCR_ANENABLE) {
335                 bmcr |= BMCR_ANRESTART;
336                 asix_mdio_write(dev, dev->phy_id, MII_BMCR, bmcr);
337                 r = 0;
338         }
339
340         return r;
341 }
342
343 static int asix_read_mac(struct eth_device *eth)
344 {
345         struct ueth_data *dev = (struct ueth_data *)eth->priv;
346         struct asix_private *priv = (struct asix_private *)dev->dev_priv;
347         int i;
348         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buf, ETH_ALEN);
349
350         if (priv->flags & FLAG_EEPROM_MAC) {
351                 for (i = 0; i < (ETH_ALEN >> 1); i++) {
352                         if (asix_read_cmd(dev, AX_CMD_READ_EEPROM,
353                                           0x04 + i, 0, 2, buf) < 0) {
354                                 debug("Failed to read SROM address 04h.\n");
355                                 return -1;
356                         }
357                         memcpy((eth->enetaddr + i * 2), buf, 2);
358                 }
359         } else {
360                 if (asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf)
361                      < 0) {
362                         debug("Failed to read MAC address.\n");
363                         return -1;
364                 }
365                 memcpy(eth->enetaddr, buf, ETH_ALEN);
366         }
367
368         return 0;
369 }
370
371 static int asix_basic_reset(struct ueth_data *dev)
372 {
373         int embd_phy;
374         u16 rx_ctl;
375
376         if (asix_write_gpio(dev,
377                         AX_GPIO_RSE | AX_GPIO_GPO_2 | AX_GPIO_GPO2EN, 5) < 0)
378                 return -1;
379
380         /* 0x10 is the phy id of the embedded 10/100 ethernet phy */
381         embd_phy = ((asix_get_phy_addr(dev) & 0x1f) == 0x10 ? 1 : 0);
382         if (asix_write_cmd(dev, AX_CMD_SW_PHY_SELECT,
383                                 embd_phy, 0, 0, NULL) < 0) {
384                 debug("Select PHY #1 failed\n");
385                 return -1;
386         }
387
388         if (asix_sw_reset(dev, AX_SWRESET_IPPD | AX_SWRESET_PRL) < 0)
389                 return -1;
390
391         if (asix_sw_reset(dev, AX_SWRESET_CLEAR) < 0)
392                 return -1;
393
394         if (embd_phy) {
395                 if (asix_sw_reset(dev, AX_SWRESET_IPRL) < 0)
396                         return -1;
397         } else {
398                 if (asix_sw_reset(dev, AX_SWRESET_PRTE) < 0)
399                         return -1;
400         }
401
402         rx_ctl = asix_read_rx_ctl(dev);
403         debug("RX_CTL is 0x%04x after software reset\n", rx_ctl);
404         if (asix_write_rx_ctl(dev, 0x0000) < 0)
405                 return -1;
406
407         rx_ctl = asix_read_rx_ctl(dev);
408         debug("RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl);
409
410         dev->phy_id = asix_get_phy_addr(dev);
411         if (dev->phy_id < 0)
412                 debug("Failed to read phy id\n");
413
414         asix_mdio_write(dev, dev->phy_id, MII_BMCR, BMCR_RESET);
415         asix_mdio_write(dev, dev->phy_id, MII_ADVERTISE,
416                         ADVERTISE_ALL | ADVERTISE_CSMA);
417         mii_nway_restart(dev);
418
419         if (asix_write_medium_mode(dev, AX88772_MEDIUM_DEFAULT) < 0)
420                 return -1;
421
422         if (asix_write_cmd(dev, AX_CMD_WRITE_IPG0,
423                                 AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,
424                                 AX88772_IPG2_DEFAULT, 0, NULL) < 0) {
425                 debug("Write IPG,IPG1,IPG2 failed\n");
426                 return -1;
427         }
428
429         return 0;
430 }
431
432 /*
433  * Asix callbacks
434  */
435 static int asix_init(struct eth_device *eth, bd_t *bd)
436 {
437         struct ueth_data        *dev = (struct ueth_data *)eth->priv;
438         int timeout = 0;
439 #define TIMEOUT_RESOLUTION 50   /* ms */
440         int link_detected;
441
442         debug("** %s()\n", __func__);
443
444         if (asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL) < 0)
445                 goto out_err;
446
447         do {
448                 link_detected = asix_mdio_read(dev, dev->phy_id, MII_BMSR) &
449                         BMSR_LSTATUS;
450                 if (!link_detected) {
451                         if (timeout == 0)
452                                 printf("Waiting for Ethernet connection... ");
453                         udelay(TIMEOUT_RESOLUTION * 1000);
454                         timeout += TIMEOUT_RESOLUTION;
455                 }
456         } while (!link_detected && timeout < PHY_CONNECT_TIMEOUT);
457         if (link_detected) {
458                 if (timeout != 0)
459                         printf("done.\n");
460         } else {
461                 printf("unable to connect.\n");
462                 goto out_err;
463         }
464
465         return 0;
466 out_err:
467         return -1;
468 }
469
470 static int asix_send(struct eth_device *eth, void *packet, int length)
471 {
472         struct ueth_data *dev = (struct ueth_data *)eth->priv;
473         int err;
474         u32 packet_len;
475         int actual_len;
476         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, msg,
477                 PKTSIZE + sizeof(packet_len));
478
479         debug("** %s(), len %d\n", __func__, length);
480
481         packet_len = (((length) ^ 0x0000ffff) << 16) + (length);
482         cpu_to_le32s(&packet_len);
483
484         memcpy(msg, &packet_len, sizeof(packet_len));
485         memcpy(msg + sizeof(packet_len), (void *)packet, length);
486         if (length & 1)
487                 length++;
488
489         err = usb_bulk_msg(dev->pusb_dev,
490                                 usb_sndbulkpipe(dev->pusb_dev, dev->ep_out),
491                                 (void *)msg,
492                                 length + sizeof(packet_len),
493                                 &actual_len,
494                                 USB_BULK_SEND_TIMEOUT);
495         debug("Tx: len = %u, actual = %u, err = %d\n",
496                         length + sizeof(packet_len), actual_len, err);
497
498         return err;
499 }
500
501 static int asix_recv(struct eth_device *eth)
502 {
503         struct ueth_data *dev = (struct ueth_data *)eth->priv;
504         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, recv_buf, AX_RX_URB_SIZE);
505         unsigned char *buf_ptr;
506         int err;
507         int actual_len;
508         u32 packet_len;
509
510         debug("** %s()\n", __func__);
511
512         err = usb_bulk_msg(dev->pusb_dev,
513                                 usb_rcvbulkpipe(dev->pusb_dev, dev->ep_in),
514                                 (void *)recv_buf,
515                                 AX_RX_URB_SIZE,
516                                 &actual_len,
517                                 USB_BULK_RECV_TIMEOUT);
518         debug("Rx: len = %u, actual = %u, err = %d\n", AX_RX_URB_SIZE,
519                 actual_len, err);
520         if (err != 0) {
521                 debug("Rx: failed to receive\n");
522                 return -1;
523         }
524         if (actual_len > AX_RX_URB_SIZE) {
525                 debug("Rx: received too many bytes %d\n", actual_len);
526                 return -1;
527         }
528
529         buf_ptr = recv_buf;
530         while (actual_len > 0) {
531                 /*
532                  * 1st 4 bytes contain the length of the actual data as two
533                  * complementary 16-bit words. Extract the length of the data.
534                  */
535                 if (actual_len < sizeof(packet_len)) {
536                         debug("Rx: incomplete packet length\n");
537                         return -1;
538                 }
539                 memcpy(&packet_len, buf_ptr, sizeof(packet_len));
540                 le32_to_cpus(&packet_len);
541                 if (((~packet_len >> 16) & 0x7ff) != (packet_len & 0x7ff)) {
542                         debug("Rx: malformed packet length: %#x (%#x:%#x)\n",
543                               packet_len, (~packet_len >> 16) & 0x7ff,
544                               packet_len & 0x7ff);
545                         return -1;
546                 }
547                 packet_len = packet_len & 0x7ff;
548                 if (packet_len > actual_len - sizeof(packet_len)) {
549                         debug("Rx: too large packet: %d\n", packet_len);
550                         return -1;
551                 }
552
553                 /* Notify net stack */
554                 NetReceive(buf_ptr + sizeof(packet_len), packet_len);
555
556                 /* Adjust for next iteration. Packets are padded to 16-bits */
557                 if (packet_len & 1)
558                         packet_len++;
559                 actual_len -= sizeof(packet_len) + packet_len;
560                 buf_ptr += sizeof(packet_len) + packet_len;
561         }
562
563         return err;
564 }
565
566 static void asix_halt(struct eth_device *eth)
567 {
568         debug("** %s()\n", __func__);
569 }
570
571 /*
572  * Asix probing functions
573  */
574 void asix_eth_before_probe(void)
575 {
576         curr_eth_dev = 0;
577 }
578
579 struct asix_dongle {
580         unsigned short vendor;
581         unsigned short product;
582         int flags;
583 };
584
585 static const struct asix_dongle const asix_dongles[] = {
586         { 0x05ac, 0x1402, FLAG_TYPE_AX88772 },  /* Apple USB Ethernet Adapter */
587         { 0x07d1, 0x3c05, FLAG_TYPE_AX88772 },  /* D-Link DUB-E100 H/W Ver B1 */
588         /* Cables-to-Go USB Ethernet Adapter */
589         { 0x0b95, 0x772a, FLAG_TYPE_AX88772 },
590         { 0x0b95, 0x7720, FLAG_TYPE_AX88772 },  /* Trendnet TU2-ET100 V3.0R */
591         { 0x0b95, 0x1720, FLAG_TYPE_AX88172 },  /* SMC */
592         { 0x0db0, 0xa877, FLAG_TYPE_AX88772 },  /* MSI - ASIX 88772a */
593         { 0x13b1, 0x0018, FLAG_TYPE_AX88172 },  /* Linksys 200M v2.1 */
594         { 0x1557, 0x7720, FLAG_TYPE_AX88772 },  /* 0Q0 cable ethernet */
595         /* DLink DUB-E100 H/W Ver B1 Alternate */
596         { 0x2001, 0x3c05, FLAG_TYPE_AX88772 },
597         /* ASIX 88772B */
598         { 0x0b95, 0x772b, FLAG_TYPE_AX88772B | FLAG_EEPROM_MAC },
599         { 0x0000, 0x0000, FLAG_NONE }   /* END - Do not remove */
600 };
601
602 /* Probe to see if a new device is actually an asix device */
603 int asix_eth_probe(struct usb_device *dev, unsigned int ifnum,
604                       struct ueth_data *ss)
605 {
606         struct usb_interface *iface;
607         struct usb_interface_descriptor *iface_desc;
608         int ep_in_found = 0, ep_out_found = 0;
609         int i;
610
611         /* let's examine the device now */
612         iface = &dev->config.if_desc[ifnum];
613         iface_desc = &dev->config.if_desc[ifnum].desc;
614
615         for (i = 0; asix_dongles[i].vendor != 0; i++) {
616                 if (dev->descriptor.idVendor == asix_dongles[i].vendor &&
617                     dev->descriptor.idProduct == asix_dongles[i].product)
618                         /* Found a supported dongle */
619                         break;
620         }
621
622         if (asix_dongles[i].vendor == 0)
623                 return 0;
624
625         memset(ss, 0, sizeof(struct ueth_data));
626
627         /* At this point, we know we've got a live one */
628         debug("\n\nUSB Ethernet device detected: %#04x:%#04x\n",
629               dev->descriptor.idVendor, dev->descriptor.idProduct);
630
631         /* Initialize the ueth_data structure with some useful info */
632         ss->ifnum = ifnum;
633         ss->pusb_dev = dev;
634         ss->subclass = iface_desc->bInterfaceSubClass;
635         ss->protocol = iface_desc->bInterfaceProtocol;
636
637         /* alloc driver private */
638         ss->dev_priv = calloc(1, sizeof(struct asix_private));
639         if (!ss->dev_priv)
640                 return 0;
641
642         ((struct asix_private *)ss->dev_priv)->flags = asix_dongles[i].flags;
643
644         /*
645          * We are expecting a minimum of 3 endpoints - in, out (bulk), and
646          * int. We will ignore any others.
647          */
648         for (i = 0; i < iface_desc->bNumEndpoints; i++) {
649                 /* is it an BULK endpoint? */
650                 if ((iface->ep_desc[i].bmAttributes &
651                      USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) {
652                         u8 ep_addr = iface->ep_desc[i].bEndpointAddress;
653                         if (ep_addr & USB_DIR_IN) {
654                                 if (!ep_in_found) {
655                                         ss->ep_in = ep_addr &
656                                                 USB_ENDPOINT_NUMBER_MASK;
657                                         ep_in_found = 1;
658                                 }
659                         } else {
660                                 if (!ep_out_found) {
661                                         ss->ep_out = ep_addr &
662                                                 USB_ENDPOINT_NUMBER_MASK;
663                                         ep_out_found = 1;
664                                 }
665                         }
666                 }
667
668                 /* is it an interrupt endpoint? */
669                 if ((iface->ep_desc[i].bmAttributes &
670                     USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) {
671                         ss->ep_int = iface->ep_desc[i].bEndpointAddress &
672                                 USB_ENDPOINT_NUMBER_MASK;
673                         ss->irqinterval = iface->ep_desc[i].bInterval;
674                 }
675         }
676         debug("Endpoints In %d Out %d Int %d\n",
677                   ss->ep_in, ss->ep_out, ss->ep_int);
678
679         /* Do some basic sanity checks, and bail if we find a problem */
680         if (usb_set_interface(dev, iface_desc->bInterfaceNumber, 0) ||
681             !ss->ep_in || !ss->ep_out || !ss->ep_int) {
682                 debug("Problems with device\n");
683                 return 0;
684         }
685         dev->privptr = (void *)ss;
686         return 1;
687 }
688
689 int asix_eth_get_info(struct usb_device *dev, struct ueth_data *ss,
690                                 struct eth_device *eth)
691 {
692         struct asix_private *priv = (struct asix_private *)ss->dev_priv;
693
694         if (!eth) {
695                 debug("%s: missing parameter.\n", __func__);
696                 return 0;
697         }
698         sprintf(eth->name, "%s%d", ASIX_BASE_NAME, curr_eth_dev++);
699         eth->init = asix_init;
700         eth->send = asix_send;
701         eth->recv = asix_recv;
702         eth->halt = asix_halt;
703         if (!(priv->flags & FLAG_TYPE_AX88172))
704                 eth->write_hwaddr = asix_write_hwaddr;
705         eth->priv = ss;
706
707         if (asix_basic_reset(ss))
708                 return 0;
709
710         /* Get the MAC address */
711         if (asix_read_mac(eth))
712                 return 0;
713         debug("MAC %pM\n", eth->enetaddr);
714
715         return 1;
716 }