static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id) { unsigned long quirks = id->driver_data; unsigned int connect_mask = HID_CONNECT_DEFAULT; int ret; hid_set_drvdata(hdev, (void *)quirks); if (quirks & LG_NOGET) hdev->quirks |= HID_QUIRK_NOGET; ret = hid_parse(hdev); if (ret) { dev_err(&hdev->dev, "parse failed\n"); goto err_free; } if (quirks & (LG_FF | LG_FF2)) connect_mask &= ~HID_CONNECT_FF; ret = hid_hw_start(hdev, connect_mask); if (ret) { dev_err(&hdev->dev, "hw start failed\n"); goto err_free; } if (quirks & LG_FF) lgff_init(hdev); if (quirks & LG_FF2) lg2ff_init(hdev); return 0; err_free: return ret; }
static int saitek_probe(struct hid_device *hdev, const struct hid_device_id *id) { unsigned long quirks = id->driver_data; struct saitek_sc *ssc; int ret; ssc = devm_kzalloc(&hdev->dev, sizeof(*ssc), GFP_KERNEL); if (ssc == NULL) { hid_err(hdev, "can't alloc saitek descriptor\n"); return -ENOMEM; } ssc->quirks = quirks; ssc->mode = -1; hid_set_drvdata(hdev, ssc); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); return ret; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) { hid_err(hdev, "hw start failed\n"); return ret; } return 0; }
static int tpkbd_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; ret = hid_parse(hdev); if (ret) { hid_err(hdev, "hid_parse failed\n"); goto err; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) { hid_err(hdev, "hid_hw_start failed\n"); goto err; } if (hid_get_drvdata(hdev)) { hid_set_drvdata(hdev, NULL); ret = tpkbd_probe_tp(hdev); if (ret) goto err_hid; } return 0; err_hid: hid_hw_stop(hdev); err: return ret; }
static int dr_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; dev_dbg(&hdev->dev, "DragonRise Inc. HID hardware probe..."); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF); if (ret) { hid_err(hdev, "hw start failed\n"); goto err; } switch (hdev->product) { case 0x0006: ret = drff_init(hdev); if (ret) { dev_err(&hdev->dev, "force feedback init failed\n"); hid_hw_stop(hdev); goto err; } break; } return 0; err: return ret; }
static int waltop_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; struct waltop_state *s; s = kzalloc(sizeof(*s), GFP_KERNEL); if (s == NULL) { hid_err(hdev, "can't allocate device state\n"); ret = -ENOMEM; goto err; } s->pressure0 = 0; s->pressure1 = 0; hid_set_drvdata(hdev, s); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) { hid_err(hdev, "hw start failed\n"); goto err; } return 0; err: kfree(s); return ret; }
static int ms_probe(struct hid_device *hdev, const struct hid_device_id *id) { unsigned long quirks = id->driver_data; int ret; hid_set_drvdata(hdev, (void *)quirks); if (quirks & MS_NOGET) hdev->quirks |= HID_QUIRK_NOGET; ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err_free; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT | ((quirks & MS_HIDINPUT) ? HID_CONNECT_HIDINPUT_FORCE : 0)); if (ret) { hid_err(hdev, "hw start failed\n"); goto err_free; } return 0; err_free: return ret; }
static int a4_probe(struct hid_device *hdev, const struct hid_device_id *id) { struct a4tech_sc *a4; int ret; a4 = kzalloc(sizeof(*a4), GFP_KERNEL); if (a4 == NULL) { hid_err(hdev, "can't alloc device descriptor\n"); ret = -ENOMEM; goto err_free; } a4->quirks = id->driver_data; hid_set_drvdata(hdev, a4); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err_free; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) { hid_err(hdev, "hw start failed\n"); goto err_free; } return 0; err_free: kfree(a4); return ret; }
static int gfrm_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; hid_set_drvdata(hdev, (void *) id->driver_data); ret = hid_parse(hdev); if (ret) goto done; if (id->driver_data == GFRM100) { /* * GFRM100 HID Report Descriptor does not describe the Search * key reports. Thus, we need to add it manually here, so that * those reports reach gfrm_raw_event() from hid_input_report(). */ if (!hid_register_report(hdev, HID_INPUT_REPORT, GFRM100_SEARCH_KEY_REPORT_ID, 0)) { ret = -ENOMEM; goto done; } } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); done: return ret; }
static int egalax_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; struct egalax_data *td; struct hid_report *report; td = kzalloc(sizeof(struct egalax_data), GFP_KERNEL); if (!td) { hid_err(hdev, "cannot allocate eGalax data\n"); return -ENOMEM; } hid_set_drvdata(hdev, td); ret = hid_parse(hdev); if (ret) goto end; ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) goto end; report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[5]; if (report) { report->field[0]->value[0] = 2; usbhid_submit_report(hdev, report, USB_DIR_OUT); } end: if (ret) kfree(td); return ret; }
static int zc_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; struct zc_device *zc; zc = kzalloc(sizeof(*zc), GFP_KERNEL); if (zc == NULL) { dev_err(&hdev->dev, "zydacron: can't alloc descriptor\n"); return -ENOMEM; } hid_set_drvdata(hdev, zc); ret = hid_parse(hdev); if (ret) { dev_err(&hdev->dev, "zydacron: parse failed\n"); goto err_free; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) { dev_err(&hdev->dev, "zydacron: hw start failed\n"); goto err_free; } return 0; err_free: kfree(zc); return ret; }
static int avr_probe(struct hid_device *hd, const struct hid_device_id *id) { int ret; printk(KERN_ALERT "avr probe"); ret = hid_parse(hd); if (ret) { printk("Failed to parse hid"); return ret; } //ret = hid_hw_start(hd, HID_CONNECT_HIDRAW); //this will make hid device to act like a hid mouse // tested with avr random mouse //HID_CONNECT_DEFAULT is better option than // HID_CONNECT_HIDINPUT only ret = hid_hw_start(hd, HID_CONNECT_DEFAULT); if (ret) { printk("Failed to parse hid"); return ret; } return 0; }
static int quanta_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; struct quanta_data *td; td = kmalloc(sizeof(struct quanta_data), GFP_KERNEL); if (!td) { dev_err(&hdev->dev, "cannot allocate Quanta Touch data\n"); return -ENOMEM; } td->valid = false; td->activity = false; td->activity_now = false; td->first = false; hid_set_drvdata(hdev, td); ret = hid_parse(hdev); if (!ret) ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT | HID_CONNECT_HIDINPUT_FORCE); if (ret) kfree(td); return ret; }
static int samsung_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; unsigned int cmask = HID_CONNECT_DEFAULT; ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err_free; } if (USB_DEVICE_ID_SAMSUNG_IR_REMOTE == hdev->product) { if (hdev->rsize == 184) { /* disable hidinput, force hiddev */ cmask = (cmask & ~HID_CONNECT_HIDINPUT) | HID_CONNECT_HIDDEV_FORCE; } } ret = hid_hw_start(hdev, cmask); if (ret) { hid_err(hdev, "hw start failed\n"); goto err_free; } return 0; err_free: return ret; }
static int ems_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF); if (ret) { hid_err(hdev, "hw start failed\n"); goto err; } ret = emsff_init(hdev); if (ret) { dev_err(&hdev->dev, "force feedback init failed\n"); hid_hw_stop(hdev); goto err; } return 0; err: return ret; }
static int zc_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; struct zc_device *zc; zc = devm_kzalloc(&hdev->dev, sizeof(*zc), GFP_KERNEL); if (zc == NULL) { hid_err(hdev, "can't alloc descriptor\n"); return -ENOMEM; } hid_set_drvdata(hdev, zc); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); return ret; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) { hid_err(hdev, "hw start failed\n"); return ret; } return 0; }
static int u2fzero_probe(struct hid_device *hdev, const struct hid_device_id *id) { struct u2fzero_device *dev; unsigned int minor; int ret; if (!hid_is_using_ll_driver(hdev, &usb_hid_driver)) return -EINVAL; dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL); if (dev == NULL) return -ENOMEM; dev->buf_out = devm_kmalloc(&hdev->dev, sizeof(struct u2f_hid_report), GFP_KERNEL); if (dev->buf_out == NULL) return -ENOMEM; dev->buf_in = devm_kmalloc(&hdev->dev, sizeof(struct u2f_hid_msg), GFP_KERNEL); if (dev->buf_in == NULL) return -ENOMEM; ret = hid_parse(hdev); if (ret) return ret; dev->hdev = hdev; hid_set_drvdata(hdev, dev); mutex_init(&dev->lock); ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); if (ret) return ret; u2fzero_fill_in_urb(dev); dev->present = true; minor = ((struct hidraw *) hdev->hidraw)->minor; ret = u2fzero_init_led(dev, minor); if (ret) { hid_hw_stop(hdev); return ret; } hid_info(hdev, "U2F Zero LED initialised\n"); ret = u2fzero_init_hwrng(dev, minor); if (ret) { hid_hw_stop(hdev); return ret; } hid_info(hdev, "U2F Zero RNG initialised\n"); return 0; }
static int ax_probe(struct hid_device *hdev, const struct hid_device_id *id) { int error; dev_dbg(&hdev->dev, "ACRUX HID hardware probe..."); error = hid_parse(hdev); if (error) { dev_err(&hdev->dev, "parse failed\n"); return error; } error = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF); if (error) { dev_err(&hdev->dev, "hw start failed\n"); return error; } error = axff_init(hdev); if (error) { /* * Do not fail device initialization completely as device * may still be partially operable, just warn. */ dev_warn(&hdev->dev, "Failed to enable force feedback support, error: %d\n", error); } return 0; }
static int kovaplus_probe(struct hid_device *hdev, const struct hid_device_id *id) { int retval; retval = hid_parse(hdev); if (retval) { hid_err(hdev, "parse failed\n"); goto exit; } retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (retval) { hid_err(hdev, "hw start failed\n"); goto exit; } retval = kovaplus_init_specials(hdev); if (retval) { hid_err(hdev, "couldn't install mouse\n"); goto exit_stop; } return 0; exit_stop: hid_hw_stop(hdev); exit: return retval; }
static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id) { unsigned long quirks = id->driver_data; unsigned int connect_mask = HID_CONNECT_DEFAULT; int ret; hid_set_drvdata(hdev, (void *)quirks); if (quirks & LG_NOGET) hdev->quirks |= HID_QUIRK_NOGET; ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err_free; } if (quirks & (LG_FF | LG_FF2 | LG_FF3 | LG_FF4)) connect_mask &= ~HID_CONNECT_FF; ret = hid_hw_start(hdev, connect_mask); if (ret) { hid_err(hdev, "hw start failed\n"); goto err_free; } /* Setup wireless link with Logitech Wii wheel */ if(hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) { unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); if (ret >= 0) { /* insert a little delay of 10 jiffies ~ 40ms */ wait_queue_head_t wait; init_waitqueue_head (&wait); wait_event_interruptible_timeout(wait, 0, 10); /* Select random Address */ buf[1] = 0xB2; get_random_bytes(&buf[2], 2); ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT); } } if (quirks & LG_FF) lgff_init(hdev); if (quirks & LG_FF2) lg2ff_init(hdev); if (quirks & LG_FF3) lg3ff_init(hdev); if (quirks & LG_FF4) lg4ff_init(hdev); return 0; err_free: return ret; }
static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; unsigned long quirks = id->driver_data; struct sony_sc *sc; unsigned int connect_mask = HID_CONNECT_DEFAULT; sc = kzalloc(sizeof(*sc), GFP_KERNEL); if (sc == NULL) { hid_err(hdev, "can't alloc sony descriptor\n"); return -ENOMEM; } sc->quirks = quirks; hid_set_drvdata(hdev, sc); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err_free; } if (sc->quirks & VAIO_RDESC_CONSTANT) connect_mask |= HID_CONNECT_HIDDEV_FORCE; else if (sc->quirks & SIXAXIS_CONTROLLER_USB) connect_mask |= HID_CONNECT_HIDDEV_FORCE; else if (sc->quirks & SIXAXIS_CONTROLLER_BT) connect_mask |= HID_CONNECT_HIDDEV_FORCE; ret = hid_hw_start(hdev, connect_mask); if (ret) { hid_err(hdev, "hw start failed\n"); goto err_free; } if (sc->quirks & SIXAXIS_CONTROLLER_USB) { hdev->hid_output_raw_report = sixaxis_usb_output_raw_report; ret = sixaxis_set_operational_usb(hdev); } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) ret = sixaxis_set_operational_bt(hdev); else if (sc->quirks & BUZZ_CONTROLLER) ret = buzz_init(hdev); else ret = 0; if (ret < 0) goto err_stop; return 0; err_stop: hid_hw_stop(hdev); err_free: kfree(sc); return ret; }
static int belkin_probe(struct hid_device *hdev, const struct hid_device_id *id) { unsigned long quirks = id->driver_data; int ret; hid_set_drvdata(hdev, (void *)quirks); ret = hid_parse(hdev); if (ret) { <<<<<<< HEAD hid_err(hdev, "parse failed\n"); =======
static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret, i; struct mt_device *td; struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */ for (i = 0; mt_classes[i].name ; i++) { if (id->driver_data == mt_classes[i].name) { mtclass = &(mt_classes[i]); break; } } #ifdef MT_DBG if (trace) printk(KERN_ERR "hid-multitouch: class=%d\n", mtclass->name); #endif /* MT_DBG */ /* This allows the driver to correctly support devices * that emit events over several HID messages. */ hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC; td = kzalloc(sizeof(struct mt_device), GFP_KERNEL); if (!td) { dev_err(&hdev->dev, "cannot allocate multitouch data\n"); return -ENOMEM; } td->mtclass = mtclass; td->inputmode = -1; hid_set_drvdata(hdev, td); ret = hid_parse(hdev); if (ret != 0) goto fail; ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) goto fail; td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot), GFP_KERNEL); mt_set_input_mode(hdev); return 0; fail: kfree(td); return ret; }
static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; unsigned long quirks = id->driver_data; struct sony_sc *sc; sc = kzalloc(sizeof(*sc), GFP_KERNEL); if (sc == NULL) { hid_err(hdev, "can't alloc sony descriptor\n"); return -ENOMEM; } sc->quirks = quirks; hid_set_drvdata(hdev, sc); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); goto err_free; } ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT | HID_CONNECT_HIDDEV_FORCE); if (ret) { hid_err(hdev, "hw start failed\n"); goto err_free; } if (sc->quirks & SIXAXIS_CONTROLLER_USB) { #ifndef CONFIG_HID_SONY_PS3_CTRL_BT hdev->hid_output_raw_report = sixaxis_usb_output_raw_report; #endif ret = sixaxis_set_operational_usb(hdev); } else if (sc->quirks & SIXAXIS_CONTROLLER_BT) ret = sixaxis_set_operational_bt(hdev); else ret = 0; if (ret < 0) goto err_stop; return 0; err_stop: hid_hw_stop(hdev); err_free: kfree(sc); return ret; }
static int logi_djdevice_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; struct dj_device *dj_dev = hdev->driver_data; if (!is_dj_device(dj_dev)) return -ENODEV; ret = hid_parse(hdev); if (!ret) ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); return ret; }
//------------------------------------------------------ static int penmount_probe(struct hid_device *pHidDevice, const struct hid_device_id *pHidDevID) { int ret = 0; ret = hid_parse(pHidDevice); if (ret) return ret; ret = hid_hw_start(pHidDevice, HID_CONNECT_DEFAULT); if (ret) return ret; return ret; }
static int apple_probe(struct hid_device *hdev, const struct hid_device_id *id) { unsigned long quirks = id->driver_data; struct apple_sc *asc; unsigned int connect_mask = HID_CONNECT_DEFAULT; int ret; /* return something else or move to hid layer? device will reside allocated */ if (id->bus == BUS_USB && (quirks & APPLE_IGNORE_MOUSE) && to_usb_interface(hdev->dev.parent)->cur_altsetting-> desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE) return -ENODEV; asc = kzalloc(sizeof(*asc), GFP_KERNEL); if (asc == NULL) { dev_err(&hdev->dev, "can't alloc apple descriptor\n"); return -ENOMEM; } asc->quirks = quirks; hid_set_drvdata(hdev, asc); ret = hid_parse(hdev); if (ret) { dev_err(&hdev->dev, "parse failed\n"); goto err_free; } if (quirks & APPLE_HIDDEV) connect_mask |= HID_CONNECT_HIDDEV_FORCE; if (quirks & APPLE_IGNORE_HIDINPUT) connect_mask &= ~HID_CONNECT_HIDINPUT; ret = hid_hw_start(hdev, connect_mask); if (ret) { dev_err(&hdev->dev, "hw start failed\n"); goto err_free; } return 0; err_free: kfree(asc); return ret; }
static int udraw_probe(struct hid_device *hdev, const struct hid_device_id *id) { struct udraw *udraw; int ret; udraw = devm_kzalloc(&hdev->dev, sizeof(struct udraw), GFP_KERNEL); if (!udraw) return -ENOMEM; udraw->hdev = hdev; udraw->last_two_finger_x = -1; udraw->last_two_finger_y = -1; hid_set_drvdata(hdev, udraw); ret = hid_parse(hdev); if (ret) { hid_err(hdev, "parse failed\n"); return ret; } if (!udraw_setup_joypad(udraw, hdev) || !udraw_setup_touch(udraw, hdev) || !udraw_setup_pen(udraw, hdev) || !udraw_setup_accel(udraw, hdev)) { hid_err(hdev, "could not allocate interfaces\n"); return -ENOMEM; } ret = input_register_device(udraw->joy_input_dev) || input_register_device(udraw->touch_input_dev) || input_register_device(udraw->pen_input_dev) || input_register_device(udraw->accel_input_dev); if (ret) { hid_err(hdev, "failed to register interfaces\n"); return ret; } ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW | HID_CONNECT_DRIVER); if (ret) { hid_err(hdev, "hw start failed\n"); return ret; } return 0; }
static int px_probe(struct hid_device *hid, const struct hid_device_id *id) { int ret; ret = hid_parse(hid); if (ret) { hid_err(hid, "parse failed\n"); goto fail; } ret = hid_hw_start(hid, HID_CONNECT_DEFAULT); if (ret) hid_err(hid, "hw start failed\n"); fail: return ret; }
static int accel_probe(struct hid_device *dev, const struct hid_device_id *id) { //struct hid_accel *data = NULL; int retval = -ENOMEM; printk(KERN_INFO "Probing device\n"); dev_info(&dev->dev, "Found USB Accelerometer\n"); // Set up HID Report Parser retval = hid_parse(dev); if (retval) goto error; //data = kzalloc(sizeof(struct hid_accel), GFP_KERNEL); //if (data == NULL) { // dev_err(&dev->dev, "Out of memory\n"); // goto error_mem; //} retval = device_create_file(&dev->dev, &dev_attr_position); if (retval) goto error; retval = device_create_file(&dev->dev, &dev_attr_calibrate); if (retval) goto error; retval = device_create_file(&dev->dev, &dev_attr_recalibrate); if (retval) goto error; read_position(&dev->dev, &rest_x, &rest_y, &rest_z); dev_info(&dev->dev, "USB Accelerometer device now attached\n"); return 0; error: err_hid("There was an error\n"); device_remove_file(&dev->dev, &dev_attr_position); device_remove_file(&dev->dev, &dev_attr_calibrate); device_remove_file(&dev->dev, &dev_attr_recalibrate); // kfree(dev); error_mem: return retval; }
int gcore_hid_open(struct gcore_data *gdata) { struct hid_device *hdev = gdata->hdev; int error; dbg_hid("Preparing to parse %s hid reports\n", gdata->name); /* Parse the device reports and start it up */ error = hid_parse(hdev); if (error) { dev_err(&hdev->dev, "%s device report parse failed\n", gdata->name); error = -EINVAL; goto err_no_cleanup; } error = hid_hw_start(hdev, HID_CONNECT_DEFAULT | HID_CONNECT_HIDINPUT_FORCE); if (error) { dev_err(&hdev->dev, "%s hardware start failed\n", gdata->name); error = -EINVAL; goto err_cleanup_hid; } dbg_hid("%s claimed: %d\n", gdata->name, hdev->claimed); error = hdev->ll_driver->open(hdev); if (error) { dev_err(&hdev->dev, "%s failed to open input interrupt pipe for key and joystick events\n", gdata->name); error = -EINVAL; goto err_cleanup_hid; } return 0; err_cleanup_hid: hid_hw_stop(hdev); err_no_cleanup: return error; }