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; }
void svec_remove_sysfs_files (struct svec_dev *card) { sysfs_remove_group(&card->dev->kobj, &svec_attr_group); }
void dpm_sysfs_remove(struct device *dev) { rpm_sysfs_remove(dev); sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group); sysfs_remove_group(&dev->kobj, &pm_attr_group); }
static int lightsensor_probe(struct platform_device *pdev) { struct sensor_data *data = NULL; int rt = -ENXIO; unsigned char get_data = 0; pr_info("%s, is called\n", __func__); /* Check I2C communication */ rt = opt_i2c_read(DATA0_LSB, &get_data, sizeof(get_data)); if (rt < 0) { pr_err("%s failed : threre is no such device.\n", __func__); return rt; } gprintk("probe start!\n"); data = kzalloc(sizeof(struct sensor_data), GFP_KERNEL); if (!data) { pr_err("%s: failed to alloc memory for module data\n", __func__); return -ENOMEM; } data->enabled = 0; data->delay = SENSOR_DEFAULT_DELAY; data->input_dev = input_allocate_device(); if (!data->input_dev) { pr_err("%s: could not allocate input device\n", __func__); rt = -ENOMEM; goto err_input_allocate_device_light; } input_set_capability(data->input_dev, EV_REL, REL_MISC); data->input_dev->name = SENSOR_NAME; rt = input_register_device(data->input_dev); if (rt) { pr_err("%s: could not register input device\n", __func__); input_free_device(data->input_dev); goto err_input_register_device_light; } input_set_drvdata(data->input_dev, data); rt = sysfs_create_group(&data->input_dev->dev.kobj, &lightsensor_attribute_group); if (rt) { pr_err("%s: could not create sysfs group\n", __func__); goto err_sysfs_create_group_light; } mutex_init(&data->mutex); mutex_init(&data->light_mutex); data->light_dev = sensors_classdev_register("light_sensor"); if (IS_ERR(data->light_dev)) { pr_err("%s: could not create light_dev\n", __func__); goto err_light_device_create; } if (device_create_file(data->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_file; } if (device_create_file(data->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_file1; } if (device_create_file(data->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_file2; } if (device_create_file(data->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_file3; } dev_set_drvdata(data->light_dev, data); data->wq = create_singlethread_workqueue("gp2a_wq"); if (!data->wq) { rt = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } /* this is the thread function we run on the work queue */ INIT_DELAYED_WORK(&data->work, gp2a_work_func_light); /* set platdata */ platform_set_drvdata(pdev, data); gprintk("probe success!\n"); goto done; /* error, unwind it all */ err_light_device_create_file3: device_remove_file(data->light_dev, &dev_attr_raw_data); err_light_device_create_file2: device_remove_file(data->light_dev, &dev_attr_name); err_light_device_create_file1: device_remove_file(data->light_dev, &dev_attr_vendor); err_create_workqueue: device_remove_file(data->light_dev, &dev_attr_lux); err_light_device_create_file: sensors_classdev_unregister(data->light_dev); err_light_device_create: mutex_destroy(&data->mutex); sysfs_remove_group(&data->input_dev->dev.kobj, &lightsensor_attribute_group); err_sysfs_create_group_light: input_unregister_device(data->input_dev); err_input_register_device_light: err_input_allocate_device_light: kfree(data); done: return rt; }
static int __devinit gpio_keys_probe(struct platform_device *pdev) { const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; struct gpio_keys_drvdata *ddata; struct device *dev = &pdev->dev; struct gpio_keys_platform_data alt_pdata; struct input_dev *input; int i, error; int wakeup = 0; wake_lock_init(&gpio_wake_lock,WAKE_LOCK_SUSPEND,"gpio_wake_lock"); if (!pdata) { error = gpio_keys_get_devtree_pdata(dev, &alt_pdata); if (error) return error; pdata = &alt_pdata; } ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + pdata->nbuttons * sizeof(struct gpio_button_data), GFP_KERNEL); input = input_allocate_device(); if (!ddata || !input) { dev_err(dev, "failed to allocate state\n"); error = -ENOMEM; goto fail1; } ddata->input = input; ddata->n_buttons = pdata->nbuttons; ddata->enable = pdata->enable; ddata->disable = pdata->disable; mutex_init(&ddata->disable_lock); platform_set_drvdata(pdev, ddata); input_set_drvdata(input, ddata); input->name = pdata->name ? : pdev->name; input->phys = "gpio-keys/input0"; input->dev.parent = &pdev->dev; input->open = gpio_keys_open; input->close = gpio_keys_close; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; /* Enable auto repeat feature of Linux input subsystem */ if (pdata->rep) __set_bit(EV_REP, input->evbit); for (i = 0; i < pdata->nbuttons; i++) { struct gpio_keys_button *button = &pdata->buttons[i]; struct gpio_button_data *bdata = &ddata->data[i]; error = gpio_keys_setup_key(pdev, input, bdata, button); if (error) goto fail2; if (button->wakeup) wakeup = 1; } error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group); if (error) { dev_err(dev, "Unable to export keys/switches, error: %d\n", error); goto fail2; } error = input_register_device(input); if (error) { dev_err(dev, "Unable to register input device, error: %d\n", error); goto fail3; } /* get current state of buttons that are connected to GPIOs */ for (i = 0; i < pdata->nbuttons; i++) { struct gpio_button_data *bdata = &ddata->data[i]; if (gpio_is_valid(bdata->button->gpio)) gpio_keys_gpio_report_event(bdata); } input_sync(input); device_init_wakeup(&pdev->dev, wakeup); return 0; fail3: sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); fail2: while (--i >= 0) gpio_remove_key(&ddata->data[i]); platform_set_drvdata(pdev, NULL); fail1: input_free_device(input); kfree(ddata); /* If we have no platform_data, we allocated buttons dynamically. */ if (!pdev->dev.platform_data) kfree(pdata->buttons); return error; }
void ipath_driver_remove_group(struct device_driver *drv) { sysfs_remove_group(&drv->kobj, &driver_attr_group); }
static int sensor_probe(struct platform_device *pdev) { struct sensor_data *data = NULL; struct input_dev *input_data = NULL; int input_registered = 0, sysfs_created = 0; int rt; data = kzalloc(sizeof(struct sensor_data), GFP_KERNEL); if (!data) { rt = -ENOMEM; goto err; } data->enabled = 0; data->delay = SENSOR_DEFAULT_DELAY; input_data = input_allocate_device(); if (!input_data) { rt = -ENOMEM; YLOGE(("sensor_probe: Failed to allocate input_data device\n")); goto err; } input_alloc_absinfo(input_data); set_bit(EV_ABS, input_data->evbit); input_set_capability(input_data, EV_ABS, ABS_X); #if SENSOR_TYPE <= 4 input_set_capability(input_data, EV_ABS, ABS_Y); input_set_capability(input_data, EV_ABS, ABS_Z); input_set_capability(input_data, EV_ABS, ABS_RUDDER); #endif input_set_capability(input_data, EV_ABS, ABS_STATUS); /* status */ input_set_capability(input_data, EV_ABS, ABS_WAKE); /* wake */ input_set_capability(input_data, EV_ABS, ABS_CONTROL_REPORT); /* enabled/delay */ input_data->name = SENSOR_NAME; rt = input_register_device(input_data); if (rt) { YLOGE(("sensor_probe: Unable to register input_data device: %s\n", input_data->name)); goto err; } input_set_drvdata(input_data, data); input_registered = 1; rt = sysfs_create_group(&input_data->dev.kobj, &sensor_attribute_group); if (rt) { YLOGE(("sensor_probe: sysfs_create_group failed[%s]\n", input_data->name)); goto err; } sysfs_created = 1; mutex_init(&data->mutex); this_data = input_data; return 0; err: if (data != NULL) { if (input_data != NULL) { if (sysfs_created) { sysfs_remove_group(&input_data->dev.kobj, &sensor_attribute_group); } if (input_registered) { input_unregister_device(input_data); } else { input_free_device(input_data); } input_data = NULL; } kfree(data); } return rt; }
static int fsl_dcm_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct fsl_dcm_data *dcm; int ret; u8 ver; dcm = kzalloc(sizeof(struct fsl_dcm_data), GFP_KERNEL); if (!dcm) return -ENOMEM; dcm->base = of_iomap(np, 0); if (!dcm->base) { dev_err(&pdev->dev, "could not map fpga node\n"); ret = -ENOMEM; goto error_kzalloc; } dcm->dev = &pdev->dev; dcm->board = pdev->dev.platform_data; /* * write 0x1F to GDC register then read GDD register * to get GMSA version. * 0x00: v1 -> pixis * 0x01: v2 -> qixis */ out_8(dcm->base + 0x16, 0x1F); ver = in_8(dcm->base + 0x17); if (ver == 0x0) { dcm->addr = dcm->base + 0x0a; dcm->data = dcm->base + 0x0d; } else if (ver == 0x01) { dcm->addr = dcm->base + 0x12; dcm->data = dcm->base + 0x13; } dcm->ocmd = dcm->base + 0x14; dcm->omsg = dcm->base + 0x15; dcm->mack = dcm->base + 0x18; /* Check to make sure the DCM is enable and working */ if (!is_sram_available(dcm)) { dev_err(&pdev->dev, "dcm is not responding\n"); ret = -ENODEV; goto error_iomap; } dev_set_drvdata(&pdev->dev, dcm); ret = sysfs_create_group(&pdev->dev.kobj, &fsl_dcm_attr_group); if (ret) { dev_err(&pdev->dev, "could not create sysfs group\n"); goto error_iomap; } if (!select_dcm_channels(dcm, dcm->board->mask)) { dev_err(&pdev->dev, "could not set crecord mask\n"); ret = -ENODEV; goto error_sysfs; } /* Set the timer to the fastest support rate. */ if (!set_dcm_frequency(dcm, 1)) { dev_err(&pdev->dev, "could not set frequency\n"); ret = -ENODEV; goto error_sysfs; } return 0; error_sysfs: sysfs_remove_group(&pdev->dev.kobj, &fsl_dcm_attr_group); error_iomap: iounmap(dcm->base); error_kzalloc: kfree(dcm); return ret; }
void aoedisk_rm_sysfs(struct aoedev *d) { sysfs_remove_group(&disk_to_dev(d->gd)->kobj, &attr_group); }
int __init rpi_power_switch_init(void) { int ret = 0; if (gpio_pin < 0) { pr_err(POWER_SWITCH_CLASS_NAME ": missing argument: gpio_pin\n"); return -EINVAL; } old_pm_power_off = pm_power_off; pm_power_off = rpi_power_switch_power_off; pr_info("Switch driver v%s\n", RPI_POWER_SWITCH_VERSION); INIT_DELAYED_WORK(&initiate_shutdown_work, initiate_shutdown); /* Register our own class for the power switch */ ret = class_register(&power_switch_class); if (ret < 0) { pr_err("%s: Unable to register class\n", power_switch_class.name); goto out0; } /* Create devices for each PWM present */ switch_dev = device_create(&power_switch_class, &platform_bus, MKDEV(0, 0), NULL, "pswitch%u", 0); if (IS_ERR(switch_dev)) { pr_err("%s: device_create failed\n", power_switch_class.name); ret = PTR_ERR(switch_dev); goto out1; } ret = sysfs_create_group(&switch_dev->kobj, &rpi_power_switch_attribute_group); if (ret < 0) { pr_err("%s: create_group failed\n", power_switch_class.name); goto out2; } /* GPIO register memory must be mapped before doing any direct * accesses such as changing GPIO alt functions or changing GPIO * pull ups or pull downs. */ gpio_reg = ioremap(GPIO_BASE, 1024); /* Set the specified pin as a GPIO input */ SET_GPIO_INPUT(gpio_pin); /* Set the pin as a pulldown. Most pins should default to having * pulldowns, and this seems most intuitive. */ set_gpio_pull(gpio_pin, GPIO_PULL_UP); gpio_request(gpio_pin, "Power switch"); gpio_direction_input(gpio_pin); /* The targeted polarity should be the opposite of the current value. * I.e. we want the pin to transition to this state in order to * initiate a shutdown. */ gpio_pol = !gpio_get_value(gpio_pin); /* Request an interrupt to fire when the pin transitions to our * desired state. */ ret = request_irq(__gpio_to_irq(gpio_pin), power_isr, gpio_pol?IRQF_TRIGGER_RISING:IRQF_TRIGGER_FALLING, "Power button", NULL); if (ret) { pr_err("Unable to request IRQ\n"); goto out3; } return 0; /* Error handling */ out3: sysfs_remove_group(&switch_dev->kobj,&rpi_power_switch_attribute_group); out2: device_unregister(switch_dev); out1: class_unregister(&power_switch_class); out0: iounmap(gpio_reg); pm_power_off = old_pm_power_off; return ret; }
static void bridge_destroy_sysfs(void) { sysfs_remove_group(&omap_dspbridge_dev->dev.kobj, &attr_group); }
static int __init hdaps_init(void) { int ret; /* Determine axis orientation orientation */ if (hdaps_invert == HDAPS_ORIENT_UNDEFINED) /* set by module param? */ if (dmi_check_system(hdaps_whitelist) < 1) /* in whitelist? */ hdaps_invert = 0; /* default */ /* Init timer before platform_driver_register, in case of suspend */ init_timer(&hdaps_timer); hdaps_timer.function = hdaps_mousedev_poll; ret = platform_driver_register(&hdaps_driver); if (ret) goto out; pdev = platform_device_register_simple("hdaps", -1, NULL, 0); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); goto out_driver; } ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group); if (ret) goto out_device; hdaps_idev = input_allocate_device(); if (!hdaps_idev) { ret = -ENOMEM; goto out_group; } hdaps_idev_raw = input_allocate_device(); if (!hdaps_idev_raw) { ret = -ENOMEM; goto out_idev_first; } /* calibration for the input device (deferred to avoid delay) */ needs_calibration = 1; /* initialize the joystick-like fuzzed input device */ hdaps_idev->name = "ThinkPad HDAPS joystick emulation"; hdaps_idev->phys = "hdaps/input0"; hdaps_idev->id.bustype = BUS_HOST; hdaps_idev->id.vendor = HDAPS_INPUT_VENDOR; hdaps_idev->id.product = HDAPS_INPUT_PRODUCT; hdaps_idev->id.version = HDAPS_INPUT_JS_VERSION; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25) hdaps_idev->cdev.dev = &pdev->dev; #endif hdaps_idev->evbit[0] = BIT(EV_ABS); hdaps_idev->open = hdaps_mousedev_open; hdaps_idev->close = hdaps_mousedev_close; input_set_abs_params(hdaps_idev, ABS_X, -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT); input_set_abs_params(hdaps_idev, ABS_Y, -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT); ret = input_register_device(hdaps_idev); if (ret) goto out_idev; /* initialize the raw data input device */ hdaps_idev_raw->name = "ThinkPad HDAPS accelerometer data"; hdaps_idev_raw->phys = "hdaps/input1"; hdaps_idev_raw->id.bustype = BUS_HOST; hdaps_idev_raw->id.vendor = HDAPS_INPUT_VENDOR; hdaps_idev_raw->id.product = HDAPS_INPUT_PRODUCT; hdaps_idev_raw->id.version = HDAPS_INPUT_RAW_VERSION; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25) hdaps_idev_raw->cdev.dev = &pdev->dev; #endif hdaps_idev_raw->evbit[0] = BIT(EV_ABS); hdaps_idev_raw->open = hdaps_mousedev_open; hdaps_idev_raw->close = hdaps_mousedev_close; input_set_abs_params(hdaps_idev_raw, ABS_X, -32768, 32767, 0, 0); input_set_abs_params(hdaps_idev_raw, ABS_Y, -32768, 32767, 0, 0); ret = input_register_device(hdaps_idev_raw); if (ret) goto out_idev_reg_first; printk(KERN_INFO "hdaps: driver successfully loaded.\n"); return 0; out_idev_reg_first: input_unregister_device(hdaps_idev); out_idev: input_free_device(hdaps_idev_raw); out_idev_first: input_free_device(hdaps_idev); out_group: sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group); out_device: platform_device_unregister(pdev); out_driver: platform_driver_unregister(&hdaps_driver); hdaps_device_shutdown(); out: printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret); 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; 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 __devinit gpio_keys_probe(struct platform_device *pdev) { const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data; struct gpio_keys_drvdata *ddata; struct gpio_keys_button *button = NULL; struct gpio_button_data *bdata = NULL ; struct device *dev = &pdev->dev; struct gpio_keys_platform_data alt_pdata; struct input_dev *input; int i, error; int wakeup = 0; #ifdef CONFIG_SENSORS_HALL int ret; struct device *sec_key; #endif if (!pdata) { error = gpio_keys_get_devtree_pdata(dev, &alt_pdata); if (error) return error; pdata = &alt_pdata; } ddata = kzalloc(sizeof(struct gpio_keys_drvdata) + pdata->nbuttons * sizeof(struct gpio_button_data), GFP_KERNEL); input = input_allocate_device(); if (!ddata || !input) { dev_err(dev, "failed to allocate state\n"); error = -ENOMEM; goto fail1; } ddata->input = input; ddata->n_buttons = pdata->nbuttons; ddata->enable = pdata->enable; ddata->disable = pdata->disable; #ifdef CONFIG_SENSORS_HALL ddata->gpio_flip_cover = pdata->gpio_flip_cover; ddata->irq_flip_cover = gpio_to_irq(ddata->gpio_flip_cover); #endif mutex_init(&ddata->disable_lock); platform_set_drvdata(pdev, ddata); input_set_drvdata(input, ddata); input->name = pdata->name ? : pdev->name; input->phys = "gpio-keys/input0"; input->dev.parent = &pdev->dev; #ifdef CONFIG_SENSORS_HALL input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, SW_FLIP); #endif input->open = gpio_keys_open; input->close = gpio_keys_close; input->id.bustype = BUS_HOST; input->id.vendor = 0x0001; input->id.product = 0x0001; input->id.version = 0x0100; /* Enable auto repeat feature of Linux input subsystem */ if (pdata->rep) __set_bit(EV_REP, input->evbit); for (i = 0; i < pdata->nbuttons; i++) { button = &pdata->buttons[i]; bdata = &ddata->data[i]; error = gpio_keys_setup_key(pdev, input, bdata, button); if (error) goto fail2; if (button->wakeup) wakeup = 1; } #ifdef KEY_BOOSTER error = gpio_key_init_dvfs(bdata); if (error < 0) { dev_err(dev, "Fail get dvfs level for touch booster\n"); goto fail2; } #endif error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group); if (error) { dev_err(dev, "Unable to export keys/switches, error: %d\n", error); goto fail2; } error = input_register_device(input); if (error) { dev_err(dev, "Unable to register input device, error: %d\n", error); goto fail3; } /* get current state of buttons that are connected to GPIOs */ for (i = 0; i < pdata->nbuttons; i++) { struct gpio_button_data *bdata = &ddata->data[i]; if (gpio_is_valid(bdata->button->gpio)) gpio_keys_gpio_report_event(bdata); } input_sync(input); #ifdef CONFIG_SENSORS_HALL sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key"); if (IS_ERR(sec_key)) pr_err("Failed to create device(sec_key)!\n"); ret = device_create_file(sec_key, &dev_attr_hall_detect); if (ret < 0) { pr_err("Failed to create device file(%s)!, error: %d\n", dev_attr_hall_detect.attr.name, ret); } ret = device_create_file(sec_key, &dev_attr_sec_key_pressed); if (ret) { pr_err("Failed to create device file in sysfs entries(%s)!\n", dev_attr_sec_key_pressed.attr.name); } ret = device_create_file(sec_key, &dev_attr_wakeup_keys); if (ret < 0) { pr_err("Failed to create device file(%s), error: %d\n", dev_attr_wakeup_keys.attr.name, ret); } dev_set_drvdata(sec_key, ddata); #endif device_init_wakeup(&pdev->dev, 1); return 0; fail3: sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group); fail2: while (--i >= 0) gpio_remove_key(&ddata->data[i]); platform_set_drvdata(pdev, NULL); fail1: input_free_device(input); kfree(ddata); /* If we have no platform_data, we allocated buttons dynamically. */ if (!pdev->dev.platform_data) kfree(pdata->buttons); return error; }
static void lenovo_remove_cptkbd(struct hid_device *hdev) { sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd); }
static int __init hdaps_init(void) { struct input_dev *idev; int ret; if (!dmi_check_system(hdaps_whitelist)) { printk(KERN_WARNING "hdaps: supported laptop not found!\n"); ret = -ENODEV; goto out; } if (!request_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS, "hdaps")) { ret = -ENXIO; goto out; } ret = platform_driver_register(&hdaps_driver); if (ret) goto out_region; pdev = platform_device_register_simple("hdaps", -1, NULL, 0); if (IS_ERR(pdev)) { ret = PTR_ERR(pdev); goto out_driver; } ret = sysfs_create_group(&pdev->dev.kobj, &hdaps_attribute_group); if (ret) goto out_device; hdaps_idev = input_allocate_polled_device(); if (!hdaps_idev) { ret = -ENOMEM; goto out_group; } hdaps_idev->poll = hdaps_mousedev_poll; hdaps_idev->poll_interval = HDAPS_POLL_INTERVAL; hdaps_calibrate(); idev = hdaps_idev->input; idev->name = "hdaps"; idev->phys = "isa1600/input0"; idev->id.bustype = BUS_ISA; idev->dev.parent = &pdev->dev; idev->evbit[0] = BIT_MASK(EV_ABS); input_set_abs_params(idev, ABS_X, -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT); input_set_abs_params(idev, ABS_Y, -256, 256, HDAPS_INPUT_FUZZ, HDAPS_INPUT_FLAT); ret = input_register_polled_device(hdaps_idev); if (ret) goto out_idev; printk(KERN_INFO "hdaps: driver successfully loaded.\n"); return 0; out_idev: input_free_polled_device(hdaps_idev); out_group: sysfs_remove_group(&pdev->dev.kobj, &hdaps_attribute_group); out_device: platform_device_unregister(pdev); out_driver: platform_driver_unregister(&hdaps_driver); out_region: release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS); out: printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret); return ret; }
static int bma023_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { struct bma023_data *bma023 = file->private_data; int try; int err = 0; unsigned char data[6]; switch (cmd) { case BMA023_CALIBRATION: if (copy_from_user((struct acceleration *)data, (struct acceleration *)arg, 6) != 0) { pr_err("copy_from_user error\n"); return -EFAULT; } /* iteration time = 20 */ try = 20; err = bma023_calibrate(bma023, *(struct acceleration *)data, &try); break; default: break; } return 0; } static const struct file_operations bma023_fops = { .owner = THIS_MODULE, .open = bma023_open, .release = bma023_close, .ioctl = bma023_ioctl, }; static int bma023_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct bma023_data *bma023; int err; /* setup private data */ bma023 = kzalloc(sizeof(struct bma023_data), GFP_KERNEL); if (!bma023) return -ENOMEM; mutex_init(&bma023->enable_mutex); mutex_init(&bma023->data_mutex); /* setup i2c client */ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { err = -ENODEV; goto err_i2c_fail; } i2c_set_clientdata(client, bma023); bma023->client = client; /* detect and init hardware */ err = bma023_detect(client, NULL); if (err) goto err_id_read; dev_info(&client->dev, "%s found\n", id->name); dev_info(&client->dev, "al_version=%d, ml_version=%d\n", bma023_read_bits(bma023, BMA023_AL_VERSION), bma023_read_bits(bma023, BMA023_ML_VERSION)); bma023_hw_init(bma023); bma023_set_delay(&client->dev, BMA023_DEFAULT_DELAY); /* setup driver interfaces */ INIT_DELAYED_WORK(&bma023->work, bma023_work_func); err = bma023_input_init(bma023); if (err < 0) goto err_input_allocate; err = sysfs_create_group(&bma023->input->dev.kobj, &bma023_attribute_group); if (err < 0) goto err_sys_create; bma023->bma023_device.minor = MISC_DYNAMIC_MINOR; bma023->bma023_device.name = "accelerometer"; bma023->bma023_device.fops = &bma023_fops; err = misc_register(&bma023->bma023_device); if (err) { pr_err("%s: misc_register failed\n", __FILE__); goto err_misc_register; } /* filter init */ filter_init(bma023); return 0; err_misc_register: sysfs_remove_group(&bma023->input->dev.kobj, &bma023_attribute_group); err_sys_create: bma023_input_fini(bma023); err_input_allocate: err_id_read: err_i2c_fail: kfree(bma023); return err; } static int bma023_remove(struct i2c_client *client) { struct bma023_data *bma023 = i2c_get_clientdata(client); bma023_set_enable(&client->dev, 0); sysfs_remove_group(&bma023->input->dev.kobj, &bma023_attribute_group); bma023_input_fini(bma023); kfree(bma023); return 0; } static int bma023_suspend(struct device *dev) { struct bma023_data *bma023 = dev_get_drvdata(dev); mutex_lock(&bma023->enable_mutex); if (bma023_get_enable(dev)) { cancel_delayed_work_sync(&bma023->work); bma023_power_down(bma023); } mutex_unlock(&bma023->enable_mutex); return 0; } static int bma023_resume(struct device *dev) { struct bma023_data *bma023 = dev_get_drvdata(dev); int delay = atomic_read(&bma023->delay); bma023_hw_init(bma023); bma023_set_delay(dev, delay); mutex_lock(&bma023->enable_mutex); if (bma023_get_enable(dev)) { bma023_power_up(bma023); schedule_delayed_work(&bma023->work, delay_to_jiffies(delay) + 1); } mutex_unlock(&bma023->enable_mutex); return 0; } static const struct dev_pm_ops bma023_pm_ops = { .suspend = bma023_suspend, .resume = bma023_resume, }; static const struct i2c_device_id bma023_id[] = { {BMA023_NAME, 0}, {}, }; MODULE_DEVICE_TABLE(i2c, bma023_id); struct i2c_driver bma023_driver = { .driver = { .name = "bma023", .owner = THIS_MODULE, .pm = &bma023_pm_ops, }, .probe = bma023_probe, .remove = bma023_remove, .id_table = bma023_id, };
static int __devinit adp8860_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct backlight_device *bl; struct adp8860_bl *data; struct adp8860_backlight_platform_data *pdata = client->dev.platform_data; struct backlight_properties props; uint8_t reg_val; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { dev_err(&client->dev, "SMBUS Byte Data not Supported\n"); return -EIO; } if (!pdata) { dev_err(&client->dev, "no platform data?\n"); return -EINVAL; } data = kzalloc(sizeof(*data), GFP_KERNEL); if (data == NULL) return -ENOMEM; ret = adp8860_read(client, ADP8860_MFDVID, ®_val); if (ret < 0) goto out2; switch (ADP8860_MANID(reg_val)) { case ADP8863_MANUFID: data->gdwn_dis = !!pdata->gdwn_dis; case ADP8860_MANUFID: data->en_ambl_sens = !!pdata->en_ambl_sens; break; case ADP8861_MANUFID: data->gdwn_dis = !!pdata->gdwn_dis; break; default: dev_err(&client->dev, "failed to probe\n"); ret = -ENODEV; goto out2; } /* It's confirmed that the DEVID field is actually a REVID */ data->revid = ADP8860_DEVID(reg_val); data->client = client; data->pdata = pdata; data->id = id->driver_data; data->current_brightness = 0; i2c_set_clientdata(client, data); memset(&props, 0, sizeof(props)); props.max_brightness = ADP8860_MAX_BRIGHTNESS; mutex_init(&data->lock); bl = backlight_device_register(dev_driver_string(&client->dev), &client->dev, data, &adp8860_bl_ops, &props); if (IS_ERR(bl)) { dev_err(&client->dev, "failed to register backlight\n"); ret = PTR_ERR(bl); goto out2; } bl->props.max_brightness = bl->props.brightness = ADP8860_MAX_BRIGHTNESS; data->bl = bl; if (data->en_ambl_sens) ret = sysfs_create_group(&bl->dev.kobj, &adp8860_bl_attr_group); if (ret) { dev_err(&client->dev, "failed to register sysfs\n"); goto out1; } ret = adp8860_bl_setup(bl); if (ret) { ret = -EIO; goto out; } backlight_update_status(bl); dev_info(&client->dev, "%s Rev.%d Backlight\n", client->name, data->revid); if (pdata->num_leds) adp8860_led_probe(client); return 0; out: if (data->en_ambl_sens) sysfs_remove_group(&data->bl->dev.kobj, &adp8860_bl_attr_group); out1: backlight_device_unregister(bl); out2: kfree(data); return ret; }
static int bh1721_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = -ENODEV; struct input_dev *input_dev; struct bh1721_data *bh1721; struct bh1721_platform_data *pdata = client->dev.platform_data; if (!pdata) { pr_err("%s: missing pdata!\n", __func__); return ret; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s: i2c functionality check failed!\n", __func__); return ret; } bh1721 = kzalloc(sizeof(struct bh1721_data), GFP_KERNEL); if (!bh1721) { pr_err("%s: failed to alloc memory for module data\n", __func__); return -ENOMEM; } bh1721->pdata = pdata; bh1721->reset = pdata->reset; bh1721->i2c_client = client; i2c_set_clientdata(client, bh1721); if (bh1721->reset) bh1721->reset(); mutex_init(&bh1721->power_lock); /* hrtimer settings. we poll for light values using a timer. */ hrtimer_init(&bh1721->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); bh1721->light_poll_delay = ns_to_ktime(200 * NSEC_PER_MSEC); bh1721->timer.function = bh1721_timer_func; /* the timer just fires off a work queue request. we need a thread to read the i2c (can be slow and blocking). */ bh1721->wq = create_singlethread_workqueue("bh1721_wq"); if (!bh1721->wq) { ret = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } /* this is the thread function we run on the work queue */ INIT_WORK(&bh1721->work_light, bh1721_work_func_light); /* allocate lightsensor-level input_device */ input_dev = input_allocate_device(); if (!input_dev) { pr_err("%s: could not allocate input device\n", __func__); ret = -ENOMEM; goto err_input_allocate_device_light; } input_set_drvdata(input_dev, bh1721); input_dev->name = "lightsensor-level"; input_set_capability(input_dev, EV_ABS, ABS_MISC); input_set_abs_params(input_dev, ABS_MISC, 0, 1, 0, 0); ret = input_register_device(input_dev); if (ret < 0) { pr_err("%s: could not register input device\n", __func__); input_free_device(input_dev); goto err_input_register_device_light; } bh1721->light_input_dev = input_dev; ret = sysfs_create_group(&input_dev->dev.kobj,&light_attribute_group); if (ret) { printk("Creating bh1721 attribute group failed"); goto error_device; } /* set sysfs for light sensor test mode*/ lightsensor_class = class_create(THIS_MODULE, "lightsensor"); if (IS_ERR(lightsensor_class)) { printk("Failed to create class(lightsensor)!\n"); goto error_device; } switch_cmd_dev = device_create(lightsensor_class, NULL, 0, NULL, "switch_cmd"); if (IS_ERR(switch_cmd_dev)) { printk("Failed to create device(switch_cmd_dev)!\n"); goto DESTROY_CLASS; } if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_state) < 0) { printk("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_state.attr.name); device_remove_file(switch_cmd_dev, &dev_attr_lightsensor_file_state); goto DESTROY_DEVICE; } if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_illuminance) < 0) { printk("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_illuminance.attr.name); device_remove_file(switch_cmd_dev, &dev_attr_lightsensor_file_illuminance); goto DESTROY_DEVICE; } if (device_create_file(switch_cmd_dev, &dev_attr_lightsensor_file_cmd) < 0) { printk("Failed to create device file(%s)!\n", dev_attr_lightsensor_file_cmd.attr.name); goto DESTROY_DEVICE; } dev_set_drvdata(switch_cmd_dev, bh1721); printk("[%s]: Light Sensor probe complete.", __func__); goto done; /* error, unwind it all */ DESTROY_DEVICE: device_destroy(lightsensor_class,0); DESTROY_CLASS: class_destroy(lightsensor_class); error_device: sysfs_remove_group(&client->dev.kobj, &light_attribute_group); err_input_register_device_light: input_unregister_device(bh1721->light_input_dev); err_input_allocate_device_light: destroy_workqueue(bh1721->wq); err_create_workqueue: mutex_destroy(&bh1721->power_lock); kfree(bh1721); done: return ret; }
void usb_notify_dev_unregister(struct usb_notify_dev *udev) { sysfs_remove_group(&udev->dev->kobj, &usb_notify_attr_grp); device_destroy(usb_notify_data.usb_notify_class, MKDEV(0, udev->index)); dev_set_drvdata(udev->dev, NULL); }
static int hall_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct hall_drvdata *ddata; struct input_dev *input; int error; int wakeup = 0; ddata = kzalloc(sizeof(struct hall_drvdata), GFP_KERNEL); if (!ddata) { dev_err(dev, "failed to allocate state\n"); return -ENOMEM; } #ifdef CONFIG_OF if(dev->of_node) { error = of_hall_data_parsing_dt(ddata); if (error < 0) { pr_info("%s : fail to get the dt (HALL)\n", __func__); goto fail1; } } #endif input = input_allocate_device(); if (!input) { dev_err(dev, "failed to allocate state\n"); error = -ENOMEM; goto fail1; } ddata->input = input; wake_lock_init(&ddata->flip_wake_lock, WAKE_LOCK_SUSPEND, "flip wake lock"); platform_set_drvdata(pdev, ddata); input_set_drvdata(input, ddata); input->name = "hall"; input->phys = "hall"; input->dev.parent = &pdev->dev; input->evbit[0] |= BIT_MASK(EV_SW); input_set_capability(input, EV_SW, SW_LID); input->open = hall_open; input->close = hall_close; /* Enable auto repeat feature of Linux input subsystem */ __set_bit(EV_REP, input->evbit); #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL mutex_init(&ddata->irq_lock); ddata->gsm_area = false; ddata->cover_state = false; g_drvdata = ddata; #endif init_hall_ic_irq(input); error = sysfs_create_group(&sec_key->kobj, &hall_attr_group); if (error) { dev_err(dev, "Unable to export keys/switches, error: %d\n", error); goto fail2; } error = input_register_device(input); if (error) { dev_err(dev, "Unable to register input device, error: %d\n", error); goto fail3; } device_init_wakeup(&pdev->dev, wakeup); return 0; fail3: sysfs_remove_group(&pdev->dev.kobj, &hall_attr_group); fail2: platform_set_drvdata(pdev, NULL); wake_lock_destroy(&ddata->flip_wake_lock); input_free_device(input); fail1: kfree(ddata); return error; }
void pccard_sysfs_remove_socket(struct device *dev) { sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr); sysfs_remove_group(&dev->kobj, &socket_attrs); }
static int __devinit bcmpmu_adc_probe(struct platform_device *pdev) { struct bcmpmu59xxx *bcmpmu = dev_get_drvdata(pdev->dev.parent); struct bcmpmu_adc *adc; int i, ret = 0; printk(KERN_DEBUG "%s: called\n", __func__); gbcmpmu = bcmpmu; adc = kzalloc(sizeof(struct bcmpmu_adc), GFP_KERNEL); if (adc == NULL) { pr_hwmon(ERROR, "%s failed to alloc mem.\n", __func__); return -ENOMEM; } bcmpmu->adc = (void *)adc; adc->pdata = (struct bcmpmu_adc_pdata *)pdev->dev.platform_data; adc->hwmon_dev = hwmon_device_register(&pdev->dev); if (IS_ERR(adc->hwmon_dev)) { ret = PTR_ERR(adc->hwmon_dev); dev_err(&pdev->dev, "Class registration failed (%d)\n", ret); goto error; } /* SAR per channel mutes */ for (i = 0; i < PMU_ADC_CHANN_MAX; i++) mutex_init(&adc->chann_mutex[i]); /* RTM mutex */ mutex_init(&adc->rtm_mutex); init_completion(&adc->rtm_ready_complete); wake_lock_init(&adc->wake_lock, WAKE_LOCK_SUSPEND, "adc"); /* Register Interrupts */ ret = bcmpmu->register_irq(bcmpmu, PMU_IRQ_RTM_DATA_RDY, bcmpmu_rtm_irq_handler, adc); if (ret) { pr_hwmon(ERROR, "Failed to register PMU_IRQ_RTM_DATA_RDY\n"); goto error; } ret = bcmpmu->register_irq(bcmpmu, PMU_IRQ_RTM_UPPER, bcmpmu_rtm_irq_handler, adc); if (ret) { pr_hwmon(ERROR, "Failed to register PMU_IRQ_RTM_UPPER\n"); goto error; } ret = bcmpmu->register_irq(bcmpmu, PMU_IRQ_RTM_IGNORE, bcmpmu_rtm_irq_handler, adc); if (ret) { pr_hwmon(ERROR, "Failed to register PMU_IRQ_RTM_IGNORE\n"); goto error; } ret = bcmpmu->register_irq(bcmpmu, PMU_IRQ_RTM_OVERRIDDEN, bcmpmu_rtm_irq_handler, adc); if (ret) { pr_hwmon(ERROR, "Failed to register PMU_IRQ_RTM_OVERRIDDEN\n"); goto error; } /* Unmask interrupts */ bcmpmu->unmask_irq(bcmpmu, PMU_IRQ_RTM_DATA_RDY); bcmpmu->unmask_irq(bcmpmu, PMU_IRQ_RTM_UPPER); bcmpmu->unmask_irq(bcmpmu, PMU_IRQ_RTM_IGNORE); /* Mask interrupts */ bcmpmu->mask_irq(bcmpmu, PMU_IRQ_RTM_OVERRIDDEN); bcmpmu->mask_irq(bcmpmu, PMU_IRQ_RTM_IN_CON_MEAS); ret = sysfs_create_group(&pdev->dev.kobj, &bcmpmu_hwmon_attr_group); if (ret != 0) goto exit_remove_files; #ifdef CONFIG_DEBUG_FS bcmpmu_adc_debug_init(bcmpmu); #endif return 0; exit_remove_files: sysfs_remove_group(&pdev->dev.kobj, &bcmpmu_hwmon_attr_group); error: bcmpmu->unregister_irq(bcmpmu, PMU_IRQ_RTM_DATA_RDY); bcmpmu->unregister_irq(bcmpmu, PMU_IRQ_RTM_UPPER); bcmpmu->unregister_irq(bcmpmu, PMU_IRQ_RTM_IGNORE); bcmpmu->unregister_irq(bcmpmu, PMU_IRQ_RTM_OVERRIDDEN); kfree(adc); return 0; }
void sysaufs_fin(void) { dbgaufs_fin(); sysfs_remove_group(&sysaufs_ket->kobj, sysaufs_attr_group); kset_unregister(sysaufs_ket); }
static inline void s3c_hwmon_remove_raw(struct device *dev) { sysfs_remove_group(&dev->kobj, &s3c_hwmon_attrgroup); }
static int __devinit #else static int #endif igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct rte_uio_pci_dev *udev; struct msix_entry msix_entry; int err; /* essential vars for configuring the device with net_device */ struct net_device *netdev; struct net_adapter *adapter = NULL; struct ixgbe_hw *hw_i = NULL; struct e1000_hw *hw_e = NULL; udev = kzalloc(sizeof(struct rte_uio_pci_dev), GFP_KERNEL); if (!udev) return -ENOMEM; /* * enable device: ask low-level code to enable I/O and * memory */ err = pci_enable_device(dev); if (err != 0) { dev_err(&dev->dev, "Cannot enable PCI device\n"); goto fail_free; } /* * reserve device's PCI memory regions for use by this * module */ err = pci_request_regions(dev, "igb_uio"); if (err != 0) { dev_err(&dev->dev, "Cannot request regions\n"); goto fail_disable; } /* enable bus mastering on the device */ pci_set_master(dev); /* remap IO memory */ err = igbuio_setup_bars(dev, &udev->info); if (err != 0) goto fail_release_iomem; /* set 64-bit DMA mask */ err = pci_set_dma_mask(dev, DMA_BIT_MASK(64)); if (err != 0) { dev_err(&dev->dev, "Cannot set DMA mask\n"); goto fail_release_iomem; } err = pci_set_consistent_dma_mask(dev, DMA_BIT_MASK(64)); if (err != 0) { dev_err(&dev->dev, "Cannot set consistent DMA mask\n"); goto fail_release_iomem; } /* fill uio infos */ udev->info.name = "igb_uio"; udev->info.version = "0.1"; udev->info.handler = igbuio_pci_irqhandler; udev->info.irqcontrol = igbuio_pci_irqcontrol; #ifdef CONFIG_XEN_DOM0 /* check if the driver run on Xen Dom0 */ if (xen_initial_domain()) udev->info.mmap = igbuio_dom0_pci_mmap; #endif udev->info.priv = udev; udev->pdev = dev; switch (igbuio_intr_mode_preferred) { case RTE_INTR_MODE_MSIX: /* Only 1 msi-x vector needed */ msix_entry.entry = 0; if (pci_enable_msix(dev, &msix_entry, 1) == 0) { dev_dbg(&dev->dev, "using MSI-X"); udev->info.irq = msix_entry.vector; udev->mode = RTE_INTR_MODE_MSIX; break; } /* fall back to INTX */ case RTE_INTR_MODE_LEGACY: if (pci_intx_mask_supported(dev)) { dev_dbg(&dev->dev, "using INTX"); udev->info.irq_flags = IRQF_SHARED; udev->info.irq = dev->irq; udev->mode = RTE_INTR_MODE_LEGACY; break; } dev_notice(&dev->dev, "PCI INTX mask not supported\n"); /* fall back to no IRQ */ case RTE_INTR_MODE_NONE: udev->mode = RTE_INTR_MODE_NONE; udev->info.irq = 0; break; default: dev_err(&dev->dev, "invalid IRQ mode %u", igbuio_intr_mode_preferred); err = -EINVAL; goto fail_release_iomem; } err = sysfs_create_group(&dev->dev.kobj, &dev_attr_grp); if (err != 0) goto fail_release_iomem; /* initialize the corresponding netdev */ netdev = alloc_etherdev(sizeof(struct net_adapter)); if (!netdev) { err = -ENOMEM; goto fail_alloc_etherdev; } SET_NETDEV_DEV(netdev, pci_dev_to_dev(dev)); adapter = netdev_priv(netdev); adapter->netdev = netdev; adapter->pdev = dev; udev->adapter = adapter; adapter->type = retrieve_dev_specs(id); /* recover device-specific mac address */ switch (adapter->type) { case IXGBE: hw_i = &adapter->hw._ixgbe_hw; hw_i->back = adapter; hw_i->hw_addr = ioremap(pci_resource_start(dev, 0), pci_resource_len(dev, 0)); if (!hw_i->hw_addr) { err = -EIO; goto fail_ioremap; } break; case IGB: hw_e = &adapter->hw._e1000_hw; hw_e->back = adapter; hw_e->hw_addr = ioremap(pci_resource_start(dev, 0), pci_resource_len(dev, 0)); if (!hw_e->hw_addr) { err = -EIO; goto fail_ioremap; } break; } netdev_assign_netdev_ops(netdev); strncpy(netdev->name, pci_name(dev), sizeof(netdev->name) - 1); retrieve_dev_addr(netdev, adapter); strcpy(netdev->name, "dpdk%d"); err = register_netdev(netdev); if (err) goto fail_ioremap; adapter->netdev_registered = true; if (sscanf(netdev->name, "dpdk%hu", &adapter->bd_number) <= 0) goto fail_bdnumber; //printk(KERN_DEBUG "ifindex picked: %hu\n", adapter->bd_number); dev_info(&dev->dev, "ifindex picked: %hu\n", adapter->bd_number); /* register uio driver */ err = uio_register_device(&dev->dev, &udev->info); if (err != 0) goto fail_remove_group; pci_set_drvdata(dev, udev); dev_info(&dev->dev, "uio device registered with irq %lx\n", udev->info.irq); /* reset nstats */ memset(&adapter->nstats, 0, sizeof(struct net_device_stats)); return 0; fail_bdnumber: fail_ioremap: free_netdev(netdev); fail_alloc_etherdev: pci_release_selected_regions(dev, pci_select_bars(dev, IORESOURCE_MEM)); fail_remove_group: sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp); fail_release_iomem: igbuio_pci_release_iomem(&udev->info); if (udev->mode == RTE_INTR_MODE_MSIX) pci_disable_msix(udev->pdev); pci_release_regions(dev); fail_disable: pci_disable_device(dev); fail_free: kfree(udev); return err; }
static int __devinit k3_bq24161_charger_probe(struct i2c_client *client, const struct i2c_device_id *id) { u8 read_reg = 0; int ret = 0; enum usb_charger_type plugin_stat = CHARGER_REMOVED; struct k3_bq24161_device_info *di = NULL; struct k3_bq24161_platform_data *pdata = NULL; /*enum plugin_status plugin_stat;*/ if (!g_battery_measure_by_bq27510_device) { dev_err(&client->dev, "g_battery_measure_by_bq27510_device is NULL!\n"); return -ENOMEM; } pdata = client->dev.platform_data; if (!pdata) { dev_err(&client->dev, "pdata is NULL!\n"); return -ENOMEM; } di = kzalloc(sizeof(*di), GFP_KERNEL); if (!di) { dev_err(&client->dev, "di is NULL!\n"); return -ENOMEM; } di->dev = &client->dev; di->client = client; i2c_set_clientdata(client, di); ret = k3_bq24161_read_byte(di, &read_reg, REG_PART_REVISION); if (ret < 0) { dev_err(&client->dev, "chip not present at address %x\n", client->addr); ret = -EINVAL; goto err_kfree; } if (((read_reg & BQ24161_VERSION_MSK) == 0x00) && (client->addr == I2C_ADDR_BQ24161)) di->bqchip_version = BQ24161; if (di->bqchip_version == 0) { dev_err(&client->dev, "unknown bq chip\n"); dev_err(&client->dev, "Chip address %x", client->addr); dev_err(&client->dev, "bq chip version reg value %x", read_reg); ret = -EINVAL; goto err_kfree; } di->max_voltagemV = pdata->max_charger_voltagemV; di->max_currentmA = pdata->max_charger_currentmA; di->voltagemV = di->max_voltagemV; di->currentmA = CURRENT_USB_CHARGE_IN ; di->term_currentmA = CURRENT_TERM_CHARGE_IN; di->dppm_voltagemV = VOLT_DPPM_ADJUST; di->cin_limit = CURRENT_USB_LIMIT_IN; di->gpio = pdata->gpio; /**********ADD BY 00186176 begin****************/ /* Set iomux normal */ #ifdef CONFIG_GPIO_BAT if (!di->piomux_block) di->piomux_block = iomux_get_block("block_charger"); if (!di->pblock_config) di->pblock_config = iomux_get_blockconfig("block_charger"); ret = blockmux_set(di->piomux_block, di->pblock_config, NORMAL); if (ret) { dev_err(&client->dev, "blockmux_set NORMAL failed, ret=%d\n", ret); goto err_kfree; } #endif /*set gpio_074 to control CD pin to disable/enable bq24161 IC*/ ret = gpio_request(di->gpio, "gpio_074_cd"); if (ret) { dev_err(&client->dev, "could not request irq\n"); ret = -ENOMEM; goto err_io; } /* set charger CD pin to low level and enable it to supply power normally*/ gpio_direction_output(di->gpio, 0); /**********ADD BY 00186176 END****************/ di->enable_low_chg = ENABLE_LOW_CHG; /*enable low charge,100mA charging*/ k3_bq24161_config_safety_reg(di); /*disable charge current termination*/ di->enable_iterm = DISABLE_ITERM; di->factory_flag = 0; di->enable_ce = ENABLE_CE; di->hz_mode = 0; di->cd_active = 0; #if BQ2416X_USE_WAKE_LOCK wake_lock_init(&di->charger_wake_lock, WAKE_LOCK_SUSPEND, "charger_wake_lock"); #endif INIT_DELAYED_WORK(&di->bq24161_charger_work, k3_bq24161_charger_work); INIT_WORK(&di->usb_work, k3_bq24161_usb_charger_work); di->active = 0; di->params.enable = 1; di->cfg_params = 1; /*di->enable_iterm = 1;*/ k3_bq24161_config_control_reg(di); k3_bq24161_config_voltage_reg(di); k3_bq24161_config_current_reg(di); k3_bq24161_config_dppm_voltage_reg(di, di->dppm_voltagemV); k3_bq24161_config_safety_reg(di); ret = sysfs_create_group(&client->dev.kobj, &k3_bq24161_attr_group); if (ret) { dev_err(&client->dev, "could not create sysfs files\n"); goto err_gpio; } /**********ADD BY 00186176 begin****************/ di->nb.notifier_call = k3_bq24161_usb_notifier_call; ret = hiusb_charger_registe_notifier(&di->nb); if (ret < 0) { dev_err(&client->dev, "hiusb_charger_registe_notifier failed\n"); goto err_sysfs; } plugin_stat = get_charger_name(); if ((CHARGER_TYPE_USB == plugin_stat) || (CHARGER_TYPE_NON_STANDARD == plugin_stat)) { di->event = plugin_stat; k3_bq24161_start_500mA_charger(di); } else if (CHARGER_TYPE_BC_USB == plugin_stat) { k3_bq24161_start_BCUSB_charger(di); } else if (CHARGER_TYPE_STANDARD == plugin_stat) { k3_bq24161_start_ac_charger(di); } else { k3_bq24161_stop_charger(di); } return 0; err_sysfs: sysfs_remove_group(&client->dev.kobj, &k3_bq24161_attr_group); err_gpio: gpio_free(di->gpio); err_io: #ifdef CONFIG_GPIO_BAT if (blockmux_set(di->piomux_block, di->pblock_config, LOWPOWER)) dev_err(&client->dev, "blockmux_set LOWPOWER failed\n"); #endif /**********ADD BY 00186176 END****************/ err_kfree: kfree(di); di = NULL; return ret; }
static int lenovo_probe_tpkbd(struct hid_device *hdev) { struct device *dev = &hdev->dev; struct lenovo_drvdata_tpkbd *data_pointer; size_t name_sz = strlen(dev_name(dev)) + 16; char *name_mute, *name_micmute; int i; int ret; /* * Only register extra settings against subdevice where input_mapping * set drvdata to 1, i.e. the trackpoint. */ if (!hid_get_drvdata(hdev)) return 0; hid_set_drvdata(hdev, NULL); /* Validate required reports. */ for (i = 0; i < 4; i++) { if (!hid_validate_values(hdev, HID_FEATURE_REPORT, 4, i, 1)) return -ENODEV; } if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 3, 0, 2)) return -ENODEV; ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd); if (ret) hid_warn(hdev, "Could not create sysfs group: %d\n", ret); data_pointer = devm_kzalloc(&hdev->dev, sizeof(struct lenovo_drvdata_tpkbd), GFP_KERNEL); if (data_pointer == NULL) { hid_err(hdev, "Could not allocate memory for driver data\n"); ret = -ENOMEM; goto err; } // set same default values as windows driver data_pointer->sensitivity = 0xa0; data_pointer->press_speed = 0x38; name_mute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL); name_micmute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL); if (name_mute == NULL || name_micmute == NULL) { hid_err(hdev, "Could not allocate memory for led data\n"); ret = -ENOMEM; goto err; } snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev)); snprintf(name_micmute, name_sz, "%s:amber:micmute", dev_name(dev)); hid_set_drvdata(hdev, data_pointer); data_pointer->led_mute.name = name_mute; data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd; data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd; data_pointer->led_mute.dev = dev; led_classdev_register(dev, &data_pointer->led_mute); data_pointer->led_micmute.name = name_micmute; data_pointer->led_micmute.brightness_get = lenovo_led_brightness_get_tpkbd; data_pointer->led_micmute.brightness_set = lenovo_led_brightness_set_tpkbd; data_pointer->led_micmute.dev = dev; led_classdev_register(dev, &data_pointer->led_micmute); lenovo_features_set_tpkbd(hdev); return 0; err: sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd); 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); if (pdata->gp2a_get_threshold) { gp2a_update_threshold(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; } 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 __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; }