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; }