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;
}
