/* Call with ams_info.lock held! */
static int ams_input_enable(void)
{
struct input_dev *input;
s8 x, y, z;
int error;
ams_sensors(&x, &y, &z);
ams_info.xcalib = x;
ams_info.ycalib = y;
ams_info.zcalib = z;
ams_info.idev = input_allocate_polled_device();
if (!ams_info.idev)
return -ENOMEM;
ams_info.idev->poll = ams_idev_poll;
ams_info.idev->poll_interval = 25;
input = ams_info.idev->input;
input->name = "Apple Motion Sensor";
input->id.bustype = ams_info.bustype;
input->id.vendor = 0;
input->dev.parent = &ams_info.of_dev->dev;
input_set_abs_params(input, ABS_X, -50, 50, 3, 0);
input_set_abs_params(input, ABS_Y, -50, 50, 3, 0);
input_set_abs_params(input, ABS_Z, -50, 50, 3, 0);
set_bit(EV_ABS, input->evbit);
set_bit(EV_KEY, input->evbit);
set_bit(BTN_TOUCH, input->keybit);
error = input_register_polled_device(ams_info.idev);
if (error) {
input_free_polled_device(ams_info.idev);
ams_info.idev = NULL;
return error;
}
joystick = true;
return 0;
}
static void __exit alps_exit(void)
{
alps_info("is called\n");
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&alps_early_suspend_handler);
alps_dbgmsg("early_suspend_unregister\n");
#endif
misc_deregister(&alps_device);
alps_dbgmsg("misc_deregister\n");
input_unregister_polled_device(alps_idev);
alps_dbgmsg("input_unregister_polled_device\n");
input_free_polled_device(alps_idev);
alps_dbgmsg("input_free_polled_device\n");
platform_device_unregister(pdev);
alps_dbgmsg("platform_device_unregister\n");
platform_driver_unregister(&alps_driver);
alps_dbgmsg("platform_driver_unregister\n");
}
static int mag3110_remove(struct i2c_client *client)
{
struct mag3110_data *data;
int ret;
data = i2c_get_clientdata(client);
data->ctl_reg1 = mag3110_read_reg(client, MAG3110_CTRL_REG1);
ret = mag3110_write_reg(client, MAG3110_CTRL_REG1,
data->ctl_reg1 & ~MAG3110_AC_MASK);
free_irq(client->irq, data);
input_unregister_polled_device(data->poll_dev);
input_free_polled_device(data->poll_dev);
hwmon_device_unregister(data->hwmon_dev);
sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group);
kfree(data);
mag3110_pdata = NULL;
return ret;
}
/**
* Remove implementation
* @param i2c I2C client
* @return 0 in success, or negative error code
*/
static int accel_remove(struct i2c_client *i2c)
{
u8 buf[2] = {ACCEL_I2C_PORT_REG1, 0x0};
/* complete all scheduled work */
flush_scheduled_work ();
/* remove irq handler */
if (accel_info.irq1 > 0) {
free_irq (accel_info.irq1, &accel_info);
/* release GPIOs */
gpio_free (accel_gpio_one);
}
#ifdef ACCEL_DATA_READY_IRQ
if (accel_info.irq2 > 0) {
free_irq (accel_info.irq2, &accel_info);
/* release GPIOs */
gpio_free (accel_gpio_two);
}
#endif
/* power down accelerometer */
i2c_master_send (i2c, buf, 2);
sysfs_remove_group (&i2c->dev.kobj, &accel_defattr_group);
if (accel_info.idev) {
input_unregister_polled_device (accel_info.ipdev);
input_free_polled_device (accel_info.ipdev);
}
misc_deregister (&accel_misc_driver);
/* platform_device_del (accel_platform_device);
device_remove_file (&accel_platform_device->dev, );
*/
vprintk ("driver exited");
return 0;
}
int lis3lv02d_joystick_enable(void)
{
struct input_dev *input_dev;
int err;
int max_val, fuzz, flat;
if (lis3_dev.idev)
return -EINVAL;
lis3_dev.idev = input_allocate_polled_device();
if (!lis3_dev.idev)
return -ENOMEM;
lis3_dev.idev->poll = lis3lv02d_joystick_poll;
lis3_dev.idev->poll_interval = MDPS_POLL_INTERVAL;
input_dev = lis3_dev.idev->input;
input_dev->name = "ST LIS3LV02DL Accelerometer";
input_dev->phys = DRIVER_NAME "/input0";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0;
input_dev->dev.parent = &lis3_dev.pdev->dev;
set_bit(EV_ABS, input_dev->evbit);
max_val = (lis3_dev.mdps_max_val * lis3_dev.scale) / LIS3_ACCURACY;
fuzz = (LIS3_DEFAULT_FUZZ * lis3_dev.scale) / LIS3_ACCURACY;
flat = (LIS3_DEFAULT_FLAT * lis3_dev.scale) / LIS3_ACCURACY;
input_set_abs_params(input_dev, ABS_X, -max_val, max_val, fuzz, flat);
input_set_abs_params(input_dev, ABS_Y, -max_val, max_val, fuzz, flat);
input_set_abs_params(input_dev, ABS_Z, -max_val, max_val, fuzz, flat);
err = input_register_polled_device(lis3_dev.idev);
if (err) {
input_free_polled_device(lis3_dev.idev);
lis3_dev.idev = NULL;
}
return err;
}
int lis3lv02d_joystick_enable(void)
{
struct input_dev *input_dev;
int err;
if (lis3_dev.idev)
return -EINVAL;
lis3_dev.idev = input_allocate_polled_device();
if (!lis3_dev.idev)
return -ENOMEM;
lis3_dev.idev->poll = lis3lv02d_joystick_poll;
lis3_dev.idev->poll_interval = MDPS_POLL_INTERVAL;
input_dev = lis3_dev.idev->input;
lis3lv02d_calibrate_joystick();
input_dev->name = "ST LIS3LV02DL Accelerometer";
input_dev->phys = DRIVER_NAME "/input0";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0;
input_dev->dev.parent = &lis3_dev.pdev->dev;
set_bit(EV_ABS, input_dev->evbit);
input_set_abs_params(input_dev, ABS_X, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3);
input_set_abs_params(input_dev, ABS_Y, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3);
input_set_abs_params(input_dev, ABS_Z, -lis3_dev.mdps_max_val, lis3_dev.mdps_max_val, 3, 3);
err = input_register_polled_device(lis3_dev.idev);
if (err) {
input_free_polled_device(lis3_dev.idev);
lis3_dev.idev = NULL;
}
return err;
}
static int mag3110_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter;
struct input_dev *idev;
struct mag3110_data *data;
int ret = 0;
struct regulator *vdd, *vdd_io;
u32 pos = 0;
struct device_node *of_node = client->dev.of_node;
#if MAG3110_IRQ_USED
struct irq_data *irq_data = irq_get_irq_data(client->irq);
u32 irq_flag;
bool shared_irq = of_property_read_bool(of_node, "shared-interrupt");
#endif
vdd = NULL;
vdd_io = NULL;
vdd = devm_regulator_get(&client->dev, "vdd");
if (!IS_ERR(vdd)) {
ret = regulator_enable(vdd);
if (ret) {
dev_err(&client->dev, "vdd set voltage error\n");
return ret;
}
}
vdd_io = devm_regulator_get(&client->dev, "vddio");
if (!IS_ERR(vdd_io)) {
ret = regulator_enable(vdd_io);
if (ret) {
dev_err(&client->dev, "vddio set voltage error\n");
return ret;
}
}
adapter = to_i2c_adapter(client->dev.parent);
if (!i2c_check_functionality(adapter,
I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_SMBUS_BYTE_DATA |
I2C_FUNC_SMBUS_I2C_BLOCK))
return -EIO;
dev_info(&client->dev, "check mag3110 chip ID\n");
ret = mag3110_read_reg(client, MAG3110_WHO_AM_I);
if (MAG3110_ID != ret) {
dev_err(&client->dev,
"read chip ID 0x%x is not equal to 0x%x!\n", ret,
MAG3110_ID);
return -EINVAL;
}
data = kzalloc(sizeof(struct mag3110_data), GFP_KERNEL);
if (!data)
return -ENOMEM;
data->client = client;
i2c_set_clientdata(client, data);
/* Init queue */
init_waitqueue_head(&data->waitq);
data->hwmon_dev = hwmon_device_register(&client->dev);
if (IS_ERR(data->hwmon_dev)) {
dev_err(&client->dev, "hwmon register failed!\n");
ret = PTR_ERR(data->hwmon_dev);
goto error_rm_dev_sysfs;
}
/*input poll device register */
data->poll_dev = input_allocate_polled_device();
if (!data->poll_dev) {
dev_err(&client->dev, "alloc poll device failed!\n");
ret = -ENOMEM;
goto error_rm_hwmon_dev;
}
data->poll_dev->poll = mag3110_dev_poll;
data->poll_dev->poll_interval = POLL_INTERVAL;
data->poll_dev->poll_interval_max = POLL_INTERVAL_MAX;
idev = data->poll_dev->input;
idev->name = MAG3110_DRV_NAME;
idev->id.bustype = BUS_I2C;
idev->evbit[0] = BIT_MASK(EV_ABS);
input_set_abs_params(idev, ABS_X, -15000, 15000, 0, 0);
input_set_abs_params(idev, ABS_Y, -15000, 15000, 0, 0);
input_set_abs_params(idev, ABS_Z, -15000, 15000, 0, 0);
ret = input_register_polled_device(data->poll_dev);
if (ret) {
dev_err(&client->dev, "register poll device failed!\n");
goto error_free_poll_dev;
}
/*create device group in sysfs as user interface */
ret = sysfs_create_group(&idev->dev.kobj, &mag3110_attr_group);
if (ret) {
dev_err(&client->dev, "create device file failed!\n");
ret = -EINVAL;
goto error_rm_poll_dev;
}
#if MAG3110_IRQ_USED
irq_flag = irqd_get_trigger_type(irq_data);
irq_flag |= IRQF_ONESHOT;
if (shared_irq)
irq_flag |= IRQF_SHARED;
ret = request_threaded_irq(client->irq, NULL, mag3110_irq_handler,
irq_flag, client->dev.driver->name, idev);
if (ret < 0) {
dev_err(&client->dev, "failed to register irq %d!\n",
client->irq);
goto error_rm_dev_sysfs;
}
#endif
/* Initialize mag3110 chip */
mag3110_init_client(client);
mag3110_pdata = data;
mag3110_pdata->active = MAG_STANDBY;
ret = of_property_read_u32(of_node, "position", &pos);
if (ret)
pos = DEFAULT_POSITION;
mag3110_pdata->position = (int)pos;
dev_info(&client->dev, "mag3110 is probed\n");
return 0;
error_rm_dev_sysfs:
sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group);
error_rm_poll_dev:
input_unregister_polled_device(data->poll_dev);
error_free_poll_dev:
input_free_polled_device(data->poll_dev);
error_rm_hwmon_dev:
hwmon_device_unregister(data->hwmon_dev);
kfree(data);
mag3110_pdata = NULL;
return ret;
}
static int mma8451_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int result;
struct input_dev *idev;
struct i2c_adapter *adapter;
u32 pos;
struct device_node *of_node = client->dev.of_node;
struct regulator *vdd, *vdd_io;
mma8451_i2c_client = client;
vdd = devm_regulator_get(&client->dev, "vdd");
if (!IS_ERR(vdd)) {
result = regulator_enable(vdd);
if (result) {
dev_err(&client->dev, "vdd set voltage error\n");
return result;
}
}
vdd_io = devm_regulator_get(&client->dev, "vddio");
if (!IS_ERR(vdd_io)) {
result = regulator_enable(vdd_io);
if (result) {
dev_err(&client->dev, "vddio set voltage error\n");
return result;
}
}
adapter = to_i2c_adapter(client->dev.parent);
result = i2c_check_functionality(adapter,
I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_SMBUS_BYTE_DATA);
if (!result)
goto err_out;
client_id = i2c_smbus_read_byte_data(client, MMA8451_WHO_AM_I);
if (client_id != MMA8451_ID && client_id != MMA8452_ID
&& client_id != MMA8453_ID && client_id != FXOS8700_ID) {
dev_err(&client->dev,
"read chip ID 0x%x is not equal to 0x%x,0x%x,0x%x!\n",
result, MMA8451_ID, MMA8452_ID, FXOS8700_ID);
result = -EINVAL;
goto err_out;
}
/* Initialize the MMA8451 chip */
result = mma8451_change_mode(client, senstive_mode);
if (result) {
dev_err(&client->dev,
"error when init mma8451 chip:(%d)\n", result);
goto err_out;
}
hwmon_dev = hwmon_device_register(&client->dev);
if (!hwmon_dev) {
result = -ENOMEM;
dev_err(&client->dev, "error when register hwmon device\n");
goto err_out;
}
/* create a polled input device for accelerometer */
mma8451_idev = input_allocate_polled_device();
if (!mma8451_idev) {
result = -ENOMEM;
dev_err(&client->dev, "alloc poll device failed!\n");
goto err_register_polled_device;
}
mma8451_idev->poll = mma8451_dev_poll;
mma8451_idev->poll_interval = POLL_INTERVAL;
mma8451_idev->poll_interval_min = POLL_INTERVAL_MIN;
mma8451_idev->poll_interval_max = POLL_INTERVAL_MAX;
idev = mma8451_idev->input;
if (client_id == FXOS8700_ID)
idev->name = "mma845x_a";
else
idev->name = "mma845x";
idev->id.bustype = BUS_I2C;
idev->evbit[0] = BIT_MASK(EV_ABS);
input_set_abs_params(idev, ABS_X, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
input_set_abs_params(idev, ABS_Y, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
input_set_abs_params(idev, ABS_Z, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
result = input_register_polled_device(mma8451_idev);
if (result) {
dev_err(&client->dev, "register poll device failed!\n");
goto err_register_polled_device;
}
result = sysfs_create_group(&idev->dev.kobj, &mma8451_attr_group);
if (result) {
dev_err(&client->dev, "create device file failed!\n");
result = -EINVAL;
goto err_register_polled_device;
}
/* create a polled input device for magnetometer */
if (client_id == FXOS8700_ID) {
fxos8700_m_idev = input_allocate_polled_device();
if (!fxos8700_m_idev) {
result = -ENOMEM;
dev_err(&client->dev, "alloc poll device failed!\n");
goto err_alloc_poll_device;
}
fxos8700_m_idev->poll = mma8451_dev_poll;
fxos8700_m_idev->poll_interval = POLL_INTERVAL;
fxos8700_m_idev->poll_interval_min = POLL_INTERVAL_MIN;
fxos8700_m_idev->poll_interval_max = POLL_INTERVAL_MAX;
idev = fxos8700_m_idev->input;
idev->name = "fxos8700_m";
idev->id.bustype = BUS_I2C;
idev->evbit[0] = BIT_MASK(EV_ABS);
input_set_abs_params(idev, ABS_X, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
input_set_abs_params(idev, ABS_Y, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
input_set_abs_params(idev, ABS_Z, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
result = input_register_polled_device(fxos8700_m_idev);
if (result) {
dev_err(&client->dev, "register poll device failed!\n");
goto err_register_polled_device1;
}
result = sysfs_create_group(&idev->dev.kobj, &mma8451_attr_group);
if (result) {
dev_err(&client->dev, "create device file failed!\n");
result = -EINVAL;
goto err_create_sysfs1;
}
}
result = of_property_read_u32(of_node, "position", &pos);
if (result)
pos = DEFAULT_POSITION;
mma_status.position = (int)pos;
return 0;
err_create_sysfs1:
input_unregister_polled_device(fxos8700_m_idev);
err_register_polled_device1:
input_free_polled_device(fxos8700_m_idev);
err_register_polled_device:
input_free_polled_device(mma8451_idev);
err_alloc_poll_device:
hwmon_device_unregister(&client->dev);
err_out:
return result;
}
static int __init alps_init(void)
{
struct input_dev *idev;
int ret;
flgM = 0;
flgA = 0;
probeA = PROBE_FAIL;
probeM = PROBE_FAIL;
ret = platform_driver_register(&alps_driver);
if (ret)
goto out_region;
pr_info("alps-init: platform_driver_register\n");
mutex_init(&alps_lock);
pdev = platform_device_register_simple("alps", -1, NULL, 0);
if (IS_ERR(pdev)) {
ret = PTR_ERR(pdev);
goto out_driver;
}
pr_info("alps-init: platform_device_register_simple\n");
ret = sysfs_create_group(&pdev->dev.kobj, &alps_attribute_group);
if (ret)
goto out_device;
pr_info("alps-init: sysfs_create_group\n");
alps_idev = input_allocate_polled_device();
if (!alps_idev) {
ret = -ENOMEM;
goto out_group;
}
pr_info("alps-init: input_allocate_polled_device\n");
alps_idev->poll = alps_poll;
alps_idev->poll_interval = ALPS_POLL_INTERVAL;
/* initialize the input class */
idev = alps_idev->input;
idev->name = "alps";
idev->phys = "alps/input0";
idev->id.bustype = BUS_HOST;
idev->dev.parent = &pdev->dev;
idev->evbit[0] = BIT_MASK(EV_ABS);
#if defined(CONFIG_SENSORS_BMA222E) || defined(CONFIG_SENSORS_BMA222) || defined(CONFIG_SENSORS_K2DH)
input_set_abs_params(idev, EVENT_TYPE_ACCEL_X,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_ACCEL_Y,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_ACCEL_Z,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
#endif
#if defined(CONFIG_SENSORS_HSCDTD006A) || defined(CONFIG_SENSORS_HSCDTD008A)
input_set_abs_params(idev, EVENT_TYPE_MAGV_X,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Y,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Z,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
#endif
ret = input_register_polled_device(alps_idev);
if (ret)
goto out_idev;
pr_info("alps-init: input_register_polled_device\n");
ret = misc_register(&alps_device);
if (ret) {
pr_info("alps-init: alps_io_device register failed\n");
goto exit_misc_device_register_failed;
}
pr_info("alps-init: misc_register\n");
return 0;
exit_misc_device_register_failed:
out_idev:
input_free_polled_device(alps_idev);
pr_info("alps-init: input_free_polled_device\n");
out_group:
sysfs_remove_group(&pdev->dev.kobj, &alps_attribute_group);
pr_info("alps-init: sysfs_remove_group\n");
out_device:
platform_device_unregister(pdev);
pr_info("alps-init: platform_device_unregister\n");
out_driver:
platform_driver_unregister(&alps_driver);
pr_info("alps-init: platform_driver_unregister\n");
mutex_destroy(&alps_lock);
out_region:
return ret;
}
/**
* Probe implementation
* Inits the character device and completes the I2C driver initialization
* @return 0 in success, or negative error code
*/
static int accel_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int err=-ENOMEM;
struct input_dev *idev;
struct input_polled_dev *ipdev;
struct platform_device *pdev;
if (!i2c_check_functionality (client->adapter, I2C_FUNC_I2C)) {
fprintk ("I2C function is not supported");
return -ENOTSUPP;
}
memset (&accel_info, 0, sizeof (accel_data_t));
accel_info.magic = ACCEL_MAGIC;
accel_info.irq1 = accel_info.irq2 = -1;
mutex_init (&accel_info.mlock);
mutex_init (&pl);
atomic_set (&accel_info.data_ready_enabled, 0);
accel_info.i2c = client;
i2c_set_clientdata (client, &accel_info);
if (accel_i2c_who_am_i () != ACCEL_I_AM_THE_ONE) {
fprintk ("I2C device with address 0x%x is not LIS331DLH", client->addr);
err = -ENODEV;
goto exit;
}else {
vprintk ("I2C device with address 0x%x is LIS331DLH accelerometer", client->addr);
}
INIT_WORK (&accel_info.wq1, accel_irq_bottom_half);
#ifdef ACCEL_DATA_READY_IRQ
INIT_WORK (&accel_info.wq2, accel_irq_data_ready_bottom_half);
#endif
// sema_init (&accel_info.sema1, 1);
// sema_init (&accel_info.sema2, 1);
pdev = (struct platform_device *)client->dev.platform_data;
/*
* IRQ field contain information about swapped axes
*/
accel_param_swapped = pdev->id;
fprintk ("swapped axes parameter 0x%02x", accel_param_swapped);
if (pdev && pdev->num_resources && ! strcmp(pdev->name, "stmicro")) {
struct resource *resource;
vprintk ("platform data for '%s', num_resources %d",
pdev->name, pdev->num_resources);
resource = platform_get_resource (pdev, IORESOURCE_IRQ, 0);
if (resource) {
accel_gpio_one = resource->start;
accel_gpio_two = resource->end;
accel_irq_config_edge (&accel_info.irq1, accel_gpio_one,
ACCEL_IRQ_INT1,
(void *)&accel_info.irq1_cnt, accel_irq_handler);
#ifdef ACCEL_DATA_READY_IRQ
accel_irq_config_high (&accel_info.irq2, accel_gpio_two,
ACCEL_IRQ_INT2,
(void *)&accel_info.irq2_cnt,
accel_irq_data_ready_handler);
#endif
} else {
fprintk ("unable to obtain GPIO information; no IRQ support");
}
} else {
fprintk ("platform data has no resources declared; no IRQ support");
}
if (accel_param_input) {
/* take care of input device here */
ipdev = input_allocate_polled_device ();
if (! ipdev) {
fprintk ("failed to allocate input device structure");
err = -ENOMEM;
goto exit_irqs;
}
ipdev->poll_interval = (int)-1;
ipdev->poll = accel_poll_data_ready;
idev = ipdev->input;
idev->name = "accelerometer";
idev->id.bustype = BUS_I2C;
idev->id.vendor = 0;
idev->id.product = ACCEL_I_AM_THE_ONE;
accel_info.idev = idev;
accel_info.ipdev = ipdev;
set_bit (EV_ABS, idev->evbit);
set_bit (EV_SW, idev->evbit);
set_bit (6, idev->swbit);
input_report_switch (idev, 6, TOGGLE_OFF);
accel_input_params (idev, ABS_X, 3, ACCEL_2G_MAX);
accel_input_params (idev, ABS_RX, 3, ACCEL_2G_MAX);
accel_input_params (idev, ABS_TILT_X, 2, ACCEL_2G_MAX);
if ((err = input_register_polled_device (ipdev))) {
fprintk ("failed to register input device");
goto exit_input;
}
}
fprintk ("registered input device accelerometer\n");
atomic_set (&accel_info.mode, 0);
atomic_set (&accel_info.odr, 0);
atomic_set (&accel_info.g_range, 1); // 4G
accel_i2c_set_config (0, 0, 0, -1);
/* create misc device and /dev/accelerometer file */
if (misc_register (&accel_misc_driver)) {
fprintk("can't register misc. device");
goto exit_input;
}
fprintk ("registered misc device\n");
/* Turn power on if forced to do so */
if (accel_param_power) {
/*enable all axises */
accel_i2c_enable_axis (AXIS_XYZ);
/* aplly power settings */
accel_i2c_set_power_mode (accel_param_power);
}
/* Register sysfs hooks */
if ((err = sysfs_create_group (&client->dev.kobj, &accel_defattr_group))) {
fprintk ("failed to create a sysfs group");
goto exit_input;
}
fprintk ("created sysfs group\n");
#ifdef CONFIG_HAS_EARLYSUSPEND
accel_info.early_suspend.suspend = accel_early_suspend;
accel_info.early_suspend.resume = accel_early_resume;
register_early_suspend (&(accel_info.early_suspend));
#endif
printk (KERN_INFO "%s: driver probed successfully\n", __func__);
return SUCCESS;
exit_input:
if (accel_info.ipdev) {
input_free_polled_device (accel_info.ipdev);
accel_info.ipdev = NULL;
}
exit_irqs:
if (accel_info.irq1 > 0) {
gpio_free (accel_gpio_one);
free_irq (accel_info.irq1, (void *)&accel_info.irq1_cnt);
}
#ifdef ACCEL_DATA_READY_IRQ
if (accel_info.irq2 > 0) {
gpio_free (accel_gpio_two);
free_irq (accel_info.irq2, (void *)&accel_info.irq2_cnt);
}
#endif
exit:
return err;
}
static int __init alps_init(void)
{
struct input_dev *idev;
int ret;
printk(KERN_INFO "[ALPS] alps_init\n");
flgM = 0;
flgA = 0;
ret = platform_driver_register(&alps_driver);
if (ret)
goto out_region;
printk(KERN_INFO "[ALPS] platform_driver_register\n");
pdev = platform_device_register_simple("alps", -1, NULL, 0);
if (IS_ERR(pdev)) {
ret = PTR_ERR(pdev);
goto out_driver;
}
printk(KERN_INFO "[ALPS] platform_device_register_simple\n");
ret = sysfs_create_group(&pdev->dev.kobj, &alps_attribute_group);
if (ret)
goto out_device;
printk(KERN_INFO "[ALPS] sysfs_create_group\n");
alps_idev = input_allocate_polled_device();
if (!alps_idev) {
ret = -ENOMEM;
goto out_group;
}
printk(KERN_INFO "[ALPS] input_allocate_polled_device\n");
alps_idev->poll = alps_poll;
alps_idev->poll_interval = ALPS_POLL_INTERVAL;
/* initialize the input class */
idev = alps_idev->input;
idev->name = "magnetic_sensor";
idev->phys = "alps/input2";
idev->id.bustype = BUS_HOST;
idev->dev.parent = &pdev->dev;
idev->evbit[0] = BIT_MASK(EV_ABS);
input_set_abs_params(idev, EVENT_TYPE_ACCEL_X,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_ACCEL_Y,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_ACCEL_Z,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_X,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Y,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Z,
-4096, 4096, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
ret = input_register_polled_device(alps_idev);
if (ret)
goto out_idev;
printk(KERN_INFO "[ALPS] input_register_polled_device\n");
ret = misc_register(&alps_device);
if (ret) {
printk(KERN_ERR "[ALPS] alps_io_device register failed\n");
goto exit_misc_device_register_failed;
}
printk(KERN_INFO "[ALPS] misc_register\n");
return 0;
exit_misc_device_register_failed:
out_idev:
input_free_polled_device(alps_idev);
printk(KERN_ERR "[ALPS] input_free_polled_device\n");
out_group:
sysfs_remove_group(&pdev->dev.kobj, &alps_attribute_group);
printk(KERN_ERR "[ALPS] sysfs_remove_group\n");
out_device:
platform_device_unregister(pdev);
printk(KERN_ERR "[ALPS] platform_device_unregister\n");
out_driver:
platform_driver_unregister(&alps_driver);
printk(KERN_ERR "[ALPS] platform_driver_unregister\n");
out_region:
return ret;
}
static int __devinit mma8452_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int result, client_id;
struct input_dev *idev;
struct i2c_adapter *adapter;
struct mma8452_data *mma;
const struct mma8452_platform_data *pdata = client->dev.platform_data;
if (!pdata) {
dev_err(&client->dev, "platform data for layout is NULL; exiting\n");
return -EINVAL;
}
/* Allocate memory for driver data */
mma = kzalloc(sizeof(struct mma8452_data), GFP_KERNEL);
if (!mma) {
printk(KERN_ERR "mma8452_probe: memory allocation failed.\n");
return -ENOMEM;
}
mma8452_i2c_client = client;
printk(SENSOR_TAG "come into %s\n",__FUNCTION__);
adapter = to_i2c_adapter(client->dev.parent);
result = i2c_check_functionality(adapter,
I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_SMBUS_BYTE_DATA);
if (!result)
goto err_out;
else
printk(SENSOR_TAG "i2c_check_functionality() was called success\n");
client_id = i2c_smbus_read_byte_data(client, MMA8452_WHO_AM_I);
if (client_id != MMA8452_ID && client_id != MMA8452_ID) {
dev_err(&client->dev,
"read chip ID 0x%x is not equal to 0x%x or 0x%x!\n",
result, MMA8452_ID, MMA8452_ID);
printk(SENSOR_TAG "I2C read error\n");
result = -EINVAL;
goto err_out;
}else{
printk(SENSOR_TAG "read chip ID is :0x%x\n",client_id);
}
/* Initialize the MMA8452 chip */
result = mma8452_change_mode(client, senstive_mode);
if (result) {
dev_err(&client->dev,
"error when init mma8452 chip:(%d)\n", result);
goto err_out;
}
hwmon_dev = hwmon_device_register(&client->dev);
if (!hwmon_dev) {
result = -ENOMEM;
dev_err(&client->dev,
"error when register hwmon device\n");
goto err_out;
}
mma8452_idev = input_allocate_polled_device();
if (!mma8452_idev) {
result = -ENOMEM;
dev_err(&client->dev, "alloc poll device failed!\n");
goto err_alloc_poll_device;
}
mma8452_idev->poll = mma8452_dev_poll;
mma8452_idev->poll_interval = POLL_INTERVAL;
mma8452_idev->poll_interval_min = POLL_INTERVAL_MIN;
mma8452_idev->poll_interval_max = POLL_INTERVAL_MAX;
idev = mma8452_idev->input;
if (client_id == MMA8452_ID)
idev->name = "mma8452";
else
idev->name = "mma8452";
idev->id.bustype = BUS_I2C;
idev->evbit[0] = BIT_MASK(EV_ABS);
input_set_abs_params(idev, ABS_X, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
input_set_abs_params(idev, ABS_Y, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
input_set_abs_params(idev, ABS_Z, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
result = input_register_polled_device(mma8452_idev);
if (result) {
dev_err(&client->dev, "register poll device failed!\n");
goto err_register_polled_device;
}
mma->mma_early_suspend.suspend = mma8452_early_suspend;
mma->mma_early_suspend.resume = mma8452_early_resume;
register_early_suspend(&mma->mma_early_suspend);
result = sysfs_create_group(&idev->dev.kobj, &mma8452_attr_group);
if (result) {
dev_err(&client->dev, "create device file failed!\n");
result = -EINVAL;
goto err_register_polled_device;
}
mma_status.position = (*pdata).axis_map_cordination;
return 0;
err_register_polled_device:
input_free_polled_device(mma8452_idev);
err_alloc_poll_device:
hwmon_device_unregister(&client->dev);
err_out:
return result;
}
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 __init alps_init(void)
{
int ret;
alps_info("is called\n");
ret = platform_driver_register(&alps_driver);
if (ret)
goto out_region;
alps_dbgmsg("platform_driver_register\n");
pdev = platform_device_register_simple("alps_compass", -1, NULL, 0);
if (IS_ERR(pdev)) {
ret = PTR_ERR(pdev);
goto out_driver;
}
alps_dbgmsg("platform_device_register_simple\n");
alps_idev = input_allocate_polled_device();
if (!alps_idev) {
ret = -ENOMEM;
goto out_device;
}
alps_dbgmsg("input_allocate_polled_device\n");
alps_idev->poll = alps_poll;
alps_idev->poll_interval = ALPS_POLL_INTERVAL;
/* initialize the input class */
idev = alps_idev->input;
idev->name = "magnetic_sensor";
//idev->phys = "alps_compass/input0";
idev->id.bustype = BUS_I2C;
//idev->dev.parent = &pdev->dev;
//idev->evbit[0] = BIT_MASK(EV_ABS);
set_bit(EV_REL, idev->evbit);
input_set_capability(idev, EV_REL, REL_X);
input_set_capability(idev, EV_REL, REL_Y);
input_set_capability(idev, EV_REL, REL_Z);
#if 0//defined(MAG_15BIT)
input_set_abs_params(idev, EVENT_TYPE_MAGV_X,
-16384, 16383, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Y,
-16384, 16383, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Z,
-16384, 16383, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
//#elif defined(MAG_13BIT)
input_set_abs_params(idev, EVENT_TYPE_MAGV_X,
-4096, 4095, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Y,
-4096, 4095, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
input_set_abs_params(idev, EVENT_TYPE_MAGV_Z,
-4096, 4095, ALPS_INPUT_FUZZ, ALPS_INPUT_FLAT);
#endif
ret = input_register_polled_device(alps_idev);
if (ret)
goto out_alc_poll;
alps_dbgmsg("input_register_polled_device\n");
ret = misc_register(&alps_device);
if (ret) {
alps_info("alps_io_device register failed\n");
goto out_reg_poll;
}
alps_dbgmsg("misc_register\n");
ret = sysfs_create_group(&idev->dev.kobj,
&magnetic_attribute_group);
#if defined(CONFIG_SENSOR_USE_SYMLINK)
ret = sensors_initialize_symlink(alps_idev->input);
if (ret < 0) {
pr_err("%s: apls_sensors_initialize_symlink error(%d).\n",
__func__, ret);
goto out_reg_poll;
}
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&alps_early_suspend_handler);
alps_dbgmsg("register_early_suspend\n");
#endif
mutex_lock(&alps_lock);
flg_suspend = 0;
mutex_unlock(&alps_lock);
return 0;
out_reg_poll:
input_unregister_polled_device(alps_idev);
alps_info("input_unregister_polled_device\n");
out_alc_poll:
input_free_polled_device(alps_idev);
alps_info("input_free_polled_device\n");
out_device:
platform_device_unregister(pdev);
alps_info("platform_device_unregister\n");
out_driver:
platform_driver_unregister(&alps_driver);
alps_info("platform_driver_unregister\n");
out_region:
return ret;
}
static int __devinit mag3110_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter;
struct input_dev *idev;
struct mag3110_data *data;
int ret = 0;
adapter = to_i2c_adapter(client->dev.parent);
if (!i2c_check_functionality(adapter,
I2C_FUNC_SMBUS_BYTE |
I2C_FUNC_SMBUS_BYTE_DATA |
I2C_FUNC_SMBUS_I2C_BLOCK))
return -EIO;
dev_info(&client->dev, "check mag3110 chip ID\n");
ret = mag3110_read_reg(client, MAG3110_WHO_AM_I);
if (MAG3110_ID != ret) {
dev_err(&client->dev,
"read chip ID 0x%x is not equal to 0x%x!\n", ret,
MAG3110_ID);
return -EINVAL;
}
data = kzalloc(sizeof(struct mag3110_data), GFP_KERNEL);
if (!data)
return -ENOMEM;
data->client = client;
i2c_set_clientdata(client, data);
/* Init queue */
init_waitqueue_head(&data->waitq);
data->hwmon_dev = hwmon_device_register(&client->dev);
if (IS_ERR(data->hwmon_dev)) {
dev_err(&client->dev, "hwmon register failed!\n");
ret = PTR_ERR(data->hwmon_dev);
goto error_rm_dev_sysfs;
}
/*input poll device register */
data->poll_dev = input_allocate_polled_device();
if (!data->poll_dev) {
dev_err(&client->dev, "alloc poll device failed!\n");
ret = -ENOMEM;
goto error_rm_hwmon_dev;
}
data->poll_dev->poll = mag3110_dev_poll;
data->poll_dev->poll_interval = POLL_INTERVAL;
data->poll_dev->poll_interval_max = POLL_INTERVAL_MAX;
idev = data->poll_dev->input;
idev->name = MAG3110_DRV_NAME;
idev->id.bustype = BUS_I2C;
idev->evbit[0] = BIT_MASK(EV_ABS);
input_set_abs_params(idev, ABS_X, -15000, 15000, 0, 0);
input_set_abs_params(idev, ABS_Y, -15000, 15000, 0, 0);
input_set_abs_params(idev, ABS_Z, -15000, 15000, 0, 0);
ret = input_register_polled_device(data->poll_dev);
if (ret) {
dev_err(&client->dev, "register poll device failed!\n");
goto error_free_poll_dev;
}
/*create device group in sysfs as user interface */
ret = sysfs_create_group(&idev->dev.kobj, &mag3110_attr_group);
if (ret) {
dev_err(&client->dev, "create device file failed!\n");
ret = -EINVAL;
goto error_rm_poll_dev;
}
/* set irq type to edge rising */
#if MAG3110_IRQ_USED
ret = request_irq(client->irq, mag3110_irq_handler,
IRQF_TRIGGER_RISING, client->dev.driver->name, idev);
if (ret < 0) {
dev_err(&client->dev, "failed to register irq %d!\n",
client->irq);
goto error_rm_dev_sysfs;
}
#endif
/* Initialize mag3110 chip */
mag3110_init_client(client);
mag3110_pdata = data;
mag3110_pdata->active = MAG_STANDBY;
mag3110_pdata->position = *(int *)client->dev.platform_data;
dev_info(&client->dev, "mag3110 is probed\n");
return 0;
error_rm_dev_sysfs:
sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group);
error_rm_poll_dev:
input_unregister_polled_device(data->poll_dev);
error_free_poll_dev:
input_free_polled_device(data->poll_dev);
error_rm_hwmon_dev:
hwmon_device_unregister(data->hwmon_dev);
kfree(data);
mag3110_pdata = NULL;
return ret;
}
static int stmp3xxx_rotdec_probe(struct platform_device *pdev)
{
int rc = 0;
/* save original state of HW_TIMROT_ROTCTRL */
rotctrl = HW_TIMROT_ROTCTRL_RD();
if (!(rotctrl & BM_TIMROT_ROTCTRL_ROTARY_PRESENT)) {
dev_info(&pdev->dev, "No rotary decoder present\n");
rc = -ENODEV;
goto err_rotdec_present;
} else {
/* I had to add some extra line breaks in here
* to avoid lines >80 chars wide
*/
HW_TIMROT_ROTCTRL_WR(
//BF_TIMROT_ROTCTRL_DIVIDER(0x0) | /* 32kHz divider - 1 */
BF_TIMROT_ROTCTRL_DIVIDER(0x0F) | /* 32/(15+1) = 2kHz sampling */
BF_TIMROT_ROTCTRL_OVERSAMPLE(
BV_TIMROT_ROTCTRL_OVERSAMPLE__2X) |
BF_TIMROT_ROTCTRL_SELECT_B(
BV_TIMROT_ROTCTRL_SELECT_B__ROTARYB) |
BF_TIMROT_ROTCTRL_SELECT_A(
BV_TIMROT_ROTCTRL_SELECT_A__ROTARYA)
);
HW_TIMROT_ROTCTRL_CLR(
BM_TIMROT_ROTCTRL_POLARITY_B |
BM_TIMROT_ROTCTRL_POLARITY_A
);
if (!absolute)
HW_TIMROT_ROTCTRL_SET(BM_TIMROT_ROTCTRL_RELATIVE);
else
HW_TIMROT_ROTCTRL_CLR(BM_TIMROT_ROTCTRL_RELATIVE);
rc = rotdec_pinmux_request();
if (rc) {
dev_err(&pdev->dev,
"Pin request failed (err=%d)\n", rc);
goto err_pinmux;
}
/* set up input_polled_dev */
rotdec = input_allocate_polled_device();
if (!rotdec) {
dev_err(&pdev->dev,
"Unable to allocate polled device\n");
rc = -ENOMEM;
goto err_alloc_polldev;
}
rotdec->flush = stmp3xxx_rotdec_flush;
rotdec->poll = stmp3xxx_rotdec_poll;
rotdec->poll_interval = poll_interval; /* msec */
rotdec->input->name = "stmp3xxx-rotdec";
if (!absolute)
input_set_capability(rotdec->input, EV_REL, REL_WHEEL);
else {
input_set_capability(rotdec->input, EV_ABS, ABS_WHEEL);
input_set_abs_params(rotdec->input, ABS_WHEEL,
-32768, 32767, 0, 0);
}
rc = input_register_polled_device(rotdec);
if (rc) {
dev_err(&pdev->dev,
"Unable to register rotary decoder (err=%d)\n",
rc);
goto err_reg_polldev;
}
previous_state = (HW_TIMROT_ROTCTRL_RD()&BM_TIMROT_ROTCTRL_STATE)>>BP_TIMROT_ROTCTRL_STATE;
}
return 0;
err_reg_polldev:
input_free_polled_device(rotdec);
err_alloc_polldev:
rotdec_pinmux_free();
err_pinmux:
/* restore original register state */
HW_TIMROT_ROTCTRL_WR(rotctrl);
err_rotdec_present:
return rc;
}
