static ssize_t rmi_f09_host_test_enable_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *data;
unsigned int new_value;
int result;
fc = to_rmi_function_container(dev);
data = fc->data;
if (sscanf(buf, "%u", &new_value) != 1) {
dev_err(dev,
"%s: Error - hostTestEnable has an invalid length.\n",
__func__);
return -EINVAL;
}
if (new_value < 0 || new_value > 1) {
dev_err(dev, "%s: Invalid hostTestEnable bit %s.",
__func__, buf);
return -EINVAL;
}
data->query.host_test_enable = new_value;
result = rmi_write(fc->rmi_dev, fc->fd.query_base_addr,
data->query.host_test_enable);
if (result < 0) {
dev_err(dev, "%s: Could not write hostTestEnable to 0x%x\n",
__func__, fc->fd.query_base_addr);
return result;
}
return count;
}
static ssize_t rmi_f09_run_bist_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *data;
unsigned int new_value;
int result;
fc = to_rmi_function_container(dev);
data = fc->data;
if (sscanf(buf, "%u", &new_value) != 1) {
dev_err(dev,
"%s: Error - run_bist_store has an "
"invalid len.\n",
__func__);
return -EINVAL;
}
if (new_value < 0 || new_value > 1) {
dev_err(dev, "%s: Invalid run_bist bit %s.", __func__, buf);
return -EINVAL;
}
data->cmd.run_bist = new_value;
result = rmi_write(fc->rmi_dev, fc->fd.command_base_addr,
data->cmd.run_bist);
if (result < 0) {
dev_err(dev, "%s : Could not write run_bist_store to 0x%x\n",
__func__, fc->fd.command_base_addr);
return result;
}
return count;
}
static ssize_t f17_rezero_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
struct rmi_function_container *fc;
struct rmi_f17_device_data *data;
unsigned int new_value;
int len;
fc = to_rmi_function_container(dev);
data = fc->data;
len = sscanf(buf, "%u", &new_value);
if (new_value != 0 && new_value != 1) {
dev_err(dev,
"%s: Error - rezero is not a valid value 0x%x.\n",
__func__, new_value);
return -EINVAL;
}
data->commands.rezero = new_value;
len = rmi_write(fc->rmi_dev, fc->fd.command_base_addr,
data->commands.rezero);
if (len < 0) {
dev_err(dev, "%s : Could not write rezero to 0x%x\n",
__func__, fc->fd.command_base_addr);
return -EINVAL;
}
return count;
}
static ssize_t rmi_fn_21_rezero_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count) {
unsigned long val;
int error, result;
struct rmi_function_container *fc;
struct rmi_fn_21_data *f21;
struct rmi_driver *driver;
u8 command;
fc = to_rmi_function_container(dev);
f21 = fc->data;
driver = fc->rmi_dev->driver;
/* need to convert the string data to an actual value */
error = strict_strtoul(buf, 10, &val);
if (error)
return error;
/* Do nothing if not set to 1. This prevents accidental commands. */
if (val != 1)
return count;
command = (unsigned char)F21_REZERO_CMD;
/* Write the command to the command register */
result = rmi_write_block(fc->rmi_dev, fc->fd.command_base_addr,
&command, 1);
if (result < 0) {
dev_err(dev, "%s : Could not write command to 0x%x\n",
__func__, fc->fd.command_base_addr);
return result;
}
return count;
}
static ssize_t rmi_fn_05_no_auto_cal_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct f05_data *data = NULL;
unsigned long new_value;
int retval;
struct rmi_function_container *fn_dev = to_rmi_function_container(dev);
data = fn_dev->data;
retval = strict_strtoul(buf, 10, &new_value);
if (retval < 0 || new_value > 1) {
dev_err(dev, "%s: Invalid no auto cal bit %s.", __func__, buf);
return -EINVAL;
}
data->dev_control.no_auto_cal = new_value;
retval = rmi_write_block(fn_dev->rmi_dev, fn_dev->fd.control_base_addr,
(u8 *) &data->dev_control, sizeof(data->dev_control));
if (retval >= 0)
retval = count;
else
dev_err(dev, "Failed to write no auto cal bit, code: %d.\n",
retval);
return retval;
}
static ssize_t rmi_f09_control_test2_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *data;
unsigned int new_low, new_high, new_diff;
int result;
fc = to_rmi_function_container(dev);
data = fc->data;
if (sscanf(buf, "%u %u %u", &new_low, &new_high, &new_diff) != 3) {
dev_err(dev,
"%s: Error - f09_control_test1_store has an "
"invalid len.\n",
__func__);
return -EINVAL;
}
if (new_low < 0 || new_low > 1 || new_high < 0 || new_high > 1 ||
new_diff < 0 || new_diff > 1) {
dev_err(dev, "%s: Invalid f09_control_test2_diff bit %s.",
__func__, buf);
return -EINVAL;
}
data->control.test2_limit_low = new_low;
data->control.test2_limit_high = new_high;
data->control.test2_limit_diff = new_diff;
result = rmi_write(fc->rmi_dev, fc->fd.control_base_addr,
data->control.test2_limit_low);
if (result < 0) {
dev_err(dev, "%s : Could not write f09_control_test2_limit_low to 0x%x\n",
__func__, fc->fd.control_base_addr);
return result;
}
result = rmi_write(fc->rmi_dev, fc->fd.control_base_addr,
data->control.test2_limit_high);
if (result < 0) {
dev_err(dev, "%s : Could not write f09_control_test2_limit_high to 0x%x\n",
__func__, fc->fd.control_base_addr);
return result;
}
result = rmi_write(fc->rmi_dev, fc->fd.control_base_addr,
data->control.test2_limit_diff);
if (result < 0) {
dev_err(dev, "%s : Could not write f09_control_test2_limit_diff to 0x%x\n",
__func__, fc->fd.control_base_addr);
return result;
}
return count;
}
static ssize_t rmi_f09_overall_bist_result_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *data;
fc = to_rmi_function_container(dev);
data = fc->data;
return snprintf(buf, PAGE_SIZE, "%u\n",
data->data.overall_bist_result);
}
static ssize_t rmi_f09_internal_limits_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *data;
fc = to_rmi_function_container(dev);
data = fc->data;
return snprintf(buf, PAGE_SIZE, "%u\n",
data->query.internal_limits);
}
static ssize_t rmi_f09_test_number_control_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *data;
fc = to_rmi_function_container(dev);
data = fc->data;
return snprintf(buf, PAGE_SIZE, "%u\n",
data->data.test_number_control);
}
static ssize_t rmi_f09_status_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *instance_data;
fc = to_rmi_function_container(dev);
instance_data = fc->data;
return snprintf(buf, PAGE_SIZE, "%d\n", instance_data->status);
}
static ssize_t rmi_fn_05_no_auto_cal_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct f05_data *data = NULL;
struct rmi_function_container *fn_dev = to_rmi_function_container(dev);
data = fn_dev->data;
return snprintf(buf, PAGE_SIZE,
"%d\n", data->dev_control.no_auto_cal);
}
static ssize_t rmi_fn_05_image_window_size_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct f05_data *data = NULL;
struct rmi_function_container *fn_dev = to_rmi_function_container(dev);
data = fn_dev->data;
return snprintf(buf, PAGE_SIZE, "%d\n",
data->dev_query.size_f05_image_window);
}
static ssize_t rmi_fn_05_has_delta16_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct f05_data *data = NULL;
struct rmi_function_container *fn_dev = to_rmi_function_container(dev);
data = fn_dev->data;
return snprintf(buf, PAGE_SIZE, "%d\n",
data->dev_query.has16_bit_delta);
}
static ssize_t rmi_fn_05_num_of_tx_electrodes_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct f05_data *data = NULL;
struct rmi_function_container *fn_dev = to_rmi_function_container(dev);
data = fn_dev->data;
return snprintf(buf, PAGE_SIZE, "0x%x\n",
data->dev_query.num_of_tx_electrodes);
}
static ssize_t rmi_f09_control_test2_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *data;
fc = to_rmi_function_container(dev);
data = fc->data;
return snprintf(buf, PAGE_SIZE, "%u %u %u\n",
data->control.test2_limit_low,
data->control.test2_limit_high,
data->control.test2_limit_diff);
}
static ssize_t f17_rezero_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct rmi_function_container *fc;
struct rmi_f17_device_data *f17;
fc = to_rmi_function_container(dev);
f17 = fc->data;
return snprintf(buf, PAGE_SIZE, "%u\n",
f17->commands.rezero);
}
static ssize_t rmi_f09_status_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct rmi_function_container *fc;
struct rmi_fn_09_data *instance_data;
fc = to_rmi_function_container(dev);
instance_data = fc->data;
/* any write to status resets 1 */
instance_data->status = 0;
return 0;
}
static __devinit int f05_probe(struct device *dev)
{
struct rmi_function_container *fc;
if (dev->type != &rmi_function_type) {
dev_dbg(dev, "Not a function device.\n");
return 1;
}
fc = to_rmi_function_container(dev);
if (fc->fd.function_number != 0x05) {
dev_dbg(dev, "Device is F%02X, not F%02X.\n",
fc->fd.function_number, 0x05);
return -ENXIO;
}
return rmi_f05_probe(fc);
}
/* Data */
static ssize_t rmi_fn_21_force_show(struct device *dev,
struct device_attribute *attr,
char *buf) {
struct rmi_function_container *fc;
struct FUNCTION_DATA *data;
int reg_length;
int result, size = 0;
char *temp;
int i;
fc = to_rmi_function_container(dev);
data = fc->data;
/* Read current regtype values */
reg_length = data->query.max_force_sensor_count;
result = rmi_read_block(fc->rmi_dev, data->data.reg_0__1.address,
data->data.reg_0__1.force_hi_lo,
2 * reg_length * sizeof(u8));
if (result < 0) {
dev_err(dev, "Could not read regtype at %#06x. Data may be outdated.",
data->data.reg_0__1.address);
}
temp = buf;
for (i = 0; i < reg_length; i++) {
result = snprintf(temp, PAGE_SIZE - size, "%d ",
data->data.reg_0__1.force_hi_lo[i] * (2 << 3)
+ data->data.reg_0__1.force_hi_lo[i + reg_length]);
if (result < 0) {
dev_err(dev, "%s : Could not write output.", __func__);
return result;
}
size += result;
temp += result;
}
result = snprintf(temp, PAGE_SIZE - size, "\n");
if (result < 0) {
dev_err(dev, "%s : Could not write output.", __func__);
return result;
}
return size + result;
}
static int f05_remove_device(struct device *dev)
{
struct rmi_function_container *fc = to_rmi_function_container(dev);
return rmi_f05_remove(fc);
}
