static int lm63_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct lm63_data *data;
int err;
data = kzalloc(sizeof(struct lm63_data), GFP_KERNEL);
if (!data) {
err = -ENOMEM;
goto exit;
}
i2c_set_clientdata(client, data);
data->valid = 0;
mutex_init(&data->update_lock);
/* Set the device type */
data->kind = id->driver_data;
if (data->kind == lm64)
data->temp2_offset = 16000;
/* Initialize chip */
lm63_init_client(client);
/* Register sysfs hooks */
err = sysfs_create_group(&client->dev.kobj, &lm63_group);
if (err)
goto exit_free;
if (data->config & 0x04) { /* tachometer enabled */
err = sysfs_create_group(&client->dev.kobj, &lm63_group_fan1);
if (err)
goto exit_remove_files;
}
if (data->kind == lm96163) {
err = device_create_file(&client->dev, &dev_attr_temp2_type);
if (err)
goto exit_remove_files;
err = sysfs_create_group(&client->dev.kobj,
&lm63_group_extra_lut);
if (err)
goto exit_remove_files;
}
data->hwmon_dev = hwmon_device_register(&client->dev);
if (IS_ERR(data->hwmon_dev)) {
err = PTR_ERR(data->hwmon_dev);
goto exit_remove_files;
}
return 0;
exit_remove_files:
sysfs_remove_group(&client->dev.kobj, &lm63_group);
sysfs_remove_group(&client->dev.kobj, &lm63_group_fan1);
if (data->kind == lm96163) {
device_remove_file(&client->dev, &dev_attr_temp2_type);
sysfs_remove_group(&client->dev.kobj, &lm63_group_extra_lut);
}
exit_free:
kfree(data);
exit:
return err;
}
static int __devinit twl6030_usb_probe(struct platform_device *pdev)
{
struct twl6030_usb *twl;
int status, err;
struct twl4030_usb_data *pdata;
struct device *dev = &pdev->dev;
pdata = dev->platform_data;
twl = kzalloc(sizeof *twl, GFP_KERNEL);
if (!twl)
return -ENOMEM;
twl->dev = &pdev->dev;
twl->irq1 = platform_get_irq(pdev, 0);
twl->irq2 = platform_get_irq(pdev, 1);
twl->features = pdata->features;
twl->otg.dev = twl->dev;
twl->otg.label = "twl6030";
twl->otg.set_host = twl6030_set_host;
twl->otg.set_peripheral = twl6030_set_peripheral;
twl->otg.set_vbus = twl6030_set_vbus;
twl->otg.set_hz_mode = twl6030_set_hz_mode;
twl->otg.init = twl6030_phy_init;
twl->otg.set_power = twl6030_set_power;
twl->otg.shutdown = twl6030_phy_shutdown;
twl->otg.set_suspend = twl6030_phy_suspend;
twl->otg.start_srp = twl6030_start_srp;
twl->otg.state = OTG_STATE_UNDEFINED;
/* init spinlock for workqueue */
spin_lock_init(&twl->lock);
err = twl6030_usb_ldo_init(twl);
if (err) {
dev_err(&pdev->dev, "ldo init failed\n");
kfree(twl);
return err;
}
otg_set_transceiver(&twl->otg);
platform_set_drvdata(pdev, twl);
if (device_create_file(&pdev->dev, &dev_attr_vbus))
dev_warn(&pdev->dev, "could not create sysfs file\n");
ATOMIC_INIT_NOTIFIER_HEAD(&twl->otg.notifier);
INIT_WORK(&twl->set_vbus_work, otg_set_vbus_work);
twl->vbus_enable = false;
twl->irq_enabled = true;
status = request_threaded_irq(twl->irq1, NULL, twl6030_usbotg_irq,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"twl6030_usb", twl);
if (status < 0) {
dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
twl->irq1, status);
device_remove_file(twl->dev, &dev_attr_vbus);
kfree(twl);
return status;
}
status = request_threaded_irq(twl->irq2, NULL, twl6030_usb_irq,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"twl6030_usb", twl);
if (status < 0) {
dev_err(&pdev->dev, "can't get IRQ %d, err %d\n",
twl->irq2, status);
free_irq(twl->irq1, twl);
device_remove_file(twl->dev, &dev_attr_vbus);
kfree(twl);
return status;
}
twl->asleep = 0;
twl->is_phy_suspended = true;
pdata->phy_init(dev);
twl6030_phy_suspend(&twl->otg, 0);
twl6030_enable_irq(&twl->otg);
dev_info(&pdev->dev, "Initialized TWL6030 USB module\n");
return 0;
}
static int rmnet_usb_probe(struct usb_interface *iface,
const struct usb_device_id *prod)
{
struct usbnet *unet;
struct driver_info *info = (struct driver_info *)prod->driver_info;
struct usb_device *udev;
int status = 0;
unsigned int i, unet_id, rdev_cnt, n = 0;
bool mux;
struct rmnet_ctrl_dev *dev;
udev = interface_to_usbdev(iface);
if (iface->num_altsetting != 1) {
dev_err(&iface->dev, "%s invalid num_altsetting %u\n",
__func__, iface->num_altsetting);
status = -EINVAL;
goto out;
}
mux = test_bit(info->data, &mux_enabled);
if (prod->idProduct == 0x908a)
mux = true;
else
mux = false;
mux_enabled_per_pid = mux;
rdev_cnt = mux ? no_rmnet_insts_per_dev : 1;
info->in = 0;
for (n = 0; n < rdev_cnt; n++) {
info->in++;
status = usbnet_probe(iface, prod);
if (status < 0) {
dev_err(&iface->dev, "usbnet_probe failed %d\n",
status);
goto out;
}
unet_id = n + info->data * no_rmnet_insts_per_dev;
unet_list[unet_id] = unet = usb_get_intfdata(iface);
unet->data[3] = n;
unet->data[1] = unet->data[4] = mux;
set_bit(RMNET_MODE_LLP_ETH, &unet->data[0]);
rmnet_usb_setup(unet->net, mux);
status = device_create_file(&unet->net->dev,
&dev_attr_dbg_mask);
if (status) {
usbnet_disconnect(iface);
goto out;
}
status = rmnet_usb_ctrl_probe(iface, unet->status, info->data,
&unet->data[1]);
if (status) {
device_remove_file(&unet->net->dev, &dev_attr_dbg_mask);
usbnet_disconnect(iface);
goto out;
}
status = rmnet_usb_data_debugfs_init(unet);
if (status)
dev_dbg(&iface->dev,
"mode debugfs file is not available\n");
}
if (udev->parent && !udev->parent->parent) {
device_set_wakeup_enable(&udev->dev, 1);
device_set_wakeup_enable(&udev->parent->dev, 1);
pm_runtime_set_autosuspend_delay(&udev->dev, 1000);
pm_runtime_set_autosuspend_delay(&udev->parent->dev, 200);
}
return 0;
out:
for (i = 0; i < n; i++) {
unet_id = i + info->data * no_rmnet_insts_per_dev;
unet = unet_list[unet_id];
dev = (struct rmnet_ctrl_dev *)unet->data[1];
rmnet_usb_data_debugfs_cleanup(unet);
rmnet_usb_ctrl_disconnect(dev);
device_remove_file(&unet->net->dev, &dev_attr_dbg_mask);
usb_set_intfdata(iface, unet_list[unet_id]);
usbnet_disconnect(iface);
unet_list[unet_id] = NULL;
}
return status;
}
static int __devinit bh1721fvc_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int err = 0;
struct bh1721fvc_data *bh1721fvc;
struct input_dev *input_dev;
struct bh1721fvc_platform_data *pdata = client->dev.platform_data;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
return -EIO;
bh1721fvc = kzalloc(sizeof(*bh1721fvc), GFP_KERNEL);
if (!bh1721fvc) {
pr_err("%s, failed to alloc memory for module data\n",
__func__);
return -ENOMEM;
}
bh1721fvc->reset = pdata->reset;
if (!bh1721fvc->reset) {
pr_err("%s: reset callback is null\n", __func__);
err = -EIO;
goto err_reset_null;
}
err = bh1721fvc->reset();
if (err) {
pr_err("%s: Failed to reset\n", __func__);
goto err_reset_failed;
}
bh1721fvc->client = client;
i2c_set_clientdata(client, bh1721fvc);
mutex_init(&bh1721fvc->lock);
bh1721fvc->state = POWER_DOWN;
bh1721fvc->measure_mode = AUTO_MEASURE;
err = bh1721fvc_test_luxvalue(bh1721fvc);
if (err < 0) {
pr_err("%s: No search bh1721fvc lightsensor!\n", __func__);
goto err_test_lightsensor;
} else {
printk(KERN_ERR"Lux : %d\n", err);
}
hrtimer_init(&bh1721fvc->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
bh1721fvc->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC);
bh1721fvc->timer.function = bh1721fvc_timer_func;
bh1721fvc->wq = alloc_workqueue("bh1721fvc_wq",
WQ_UNBOUND | WQ_RESCUER, 1);
if (!bh1721fvc->wq) {
err = -ENOMEM;
pr_err("%s: could not create workqueue\n", __func__);
goto err_create_workqueue;
}
INIT_WORK(&bh1721fvc->work_light, bh1721fvc_work_func_light);
input_dev = input_allocate_device();
if (!input_dev) {
pr_err("%s: could not allocate input device\n", __func__);
err = -ENOMEM;
goto err_input_allocate_device_light;
}
input_set_drvdata(input_dev, bh1721fvc);
input_dev->name = "light_sensor";
input_set_capability(input_dev, EV_ABS, ABS_MISC);
input_set_abs_params(input_dev, ABS_MISC,
LUX_MIN_VALUE, LUX_MAX_VALUE, 0, 0);
bh1721fvc_dbmsg("registering lightsensor-level input device\n");
err = input_register_device(input_dev);
if (err < 0) {
pr_err("%s: could not register input device\n", __func__);
input_free_device(input_dev);
goto err_input_register_device_light;
}
bh1721fvc->input_dev = input_dev;
err = sysfs_create_group(&input_dev->dev.kobj,
&bh1721fvc_attribute_group);
if (err) {
pr_err("%s: could not create sysfs group\n", __func__);
goto err_sysfs_create_group_light;
}
bh1721fvc->factory_class = class_create(THIS_MODULE, "lightsensor");
if (IS_ERR(bh1721fvc->factory_class)) {
pr_err("Failed to create class(lightsensor)!\n");
err = PTR_ERR(bh1721fvc->factory_class);
goto err_factory_sysfs_create;
}
bh1721fvc->factory_dev = device_create(bh1721fvc->factory_class, NULL,
0, bh1721fvc, "switch_cmd");
if (IS_ERR(bh1721fvc->factory_dev)) {
pr_err("Failed to create device(switch_cmd_dev)!\n");
err = PTR_ERR(bh1721fvc->factory_dev);
goto err_factory_device_create;
}
err = device_create_file(bh1721fvc->factory_dev,
&dev_attr_lightsensor_file_cmd);
if (err < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_lightsensor_file_cmd.attr.name);
goto err_file_cmd_attr_create;
}
err = device_create_file(bh1721fvc->factory_dev,
&dev_attr_lightsensor_file_illuminance);
if (err < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_lightsensor_file_illuminance.attr.name);
goto err_illuminance_attr_create;
}
err = device_create_file(bh1721fvc->factory_dev,
&dev_attr_sensor_info);
if (err < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_sensor_info.attr.name);
goto err_sensor_info_attr_create;
}
printk(KERN_INFO"%s: success!\n", __func__);
goto done;
err_sensor_info_attr_create:
device_remove_file(bh1721fvc->factory_dev,
&dev_attr_lightsensor_file_illuminance);
err_illuminance_attr_create:
device_remove_file(bh1721fvc->factory_dev,
&dev_attr_lightsensor_file_cmd);
err_file_cmd_attr_create:
device_destroy(bh1721fvc->factory_class, 0);
err_factory_device_create:
class_destroy(bh1721fvc->factory_class);
err_factory_sysfs_create:
sysfs_remove_group(&bh1721fvc->input_dev->dev.kobj,
&bh1721fvc_attribute_group);
err_sysfs_create_group_light:
input_unregister_device(bh1721fvc->input_dev);
err_input_register_device_light:
err_input_allocate_device_light:
destroy_workqueue(bh1721fvc->wq);
err_create_workqueue:
err_test_lightsensor:
mutex_destroy(&bh1721fvc->lock);
err_reset_failed:
err_reset_null:
kfree(bh1721fvc);
done:
return err;
}
static int omap_pwm_led_probe(struct platform_device *pdev)
{
pr_debug("%s%s: \n", PASS1,__func__);
struct omap_pwm_led_platform_data *pdata = pdev->dev.platform_data;
struct omap_pwm_led *led;
int ret;
led = kzalloc(sizeof(struct omap_pwm_led), GFP_KERNEL);
if (led == NULL) {
dev_err(&pdev->dev, "No memory for device\n");
return -ENOMEM;
}
platform_set_drvdata(pdev, led);
led->cdev.brightness_set = omap_pwm_led_set;
led->cdev.max_brightness = LED_FULL;
led->cdev.brightness = pdata->def_brightness;
led->cdev.default_trigger = NULL;
led->cdev.name = pdata->name;
led->pdata = pdata;
INIT_WORK(&led->work, omap_pwm_led_work);
dev_info(&pdev->dev, "OMAP PWM LED (%s) at GP timer %d/%d\n",
pdata->name, pdata->intensity_timer, pdata->blink_timer);
/* register our new led device */
ret = led_classdev_register(&pdev->dev, &led->cdev);
if (ret < 0) {
dev_err(&pdev->dev, "led_classdev_register failed\n");
goto error_classdev;
}
/* get related dm timers */
led->intensity_timer = omap_dm_timer_request_specific(pdata->intensity_timer);
if (led->intensity_timer == NULL) {
dev_err(&pdev->dev, "failed to request intensity pwm timer\n");
ret = -ENODEV;
goto error_intensity;
}
//omap_dm_timer_disable(led->intensity_timer);
if (pdata->blink_timer != 0) {
led->blink_timer = omap_dm_timer_request_specific(pdata->blink_timer);
if (led->blink_timer == NULL) {
dev_err(&pdev->dev, "failed to request blinking pwm timer\n");
ret = -ENODEV;
goto error_blink1;
}
omap_dm_timer_disable(led->blink_timer);
ret = device_create_file(led->cdev.dev,
&dev_attr_on_period);
if(ret)
goto error_blink2;
ret = device_create_file(led->cdev.dev,
&dev_attr_off_period);
if(ret)
goto error_blink3;
}
#if 0
if (led->cdev.brightness) {
omap_pwm_led_set(&led->cdev, led->cdev.brightness);
}
#endif
return 0;
error_blink3:
device_remove_file(led->cdev.dev,
&dev_attr_on_period);
error_blink2:
dev_err(&pdev->dev, "failed to create device file(s)\n");
error_blink1:
omap_dm_timer_free(led->intensity_timer);
error_intensity:
led_classdev_unregister(&led->cdev);
error_classdev:
kfree(led);
return ret;
}
static int pm8058_led_probe(struct platform_device *pdev)
{
struct pm8058_led_platform_data *pdata;
struct pm8058_led_data *ldata;
int i, ret;
ret = -ENOMEM;
pdata = pdev->dev.platform_data;
if (pdata == NULL) {
pr_err("%s: platform data is NULL\n", __func__);
return -ENODEV;
}
if (!pdata->num_leds) {
pr_err("%s: LED num is 0\n", __func__);
return 0;
}
ldata = kzalloc(sizeof(struct pm8058_led_data)
* pdata->num_leds, GFP_KERNEL);
if (ldata == NULL) {
ret = -ENOMEM;
pr_err("%s: failed on allocate ldata\n", __func__);
goto err_exit;
}
dev_set_drvdata(&pdev->dev, ldata);
wake_lock_init(&pmic_led_wake_lock, WAKE_LOCK_SUSPEND, "pmic_led");
g_led_work_queue = create_workqueue("led");
if (!g_led_work_queue)
goto err_create_work_queue;
for (i = 0; i < 64; i++)
duties[i] = pdata->duties[i];
for (i = 0; i < pdata->num_leds; i++) {
ldata[i].led_config = pdata->led_config + i;
ldata[i].ldev.name = pdata->led_config[i].name;
ldata[i].bank = pdata->led_config[i].bank;
ldata[i].flags = pdata->led_config[i].flags;
ldata[i].pwm_size = pdata->led_config[i].pwm_size;
ldata[i].clk = pdata->led_config[i].clk;
ldata[i].pre_div = pdata->led_config[i].pre_div;
ldata[i].pre_div_exp = pdata->led_config[i].pre_div_exp;
ldata[i].pwm_value = pdata->led_config[i].pwm_value;
ldata[i].period_us = pdata->led_config[i].period_us;
ldata[i].start_index = pdata->led_config[i].start_index;
ldata[i].duites_size = pdata->led_config[i].duites_size;
ldata[i].duty_time_ms = pdata->led_config[i].duty_time_ms;
ldata[i].lut_flag = pdata->led_config[i].lut_flag;
ldata[i].out_current = pdata->led_config[i].out_current;
switch (pdata->led_config[i].type) {
case PM8058_LED_CURRENT:
if (ldata[i].flags & PM8058_LED_BLINK_EN)
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
led_blink_do_work);
else
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
pwm_lut_delayed_fade_out);
ldata[i].pwm_led = pwm_request(ldata[i].bank,
ldata[i].ldev.name);
ldata[i].ldev.brightness_set =
pm8058_drvx_led_brightness_set;
break;
case PM8058_LED_RGB:
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
led_blink_do_work);
case PM8058_LED_PWM:
ldata[i].pwm_led = pwm_request(ldata[i].bank,
ldata[i].ldev.name);
ldata[i].ldev.brightness_set =
pm8058_pwm_led_brightness_set;
break;
case PM8058_LED_DRVX:
if (ldata[i].flags & PM8058_LED_BLINK_EN)
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
led_blink_do_work);
else
INIT_DELAYED_WORK(&ldata[i].led_delayed_work,
pwm_lut_delayed_fade_out);
ldata[i].pwm_led = pwm_request(ldata[i].bank,
ldata[i].ldev.name);
ldata[i].ldev.brightness_set =
pm8058_drvx_led_brightness_set;
break;
}
ret = led_classdev_register(&pdev->dev, &ldata[i].ldev);
if (ret < 0) {
pr_err("%s: failed on led_classdev_register [%s]\n",
__func__, ldata[i].ldev.name);
goto err_register_led_cdev;
}
}
for (i = 0; i < pdata->num_leds; i++) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
ret = device_create_file(ldata[i].ldev.dev,
&dev_attr_blink);
if (ret < 0) {
pr_err("%s: Failed to create attr blink"
" [%d]\n", __func__, i);
goto err_register_attr_blink;
}
}
}
for (i = 0; i < pdata->num_leds; i++) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
ret = device_create_file(ldata[i].ldev.dev,
&dev_attr_off_timer);
if (ret < 0) {
pr_err("%s: Failed to create attr off timer"
" [%d]\n", __func__, i);
goto err_register_attr_off_timer;
}
INIT_WORK(&ldata[i].led_work, led_work_func);
alarm_init(&ldata[i].led_alarm,
ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
led_alarm_handler);
}
}
for (i = 0; i < pdata->num_leds; i++) {
if (ldata[i].bank < 3)
continue;
ret = device_create_file(ldata[i].ldev.dev, &dev_attr_currents);
if (ret < 0) {
pr_err("%s: Failed to create attr blink [%d]\n",
__func__, i);
goto err_register_attr_currents;
}
}
#ifdef CONFIG_TOUCHSCREEN_ATMEL_SWEEP2WAKE
if (!strcmp(pdata->led_config[0].name, "button-backlight")) {
sweep2wake_setleddev(&ldata[0].ldev);
printk(KERN_INFO "[sweep2wake]: set led device %s, bank %d\n", pdata->led_config[0].name, ldata[0].bank);
}
#endif
return 0;
err_register_attr_currents:
for (i--; i >= 0; i--) {
if (ldata[i].bank < 3)
continue;
device_remove_file(ldata[i].ldev.dev, &dev_attr_currents);
}
i = pdata->num_leds;
err_register_attr_off_timer:
for (i--; i >= 0; i--) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
device_remove_file(ldata[i].ldev.dev,
&dev_attr_off_timer);
}
}
i = pdata->num_leds;
err_register_attr_blink:
for (i--; i >= 0; i--) {
if (pdata->led_config[i].type == PM8058_LED_RGB ||
ldata[i].flags & PM8058_LED_BLINK_EN) {
device_remove_file(ldata[i].ldev.dev, &dev_attr_blink);
}
}
i = pdata->num_leds;
err_register_led_cdev:
for (i--; i >= 0; i--) {
switch (pdata->led_config[i].type) {
case PM8058_LED_RGB:
case PM8058_LED_PWM:
case PM8058_LED_DRVX:
pwm_free(ldata[i].pwm_led);
break;
}
led_classdev_unregister(&ldata[i].ldev);
}
destroy_workqueue(g_led_work_queue);
err_create_work_queue:
kfree(ldata);
err_exit:
wake_lock_destroy(&pmic_led_wake_lock);
return ret;
}
static int gp2a_opt_probe(struct platform_device *pdev)
{
struct gp2a_data *gp2a;
struct gp2a_platform_data *pdata = pdev->dev.platform_data;
u8 value = 0;
int err = 0;
printk(KERN_INFO"[GP2A] %s : probe start!\n", __func__);
if (!pdata) {
pr_err("%s: missing pdata!\n", __func__);
return err;
}
/*PROXY_EN*/
if (gpio_request(pdata ->power_gpio, "PROXY_EN")) {
printk(KERN_ERR "Request GPIO_%d failed!\n", pdata ->power_gpio);
}
if (pdata->gp2a_led_on)
pdata->gp2a_led_on(1);
#ifndef CONFIG_MACH_HENNESSY_DUOS_CTC
if (pdata->gp2a_get_threshold) {
gp2a_update_threshold(pdata->gp2a_get_threshold(), false);
}
#endif
/* allocate driver_data */
gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
if (!gp2a) {
pr_err("kzalloc error\n");
return -ENOMEM;
}
gp2a->proximity_enabled = 0;
gp2a->pdata = pdata;
gp2a->light_enabled = 0;
gp2a->light_delay = SENSOR_DEFAULT_DELAY;
gp2a->testmode = 0;
gp2a->light_level_state = 0;
if (pdata->power_on) {
pdata->power_on(1);
msleep(5);
}
INIT_DELAYED_WORK(&gp2a->light_work, gp2a_work_func_light);
INIT_WORK(&gp2a->proximity_work, gp2a_work_func_prox);
/*misc device registration*/
err = misc_register(&gp2a_opt_misc_device);
if( err < 0 )
goto error_setup_reg_misc;
err = proximity_input_init(gp2a);
if (err < 0)
goto error_setup_reg_prox;
err = light_input_init(gp2a);
if (err < 0)
goto error_setup_reg_light;
err = sysfs_create_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
if (err < 0)
goto err_sysfs_create_group_proximity;
err = sysfs_create_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
if (err)
goto err_sysfs_create_group_light;
mutex_init(&gp2a->light_mutex);
mutex_init(&gp2a->data_mutex);
/* set platdata */
platform_set_drvdata(pdev, gp2a);
/* wake lock init */
wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND,
"prx_wake_lock");
/* init i2c */
err = opt_i2c_init();
if(err < 0)
{
pr_err("opt_probe failed : i2c_client is NULL\n");
goto err_no_device;
}
else
printk(KERN_INFO "[GP2A] opt_i2c_client : (0x%p)\n",opt_i2c_client);
/* GP2A Regs INIT SETTINGS and Check I2C communication */
value = 0x00;
err = opt_i2c_write((u8) (COMMAND1), &value); /* shutdown mode op[3]=0 */
if (err < 0) {
pr_err("%s failed : threre is no such device.\n", __func__);
goto err_no_device;
}
/* Setup irq */
err = gp2a_setup_irq(gp2a);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto err_setup_irq;
}
/* set sysfs for proximity sensor */
gp2a->proximity_dev = device_create(sensors_class,
NULL, 0, NULL, "proximity_sensor");
if (IS_ERR(gp2a->proximity_dev)) {
pr_err("%s: could not create proximity_dev\n", __func__);
goto err_proximity_device_create;
}
gp2a->light_dev = device_create(sensors_class,
NULL, 0, NULL, "light_sensor");
if (IS_ERR(gp2a->light_dev)) {
pr_err("%s: could not create light_dev\n", __func__);
goto err_light_device_create;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_state) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_state.attr.name);
goto err_proximity_device_create_file1;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_avg) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_avg.attr.name);
goto err_proximity_device_create_file2;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_proximity_enable) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_proximity_enable.attr.name);
goto err_proximity_device_create_file3;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_vendor) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_vendor.attr.name);
goto err_proximity_device_create_file4;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_name) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_name.attr.name);
goto err_proximity_device_create_file5;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_cal) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_cal.attr.name);
goto err_proximity_device_create_file6;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_offset_pass) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_offset_pass.attr.name);
goto err_proximity_device_create_file7;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_thresh) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_thresh.attr.name);
goto err_proximity_device_create_file8;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_lux) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_lux.attr.name);
goto err_light_device_create_file1;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_light_enable) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_light_enable.attr.name);
goto err_light_device_create_file2;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_vendor) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_vendor.attr.name);
goto err_light_device_create_file3;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_name) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_name.attr.name);
goto err_light_device_create_file4;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_raw_data) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_raw_data.attr.name);
goto err_light_device_create_file5;
}
dev_set_drvdata(gp2a->proximity_dev, gp2a);
dev_set_drvdata(gp2a->light_dev, gp2a);
device_init_wakeup(&pdev->dev, 1);
if (pdata->gp2a_led_on) {
pdata->gp2a_led_on(0);
printk(KERN_INFO "[GP2A] gpio_get_value of GPIO(%d) is %d\n",pdata ->power_gpio,
gpio_get_value(pdata ->power_gpio));
}
/* set initial proximity value as 1 */
input_report_abs(gp2a->proximity_input_dev, ABS_DISTANCE, 1);
input_sync(gp2a->proximity_input_dev);
gp2a_opt_data = gp2a;
printk(KERN_INFO"[GP2A] %s : probe success!\n", __func__);
return 0;
err_light_device_create_file5:
device_remove_file(gp2a->light_dev, &dev_attr_name);
err_light_device_create_file4:
device_remove_file(gp2a->light_dev, &dev_attr_vendor);
err_light_device_create_file3:
device_remove_file(gp2a->light_dev, &dev_attr_light_enable);
err_light_device_create_file2:
device_remove_file(gp2a->light_dev, &dev_attr_lux);
err_light_device_create_file1:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_thresh);
err_proximity_device_create_file8:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_offset_pass);
err_proximity_device_create_file7:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_cal);
err_proximity_device_create_file6:
device_remove_file(gp2a->proximity_dev, &dev_attr_name);
err_proximity_device_create_file5:
device_remove_file(gp2a->proximity_dev, &dev_attr_vendor);
err_proximity_device_create_file4:
device_remove_file(gp2a->proximity_dev, &dev_attr_proximity_enable);
err_proximity_device_create_file3:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_avg);
err_proximity_device_create_file2:
device_remove_file(gp2a->proximity_dev, &dev_attr_state);
err_proximity_device_create_file1:
err_light_device_create:
device_destroy(sensors_class, 0);
err_proximity_device_create:
gpio_free(pdata->p_out);
err_setup_irq:
err_no_device:
wake_lock_destroy(&gp2a->prx_wake_lock);
mutex_destroy(&gp2a->light_mutex);
mutex_destroy(&gp2a->data_mutex);
sysfs_remove_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
err_sysfs_create_group_light:
sysfs_remove_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
err_sysfs_create_group_proximity:
input_unregister_device(gp2a->light_input_dev);
error_setup_reg_light:
input_unregister_device(gp2a->proximity_input_dev);
error_setup_reg_prox:
misc_deregister(&gp2a_opt_misc_device);
error_setup_reg_misc:
if (pdata->power_on)
pdata->power_on(0);
kfree(gp2a);
return err;
}
static int pru_bridge_remove(struct platform_device *pdev)
{
struct pru_bridge_dev *pp = platform_get_drvdata(pdev);
struct device *dev = pp->miscdev.this_device;
/*Deallocating memory*/
printk("deallocating memory\n");
iounmap(ring);
iounmap(control_channel);
printk("removing sysfs files\n");
device_remove_file(dev, &dev_attr_init);
device_remove_file(dev, &dev_attr_ch1_write);
device_remove_file(dev, &dev_attr_ch1_read);
device_remove_file(dev, &dev_attr_ch2_write);
device_remove_file(dev, &dev_attr_ch2_read);
device_remove_file(dev, &dev_attr_ch3_write);
device_remove_file(dev, &dev_attr_ch3_read);
device_remove_file(dev, &dev_attr_ch4_write);
device_remove_file(dev, &dev_attr_ch4_read);
device_remove_file(dev, &dev_attr_ch5_write);
device_remove_file(dev, &dev_attr_ch5_read);
device_remove_file(dev, &dev_attr_ch6_write);
device_remove_file(dev, &dev_attr_ch6_read);
device_remove_file(dev, &dev_attr_ch7_write);
device_remove_file(dev, &dev_attr_ch7_read);
device_remove_file(dev, &dev_attr_ch8_write);
device_remove_file(dev, &dev_attr_ch8_read);
device_remove_file(dev, &dev_attr_ch9_write);
device_remove_file(dev, &dev_attr_ch9_read);
device_remove_file(dev, &dev_attr_ch10_write);
device_remove_file(dev, &dev_attr_ch10_read);
device_remove_file(dev, &dev_attr_downcall);
platform_set_drvdata(pdev, NULL);
printk("PRU bridge Driver unloaded\n");
return 0;
}
/**
* Unbind function
*/
static void razer_kbd_disconnect(struct hid_device *hdev)
{
struct razer_kbd_device *dev;
struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
struct usb_device *usb_dev = interface_to_usbdev(intf);
dev = hid_get_drvdata(hdev);
if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_ULTIMATE_2013)
{
device_remove_file(&hdev->dev, &dev_attr_mode_pulsate);
} else if(usb_dev->descriptor.idProduct == USB_DEVICE_ID_RAZER_BLACKWIDOW_ULTIMATE_2016)
{
device_remove_file(&hdev->dev, &dev_attr_mode_wave);
device_remove_file(&hdev->dev, &dev_attr_mode_starlight);
device_remove_file(&hdev->dev, &dev_attr_mode_none);
device_remove_file(&hdev->dev, &dev_attr_mode_reactive);
device_remove_file(&hdev->dev, &dev_attr_mode_breath);
device_remove_file(&hdev->dev, &dev_attr_mode_custom);
device_remove_file(&hdev->dev, &dev_attr_temp_clear_row);
device_remove_file(&hdev->dev, &dev_attr_set_key_row);
} else // Chroma
{
device_remove_file(&hdev->dev, &dev_attr_mode_wave);
device_remove_file(&hdev->dev, &dev_attr_mode_spectrum);
device_remove_file(&hdev->dev, &dev_attr_mode_none);
device_remove_file(&hdev->dev, &dev_attr_mode_reactive);
device_remove_file(&hdev->dev, &dev_attr_mode_breath);
device_remove_file(&hdev->dev, &dev_attr_mode_custom);
device_remove_file(&hdev->dev, &dev_attr_temp_clear_row);
device_remove_file(&hdev->dev, &dev_attr_set_key_row);
}
device_remove_file(&hdev->dev, &dev_attr_mode_game);
device_remove_file(&hdev->dev, &dev_attr_get_serial);
device_remove_file(&hdev->dev, &dev_attr_mode_static);
device_remove_file(&hdev->dev, &dev_attr_reset);
device_remove_file(&hdev->dev, &dev_attr_macro_keys);
device_remove_file(&hdev->dev, &dev_attr_set_brightness);
device_remove_file(&hdev->dev, &dev_attr_test);
device_remove_file(&hdev->dev, &dev_attr_device_type);
hid_hw_stop(hdev);
kfree(dev);
dev_info(&intf->dev, "Razer Device disconnected\n");
}
static void rs5c_sysfs_unregister(struct device *dev)
{
device_remove_file(dev, &dev_attr_trim);
device_remove_file(dev, &dev_attr_osc);
}
int akm8975_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct akm8975_data *akm;
int err;
if (client->dev.platform_data == NULL) {
dev_err(&client->dev, "platform data is NULL. exiting.\n");
err = -ENODEV;
goto exit_platform_data_null;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "I2C check failed, exiting.\n");
err = -ENODEV;
goto exit_check_functionality_failed;
}
akm = kzalloc(sizeof(struct akm8975_data), GFP_KERNEL);
if (!akm) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
err = -ENOMEM;
goto exit_alloc_data_failed;
}
akm->pdata = client->dev.platform_data;
mutex_init(&akm->lock);
init_completion(&akm->data_ready);
i2c_set_clientdata(client, akm);
akm->this_client = client;
err = akm8975_ecs_set_mode_power_down(akm);
if (err < 0)
goto exit_set_mode_power_down_failed;
akm->irq = client->irq;
err = akm8975_setup_irq(akm);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto exit_setup_irq;
}
akm->akmd_device.minor = MISC_DYNAMIC_MINOR;
akm->akmd_device.name = "akm8975";
akm->akmd_device.fops = &akmd_fops;
err = misc_register(&akm->akmd_device);
if (err)
goto exit_akmd_device_register_failed;
init_waitqueue_head(&akm->state_wq);
/* put into fuse access mode to read asa data */
err = i2c_smbus_write_byte_data(client, AK8975_REG_CNTL,
REG_CNTL_MODE_FUSE_ROM);
if (err)
pr_err("%s: unable to enter fuse rom mode\n", __func__);
err = i2c_smbus_read_i2c_block_data(client, AK8975_REG_ASAX,
sizeof(akm->asa), akm->asa);
if (err != sizeof(akm->asa))
pr_err("%s: unable to load factory sensitivity adjust values\n",
__func__);
else
pr_debug("%s: asa_x = %d, asa_y = %d, asa_z = %d\n", __func__,
akm->asa[0], akm->asa[1], akm->asa[2]);
err = i2c_smbus_write_byte_data(client, AK8975_REG_CNTL,
REG_CNTL_MODE_POWER_DOWN);
if (err) {
dev_err(&client->dev, "Error in setting power down mode\n");
goto exit_device_create_file2;
}
#if (defined DEBUG) || (defined FACTORY_TEST)
ak8975c_selftest(akm);
#endif
#ifdef FACTORY_TEST
err = sensors_register(magnetic_sensor_device, akm, magnetic_sensor_attrs, "magnetic_sensor");
if(err) {
printk(KERN_ERR "%s: cound not register magnetic sensor device(%d).\n", __func__, err);
}
sec_ak8975_dev = device_create(sec_class, NULL, 0, akm,
"sec_ak8975");
if (IS_ERR(sec_ak8975_dev))
printk("Failed to create device!");
if (device_create_file(sec_ak8975_dev, &dev_attr_ak8975_asa) < 0) {
printk("Failed to create device file(%s)! \n",
dev_attr_ak8975_asa.attr.name);
goto exit_device_create_file2;
}
if (device_create_file(sec_ak8975_dev, &dev_attr_ak8975_selftest) < 0) {
printk("Failed to create device file(%s)! \n",
dev_attr_ak8975_selftest.attr.name);
device_remove_file(sec_ak8975_dev, &dev_attr_ak8975_asa);
goto exit_device_create_file2;
}
if (device_create_file(sec_ak8975_dev, &dev_attr_ak8975_chk_registers) < 0) {
printk("Failed to create device file(%s)! \n",
dev_attr_ak8975_chk_registers.attr.name);
device_remove_file(sec_ak8975_dev, &dev_attr_ak8975_asa);
device_remove_file(sec_ak8975_dev, &dev_attr_ak8975_selftest);
goto exit_device_create_file2;
}
if (device_create_file(sec_ak8975_dev, &dev_attr_ak8975_chk_cntl) < 0) {
printk("Failed to create device file(%s)! \n",
dev_attr_ak8975_chk_cntl.attr.name);
device_remove_file(sec_ak8975_dev, &dev_attr_ak8975_asa);
device_remove_file(sec_ak8975_dev, &dev_attr_ak8975_selftest);
device_remove_file(sec_ak8975_dev, &dev_attr_ak8975_chk_registers);
goto exit_device_create_file2;
}
#endif
return 0;
exit_device_create_file2:
exit_akmd_device_register_failed:
free_irq(akm->irq, akm);
gpio_free(akm->pdata->gpio_data_ready_int);
exit_setup_irq:
exit_set_mode_power_down_failed:
mutex_destroy(&akm->lock);
kfree(akm);
exit_alloc_data_failed:
exit_check_functionality_failed:
exit_platform_data_null:
return err;
}
int thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
{
struct thermal_hwmon_device *hwmon;
struct thermal_hwmon_temp *temp;
int new_hwmon_device = 1;
int result;
hwmon = thermal_hwmon_lookup_by_type(tz);
if (hwmon) {
new_hwmon_device = 0;
goto register_sys_interface;
}
hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL);
if (!hwmon)
return -ENOMEM;
INIT_LIST_HEAD(&hwmon->tz_list);
strlcpy(hwmon->type, tz->type, THERMAL_NAME_LENGTH);
hwmon->device = hwmon_device_register(&tz->device);
if (IS_ERR(hwmon->device)) {
result = PTR_ERR(hwmon->device);
goto free_mem;
}
dev_set_drvdata(hwmon->device, hwmon);
result = device_create_file(hwmon->device, &dev_attr_name);
if (result)
goto free_mem;
register_sys_interface:
temp = kzalloc(sizeof(*temp), GFP_KERNEL);
if (!temp) {
result = -ENOMEM;
goto unregister_name;
}
temp->tz = tz;
hwmon->count++;
snprintf(temp->temp_input.name, sizeof(temp->temp_input.name),
"temp%d_input", hwmon->count);
temp->temp_input.attr.attr.name = temp->temp_input.name;
temp->temp_input.attr.attr.mode = 0444;
temp->temp_input.attr.show = temp_input_show;
sysfs_attr_init(&temp->temp_input.attr.attr);
result = device_create_file(hwmon->device, &temp->temp_input.attr);
if (result)
goto free_temp_mem;
if (tz->ops->get_crit_temp) {
unsigned long temperature;
if (!tz->ops->get_crit_temp(tz, &temperature)) {
snprintf(temp->temp_crit.name,
sizeof(temp->temp_crit.name),
"temp%d_crit", hwmon->count);
temp->temp_crit.attr.attr.name = temp->temp_crit.name;
temp->temp_crit.attr.attr.mode = 0444;
temp->temp_crit.attr.show = temp_crit_show;
sysfs_attr_init(&temp->temp_crit.attr.attr);
result = device_create_file(hwmon->device,
&temp->temp_crit.attr);
if (result)
goto unregister_input;
}
}
mutex_lock(&thermal_hwmon_list_lock);
if (new_hwmon_device)
list_add_tail(&hwmon->node, &thermal_hwmon_list);
list_add_tail(&temp->hwmon_node, &hwmon->tz_list);
mutex_unlock(&thermal_hwmon_list_lock);
return 0;
unregister_input:
device_remove_file(hwmon->device, &temp->temp_input.attr);
free_temp_mem:
kfree(temp);
unregister_name:
if (new_hwmon_device) {
device_remove_file(hwmon->device, &dev_attr_name);
hwmon_device_unregister(hwmon->device);
}
free_mem:
if (new_hwmon_device)
kfree(hwmon);
return result;
}
static int gp2a_opt_probe(struct platform_device *pdev)
{
struct gp2a_data *gp2a;
struct gp2a_platform_data *pdata = pdev->dev.platform_data;
u8 value = 0;
int err = 0;
gprintk("probe start!\n");
if (!pdata) {
pr_err("%s: missing pdata!\n", __func__);
return err;
}
if (!pdata->gp2a_led_on) {
pr_err("%s: incomplete pdata!\n", __func__);
return err;
}
/* gp2a power on */
pdata->gp2a_led_on(true);
if (pdata->gp2a_get_threshold) {
gp2a_update_threshold(is_gp2a030a() ?
gp2a_original_image_030a : gp2a_original_image,
pdata->gp2a_get_threshold(), false);
}
/* allocate driver_data */
gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
if (!gp2a) {
pr_err("kzalloc error\n");
return -ENOMEM;
}
proximity_enable = 0;
proximity_sensor_detection = 0;
proximity_avg_on = 0;
gp2a->enabled = 0;
gp2a->pdata = pdata;
/* prox_timer settings. we poll for prox_avg values using a timer. */
hrtimer_init(&gp2a->prox_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
gp2a->prox_poll_delay = ns_to_ktime(2000 * NSEC_PER_MSEC);
gp2a->prox_timer.function = gp2a_prox_timer_func;
gp2a->prox_wq = create_singlethread_workqueue("gp2a_prox_wq");
if (!gp2a->prox_wq) {
err = -ENOMEM;
pr_err("%s: could not create prox workqueue\n", __func__);
goto err_create_prox_workqueue;
}
INIT_WORK(&gp2a->work_prox, gp2a_work_func_prox_avg);
INIT_WORK(&gp2a->work, gp2a_work_func_prox);
err = proximity_input_init(gp2a);
if (err < 0)
goto error_setup_reg;
err = sysfs_create_group(&gp2a->input_dev->dev.kobj,
&proximity_attribute_group);
if (err < 0)
goto err_sysfs_create_group_proximity;
/* set platdata */
platform_set_drvdata(pdev, gp2a);
/* wake lock init */
wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND,
"prx_wake_lock");
/* init i2c */
opt_i2c_init();
if (opt_i2c_client == NULL) {
pr_err("opt_probe failed : i2c_client is NULL\n");
goto err_no_device;
} else
printk(KERN_INFO "opt_i2c_client : (0x%p), address = %x\n",
opt_i2c_client, opt_i2c_client->addr);
/* GP2A Regs INIT SETTINGS and Check I2C communication */
value = 0x00;
/* shutdown mode op[3]=0 */
err = opt_i2c_write((u8) (COMMAND1), &value);
if (err < 0) {
pr_err("%s failed : threre is no such device.\n", __func__);
goto err_no_device;
}
/* Setup irq */
err = gp2a_setup_irq(gp2a);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto err_setup_irq;
}
/* set sysfs for proximity sensor */
gp2a->proximity_dev = sensors_classdev_register("proximity_sensor");
if (IS_ERR(gp2a->proximity_dev)) {
pr_err("%s: could not create proximity_dev\n", __func__);
goto err_proximity_device_create;
}
if (device_create_file(gp2a->proximity_dev, &dev_attr_state) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_state.attr.name);
goto err_proximity_device_create_file1;
}
if (device_create_file(gp2a->proximity_dev, &dev_attr_prox_avg) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_avg.attr.name);
goto err_proximity_device_create_file2;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_thresh) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_thresh.attr.name);
goto err_proximity_device_create_file3;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_vendor) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_vendor.attr.name);
goto err_proximity_device_create_file4;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_name) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_name.attr.name);
goto err_proximity_device_create_file5;
}
if (device_create_file(gp2a->proximity_dev, &dev_attr_raw_data) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_raw_data.attr.name);
goto err_proximity_device_create_file6;
}
#ifdef CONFIG_SLP
device_init_wakeup(gp2a->proximity_dev, true);
#endif
dev_set_drvdata(gp2a->proximity_dev, gp2a);
device_init_wakeup(&pdev->dev, 1);
gprintk("probe success!\n");
return 0;
err_proximity_device_create_file6:
device_remove_file(gp2a->proximity_dev, &dev_attr_raw_data);
err_proximity_device_create_file5:
device_remove_file(gp2a->proximity_dev, &dev_attr_name);
err_proximity_device_create_file4:
device_remove_file(gp2a->proximity_dev, &dev_attr_vendor);
err_proximity_device_create_file3:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_avg);
err_proximity_device_create_file2:
device_remove_file(gp2a->proximity_dev, &dev_attr_state);
err_proximity_device_create_file1:
sensors_classdev_unregister(gp2a->proximity_dev);
err_proximity_device_create:
gpio_free(pdata->p_out);
err_setup_irq:
err_no_device:
sysfs_remove_group(&gp2a->input_dev->dev.kobj,
&proximity_attribute_group);
wake_lock_destroy(&gp2a->prx_wake_lock);
err_sysfs_create_group_proximity:
input_unregister_device(gp2a->input_dev);
error_setup_reg:
destroy_workqueue(gp2a->prox_wq);
err_create_prox_workqueue:
kfree(gp2a);
return err;
}
static int SM5701_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct device_node *of_node = i2c->dev.of_node;
struct SM5701_platform_data *pdata = i2c->dev.platform_data;
struct SM5701_dev *SM5701;
int ret = 0;
pr_info("%s: SM5701 MFD Probe Start !!!!!\n", __func__);
if (of_node) {
pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata) {
dev_err(&i2c->dev, "Failed to allocate memory\n");
ret = -ENOMEM;
goto err_dt_nomem;
}
ret = SM5701_parse_dt(pdata);
if (ret < 0)
goto err_parse_dt;
i2c->dev.platform_data = pdata;
} else
pdata = i2c->dev.platform_data;
SM5701 = kzalloc(sizeof(struct SM5701_dev), GFP_KERNEL);
if (!SM5701) {
dev_err(&i2c->dev, "Failed to allocate memory for SM5701 \n");
return -ENOMEM;
}
i2c_set_clientdata(i2c, SM5701);
SM5701->dev = &i2c->dev;
SM5701->i2c = i2c;
SM5701->irq = i2c->irq;
SM5701_core_client = i2c;
if (!pdata)
goto err;
mutex_init(&SM5701->i2c_lock);
// ret = SM5701_irq_init(SM5701);
// if (ret < 0)
// goto err_irq_init;
ret = mfd_add_devices(SM5701->dev, -1,
SM5701_devs, ARRAY_SIZE(SM5701_devs),
NULL, 0, NULL);
if (ret < 0)
goto err;
ret = device_create_file(SM5701->dev, &dev_attr_SM5701_core);
if (ret < 0) {
dev_err(SM5701->dev, "failed to create flash file\n");
goto err_create_core_file;
}
dev_info(SM5701->dev ,"SM5701 MFD probe done!!! \n");
return ret;
err_parse_dt:
pr_info("%s: parse_dt error \n", __func__);
err_dt_nomem:
pr_info("%s: dt_nomem error \n", __func__);
err:
pr_info("%s: err error \n", __func__);
mfd_remove_devices(SM5701->dev);
//err_irq_init:
// SM5701_irq_exit(SM5701);
kfree(SM5701);
err_create_core_file:
device_remove_file(SM5701->dev, &dev_attr_SM5701_core);
return ret;
}
static int pcf2123_probe(struct spi_device *spi)
{
struct rtc_device *rtc;
struct pcf2123_plat_data *pdata;
u8 txbuf[2], rxbuf[2];
int ret, i;
pdata = devm_kzalloc(&spi->dev, sizeof(struct pcf2123_plat_data),
GFP_KERNEL);
if (!pdata)
return -ENOMEM;
spi->dev.platform_data = pdata;
/* Send a software reset command */
txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
txbuf[1] = 0x58;
dev_dbg(&spi->dev, "resetting RTC (0x%02X 0x%02X)\n",
txbuf[0], txbuf[1]);
ret = spi_write(spi, txbuf, 2 * sizeof(u8));
if (ret < 0)
goto kfree_exit;
pcf2123_delay_trec();
/* Stop the counter */
txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
txbuf[1] = 0x20;
dev_dbg(&spi->dev, "stopping RTC (0x%02X 0x%02X)\n",
txbuf[0], txbuf[1]);
ret = spi_write(spi, txbuf, 2 * sizeof(u8));
if (ret < 0)
goto kfree_exit;
pcf2123_delay_trec();
/* See if the counter was actually stopped */
txbuf[0] = PCF2123_READ | PCF2123_REG_CTRL1;
dev_dbg(&spi->dev, "checking for presence of RTC (0x%02X)\n",
txbuf[0]);
ret = spi_write_then_read(spi, txbuf, 1 * sizeof(u8),
rxbuf, 2 * sizeof(u8));
dev_dbg(&spi->dev, "received data from RTC (0x%02X 0x%02X)\n",
rxbuf[0], rxbuf[1]);
if (ret < 0)
goto kfree_exit;
pcf2123_delay_trec();
if (!(rxbuf[0] & 0x20)) {
dev_err(&spi->dev, "chip not found\n");
ret = -ENODEV;
goto kfree_exit;
}
dev_info(&spi->dev, "chip found, driver version " DRV_VERSION "\n");
dev_info(&spi->dev, "spiclk %u KHz.\n",
(spi->max_speed_hz + 500) / 1000);
/* Start the counter */
txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1;
txbuf[1] = 0x00;
ret = spi_write(spi, txbuf, sizeof(txbuf));
if (ret < 0)
goto kfree_exit;
pcf2123_delay_trec();
/* Finalize the initialization */
rtc = devm_rtc_device_register(&spi->dev, pcf2123_driver.driver.name,
&pcf2123_rtc_ops, THIS_MODULE);
if (IS_ERR(rtc)) {
dev_err(&spi->dev, "failed to register.\n");
ret = PTR_ERR(rtc);
goto kfree_exit;
}
pdata->rtc = rtc;
for (i = 0; i < 16; i++) {
sysfs_attr_init(&pdata->regs[i].attr.attr);
sprintf(pdata->regs[i].name, "%1x", i);
pdata->regs[i].attr.attr.mode = S_IRUGO | S_IWUSR;
pdata->regs[i].attr.attr.name = pdata->regs[i].name;
pdata->regs[i].attr.show = pcf2123_show;
pdata->regs[i].attr.store = pcf2123_store;
ret = device_create_file(&spi->dev, &pdata->regs[i].attr);
if (ret) {
dev_err(&spi->dev, "Unable to create sysfs %s\n",
pdata->regs[i].name);
goto sysfs_exit;
}
}
return 0;
sysfs_exit:
for (i--; i >= 0; i--)
device_remove_file(&spi->dev, &pdata->regs[i].attr);
kfree_exit:
spi->dev.platform_data = NULL;
return ret;
}
void rtc_sysfs_del_device(struct rtc_device *rtc)
{
/* REVISIT did we add it successfully? */
if (rtc_does_wakealarm(rtc))
device_remove_file(&rtc->dev, &dev_attr_wakealarm);
}
static int register_attributes(void)
{
int ret = 0;
hi->htc_accessory_class = class_create(THIS_MODULE, "htc_accessory");
if (IS_ERR(hi->htc_accessory_class)) {
ret = PTR_ERR(hi->htc_accessory_class);
hi->htc_accessory_class = NULL;
goto err_create_class;
}
/* Register headset attributes */
hi->headset_dev = device_create(hi->htc_accessory_class,
NULL, 0, "%s", "headset");
if (unlikely(IS_ERR(hi->headset_dev))) {
ret = PTR_ERR(hi->headset_dev);
hi->headset_dev = NULL;
goto err_create_headset_device;
}
ret = device_create_file(hi->headset_dev, &dev_attr_headset_state);
if (ret)
goto err_create_headset_state_device_file;
ret = device_create_file(hi->headset_dev, &dev_attr_headset_1wire);
if (ret)
goto err_create_headset_state_device_file;
/* Register TTY attributes */
hi->tty_dev = device_create(hi->htc_accessory_class,
NULL, 0, "%s", "tty");
if (unlikely(IS_ERR(hi->tty_dev))) {
ret = PTR_ERR(hi->tty_dev);
hi->tty_dev = NULL;
goto err_create_tty_device;
}
ret = device_create_file(hi->tty_dev, &dev_attr_tty);
if (ret)
goto err_create_tty_device_file;
/* Register FM attributes */
hi->fm_dev = device_create(hi->htc_accessory_class,
NULL, 0, "%s", "fm");
if (unlikely(IS_ERR(hi->fm_dev))) {
ret = PTR_ERR(hi->fm_dev);
hi->fm_dev = NULL;
goto err_create_fm_device;
}
ret = device_create_file(hi->fm_dev, &dev_attr_fm);
if (ret)
goto err_create_fm_device_file;
/* Register debug attributes */
hi->debug_dev = device_create(hi->htc_accessory_class,
NULL, 0, "%s", "debug");
if (unlikely(IS_ERR(hi->debug_dev))) {
ret = PTR_ERR(hi->debug_dev);
hi->debug_dev = NULL;
goto err_create_debug_device;
}
/* register the attributes */
ret = device_create_file(hi->debug_dev, &dev_attr_debug);
if (ret)
goto err_create_debug_device_file;
return 0;
err_create_debug_device_file:
device_unregister(hi->debug_dev);
err_create_debug_device:
device_remove_file(hi->fm_dev, &dev_attr_fm);
err_create_fm_device_file:
device_unregister(hi->fm_dev);
err_create_fm_device:
device_remove_file(hi->tty_dev, &dev_attr_tty);
err_create_tty_device_file:
device_unregister(hi->tty_dev);
err_create_tty_device:
device_remove_file(hi->headset_dev, &dev_attr_headset_state);
err_create_headset_state_device_file:
device_unregister(hi->headset_dev);
err_create_headset_device:
class_destroy(hi->htc_accessory_class);
err_create_class:
return ret;
}
static int acm_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_cdc_union_desc *union_header = NULL;
struct usb_cdc_country_functional_desc *cfd = NULL;
unsigned char *buffer = intf->altsetting->extra;
int buflen = intf->altsetting->extralen;
struct usb_interface *control_interface;
struct usb_interface *data_interface;
struct usb_endpoint_descriptor *epctrl = NULL;
struct usb_endpoint_descriptor *epread = NULL;
struct usb_endpoint_descriptor *epwrite = NULL;
struct usb_device *usb_dev = interface_to_usbdev(intf);
struct acm *acm;
int minor;
int ctrlsize, readsize;
u8 *buf;
u8 ac_management_function = 0;
u8 call_management_function = 0;
int call_interface_num = -1;
int data_interface_num = -1;
unsigned long quirks;
int num_rx_buf;
int i;
int combined_interfaces = 0;
/* normal quirks */
quirks = (unsigned long)id->driver_info;
num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
/* not a real CDC ACM device */
if (quirks & NOT_REAL_ACM)
return -ENODEV;
if (max_intfs == 1) {
/* XMM HACK - use ACM for interfaces 0/1 only */
switch (intf->cur_altsetting->desc.bInterfaceNumber)
{
case 0: case 1:
I("XMM HACK -"
" interface #%d create for ttyACM device\n",
intf->cur_altsetting->desc.bInterfaceNumber);
break;
default:
D("XMM HACK -"
" interface #%d reserved for RAW-IP network driver\n",
intf->cur_altsetting->desc.bInterfaceNumber);
return -EINVAL;
}
} else if (max_intfs == 2) {
/* XMM HACK - use ACM for interfaces 0/1 & 6/7 only */
switch (intf->cur_altsetting->desc.bInterfaceNumber)
{
case 0: case 1:
case 6: case 7:
I("XMM HACK -"
" interface #%d create for ttyACM device\n",
intf->cur_altsetting->desc.bInterfaceNumber);
break;
default:
D("XMM HACK -"
" interface #%d reserved for RAW-IP network driver\n",
intf->cur_altsetting->desc.bInterfaceNumber);
return -EINVAL;
}
}
/* handle quirks deadly to normal probing*/
if (quirks & NO_UNION_NORMAL) {
data_interface = usb_ifnum_to_if(usb_dev, 1);
control_interface = usb_ifnum_to_if(usb_dev, 0);
if (!control_interface || !data_interface) {
E("no ctrl or data interfaces\n");
return -ENODEV;
}
goto skip_normal_probe;
}
/* normal probing*/
if (!buffer) {
E("Weird descriptor references\n");
return -EINVAL;
}
if (!buflen) {
if (intf->cur_altsetting->endpoint &&
intf->cur_altsetting->endpoint->extralen &&
intf->cur_altsetting->endpoint->extra) {
D("Seeking extra descriptors on endpoint\n");
buflen = intf->cur_altsetting->endpoint->extralen;
buffer = intf->cur_altsetting->endpoint->extra;
} else {
E("Zero length descriptor references\n");
return -EINVAL;
}
}
while (buflen > 0) {
if (buffer[1] != USB_DT_CS_INTERFACE) {
E("skipping garbage\n");
goto next_desc;
}
switch (buffer[2]) {
case USB_CDC_UNION_TYPE: /* we've found it */
if (union_header) {
E("More than one "
"union descriptor, skipping ...\n");
goto next_desc;
}
union_header = (struct usb_cdc_union_desc *)buffer;
break;
case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
cfd = (struct usb_cdc_country_functional_desc *)buffer;
break;
case USB_CDC_HEADER_TYPE: /* maybe check version */
break; /* for now we ignore it */
case USB_CDC_ACM_TYPE:
ac_management_function = buffer[3];
break;
case USB_CDC_CALL_MANAGEMENT_TYPE:
call_management_function = buffer[3];
call_interface_num = buffer[4];
if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
D("This device cannot do calls on its own. It is not a modem.\n");
break;
default:
/* there are LOTS more CDC descriptors that
* could legitimately be found here.
*/
D("Ignoring descriptor: "
"type %02x, length %d\n",
buffer[2], buffer[0]);
break;
}
next_desc:
buflen -= buffer[0];
buffer += buffer[0];
}
if (!union_header) {
if (call_interface_num > 0) {
D("No union descriptor, using call management descriptor\n");
/* quirks for Droids MuIn LCD */
if (quirks & NO_DATA_INTERFACE)
data_interface = usb_ifnum_to_if(usb_dev, 0);
else
data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
control_interface = intf;
if (!data_interface) {
D("no data interfaces\n");
return -ENODEV;
}
} else {
if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
D("No union descriptor, giving up\n");
return -ENODEV;
} else {
D("No union descriptor, testing for castrated device\n");
combined_interfaces = 1;
control_interface = data_interface = intf;
goto look_for_collapsed_interface;
}
}
} else {
control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
if (!control_interface || !data_interface) {
D("no interfaces\n");
return -ENODEV;
}
}
if (data_interface_num != call_interface_num)
D("Separate call control interface. That is not fully supported.\n");
if (control_interface == data_interface) {
/* some broken devices designed for windows work this way */
D("Control and data interfaces are not separated!\n");
combined_interfaces = 1;
/* a popular other OS doesn't use it */
quirks |= NO_CAP_LINE;
if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
E("This needs exactly 3 endpoints\n");
return -EINVAL;
}
look_for_collapsed_interface:
for (i = 0; i < 3; i++) {
struct usb_endpoint_descriptor *ep;
ep = &data_interface->cur_altsetting->endpoint[i].desc;
if (usb_endpoint_is_int_in(ep))
epctrl = ep;
else if (usb_endpoint_is_bulk_out(ep))
epwrite = ep;
else if (usb_endpoint_is_bulk_in(ep))
epread = ep;
else
return -EINVAL;
}
if (!epctrl || !epread || !epwrite)
return -ENODEV;
else
goto made_compressed_probe;
}
skip_normal_probe:
/*workaround for switched interfaces */
if (data_interface->cur_altsetting->desc.bInterfaceClass
!= CDC_DATA_INTERFACE_TYPE) {
if (control_interface->cur_altsetting->desc.bInterfaceClass
== CDC_DATA_INTERFACE_TYPE) {
struct usb_interface *t;
D("Your device has switched interfaces.\n");
t = control_interface;
control_interface = data_interface;
data_interface = t;
} else {
return -EINVAL;
}
}
/* Accept probe requests only for the control interface */
if (!combined_interfaces && intf != control_interface)
return -ENODEV;
if (!combined_interfaces && usb_interface_claimed(data_interface)) {
/* valid in this context */
D("The data interface isn't available\n");
return -EBUSY;
}
if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
return -EINVAL;
epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
epread = &data_interface->cur_altsetting->endpoint[0].desc;
epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
/* workaround for switched endpoints */
if (!usb_endpoint_dir_in(epread)) {
/* descriptors are swapped */
struct usb_endpoint_descriptor *t;
D("The data interface has switched endpoints\n");
t = epread;
epread = epwrite;
epwrite = t;
}
made_compressed_probe:
D( "interfaces are valid\n");
for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
if (minor == ACM_TTY_MINORS) {
E("no more free acm devices\n");
return -ENODEV;
}
acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
if (acm == NULL) {
E("out of memory (acm kzalloc)\n");
goto alloc_fail;
}
ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
readsize = le16_to_cpu(epread->wMaxPacketSize) *
(quirks == SINGLE_RX_URB ? 1 : 2);
acm->combined_interfaces = combined_interfaces;
acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
acm->control = control_interface;
acm->data = data_interface;
acm->minor = minor;
acm->dev = usb_dev;
acm->ctrl_caps = ac_management_function;
if (quirks & NO_CAP_LINE)
acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
acm->ctrlsize = ctrlsize;
acm->readsize = readsize;
acm->rx_buflimit = num_rx_buf;
INIT_WORK(&acm->work, acm_softint);
init_usb_anchor(&acm->deferred);
spin_lock_init(&acm->write_lock);
spin_lock_init(&acm->read_lock);
mutex_init(&acm->mutex);
acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
acm->is_int_ep = usb_endpoint_xfer_int(epread);
if (acm->is_int_ep)
acm->bInterval = epread->bInterval;
if (quirks & NO_HANGUP_IN_RESET_RESUME)
acm->no_hangup_in_reset_resume = 1;
tty_port_init(&acm->port);
acm->port.ops = &acm_port_ops;
buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
if (!buf) {
E("out of memory (ctrl buffer alloc)\n");
goto alloc_fail2;
}
acm->ctrl_buffer = buf;
if (acm_write_buffers_alloc(acm) < 0) {
E("out of memory (write buffer alloc)\n");
goto alloc_fail4;
}
acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
if (!acm->ctrlurb) {
E("out of memory (ctrlurb kmalloc)\n");
goto alloc_fail5;
}
for (i = 0; i < num_rx_buf; i++) {
struct acm_rb *rb = &(acm->read_buffers[i]);
struct urb *urb;
rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
&rb->dma);
if (!rb->base) {
E("out of memory "
"(read bufs usb_alloc_coherent)\n");
goto alloc_fail6;
}
rb->index = i;
rb->instance = acm;
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb) {
E("out of memory (read urbs usb_alloc_urb)\n");
goto alloc_fail6;
}
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
urb->transfer_dma = rb->dma;
if (acm->is_int_ep) {
usb_fill_int_urb(urb, acm->dev,
acm->rx_endpoint,
rb->base,
acm->readsize,
acm_read_bulk_callback, rb,
acm->bInterval);
} else {
usb_fill_bulk_urb(urb, acm->dev,
acm->rx_endpoint,
rb->base,
acm->readsize,
acm_read_bulk_callback, rb);
}
acm->read_urbs[i] = urb;
__set_bit(i, &acm->read_urbs_free);
}
for (i = 0; i < ACM_NW; i++) {
struct acm_wb *snd = &(acm->wb[i]);
snd->urb = usb_alloc_urb(0, GFP_KERNEL);
if (snd->urb == NULL) {
E("out of memory (write urbs usb_alloc_urb)\n");
goto alloc_fail7;
}
if (usb_endpoint_xfer_int(epwrite))
usb_fill_int_urb(snd->urb, usb_dev,
usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
else
usb_fill_bulk_urb(snd->urb, usb_dev,
usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
NULL, acm->writesize, acm_write_bulk, snd);
snd->urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP+URB_ZERO_PACKET);
snd->instance = acm;
}
usb_set_intfdata(intf, acm);
i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
if (i < 0)
goto alloc_fail7;
if (cfd) { /* export the country data */
acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
if (!acm->country_codes)
goto skip_countries;
acm->country_code_size = cfd->bLength - 4;
memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
cfd->bLength - 4);
acm->country_rel_date = cfd->iCountryCodeRelDate;
i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
if (i < 0) {
kfree(acm->country_codes);
acm->country_codes = NULL;
acm->country_code_size = 0;
goto skip_countries;
}
i = device_create_file(&intf->dev,
&dev_attr_iCountryCodeRelDate);
if (i < 0) {
device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
kfree(acm->country_codes);
acm->country_codes = NULL;
acm->country_code_size = 0;
goto skip_countries;
}
}
skip_countries:
usb_fill_int_urb(acm->ctrlurb, usb_dev,
usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
/* works around buggy devices */
epctrl->bInterval ? epctrl->bInterval : 0xff);
acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
acm->ctrlurb->transfer_dma = acm->ctrl_dma;
I("ttyACM%d: USB ACM device\n", minor);
acm_set_control(acm, acm->ctrlout);
acm->line.dwDTERate = cpu_to_le32(9600);
acm->line.bDataBits = 8;
acm_set_line(acm, &acm->line);
usb_driver_claim_interface(&acm_driver, data_interface, acm);
usb_set_intfdata(data_interface, acm);
usb_get_intf(control_interface);
tty_register_device(acm_tty_driver, minor, &control_interface->dev);
acm_table[minor] = acm;
return 0;
alloc_fail7:
for (i = 0; i < ACM_NW; i++)
usb_free_urb(acm->wb[i].urb);
alloc_fail6:
for (i = 0; i < num_rx_buf; i++)
usb_free_urb(acm->read_urbs[i]);
acm_read_buffers_free(acm);
usb_free_urb(acm->ctrlurb);
alloc_fail5:
acm_write_buffers_free(acm);
alloc_fail4:
usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
alloc_fail2:
kfree(acm);
alloc_fail:
return -ENOMEM;
}
static int i5k_amb_hwmon_init(struct platform_device *pdev)
{
int i, j, k, d = 0;
u16 c;
int res = 0;
int num_ambs = 0;
struct i5k_amb_data *data = platform_get_drvdata(pdev);
/* Count the number of AMBs found */
/* ignore the high-order bit, see "Ugly hack" comment above */
for (i = 0; i < MAX_MEM_CHANNELS; i++)
num_ambs += hweight16(data->amb_present[i] & 0x7fff);
/* Set up sysfs stuff */
data->attrs = kzalloc(sizeof(*data->attrs) * num_ambs * KNOBS_PER_AMB,
GFP_KERNEL);
if (!data->attrs)
return -ENOMEM;
data->num_attrs = 0;
for (i = 0; i < MAX_MEM_CHANNELS; i++) {
c = data->amb_present[i];
for (j = 0; j < REAL_MAX_AMBS_PER_CHANNEL; j++, c >>= 1) {
struct i5k_device_attribute *iattr;
k = amb_num_from_reg(i, j);
if (!(c & 0x1))
continue;
d++;
/* sysfs label */
iattr = data->attrs + data->num_attrs;
snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
"temp%d_label", d);
iattr->s_attr.dev_attr.attr.name = iattr->name;
iattr->s_attr.dev_attr.attr.mode = S_IRUGO;
iattr->s_attr.dev_attr.show = show_label;
iattr->s_attr.index = k;
sysfs_attr_init(&iattr->s_attr.dev_attr.attr);
res = device_create_file(&pdev->dev,
&iattr->s_attr.dev_attr);
if (res)
goto exit_remove;
data->num_attrs++;
/* Temperature sysfs knob */
iattr = data->attrs + data->num_attrs;
snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
"temp%d_input", d);
iattr->s_attr.dev_attr.attr.name = iattr->name;
iattr->s_attr.dev_attr.attr.mode = S_IRUGO;
iattr->s_attr.dev_attr.show = show_amb_temp;
iattr->s_attr.index = k;
sysfs_attr_init(&iattr->s_attr.dev_attr.attr);
res = device_create_file(&pdev->dev,
&iattr->s_attr.dev_attr);
if (res)
goto exit_remove;
data->num_attrs++;
/* Temperature min sysfs knob */
iattr = data->attrs + data->num_attrs;
snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
"temp%d_min", d);
iattr->s_attr.dev_attr.attr.name = iattr->name;
iattr->s_attr.dev_attr.attr.mode = S_IWUSR | S_IRUGO;
iattr->s_attr.dev_attr.show = show_amb_min;
iattr->s_attr.dev_attr.store = store_amb_min;
iattr->s_attr.index = k;
sysfs_attr_init(&iattr->s_attr.dev_attr.attr);
res = device_create_file(&pdev->dev,
&iattr->s_attr.dev_attr);
if (res)
goto exit_remove;
data->num_attrs++;
/* Temperature mid sysfs knob */
iattr = data->attrs + data->num_attrs;
snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
"temp%d_mid", d);
iattr->s_attr.dev_attr.attr.name = iattr->name;
iattr->s_attr.dev_attr.attr.mode = S_IWUSR | S_IRUGO;
iattr->s_attr.dev_attr.show = show_amb_mid;
iattr->s_attr.dev_attr.store = store_amb_mid;
iattr->s_attr.index = k;
sysfs_attr_init(&iattr->s_attr.dev_attr.attr);
res = device_create_file(&pdev->dev,
&iattr->s_attr.dev_attr);
if (res)
goto exit_remove;
data->num_attrs++;
/* Temperature max sysfs knob */
iattr = data->attrs + data->num_attrs;
snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
"temp%d_max", d);
iattr->s_attr.dev_attr.attr.name = iattr->name;
iattr->s_attr.dev_attr.attr.mode = S_IWUSR | S_IRUGO;
iattr->s_attr.dev_attr.show = show_amb_max;
iattr->s_attr.dev_attr.store = store_amb_max;
iattr->s_attr.index = k;
sysfs_attr_init(&iattr->s_attr.dev_attr.attr);
res = device_create_file(&pdev->dev,
&iattr->s_attr.dev_attr);
if (res)
goto exit_remove;
data->num_attrs++;
/* Temperature alarm sysfs knob */
iattr = data->attrs + data->num_attrs;
snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
"temp%d_alarm", d);
iattr->s_attr.dev_attr.attr.name = iattr->name;
iattr->s_attr.dev_attr.attr.mode = S_IRUGO;
iattr->s_attr.dev_attr.show = show_amb_alarm;
iattr->s_attr.index = k;
sysfs_attr_init(&iattr->s_attr.dev_attr.attr);
res = device_create_file(&pdev->dev,
&iattr->s_attr.dev_attr);
if (res)
goto exit_remove;
data->num_attrs++;
}
}
res = device_create_file(&pdev->dev, &dev_attr_name);
if (res)
goto exit_remove;
data->hwmon_dev = hwmon_device_register(&pdev->dev);
if (IS_ERR(data->hwmon_dev)) {
res = PTR_ERR(data->hwmon_dev);
goto exit_remove;
}
return res;
exit_remove:
device_remove_file(&pdev->dev, &dev_attr_name);
for (i = 0; i < data->num_attrs; i++)
device_remove_file(&pdev->dev, &data->attrs[i].s_attr.dev_attr);
kfree(data->attrs);
return res;
}
void eeh_sysfs_remove_device(struct pci_dev *pdev)
{
device_remove_file(&pdev->dev, &dev_attr_eeh_mode);
device_remove_file(&pdev->dev, &dev_attr_eeh_config_addr);
device_remove_file(&pdev->dev, &dev_attr_eeh_pe_config_addr);
}
static void razer_kbd_disconnect(struct hid_device *hdev)
{
struct razer_kbd_device *dev;
struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
dev = hid_get_drvdata(hdev);
device_remove_file(&hdev->dev, &dev_attr_mode_wave);
device_remove_file(&hdev->dev, &dev_attr_mode_spectrum);
device_remove_file(&hdev->dev, &dev_attr_mode_none);
device_remove_file(&hdev->dev, &dev_attr_mode_reactive);
device_remove_file(&hdev->dev, &dev_attr_mode_breath);
device_remove_file(&hdev->dev, &dev_attr_mode_custom);
device_remove_file(&hdev->dev, &dev_attr_mode_static);
device_remove_file(&hdev->dev, &dev_attr_temp_clear_row);
device_remove_file(&hdev->dev, &dev_attr_set_key_row);
device_remove_file(&hdev->dev, &dev_attr_reset);
device_remove_file(&hdev->dev, &dev_attr_macro_keys);
device_remove_file(&hdev->dev, &dev_attr_set_brightness);
hid_hw_stop(hdev);
kfree(dev);
dev_info(&intf->dev, "Razer Blackwidow Chroma disconnected\n");
}
static void remove_sysfs_interfaces(struct device *dev)
{
int i;
for (i = 0; i < ARRAY_SIZE(attributes); i++)
device_remove_file(dev, attributes + i);
}
static int cyttsp5_debug_probe(struct cyttsp5_device *ttsp)
{
struct device *dev = &ttsp->dev;
struct cyttsp5_debug_data *dd;
struct cyttsp5_debug_platform_data *pdata = dev_get_platdata(dev);
int rc;
/* get context and debug print buffers */
dd = kzalloc(sizeof(*dd), GFP_KERNEL);
if (dd == NULL) {
dev_err(dev, "%s: Error, kzalloc\n", __func__);
rc = -ENOMEM;
goto cyttsp5_debug_probe_alloc_failed;
}
rc = device_create_file(dev, &dev_attr_int_count);
if (rc) {
dev_err(dev, "%s: Error, could not create int_count\n",
__func__);
goto cyttsp5_debug_probe_create_int_count_failed;
}
rc = device_create_file(dev, &dev_attr_formated_output);
if (rc) {
dev_err(dev, "%s: Error, could not create formated_output\n",
__func__);
goto cyttsp5_debug_probe_create_formated_failed;
}
mutex_init(&dd->sysfs_lock);
dd->ttsp = ttsp;
dd->pdata = pdata;
dev_set_drvdata(dev, dd);
pm_runtime_enable(dev);
pm_runtime_get_sync(dev);
dd->si = cyttsp5_request_sysinfo(ttsp);
if (dd->si == NULL) {
dev_err(dev, "%s: Fail get sysinfo pointer from core\n",
__func__);
rc = -ENODEV;
goto cyttsp5_debug_probe_sysinfo_failed;
}
rc = cyttsp5_subscribe_attention(ttsp, CY_ATTEN_IRQ,
cyttsp5_debug_attention, CY_MODE_OPERATIONAL);
if (rc < 0) {
dev_err(dev, "%s: Error, could not subscribe attention cb\n",
__func__);
goto cyttsp5_debug_probe_subscribe_failed;
}
pm_runtime_put(dev);
return 0;
cyttsp5_debug_probe_subscribe_failed:
cyttsp5_debug_probe_sysinfo_failed:
pm_runtime_put(dev);
pm_runtime_suspend(dev);
pm_runtime_disable(dev);
dev_set_drvdata(dev, NULL);
device_remove_file(dev, &dev_attr_formated_output);
cyttsp5_debug_probe_create_formated_failed:
device_remove_file(dev, &dev_attr_int_count);
cyttsp5_debug_probe_create_int_count_failed:
kfree(dd);
cyttsp5_debug_probe_alloc_failed:
dev_err(dev, "%s failed.\n", __func__);
return rc;
}
void nvhost_scale3d_deinit(struct device *dev, struct nvhost_module *mod)
{
device_remove_file(dev, &dev_attr_enable_3d_scaling);
scale3d.init = 0;
}
void timed_output_dev_unregister(struct timed_output_dev *tdev)
{
device_remove_file(tdev->dev, &dev_attr_enable);
device_destroy(timed_output_class, MKDEV(0, tdev->index));
dev_set_drvdata(tdev->dev, NULL);
}
static int __devinit
powertecscsi_probe(struct expansion_card *ec, const struct ecard_id *id)
{
struct Scsi_Host *host;
struct powertec_info *info;
void __iomem *base;
int ret;
ret = ecard_request_resources(ec);
if (ret)
goto out;
base = ecardm_iomap(ec, ECARD_RES_IOCFAST, 0, 0);
if (!base) {
ret = -ENOMEM;
goto out_region;
}
host = scsi_host_alloc(&powertecscsi_template,
sizeof (struct powertec_info));
if (!host) {
ret = -ENOMEM;
goto out_region;
}
ecard_set_drvdata(ec, host);
info = (struct powertec_info *)host->hostdata;
info->base = base;
powertecscsi_terminator_ctl(host, term[ec->slot_no]);
info->ec = ec;
info->info.scsi.io_base = base + POWERTEC_FAS216_OFFSET;
info->info.scsi.io_shift = POWERTEC_FAS216_SHIFT;
info->info.scsi.irq = ec->irq;
info->info.scsi.dma = ec->dma;
info->info.ifcfg.clockrate = 40; /* MHz */
info->info.ifcfg.select_timeout = 255;
info->info.ifcfg.asyncperiod = 200; /* ns */
info->info.ifcfg.sync_max_depth = 7;
info->info.ifcfg.cntl3 = CNTL3_BS8 | CNTL3_FASTSCSI | CNTL3_FASTCLK;
info->info.ifcfg.disconnect_ok = 1;
info->info.ifcfg.wide_max_size = 0;
info->info.ifcfg.capabilities = 0;
info->info.dma.setup = powertecscsi_dma_setup;
info->info.dma.pseudo = NULL;
info->info.dma.stop = powertecscsi_dma_stop;
ec->irqaddr = base + POWERTEC_INTR_STATUS;
ec->irqmask = POWERTEC_INTR_BIT;
ecard_setirq(ec, &powertecscsi_ops, info);
device_create_file(&ec->dev, &dev_attr_bus_term);
ret = fas216_init(host);
if (ret)
goto out_free;
ret = request_irq(ec->irq, powertecscsi_intr,
IRQF_DISABLED, "powertec", info);
if (ret) {
printk("scsi%d: IRQ%d not free: %d\n",
host->host_no, ec->irq, ret);
goto out_release;
}
if (info->info.scsi.dma != NO_DMA) {
if (request_dma(info->info.scsi.dma, "powertec")) {
printk("scsi%d: DMA%d not free, using PIO\n",
host->host_no, info->info.scsi.dma);
info->info.scsi.dma = NO_DMA;
} else {
set_dma_speed(info->info.scsi.dma, 180);
info->info.ifcfg.capabilities |= FASCAP_DMA;
}
}
ret = fas216_add(host, &ec->dev);
if (ret == 0)
goto out;
if (info->info.scsi.dma != NO_DMA)
free_dma(info->info.scsi.dma);
free_irq(ec->irq, host);
out_release:
fas216_release(host);
out_free:
device_remove_file(&ec->dev, &dev_attr_bus_term);
scsi_host_put(host);
out_region:
ecard_release_resources(ec);
out:
return ret;
}
void kgsl_pwrctrl_uninit_sysfs(struct kgsl_device *device)
{
device_remove_file(device->dev, &pwrio_fraction_attr);
}
static int __devinit pm8xxx_led_probe(struct platform_device *pdev)
{
const struct pm8xxx_led_platform_data *pdata = pdev->dev.platform_data;
struct pm8xxx_led_configure *curr_led;
struct pm8xxx_led_data *led, *led_dat;
int i, j, ret = -ENOMEM;
if (pdata == NULL) {
LED_ERR("platform data not supplied\n");
return -EINVAL;
}
led = kcalloc(pdata->num_leds + 1, sizeof(*led), GFP_KERNEL);
if (led == NULL) {
LED_ERR("failed to alloc memory\n");
return -ENOMEM;
}
wake_lock_init(&pmic_led_wake_lock, WAKE_LOCK_SUSPEND, "pmic_led");
g_led_work_queue = create_workqueue("pm8xxx-led");
if (g_led_work_queue == NULL) {
LED_ERR("failed to create workqueue\n");
goto err_create_work_queue;
}
for (i = 0; i < pdata->num_leds; i++) {
curr_led = &pdata->leds[i];
led_dat = &led[i];
led_dat->cdev.name = curr_led->name;
led_dat->id = curr_led->flags;
led_dat->bank = curr_led->flags;
led_dat->function_flags = curr_led->function_flags;
led_dat->start_index = curr_led->start_index;
led_dat->duty_time_ms = curr_led->duty_time_ms;
led_dat->period_us = curr_led->period_us;
led_dat->duites_size = curr_led->duites_size;
led_dat->lut_flag = curr_led->lut_flag;
led_dat->out_current = curr_led->out_current;
led_dat->duties = &(curr_led->duties[0]);
led_dat->led_sync = curr_led->led_sync;
led_dat->pwm_led = pwm_request(led_dat->bank, led_dat->cdev.name);
if (curr_led->duties[1]) {
for (j = 0; j < 64; j++)
dutys_array[j] = *(led_dat->duties + j);
}
if( curr_led->pwm_coefficient > 0 )
led_dat->pwm_coefficient = curr_led->pwm_coefficient;
else
led_dat->pwm_coefficient = 100;
switch (led_dat->id) {
case PM8XXX_ID_GPIO24:
case PM8XXX_ID_GPIO25:
case PM8XXX_ID_GPIO26:
led_dat->cdev.brightness_set = pm8xxx_led_gpio_set;
if (curr_led->gpio_status_switch != NULL)
led_dat->gpio_status_switch = curr_led->gpio_status_switch;
break;
case PM8XXX_ID_LED_0:
case PM8XXX_ID_LED_1:
case PM8XXX_ID_LED_2:
led_dat->cdev.brightness_set = pm8xxx_led_current_set;
if (led_dat->function_flags & LED_PWM_FUNCTION) {
led_dat->reg = pm8xxxx_led_pwm_mode(led_dat->id);
INIT_DELAYED_WORK(&led[i].fade_delayed_work, led_fade_do_work);
} else
led_dat->reg = PM8XXX_LED_MODE_MANUAL;
break;
case PM8XXX_ID_LED_KB_LIGHT:
break;
}
led_dat->cdev.brightness = LED_OFF;
led_dat->dev = &pdev->dev;
ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
if (ret) {
LED_ERR("unable to register led %d,ret=%d\n", led_dat->id, ret);
goto err_register_led_cdev;
}
if (led_dat->id >= PM8XXX_ID_LED_2 && led_dat->id <= PM8XXX_ID_LED_0) {
ret = device_create_file(led_dat->cdev.dev, &dev_attr_currents);
if (ret < 0) {
LED_ERR("%s: Failed to create %d attr currents\n", __func__, i);
goto err_register_attr_currents;
}
}
if (led_dat->id >= PM8XXX_ID_LED_2 && led_dat->id <= PM8XXX_ID_LED_0) {
ret = device_create_file(led_dat->cdev.dev, &dev_attr_lut_coefficient);
if (ret < 0) {
LED_ERR("%s: Failed to create %d attr lut_coefficient\n", __func__, i);
goto err_register_attr_lut_coefficient;
}
}
if ((led_dat->id <= PM8XXX_ID_GPIO26) || (led_dat->id <= PM8XXX_ID_LED_2) ||
(led_dat->id <= PM8XXX_ID_LED_1)) {
ret = device_create_file(led_dat->cdev.dev, &dev_attr_pwm_coefficient);
if (ret < 0) {
LED_ERR("%s: Failed to create %d attr pwm_coefficient\n", __func__, i);
goto err_register_attr_pwm_coefficient;
}
}
if (led_dat->function_flags & LED_BLINK_FUNCTION) {
INIT_DELAYED_WORK(&led[i].blink_delayed_work, led_blink_do_work);
ret = device_create_file(led_dat->cdev.dev, &dev_attr_blink);
if (ret < 0) {
LED_ERR("%s: Failed to create %d attr blink\n", __func__, i);
goto err_register_attr_blink;
}
ret = device_create_file(led_dat->cdev.dev, &dev_attr_off_timer);
if (ret < 0) {
LED_ERR("%s: Failed to create %d attr off timer\n", __func__, i);
goto err_register_attr_off_timer;
}
alarm_init(&led[i].led_alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP, led_alarm_handler);
INIT_WORK(&led[i].led_work, led_work_func);
}
if (!strcmp(led_dat->cdev.name, "button-backlight")) {
for_key_led_data = led_dat;
}
if (!strcmp(led_dat->cdev.name, "green-back")) {
LED_INFO("%s: green-back, 000 probe, led_dat = %x\n", __func__, (unsigned int)led_dat);
green_back_led_data = led_dat;
}
if (!strcmp(led_dat->cdev.name, "amber-back")) {
LED_INFO("%s: amber-back\n", __func__);
amber_back_led_data = led_dat;
}
}
pm8xxx_leds = led;
platform_set_drvdata(pdev, led);
return 0;
err_register_attr_off_timer:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
if (led[i].function_flags & LED_BLINK_FUNCTION)
device_remove_file(led[i].cdev.dev, &dev_attr_off_timer);
}
}
i = pdata->num_leds;
err_register_attr_blink:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
if (led[i].function_flags & LED_BLINK_FUNCTION)
device_remove_file(led[i].cdev.dev, &dev_attr_blink);
}
}
i = pdata->num_leds;
err_register_attr_pwm_coefficient:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
if (led[i].function_flags <= PM8XXX_ID_GPIO26)
device_remove_file(led[i].cdev.dev, &dev_attr_pwm_coefficient);
}
}
i = pdata->num_leds;
err_register_attr_lut_coefficient:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
if (led[i].function_flags >= PM8XXX_ID_LED_2 && led[i].function_flags <= PM8XXX_ID_LED_0)
device_remove_file(led[i].cdev.dev, &dev_attr_lut_coefficient);
}
}
i = pdata->num_leds;
err_register_attr_currents:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
if (led[i].function_flags >= PM8XXX_ID_LED_2 && led[i].function_flags <= PM8XXX_ID_LED_0)
device_remove_file(led[i].cdev.dev, &dev_attr_currents);
}
}
i = pdata->num_leds;
err_register_led_cdev:
if (i > 0) {
for (i = i - 1; i >= 0; i--) {
pwm_free(led[i].pwm_led);
led_classdev_unregister(&led[i].cdev);
}
}
destroy_workqueue(g_led_work_queue);
err_create_work_queue:
kfree(led);
wake_lock_destroy(&pmic_led_wake_lock);
return ret;
}
static int ltn070nl01_panel_probe(struct omap_dss_device *dssdev)
{
int ret = 0;
struct ltn070nl01 *lcd = NULL;
struct backlight_properties props = {
.brightness = BRIGHTNESS_DEFAULT,
.max_brightness = 255,
.type = BACKLIGHT_RAW,
};
pr_info("(%s): called (@%d)\n", __func__, __LINE__);
dev_dbg(&dssdev->dev, "ltn070nl01_probe\n");
lcd = kzalloc(sizeof(*lcd), GFP_KERNEL);
if (!lcd)
return -ENOMEM;
if (dssdev->data == NULL) {
dev_err(&dssdev->dev, "no platform data!\n");
ret = -EINVAL;
goto err_no_platform_data;
}
dssdev->panel.config = OMAP_DSS_LCD_TFT
| OMAP_DSS_LCD_IVS
/*| OMAP_DSS_LCD_IEO */
| OMAP_DSS_LCD_IPC
| OMAP_DSS_LCD_IHS
| OMAP_DSS_LCD_ONOFF;
dssdev->panel.acb = 0;
lcd->dssdev = dssdev;
lcd->pdata = dssdev->data;
ltn070nl01_brightness_data = lcd->pdata->brightness_table;
lcd->bl = get_gamma_value_from_bl(props.brightness);
ret = gpio_request(lcd->pdata->lvds_nshdn_gpio, "lvds_nshdn");
if (ret < 0) {
dev_err(&dssdev->dev, "gpio_request %d failed!\n",
lcd->pdata->lvds_nshdn_gpio);
goto err_no_platform_data;
}
gpio_direction_output(lcd->pdata->lvds_nshdn_gpio, 1);
ret = gpio_request(lcd->pdata->led_backlight_reset_gpio,
"led_backlight_reset");
if (ret < 0) {
dev_err(&dssdev->dev, "gpio_request %d failed!\n",
lcd->pdata->led_backlight_reset_gpio);
goto err_backlight_reset_gpio_request;
}
gpio_direction_output(lcd->pdata->led_backlight_reset_gpio, 1);
mutex_init(&lcd->lock);
dev_set_drvdata(&dssdev->dev, lcd);
/* Register DSI backlight control */
lcd->bd = backlight_device_register("panel", &dssdev->dev, dssdev,
<n070nl01_backlight_ops, &props);
if (IS_ERR(lcd->bd)) {
ret = PTR_ERR(lcd->bd);
goto err_backlight_device_register;
}
lcd->lcd_class = class_create(THIS_MODULE, "lcd");
if (IS_ERR(lcd->lcd_class)) {
pr_err("Failed to create lcd_class!");
goto err_class_create;
}
lcd->dev = device_create(lcd->lcd_class, NULL, 0, NULL, "panel");
if (IS_ERR(lcd->dev)) {
pr_err("Failed to create device(panel)!\n");
goto err_device_create;
}
dev_set_drvdata(lcd->dev, &dssdev->dev);
ret = device_create_file(lcd->dev, &dev_attr_lcd_type);
if (ret < 0) {
dev_err(&dssdev->dev,
"failed to add 'lcd_type' sysfs entries\n");
goto err_lcd_device;
}
ret = device_create_file(lcd->dev, &dev_attr_lcd_power);
if (ret < 0) {
dev_err(&dssdev->dev,
"failed to add 'lcd_power' sysfs entries\n");
goto err_lcd_type;
}
ret = backlight_gptimer_init(dssdev);
if (ret < 0) {
dev_err(&dssdev->dev,
"backlight_gptimer_init failed!\n");
goto err_gptimer_init;
}
/*
* if lcd panel was on from bootloader like u-boot then
* do not lcd on.
*/
if (dssdev->skip_init)
lcd->enabled = 1;
update_brightness(dssdev);
dev_dbg(&dssdev->dev, "%s\n", __func__);
return ret;
err_gptimer_init:
device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_power);
err_lcd_type:
device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_type);
err_lcd_device:
device_destroy(lcd->lcd_class, 0);
err_device_create:
class_destroy(lcd->lcd_class);
err_class_create:
backlight_device_unregister(lcd->bd);
err_backlight_device_register:
mutex_destroy(&lcd->lock);
gpio_free(lcd->pdata->led_backlight_reset_gpio);
err_backlight_reset_gpio_request:
gpio_free(lcd->pdata->lvds_nshdn_gpio);
err_no_platform_data:
kfree(lcd);
return ret;
}
static void ltn070nl01_panel_remove(struct omap_dss_device *dssdev)
{
struct ltn070nl01 *lcd = dev_get_drvdata(&dssdev->dev);
device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_power);
device_remove_file(&(lcd->bd->dev), &dev_attr_lcd_type);
device_destroy(lcd->lcd_class, 0);
class_destroy(lcd->lcd_class);
backlight_device_unregister(lcd->bd);
mutex_destroy(&lcd->lock);
gpio_free(lcd->pdata->led_backlight_reset_gpio);
gpio_free(lcd->pdata->lvds_nshdn_gpio);
kfree(lcd);
}
static int ltn070nl01_start(struct omap_dss_device *dssdev)
{
int r = 0;
r = ltn070nl01_power_on(dssdev);
if (r) {
dev_dbg(&dssdev->dev, "enable failed\n");
dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
} else {
dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
dssdev->manager->enable(dssdev->manager);
}
return r;
}
static int usblp_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev (intf);
struct usblp *usblp = NULL;
int protocol;
int retval;
/* Malloc and start initializing usblp structure so we can use it
* directly. */
if (!(usblp = kzalloc(sizeof(struct usblp), GFP_KERNEL))) {
err("out of memory for usblp");
goto abort;
}
usblp->dev = dev;
init_MUTEX (&usblp->sem);
init_waitqueue_head(&usblp->wait);
usblp->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
usblp->intf = intf;
usblp->writeurb = usb_alloc_urb(0, GFP_KERNEL);
if (!usblp->writeurb) {
err("out of memory");
goto abort;
}
usblp->readurb = usb_alloc_urb(0, GFP_KERNEL);
if (!usblp->readurb) {
err("out of memory");
goto abort;
}
/* Malloc device ID string buffer to the largest expected length,
* since we can re-query it on an ioctl and a dynamic string
* could change in length. */
if (!(usblp->device_id_string = kmalloc(USBLP_DEVICE_ID_SIZE, GFP_KERNEL))) {
err("out of memory for device_id_string");
goto abort;
}
usblp->writebuf = usblp->readbuf = NULL;
usblp->writeurb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
usblp->readurb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
/* Malloc write & read buffers. We somewhat wastefully
* malloc both regardless of bidirectionality, because the
* alternate setting can be changed later via an ioctl. */
if (!(usblp->writebuf = usb_buffer_alloc(dev, USBLP_BUF_SIZE,
GFP_KERNEL, &usblp->writeurb->transfer_dma))) {
err("out of memory for write buf");
goto abort;
}
if (!(usblp->readbuf = usb_buffer_alloc(dev, USBLP_BUF_SIZE,
GFP_KERNEL, &usblp->readurb->transfer_dma))) {
err("out of memory for read buf");
goto abort;
}
/* Allocate buffer for printer status */
usblp->statusbuf = kmalloc(STATUS_BUF_SIZE, GFP_KERNEL);
if (!usblp->statusbuf) {
err("out of memory for statusbuf");
goto abort;
}
/* Lookup quirks for this printer. */
usblp->quirks = usblp_quirks(
le16_to_cpu(dev->descriptor.idVendor),
le16_to_cpu(dev->descriptor.idProduct));
/* Analyze and pick initial alternate settings and endpoints. */
protocol = usblp_select_alts(usblp);
if (protocol < 0) {
dbg("incompatible printer-class device 0x%4.4X/0x%4.4X",
le16_to_cpu(dev->descriptor.idVendor),
le16_to_cpu(dev->descriptor.idProduct));
goto abort;
}
/* Setup the selected alternate setting and endpoints. */
if (usblp_set_protocol(usblp, protocol) < 0)
goto abort;
/* Retrieve and store the device ID string. */
usblp_cache_device_id_string(usblp);
device_create_file(&intf->dev, &dev_attr_ieee1284_id);
#ifdef DEBUG
usblp_check_status(usblp, 0);
#endif
usb_set_intfdata (intf, usblp);
usblp->present = 1;
retval = usb_register_dev(intf, &usblp_class);
if (retval) {
err("Not able to get a minor for this device.");
goto abort_intfdata;
}
usblp->minor = intf->minor;
info("usblp%d: USB %sdirectional printer dev %d "
"if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X",
usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum,
usblp->ifnum,
usblp->protocol[usblp->current_protocol].alt_setting,
usblp->current_protocol,
le16_to_cpu(usblp->dev->descriptor.idVendor),
le16_to_cpu(usblp->dev->descriptor.idProduct));
return 0;
abort_intfdata:
usb_set_intfdata (intf, NULL);
device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
abort:
if (usblp) {
if (usblp->writebuf)
usb_buffer_free (usblp->dev, USBLP_BUF_SIZE,
usblp->writebuf, usblp->writeurb->transfer_dma);
if (usblp->readbuf)
usb_buffer_free (usblp->dev, USBLP_BUF_SIZE,
usblp->readbuf, usblp->writeurb->transfer_dma);
kfree(usblp->statusbuf);
kfree(usblp->device_id_string);
usb_free_urb(usblp->writeurb);
usb_free_urb(usblp->readurb);
kfree(usblp);
}
return -EIO;
}
