static void hampshire_disconnect(struct serio *serio) { struct hampshire *phampshire = serio_get_drvdata(serio); input_get_device(phampshire->dev); input_unregister_device(phampshire->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(phampshire->dev); kfree(phampshire); }
static void inexio_disconnect(struct serio *serio) { struct inexio* pinexio = serio_get_drvdata(serio); input_get_device(pinexio->dev); input_unregister_device(pinexio->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(pinexio->dev); kfree(pinexio); }
static void touchit213_disconnect(struct serio *serio) { struct touchit213 *touchit213 = serio_get_drvdata(serio); input_get_device(touchit213->dev); input_unregister_device(touchit213->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(touchit213->dev); kfree(touchit213); }
static void dynapro_disconnect(struct serio *serio) { struct dynapro *pdynapro = serio_get_drvdata(serio); input_get_device(pdynapro->dev); input_unregister_device(pdynapro->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(pdynapro->dev); kfree(pdynapro); }
/* * fujitsu_disconnect() is the opposite of fujitsu_connect() */ static void fujitsu_disconnect(struct serio *serio) { struct fujitsu *fujitsu = serio_get_drvdata(serio); input_get_device(fujitsu->dev); input_unregister_device(fujitsu->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(fujitsu->dev); kfree(fujitsu); }
static void tw_disconnect(struct serio *serio) { struct tw *tw = serio_get_drvdata(serio); input_get_device(tw->dev); input_unregister_device(tw->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(tw->dev); kfree(tw); }
static void elo_disconnect(struct serio *serio) { struct elo *elo = serio_get_drvdata(serio); input_get_device(elo->dev); input_unregister_device(elo->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(elo->dev); kfree(elo); }
static void gunze_disconnect(struct serio *serio) { struct gunze *gunze = serio_get_drvdata(serio); input_get_device(gunze->dev); input_unregister_device(gunze->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(gunze->dev); kfree(gunze); }
static void mtouch_disconnect(struct serio *serio) { struct mtouch* mtouch = serio_get_drvdata(serio); input_get_device(mtouch->dev); input_unregister_device(mtouch->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(mtouch->dev); kfree(mtouch); }
/* * lkkbd_disconnect() unregisters and closes behind us. */ static void lkkbd_disconnect(struct serio *serio) { struct lkkbd *lk = serio_get_drvdata(serio); input_get_device(lk->dev); input_unregister_device(lk->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(lk->dev); kfree(lk); }
static void pm_disconnect(struct serio *serio) { struct pm *pm = serio_get_drvdata(serio); input_get_device(pm->dev); input_unregister_device(pm->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(pm->dev); kfree(pm); }
static void h3600ts_disconnect(struct serio *serio) { struct h3600_dev *ts = serio_get_drvdata(serio); free_irq(IRQ_GPIO_BITSY_ACTION_BUTTON, &ts->dev); free_irq(IRQ_GPIO_BITSY_NPOWER_BUTTON, &ts->dev); input_get_device(ts->dev); input_unregister_device(ts->dev); serio_close(serio); serio_set_drvdata(serio, NULL); input_put_device(ts->dev); kfree(ts); }
/** * input_register_polled_device - register polled device * @dev: device to register * * The function registers previously initialized polled input device * with input layer. The device should be allocated with call to * input_allocate_polled_device(). Callers should also set up poll() * method and set up capabilities (id, name, phys, bits) of the * corresponding input_dev structure. */ int input_register_polled_device(struct input_polled_dev *dev) { struct input_polled_devres *devres = NULL; struct input_dev *input = dev->input; int error; if (dev->devres_managed) { devres = devres_alloc(devm_input_polldev_unregister, sizeof(*devres), GFP_KERNEL); if (!devres) return -ENOMEM; devres->polldev = dev; } input_set_drvdata(input, dev); INIT_DELAYED_WORK(&dev->work, input_polled_device_work); if (!dev->poll_interval) dev->poll_interval = 500; if (!dev->poll_interval_max) dev->poll_interval_max = dev->poll_interval; input->open = input_open_polled_device; input->close = input_close_polled_device; input->dev.groups = input_polldev_attribute_groups; error = input_register_device(input); if (error) { devres_free(devres); return error; } /* * Take extra reference to the underlying input device so * that it survives call to input_unregister_polled_device() * and is deleted only after input_free_polled_device() * has been invoked. This is needed to ease task of freeing * sparse keymaps. */ input_get_device(input); if (dev->devres_managed) { dev_dbg(input->dev.parent, "%s: registering %s with devres.\n", __func__, dev_name(&input->dev)); devres_add(input->dev.parent, devres); } return 0; }
/** * input_register_polled_device - register polled device * @dev: device to register * * The function registers previously initialized polled input device * with input layer. The device should be allocated with call to * input_allocate_polled_device(). Callers should also set up poll() * method and set up capabilities (id, name, phys, bits) of the * corresponing input_dev structure. */ int input_register_polled_device(struct input_polled_dev *dev) { struct input_dev *input = dev->input; int error; input_set_drvdata(input, dev); INIT_DELAYED_WORK(&dev->work, input_polled_device_work); if (!dev->poll_interval) dev->poll_interval = 500; if (!dev->poll_interval_max) dev->poll_interval_max = dev->poll_interval; input->open = input_open_polled_device; input->close = input_close_polled_device; error = input_register_device(input); if (error) return error; error = sysfs_create_group(&input->dev.kobj, &input_polldev_attribute_group); if (error) { input_unregister_device(input); return error; } /* * Take extra reference to the underlying input device so * that it survives call to input_unregister_polled_device() * and is deleted only after input_free_polled_device() * has been invoked. This is needed to ease task of freeing * sparse keymaps. */ input_get_device(input); return 0; }