static int rmi_f09_initialize(struct rmi_function_dev *fn_dev)
{
struct rmi_device *rmi_dev = fn_dev->rmi_dev;
struct rmi_device_platform_data *pdata;
struct rmi_fn_09_data *f09 = fn_dev->data;
u16 query_base_addr;
int rc;
pdata = to_rmi_platform_data(rmi_dev);
query_base_addr = fn_dev->fd.query_base_addr;
/* initial all default values for f09 query here */
rc = rmi_read_block(rmi_dev, query_base_addr,
(u8 *)&f09->query, sizeof(f09->query));
if (rc < 0) {
dev_err(&fn_dev->dev, "Failed to read query register from %#06x\n",
query_base_addr);
return rc;
}
return 0;
}
static int rmi_f12_probe(struct rmi_function *fn)
{
struct f12_data *f12;
int retval;
struct input_dev *input_dev;
struct rmi_device *rmi_dev = fn->rmi_dev;
struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev);
struct rmi_device_platform_data *pdata = to_rmi_platform_data(rmi_dev);
unsigned long input_flags;
int res_x, res_y;
f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data), GFP_KERNEL);
if (!f12)
return -ENOMEM;
fn->data = f12;
retval = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr,
&f12->info, sizeof(f12->info));
if (retval < 0) {
dev_err(&fn->dev, "Failed to read general info register, code %d\n",
retval);
goto error_free_data;
}
if (!f12->info.has_register_descriptors) {
dev_err(&fn->dev, "Behavior of F12 without register descriptors is undefined.\n");
retval = -ENODEV;
goto error_free_data;
}
retval = rmi_read_descriptors(fn, &f12->desc,
fn->fd.query_base_addr + 1);
if (retval)
return retval;
if (!rmi_has_register(&f12->desc.data, F12_FINGER_DATA_REG)) {
dev_err(&fn->dev, "Finger data registers are missing!\n");
retval = -ENODEV;
goto error_free_data;
}
f12->buf_size = rmi_register_size(&f12->desc.data, F12_FINGER_DATA_REG);
f12->object_buf = devm_kzalloc(&fn->dev, f12->buf_size * sizeof(u8), GFP_KERNEL);
if (!f12->object_buf) {
retval = -ENOMEM;
goto error_free_data;
}
f12->max_objects = rmi_register_subpackets(&f12->desc.data, F12_FINGER_DATA_REG);
f12->object_address = fn->fd.data_base_addr + rmi_register_offset(&f12->desc.data, F12_FINGER_DATA_REG);
f12->has_ACM25 = false;
if (rmi_has_register(&f12->desc.data, F12_FINGER_ACM_REG)) {
f12->has_ACM25 = true;
}
#if 1
if (f12->has_ACM25) {
pr_debug("acm25 is on\n");
}
else {
pr_debug("acm25 is off\n");
}
#endif
read_sensor_tuning(fn);
if (f12->info.has_dribble) {
enable_dribble(fn);
} else {
dev_err(&fn->dev, "No dribble support!\n");
}
f12->sensor_type = pdata->f12_sensor_data->sensor_type;
if (pdata->unified_input_device) {
f12->rmi_input = driver_data->rmi_input;
input_dev = f12->rmi_input->input_dev;
rmi_touchpad_create(f12->rmi_input, f12->max_objects, f12->x_max, f12->y_max);
} else {
f12->rmi_input = rmi_input_dev_alloc(&rmi_dev->dev, driver_data,
"%s/input0", f12);
if (f12->rmi_input) {
dev_err(&fn->dev, "Error in setting input device.\n");
goto error_free_data;
}
input_dev = f12->rmi_input->input_dev;
}
set_bit(EV_SYN, input_dev->evbit);
set_bit(EV_ABS, input_dev->evbit);
input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
if (f12->sensor_type == rmi_sensor_touchpad)
input_flags = INPUT_PROP_POINTER;
else
input_flags = INPUT_PROP_DIRECT;
set_bit(input_flags, input_dev->propbit);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0))
input_mt_init_slots(input_dev, f12->max_objects, 0);
#else
input_mt_init_slots(input_dev, f12->max_objects);
#endif
input_set_abs_params(input_dev, ABS_X, 0, f12->x_max, 0, 0);
input_set_abs_params(input_dev, ABS_Y, 0, f12->y_max, 0, 0);
input_set_abs_params(input_dev, ABS_PRESSURE, 0, DEFAULT_MAX_ABS_MT_PRESSURE, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_X,
0, f12->x_max, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
0, f12->y_max, 0, 0);
input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0,
DEFAULT_MAX_ABS_MT_PRESSURE, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
0, DEFAULT_MAX_ABS_MT_TOUCH, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR,
0, DEFAULT_MAX_ABS_MT_TOUCH, 0, 0);
input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
0, DEFAULT_MAX_ABS_MT_ORIENTATION, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TRACKING_ID,
DEFAULT_MIN_ABS_MT_TRACKING_ID,
f12->max_objects, 0, 0);
if (pdata->f12_sensor_data->x_mm && pdata->f12_sensor_data->y_mm) {
res_x = (f12->x_max - 0) / pdata->f12_sensor_data->x_mm;
res_y = (f12->y_max - 0) / pdata->f12_sensor_data->y_mm;
input_abs_set_res(input_dev, ABS_X, res_x);
input_abs_set_res(input_dev, ABS_Y, res_y);
input_abs_set_res(input_dev, ABS_MT_POSITION_X, res_x);
input_abs_set_res(input_dev, ABS_MT_POSITION_Y, res_y);
}
//input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
// 0, MT_TOOL_MAX, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
0, MT_TOOL_FINGER, 0, 0);
if (f12->sensor_type == rmi_sensor_touchpad) {
set_bit(EV_KEY, input_dev->evbit);
set_bit(BTN_LEFT, input_dev->keybit);
set_bit(BTN_TOOL_FINGER, input_dev->keybit);
set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
set_bit(BTN_TOOL_QUADTAP, input_dev->keybit);
set_bit(BTN_TOOL_QUINTTAP, input_dev->keybit);
}
if (!pdata->unified_input_device) {
retval = rmi_input_dev_register(f12->rmi_input);
if (retval < 0)
goto error_free_dev;
}
return 0;
error_free_dev:
if (!pdata->unified_input_device)
rmi_input_dev_free(f12->rmi_input);
error_free_data:
devm_kfree(&fn->dev, f12->object_buf);
devm_kfree(&fn->dev, f12);
return retval;
}
static inline int rmi_f30_initialize(struct rmi_function *fn)
{
struct rmi_device *rmi_dev = fn->rmi_dev;
struct rmi_device_platform_data *pdata;
struct rmi_fn_30_data *instance_data = fn->data;
int retval = 0;
u16 next_loc;
int gpio_led_cnt = 0;
int regs_size = 0;
u8 reg_num = 0;
int reg_flg;
int hasgpio, hasled, hasmbtn, hashaptic;
struct f30_control *control = &instance_data->control;
/* Read F30 Query Data */
instance_data->query.address = fn->fd.query_base_addr;
retval = rmi_read_block(fn->rmi_dev, instance_data->query.address,
(u8 *)&instance_data->query, sizeof(instance_data->query));
if (retval < 0) {
dev_err(&fn->dev,
"Could not read query registers from 0x%04x\n",
instance_data->query.address);
return retval;
}
/* initialize gpioled_map data */
hasgpio = instance_data->query.has_gpio;
hasled = instance_data->query.has_led;
hasmbtn = instance_data->query.has_mappable_buttons;
hashaptic = instance_data->query.has_haptic ;
gpio_led_cnt = instance_data->query.gpio_led_count;
pdata = to_rmi_platform_data(rmi_dev);
if (pdata) {
if (!pdata->gpioled_map) {
dev_warn(&fn->dev,
"%s - gpioled_map is NULL", __func__);
} else if (pdata->gpioled_map->ngpioleds != gpio_led_cnt) {
dev_warn(&fn->dev,
"Platformdata gpioled map size (%d) != number of buttons on device (%d) - ignored\n",
pdata->gpioled_map->ngpioleds, gpio_led_cnt);
} else if (!pdata->gpioled_map->map) {
dev_warn(&fn->dev,
"Platformdata button map is missing!\n");
} else {
int i;
for (i = 0; i < pdata->gpioled_map->ngpioleds; i++)
instance_data->gpioled_map[i] =
pdata->gpioled_map->map[i];
}
}
/* Initialize Control Data */
next_loc = fn->fd.control_base_addr;
/* calculate reg size */
instance_data->gpioled_bitmask_size = sizeof(u8)*(gpio_led_cnt + 7) / 8;
instance_data->gpioled_byte_size = sizeof(u8)*gpio_led_cnt;
/* reg_0 */
control->reg_0 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_0), GFP_KERNEL);
if (!control->reg_0) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
if (hasgpio && hasled)
reg_flg = 1;
f30_attrs_regs_exist[reg_num] = true;
regs_size = max((int)sizeof(struct f30_gpio_ctrl_0n) * reg_flg *
instance_data->gpioled_bitmask_size, 1);
control->reg_0->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!control->reg_0->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_0->address = next_loc;
control->reg_0->length = regs_size;
next_loc += regs_size;
reg_num++;
/* reg_1 */
control->reg_1 = devm_kzalloc(&fn->dev,
sizeof(union f30_gpio_ctrl_1), GFP_KERNEL);
if (!control->reg_1) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
f30_attrs_regs_exist[reg_num] = true;
reg_num++;
instance_data->control.reg_1->address = next_loc;
next_loc += regs_size;
/* reg_2 */
instance_data->control.reg_2 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_2), GFP_KERNEL);
if (!control->reg_2) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
reg_flg = hasgpio;
f30_attrs_regs_exist[reg_num] = true;
regs_size = max((int)sizeof(struct f30_gpio_ctrl_2n)*reg_flg*
instance_data->gpioled_bitmask_size, 1);
control->reg_2->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!control->reg_2->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_2->address = next_loc;
control->reg_2->length = regs_size;
next_loc += regs_size;
reg_num++;
/* reg_3 */
instance_data->control.reg_3 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_3), GFP_KERNEL);
if (!control->reg_3) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
reg_flg = hasgpio;
f30_attrs_regs_exist[reg_num] = true;
regs_size = max((int)sizeof(struct f30_gpio_ctrl_3n) * reg_flg *
instance_data->gpioled_bitmask_size, 1);
control->reg_3->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!control->reg_3->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_3->address = next_loc;
control->reg_3->length = regs_size;
next_loc += regs_size;
reg_num++;
/* reg_4 */
control->reg_4 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_4), GFP_KERNEL);
if (!control->reg_4) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
reg_flg = hasled;
f30_attrs_regs_exist[reg_num] = true;
regs_size = max(sizeof(struct f30_gpio_ctrl_4n)*reg_flg*
instance_data->gpioled_bitmask_size,
sizeof(struct f30_gpio_ctrl_4n));
control->reg_4->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!control->reg_4->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_4->address = next_loc;
control->reg_4->length = regs_size;
next_loc += regs_size;
reg_num++;
/* reg_5 */
control->reg_5 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_5), GFP_KERNEL);
if (!control->reg_5) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
reg_flg = hasled;
f30_attrs_regs_exist[reg_num] = true;
regs_size = max(6 * reg_flg, 2);
control->reg_5->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!control->reg_5->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_5->address = next_loc;
control->reg_5->length = regs_size;
next_loc += regs_size;
reg_num++;
/* reg_6 */
control->reg_6 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_6), GFP_KERNEL);
if (!control->reg_6) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
reg_flg = hasled || (!hasled
&& instance_data->query.has_gpio_driver_control);
regs_size = max(sizeof(union f30_gpio_ctrl_6n)*reg_flg*gpio_led_cnt,
sizeof(union f30_gpio_ctrl_6n));
if (!hasled
&& instance_data->query.has_gpio_driver_control)
f30_attrs_regs_exist[reg_num] = true;
reg_num++;
if (hasled)
f30_attrs_regs_exist[reg_num] = true;
reg_num++;
control->reg_6->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!control->reg_6->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_6->address = next_loc;
control->reg_6->length = regs_size;
next_loc += regs_size;
/* reg_7 */
reg_flg = hasmbtn;
control->reg_7 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_7), GFP_KERNEL);
if (!control->reg_7) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
if (hasmbtn)
regs_size = sizeof(struct f30_gpio_ctrl_7n)*gpio_led_cnt;
else
regs_size = sizeof(struct f30_gpio_ctrl_7n);
regs_size = max(sizeof(struct f30_gpio_ctrl_7n)*reg_flg*
gpio_led_cnt,
sizeof(struct f30_gpio_ctrl_7n));
f30_attrs_regs_exist[reg_num] = true;
control->reg_7->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!control->reg_7->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_7->address = next_loc;
control->reg_7->length = regs_size;
next_loc += regs_size;
reg_num++;
/* reg_8 */
control->reg_8 = devm_kzalloc(&fn->dev,
sizeof(struct f30_gpio_ctrl_8), GFP_KERNEL);
if (!control->reg_8) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
regs_size = max(sizeof(struct f30_gpio_ctrl_8n)*hashaptic*
gpio_led_cnt,
sizeof(struct f30_gpio_ctrl_8n));
f30_attrs_regs_exist[reg_num] = true;
control->reg_8->regs =
devm_kzalloc(&fn->dev, regs_size, GFP_KERNEL);
if (!control->reg_8->regs) {
dev_err(&fn->dev, "Failed to allocate control registers.");
return -ENOMEM;
}
control->reg_8->address = next_loc;
control->reg_8->length = regs_size;
next_loc += regs_size;
reg_num++;
/* reg_9 */
control->reg_9 = devm_kzalloc(&fn->dev,
sizeof(union f30_gpio_ctrl_9), GFP_KERNEL);
if (!control->reg_9) {
dev_err(&fn->dev, "Failed to allocate control register.");
return -ENOMEM;
}
if (instance_data->query.has_haptic)
f30_attrs_regs_exist[reg_num] = true;
control->reg_9->address = next_loc;
next_loc += sizeof(control->reg_9->regs);
/* data reg_0 */
instance_data->data.datareg_0 = devm_kzalloc(&fn->dev,
sizeof(struct f30_data_0), GFP_KERNEL);
if (!instance_data->data.datareg_0) {
dev_err(&fn->dev, "Failed to allocate control register.");
return -ENOMEM;
}
regs_size = sizeof(struct f30_data_0n)*
instance_data->gpioled_byte_size;
instance_data->data.datareg_0->address = fn->fd.data_base_addr;
instance_data->data.datareg_0->regs = devm_kzalloc(&fn->dev, regs_size,
GFP_KERNEL);
if (!instance_data->data.datareg_0->regs) {
dev_err(&fn->dev, "Failed to allocate data registers.");
return -ENOMEM;
}
next_loc += sizeof(instance_data->data.datareg_0->regs);
retval = rmi_f30_read_control_parameters(rmi_dev, instance_data);
if (retval < 0) {
dev_err(&fn->dev,
"Failed to initialize F19 control params.\n");
return retval;
}
mutex_init(&instance_data->control_mutex);
mutex_init(&instance_data->data_mutex);
return 0;
}
static int rmi_f34_initialize(struct rmi_function_dev *fn_dev)
{
struct rmi_device *rmi_dev = fn_dev->rmi_dev;
struct rmi_device_platform_data *pdata;
int retval = 0;
struct rmi_fn_34_data *f34 = fn_dev->data;
u16 query_base_addr;
u16 control_base_addr;
u8 buf[2];
pdata = to_rmi_platform_data(rmi_dev);
mutex_init(&f34->attn_mutex);
/* get the Bootloader ID and Block Size. */
query_base_addr = fn_dev->fd.query_base_addr;
control_base_addr = fn_dev->fd.control_base_addr;
retval = rmi_read_block(fn_dev->rmi_dev, query_base_addr, buf,
ARRAY_SIZE(buf));
if (retval < 0) {
dev_err(&fn_dev->dev, "Could not read bootloaderid from 0x%04x.\n",
query_base_addr);
return retval;
}
f34->bootloaderid = batohs(buf);
retval = rmi_read_block(fn_dev->rmi_dev, query_base_addr + BLK_SZ_OFF,
buf, ARRAY_SIZE(buf));
if (retval < 0) {
dev_err(&fn_dev->dev, "Could not read block size from 0x%04x, error=%d.\n",
query_base_addr + BLK_SZ_OFF, retval);
return retval;
}
f34->blocksize = batohs(buf);
/* Get firmware image block count and store it in the instance data */
retval = rmi_read_block(fn_dev->rmi_dev,
query_base_addr + IMG_BLK_CNT_OFF,
buf, ARRAY_SIZE(buf));
if (retval < 0) {
dev_err(&fn_dev->dev, "Couldn't read image block count from 0x%x, error=%d.\n",
query_base_addr + IMG_BLK_CNT_OFF, retval);
return retval;
}
f34->imageblockcount = batohs(buf);
/* Get config block count and store it in the instance data */
retval = rmi_read_block(fn_dev->rmi_dev, query_base_addr + 7, buf,
ARRAY_SIZE(buf));
if (retval < 0) {
dev_err(&fn_dev->dev, "Couldn't read config block count from 0x%x, error=%d.\n",
query_base_addr + CFG_BLK_CNT_OFF, retval);
return retval;
}
f34->configblockcount = batohs(buf);
return 0;
}
