static int f17_config(struct rmi_function_container *fc)
{
struct rmi_f17_device_data *f17 = fc->data;
int retval;
int i;
retval = rmi_write_block(fc->rmi_dev, f17->control_address,
f17->controls.regs, sizeof(f17->controls.regs));
if (retval < 0) {
dev_err(&fc->dev, "Could not write stick controls to 0x%04x\n",
f17->control_address);
return retval;
}
#if 0
if (f17->query.has_relative) {
retval = rmi_write_block(fc->rmi_dev,
f17->relative_control_address,
f17->controls.relative.regs,
sizeof(f17->controls.relative.regs));
if (retval < 0) {
dev_err(&fc->dev, "Could not write stick controls to 0x%04x\n",
f17->control_address);
return retval;
}
}
#endif
for (i = 0; i < f17->query.number_of_sticks + 1; i++) {
// TODO: Configure each styk
}
return retval;
}
/** Request the next report from the sensor.
*/
static int request_next_report(struct f05_data *f05) {
int retval = 0;
mutex_lock(&f05->status_mutex);
if (f05->status != F05_STATE_RUN) {
dev_err(&f05->fn_dev->dev, "ERROR: Can't request report in state %d.\n",
f05->status);
retval = -EIO;
goto exit_unlock;
}
f05->dev_command.force_zero = 0;
f05->dev_command.get_image = 1;
retval = rmi_write_block(f05->fn_dev->rmi_dev,
f05->fn_dev->fd.command_base_addr,
(u8 *) &f05->dev_command, sizeof(f05->dev_command));
if (retval < 0) {
dev_err(&f05->fn_dev->dev, "ERROR: Failed to request report, code: %d.\n",
retval);
set_status(f05, F05_STATE_ERROR);
goto exit_unlock;
}
set_status(f05, F05_STATE_PENDING);
exit_unlock:
mutex_unlock(&f05->status_mutex);
return retval;
}
/*
* rmidev_write: - use to write data into RMI stream
*
* @filep : file structure for write
* @buf: user-level buffer pointer contains data to be written
* @count: number of byte be be written
* @f_pos: offset (starting register address)
*
* @return number of bytes written from user buffer (buf) if succeeds
* negative number if error occurs.
*/
static ssize_t rmidev_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos)
{
struct rmidev_data *data = filp->private_data;
ssize_t retval = 0;
unsigned char tmpbuf[count+1];
/* limit offset to REG_ADDR_LIMIT-1 */
if (count > (REG_ADDR_LIMIT - *f_pos))
count = REG_ADDR_LIMIT - *f_pos;
if (count == 0)
return 0;
if (IS_ERR(data)) {
pr_err("%s: pointer of char device is invalid", __func__);
return -EBADF;
}
if (copy_from_user(tmpbuf, buf, count))
return -EFAULT;
mutex_lock(&(data->file_mutex));
retval = rmi_write_block(data->rmi_dev, *f_pos, tmpbuf, count);
if (retval >= 0)
*f_pos += count;
mutex_unlock(&(data->file_mutex));
return retval;
}
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 int rmi_f34_write_bootloader_id(struct f34_data *f34)
{
struct rmi_function *fn = f34->fn;
struct rmi_device *rmi_dev = fn->rmi_dev;
u8 bootloader_id[F34_BOOTLOADER_ID_LEN];
int ret;
ret = rmi_read_block(rmi_dev, fn->fd.query_base_addr,
bootloader_id, sizeof(bootloader_id));
if (ret) {
dev_err(&fn->dev, "%s: Reading bootloader ID failed: %d\n",
__func__, ret);
return ret;
}
rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: writing bootloader id '%c%c'\n",
__func__, bootloader_id[0], bootloader_id[1]);
ret = rmi_write_block(rmi_dev,
fn->fd.data_base_addr + F34_BLOCK_DATA_OFFSET,
bootloader_id, sizeof(bootloader_id));
if (ret) {
dev_err(&fn->dev, "Failed to write bootloader ID: %d\n", ret);
return ret;
}
return 0;
}
static int rmi_f30_gpio_data_direction_in(struct gpio_chip *gc,
unsigned gpio_num)
{
//When switching a pin's direction from output to input, write 0 to DirN
//followed by writing 1 to DataN to force pull up
//nneds to check data setting accuracy.
struct rmi_function *fn = container_of(gc,
struct rmi_fn_30_data, gpio);
struct rmi_fn_30_data *f30 = fn->data;
struct f30_control *control = &f30->control;
struct rmi_device *rmi_dev = fn->rmi_dev;
f30->gpioled_count = f30->query.gpio_led_count;
u8 reg = sizeof(u8)*(f30->gpioled_count + 7) / 8;
u8 mask = 1 << (gpio_num % 8);
int bit_no = gpio_num % 8;
int retval;
mutex_lock(&f30->gpio_mutex);
//Need to set dirN bit of the ctrl_reg2_dirN
retval = rmi_write_block(rmi_dev, control->reg_2->address,
(u8 *)control->reg_2->regs, control->reg_2->length);
set_bit(gpio_num, control->reg_2->address+reg);
//how about setting ctrl_reg2_dataN?
rmi_f30_gpio_data_set(gc, gpio_num, 1);
mutex_unlock(&f30->gpio_mutex);
return 0;
}
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_dev *fn_dev;
struct rmi_fn_21_data *f21;
struct rmi_driver *driver;
u8 command;
fn_dev = to_rmi_function_dev(dev);
f21 = fn_dev->data;
driver = fn_dev->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 = F21_REZERO_CMD;
/* Write the command to the command register */
result = rmi_write_block(fn_dev->rmi_dev, fn_dev->fd.command_base_addr,
&command, 1);
if (result < 0) {
dev_err(dev, "%s : Could not write command to 0x%x\n",
__func__, fn_dev->fd.command_base_addr);
return result;
}
return count;
}
static int rmi_f34_write_blocks(struct f34_data *f34, const void *data,
int block_count, u8 command)
{
struct rmi_function *fn = f34->fn;
struct rmi_device *rmi_dev = fn->rmi_dev;
u16 address = fn->fd.data_base_addr + F34_BLOCK_DATA_OFFSET;
u8 start_address[] = { 0, 0 };
int i;
int ret;
ret = rmi_write_block(rmi_dev, fn->fd.data_base_addr,
start_address, sizeof(start_address));
if (ret) {
dev_err(&fn->dev, "Failed to write initial zeros: %d\n", ret);
return ret;
}
for (i = 0; i < block_count; i++) {
ret = rmi_write_block(rmi_dev, address,
data, f34->v5.block_size);
if (ret) {
dev_err(&fn->dev,
"failed to write block #%d: %d\n", i, ret);
return ret;
}
ret = rmi_f34_command(f34, command, F34_IDLE_WAIT_MS, false);
if (ret) {
dev_err(&fn->dev,
"Failed to write command for block #%d: %d\n",
i, ret);
return ret;
}
rmi_dbg(RMI_DEBUG_FN, &fn->dev, "wrote block %d of %d\n",
i + 1, block_count);
data += f34->v5.block_size;
f34->update_progress += f34->v5.block_size;
f34->update_status = (f34->update_progress * 100) /
f34->update_size;
}
return 0;
}
static int do_set_report_mode(struct f05_data *f05, u8 report_mode)
{
struct rmi_function_container *fn_dev = f05->fn_dev;
int report_size;
u8 row_size;
int retval;
switch (report_mode) {
/* this is baseline capacitance image data */
case 1:
row_size = f05->dev_query.num_of_rx_electrodes * 2;
break;
/* this is delta image data */
case 2:
if (f05->dev_query.has16_bit_delta == 0)
row_size = f05->dev_query.num_of_rx_electrodes;
else
row_size = f05->dev_query.num_of_rx_electrodes * 2;
break;
default:
dev_err(&fn_dev->dev, "%s: Report mode %d is unrecognized.\n",
__func__, report_mode);
return -EINVAL;
}
report_size = row_size * f05->dev_query.num_of_tx_electrodes;
mutex_lock(&f05->status_mutex);
if (f05->status == F05_STATE_READY) {
f05->data_ready = false;
f05->dev_data.report_mode = report_mode;
f05->report_size = report_size;
f05->row_size = row_size;
retval = rmi_write_block(fn_dev->rmi_dev,
fn_dev->fd.data_base_addr,
(u8 *) &f05->dev_data,
sizeof(f05->dev_data));
if (retval < 0)
dev_err(&fn_dev->dev, "%s: Could not write report mode %d, code: %d.\n",
__func__, report_mode, retval);
} else {
dev_err(&fn_dev->dev, "%s: Report type cannot change in state %d.\n",
__func__, f05->status);
retval = -EINVAL;
}
mutex_unlock(&f05->status_mutex);
return retval;
}
static int f17_config(struct rmi_function_container *fc)
{
struct rmi_f17_device_data *f17 = fc->data;
int retval;
retval = rmi_write_block(fc->rmi_dev, f17->control_address,
f17->controls.regs, sizeof(f17->controls.regs));
if (retval < 0) {
dev_err(&fc->dev, "Could not write stick controls to 0x%04x\n",
f17->control_address);
return retval;
}
return retval;
}
static ssize_t rmi_fn_34_sensorid_pullupmask_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
int error;
unsigned long val;
u8 data[2];
struct rmi_function_dev *fn_dev;
struct rmi_fn_34_data *instance_data;
u16 data_base_addr;
u16 pullup_mask;
fn_dev = to_rmi_function_dev(dev);
instance_data = fn_dev->data;
data_base_addr = fn_dev->fd.data_base_addr;
if (!instance_data->inflashprogmode) {
dev_err(dev, "Cannot set mask to sensor - not in flash programming mode.\n");
return -EINVAL;
}
/* need to convert the string data to an actual value */
error = strict_strtoul(buf, 10, &val);
if (error)
return error;
pullup_mask = val;
/* Write the Block Number data back to the first two Block
* Data registers (F34_Flash_Data_0 and F34_Flash_Data_1). */
hstoba(data, (u16)val);
error = rmi_write_block(fn_dev->rmi_dev, data_base_addr + 2,
data, ARRAY_SIZE(data));
if (error < 0) {
dev_err(dev, "Could not write snesor id pin mask%u to %#06x.\n",
pullup_mask, data_base_addr);
return error;
}
return count;
}
/*
* rmidev_write: - use to write data into RMI stream
*
* @filep : file structure for write
* @buf: user-level buffer pointer contains data to be written
* @count: number of byte be be written
* @f_pos: offset (starting register address)
*
* @return number of bytes written from user buffer (buf) if succeeds
* negative number if error occurs.
*/
static ssize_t rmidev_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos)
{
struct rmidev_data *data = filp->private_data;
ssize_t retval = 0;
unsigned char tmpbuf[RMI_CHAR_DEV_TMPBUF_SZ];
if (*f_pos > REG_ADDR_LIMIT) {
retval = -EINVAL;
goto exit;
}
/* limit offset to REG_ADDR_LIMIT-1 */
if (count > (REG_ADDR_LIMIT - *f_pos))
count = REG_ADDR_LIMIT - *f_pos;
if (count > RMI_CHAR_DEV_TMPBUF_SZ)
count = RMI_CHAR_DEV_TMPBUF_SZ;
if (count == 0)
goto exit;
if (IS_ERR(data)) {
pr_err("%s: pointer of char device is invalid", __func__);
retval = -EBADF;
goto exit;
}
if (copy_from_user(tmpbuf, buf, count)) {
retval = -EFAULT;
goto exit;
}
mutex_lock(&(data->file_mutex));
retval = rmi_write_block(data, *f_pos, tmpbuf, count);
if (retval >= 0)
*f_pos += count;
mutex_unlock(&(data->file_mutex));
exit:
return retval;
}
static void do_stop(struct f05_data *f05)
{
struct rmi_function_container *fn_dev = f05->fn_dev;
struct rmi_driver *driver = fn_dev->rmi_dev->driver;
struct rmi_driver_data *driver_data;
struct rmi_device_platform_data *pdata;
struct rmi_function_container *f01_dev;
int retval;
driver_data = dev_get_drvdata(&fn_dev->rmi_dev->dev);
pdata = to_rmi_platform_data(fn_dev->rmi_dev);
f01_dev = driver_data->f01_container;
mutex_lock(&f05->status_mutex);
if (f05->status == F05_STATE_IDLE) {
mutex_unlock(&f05->status_mutex);
return;
}
set_status(f05, F05_STATE_IDLE);
f05->data_ready = false;
f05->dev_data.report_mode = 0;
/* Write 0 to the Report Mode back to the first Block
* Data registers. */
retval = rmi_write_block(fn_dev->rmi_dev, fn_dev->fd.data_base_addr,
(u8 *) &f05->dev_data, sizeof(f05->dev_data));
if (retval < 0) {
dev_warn(&fn_dev->dev, "%s : Could not write report mode to 0x%x\n",
__func__, fn_dev->fd.data_base_addr);
}
mutex_unlock(&f05->status_mutex);
driver->restore_irq_mask(fn_dev->rmi_dev);
retval = rmi_write(fn_dev->rmi_dev, f01_dev->fd.command_base_addr,
F01_RESET_MASK);
if (retval < 0)
dev_warn(&fn_dev->rmi_dev->dev,
"WARNING - post-F05 reset failed, code: %d.\n",
retval);
msleep(pdata->reset_delay_ms);
}
static ssize_t rmi_fn_34_data_write(struct file *data_file,
struct kobject *kobj,
struct bin_attribute *attributes,
char *buf,
loff_t pos,
size_t count)
{
struct device *dev = container_of(kobj, struct device, kobj);
struct rmi_function_dev *fn_dev;
struct rmi_fn_34_data *instance_data;
u16 data_base_addr;
int error;
fn_dev = to_rmi_function_dev(dev);
instance_data = fn_dev->data;
data_base_addr = fn_dev->fd.data_base_addr;
/* Write the data from buf to flash. The app layer will be
* blocked at writing to the sysfs file. When we return the
* count (or error if we fail) the app will resume. */
if (count != instance_data->blocksize) {
dev_err(dev, "Incorrect F34 block size %d. Expected size %d.\n",
count, instance_data->blocksize);
return -EINVAL;
}
/* Write the data block - only if the count is non-zero */
if (count) {
error = rmi_write_block(fn_dev->rmi_dev,
data_base_addr + BLK_NUM_OFF,
(u8 *)buf, count);
if (error < 0) {
dev_err(dev, "%s : Could not write block data to 0x%x\n",
__func__, data_base_addr + BLK_NUM_OFF);
return error;
}
}
return count;
}
static ssize_t rmi_fn_34_bootloaderid_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
int error;
unsigned long val;
u8 data[2];
struct rmi_function_dev *fn_dev;
struct rmi_fn_34_data *instance_data;
u16 data_base_addr;
fn_dev = to_rmi_function_dev(dev);
instance_data = fn_dev->data;
/* need to convert the string data to an actual value */
error = strict_strtoul(buf, 10, &val);
if (error)
return error;
instance_data->bootloaderid = val;
/* Write the Bootloader ID key data back to the first two Block
* Data registers (F34_Flash_Data2.0 and F34_Flash_Data2.1). */
hstoba(data, (u16)val);
data_base_addr = fn_dev->fd.data_base_addr;
error = rmi_write_block(fn_dev->rmi_dev,
data_base_addr + BLK_NUM_OFF,
data,
ARRAY_SIZE(data));
if (error < 0) {
dev_err(dev, "%s : Could not write bootloader id to 0x%x\n",
__func__, data_base_addr + BLK_NUM_OFF);
return error;
}
return count;
}
/* gpio get and set */
static void rmi_f30_gpio_data_set(struct gpio_chip *gc, unsigned nr, int val)
{
int reg_val = 32;
struct rmi_function *fn = container_of(gc,
struct rmi_fn_30_data, gpio);
struct rmi_device *rmi_dev = fn->rmi_dev;
//struct input_dev *input_dev;
struct rmi_fn_30_data *f30 = fn->data;
int gpio_led_cnt = f30->query.gpio_led_count;
int bytecnt = gpio_led_cnt / 7 + 1;
//int regs_size = 0;
int rc;
mutex_lock(&f30->gpio_mutex);
rc = rmi_read_block(rmi_dev, f30->data.datareg_0->address,
(u8 *)reg_val, bytecnt);
if (rc < 0) {
dev_err(&fn->dev,
"Could not read query registers from 0x%04x\n",
f30->data.datareg_0->address);
mutex_unlock(&f30->gpio_mutex);
return;
}
if (val)
reg_val |= (1 << nr);
else
reg_val &= ~(1 << nr);
/* Write gpio data Register value */
rc = rmi_write_block(rmi_dev, f30->data.datareg_0->address,
(u8 *)reg_val, bytecnt);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not read control 0 to 0x%x\n",
__func__, rc, f30->control.reg_0->address);
}
mutex_unlock(&f30->gpio_mutex);
}
static ssize_t rmi_fn_34_blocknum_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
int error;
unsigned long val;
u8 data[2];
struct rmi_function_dev *fn_dev;
struct rmi_fn_34_data *instance_data;
u16 data_base_addr;
fn_dev = to_rmi_function_dev(dev);
instance_data = fn_dev->data;
data_base_addr = fn_dev->fd.data_base_addr;
/* need to convert the string data to an actual value */
error = strict_strtoul(buf, 10, &val);
if (error)
return error;
instance_data->blocknum = val;
/* Write the Block Number data back to the first two Block
* Data registers (F34_Flash_Data_0 and F34_Flash_Data_1). */
hstoba(data, (u16)val);
error = rmi_write_block(fn_dev->rmi_dev, data_base_addr,
data, ARRAY_SIZE(data));
if (error < 0) {
dev_err(dev, "Could not write block number %u to %#06x.\n",
instance_data->blocknum, data_base_addr);
return error;
}
return count;
}
static void enable_dribble(struct rmi_function *fn) {
struct f12_data *f12 = fn->data;
int buffer_size;
int retval;
int i;
int offset = 0;
if (!rmi_has_register(&f12->desc.control, F12_REPORTING_CONTROL_REG)) {
dev_warn(&fn->dev, "WARNING: no reporting control reg exists Using default values.\n");
return;
}
buffer_size = rmi_register_size(&f12->desc.control, F12_REPORTING_CONTROL_REG);
if (!buffer_size)
return;
for(i = 0; i < F12_REPORTING_CONTROL_REG ; i++) {
if(rmi_has_register(&f12->desc.control, i))
offset++;
}
f12->reporting_control.buffer = devm_kzalloc(&fn->dev, buffer_size, GFP_KERNEL);
if (!f12->reporting_control.buffer)
return;
retval = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr + offset, f12->reporting_control.buffer, buffer_size);
if (!retval) {
dev_warn(&fn->dev, "WARNING: Failed to read reporting control. Using default values.\n");
return;
}
f12->reporting_control.buffer[2] |= 0x04;
retval = rmi_write_block(fn->rmi_dev, fn->fd.control_base_addr + offset,f12->reporting_control.buffer, buffer_size);
if (!retval) {
dev_warn(&fn->dev, "WARNING: Failed to write reporting control. Using default values.\n");
return;
}
dev_info(&fn->dev, "dribble enabled\n");
}
static void do_pause(struct f05_data *f05)
{
struct rmi_function_container *fn_dev = f05->fn_dev;
struct rmi_driver *driver = fn_dev->rmi_dev->driver;
int retval;
mutex_lock(&f05->status_mutex);
set_status(f05, F05_STATE_READY);
f05->data_ready = false;
f05->dev_data.report_mode = 0;
retval = rmi_write_block(fn_dev->rmi_dev, fn_dev->fd.data_base_addr,
(u8 *) &f05->dev_data, sizeof(f05->dev_data));
if (retval < 0) {
dev_warn(&fn_dev->dev, "WARNING: Failed to clear F05 report mode, code; %d.\n",
retval);
}
driver->restore_irq_mask(fn_dev->rmi_dev);
mutex_unlock(&f05->status_mutex);
wake_up(&f05->wq);
}
static int rmi_f21_config(struct rmi_function_container *fc)
{
struct rmi_fn_21_data *data = fc->data;
/* repeated register functions */
/* Write Control Register values back to device */
rmi_write_block(fc->rmi_dev, data->control.reg_0__3->address,
(u8 *)data->control.reg_0__3,
sizeof(data->control.reg_0__3->regs));
rmi_write_block(fc->rmi_dev, data->control.reg_4->address,
(u8 *) data->control.reg_4->regs,
data->control.reg_4->length);
rmi_write_block(fc->rmi_dev, data->control.reg_5->address,
(u8 *) data->control.reg_5->regs,
data->control.reg_5->length);
rmi_write_block(fc->rmi_dev, data->control.reg_6->address,
(u8 *) data->control.reg_6->regs,
data->control.reg_6->length);
rmi_write_block(fc->rmi_dev, data->control.reg_7->address,
(u8 *) data->control.reg_7->regs,
data->control.reg_7->length);
rmi_write_block(fc->rmi_dev, data->control.reg_8->address,
(u8 *) data->control.reg_8->regs,
data->control.reg_8->length);
rmi_write_block(fc->rmi_dev, data->control.reg_9->address,
(u8 *) data->control.reg_9->regs,
data->control.reg_9->length);
return 0;
}
/*
* f05_char_dev_write: - use to write data into RMI stream
* First byte is indication of parameter to change
*
* @filep : file structure for write
* @buf: user-level buffer pointer contains data to be written
* @count: number of byte be be written
* @f_pos: offset (starting register address)
*
* @return number of bytes written from user buffer (buf) if succeeds
* negative number if error occurs.
*/
static ssize_t f05_char_dev_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos)
{
struct f05_data *f05 = NULL;
struct f05_raw_data_char_dev *my_dev = NULL;
struct rmi_function_container *fn_dev;
struct rmi_driver *driver;
struct rmi_driver_data *driver_data;
struct rmi_function_container *f01_dev;
char tmpbuf[2];
char command;
int retval = 0;
if (!filp) {
dev_err(&fn_dev->dev, "%s: called with NULL file pointer\n",
__func__);
return -EINVAL;
}
my_dev = filp->private_data;
if (!my_dev) {
dev_err(&fn_dev->dev, "%s: called with NULL private_data\n",
__func__);
return -EINVAL;
}
f05 = container_of(my_dev, struct f05_data, raw_data_feed);
fn_dev = f05->fn_dev;
driver = fn_dev->rmi_dev->driver;
driver_data = dev_get_drvdata(&fn_dev->rmi_dev->dev);
retval = copy_from_user(tmpbuf, buf, count);
command = tmpbuf[0];
switch (command) {
case F05_REPORT_SET_TYPE:
if (count < 1) {
dev_err(&fn_dev->dev, "%s: missing report type.\n",
__func__);
retval = -EINVAL;
goto error_exit;
}
retval = do_set_report_mode(f05, (u8)tmpbuf[1]);
if (retval < 0)
goto error_exit;
break;
case F05_REPORT_START:
/* Overwrite and store interrupts */
mutex_lock(&f05->status_mutex);
if (f05->status == F05_STATE_READY) {
if (driver->store_irq_mask) {
u8 irq_bits[driver_data->num_of_irq_regs];
f01_dev = driver_data->f01_container;
u8_or(irq_bits, f01_dev->irq_mask,
fn_dev->irq_mask, driver_data->irq_count);
driver->store_irq_mask(fn_dev->rmi_dev,
irq_bits);
}
f05->data_ready = false;
set_status(f05, F05_STATE_RUN);
mutex_unlock(&f05->status_mutex);
request_next_report(f05);
} else {
dev_err(&fn_dev->dev, "%s: cannot start report in state %d.\n",
__func__, f05->status);
mutex_unlock(&f05->status_mutex);
retval = -EINVAL;
goto error_exit;
}
break;
case F05_REPORT_PAUSE:
do_pause(f05);
break;
case F05_REPORT_STOP:
do_stop(f05);
break;
case F05_REPORT_FORCE_ZERO:
mutex_lock(&f05->status_mutex);
if (f05->status == F05_STATE_READY) {
f05->data_ready = false;
f05->dev_command.get_image = 0;
f05->dev_command.force_zero = 1;
retval = rmi_write_block(f05->fn_dev->rmi_dev,
f05->fn_dev->fd.command_base_addr,
(u8 *) &f05->dev_command,
sizeof(f05->dev_command));
mutex_unlock(&f05->status_mutex);
if (retval < 0) {
dev_err(&fn_dev->dev, "%s: Could not write command register, code: %d.\n",
__func__, retval);
goto error_exit;
}
} else {
dev_err(&fn_dev->dev, "%s: cannot force zero in state %d.\n",
__func__, f05->status);
mutex_unlock(&f05->status_mutex);
retval = -EINVAL;
goto error_exit;
}
break;
default:
dev_err(&fn_dev->dev, "%s: invalid command %d.\n", __func__,
command);
retval = -EINVAL;
goto error_exit;
}
retval = count;
error_exit:
return retval;
}
static int rmi_f30_config(struct rmi_function *fn)
{
struct rmi_fn_30_data *data = fn->data;
int gpio_led_cnt = data->query.gpio_led_count;
int bytecnt = gpio_led_cnt / 7 + 1;
int regs_size = 0;
int rc;
/* repeated register functions */
/* Write Control Register values back to device */
rc = rmi_write_block(fn->rmi_dev, data->control.reg_0->address,
(u8 *)data->control.reg_0,
bytecnt * sizeof(struct f30_gpio_ctrl_0n));
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 0 to 0x%x\n",
__func__, rc, data->control.reg_0->address);
return rc;
}
rc = rmi_write_block(fn->rmi_dev, data->control.reg_1->address,
(u8 *) data->control.reg_1->regs,
sizeof(union f30_gpio_ctrl_1));
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 1 to 0x%x\n",
__func__, rc, data->control.reg_1->address);
return rc;
}
regs_size = data->control.reg_2->length;
rc = rmi_write_block(fn->rmi_dev, data->control.reg_2->address,
(u8 *) data->control.reg_2->regs,
regs_size);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 2 to 0x%x\n",
__func__, rc, data->control.reg_2->address);
return rc;
}
regs_size = data->control.reg_3->length;
rc = rmi_write_block(fn->rmi_dev, data->control.reg_3->address,
(u8 *) data->control.reg_3->regs,
regs_size);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 3 to 0x%x\n",
__func__, rc, data->control.reg_3->address);
return rc;
}
regs_size = data->control.reg_4->length;
rc = rmi_write_block(fn->rmi_dev, data->control.reg_4->address,
(u8 *) data->control.reg_4->regs,
regs_size);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 4 to 0x%x\n",
__func__, rc, data->control.reg_4->address);
return rc;
}
regs_size = data->control.reg_5->length;
rc = rmi_write_block(fn->rmi_dev, data->control.reg_5->address,
(u8 *) data->control.reg_5->regs,
regs_size);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 5 to 0x%x\n",
__func__, rc, data->control.reg_5->address);
return rc;
}
regs_size = data->control.reg_6->length;
rc = rmi_write_block(fn->rmi_dev, data->control.reg_6->address,
(u8 *) data->control.reg_6->regs,
regs_size);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 6 to 0x%x\n",
__func__, rc, data->control.reg_6->address);
return rc;
}
regs_size = data->control.reg_7->length;
rc = rmi_write_block(fn->rmi_dev, data->control.reg_7->address,
(u8 *) data->control.reg_7->regs,
regs_size);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 7 to 0x%x\n",
__func__, rc, data->control.reg_7->address);
return rc;
}
regs_size = data->control.reg_8->length;
rc = rmi_write_block(fn->rmi_dev, data->control.reg_8->address,
(u8 *) data->control.reg_8->regs, regs_size);
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 9 to 0x%x\n",
__func__, rc, data->control.reg_8->address);
return rc;
}
rc = rmi_write_block(fn->rmi_dev, data->control.reg_9->address,
(u8 *) data->control.reg_9->regs,
sizeof(union f30_gpio_ctrl_9));
if (rc < 0) {
dev_err(&fn->dev, "%s error %d: Could not write control 9 to 0x%x\n",
__func__, rc, data->control.reg_9->address);
return rc;
}
return 0;
}
static int rmi_f05_attention(struct rmi_function_container *fn_dev,
u8 *irq_bits)
{
int i;
int retval = 0;
struct f05_data *f05;
u8 *tmp_ptr;
u8 *stash;
int report_size;
u8 row_size;
f05 = fn_dev->data;
mutex_lock(&f05->status_mutex);
if (f05->status != F05_STATE_PENDING) {
mutex_unlock(&f05->status_mutex);
return 0;
}
report_size = f05->report_size;
row_size = f05->row_size;
mutex_unlock(&f05->status_mutex);
tmp_ptr = f05->tmp_buffer;
for (i = 0; i < f05->dev_query.num_of_tx_electrodes; i++) {
f05->dev_data.report_index = i;
retval = rmi_write_block(fn_dev->rmi_dev,
fn_dev->fd.data_base_addr,
(u8 *) &f05->dev_data, sizeof(f05->dev_data));
if (retval < 0) {
dev_err(&fn_dev->dev, "Failed to write to report index! code: %d.\n",
retval);
goto error_exit;
} else
retval = rmi_read_block(fn_dev->rmi_dev,
(fn_dev->fd.data_base_addr + sizeof(f05->dev_data)),
tmp_ptr, row_size);
if (retval < 0) {
dev_err(&fn_dev->dev, "Failed to read report data! code: %d.\n",
retval);
goto error_exit;
}
tmp_ptr += row_size;
}
mutex_lock(&f05->status_mutex);
if (f05->status != F05_STATE_PENDING) {
/* State changed while we were handling the read. */
mutex_unlock(&f05->status_mutex);
goto exit;
}
stash = f05->report_data;
f05->report_data = f05->tmp_buffer;
f05->tmp_buffer = stash;
f05->data_ready = true;
set_status(f05, F05_STATE_RUN);
mutex_unlock(&f05->status_mutex);
wake_up(&f05->wq);
request_next_report(f05);
goto exit;
error_exit:
mutex_lock(&f05->status_mutex);
f05->data_ready = false;
set_status(f05, F05_STATE_ERROR);
mutex_unlock(&f05->status_mutex);
wake_up(&f05->wq);
exit:
return 0;
}
static int rmi_f21_config(struct rmi_function_dev *fn_dev)
{
struct rmi_fn_21_data *data = fn_dev->data;
int retval;
/* repeated register functions */
/* Write Control Register values back to device */
retval = rmi_write_block(fn_dev->rmi_dev,
data->control.reg_0__3->address,
data->control.reg_0__3,
sizeof(data->control.reg_0__3->regs));
if (retval < 0) {
dev_err(&fn_dev->dev, "%s : Could not write reg_0_3 to 0x%x\n",
__func__, data->control.reg_0__3->address);
return retval;
}
retval = rmi_write_block(fn_dev->rmi_dev, data->control.reg_4->address,
data->control.reg_4->regs, data->control.reg_4->length);
if (retval < 0) {
dev_err(&fn_dev->dev, "%s : Could not write reg_4 to 0x%x\n",
__func__, data->control.reg_4->address);
return retval;
}
retval = rmi_write_block(fn_dev->rmi_dev, data->control.reg_5->address,
data->control.reg_5->regs, data->control.reg_5->length);
if (retval < 0) {
dev_err(&fn_dev->dev, "%s : Could not write reg_5 to 0x%x\n",
__func__, data->control.reg_5->address);
return retval;
}
retval = rmi_write_block(fn_dev->rmi_dev, data->control.reg_6->address,
(u8 *) data->control.reg_6->regs,
data->control.reg_6->length);
if (retval < 0) {
dev_err(&fn_dev->dev, "%s : Could not write reg_6 to 0x%x\n",
__func__, data->control.reg_6->address);
return retval;
}
retval = rmi_write_block(fn_dev->rmi_dev, data->control.reg_7->address,
(u8 *) data->control.reg_7->regs,
data->control.reg_7->length);
if (retval < 0) {
dev_err(&fn_dev->dev, "%s : Could not write reg_7 to 0x%x\n",
__func__, data->control.reg_7->address);
return retval;
}
retval = rmi_write_block(fn_dev->rmi_dev, data->control.reg_8->address,
(u8 *) data->control.reg_8->regs,
data->control.reg_8->length);
if (retval < 0) {
dev_err(&fn_dev->dev, "%s : Could not write reg_8 to 0x%x\n",
__func__, data->control.reg_8->address);
return retval;
}
retval = rmi_write_block(fn_dev->rmi_dev, data->control.reg_9->address,
(u8 *) data->control.reg_9->regs,
data->control.reg_9->length);
if (retval < 0) {
dev_err(&fn_dev->dev, "%s : Could not write reg_9 to 0x%x\n",
__func__, data->control.reg_9->address);
return retval;
}
return 0;
}
