← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-ti-omap4/saucy-proposed

« back to all changes in this revision

Viewing changes to drivers/hid/hid-core.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati, Stefan Bader, Upstream Kernel Changes
  • Date: 2012-08-15 17:17:43 UTC
  • Revision ID: package-import@ubuntu.com-20120815171743-h5wnuf51xe7pvdid
Tags: 3.5.0-207.13
[ Paolo Pisati ]

* Start new release

[ Stefan Bader ]

* (config) Enable getabis to use local package copies

[ Upstream Kernel Changes ]

* fixup: gargabe collect iva_seq[0|1] init
* [Config] enable all SND_OMAP_SOC_*s
* fixup: cm2xxx_3xxx.o is needed for omap2_cm_read|write_reg
* fixup: add some snd_soc_dai* helper functions
* fixup: s/snd_soc_dpcm_params/snd_soc_dpcm/g
* fixup: typo, no_host_mode and useless SDP4430 init
* fixup: enable again aess hwmod

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/hid/hid-core.c
230
230
                return -1;
231
231
        }
232
232
 
233
 
        if (parser->global.logical_maximum < parser->global.logical_minimum) {
234
 
                hid_err(parser->device, "logical range invalid %d %d\n",
235
 
                                parser->global.logical_minimum, parser->global.logical_maximum);
 
233
        /* Handle both signed and unsigned cases properly */
 
234
        if ((parser->global.logical_minimum < 0 &&
 
235
                parser->global.logical_maximum <
 
236
                parser->global.logical_minimum) ||
 
237
                (parser->global.logical_minimum >= 0 &&
 
238
                (__u32)parser->global.logical_maximum <
 
239
                (__u32)parser->global.logical_minimum)) {
 
240
                dbg_hid("logical range invalid 0x%x 0x%x\n",
 
241
                        parser->global.logical_minimum,
 
242
                        parser->global.logical_maximum);
236
243
                return -1;
237
244
        }
238
245
 
546
553
}
547
554
 
548
555
/*
549
 
 * Free a device structure, all reports, and all fields.
 
556
 * Close report. This function returns the device
 
557
 * state to the point prior to hid_open_report().
550
558
 */
551
 
 
552
 
static void hid_device_release(struct device *dev)
 
559
static void hid_close_report(struct hid_device *device)
553
560
{
554
 
        struct hid_device *device = container_of(dev, struct hid_device, dev);
555
561
        unsigned i, j;
556
562
 
557
563
        for (i = 0; i < HID_REPORT_TYPES; i++) {
562
568
                        if (report)
563
569
                                hid_free_report(report);
564
570
                }
 
571
                memset(report_enum, 0, sizeof(*report_enum));
 
572
                INIT_LIST_HEAD(&report_enum->report_list);
565
573
        }
566
574
 
567
575
        kfree(device->rdesc);
 
576
        device->rdesc = NULL;
 
577
        device->rsize = 0;
 
578
 
568
579
        kfree(device->collection);
569
 
        kfree(device);
 
580
        device->collection = NULL;
 
581
        device->collection_size = 0;
 
582
        device->maxcollection = 0;
 
583
        device->maxapplication = 0;
 
584
 
 
585
        device->status &= ~HID_STAT_PARSED;
 
586
}
 
587
 
 
588
/*
 
589
 * Free a device structure, all reports, and all fields.
 
590
 */
 
591
 
 
592
static void hid_device_release(struct device *dev)
 
593
{
 
594
        struct hid_device *hid = container_of(dev, struct hid_device, dev);
 
595
 
 
596
        hid_close_report(hid);
 
597
        kfree(hid->dev_rdesc);
 
598
        kfree(hid);
570
599
}
571
600
 
572
601
/*
636
665
        return NULL;
637
666
}
638
667
 
 
668
static void hid_scan_usage(struct hid_device *hid, u32 usage)
 
669
{
 
670
        if (usage == HID_DG_CONTACTID)
 
671
                hid->group = HID_GROUP_MULTITOUCH;
 
672
}
 
673
 
 
674
/*
 
675
 * Scan a report descriptor before the device is added to the bus.
 
676
 * Sets device groups and other properties that determine what driver
 
677
 * to load.
 
678
 */
 
679
static int hid_scan_report(struct hid_device *hid)
 
680
{
 
681
        unsigned int page = 0, delim = 0;
 
682
        __u8 *start = hid->dev_rdesc;
 
683
        __u8 *end = start + hid->dev_rsize;
 
684
        unsigned int u, u_min = 0, u_max = 0;
 
685
        struct hid_item item;
 
686
 
 
687
        hid->group = HID_GROUP_GENERIC;
 
688
        while ((start = fetch_item(start, end, &item)) != NULL) {
 
689
                if (item.format != HID_ITEM_FORMAT_SHORT)
 
690
                        return -EINVAL;
 
691
                if (item.type == HID_ITEM_TYPE_GLOBAL) {
 
692
                        if (item.tag == HID_GLOBAL_ITEM_TAG_USAGE_PAGE)
 
693
                                page = item_udata(&item) << 16;
 
694
                } else if (item.type == HID_ITEM_TYPE_LOCAL) {
 
695
                        if (delim > 1)
 
696
                                break;
 
697
                        u = item_udata(&item);
 
698
                        if (item.size <= 2)
 
699
                                u += page;
 
700
                        switch (item.tag) {
 
701
                        case HID_LOCAL_ITEM_TAG_DELIMITER:
 
702
                                delim += !!u;
 
703
                                break;
 
704
                        case HID_LOCAL_ITEM_TAG_USAGE:
 
705
                                hid_scan_usage(hid, u);
 
706
                                break;
 
707
                        case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 
708
                                u_min = u;
 
709
                                break;
 
710
                        case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 
711
                                u_max = u;
 
712
                                for (u = u_min; u <= u_max; u++)
 
713
                                        hid_scan_usage(hid, u);
 
714
                                break;
 
715
                        }
 
716
                }
 
717
        }
 
718
 
 
719
        return 0;
 
720
}
 
721
 
639
722
/**
640
723
 * hid_parse_report - parse device report
641
724
 *
643
726
 * @start: report start
644
727
 * @size: report size
645
728
 *
 
729
 * Allocate the device report as read by the bus driver. This function should
 
730
 * only be called from parse() in ll drivers.
 
731
 */
 
732
int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size)
 
733
{
 
734
        hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL);
 
735
        if (!hid->dev_rdesc)
 
736
                return -ENOMEM;
 
737
        hid->dev_rsize = size;
 
738
        return 0;
 
739
}
 
740
EXPORT_SYMBOL_GPL(hid_parse_report);
 
741
 
 
742
/**
 
743
 * hid_open_report - open a driver-specific device report
 
744
 *
 
745
 * @device: hid device
 
746
 *
646
747
 * Parse a report description into a hid_device structure. Reports are
647
748
 * enumerated, fields are attached to these reports.
648
749
 * 0 returned on success, otherwise nonzero error value.
 
750
 *
 
751
 * This function (or the equivalent hid_parse() macro) should only be
 
752
 * called from probe() in drivers, before starting the device.
649
753
 */
650
 
int hid_parse_report(struct hid_device *device, __u8 *start,
651
 
                unsigned size)
 
754
int hid_open_report(struct hid_device *device)
652
755
{
653
756
        struct hid_parser *parser;
654
757
        struct hid_item item;
 
758
        unsigned int size;
 
759
        __u8 *start;
655
760
        __u8 *end;
656
761
        int ret;
657
762
        static int (*dispatch_type[])(struct hid_parser *parser,
662
767
                hid_parser_reserved
663
768
        };
664
769
 
 
770
        if (WARN_ON(device->status & HID_STAT_PARSED))
 
771
                return -EBUSY;
 
772
 
 
773
        start = device->dev_rdesc;
 
774
        if (WARN_ON(!start))
 
775
                return -ENODEV;
 
776
        size = device->dev_rsize;
 
777
 
665
778
        if (device->driver->report_fixup)
666
779
                start = device->driver->report_fixup(device, start, &size);
667
780
 
679
792
        parser->device = device;
680
793
 
681
794
        end = start + size;
 
795
 
 
796
        device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
 
797
                                     sizeof(struct hid_collection), GFP_KERNEL);
 
798
        if (!device->collection) {
 
799
                ret = -ENOMEM;
 
800
                goto err;
 
801
        }
 
802
        device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
 
803
 
682
804
        ret = -EINVAL;
683
805
        while ((start = fetch_item(start, end, &item)) != NULL) {
684
806
 
704
826
                                goto err;
705
827
                        }
706
828
                        vfree(parser);
 
829
                        device->status |= HID_STAT_PARSED;
707
830
                        return 0;
708
831
                }
709
832
        }
711
834
        hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));
712
835
err:
713
836
        vfree(parser);
 
837
        hid_close_report(device);
714
838
        return ret;
715
839
}
716
 
EXPORT_SYMBOL_GPL(hid_parse_report);
 
840
EXPORT_SYMBOL_GPL(hid_open_report);
717
841
 
718
842
/*
719
843
 * Convert a signed n-bit integer to signed 32-bit integer. Common
1032
1156
        return report;
1033
1157
}
1034
1158
 
1035
 
void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
 
1159
int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
1036
1160
                int interrupt)
1037
1161
{
1038
1162
        struct hid_report_enum *report_enum = hid->report_enum + type;
1040
1164
        unsigned int a;
1041
1165
        int rsize, csize = size;
1042
1166
        u8 *cdata = data;
 
1167
        int ret = 0;
1043
1168
 
1044
1169
        report = hid_get_report(report_enum, data);
1045
1170
        if (!report)
1046
 
                return;
 
1171
                goto out;
1047
1172
 
1048
1173
        if (report_enum->numbered) {
1049
1174
                cdata++;
1063
1188
 
1064
1189
        if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
1065
1190
                hid->hiddev_report_event(hid, report);
1066
 
        if (hid->claimed & HID_CLAIMED_HIDRAW)
1067
 
                hidraw_report_event(hid, data, size);
 
1191
        if (hid->claimed & HID_CLAIMED_HIDRAW) {
 
1192
                ret = hidraw_report_event(hid, data, size);
 
1193
                if (ret)
 
1194
                        goto out;
 
1195
        }
1068
1196
 
1069
1197
        for (a = 0; a < report->maxfield; a++)
1070
1198
                hid_input_field(hid, report->field[a], cdata, interrupt);
1071
1199
 
1072
1200
        if (hid->claimed & HID_CLAIMED_INPUT)
1073
1201
                hidinput_report_event(hid, report);
 
1202
out:
 
1203
        return ret;
1074
1204
}
1075
1205
EXPORT_SYMBOL_GPL(hid_report_raw_event);
1076
1206
 
1147
1277
                }
1148
1278
        }
1149
1279
 
1150
 
        hid_report_raw_event(hid, type, data, size, interrupt);
 
1280
        ret = hid_report_raw_event(hid, type, data, size, interrupt);
1151
1281
 
1152
1282
unlock:
1153
1283
        up(&hid->driver_lock);
1158
1288
static bool hid_match_one_id(struct hid_device *hdev,
1159
1289
                const struct hid_device_id *id)
1160
1290
{
1161
 
        return id->bus == hdev->bus &&
 
1291
        return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) &&
 
1292
                (id->group == HID_GROUP_ANY || id->group == hdev->group) &&
1162
1293
                (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
1163
1294
                (id->product == HID_ANY_ID || id->product == hdev->product);
1164
1295
}
1234
1365
        if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
1235
1366
                                connect_mask & HID_CONNECT_HIDINPUT_FORCE))
1236
1367
                hdev->claimed |= HID_CLAIMED_INPUT;
1237
 
        if (hdev->quirks & HID_QUIRK_MULTITOUCH) {
1238
 
                /* this device should be handled by hid-multitouch, skip it */
1239
 
                return -ENODEV;
1240
 
        }
1241
1368
 
1242
1369
        if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
1243
1370
                        !hdev->hiddev_connect(hdev,
1314
1441
 
1315
1442
/* a list of devices for which there is a specialized driver on HID bus */
1316
1443
static const struct hid_device_id hid_have_special_driver[] = {
1317
 
        { HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) },
1318
 
        { HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M2256) },
1319
1444
        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
1320
1445
        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
1321
1446
        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },
1322
1447
        { HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },
1323
 
        { HID_USB_DEVICE(USB_VENDOR_ID_ACTIONSTAR, USB_DEVICE_ID_ACTIONSTAR_1011) },
1324
1448
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },
1325
1449
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
1326
1450
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
1379
1503
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
1380
1504
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
1381
1505
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
 
1506
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
 
1507
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
 
1508
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
1382
1509
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
1383
1510
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
1384
1511
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
1385
1512
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) },
1386
1513
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
1387
1514
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
1388
 
        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },
1389
 
        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
 
1515
        { HID_USB_DEVICE(USB_VENDOR_ID_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },
1390
1516
        { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
1391
1517
        { HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
1392
1518
        { HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
1393
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
1394
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
1395
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
1396
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
1397
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
1398
1519
        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
1399
1520
        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
1400
1521
        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
1401
1522
        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
1402
1523
        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
1403
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
1404
1524
        { HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
1405
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CVTOUCH, USB_DEVICE_ID_CVTOUCH_SCREEN) },
1406
1525
        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
1407
1526
        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
1408
1527
        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },
1409
1528
        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
1410
 
        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
1411
1529
        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
1412
1530
        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
1413
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480D) },
1414
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_480E) },
1415
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_720C) },
1416
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7224) },
1417
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_725E) },
1418
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_726B) },
1419
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_72A1) },
1420
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_7302) },
1421
 
        { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH_A001) },
1422
1531
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
1423
 
        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2515) },
1424
1532
        { HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
1425
1533
        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
1426
 
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_FRUCTEL, USB_DEVICE_ID_GAMETEL_MT_MODE) },
1427
1534
        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
1428
1535
        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
1429
 
        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
1430
 
        { HID_USB_DEVICE(USB_VENDOR_ID_GOODTOUCH, USB_DEVICE_ID_GOODTOUCH_000f) },
1431
1536
        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
1432
1537
        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
1433
1538
        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
1434
1539
        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
1435
1540
        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
1436
 
        { HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },
1437
 
        { HID_USB_DEVICE(USB_VENDOR_ID_HANVON_ALT, USB_DEVICE_ID_HANVON_ALT_MULTITOUCH) },
1438
 
        { HID_USB_DEVICE(USB_VENDOR_ID_IDEACOM, USB_DEVICE_ID_IDEACOM_IDC6650) },
1439
1541
        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
1440
 
        { HID_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) },
1441
 
        { HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS, USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
1442
1542
        { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
1443
1543
        { HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
1444
1544
        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
1447
1547
        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },
1448
1548
        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
1449
1549
        { HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },
1450
 
        { HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MULTITOUCH) },
1451
1550
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
1452
1551
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
1453
1552
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
1480
1579
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
1481
1580
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
1482
1581
        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
1483
 
        { HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH) },
1484
 
        { HID_USB_DEVICE(USB_VENDOR_ID_LUMIO, USB_DEVICE_ID_CRYSTALTOUCH_DUAL) },
1485
1582
        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
1486
1583
        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
1487
1584
        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },
1513
1610
        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
1514
1611
        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },
1515
1612
        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
1516
 
        { HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT780) },
1517
 
        { HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC, USB_DEVICE_ID_PANABOARD_UBT880) },
1518
 
        { HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_PCI) },
1519
1613
        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
1520
 
        { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN) },
1521
 
        { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN1) },
1522
 
        { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN2) },
1523
1614
        { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
1524
 
        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
1525
1615
        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
1526
1616
        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
1527
1617
        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
1538
1628
        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
1539
1629
        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
1540
1630
        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
1541
 
        { HID_USB_DEVICE(USB_VENDOR_ID_STANTUM, USB_DEVICE_ID_MTP) },
1542
 
        { HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_STM, USB_DEVICE_ID_MTP_STM) },
1543
 
        { HID_USB_DEVICE(USB_VENDOR_ID_STANTUM_SITRONIX, USB_DEVICE_ID_MTP_SITRONIX) },
1544
1631
        { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
1545
1632
        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
1546
1633
        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
1554
1641
        { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },
1555
1642
        { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
1556
1643
        { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
1557
 
        { HID_USB_DEVICE(USB_VENDOR_ID_TOUCH_INTL, USB_DEVICE_ID_TOUCH_INTL_MULTI_TOUCH) },
1558
1644
        { HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
1559
 
        { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
1560
1645
        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
1561
1646
        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
1562
1647
        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
1563
1648
        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },
1564
1649
        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },
1565
 
        { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0709) },
1566
 
        { HID_USB_DEVICE(USB_VENDOR_ID_UNITEC, USB_DEVICE_ID_UNITEC_USB_TOUCH_0A19) },
 
1650
        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },
1567
1651
        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
1568
1652
        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },
1569
1653
        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },
1578
1662
        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) },
1579
1663
        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
1580
1664
        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
1581
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XAT, USB_DEVICE_ID_XAT_CSR) },
1582
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX) },
1583
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX) },
1584
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR) },
1585
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX1) },
1586
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX1) },
1587
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR1) },
1588
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_SPX2) },
1589
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_MPX2) },
1590
 
        { HID_USB_DEVICE(USB_VENDOR_ID_XIROKU, USB_DEVICE_ID_XIROKU_CSR2) },
 
1665
        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },
1591
1666
        { HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
1592
1667
        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
1593
1668
        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
1631
1706
                return -ENOMEM;
1632
1707
 
1633
1708
        dynid->id.bus = bus;
 
1709
        dynid->id.group = HID_GROUP_ANY;
1634
1710
        dynid->id.vendor = vendor;
1635
1711
        dynid->id.product = product;
1636
1712
        dynid->id.driver_data = driver_data;
1679
1755
        struct hid_driver *hdrv = container_of(drv, struct hid_driver, driver);
1680
1756
        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1681
1757
 
1682
 
        if ((hdev->quirks & HID_QUIRK_MULTITOUCH) &&
1683
 
                !strncmp(hdrv->name, "hid-multitouch", 14))
1684
 
                return 1;
1685
 
 
1686
 
        if (!hid_match_device(hdev, hdrv))
1687
 
                return 0;
1688
 
 
1689
 
        /* generic wants all that don't have specialized driver */
1690
 
        if (!strncmp(hdrv->name, "generic-", 8) && !hid_ignore_special_drivers)
1691
 
                return !hid_match_id(hdev, hid_have_special_driver);
1692
 
 
1693
 
        return 1;
 
1758
        return hid_match_device(hdev, hdrv) != NULL;
1694
1759
}
1695
1760
 
1696
1761
static int hid_device_probe(struct device *dev)
1707
1772
        if (!hdev->driver) {
1708
1773
                id = hid_match_device(hdev, hdrv);
1709
1774
                if (id == NULL) {
1710
 
                        if (!((hdev->quirks & HID_QUIRK_MULTITOUCH) &&
1711
 
                                !strncmp(hdrv->name, "hid-multitouch", 14))) {
1712
 
                                ret = -ENODEV;
1713
 
                                goto unlock;
1714
 
                        }
 
1775
                        ret = -ENODEV;
 
1776
                        goto unlock;
1715
1777
                }
1716
1778
 
1717
1779
                hdev->driver = hdrv;
1718
1780
                if (hdrv->probe) {
1719
1781
                        ret = hdrv->probe(hdev, id);
1720
1782
                } else { /* default probe */
1721
 
                        ret = hid_parse(hdev);
 
1783
                        ret = hid_open_report(hdev);
1722
1784
                        if (!ret)
1723
1785
                                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
1724
1786
                }
1725
 
                if (ret)
 
1787
                if (ret) {
 
1788
                        hid_close_report(hdev);
1726
1789
                        hdev->driver = NULL;
 
1790
                }
1727
1791
        }
1728
1792
unlock:
1729
1793
        up(&hdev->driver_lock);
1744
1808
                        hdrv->remove(hdev);
1745
1809
                else /* default remove */
1746
1810
                        hid_hw_stop(hdev);
 
1811
                hid_close_report(hdev);
1747
1812
                hdev->driver = NULL;
1748
1813
        }
1749
1814
 
1751
1816
        return 0;
1752
1817
}
1753
1818
 
 
1819
static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 
1820
                             char *buf)
 
1821
{
 
1822
        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
 
1823
        int len;
 
1824
 
 
1825
        len = snprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n",
 
1826
                       hdev->bus, hdev->group, hdev->vendor, hdev->product);
 
1827
 
 
1828
        return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
 
1829
}
 
1830
 
 
1831
static struct device_attribute hid_dev_attrs[] = {
 
1832
        __ATTR_RO(modalias),
 
1833
        __ATTR_NULL,
 
1834
};
 
1835
 
1754
1836
static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
1755
1837
{
1756
1838
        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
1768
1850
        if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
1769
1851
                return -ENOMEM;
1770
1852
 
1771
 
        if (add_uevent_var(env, "MODALIAS=hid:b%04Xv%08Xp%08X",
1772
 
                        hdev->bus, hdev->vendor, hdev->product))
 
1853
        if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X",
 
1854
                           hdev->bus, hdev->group, hdev->vendor, hdev->product))
1773
1855
                return -ENOMEM;
1774
1856
 
1775
1857
        return 0;
1777
1859
 
1778
1860
static struct bus_type hid_bus_type = {
1779
1861
        .name           = "hid",
 
1862
        .dev_attrs      = hid_dev_attrs,
1780
1863
        .match          = hid_bus_match,
1781
1864
        .probe          = hid_device_probe,
1782
1865
        .remove         = hid_device_remove,
1800
1883
        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},
1801
1884
        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},
1802
1885
        { HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
 
1886
        { HID_USB_DEVICE(USB_VENDOR_ID_AXENTIA, USB_DEVICE_ID_AXENTIA_FM_RADIO) },
1803
1887
        { HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },
1804
1888
        { HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },
1805
1889
        { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },
1914
1998
        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
1915
1999
        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
1916
2000
        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
 
2001
        { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },
1917
2002
        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
1918
2003
        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
1919
2004
        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
2008
2093
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
2009
2094
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
2010
2095
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
 
2096
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
 
2097
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
 
2098
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
2011
2099
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
2012
2100
        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
2013
2101
        { }
2075
2163
            && (hid_ignore(hdev) || (hdev->quirks & HID_QUIRK_IGNORE)))
2076
2164
                return -ENODEV;
2077
2165
 
 
2166
        /*
 
2167
         * Read the device report descriptor once and use as template
 
2168
         * for the driver-specific modifications.
 
2169
         */
 
2170
        ret = hdev->ll_driver->parse(hdev);
 
2171
        if (ret)
 
2172
                return ret;
 
2173
        if (!hdev->dev_rdesc)
 
2174
                return -ENODEV;
 
2175
 
 
2176
        /*
 
2177
         * Scan generic devices for group information
 
2178
         */
 
2179
        if (hid_ignore_special_drivers ||
 
2180
            !hid_match_id(hdev, hid_have_special_driver)) {
 
2181
                ret = hid_scan_report(hdev);
 
2182
                if (ret)
 
2183
                        hid_warn(hdev, "bad device descriptor (%d)\n", ret);
 
2184
        }
 
2185
 
2078
2186
        /* XXX hack, any other cleaner solution after the driver core
2079
2187
         * is converted to allow more than 20 bytes as the device name? */
2080
2188
        dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
2103
2211
struct hid_device *hid_allocate_device(void)
2104
2212
{
2105
2213
        struct hid_device *hdev;
2106
 
        unsigned int i;
2107
2214
        int ret = -ENOMEM;
2108
2215
 
2109
2216
        hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
2114
2221
        hdev->dev.release = hid_device_release;
2115
2222
        hdev->dev.bus = &hid_bus_type;
2116
2223
 
2117
 
        hdev->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
2118
 
                        sizeof(struct hid_collection), GFP_KERNEL);
2119
 
        if (hdev->collection == NULL)
2120
 
                goto err;
2121
 
        hdev->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
2122
 
 
2123
 
        for (i = 0; i < HID_REPORT_TYPES; i++)
2124
 
                INIT_LIST_HEAD(&hdev->report_enum[i].report_list);
 
2224
        hid_close_report(hdev);
2125
2225
 
2126
2226
        init_waitqueue_head(&hdev->debug_wait);
2127
2227
        INIT_LIST_HEAD(&hdev->debug_list);
2128
2228
        sema_init(&hdev->driver_lock, 1);
2129
2229
 
2130
2230
        return hdev;
2131
 
err:
2132
 
        put_device(&hdev->dev);
2133
 
        return ERR_PTR(ret);
2134
2231
}
2135
2232
EXPORT_SYMBOL_GPL(hid_allocate_device);
2136
2233
 
2141
2238
                hid_debug_unregister(hdev);
2142
2239
                hdev->status &= ~HID_STAT_ADDED;
2143
2240
        }
 
2241
        kfree(hdev->dev_rdesc);
 
2242
        hdev->dev_rdesc = NULL;
 
2243
        hdev->dev_rsize = 0;
2144
2244
}
2145
2245
 
2146
2246
/**