static int axff_init(struct hid_device *hid) { struct axff_device *axff; struct hid_report *report; struct hid_input *hidinput = list_first_entry(&hid->inputs, struct hid_input, list); struct list_head *report_list =&hid->report_enum[HID_OUTPUT_REPORT].report_list; struct input_dev *dev = hidinput->input; int error; if (list_empty(report_list)) { hid_err(hid, "no output reports found\n"); return -ENODEV; } report = list_first_entry(report_list, struct hid_report, list); if (report->maxfield < 4) { hid_err(hid, "no fields in the report: %d\n", report->maxfield); return -ENODEV; } axff = kzalloc(sizeof(struct axff_device), GFP_KERNEL); if (!axff) return -ENOMEM; set_bit(FF_RUMBLE, dev->ffbit); error = input_ff_create_memless(dev, axff, axff_play); if (error) goto err_free_mem; axff->report = report; axff->report->field[0]->value[0] = 0x00; axff->report->field[1]->value[0] = 0x00; axff->report->field[2]->value[0] = 0x00; axff->report->field[3]->value[0] = 0x00; usbhid_submit_report(hid, axff->report, USB_DIR_OUT); hid_info(hid, "Force Feedback for ACRUX game controllers by Sergei Kolzun<*****@*****.**>\n"); return 0; err_free_mem: kfree(axff); return error; }
int lg2ff_init(struct hid_device *hid) { struct lg2ff_device *lg2ff; struct hid_report *report; struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); struct input_dev *dev = hidinput->input; int error; /* Check that the report looks ok */ report = hid_validate_report(hid, HID_OUTPUT_REPORT, 0, 1, 7); if (!report) return -ENODEV; lg2ff = kmalloc(sizeof(struct lg2ff_device), GFP_KERNEL); if (!lg2ff) return -ENOMEM; set_bit(FF_RUMBLE, dev->ffbit); error = input_ff_create_memless(dev, lg2ff, play_effect); if (error) { kfree(lg2ff); return error; } lg2ff->report = report; report->field[0]->value[0] = 0xf3; report->field[0]->value[1] = 0x00; report->field[0]->value[2] = 0x00; report->field[0]->value[3] = 0x00; report->field[0]->value[4] = 0x00; report->field[0]->value[5] = 0x00; report->field[0]->value[6] = 0x00; usbhid_submit_report(hid, report, USB_DIR_OUT); hid_info(hid, "Force feedback for Logitech RumblePad/Rumblepad 2 by Anssi Hannula <*****@*****.**>\n"); return 0; }
static int zpff_init(struct hid_device *hid) { struct zpff_device *zpff; struct hid_report *report; struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); struct input_dev *dev = hidinput->input; int i, error; for (i = 0; i < 4; i++) { report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, i, 1); if (!report) return -ENODEV; } zpff = kzalloc(sizeof(struct zpff_device), GFP_KERNEL); if (!zpff) return -ENOMEM; set_bit(FF_RUMBLE, dev->ffbit); error = input_ff_create_memless(dev, zpff, zpff_play); if (error) { kfree(zpff); return error; } zpff->report = report; zpff->report->field[0]->value[0] = 0x00; zpff->report->field[1]->value[0] = 0x02; zpff->report->field[2]->value[0] = 0x00; zpff->report->field[3]->value[0] = 0x00; usbhid_submit_report(hid, zpff->report, USB_DIR_OUT); dev_info(&hid->dev, "force feedback for Zeroplus based devices by " "Anssi Hannula <*****@*****.**>\n"); return 0; }
static int twl6040_vibra_probe(struct platform_device *pdev) { struct device *twl6040_core_dev = pdev->dev.parent; struct device_node *twl6040_core_node; struct vibra_info *info; int vddvibl_uV = 0; int vddvibr_uV = 0; int error; twl6040_core_node = of_find_node_by_name(twl6040_core_dev->of_node, "vibra"); if (!twl6040_core_node) { dev_err(&pdev->dev, "parent of node is missing?\n"); return -EINVAL; } info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); if (!info) { of_node_put(twl6040_core_node); dev_err(&pdev->dev, "couldn't allocate memory\n"); return -ENOMEM; } info->dev = &pdev->dev; info->twl6040 = dev_get_drvdata(pdev->dev.parent); of_property_read_u32(twl6040_core_node, "ti,vibldrv-res", &info->vibldrv_res); of_property_read_u32(twl6040_core_node, "ti,vibrdrv-res", &info->vibrdrv_res); of_property_read_u32(twl6040_core_node, "ti,viblmotor-res", &info->viblmotor_res); of_property_read_u32(twl6040_core_node, "ti,vibrmotor-res", &info->vibrmotor_res); of_property_read_u32(twl6040_core_node, "ti,vddvibl-uV", &vddvibl_uV); of_property_read_u32(twl6040_core_node, "ti,vddvibr-uV", &vddvibr_uV); of_node_put(twl6040_core_node); if ((!info->vibldrv_res && !info->viblmotor_res) || (!info->vibrdrv_res && !info->vibrmotor_res)) { dev_err(info->dev, "invalid vibra driver/motor resistance\n"); return -EINVAL; } info->irq = platform_get_irq(pdev, 0); if (info->irq < 0) { dev_err(info->dev, "invalid irq\n"); return -EINVAL; } mutex_init(&info->mutex); error = devm_request_threaded_irq(&pdev->dev, info->irq, NULL, twl6040_vib_irq_handler, 0, "twl6040_irq_vib", info); if (error) { dev_err(info->dev, "VIB IRQ request failed: %d\n", error); return error; } info->supplies[0].supply = "vddvibl"; info->supplies[1].supply = "vddvibr"; /* * When booted with Device tree the regulators are attached to the * parent device (twl6040 MFD core) */ error = devm_regulator_bulk_get(twl6040_core_dev, ARRAY_SIZE(info->supplies), info->supplies); if (error) { dev_err(info->dev, "couldn't get regulators %d\n", error); return error; } if (vddvibl_uV) { error = regulator_set_voltage(info->supplies[0].consumer, vddvibl_uV, vddvibl_uV); if (error) { dev_err(info->dev, "failed to set VDDVIBL volt %d\n", error); return error; } } if (vddvibr_uV) { error = regulator_set_voltage(info->supplies[1].consumer, vddvibr_uV, vddvibr_uV); if (error) { dev_err(info->dev, "failed to set VDDVIBR volt %d\n", error); return error; } } INIT_WORK(&info->play_work, vibra_play_work); info->input_dev = devm_input_allocate_device(&pdev->dev); if (!info->input_dev) { dev_err(info->dev, "couldn't allocate input device\n"); return -ENOMEM; } input_set_drvdata(info->input_dev, info); info->input_dev->name = "twl6040:vibrator"; info->input_dev->id.version = 1; info->input_dev->dev.parent = pdev->dev.parent; info->input_dev->close = twl6040_vibra_close; __set_bit(FF_RUMBLE, info->input_dev->ffbit); error = input_ff_create_memless(info->input_dev, NULL, vibra_play); if (error) { dev_err(info->dev, "couldn't register vibrator to FF\n"); return error; } error = input_register_device(info->input_dev); if (error) { dev_err(info->dev, "couldn't register input device\n"); return error; } platform_set_drvdata(pdev, info); return 0; }
static int max77660_haptic_probe(struct platform_device *pdev) { /* we register the parent platform data */ struct max77660_platform_data *parent_pdata; struct max77660_haptic_platform_data *haptic_pdata; struct max77660_haptic *chip; struct input_dev *input_dev; int ret; parent_pdata = dev_get_platdata(pdev->dev.parent); if (!parent_pdata) { dev_err(&pdev->dev, "no haptic parent platform data\n"); return -EINVAL; } if ((!parent_pdata->haptic_pdata) || !parent_pdata->haptic_pdata->pdata) { dev_err(&pdev->dev, "no haptic platform data\n"); return -EINVAL; } haptic_pdata = parent_pdata->haptic_pdata->pdata; chip = devm_kzalloc(&pdev->dev, sizeof(struct max77660_haptic), GFP_KERNEL); if (!chip) { dev_err(&pdev->dev, "unable to allocate memory\n"); return -ENOMEM; } input_dev = input_allocate_device(); if (!input_dev) { dev_err(&pdev->dev, "unable to allocate memory for input dev\n"); ret = -ENOMEM; goto err_input_alloc; } chip->dev = &pdev->dev; chip->input_dev = input_dev; chip->type = haptic_pdata->type; chip->mode = haptic_pdata->mode; if (chip->mode == MAX77660_INTERNAL_MODE) { chip->internal_mode_pattern = haptic_pdata->internal_mode_pattern; chip->pattern_cycle = haptic_pdata->pattern_cycle; chip->pattern_signal_period = haptic_pdata->pattern_signal_period; chip->feedback_duty_cycle = haptic_pdata->feedback_duty_cycle; chip->invert = haptic_pdata->invert; chip->cont_mode = haptic_pdata->cont_mode; chip->motor_startup_val = haptic_pdata->motor_startup_val; chip->scf_val = haptic_pdata->scf_val; } if (chip->mode == MAX77660_EXTERNAL_MODE) { chip->pwm = pwm_request(haptic_pdata->pwm_channel_id, "max-vbrtr"); if (IS_ERR(chip->pwm)) { dev_err(&pdev->dev, "unable to request PWM for haptic\n"); ret = PTR_ERR(chip->pwm); goto err_pwm; } } chip->regulator = regulator_get(&pdev->dev, "vdd_vbrtr"); if (IS_ERR(chip->regulator)) { dev_err(&pdev->dev, "unable to get regulator\n"); ret = PTR_ERR(chip->regulator); goto err_regulator; } register_input: dev_set_drvdata(&pdev->dev, chip); input_dev->name = MAX77660_HAPTIC_DRIVER_MATCHED_NAME; input_dev->id.version = 1; input_dev->dev.parent = &pdev->dev; input_set_drvdata(input_dev, chip); input_set_capability(input_dev, EV_FF, FF_RUMBLE); ret = input_ff_create_memless(input_dev, NULL, max77660_haptic_play_effect); if (ret) { dev_err(&pdev->dev, "unable to create FF device(ret : %d)\n", ret); goto err_ff_memless; } INIT_WORK(&chip->work, max77660_haptic_play_effect_work); ret = input_register_device(input_dev); if (ret) { dev_err(&pdev->dev, "unable to register input device(ret : %d)\n", ret); goto err_input_register; } ret = sysfs_create_group(&pdev->dev.kobj, &max77660_haptics_attr_group); if (ret < 0) dev_err(&pdev->dev, "unable to create sysfs %d\n", ret); return 0; err_input_register: destroy_work_on_stack(&chip->work); input_ff_destroy(input_dev); err_ff_memless: regulator_put(chip->regulator); err_regulator: if (chip->mode == MAX77660_EXTERNAL_MODE) pwm_free(chip->pwm); err_pwm: input_free_device(input_dev); err_input_alloc: dev_err(&pdev->dev, "Error: %s return ret=%d\n", __func__, ret); return ret; }
static int __devinit max8997_haptic_probe(struct platform_device *pdev) { struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent); const struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev); const struct max8997_haptic_platform_data *haptic_pdata = pdata->haptic_pdata; struct max8997_haptic *chip; struct input_dev *input_dev; int error; if (!haptic_pdata) { dev_err(&pdev->dev, "no haptic platform data\n"); return -EINVAL; } chip = kzalloc(sizeof(struct max8997_haptic), GFP_KERNEL); input_dev = input_allocate_device(); if (!chip || !input_dev) { dev_err(&pdev->dev, "unable to allocate memory\n"); error = -ENOMEM; goto err_free_mem; } INIT_WORK(&chip->work, max8997_haptic_play_effect_work); mutex_init(&chip->mutex); chip->client = iodev->haptic; chip->dev = &pdev->dev; chip->input_dev = input_dev; chip->pwm_period = haptic_pdata->pwm_period; chip->type = haptic_pdata->type; chip->mode = haptic_pdata->mode; chip->pwm_divisor = haptic_pdata->pwm_divisor; switch (chip->mode) { case MAX8997_INTERNAL_MODE: chip->internal_mode_pattern = haptic_pdata->internal_mode_pattern; chip->pattern_cycle = haptic_pdata->pattern_cycle; chip->pattern_signal_period = haptic_pdata->pattern_signal_period; break; case MAX8997_EXTERNAL_MODE: chip->pwm = pwm_request(haptic_pdata->pwm_channel_id, "max8997-haptic"); if (IS_ERR(chip->pwm)) { error = PTR_ERR(chip->pwm); dev_err(&pdev->dev, "unable to request PWM for haptic, error: %d\n", error); goto err_free_mem; } break; default: dev_err(&pdev->dev, "Invalid chip mode specified (%d)\n", chip->mode); error = -EINVAL; goto err_free_mem; } chip->regulator = regulator_get(&pdev->dev, "inmotor"); if (IS_ERR(chip->regulator)) { error = PTR_ERR(chip->regulator); dev_err(&pdev->dev, "unable to get regulator, error: %d\n", error); goto err_free_pwm; } input_dev->name = "max8997-haptic"; input_dev->id.version = 1; input_dev->dev.parent = &pdev->dev; input_dev->close = max8997_haptic_close; input_set_drvdata(input_dev, chip); input_set_capability(input_dev, EV_FF, FF_RUMBLE); error = input_ff_create_memless(input_dev, NULL, max8997_haptic_play_effect); if (error) { dev_err(&pdev->dev, "unable to create FF device, error: %d\n", error); goto err_put_regulator; } error = input_register_device(input_dev); if (error) { dev_err(&pdev->dev, "unable to register input device, error: %d\n", error); goto err_destroy_ff; } platform_set_drvdata(pdev, chip); return 0; err_destroy_ff: input_ff_destroy(input_dev); err_put_regulator: regulator_put(chip->regulator); err_free_pwm: if (chip->mode == MAX8997_EXTERNAL_MODE) pwm_free(chip->pwm); err_free_mem: input_free_device(input_dev); kfree(chip); return error; }
static int sjoyff_init(struct hid_device *hid) { struct sjoyff_device *sjoyff; struct hid_report *report; struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list); struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list; struct list_head *report_ptr = report_list; struct input_dev *dev; int error; if (list_empty(report_list)) { dev_err(&hid->dev, "no output reports found\n"); return -ENODEV; } report_ptr = report_ptr->next; if (report_ptr == report_list) { dev_err(&hid->dev, "required output report is " "missing\n"); return -ENODEV; } report = list_entry(report_ptr, struct hid_report, list); if (report->maxfield < 1) { dev_err(&hid->dev, "no fields in the report\n"); return -ENODEV; } if (report->field[0]->report_count < 3) { dev_err(&hid->dev, "not enough values in the field\n"); return -ENODEV; } sjoyff = kzalloc(sizeof(struct sjoyff_device), GFP_KERNEL); if (!sjoyff) return -ENOMEM; dev = hidinput->input; set_bit(FF_RUMBLE, dev->ffbit); error = input_ff_create_memless(dev, sjoyff, hid_sjoyff_play); if (error) { kfree(sjoyff); return error; } sjoyff->report = report; sjoyff->report->field[0]->value[0] = 0x01; sjoyff->report->field[0]->value[1] = 0x00; sjoyff->report->field[0]->value[2] = 0x00; usbhid_submit_report(hid, sjoyff->report, USB_DIR_OUT); dev_info(&hid->dev, "Force feedback for SmartJoy PLUS PS2/USB adapter\n"); return 0; }
static int __devinit pm8xxx_vib_probe(struct platform_device *pdev) { struct pm8xxx_vib *vib; struct input_dev *input_dev; int error; u8 val; vib = kzalloc(sizeof(*vib), GFP_KERNEL); input_dev = input_allocate_device(); if (!vib || !input_dev) { dev_err(&pdev->dev, "couldn't allocate memory\n"); error = -ENOMEM; goto err_free_mem; } INIT_WORK(&vib->work, pm8xxx_work_handler); vib->dev = &pdev->dev; vib->vib_input_dev = input_dev; error = pm8xxx_vib_read_u8(vib, &val, VIB_DRV); if (error < 0) goto err_free_mem; val &= ~VIB_DRV_EN_MANUAL_MASK; error = pm8xxx_vib_write_u8(vib, val, VIB_DRV); if (error < 0) goto err_free_mem; vib->reg_vib_drv = val; input_dev->name = "pm8xxx_vib_ffmemless"; input_dev->id.version = 1; input_dev->dev.parent = &pdev->dev; input_dev->close = pm8xxx_vib_close; input_set_drvdata(input_dev, vib); input_set_capability(vib->vib_input_dev, EV_FF, FF_RUMBLE); error = input_ff_create_memless(input_dev, NULL, pm8xxx_vib_play_effect); if (error) { dev_err(&pdev->dev, "couldn't register vibrator as FF device\n"); goto err_free_mem; } error = input_register_device(input_dev); if (error) { dev_err(&pdev->dev, "couldn't register input device\n"); goto err_destroy_memless; } platform_set_drvdata(pdev, vib); return 0; err_destroy_memless: input_ff_destroy(input_dev); err_free_mem: input_free_device(input_dev); kfree(vib); return error; }
static int __devinit twl6040_vibra_probe(struct platform_device *pdev) { struct twl4030_vibra_data *pdata = pdev->dev.platform_data; struct vibra_info *info; int ret; if (!pdata) { dev_err(&pdev->dev, "platform_data not available\n"); return -EINVAL; } info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { dev_err(&pdev->dev, "couldn't allocate memory\n"); return -ENOMEM; } info->dev = &pdev->dev; info->twl6040 = dev_get_drvdata(pdev->dev.parent); info->vibldrv_res = pdata->vibldrv_res; info->vibrdrv_res = pdata->vibrdrv_res; info->viblmotor_res = pdata->viblmotor_res; info->vibrmotor_res = pdata->vibrmotor_res; if ((!info->vibldrv_res && !info->viblmotor_res) || (!info->vibrdrv_res && !info->vibrmotor_res)) { dev_err(info->dev, "invalid vibra driver/motor resistance\n"); ret = -EINVAL; goto err_kzalloc; } info->irq = platform_get_irq(pdev, 0); if (info->irq < 0) { dev_err(info->dev, "invalid irq\n"); ret = -EINVAL; goto err_kzalloc; } mutex_init(&info->mutex); info->input_dev = input_allocate_device(); if (info->input_dev == NULL) { dev_err(info->dev, "couldn't allocate input device\n"); ret = -ENOMEM; goto err_kzalloc; } input_set_drvdata(info->input_dev, info); info->input_dev->name = "twl6040:vibrator"; info->input_dev->id.version = 1; info->input_dev->dev.parent = pdev->dev.parent; info->input_dev->close = twl6040_vibra_close; __set_bit(FF_RUMBLE, info->input_dev->ffbit); ret = input_ff_create_memless(info->input_dev, NULL, vibra_play); if (ret < 0) { dev_err(info->dev, "couldn't register vibrator to FF\n"); goto err_ialloc; } ret = input_register_device(info->input_dev); if (ret < 0) { dev_err(info->dev, "couldn't register input device\n"); goto err_iff; } platform_set_drvdata(pdev, info); ret = request_threaded_irq(info->irq, NULL, twl6040_vib_irq_handler, 0, "twl6040_irq_vib", info); if (ret) { dev_err(info->dev, "VIB IRQ request failed: %d\n", ret); goto err_irq; } info->supplies[0].supply = "vddvibl"; info->supplies[1].supply = "vddvibr"; ret = regulator_bulk_get(info->dev, ARRAY_SIZE(info->supplies), info->supplies); if (ret) { dev_err(info->dev, "couldn't get regulators %d\n", ret); goto err_regulator; } if (pdata->vddvibl_uV) { ret = regulator_set_voltage(info->supplies[0].consumer, pdata->vddvibl_uV, pdata->vddvibl_uV); if (ret) { dev_err(info->dev, "failed to set VDDVIBL volt %d\n", ret); goto err_voltage; } } if (pdata->vddvibr_uV) { ret = regulator_set_voltage(info->supplies[1].consumer, pdata->vddvibr_uV, pdata->vddvibr_uV); if (ret) { dev_err(info->dev, "failed to set VDDVIBR volt %d\n", ret); goto err_voltage; } } info->workqueue = alloc_workqueue("twl6040-vibra", 0, 0); if (info->workqueue == NULL) { dev_err(info->dev, "couldn't create workqueue\n"); ret = -ENOMEM; goto err_voltage; } INIT_WORK(&info->play_work, vibra_play_work); return 0; err_voltage: regulator_bulk_free(ARRAY_SIZE(info->supplies), info->supplies); err_regulator: free_irq(info->irq, info); err_irq: input_unregister_device(info->input_dev); info->input_dev = NULL; err_iff: if (info->input_dev) input_ff_destroy(info->input_dev); err_ialloc: input_free_device(info->input_dev); err_kzalloc: kfree(info); return ret; }
static int __devinit pmic8058_vib_probe(struct platform_device *pdev) { struct pmic8058_vibrator_pdata *pdata = pdev->dev.platform_data; struct pmic8058_vib *vib; u8 val; int rc; struct pm8058_chip *pm_chip; pm_chip = dev_get_drvdata(pdev->parent.dev); if (pm_chip == NULL) { dev_err(&pdev->dev, "no parent data passed in\n"); return -EFAULT; } if (!pdata) return -EINVAL; if (pdata->level_mV < VIB_MIN_LEVEL_mV || pdata->level_mV > VIB_MAX_LEVEL_mV) return -EINVAL; vib = kzalloc(sizeof(*vib), GFP_KERNEL); if (!vib) return -ENOMEM; vib->pm_chip = pm_chip; vib->enabled = 0; vib->pdata = pdata; vib->level = pdata->level_mV / 100; vib->dev = &pdev->dev; spin_lock_init(&vib->lock); INIT_WORK(&vib->work, pmic8058_work_handler); vib->info = input_allocate_device(); if (vib->info == NULL) { dev_err(&pdev->dev, "couldn't allocate input device\n"); return -ENOMEM; } input_set_drvdata(vib->info, vib); vib->info->name = "pmic8058:vibrator"; vib->info->id.version = 1; vib->info->dev.parent = pdev->dev.parent; __set_bit(FF_RUMBLE, vib->info->ffbit); __dump_vib_regs(vib, "boot_vib_default"); /* */ rc = pmic8058_vib_read_u8(vib, &val, VIB_DRV); if (rc < 0) goto err_read_vib; val &= ~VIB_DRV_EN_MANUAL_MASK; rc = pmic8058_vib_write_u8(vib, val, VIB_DRV); if (rc < 0) goto err_read_vib; vib->reg_vib_drv = val; rc = input_ff_create_memless(vib->info, NULL, pmic8058_vib_play_effect); if (rc < 0) { dev_dbg(&pdev->dev, "couldn't register vibrator to FF\n"); goto create_memless_err; } platform_set_drvdata(pdev, vib); rc = input_register_device(vib->info); if (rc < 0) { dev_dbg(&pdev->dev, "couldn't register input device\n"); goto reg_err; } return 0; reg_err: input_ff_destroy(vib->info); create_memless_err: input_free_device(vib->info); err_read_vib: kfree(vib); return rc; }
static int regulator_haptic_probe(struct platform_device *pdev) { struct regulator_haptic *haptic; struct input_dev *input_dev; char *select_regulator_name; int error; haptic = kzalloc(sizeof(*haptic), GFP_KERNEL); if (!haptic) { printk("regulator-haptic : unable to allocate memory for haptic\n"); return -ENOMEM; } input_dev = input_allocate_device(); if (!input_dev) { printk("regulator-haptic : unalbe to allocate memory\n"); error = -ENOMEM; goto err_kfree_mem; } INIT_WORK(&haptic->work, regulator_haptic_work); mutex_init(&haptic->mutex); haptic->input_dev = input_dev; haptic->dev = &pdev->dev; select_regulator_name = get_regulator_name(); if(!strcmp(select_regulator_name, ERROR_NAME)) { pr_info("%s : error regulator_name\n", __func__); error = -ENOMEM; goto err_kfree_mem; } haptic->regulator = regulator_get(&pdev->dev, select_regulator_name); if (IS_ERR(haptic->regulator)) { error = PTR_ERR(haptic->regulator); printk("regulator-haptic : unable to get regulator, err : %d\n", error); goto err_ifree_mem; } set_haptic_data(haptic); haptic->input_dev->name = "regulator-haptic"; haptic->input_dev->dev.parent = &pdev->dev; haptic->input_dev->close = regulator_haptic_close; haptic->enabled = false; input_set_drvdata(haptic->input_dev, haptic); input_set_capability(haptic->input_dev, EV_FF, FF_RUMBLE); error = input_ff_create_memless(input_dev, NULL, regulator_haptic_play); if (error) { printk("regulator-haptic : input_ff_create_memless() failed : %d\n", error); goto err_put_regulator; } error = input_register_device(haptic->input_dev); if (error) { printk("regulator-haptic : couldn't register input device : %d\n", error); goto err_destroy_ff; } platform_set_drvdata(pdev, haptic); return 0; err_destroy_ff: input_ff_destroy(haptic->input_dev); err_put_regulator: regulator_put(haptic->regulator); err_ifree_mem: input_free_device(haptic->input_dev); err_kfree_mem: kfree(haptic); return error; }
static int __devinit max77665_haptic_probe(struct platform_device *pdev) { struct max77665_haptic_platform_data *haptic_pdata = pdev->dev.platform_data; struct max77665_haptic *chip; struct edp_manager *battery_manager = NULL; struct input_dev *input_dev; int ret; if (!haptic_pdata) { dev_err(&pdev->dev, "no haptic platform data\n"); return -EINVAL; } chip = devm_kzalloc(&pdev->dev, sizeof(struct max77665_haptic), GFP_KERNEL); if (!chip) { dev_err(&pdev->dev, "unable to allocate memory\n"); return -ENOMEM; } input_dev = input_allocate_device(); if (!input_dev) { dev_err(&pdev->dev, "unable to allocate memory for input dev\n"); ret = -ENOMEM; goto err_input_alloc; } chip->dev = &pdev->dev; chip->input_dev = input_dev; chip->pwm_period = haptic_pdata->pwm_period; chip->type = haptic_pdata->type; chip->mode = haptic_pdata->mode; chip->pwm_divisor = haptic_pdata->pwm_divisor; if (chip->mode == MAX77665_INTERNAL_MODE) { chip->internal_mode_pattern = haptic_pdata->internal_mode_pattern; chip->pattern_cycle = haptic_pdata->pattern_cycle; chip->pattern_signal_period = haptic_pdata->pattern_signal_period; chip->feedback_duty_cycle = haptic_pdata->feedback_duty_cycle; chip->invert = haptic_pdata->invert; chip->cont_mode = haptic_pdata->cont_mode; chip->motor_startup_val = haptic_pdata->motor_startup_val; chip->scf_val = haptic_pdata->scf_val; } if (chip->mode == MAX77665_EXTERNAL_MODE) { chip->pwm = pwm_request(haptic_pdata->pwm_channel_id, "max-vbrtr"); if (IS_ERR(chip->pwm)) { dev_err(&pdev->dev, "unable to request PWM for haptic\n"); ret = PTR_ERR(chip->pwm); goto err_pwm; } } chip->regulator = regulator_get(&pdev->dev, "vdd_vbrtr"); if (IS_ERR(chip->regulator)) { dev_err(&pdev->dev, "unable to get regulator\n"); ret = PTR_ERR(chip->regulator); goto err_regulator; } if (haptic_pdata->edp_states == NULL) goto register_input; chip->haptic_edp_client = devm_kzalloc(&pdev->dev, sizeof(struct edp_client), GFP_KERNEL); if (IS_ERR_OR_NULL(chip->haptic_edp_client)) { dev_err(&pdev->dev, "could not allocate edp client\n"); goto register_input; } chip->haptic_edp_client->name[EDP_NAME_LEN - 1] = '\0'; strncpy(chip->haptic_edp_client->name, "vibrator", EDP_NAME_LEN - 1); chip->haptic_edp_client->states = haptic_pdata->edp_states; chip->haptic_edp_client->num_states = MAX77665_HAPTIC_EDP_NUM_STATES; chip->haptic_edp_client->e0_index = MAX77665_HAPTIC_EDP_LOW; chip->haptic_edp_client->priority = EDP_MAX_PRIO + 2; chip->haptic_edp_client->throttle = max77665_haptic_throttle; chip->haptic_edp_client->private_data = chip; battery_manager = edp_get_manager("battery"); if (!battery_manager) { dev_err(&pdev->dev, "unable to get edp manager\n"); } else { ret = edp_register_client(battery_manager, chip->haptic_edp_client); if (ret) { dev_err(&pdev->dev, "unable to register edp client\n"); } else { ret = edp_update_client_request(chip->haptic_edp_client, MAX77665_HAPTIC_EDP_LOW, NULL); if (ret) { dev_err(&pdev->dev, "unable to set E0 EDP state\n"); edp_unregister_client(chip->haptic_edp_client); } else { goto register_input; } } } devm_kfree(&pdev->dev, chip->haptic_edp_client); chip->haptic_edp_client = NULL; register_input: dev_set_drvdata(&pdev->dev, chip); input_dev->name = "max77665-haptic"; input_dev->id.version = 1; input_dev->dev.parent = &pdev->dev; input_set_drvdata(input_dev, chip); input_set_capability(input_dev, EV_FF, FF_RUMBLE); ret = input_ff_create_memless(input_dev, NULL, max77665_haptic_play_effect); if (ret) { dev_err(&pdev->dev, "unable to create FF device(ret : %d)\n", ret); goto err_ff_memless; } INIT_WORK(&chip->work, max77665_haptic_play_effect_work); ret = input_register_device(input_dev); if (ret) { dev_err(&pdev->dev, "unable to register input device(ret : %d)\n", ret); goto err_input_register; } ret = sysfs_create_group(&pdev->dev.kobj, &max77665_haptics_attr_group); if (ret < 0) { dev_err(&pdev->dev, "unable to create sysfs %d\n", ret); } return 0; err_input_register: destroy_work_on_stack(&chip->work); input_ff_destroy(input_dev); err_ff_memless: regulator_put(chip->regulator); err_regulator: if (chip->mode == MAX77665_EXTERNAL_MODE) pwm_free(chip->pwm); err_pwm: input_free_device(input_dev); err_input_alloc: kfree(chip); return ret; }
static int xpad360_probe(struct usb_interface *interface, const struct usb_device_id *id) { int error = 0; struct usb_device *usb_dev = interface_to_usbdev(interface); struct xpad360_controller *controller = kzalloc(sizeof(struct xpad360_controller), GFP_KERNEL); if (!controller) return -ENOMEM; usb_set_intfdata(interface, controller); /* LED */ error = xpad360_setup_transfer_out(interface, &controller->led_out, xpad360_send, GFP_KERNEL); if (error) goto fail_led_setup; controller->led_out.urb->transfer_buffer_length = 3; /* Never changes */ xpad360_async_led(controller, XPAD360_LED_ON_1); /* Input Dev allocation, capabilities, registration */ controller->input_dev = xpad360_create_input_dev(usb_dev, xpad360_device_names[id - xpad360_table], xpad360_open, xpad360_close); if (!controller->input_dev) { error = -ENOMEM; goto fail_input_setup; } xpad360_set_capabilities(controller->input_dev); error = input_register_device(controller->input_dev); if (error) goto fail_input_register; input_set_drvdata(controller->input_dev, controller); /* Rumble transfer setup */ #ifndef XPAD360_RUMBLE_DISABLED error = xpad360_setup_transfer_out(interface, &controller->rumble_out, xpad360_send, GFP_KERNEL); if (error) goto fail_ff_setup; controller->rumble_out.urb->transfer_buffer_length = 8; /* Never changes */ /* ff-memless setup */ error = input_ff_create_memless(controller->input_dev, NULL, xpad360_rumble); if (error) goto fail_ff_memless; #endif /* In transfer */ error = xpad360_setup_transfer_in(interface, &controller->in, xpad360_receive, GFP_KERNEL); if (error) goto fail_in_init; error = usb_submit_urb(controller->in.urb, GFP_KERNEL); if (error) goto fail_in_submit; goto success; fail_in_submit: xpad360_free_transfer(usb_dev, &controller->in); fail_in_init: fail_ff_memless: xpad360_free_transfer(usb_dev, &controller->rumble_out); fail_ff_setup: xpad360_unregister_input_dev(controller->input_dev); fail_input_register: xpad360_free_input_dev(controller->input_dev); fail_input_setup: xpad360_free_transfer(usb_dev, &controller->led_out); fail_led_setup: kfree(controller); success: return error; }
static int __devinit twl4030_vibra_probe(struct platform_device *pdev) { struct twl4030_codec_vibra_data *pdata = pdev->dev.platform_data; struct vibra_info *info; int ret; if (!pdata) { dev_dbg(&pdev->dev, "platform_data not available\n"); return -EINVAL; } info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) return -ENOMEM; info->dev = &pdev->dev; info->coexist = pdata->coexist; INIT_WORK(&info->play_work, vibra_play_work); info->input_dev = input_allocate_device(); if (info->input_dev == NULL) { dev_err(&pdev->dev, "couldn't allocate input device\n"); ret = -ENOMEM; goto err_kzalloc; } input_set_drvdata(info->input_dev, info); info->input_dev->name = "twl4030:vibrator"; info->input_dev->id.version = 1; info->input_dev->dev.parent = pdev->dev.parent; info->input_dev->open = twl4030_vibra_open; info->input_dev->close = twl4030_vibra_close; __set_bit(FF_RUMBLE, info->input_dev->ffbit); ret = input_ff_create_memless(info->input_dev, NULL, vibra_play); if (ret < 0) { dev_dbg(&pdev->dev, "couldn't register vibrator to FF\n"); goto err_ialloc; } ret = input_register_device(info->input_dev); if (ret < 0) { dev_dbg(&pdev->dev, "couldn't register input device\n"); goto err_iff; } vibra_disable_leds(); platform_set_drvdata(pdev, info); #ifdef VDEBUG printk(KERN_INFO "successfully probed the vibrator device.\n"); #endif return 0; err_iff: input_ff_destroy(info->input_dev); err_ialloc: input_free_device(info->input_dev); err_kzalloc: kfree(info); return ret; }
static int drv2667_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct drv2667_data *haptics; int error; haptics = devm_kzalloc(&client->dev, sizeof(*haptics), GFP_KERNEL); if (!haptics) return -ENOMEM; haptics->regulator = devm_regulator_get(&client->dev, "vbat"); if (IS_ERR(haptics->regulator)) { error = PTR_ERR(haptics->regulator); dev_err(&client->dev, "unable to get regulator, error: %d\n", error); return error; } haptics->input_dev = devm_input_allocate_device(&client->dev); if (!haptics->input_dev) { dev_err(&client->dev, "Failed to allocate input device\n"); return -ENOMEM; } haptics->input_dev->name = "drv2667:haptics"; haptics->input_dev->dev.parent = client->dev.parent; haptics->input_dev->close = drv2667_close; input_set_drvdata(haptics->input_dev, haptics); input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE); error = input_ff_create_memless(haptics->input_dev, NULL, drv2667_haptics_play); if (error) { dev_err(&client->dev, "input_ff_create() failed: %d\n", error); return error; } INIT_WORK(&haptics->work, drv2667_worker); haptics->client = client; i2c_set_clientdata(client, haptics); haptics->regmap = devm_regmap_init_i2c(client, &drv2667_regmap_config); if (IS_ERR(haptics->regmap)) { error = PTR_ERR(haptics->regmap); dev_err(&client->dev, "Failed to allocate register map: %d\n", error); return error; } error = drv2667_init(haptics); if (error) { dev_err(&client->dev, "Device init failed: %d\n", error); return error; } error = input_register_device(haptics->input_dev); if (error) { dev_err(&client->dev, "couldn't register input device: %d\n", error); return error; } return 0; }
static int max77693_haptic_probe(struct platform_device *pdev) { struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent); struct max77693_haptic *haptic; int error; haptic = devm_kzalloc(&pdev->dev, sizeof(*haptic), GFP_KERNEL); if (!haptic) return -ENOMEM; haptic->regmap_pmic = max77693->regmap; haptic->regmap_haptic = max77693->regmap_haptic; haptic->dev = &pdev->dev; haptic->type = MAX77693_HAPTIC_LRA; haptic->mode = MAX77693_HAPTIC_EXTERNAL_MODE; haptic->pwm_divisor = MAX77693_HAPTIC_PWM_DIVISOR_128; haptic->suspend_state = false; INIT_WORK(&haptic->work, max77693_haptic_play_work); /* Get pwm and regulatot for haptic device */ haptic->pwm_dev = devm_pwm_get(&pdev->dev, NULL); if (IS_ERR(haptic->pwm_dev)) { dev_err(&pdev->dev, "failed to get pwm device\n"); return PTR_ERR(haptic->pwm_dev); } haptic->motor_reg = devm_regulator_get(&pdev->dev, "haptic"); if (IS_ERR(haptic->motor_reg)) { dev_err(&pdev->dev, "failed to get regulator\n"); return PTR_ERR(haptic->motor_reg); } /* Initialize input device for haptic device */ haptic->input_dev = devm_input_allocate_device(&pdev->dev); if (!haptic->input_dev) { dev_err(&pdev->dev, "failed to allocate input device\n"); return -ENOMEM; } haptic->input_dev->name = "max77693-haptic"; haptic->input_dev->id.version = 1; haptic->input_dev->dev.parent = &pdev->dev; haptic->input_dev->open = max77693_haptic_open; haptic->input_dev->close = max77693_haptic_close; input_set_drvdata(haptic->input_dev, haptic); input_set_capability(haptic->input_dev, EV_FF, FF_RUMBLE); error = input_ff_create_memless(haptic->input_dev, NULL, max77693_haptic_play_effect); if (error) { dev_err(&pdev->dev, "failed to create force-feedback\n"); return error; } error = input_register_device(haptic->input_dev); if (error) { dev_err(&pdev->dev, "failed to register input device\n"); return error; } platform_set_drvdata(pdev, haptic); return 0; }