Patched in Tegra support.

1 files changed, 53 insertions, 339 deletions

diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 21b196c394b..1483c8296d5 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -32,8 +32,6 @@
 #include <linux/hid.h>
 #include <linux/hid-debug.h>
 
-#include "hid-ids.h"
-
 #define unk     KEY_UNKNOWN
 
 static const unsigned char hid_keyboard[256] = {
@@ -192,6 +190,7 @@ static int hidinput_setkeycode(struct input_dev *dev,
         return -EINVAL;
 }
 
+
 /**
  * hidinput_calc_abs_res - calculate an absolute axis resolution
  * @field: the HID report field to calculate resolution for
@@ -207,7 +206,7 @@ static int hidinput_setkeycode(struct input_dev *dev,
  * Only exponent 1 length units are processed. Centimeters and inches are
  * converted to millimeters. Degrees are converted to radians.
  */
-__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
+static __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
 {
         __s32 unit_exponent = field->unit_exponent;
         __s32 logical_extents = field->logical_maximum -
@@ -224,42 +223,21 @@ __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
          * Verify and convert units.
          * See HID specification v1.11 6.2.2.7 Global Items for unit decoding
          */
-        switch (code) {
-        case ABS_X:
-        case ABS_Y:
-        case ABS_Z:
-        case ABS_MT_POSITION_X:
-        case ABS_MT_POSITION_Y:
-        case ABS_MT_TOOL_X:
-        case ABS_MT_TOOL_Y:
-        case ABS_MT_TOUCH_MAJOR:
-        case ABS_MT_TOUCH_MINOR:
-                if (field->unit & 0xffffff00)           /* Not a length */
-                        return 0;
-                unit_exponent += hid_snto32(field->unit >> 4, 4) - 1;
-                switch (field->unit & 0xf) {
-                case 0x1:                               /* If centimeters */
+        if (code == ABS_X || code == ABS_Y || code == ABS_Z) {
+                if (field->unit == 0x11) {              /* If centimeters */
                         /* Convert to millimeters */
                         unit_exponent += 1;
-                        break;
-                case 0x3:                               /* If inches */
+                } else if (field->unit == 0x13) {       /* If inches */
                         /* Convert to millimeters */
                         prev = physical_extents;
                         physical_extents *= 254;
                         if (physical_extents < prev)
                                 return 0;
                         unit_exponent -= 1;
-                        break;
-                default:
+                } else {
                         return 0;
                 }
-                break;
-
-        case ABS_RX:
-        case ABS_RY:
-        case ABS_RZ:
-        case ABS_TILT_X:
-        case ABS_TILT_Y:
+        } else if (code == ABS_RX || code == ABS_RY || code == ABS_RZ) {
                 if (field->unit == 0x14) {              /* If degrees */
                         /* Convert to radians */
                         prev = logical_extents;
@@ -270,9 +248,7 @@ __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
                 } else if (field->unit != 0x12) {       /* If not radians */
                         return 0;
                 }
-                break;
-
-        default:
+        } else {
                 return 0;
         }
 
@@ -292,178 +268,9 @@ __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
         }
 
         /* Calculate resolution */
-        return DIV_ROUND_CLOSEST(logical_extents, physical_extents);
-}
-EXPORT_SYMBOL_GPL(hidinput_calc_abs_res);
-
-#ifdef CONFIG_HID_BATTERY_STRENGTH
-static enum power_supply_property hidinput_battery_props[] = {
-        POWER_SUPPLY_PROP_PRESENT,
-        POWER_SUPPLY_PROP_ONLINE,
-        POWER_SUPPLY_PROP_CAPACITY,
-        POWER_SUPPLY_PROP_MODEL_NAME,
-        POWER_SUPPLY_PROP_STATUS,
-        POWER_SUPPLY_PROP_SCOPE,
-};
-
-#define HID_BATTERY_QUIRK_PERCENT       (1 << 0) /* always reports percent */
-#define HID_BATTERY_QUIRK_FEATURE       (1 << 1) /* ask for feature report */
-
-static const struct hid_device_id hid_battery_quirks[] = {
-        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
-                        USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
-        HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
-        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
-                               USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
-          HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
-        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
-                USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
-          HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
-        {}
-};
-
-static unsigned find_battery_quirk(struct hid_device *hdev)
-{
-        unsigned quirks = 0;
-        const struct hid_device_id *match;
-
-        match = hid_match_id(hdev, hid_battery_quirks);
-        if (match != NULL)
-                quirks = match->driver_data;
-
-        return quirks;
+        return logical_extents / physical_extents;
 }
 
-static int hidinput_get_battery_property(struct power_supply *psy,
-                                         enum power_supply_property prop,
-                                         union power_supply_propval *val)
-{
-        struct hid_device *dev = container_of(psy, struct hid_device, battery);
-        int ret = 0;
-        __u8 buf[2] = {};
-
-        switch (prop) {
-        case POWER_SUPPLY_PROP_PRESENT:
-        case POWER_SUPPLY_PROP_ONLINE:
-                val->intval = 1;
-                break;
-
-        case POWER_SUPPLY_PROP_CAPACITY:
-                ret = dev->hid_get_raw_report(dev, dev->battery_report_id,
-                                              buf, sizeof(buf),
-                                              dev->battery_report_type);
-
-                if (ret != 2) {
-                        if (ret >= 0)
-                                ret = -EINVAL;
-                        break;
-                }
-
-                if (dev->battery_min < dev->battery_max &&
-                    buf[1] >= dev->battery_min &&
-                    buf[1] <= dev->battery_max)
-                        val->intval = (100 * (buf[1] - dev->battery_min)) /
-                                (dev->battery_max - dev->battery_min);
-                break;
-
-        case POWER_SUPPLY_PROP_MODEL_NAME:
-                val->strval = dev->name;
-                break;
-
-        case POWER_SUPPLY_PROP_STATUS:
-                val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
-                break;
-
-        case POWER_SUPPLY_PROP_SCOPE:
-                val->intval = POWER_SUPPLY_SCOPE_DEVICE;
-                break;
-
-        default:
-                ret = -EINVAL;
-                break;
-        }
-
-        return ret;
-}
-
-static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type, struct hid_field *field)
-{
-        struct power_supply *battery = &dev->battery;
-        int ret;
-        unsigned quirks;
-        s32 min, max;
-
-        if (field->usage->hid != HID_DC_BATTERYSTRENGTH)
-                return false;   /* no match */
-
-        if (battery->name != NULL)
-                goto out;       /* already initialized? */
-
-        battery->name = kasprintf(GFP_KERNEL, "hid-%s-battery", dev->uniq);
-        if (battery->name == NULL)
-                goto out;
-
-        battery->type = POWER_SUPPLY_TYPE_BATTERY;
-        battery->properties = hidinput_battery_props;
-        battery->num_properties = ARRAY_SIZE(hidinput_battery_props);
-        battery->use_for_apm = 0;
-        battery->get_property = hidinput_get_battery_property;
-
-        quirks = find_battery_quirk(dev);
-
-        hid_dbg(dev, "device %x:%x:%x %d quirks %d\n",
-                dev->bus, dev->vendor, dev->product, dev->version, quirks);
-
-        min = field->logical_minimum;
-        max = field->logical_maximum;
-
-        if (quirks & HID_BATTERY_QUIRK_PERCENT) {
-                min = 0;
-                max = 100;
-        }
-
-        if (quirks & HID_BATTERY_QUIRK_FEATURE)
-                report_type = HID_FEATURE_REPORT;
-
-        dev->battery_min = min;
-        dev->battery_max = max;
-        dev->battery_report_type = report_type;
-        dev->battery_report_id = field->report->id;
-
-        ret = power_supply_register(&dev->dev, battery);
-        if (ret != 0) {
-                hid_warn(dev, "can't register power supply: %d\n", ret);
-                kfree(battery->name);
-                battery->name = NULL;
-        }
-
-        power_supply_powers(battery, &dev->dev);
-
-out:
-        return true;
-}
-
-static void hidinput_cleanup_battery(struct hid_device *dev)
-{
-        if (!dev->battery.name)
-                return;
-
-        power_supply_unregister(&dev->battery);
-        kfree(dev->battery.name);
-        dev->battery.name = NULL;
-}
-#else  /* !CONFIG_HID_BATTERY_STRENGTH */
-static bool hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
-                                   struct hid_field *field)
-{
-        return false;
-}
-
-static void hidinput_cleanup_battery(struct hid_device *dev)
-{
-}
-#endif  /* CONFIG_HID_BATTERY_STRENGTH */
-
 static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
                                      struct hid_usage *usage)
 {
@@ -517,14 +324,9 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 if (code <= 0xf)
                                         code += BTN_JOYSTICK;
                                 else
-                                        code += BTN_TRIGGER_HAPPY - 0x10;
-                                break;
-                case HID_GD_GAMEPAD:
-                                if (code <= 0xf)
-                                        code += BTN_GAMEPAD;
-                                else
-                                        code += BTN_TRIGGER_HAPPY - 0x10;
+                                        code += BTN_TRIGGER_HAPPY;
                                 break;
+                case HID_GD_GAMEPAD:  code += BTN_GAMEPAD; break;
                 default:
                         switch (field->physical) {
                         case HID_GD_MOUSE:
@@ -657,14 +459,6 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                         map_key_clear(BTN_TOOL_RUBBER);
                         break;
 
-                case 0x3d: /* X Tilt */
-                        map_abs_clear(ABS_TILT_X);
-                        break;
-
-                case 0x3e: /* Y Tilt */
-                        map_abs_clear(ABS_TILT_Y);
-                        break;
-
                 case 0x33: /* Touch */
                 case 0x42: /* TipSwitch */
                 case 0x43: /* TipSwitch2 */
@@ -831,13 +625,6 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                 }
                 break;
 
-        case HID_UP_GENDEVCTRLS:
-                if (hidinput_setup_battery(device, HID_INPUT_REPORT, field))
-                        goto ignore;
-                else
-                        goto unknown;
-                break;
-
         case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
                 set_bit(EV_REP, input->evbit);
                 switch (usage->hid & HID_USAGE) {
@@ -857,15 +644,6 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                 }
                 break;
 
-        case HID_UP_HPVENDOR2:
-                set_bit(EV_REP, input->evbit);
-                switch (usage->hid & HID_USAGE) {
-                case 0x003: map_key_clear(KEY_BRIGHTNESSDOWN);  break;
-                case 0x004: map_key_clear(KEY_BRIGHTNESSUP);    break;
-                default:    goto ignore;
-                }
-                break;
-
         case HID_UP_MSVENDOR:
                 goto ignore;
 
@@ -1040,17 +818,6 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
                 return;
         }
 
-        /*
-         * Ignore out-of-range values as per HID specification,
-         * section 5.10 and 6.2.25
-         */
-        if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
-            (value < field->logical_minimum ||
-             value > field->logical_maximum)) {
-                dbg_hid("Ignoring out-of-range value %x\n", value);
-                return;
-        }
-
         /* report the usage code as scancode if the key status has changed */
         if (usage->type == EV_KEY && !!test_bit(usage->code, input->key) != value)
                 input_event(input, EV_MSC, MSC_SCAN, usage->hid);
@@ -1090,48 +857,6 @@ int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int
 }
 EXPORT_SYMBOL_GPL(hidinput_find_field);
 
-struct hid_field *hidinput_get_led_field(struct hid_device *hid)
-{
-        struct hid_report *report;
-        struct hid_field *field;
-        int i, j;
-
-        list_for_each_entry(report,
-                            &hid->report_enum[HID_OUTPUT_REPORT].report_list,
-                            list) {
-                for (i = 0; i < report->maxfield; i++) {
-                        field = report->field[i];
-                        for (j = 0; j < field->maxusage; j++)
-                                if (field->usage[j].type == EV_LED)
-                                        return field;
-                }
-        }
-        return NULL;
-}
-EXPORT_SYMBOL_GPL(hidinput_get_led_field);
-
-unsigned int hidinput_count_leds(struct hid_device *hid)
-{
-        struct hid_report *report;
-        struct hid_field *field;
-        int i, j;
-        unsigned int count = 0;
-
-        list_for_each_entry(report,
-                            &hid->report_enum[HID_OUTPUT_REPORT].report_list,
-                            list) {
-                for (i = 0; i < report->maxfield; i++) {
-                        field = report->field[i];
-                        for (j = 0; j < field->maxusage; j++)
-                                if (field->usage[j].type == EV_LED &&
-                                    field->value[j])
-                                        count += 1;
-                }
-        }
-        return count;
-}
-EXPORT_SYMBOL_GPL(hidinput_count_leds);
-
 static int hidinput_open(struct input_dev *dev)
 {
         struct hid_device *hid = input_get_drvdata(dev);
@@ -1153,49 +878,15 @@ static void report_features(struct hid_device *hid)
         struct hid_report *rep;
         int i, j;
 
+        if (!drv->feature_mapping)
+                return;
+
         rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
         list_for_each_entry(rep, &rep_enum->report_list, list)
                 for (i = 0; i < rep->maxfield; i++)
-                        for (j = 0; j < rep->field[i]->maxusage; j++) {
-                                /* Verify if Battery Strength feature is available */
-                                hidinput_setup_battery(hid, HID_FEATURE_REPORT, rep->field[i]);
-
-                                if (drv->feature_mapping)
-                                        drv->feature_mapping(hid, rep->field[i],
-                                                             rep->field[i]->usage + j);
-                        }
-}
-
-static struct hid_input *hidinput_allocate(struct hid_device *hid)
-{
-        struct hid_input *hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
-        struct input_dev *input_dev = input_allocate_device();
-        if (!hidinput || !input_dev) {
-                kfree(hidinput);
-                input_free_device(input_dev);
-                hid_err(hid, "Out of memory during hid input probe\n");
-                return NULL;
-        }
-
-        input_set_drvdata(input_dev, hid);
-        input_dev->event = hid->ll_driver->hidinput_input_event;
-        input_dev->open = hidinput_open;
-        input_dev->close = hidinput_close;
-        input_dev->setkeycode = hidinput_setkeycode;
-        input_dev->getkeycode = hidinput_getkeycode;
-
-        input_dev->name = hid->name;
-        input_dev->phys = hid->phys;
-        input_dev->uniq = hid->uniq;
-        input_dev->id.bustype = hid->bus;
-        input_dev->id.vendor  = hid->vendor;
-        input_dev->id.product = hid->product;
-        input_dev->id.version = hid->version;
-        input_dev->dev.parent = hid->dev.parent;
-        hidinput->input = input_dev;
-        list_add_tail(&hidinput->list, &hid->inputs);
-
-        return hidinput;
+                        for (j = 0; j < rep->field[i]->maxusage; j++)
+                                drv->feature_mapping(hid, rep->field[i],
+                                                     rep->field[i]->usage + j);
 }
 
 /*
@@ -1206,9 +897,9 @@ static struct hid_input *hidinput_allocate(struct hid_device *hid)
 
 int hidinput_connect(struct hid_device *hid, unsigned int force)
 {
-        struct hid_driver *drv = hid->driver;
         struct hid_report *report;
         struct hid_input *hidinput = NULL;
+        struct input_dev *input_dev;
         int i, j, k;
 
         INIT_LIST_HEAD(&hid->inputs);
@@ -1239,9 +930,33 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                                 continue;
 
                         if (!hidinput) {
-                                hidinput = hidinput_allocate(hid);
-                                if (!hidinput)
+                                hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
+                                input_dev = input_allocate_device();
+                                if (!hidinput || !input_dev) {
+                                        kfree(hidinput);
+                                        input_free_device(input_dev);
+                                        hid_err(hid, "Out of memory during hid input probe\n");
                                         goto out_unwind;
+                                }
+
+                                input_set_drvdata(input_dev, hid);
+                                input_dev->event =
+                                        hid->ll_driver->hidinput_input_event;
+                                input_dev->open = hidinput_open;
+                                input_dev->close = hidinput_close;
+                                input_dev->setkeycode = hidinput_setkeycode;
+                                input_dev->getkeycode = hidinput_getkeycode;
+
+                                input_dev->name = hid->name;
+                                input_dev->phys = hid->phys;
+                                input_dev->uniq = hid->uniq;
+                                input_dev->id.bustype = hid->bus;
+                                input_dev->id.vendor  = hid->vendor;
+                                input_dev->id.product = hid->product;
+                                input_dev->id.version = hid->version;
+                                input_dev->dev.parent = hid->dev.parent;
+                                hidinput->input = input_dev;
+                                list_add_tail(&hidinput->list, &hid->inputs);
                         }
 
                         for (i = 0; i < report->maxfield; i++)
@@ -1256,8 +971,9 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                                  * UGCI) cram a lot of unrelated inputs into the
                                  * same interface. */
                                 hidinput->report = report;
-                                if (drv->input_configured)
-                                        drv->input_configured(hid, hidinput);
+                                if (hid->driver->input_register &&
+                                                hid->driver->input_register(hid, hidinput))
+                                        goto out_cleanup;
                                 if (input_register_device(hidinput->input))
                                         goto out_cleanup;
                                 hidinput = NULL;
@@ -1265,12 +981,12 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                 }
         }
 
-        if (hidinput) {
-                if (drv->input_configured)
-                        drv->input_configured(hid, hidinput);
-                if (input_register_device(hidinput->input))
-                        goto out_cleanup;
-        }
+        if (hidinput && hid->driver->input_register &&
+                        hid->driver->input_register(hid, hidinput))
+                goto out_cleanup;
+
+        if (hidinput && input_register_device(hidinput->input))
+                goto out_cleanup;
 
         return 0;
 
@@ -1290,8 +1006,6 @@ void hidinput_disconnect(struct hid_device *hid)
 {
         struct hid_input *hidinput, *next;
 
-        hidinput_cleanup_battery(hid);
-
         list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
                 list_del(&hidinput->list);
                 input_unregister_device(hidinput->input);