← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/usb/atm/ueagle-atm.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/usb/atm/ueagle-atm.c
66
66
#include <linux/kthread.h>
67
67
#include <linux/mutex.h>
68
68
#include <linux/freezer.h>
 
69
#include <linux/slab.h>
 
70
#include <linux/kernel.h>
69
71
 
70
72
#include <asm/unaligned.h>
71
73
 
93
95
        } while (0)
94
96
 
95
97
#define uea_enters(usb_dev) \
96
 
        uea_vdbg(usb_dev, "entering %s\n", __func__)
 
98
        uea_vdbg(usb_dev, "entering %s\n" , __func__)
97
99
 
98
100
#define uea_leaves(usb_dev) \
99
 
        uea_vdbg(usb_dev, "leaving  %s\n", __func__)
100
 
 
101
 
#define uea_err(usb_dev, format,args...) \
102
 
        dev_err(&(usb_dev)->dev ,"[UEAGLE-ATM] " format , ##args)
103
 
 
104
 
#define uea_warn(usb_dev, format,args...) \
105
 
        dev_warn(&(usb_dev)->dev ,"[Ueagle-atm] " format, ##args)
106
 
 
107
 
#define uea_info(usb_dev, format,args...) \
108
 
        dev_info(&(usb_dev)->dev ,"[ueagle-atm] " format, ##args)
 
101
        uea_vdbg(usb_dev, "leaving  %s\n" , __func__)
 
102
 
 
103
#define uea_err(usb_dev, format, args...) \
 
104
        dev_err(&(usb_dev)->dev , "[UEAGLE-ATM] " format , ##args)
 
105
 
 
106
#define uea_warn(usb_dev, format, args...) \
 
107
        dev_warn(&(usb_dev)->dev , "[Ueagle-atm] " format, ##args)
 
108
 
 
109
#define uea_info(usb_dev, format, args...) \
 
110
        dev_info(&(usb_dev)->dev , "[ueagle-atm] " format, ##args)
109
111
 
110
112
struct intr_pkt;
111
113
 
288
290
#define IS_ISDN(x) \
289
291
        ((x)->annex & ANNEXB)
290
292
 
291
 
#define INS_TO_USBDEV(ins) ins->usb_dev
 
293
#define INS_TO_USBDEV(ins) (ins->usb_dev)
292
294
 
293
295
#define GET_STATUS(data) \
294
296
        ((data >> 8) & 0xf)
303
305
 * The FW_GET_BYTE() macro is provided only for consistency.
304
306
 */
305
307
 
306
 
#define FW_GET_BYTE(p)  *((__u8 *) (p))
 
308
#define FW_GET_BYTE(p) (*((__u8 *) (p)))
307
309
 
308
310
#define FW_DIR "ueagle-atm/"
309
311
#define UEA_FW_NAME_MAX 30
314
316
 
315
317
#define ACK_TIMEOUT msecs_to_jiffies(3000)
316
318
 
317
 
#define UEA_INTR_IFACE_NO       0
 
319
#define UEA_INTR_IFACE_NO       0
318
320
#define UEA_US_IFACE_NO         1
319
321
#define UEA_DS_IFACE_NO         2
320
322
 
325
327
#define UEA_INTR_PIPE           0x04
326
328
#define UEA_ISO_DATA_PIPE       0x08
327
329
 
328
 
#define UEA_E1_SET_BLOCK        0x0001
 
330
#define UEA_E1_SET_BLOCK        0x0001
329
331
#define UEA_E4_SET_BLOCK        0x002c
330
 
#define UEA_SET_MODE            0x0003
 
332
#define UEA_SET_MODE            0x0003
331
333
#define UEA_SET_2183_DATA       0x0004
332
334
#define UEA_SET_TIMEOUT         0x0011
333
335
 
365
367
        u8 string_header[E4_L1_STRING_HEADER];
366
368
        u8 page_number_to_block_index[E4_MAX_PAGE_NUMBER];
367
369
        struct block_index page_header[E4_NO_SWAPPAGE_HEADERS];
368
 
        u8 code [0];
 
370
        u8 code[0];
369
371
} __attribute__ ((packed));
370
372
 
371
373
/* structures describing a block within a DSP page */
427
429
#define E4_MODEMREADY  0x1
428
430
 
429
431
#define E1_MAKEFUNCTION(t, s) (((t) & 0xf) << 4 | ((s) & 0xf))
430
 
#define E4_MAKEFUNCTION(t, st, s) (((t) & 0xf) << 8 | ((st) & 0xf) << 4 | ((s) & 0xf))
 
432
#define E4_MAKEFUNCTION(t, st, s) (((t) & 0xf) << 8 | \
 
433
        ((st) & 0xf) << 4 | ((s) & 0xf))
431
434
 
432
435
#define E1_MAKESA(a, b, c, d)                                           \
433
436
        (((c) & 0xff) << 24 |                                           \
472
475
        __be16 wFunction;
473
476
        __be16 wOffset;
474
477
        __be16 wAddress;
475
 
        __be32 dwData [6];
 
478
        __be32 dwData[6];
476
479
} __attribute__ ((packed));
477
480
 
478
481
/* structures representing swap information */
533
536
 
534
537
static struct usb_driver uea_driver;
535
538
static DEFINE_MUTEX(uea_mutex);
536
 
static const char *chip_name[] = {"ADI930", "Eagle I", "Eagle II", "Eagle III", "Eagle IV"};
 
539
static const char *chip_name[] = {"ADI930", "Eagle I", "Eagle II", "Eagle III",
 
540
                                                                "Eagle IV"};
537
541
 
538
542
static int modem_index;
539
543
static unsigned int debug;
540
 
static unsigned int altsetting[NB_MODEM] = {[0 ... (NB_MODEM - 1)] = FASTEST_ISO_INTF};
 
544
static unsigned int altsetting[NB_MODEM] = {
 
545
                                [0 ... (NB_MODEM - 1)] = FASTEST_ISO_INTF};
541
546
static int sync_wait[NB_MODEM];
542
547
static char *cmv_file[NB_MODEM];
543
548
static int annex[NB_MODEM];
554
559
                "file name with configuration and management variables");
555
560
module_param_array(annex, uint, NULL, 0644);
556
561
MODULE_PARM_DESC(annex,
557
 
                 "manually set annex a/b (0=auto, 1=annex a, 2=annex b)");
 
562
                "manually set annex a/b (0=auto, 1=annex a, 2=annex b)");
558
563
 
559
564
#define uea_wait(sc, cond, timeo) \
560
565
({ \
571
576
                        sc->usbatm->atm_dev->type = val; \
572
577
        } while (0)
573
578
 
 
579
#define UPDATE_ATM_SIGNAL(val) \
 
580
        do { \
 
581
                if (sc->usbatm->atm_dev) \
 
582
                        atm_dev_signal_change(sc->usbatm->atm_dev, val); \
 
583
        } while (0)
 
584
 
 
585
 
574
586
/* Firmware loading */
575
587
#define LOAD_INTERNAL     0xA0
576
588
#define F8051_USBCS       0x7f92
601
613
        return (ret == size) ? 0 : -EIO;
602
614
}
603
615
 
604
 
static void uea_upload_pre_firmware(const struct firmware *fw_entry, void *context)
 
616
static void uea_upload_pre_firmware(const struct firmware *fw_entry,
 
617
                                                                void *context)
605
618
{
606
619
        struct usb_device *usb = context;
607
620
        const u8 *pfw;
667
680
        else
668
681
                uea_info(usb, "firmware uploaded\n");
669
682
 
670
 
        uea_leaves(usb);
671
 
        return;
 
683
        goto err;
672
684
 
673
685
err_fw_corrupted:
674
686
        uea_err(usb, "firmware is corrupted\n");
675
687
err:
 
688
        release_firmware(fw_entry);
676
689
        uea_leaves(usb);
677
690
}
678
691
 
705
718
                break;
706
719
        }
707
720
 
708
 
        ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev, usb, uea_upload_pre_firmware);
 
721
        ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev,
 
722
                                        GFP_KERNEL, usb,
 
723
                                        uea_upload_pre_firmware);
709
724
        if (ret)
710
725
                uea_err(usb, "firmware %s is not available\n", fw_name);
711
726
        else
874
889
        if (ret < 0) {
875
890
                uea_err(INS_TO_USBDEV(sc),
876
891
                       "requesting firmware %s failed with error %d\n",
877
 
                        dsp_name, ret);
 
892
                        dsp_name, ret);
878
893
                return ret;
879
894
        }
880
895
 
992
1007
 
993
1008
                blockidx = &p->page_header[blockno];
994
1009
                blocksize = E4_PAGE_BYTES(blockidx->PageSize);
995
 
                blockoffset = sc->dsp_firm->data + le32_to_cpu(blockidx->PageOffset);
 
1010
                blockoffset = sc->dsp_firm->data + le32_to_cpu(
 
1011
                                                        blockidx->PageOffset);
996
1012
 
997
1013
                bi.dwSize = cpu_to_be32(blocksize);
998
1014
                bi.dwAddress = cpu_to_be32(le32_to_cpu(blockidx->PageAddress));
999
1015
 
1000
1016
                uea_dbg(INS_TO_USBDEV(sc),
1001
 
                       "sending block %u for DSP page %u size %u address %x\n",
1002
 
                       blockno, pageno, blocksize, le32_to_cpu(blockidx->PageAddress));
 
1017
                        "sending block %u for DSP page "
 
1018
                        "%u size %u address %x\n",
 
1019
                        blockno, pageno, blocksize,
 
1020
                        le32_to_cpu(blockidx->PageAddress));
1003
1021
 
1004
1022
                /* send block info through the IDMA pipe */
1005
1023
                if (uea_idma_write(sc, &bi, E4_BLOCK_INFO_SIZE))
1040
1058
 
1041
1059
        p = (struct l1_code *) sc->dsp_firm->data;
1042
1060
        if (pageno >= le16_to_cpu(p->page_header[0].PageNumber)) {
1043
 
                uea_err(INS_TO_USBDEV(sc), "invalid DSP page %u requested\n", pageno);
 
1061
                uea_err(INS_TO_USBDEV(sc), "invalid DSP "
 
1062
                                                "page %u requested\n", pageno);
1044
1063
                return;
1045
1064
        }
1046
1065
 
1057
1076
                        __uea_load_page_e4(sc, i, 1);
1058
1077
        }
1059
1078
 
1060
 
        uea_dbg(INS_TO_USBDEV(sc),"sending start bi\n");
 
1079
        uea_dbg(INS_TO_USBDEV(sc) , "sending start bi\n");
1061
1080
 
1062
1081
        bi.wHdr = cpu_to_be16(UEA_BIHDR);
1063
1082
        bi.bBootPage = 0;
1137
1156
        uea_enters(INS_TO_USBDEV(sc));
1138
1157
        uea_vdbg(INS_TO_USBDEV(sc), "Function : %d-%d, Address : %c%c%c%c, "
1139
1158
                        "offset : 0x%04x, data : 0x%08x\n",
1140
 
                        E1_FUNCTION_TYPE(function), E1_FUNCTION_SUBTYPE(function),
1141
 
                        E1_GETSA1(address), E1_GETSA2(address), E1_GETSA3(address),
 
1159
                        E1_FUNCTION_TYPE(function),
 
1160
                        E1_FUNCTION_SUBTYPE(function),
 
1161
                        E1_GETSA1(address), E1_GETSA2(address),
 
1162
                        E1_GETSA3(address),
1142
1163
                        E1_GETSA4(address), offset, data);
1143
1164
 
1144
1165
        /* we send a request, but we expect a reply */
1155
1176
        cmv.wOffsetAddress = cpu_to_le16(offset);
1156
1177
        put_unaligned_le32(data >> 16 | data << 16, &cmv.dwData);
1157
1178
 
1158
 
        ret = uea_request(sc, UEA_E1_SET_BLOCK, UEA_MPTX_START, sizeof(cmv), &cmv);
 
1179
        ret = uea_request(sc, UEA_E1_SET_BLOCK, UEA_MPTX_START,
 
1180
                                                        sizeof(cmv), &cmv);
1159
1181
        if (ret < 0)
1160
1182
                return ret;
1161
1183
        ret = wait_cmv_ack(sc);
1189
1211
        cmv.wOffset = cpu_to_be16(offset);
1190
1212
        cmv.dwData[0] = cpu_to_be32(data);
1191
1213
 
1192
 
        ret = uea_request(sc, UEA_E4_SET_BLOCK, UEA_MPTX_START, sizeof(cmv), &cmv);
 
1214
        ret = uea_request(sc, UEA_E4_SET_BLOCK, UEA_MPTX_START,
 
1215
                                                        sizeof(cmv), &cmv);
1193
1216
        if (ret < 0)
1194
1217
                return ret;
1195
1218
        ret = wait_cmv_ack(sc);
1206
1229
                uea_err(INS_TO_USBDEV(sc),
1207
1230
                        "reading cmv failed with error %d\n", ret);
1208
1231
        else
1209
 
                *data = sc->data;
 
1232
                *data = sc->data;
1210
1233
 
1211
1234
        return ret;
1212
1235
}
1214
1237
static inline int uea_read_cmv_e4(struct uea_softc *sc,
1215
1238
                u8 size, u16 group, u16 address, u16 offset, u32 *data)
1216
1239
{
1217
 
        int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS, E4_REQUESTREAD, size),
 
1240
        int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS,
 
1241
                                                        E4_REQUESTREAD, size),
1218
1242
                          group, address, offset, 0);
1219
1243
        if (ret < 0)
1220
1244
                uea_err(INS_TO_USBDEV(sc),
1221
1245
                        "reading cmv failed with error %d\n", ret);
1222
1246
        else {
1223
 
                *data = sc->data;
 
1247
                *data = sc->data;
1224
1248
                /* size is in 16-bit word quantities */
1225
1249
                if (size > 2)
1226
1250
                        *(data + 1) = sc->data1;
1243
1267
static inline int uea_write_cmv_e4(struct uea_softc *sc,
1244
1268
                u8 size, u16 group, u16 address, u16 offset, u32 data)
1245
1269
{
1246
 
        int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS, E4_REQUESTWRITE, size),
 
1270
        int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS,
 
1271
                                                        E4_REQUESTWRITE, size),
1247
1272
                          group, address, offset, data);
1248
1273
        if (ret < 0)
1249
1274
                uea_err(INS_TO_USBDEV(sc),
1342
1367
        /* always update it as atm layer could not be init when we switch to
1343
1368
         * operational state
1344
1369
         */
1345
 
        UPDATE_ATM_STAT(signal, ATM_PHY_SIG_FOUND);
 
1370
        UPDATE_ATM_SIGNAL(ATM_PHY_SIG_FOUND);
1346
1371
 
1347
1372
        /* wake up processes waiting for synchronization */
1348
1373
        wake_up(&sc->sync_q);
1440
1465
                return ret;
1441
1466
 
1442
1467
        switch (sc->stats.phy.state) {
1443
 
                case 0x0:       /* not yet synchronized */
1444
 
                case 0x1:
1445
 
                case 0x3:
1446
 
                case 0x4:
1447
 
                        uea_dbg(INS_TO_USBDEV(sc), "modem not yet synchronized\n");
1448
 
                        return 0;
1449
 
                case 0x5:       /* initialization */
1450
 
                case 0x6:
1451
 
                case 0x9:
1452
 
                case 0xa:
1453
 
                        uea_dbg(INS_TO_USBDEV(sc), "modem initializing\n");
1454
 
                        return 0;
1455
 
                case 0x2:       /* fail ... */
1456
 
                        uea_info(INS_TO_USBDEV(sc), "modem synchronization failed"
1457
 
                                        " (may be try other cmv/dsp)\n");
1458
 
                        return -EAGAIN;
1459
 
                case 0x7:       /* operational */
1460
 
                        break;
1461
 
                default:
1462
 
                        uea_warn(INS_TO_USBDEV(sc), "unknown state: %x\n", sc->stats.phy.state);
1463
 
                        return 0;
 
1468
        case 0x0:       /* not yet synchronized */
 
1469
        case 0x1:
 
1470
        case 0x3:
 
1471
        case 0x4:
 
1472
                uea_dbg(INS_TO_USBDEV(sc), "modem not yet "
 
1473
                                                "synchronized\n");
 
1474
                return 0;
 
1475
        case 0x5:       /* initialization */
 
1476
        case 0x6:
 
1477
        case 0x9:
 
1478
        case 0xa:
 
1479
                uea_dbg(INS_TO_USBDEV(sc), "modem initializing\n");
 
1480
                return 0;
 
1481
        case 0x2:       /* fail ... */
 
1482
                uea_info(INS_TO_USBDEV(sc), "modem synchronization "
 
1483
                                "failed (may be try other cmv/dsp)\n");
 
1484
                return -EAGAIN;
 
1485
        case 0x7:       /* operational */
 
1486
                break;
 
1487
        default:
 
1488
                uea_warn(INS_TO_USBDEV(sc), "unknown state: %x\n",
 
1489
                                                sc->stats.phy.state);
 
1490
                return 0;
1464
1491
        }
1465
1492
 
1466
1493
        if (data != 7) {
1479
1506
        /* always update it as atm layer could not be init when we switch to
1480
1507
         * operational state
1481
1508
         */
1482
 
        UPDATE_ATM_STAT(signal, ATM_PHY_SIG_FOUND);
 
1509
        UPDATE_ATM_SIGNAL(ATM_PHY_SIG_FOUND);
1483
1510
 
1484
1511
        /* wake up processes waiting for synchronization */
1485
1512
        wake_up(&sc->sync_q);
1500
1527
        if (sc->stats.phy.flags) {
1501
1528
                uea_dbg(INS_TO_USBDEV(sc), "Stat flag = 0x%x\n",
1502
1529
                       sc->stats.phy.flags);
1503
 
                if (sc->stats.phy.flags & 1) //delineation LOSS
 
1530
                if (sc->stats.phy.flags & 1) /* delineation LOSS */
1504
1531
                        return -EAGAIN;
1505
 
                if (sc->stats.phy.flags & 0x4000) //Reset Flag
 
1532
                if (sc->stats.phy.flags & 0x4000) /* Reset Flag */
1506
1533
                        return -EAGAIN;
1507
1534
                return 0;
1508
1535
        }
1550
1577
        char file_arr[] = "CMVxy.bin";
1551
1578
        char *file;
1552
1579
 
 
1580
        kparam_block_sysfs_write(cmv_file);
1553
1581
        /* set proper name corresponding modem version and line type */
1554
1582
        if (cmv_file[sc->modem_index] == NULL) {
1555
1583
                if (UEA_CHIP_VERSION(sc) == ADI930)
1568
1596
        strlcat(cmv_name, file, UEA_FW_NAME_MAX);
1569
1597
        if (ver == 2)
1570
1598
                strlcat(cmv_name, ".v2", UEA_FW_NAME_MAX);
 
1599
        kparam_unblock_sysfs_write(cmv_file);
1571
1600
}
1572
1601
 
1573
1602
static int request_cmvs_old(struct uea_softc *sc,
1616
1645
        if (ret < 0) {
1617
1646
                /* if caller can handle old version, try to provide it */
1618
1647
                if (*ver == 1) {
1619
 
                        uea_warn(INS_TO_USBDEV(sc), "requesting firmware %s failed, "
 
1648
                        uea_warn(INS_TO_USBDEV(sc), "requesting "
 
1649
                                                        "firmware %s failed, "
1620
1650
                                "try to get older cmvs\n", cmv_name);
1621
1651
                        return request_cmvs_old(sc, cmvs, fw);
1622
1652
                }
1630
1660
        data = (u8 *) (*fw)->data;
1631
1661
        if (size < 4 || strncmp(data, "cmv2", 4) != 0) {
1632
1662
                if (*ver == 1) {
1633
 
                        uea_warn(INS_TO_USBDEV(sc), "firmware %s is corrupted, "
1634
 
                                "try to get older cmvs\n", cmv_name);
 
1663
                        uea_warn(INS_TO_USBDEV(sc), "firmware %s is corrupted,"
 
1664
                                " try to get older cmvs\n", cmv_name);
1635
1665
                        release_firmware(*fw);
1636
1666
                        return request_cmvs_old(sc, cmvs, fw);
1637
1667
                }
1668
1698
        int i, ret, len;
1669
1699
        void *cmvs_ptr;
1670
1700
        const struct firmware *cmvs_fw;
1671
 
        int ver = 1; // we can handle v1 cmv firmware version;
 
1701
        int ver = 1; /* we can handle v1 cmv firmware version; */
1672
1702
 
1673
1703
        /* Enter in R-IDLE (cmv) until instructed otherwise */
1674
1704
        ret = uea_write_cmv_e1(sc, E1_SA_CNTL, 0, 1);
1683
1713
                        sc->stats.phy.firmid);
1684
1714
 
1685
1715
        /* get options */
1686
 
        ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver);
 
1716
        ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver);
1687
1717
        if (ret < 0)
1688
1718
                return ret;
1689
1719
 
1695
1725
                        "please update your firmware\n");
1696
1726
 
1697
1727
                for (i = 0; i < len; i++) {
1698
 
                        ret = uea_write_cmv_e1(sc, get_unaligned_le32(&cmvs_v1[i].address),
1699
 
                                                get_unaligned_le16(&cmvs_v1[i].offset),
1700
 
                                                get_unaligned_le32(&cmvs_v1[i].data));
 
1728
                        ret = uea_write_cmv_e1(sc,
 
1729
                                get_unaligned_le32(&cmvs_v1[i].address),
 
1730
                                get_unaligned_le16(&cmvs_v1[i].offset),
 
1731
                                get_unaligned_le32(&cmvs_v1[i].data));
1701
1732
                        if (ret < 0)
1702
1733
                                goto out;
1703
1734
                }
1705
1736
                struct uea_cmvs_v2 *cmvs_v2 = cmvs_ptr;
1706
1737
 
1707
1738
                for (i = 0; i < len; i++) {
1708
 
                        ret = uea_write_cmv_e1(sc, get_unaligned_le32(&cmvs_v2[i].address),
1709
 
                                                (u16) get_unaligned_le32(&cmvs_v2[i].offset),
1710
 
                                                get_unaligned_le32(&cmvs_v2[i].data));
 
1739
                        ret = uea_write_cmv_e1(sc,
 
1740
                                get_unaligned_le32(&cmvs_v2[i].address),
 
1741
                                (u16) get_unaligned_le32(&cmvs_v2[i].offset),
 
1742
                                get_unaligned_le32(&cmvs_v2[i].data));
1711
1743
                        if (ret < 0)
1712
1744
                                goto out;
1713
1745
                }
1720
1752
        /* Enter in R-ACT-REQ */
1721
1753
        ret = uea_write_cmv_e1(sc, E1_SA_CNTL, 0, 2);
1722
1754
        uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n");
1723
 
        uea_info(INS_TO_USBDEV(sc), "modem started, waiting synchronization...\n");
 
1755
        uea_info(INS_TO_USBDEV(sc), "modem started, waiting "
 
1756
                                                "synchronization...\n");
1724
1757
out:
1725
1758
        release_firmware(cmvs_fw);
1726
1759
        return ret;
1731
1764
        int i, ret, len;
1732
1765
        void *cmvs_ptr;
1733
1766
        const struct firmware *cmvs_fw;
1734
 
        int ver = 2; // we can only handle v2 cmv firmware version;
 
1767
        int ver = 2; /* we can only handle v2 cmv firmware version; */
1735
1768
 
1736
1769
        /* Enter in R-IDLE (cmv) until instructed otherwise */
1737
1770
        ret = uea_write_cmv_e4(sc, 1, E4_SA_CNTL, 0, 0, 1);
1748
1781
 
1749
1782
 
1750
1783
        /* get options */
1751
 
        ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver);
 
1784
        ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver);
1752
1785
        if (ret < 0)
1753
1786
                return ret;
1754
1787
 
1758
1791
 
1759
1792
                for (i = 0; i < len; i++) {
1760
1793
                        ret = uea_write_cmv_e4(sc, 1,
1761
 
                                                get_unaligned_le32(&cmvs_v2[i].group),
1762
 
                                                get_unaligned_le32(&cmvs_v2[i].address),
1763
 
                                                get_unaligned_le32(&cmvs_v2[i].offset),
1764
 
                                                get_unaligned_le32(&cmvs_v2[i].data));
 
1794
                                get_unaligned_le32(&cmvs_v2[i].group),
 
1795
                                get_unaligned_le32(&cmvs_v2[i].address),
 
1796
                                get_unaligned_le32(&cmvs_v2[i].offset),
 
1797
                                get_unaligned_le32(&cmvs_v2[i].data));
1765
1798
                        if (ret < 0)
1766
1799
                                goto out;
1767
1800
                }
1774
1807
        /* Enter in R-ACT-REQ */
1775
1808
        ret = uea_write_cmv_e4(sc, 1, E4_SA_CNTL, 0, 0, 2);
1776
1809
        uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n");
1777
 
        uea_info(INS_TO_USBDEV(sc), "modem started, waiting synchronization...\n");
 
1810
        uea_info(INS_TO_USBDEV(sc), "modem started, waiting "
 
1811
                                                "synchronization...\n");
1778
1812
out:
1779
1813
        release_firmware(cmvs_fw);
1780
1814
        return ret;
1801
1835
         * So we will failed to wait Ready CMV.
1802
1836
         */
1803
1837
        sc->cmv_ack = 0;
1804
 
        UPDATE_ATM_STAT(signal, ATM_PHY_SIG_LOST);
 
1838
        UPDATE_ATM_SIGNAL(ATM_PHY_SIG_LOST);
1805
1839
 
1806
1840
        /* reset statistics */
1807
1841
        memset(&sc->stats, 0, sizeof(struct uea_stats));
1810
1844
        uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL);
1811
1845
        uea_request(sc, UEA_SET_MODE, UEA_BOOT_IDMA, 0, NULL);
1812
1846
 
1813
 
        /* enter reset mode */
 
1847
        /* enter reset mode */
1814
1848
        uea_request(sc, UEA_SET_MODE, UEA_START_RESET, 0, NULL);
1815
1849
 
1816
1850
        /* original driver use 200ms, but windows driver use 100ms */
1822
1856
        uea_request(sc, UEA_SET_MODE, UEA_END_RESET, 0, NULL);
1823
1857
 
1824
1858
        if (UEA_CHIP_VERSION(sc) != EAGLE_IV) {
1825
 
                /* clear tx and rx mailboxes */
 
1859
                /* clear tx and rx mailboxes */
1826
1860
                uea_request(sc, UEA_SET_2183_DATA, UEA_MPTX_MAILBOX, 2, &zero);
1827
1861
                uea_request(sc, UEA_SET_2183_DATA, UEA_MPRX_MAILBOX, 2, &zero);
1828
1862
                uea_request(sc, UEA_SET_2183_DATA, UEA_SWAP_MAILBOX, 2, &zero);
1833
1867
                return ret;
1834
1868
 
1835
1869
        if (UEA_CHIP_VERSION(sc) == EAGLE_IV)
1836
 
                sc->cmv_dsc.e4.function = E4_MAKEFUNCTION(E4_ADSLDIRECTIVE, E4_MODEMREADY, 1);
 
1870
                sc->cmv_dsc.e4.function = E4_MAKEFUNCTION(E4_ADSLDIRECTIVE,
 
1871
                                                        E4_MODEMREADY, 1);
1837
1872
        else
1838
 
                sc->cmv_dsc.e1.function = E1_MAKEFUNCTION(E1_ADSLDIRECTIVE, E1_MODEMREADY);
 
1873
                sc->cmv_dsc.e1.function = E1_MAKEFUNCTION(E1_ADSLDIRECTIVE,
 
1874
                                                        E1_MODEMREADY);
1839
1875
 
1840
1876
        /* demask interrupt */
1841
1877
        sc->booting = 0;
1935
1971
        value = 0;
1936
1972
        ret = uea_send_modem_cmd(sc->usb_dev, 0xe, 1, &value);
1937
1973
        if (ret < 0)
1938
 
                uea_err(sc->usb_dev, "elsa de-assert failed with error %d\n", ret);
 
1974
                uea_err(sc->usb_dev, "elsa de-assert failed with error"
 
1975
                                                                " %d\n", ret);
1939
1976
 
1940
1977
err1:
1941
1978
        release_firmware(fw_entry);
1958
1995
                goto bad1;
1959
1996
 
1960
1997
        /* FIXME : ADI930 reply wrong preambule (func = 2, sub = 2) to
1961
 
         * the first MEMACESS cmv. Ignore it...
 
1998
         * the first MEMACCESS cmv. Ignore it...
1962
1999
         */
1963
2000
        if (cmv->bFunction != dsc->function) {
1964
2001
                if (UEA_CHIP_VERSION(sc) == ADI930
1965
2002
                                && cmv->bFunction ==  E1_MAKEFUNCTION(2, 2)) {
1966
2003
                        cmv->wIndex = cpu_to_le16(dsc->idx);
1967
 
                        put_unaligned_le32(dsc->address, &cmv->dwSymbolicAddress);
 
2004
                        put_unaligned_le32(dsc->address,
 
2005
                                                &cmv->dwSymbolicAddress);
1968
2006
                        cmv->wOffsetAddress = cpu_to_le16(dsc->offset);
1969
2007
                } else
1970
2008
                        goto bad2;
1971
2009
        }
1972
2010
 
1973
 
        if (cmv->bFunction == E1_MAKEFUNCTION(E1_ADSLDIRECTIVE, E1_MODEMREADY)) {
 
2011
        if (cmv->bFunction == E1_MAKEFUNCTION(E1_ADSLDIRECTIVE,
 
2012
                                                        E1_MODEMREADY)) {
1974
2013
                wake_up_cmv_ack(sc);
1975
2014
                uea_leaves(INS_TO_USBDEV(sc));
1976
2015
                return;
2019
2058
        if (be16_to_cpu(cmv->wFunction) != dsc->function)
2020
2059
                goto bad2;
2021
2060
 
2022
 
        if (be16_to_cpu(cmv->wFunction) == E4_MAKEFUNCTION(E4_ADSLDIRECTIVE, E4_MODEMREADY, 1)) {
 
2061
        if (be16_to_cpu(cmv->wFunction) == E4_MAKEFUNCTION(E4_ADSLDIRECTIVE,
 
2062
                                                E4_MODEMREADY, 1)) {
2023
2063
                wake_up_cmv_ack(sc);
2024
2064
                uea_leaves(INS_TO_USBDEV(sc));
2025
2065
                return;
2046
2086
        return;
2047
2087
}
2048
2088
 
2049
 
static void uea_schedule_load_page_e1(struct uea_softc *sc, struct intr_pkt *intr)
 
2089
static void uea_schedule_load_page_e1(struct uea_softc *sc,
 
2090
                                                struct intr_pkt *intr)
2050
2091
{
2051
2092
        sc->pageno = intr->e1_bSwapPageNo;
2052
2093
        sc->ovl = intr->e1_bOvl >> 4 | intr->e1_bOvl << 4;
2053
2094
        queue_work(sc->work_q, &sc->task);
2054
2095
}
2055
2096
 
2056
 
static void uea_schedule_load_page_e4(struct uea_softc *sc, struct intr_pkt *intr)
 
2097
static void uea_schedule_load_page_e4(struct uea_softc *sc,
 
2098
                                                struct intr_pkt *intr)
2057
2099
{
2058
2100
        sc->pageno = intr->e4_bSwapPageNo;
2059
2101
        queue_work(sc->work_q, &sc->task);
2164
2206
                goto err1;
2165
2207
        }
2166
2208
 
2167
 
        sc->kthread = kthread_run(uea_kthread, sc, "ueagle-atm");
2168
 
        if (sc->kthread == ERR_PTR(-ENOMEM)) {
 
2209
        /* Create worker thread, but don't start it here.  Start it after
 
2210
         * all usbatm generic initialization is done.
 
2211
         */
 
2212
        sc->kthread = kthread_create(uea_kthread, sc, "ueagle-atm");
 
2213
        if (IS_ERR(sc->kthread)) {
2169
2214
                uea_err(INS_TO_USBDEV(sc), "failed to create thread\n");
2170
2215
                goto err2;
2171
2216
        }
2259
2304
        return ret;
2260
2305
}
2261
2306
 
2262
 
static DEVICE_ATTR(stat_status, S_IWUGO | S_IRUGO, read_status, reboot);
 
2307
static DEVICE_ATTR(stat_status, S_IWUSR | S_IRUGO, read_status, reboot);
2263
2308
 
2264
 
static ssize_t read_human_status(struct device *dev, struct device_attribute *attr,
2265
 
                char *buf)
 
2309
static ssize_t read_human_status(struct device *dev,
 
2310
                        struct device_attribute *attr, char *buf)
2266
2311
{
2267
2312
        int ret = -ENODEV;
2268
2313
        int modem_state;
2287
2332
                case 0xa:
2288
2333
                        modem_state = 1;
2289
2334
                        break;
2290
 
                case 0x7:       /* operational */
 
2335
                case 0x7:       /* operational */
2291
2336
                        modem_state = 2;
2292
2337
                        break;
2293
2338
                case 0x2:       /* fail ... */
2322
2367
        return ret;
2323
2368
}
2324
2369
 
2325
 
static DEVICE_ATTR(stat_human_status, S_IWUGO | S_IRUGO, read_human_status, NULL);
 
2370
static DEVICE_ATTR(stat_human_status, S_IRUGO, read_human_status, NULL);
2326
2371
 
2327
2372
static ssize_t read_delin(struct device *dev, struct device_attribute *attr,
2328
2373
                char *buf)
2354
2399
        return ret;
2355
2400
}
2356
2401
 
2357
 
static DEVICE_ATTR(stat_delin, S_IWUGO | S_IRUGO, read_delin, NULL);
 
2402
static DEVICE_ATTR(stat_delin, S_IRUGO, read_delin, NULL);
2358
2403
 
2359
 
#define UEA_ATTR(name, reset)                                   \
 
2404
#define UEA_ATTR(name, reset)                                   \
2360
2405
                                                                \
2361
 
static ssize_t read_##name(struct device *dev,                  \
 
2406
static ssize_t read_##name(struct device *dev,                  \
2362
2407
                struct device_attribute *attr, char *buf)       \
2363
 
{                                                               \
2364
 
        int ret = -ENODEV;                                      \
2365
 
        struct uea_softc *sc;                                   \
2366
 
                                                                \
2367
 
        mutex_lock(&uea_mutex);                                 \
 
2408
{                                                               \
 
2409
        int ret = -ENODEV;                                      \
 
2410
        struct uea_softc *sc;                                   \
 
2411
                                                                \
 
2412
        mutex_lock(&uea_mutex);                                 \
2368
2413
        sc = dev_to_uea(dev);                                   \
2369
 
        if (!sc)                                                \
2370
 
                goto out;                                       \
 
2414
        if (!sc)                                                \
 
2415
                goto out;                                       \
2371
2416
        ret = snprintf(buf, 10, "%08x\n", sc->stats.phy.name);  \
2372
2417
        if (reset)                                              \
2373
2418
                sc->stats.phy.name = 0;                         \
2374
 
out:                                                            \
2375
 
        mutex_unlock(&uea_mutex);                               \
2376
 
        return ret;                                             \
2377
 
}                                                               \
 
2419
out:                                                            \
 
2420
        mutex_unlock(&uea_mutex);                               \
 
2421
        return ret;                                             \
 
2422
}                                                               \
2378
2423
                                                                \
2379
2424
static DEVICE_ATTR(stat_##name, S_IRUGO, read_##name, NULL)
2380
2425
 
2396
2441
 
2397
2442
/* Retrieve the device End System Identifier (MAC) */
2398
2443
 
2399
 
#define htoi(x) (isdigit(x) ? x-'0' : toupper(x)-'A'+10)
2400
2444
static int uea_getesi(struct uea_softc *sc, u_char * esi)
2401
2445
{
2402
2446
        unsigned char mac_str[2 * ETH_ALEN + 1];
2407
2451
                return 1;
2408
2452
 
2409
2453
        for (i = 0; i < ETH_ALEN; i++)
2410
 
                esi[i] = htoi(mac_str[2 * i]) * 16 + htoi(mac_str[2 * i + 1]);
 
2454
                esi[i] = hex_to_bin(mac_str[2 * i]) * 16 +
 
2455
                         hex_to_bin(mac_str[2 * i + 1]);
2411
2456
 
2412
2457
        return 0;
2413
2458
}
2525
2570
        else if (sc->driver_info & AUTO_ANNEX_B)
2526
2571
                sc->annex = ANNEXB;
2527
2572
        else
2528
 
                sc->annex = (le16_to_cpu(sc->usb_dev->descriptor.bcdDevice) & 0x80)?ANNEXB:ANNEXA;
 
2573
                sc->annex = (le16_to_cpu
 
2574
                (sc->usb_dev->descriptor.bcdDevice) & 0x80) ? ANNEXB : ANNEXA;
2529
2575
 
2530
2576
        alt = altsetting[sc->modem_index];
2531
2577
        /* ADI930 don't support iso */
2532
2578
        if (UEA_CHIP_VERSION(id) != ADI930 && alt > 0) {
2533
 
                if (alt <= 8 && usb_set_interface(usb, UEA_DS_IFACE_NO, alt) == 0) {
 
2579
                if (alt <= 8 &&
 
2580
                        usb_set_interface(usb, UEA_DS_IFACE_NO, alt) == 0) {
2534
2581
                        uea_dbg(usb, "set alternate %u for 2 interface\n", alt);
2535
2582
                        uea_info(usb, "using iso mode\n");
2536
2583
                        usbatm->flags |= UDSL_USE_ISOC | UDSL_IGNORE_EILSEQ;
2580
2627
static int uea_probe(struct usb_interface *intf, const struct usb_device_id *id)
2581
2628
{
2582
2629
        struct usb_device *usb = interface_to_usbdev(intf);
 
2630
        int ret;
2583
2631
 
2584
2632
        uea_enters(usb);
2585
2633
        uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) Rev (%#X): %s\n",
2593
2641
        if (UEA_IS_PREFIRM(id))
2594
2642
                return uea_load_firmware(usb, UEA_CHIP_VERSION(id));
2595
2643
 
2596
 
        return usbatm_usb_probe(intf, id, &uea_usbatm_driver);
 
2644
        ret = usbatm_usb_probe(intf, id, &uea_usbatm_driver);
 
2645
        if (ret == 0) {
 
2646
                struct usbatm_data *usbatm = usb_get_intfdata(intf);
 
2647
                struct uea_softc *sc = usbatm->driver_data;
 
2648
 
 
2649
                /* Ensure carrier is initialized to off as early as possible */
 
2650
                UPDATE_ATM_SIGNAL(ATM_PHY_SIG_LOST);
 
2651
 
 
2652
                /* Only start the worker thread when all init is done */
 
2653
                wake_up_process(sc->kthread);
 
2654
        }
 
2655
 
 
2656
        return ret;
2597
2657
}
2598
2658
 
2599
2659
static void uea_disconnect(struct usb_interface *intf)
2619
2679
 * List of supported VID/PID
2620
2680
 */
2621
2681
static const struct usb_device_id uea_ids[] = {
2622
 
        {USB_DEVICE(ANALOG_VID, ADI930_PID_PREFIRM),    .driver_info = ADI930 | PREFIRM},
2623
 
        {USB_DEVICE(ANALOG_VID, ADI930_PID_PSTFIRM),    .driver_info = ADI930 | PSTFIRM},
2624
 
        {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PREFIRM),   .driver_info = EAGLE_I | PREFIRM},
2625
 
        {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PSTFIRM),   .driver_info = EAGLE_I | PSTFIRM},
2626
 
        {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PREFIRM),  .driver_info = EAGLE_II | PREFIRM},
2627
 
        {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PSTFIRM),  .driver_info = EAGLE_II | PSTFIRM},
2628
 
        {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
2629
 
        {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM},
2630
 
        {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PREFIRM), .driver_info = EAGLE_III | PREFIRM},
2631
 
        {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PSTFIRM), .driver_info = EAGLE_III | PSTFIRM},
2632
 
        {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PREFIRM),  .driver_info = EAGLE_IV | PREFIRM},
2633
 
        {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PSTFIRM),  .driver_info = EAGLE_IV | PSTFIRM},
2634
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
2635
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A},
2636
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
2637
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B},
2638
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
2639
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_A},
2640
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
2641
 
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_B},
2642
 
        {USB_DEVICE(ELSA_VID,   ELSA_PID_PREFIRM),      .driver_info = ADI930 | PREFIRM},
2643
 
        {USB_DEVICE(ELSA_VID,   ELSA_PID_PSTFIRM),      .driver_info = ADI930 | PSTFIRM},
2644
 
        {USB_DEVICE(ELSA_VID,   ELSA_PID_A_PREFIRM),    .driver_info = ADI930 | PREFIRM},
2645
 
        {USB_DEVICE(ELSA_VID,   ELSA_PID_A_PSTFIRM),    .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_A},
2646
 
        {USB_DEVICE(ELSA_VID,   ELSA_PID_B_PREFIRM),    .driver_info = ADI930 | PREFIRM},
2647
 
        {USB_DEVICE(ELSA_VID,   ELSA_PID_B_PSTFIRM),    .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_B},
2648
 
        {USB_DEVICE(USR_VID,    MILLER_A_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
2649
 
        {USB_DEVICE(USR_VID,    MILLER_A_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM  | AUTO_ANNEX_A},
2650
 
        {USB_DEVICE(USR_VID,    MILLER_B_PID_PREFIRM),  .driver_info = EAGLE_I | PREFIRM},
2651
 
        {USB_DEVICE(USR_VID,    MILLER_B_PID_PSTFIRM),  .driver_info = EAGLE_I | PSTFIRM  | AUTO_ANNEX_B},
2652
 
        {USB_DEVICE(USR_VID,    HEINEKEN_A_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM},
2653
 
        {USB_DEVICE(USR_VID,    HEINEKEN_A_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A},
2654
 
        {USB_DEVICE(USR_VID,    HEINEKEN_B_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM},
2655
 
        {USB_DEVICE(USR_VID,    HEINEKEN_B_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B},
 
2682
        {USB_DEVICE(ANALOG_VID, ADI930_PID_PREFIRM),
 
2683
                .driver_info = ADI930 | PREFIRM},
 
2684
        {USB_DEVICE(ANALOG_VID, ADI930_PID_PSTFIRM),
 
2685
                .driver_info = ADI930 | PSTFIRM},
 
2686
        {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PREFIRM),
 
2687
                .driver_info = EAGLE_I | PREFIRM},
 
2688
        {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PSTFIRM),
 
2689
                .driver_info = EAGLE_I | PSTFIRM},
 
2690
        {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PREFIRM),
 
2691
                .driver_info = EAGLE_II | PREFIRM},
 
2692
        {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PSTFIRM),
 
2693
                .driver_info = EAGLE_II | PSTFIRM},
 
2694
        {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PREFIRM),
 
2695
                .driver_info = EAGLE_II | PREFIRM},
 
2696
        {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PSTFIRM),
 
2697
                .driver_info = EAGLE_II | PSTFIRM},
 
2698
        {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PREFIRM),
 
2699
                .driver_info = EAGLE_III | PREFIRM},
 
2700
        {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PSTFIRM),
 
2701
                .driver_info = EAGLE_III | PSTFIRM},
 
2702
        {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PREFIRM),
 
2703
                .driver_info = EAGLE_IV | PREFIRM},
 
2704
        {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PSTFIRM),
 
2705
                .driver_info = EAGLE_IV | PSTFIRM},
 
2706
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PREFIRM),
 
2707
                .driver_info = EAGLE_I | PREFIRM},
 
2708
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PSTFIRM),
 
2709
                .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A},
 
2710
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PREFIRM),
 
2711
                .driver_info = EAGLE_I | PREFIRM},
 
2712
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PSTFIRM),
 
2713
                .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B},
 
2714
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PREFIRM),
 
2715
                .driver_info = EAGLE_II | PREFIRM},
 
2716
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PSTFIRM),
 
2717
                .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_A},
 
2718
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PREFIRM),
 
2719
                .driver_info = EAGLE_II | PREFIRM},
 
2720
        {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PSTFIRM),
 
2721
                .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_B},
 
2722
        {USB_DEVICE(ELSA_VID,   ELSA_PID_PREFIRM),
 
2723
                .driver_info = ADI930 | PREFIRM},
 
2724
        {USB_DEVICE(ELSA_VID,   ELSA_PID_PSTFIRM),
 
2725
                .driver_info = ADI930 | PSTFIRM},
 
2726
        {USB_DEVICE(ELSA_VID,   ELSA_PID_A_PREFIRM),
 
2727
                .driver_info = ADI930 | PREFIRM},
 
2728
        {USB_DEVICE(ELSA_VID,   ELSA_PID_A_PSTFIRM),
 
2729
                .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_A},
 
2730
        {USB_DEVICE(ELSA_VID,   ELSA_PID_B_PREFIRM),
 
2731
                .driver_info = ADI930 | PREFIRM},
 
2732
        {USB_DEVICE(ELSA_VID,   ELSA_PID_B_PSTFIRM),
 
2733
                .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_B},
 
2734
        {USB_DEVICE(USR_VID,    MILLER_A_PID_PREFIRM),
 
2735
                .driver_info = EAGLE_I | PREFIRM},
 
2736
        {USB_DEVICE(USR_VID,    MILLER_A_PID_PSTFIRM),
 
2737
                .driver_info = EAGLE_I | PSTFIRM  | AUTO_ANNEX_A},
 
2738
        {USB_DEVICE(USR_VID,    MILLER_B_PID_PREFIRM),
 
2739
                .driver_info = EAGLE_I | PREFIRM},
 
2740
        {USB_DEVICE(USR_VID,    MILLER_B_PID_PSTFIRM),
 
2741
                .driver_info = EAGLE_I | PSTFIRM  | AUTO_ANNEX_B},
 
2742
        {USB_DEVICE(USR_VID,    HEINEKEN_A_PID_PREFIRM),
 
2743
                .driver_info = EAGLE_I | PREFIRM},
 
2744
        {USB_DEVICE(USR_VID,    HEINEKEN_A_PID_PSTFIRM),
 
2745
                .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A},
 
2746
        {USB_DEVICE(USR_VID,    HEINEKEN_B_PID_PREFIRM),
 
2747
                .driver_info = EAGLE_I | PREFIRM},
 
2748
        {USB_DEVICE(USR_VID,    HEINEKEN_B_PID_PSTFIRM),
 
2749
                .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B},
2656
2750
        {}
2657
2751
};
2658
2752