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