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