![Javier Martinez Canillas](/assets/img/avatar_default.png)
The I2C core always reports the MODALIAS uevent as "i2c:<client name" regardless if the driver was matched using the I2C id_table or the of_match_table. So technically there's no need for a driver to export the OF table since currently it's not used. In fact, the I2C device ID table is mandatory for I2C drivers since a i2c_device_id is passed to the driver's probe function even if the I2C core used the OF table to match the driver. And since the I2C core uses different tables, OF-only drivers needs to have duplicated data that has to be kept in sync and also the dev node compatible manufacturer prefix is stripped when reporting the MODALIAS. To avoid the above, the I2C core behavior may be changed in the future to not require an I2C device table for OF-only drivers and report the OF module alias. So, it's better to also export the OF table to prevent breaking module autoloading if that happens. Signed-off-by: Javier Martinez Canillas <javier@osg.samsung.com> Signed-off-by: Jonathan Cameron <jic23@kernel.org>
440 lines
11 KiB
C
440 lines
11 KiB
C
/*
|
|
* CM3232 Ambient Light Sensor
|
|
*
|
|
* Copyright (C) 2014-2015 Capella Microsystems Inc.
|
|
* Author: Kevin Tsai <ktsai@capellamicro.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2, as published
|
|
* by the Free Software Foundation.
|
|
*
|
|
* IIO driver for CM3232 (7-bit I2C slave address 0x10).
|
|
*/
|
|
|
|
#include <linux/i2c.h>
|
|
#include <linux/module.h>
|
|
#include <linux/iio/iio.h>
|
|
#include <linux/iio/sysfs.h>
|
|
#include <linux/init.h>
|
|
|
|
/* Registers Address */
|
|
#define CM3232_REG_ADDR_CMD 0x00
|
|
#define CM3232_REG_ADDR_ALS 0x50
|
|
#define CM3232_REG_ADDR_ID 0x53
|
|
|
|
#define CM3232_CMD_ALS_DISABLE BIT(0)
|
|
|
|
#define CM3232_CMD_ALS_IT_SHIFT 2
|
|
#define CM3232_CMD_ALS_IT_MASK (BIT(2) | BIT(3) | BIT(4))
|
|
#define CM3232_CMD_ALS_IT_DEFAULT (0x01 << CM3232_CMD_ALS_IT_SHIFT)
|
|
|
|
#define CM3232_CMD_ALS_RESET BIT(6)
|
|
|
|
#define CM3232_CMD_DEFAULT CM3232_CMD_ALS_IT_DEFAULT
|
|
|
|
#define CM3232_HW_ID 0x32
|
|
#define CM3232_CALIBSCALE_DEFAULT 100000
|
|
#define CM3232_CALIBSCALE_RESOLUTION 100000
|
|
#define CM3232_MLUX_PER_LUX 1000
|
|
|
|
#define CM3232_MLUX_PER_BIT_DEFAULT 64
|
|
#define CM3232_MLUX_PER_BIT_BASE_IT 100000
|
|
|
|
static const struct {
|
|
int val;
|
|
int val2;
|
|
u8 it;
|
|
} cm3232_als_it_scales[] = {
|
|
{0, 100000, 0}, /* 0.100000 */
|
|
{0, 200000, 1}, /* 0.200000 */
|
|
{0, 400000, 2}, /* 0.400000 */
|
|
{0, 800000, 3}, /* 0.800000 */
|
|
{1, 600000, 4}, /* 1.600000 */
|
|
{3, 200000, 5}, /* 3.200000 */
|
|
};
|
|
|
|
struct cm3232_als_info {
|
|
u8 regs_cmd_default;
|
|
u8 hw_id;
|
|
int calibscale;
|
|
int mlux_per_bit;
|
|
int mlux_per_bit_base_it;
|
|
};
|
|
|
|
static struct cm3232_als_info cm3232_als_info_default = {
|
|
.regs_cmd_default = CM3232_CMD_DEFAULT,
|
|
.hw_id = CM3232_HW_ID,
|
|
.calibscale = CM3232_CALIBSCALE_DEFAULT,
|
|
.mlux_per_bit = CM3232_MLUX_PER_BIT_DEFAULT,
|
|
.mlux_per_bit_base_it = CM3232_MLUX_PER_BIT_BASE_IT,
|
|
};
|
|
|
|
struct cm3232_chip {
|
|
struct i2c_client *client;
|
|
struct cm3232_als_info *als_info;
|
|
u8 regs_cmd;
|
|
u16 regs_als;
|
|
};
|
|
|
|
/**
|
|
* cm3232_reg_init() - Initialize CM3232
|
|
* @chip: pointer of struct cm3232_chip.
|
|
*
|
|
* Check and initialize CM3232 ambient light sensor.
|
|
*
|
|
* Return: 0 for success; otherwise for error code.
|
|
*/
|
|
static int cm3232_reg_init(struct cm3232_chip *chip)
|
|
{
|
|
struct i2c_client *client = chip->client;
|
|
s32 ret;
|
|
|
|
chip->als_info = &cm3232_als_info_default;
|
|
|
|
/* Identify device */
|
|
ret = i2c_smbus_read_word_data(client, CM3232_REG_ADDR_ID);
|
|
if (ret < 0) {
|
|
dev_err(&chip->client->dev, "Error reading addr_id\n");
|
|
return ret;
|
|
}
|
|
|
|
if ((ret & 0xFF) != chip->als_info->hw_id)
|
|
return -ENODEV;
|
|
|
|
/* Disable and reset device */
|
|
chip->regs_cmd = CM3232_CMD_ALS_DISABLE | CM3232_CMD_ALS_RESET;
|
|
ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
|
|
chip->regs_cmd);
|
|
if (ret < 0) {
|
|
dev_err(&chip->client->dev, "Error writing reg_cmd\n");
|
|
return ret;
|
|
}
|
|
|
|
/* Register default value */
|
|
chip->regs_cmd = chip->als_info->regs_cmd_default;
|
|
|
|
/* Configure register */
|
|
ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
|
|
chip->regs_cmd);
|
|
if (ret < 0)
|
|
dev_err(&chip->client->dev, "Error writing reg_cmd\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* cm3232_read_als_it() - Get sensor integration time
|
|
* @chip: pointer of struct cm3232_chip
|
|
* @val: pointer of int to load the integration (sec).
|
|
* @val2: pointer of int to load the integration time (microsecond).
|
|
*
|
|
* Report the current integration time.
|
|
*
|
|
* Return: IIO_VAL_INT_PLUS_MICRO for success, otherwise -EINVAL.
|
|
*/
|
|
static int cm3232_read_als_it(struct cm3232_chip *chip, int *val, int *val2)
|
|
{
|
|
u16 als_it;
|
|
int i;
|
|
|
|
als_it = chip->regs_cmd;
|
|
als_it &= CM3232_CMD_ALS_IT_MASK;
|
|
als_it >>= CM3232_CMD_ALS_IT_SHIFT;
|
|
for (i = 0; i < ARRAY_SIZE(cm3232_als_it_scales); i++) {
|
|
if (als_it == cm3232_als_it_scales[i].it) {
|
|
*val = cm3232_als_it_scales[i].val;
|
|
*val2 = cm3232_als_it_scales[i].val2;
|
|
return IIO_VAL_INT_PLUS_MICRO;
|
|
}
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
/**
|
|
* cm3232_write_als_it() - Write sensor integration time
|
|
* @chip: pointer of struct cm3232_chip.
|
|
* @val: integration time in second.
|
|
* @val2: integration time in microsecond.
|
|
*
|
|
* Convert integration time to sensor value.
|
|
*
|
|
* Return: i2c_smbus_write_byte_data command return value.
|
|
*/
|
|
static int cm3232_write_als_it(struct cm3232_chip *chip, int val, int val2)
|
|
{
|
|
struct i2c_client *client = chip->client;
|
|
u16 als_it, cmd;
|
|
int i;
|
|
s32 ret;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(cm3232_als_it_scales); i++) {
|
|
if (val == cm3232_als_it_scales[i].val &&
|
|
val2 == cm3232_als_it_scales[i].val2) {
|
|
|
|
als_it = cm3232_als_it_scales[i].it;
|
|
als_it <<= CM3232_CMD_ALS_IT_SHIFT;
|
|
|
|
cmd = chip->regs_cmd & ~CM3232_CMD_ALS_IT_MASK;
|
|
cmd |= als_it;
|
|
ret = i2c_smbus_write_byte_data(client,
|
|
CM3232_REG_ADDR_CMD,
|
|
cmd);
|
|
if (ret < 0)
|
|
return ret;
|
|
chip->regs_cmd = cmd;
|
|
return 0;
|
|
}
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
/**
|
|
* cm3232_get_lux() - report current lux value
|
|
* @chip: pointer of struct cm3232_chip.
|
|
*
|
|
* Convert sensor data to lux. It depends on integration
|
|
* time and calibscale variable.
|
|
*
|
|
* Return: Zero or positive value is lux, otherwise error code.
|
|
*/
|
|
static int cm3232_get_lux(struct cm3232_chip *chip)
|
|
{
|
|
struct i2c_client *client = chip->client;
|
|
struct cm3232_als_info *als_info = chip->als_info;
|
|
int ret;
|
|
int val, val2;
|
|
int als_it;
|
|
u64 lux;
|
|
|
|
/* Calculate mlux per bit based on als_it */
|
|
ret = cm3232_read_als_it(chip, &val, &val2);
|
|
if (ret < 0)
|
|
return -EINVAL;
|
|
als_it = val * 1000000 + val2;
|
|
lux = (__force u64)als_info->mlux_per_bit;
|
|
lux *= als_info->mlux_per_bit_base_it;
|
|
lux = div_u64(lux, als_it);
|
|
|
|
ret = i2c_smbus_read_word_data(client, CM3232_REG_ADDR_ALS);
|
|
if (ret < 0) {
|
|
dev_err(&client->dev, "Error reading reg_addr_als\n");
|
|
return ret;
|
|
}
|
|
|
|
chip->regs_als = (u16)ret;
|
|
lux *= chip->regs_als;
|
|
lux *= als_info->calibscale;
|
|
lux = div_u64(lux, CM3232_CALIBSCALE_RESOLUTION);
|
|
lux = div_u64(lux, CM3232_MLUX_PER_LUX);
|
|
|
|
if (lux > 0xFFFF)
|
|
lux = 0xFFFF;
|
|
|
|
return (int)lux;
|
|
}
|
|
|
|
static int cm3232_read_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan,
|
|
int *val, int *val2, long mask)
|
|
{
|
|
struct cm3232_chip *chip = iio_priv(indio_dev);
|
|
struct cm3232_als_info *als_info = chip->als_info;
|
|
int ret;
|
|
|
|
switch (mask) {
|
|
case IIO_CHAN_INFO_PROCESSED:
|
|
ret = cm3232_get_lux(chip);
|
|
if (ret < 0)
|
|
return ret;
|
|
*val = ret;
|
|
return IIO_VAL_INT;
|
|
case IIO_CHAN_INFO_CALIBSCALE:
|
|
*val = als_info->calibscale;
|
|
return IIO_VAL_INT;
|
|
case IIO_CHAN_INFO_INT_TIME:
|
|
return cm3232_read_als_it(chip, val, val2);
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int cm3232_write_raw(struct iio_dev *indio_dev,
|
|
struct iio_chan_spec const *chan,
|
|
int val, int val2, long mask)
|
|
{
|
|
struct cm3232_chip *chip = iio_priv(indio_dev);
|
|
struct cm3232_als_info *als_info = chip->als_info;
|
|
|
|
switch (mask) {
|
|
case IIO_CHAN_INFO_CALIBSCALE:
|
|
als_info->calibscale = val;
|
|
return 0;
|
|
case IIO_CHAN_INFO_INT_TIME:
|
|
return cm3232_write_als_it(chip, val, val2);
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
/**
|
|
* cm3232_get_it_available() - Get available ALS IT value
|
|
* @dev: pointer of struct device.
|
|
* @attr: pointer of struct device_attribute.
|
|
* @buf: pointer of return string buffer.
|
|
*
|
|
* Display the available integration time in second.
|
|
*
|
|
* Return: string length.
|
|
*/
|
|
static ssize_t cm3232_get_it_available(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int i, len;
|
|
|
|
for (i = 0, len = 0; i < ARRAY_SIZE(cm3232_als_it_scales); i++)
|
|
len += scnprintf(buf + len, PAGE_SIZE - len, "%u.%06u ",
|
|
cm3232_als_it_scales[i].val,
|
|
cm3232_als_it_scales[i].val2);
|
|
return len + scnprintf(buf + len, PAGE_SIZE - len, "\n");
|
|
}
|
|
|
|
static const struct iio_chan_spec cm3232_channels[] = {
|
|
{
|
|
.type = IIO_LIGHT,
|
|
.info_mask_separate =
|
|
BIT(IIO_CHAN_INFO_PROCESSED) |
|
|
BIT(IIO_CHAN_INFO_CALIBSCALE) |
|
|
BIT(IIO_CHAN_INFO_INT_TIME),
|
|
}
|
|
};
|
|
|
|
static IIO_DEVICE_ATTR(in_illuminance_integration_time_available,
|
|
S_IRUGO, cm3232_get_it_available, NULL, 0);
|
|
|
|
static struct attribute *cm3232_attributes[] = {
|
|
&iio_dev_attr_in_illuminance_integration_time_available.dev_attr.attr,
|
|
NULL,
|
|
};
|
|
|
|
static const struct attribute_group cm3232_attribute_group = {
|
|
.attrs = cm3232_attributes
|
|
};
|
|
|
|
static const struct iio_info cm3232_info = {
|
|
.driver_module = THIS_MODULE,
|
|
.read_raw = &cm3232_read_raw,
|
|
.write_raw = &cm3232_write_raw,
|
|
.attrs = &cm3232_attribute_group,
|
|
};
|
|
|
|
static int cm3232_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
struct cm3232_chip *chip;
|
|
struct iio_dev *indio_dev;
|
|
int ret;
|
|
|
|
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
|
|
if (!indio_dev)
|
|
return -ENOMEM;
|
|
|
|
chip = iio_priv(indio_dev);
|
|
i2c_set_clientdata(client, indio_dev);
|
|
chip->client = client;
|
|
|
|
indio_dev->dev.parent = &client->dev;
|
|
indio_dev->channels = cm3232_channels;
|
|
indio_dev->num_channels = ARRAY_SIZE(cm3232_channels);
|
|
indio_dev->info = &cm3232_info;
|
|
indio_dev->name = id->name;
|
|
indio_dev->modes = INDIO_DIRECT_MODE;
|
|
|
|
ret = cm3232_reg_init(chip);
|
|
if (ret) {
|
|
dev_err(&client->dev,
|
|
"%s: register init failed\n",
|
|
__func__);
|
|
return ret;
|
|
}
|
|
|
|
return iio_device_register(indio_dev);
|
|
}
|
|
|
|
static int cm3232_remove(struct i2c_client *client)
|
|
{
|
|
struct iio_dev *indio_dev = i2c_get_clientdata(client);
|
|
|
|
i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
|
|
CM3232_CMD_ALS_DISABLE);
|
|
|
|
iio_device_unregister(indio_dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct i2c_device_id cm3232_id[] = {
|
|
{"cm3232", 0},
|
|
{}
|
|
};
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static int cm3232_suspend(struct device *dev)
|
|
{
|
|
struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
|
|
struct cm3232_chip *chip = iio_priv(indio_dev);
|
|
struct i2c_client *client = chip->client;
|
|
int ret;
|
|
|
|
chip->regs_cmd |= CM3232_CMD_ALS_DISABLE;
|
|
ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
|
|
chip->regs_cmd);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int cm3232_resume(struct device *dev)
|
|
{
|
|
struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
|
|
struct cm3232_chip *chip = iio_priv(indio_dev);
|
|
struct i2c_client *client = chip->client;
|
|
int ret;
|
|
|
|
chip->regs_cmd &= ~CM3232_CMD_ALS_DISABLE;
|
|
ret = i2c_smbus_write_byte_data(client, CM3232_REG_ADDR_CMD,
|
|
chip->regs_cmd | CM3232_CMD_ALS_RESET);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const struct dev_pm_ops cm3232_pm_ops = {
|
|
SET_SYSTEM_SLEEP_PM_OPS(cm3232_suspend, cm3232_resume)};
|
|
#endif
|
|
|
|
MODULE_DEVICE_TABLE(i2c, cm3232_id);
|
|
|
|
static const struct of_device_id cm3232_of_match[] = {
|
|
{.compatible = "capella,cm3232"},
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(of, cm3232_of_match);
|
|
|
|
static struct i2c_driver cm3232_driver = {
|
|
.driver = {
|
|
.name = "cm3232",
|
|
.of_match_table = of_match_ptr(cm3232_of_match),
|
|
#ifdef CONFIG_PM_SLEEP
|
|
.pm = &cm3232_pm_ops,
|
|
#endif
|
|
},
|
|
.id_table = cm3232_id,
|
|
.probe = cm3232_probe,
|
|
.remove = cm3232_remove,
|
|
};
|
|
|
|
module_i2c_driver(cm3232_driver);
|
|
|
|
MODULE_AUTHOR("Kevin Tsai <ktsai@capellamicro.com>");
|
|
MODULE_DESCRIPTION("CM3232 ambient light sensor driver");
|
|
MODULE_LICENSE("GPL");
|