Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2012-2016 Synaptics Incorporated
0004  */
0005 #include <linux/input.h>
0006 #include <linux/input/mt.h>
0007 #include <linux/rmi.h>
0008 #include "rmi_driver.h"
0009 #include "rmi_2d_sensor.h"
0010 
0011 enum rmi_f12_object_type {
0012     RMI_F12_OBJECT_NONE         = 0x00,
0013     RMI_F12_OBJECT_FINGER           = 0x01,
0014     RMI_F12_OBJECT_STYLUS           = 0x02,
0015     RMI_F12_OBJECT_PALM         = 0x03,
0016     RMI_F12_OBJECT_UNCLASSIFIED     = 0x04,
0017     RMI_F12_OBJECT_GLOVED_FINGER        = 0x06,
0018     RMI_F12_OBJECT_NARROW_OBJECT        = 0x07,
0019     RMI_F12_OBJECT_HAND_EDGE        = 0x08,
0020     RMI_F12_OBJECT_COVER            = 0x0A,
0021     RMI_F12_OBJECT_STYLUS_2         = 0x0B,
0022     RMI_F12_OBJECT_ERASER           = 0x0C,
0023     RMI_F12_OBJECT_SMALL_OBJECT     = 0x0D,
0024 };
0025 
0026 #define F12_DATA1_BYTES_PER_OBJ         8
0027 
0028 struct f12_data {
0029     struct rmi_2d_sensor sensor;
0030     struct rmi_2d_sensor_platform_data sensor_pdata;
0031     bool has_dribble;
0032 
0033     u16 data_addr;
0034 
0035     struct rmi_register_descriptor query_reg_desc;
0036     struct rmi_register_descriptor control_reg_desc;
0037     struct rmi_register_descriptor data_reg_desc;
0038 
0039     /* F12 Data1 describes sensed objects */
0040     const struct rmi_register_desc_item *data1;
0041     u16 data1_offset;
0042 
0043     /* F12 Data5 describes finger ACM */
0044     const struct rmi_register_desc_item *data5;
0045     u16 data5_offset;
0046 
0047     /* F12 Data5 describes Pen */
0048     const struct rmi_register_desc_item *data6;
0049     u16 data6_offset;
0050 
0051 
0052     /* F12 Data9 reports relative data */
0053     const struct rmi_register_desc_item *data9;
0054     u16 data9_offset;
0055 
0056     const struct rmi_register_desc_item *data15;
0057     u16 data15_offset;
0058 
0059     unsigned long *abs_mask;
0060     unsigned long *rel_mask;
0061 };
0062 
0063 static int rmi_f12_read_sensor_tuning(struct f12_data *f12)
0064 {
0065     const struct rmi_register_desc_item *item;
0066     struct rmi_2d_sensor *sensor = &f12->sensor;
0067     struct rmi_function *fn = sensor->fn;
0068     struct rmi_device *rmi_dev = fn->rmi_dev;
0069     int ret;
0070     int offset;
0071     u8 buf[15];
0072     int pitch_x = 0;
0073     int pitch_y = 0;
0074     int rx_receivers = 0;
0075     int tx_receivers = 0;
0076 
0077     item = rmi_get_register_desc_item(&f12->control_reg_desc, 8);
0078     if (!item) {
0079         dev_err(&fn->dev,
0080             "F12 does not have the sensor tuning control register\n");
0081         return -ENODEV;
0082     }
0083 
0084     offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8);
0085 
0086     if (item->reg_size > sizeof(buf)) {
0087         dev_err(&fn->dev,
0088             "F12 control8 should be no bigger than %zd bytes, not: %ld\n",
0089             sizeof(buf), item->reg_size);
0090         return -ENODEV;
0091     }
0092 
0093     ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset, buf,
0094                 item->reg_size);
0095     if (ret)
0096         return ret;
0097 
0098     offset = 0;
0099     if (rmi_register_desc_has_subpacket(item, 0)) {
0100         sensor->max_x = (buf[offset + 1] << 8) | buf[offset];
0101         sensor->max_y = (buf[offset + 3] << 8) | buf[offset + 2];
0102         offset += 4;
0103     }
0104 
0105     rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__,
0106         sensor->max_x, sensor->max_y);
0107 
0108     if (rmi_register_desc_has_subpacket(item, 1)) {
0109         pitch_x = (buf[offset + 1] << 8) | buf[offset];
0110         pitch_y = (buf[offset + 3] << 8) | buf[offset + 2];
0111         offset += 4;
0112     }
0113 
0114     if (rmi_register_desc_has_subpacket(item, 2)) {
0115         /* Units 1/128 sensor pitch */
0116         rmi_dbg(RMI_DEBUG_FN, &fn->dev,
0117             "%s: Inactive Border xlo:%d xhi:%d ylo:%d yhi:%d\n",
0118             __func__,
0119             buf[offset], buf[offset + 1],
0120             buf[offset + 2], buf[offset + 3]);
0121 
0122         offset += 4;
0123     }
0124 
0125     if (rmi_register_desc_has_subpacket(item, 3)) {
0126         rx_receivers = buf[offset];
0127         tx_receivers = buf[offset + 1];
0128         offset += 2;
0129     }
0130 
0131     /* Skip over sensor flags */
0132     if (rmi_register_desc_has_subpacket(item, 4))
0133         offset += 1;
0134 
0135     sensor->x_mm = (pitch_x * rx_receivers) >> 12;
0136     sensor->y_mm = (pitch_y * tx_receivers) >> 12;
0137 
0138     rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__,
0139         sensor->x_mm, sensor->y_mm);
0140 
0141     return 0;
0142 }
0143 
0144 static void rmi_f12_process_objects(struct f12_data *f12, u8 *data1, int size)
0145 {
0146     int i;
0147     struct rmi_2d_sensor *sensor = &f12->sensor;
0148     int objects = f12->data1->num_subpackets;
0149 
0150     if ((f12->data1->num_subpackets * F12_DATA1_BYTES_PER_OBJ) > size)
0151         objects = size / F12_DATA1_BYTES_PER_OBJ;
0152 
0153     for (i = 0; i < objects; i++) {
0154         struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];
0155 
0156         obj->type = RMI_2D_OBJECT_NONE;
0157         obj->mt_tool = MT_TOOL_FINGER;
0158 
0159         switch (data1[0]) {
0160         case RMI_F12_OBJECT_FINGER:
0161             obj->type = RMI_2D_OBJECT_FINGER;
0162             break;
0163         case RMI_F12_OBJECT_STYLUS:
0164             obj->type = RMI_2D_OBJECT_STYLUS;
0165             obj->mt_tool = MT_TOOL_PEN;
0166             break;
0167         case RMI_F12_OBJECT_PALM:
0168             obj->type = RMI_2D_OBJECT_PALM;
0169             obj->mt_tool = MT_TOOL_PALM;
0170             break;
0171         case RMI_F12_OBJECT_UNCLASSIFIED:
0172             obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
0173             break;
0174         }
0175 
0176         obj->x = (data1[2] << 8) | data1[1];
0177         obj->y = (data1[4] << 8) | data1[3];
0178         obj->z = data1[5];
0179         obj->wx = data1[6];
0180         obj->wy = data1[7];
0181 
0182         rmi_2d_sensor_abs_process(sensor, obj, i);
0183 
0184         data1 += F12_DATA1_BYTES_PER_OBJ;
0185     }
0186 
0187     if (sensor->kernel_tracking)
0188         input_mt_assign_slots(sensor->input,
0189                       sensor->tracking_slots,
0190                       sensor->tracking_pos,
0191                       sensor->nbr_fingers,
0192                       sensor->dmax);
0193 
0194     for (i = 0; i < objects; i++)
0195         rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
0196 }
0197 
0198 static irqreturn_t rmi_f12_attention(int irq, void *ctx)
0199 {
0200     int retval;
0201     struct rmi_function *fn = ctx;
0202     struct rmi_device *rmi_dev = fn->rmi_dev;
0203     struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
0204     struct f12_data *f12 = dev_get_drvdata(&fn->dev);
0205     struct rmi_2d_sensor *sensor = &f12->sensor;
0206     int valid_bytes = sensor->pkt_size;
0207 
0208     if (drvdata->attn_data.data) {
0209         if (sensor->attn_size > drvdata->attn_data.size)
0210             valid_bytes = drvdata->attn_data.size;
0211         else
0212             valid_bytes = sensor->attn_size;
0213         memcpy(sensor->data_pkt, drvdata->attn_data.data,
0214             valid_bytes);
0215         drvdata->attn_data.data += valid_bytes;
0216         drvdata->attn_data.size -= valid_bytes;
0217     } else {
0218         retval = rmi_read_block(rmi_dev, f12->data_addr,
0219                     sensor->data_pkt, sensor->pkt_size);
0220         if (retval < 0) {
0221             dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
0222                 retval);
0223             return IRQ_RETVAL(retval);
0224         }
0225     }
0226 
0227     if (f12->data1)
0228         rmi_f12_process_objects(f12,
0229             &sensor->data_pkt[f12->data1_offset], valid_bytes);
0230 
0231     input_mt_sync_frame(sensor->input);
0232 
0233     return IRQ_HANDLED;
0234 }
0235 
0236 static int rmi_f12_write_control_regs(struct rmi_function *fn)
0237 {
0238     int ret;
0239     const struct rmi_register_desc_item *item;
0240     struct rmi_device *rmi_dev = fn->rmi_dev;
0241     struct f12_data *f12 = dev_get_drvdata(&fn->dev);
0242     int control_size;
0243     char buf[3];
0244     u16 control_offset = 0;
0245     u8 subpacket_offset = 0;
0246 
0247     if (f12->has_dribble
0248         && (f12->sensor.dribble != RMI_REG_STATE_DEFAULT)) {
0249         item = rmi_get_register_desc_item(&f12->control_reg_desc, 20);
0250         if (item) {
0251             control_offset = rmi_register_desc_calc_reg_offset(
0252                         &f12->control_reg_desc, 20);
0253 
0254             /*
0255              * The byte containing the EnableDribble bit will be
0256              * in either byte 0 or byte 2 of control 20. Depending
0257              * on the existence of subpacket 0. If control 20 is
0258              * larger then 3 bytes, just read the first 3.
0259              */
0260             control_size = min(item->reg_size, 3UL);
0261 
0262             ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr
0263                     + control_offset, buf, control_size);
0264             if (ret)
0265                 return ret;
0266 
0267             if (rmi_register_desc_has_subpacket(item, 0))
0268                 subpacket_offset += 1;
0269 
0270             switch (f12->sensor.dribble) {
0271             case RMI_REG_STATE_OFF:
0272                 buf[subpacket_offset] &= ~BIT(2);
0273                 break;
0274             case RMI_REG_STATE_ON:
0275                 buf[subpacket_offset] |= BIT(2);
0276                 break;
0277             case RMI_REG_STATE_DEFAULT:
0278             default:
0279                 break;
0280             }
0281 
0282             ret = rmi_write_block(rmi_dev,
0283                 fn->fd.control_base_addr + control_offset,
0284                 buf, control_size);
0285             if (ret)
0286                 return ret;
0287         }
0288     }
0289 
0290     return 0;
0291 
0292 }
0293 
0294 static int rmi_f12_config(struct rmi_function *fn)
0295 {
0296     struct rmi_driver *drv = fn->rmi_dev->driver;
0297     struct f12_data *f12 = dev_get_drvdata(&fn->dev);
0298     struct rmi_2d_sensor *sensor;
0299     int ret;
0300 
0301     sensor = &f12->sensor;
0302 
0303     if (!sensor->report_abs)
0304         drv->clear_irq_bits(fn->rmi_dev, f12->abs_mask);
0305     else
0306         drv->set_irq_bits(fn->rmi_dev, f12->abs_mask);
0307 
0308     drv->clear_irq_bits(fn->rmi_dev, f12->rel_mask);
0309 
0310     ret = rmi_f12_write_control_regs(fn);
0311     if (ret)
0312         dev_warn(&fn->dev,
0313             "Failed to write F12 control registers: %d\n", ret);
0314 
0315     return 0;
0316 }
0317 
0318 static int rmi_f12_probe(struct rmi_function *fn)
0319 {
0320     struct f12_data *f12;
0321     int ret;
0322     struct rmi_device *rmi_dev = fn->rmi_dev;
0323     char buf;
0324     u16 query_addr = fn->fd.query_base_addr;
0325     const struct rmi_register_desc_item *item;
0326     struct rmi_2d_sensor *sensor;
0327     struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
0328     struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
0329     u16 data_offset = 0;
0330     int mask_size;
0331 
0332     rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);
0333 
0334     mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long);
0335 
0336     ret = rmi_read(fn->rmi_dev, query_addr, &buf);
0337     if (ret < 0) {
0338         dev_err(&fn->dev, "Failed to read general info register: %d\n",
0339             ret);
0340         return -ENODEV;
0341     }
0342     ++query_addr;
0343 
0344     if (!(buf & BIT(0))) {
0345         dev_err(&fn->dev,
0346             "Behavior of F12 without register descriptors is undefined.\n");
0347         return -ENODEV;
0348     }
0349 
0350     f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data) + mask_size * 2,
0351             GFP_KERNEL);
0352     if (!f12)
0353         return -ENOMEM;
0354 
0355     f12->abs_mask = (unsigned long *)((char *)f12
0356             + sizeof(struct f12_data));
0357     f12->rel_mask = (unsigned long *)((char *)f12
0358             + sizeof(struct f12_data) + mask_size);
0359 
0360     set_bit(fn->irq_pos, f12->abs_mask);
0361     set_bit(fn->irq_pos + 1, f12->rel_mask);
0362 
0363     f12->has_dribble = !!(buf & BIT(3));
0364 
0365     if (fn->dev.of_node) {
0366         ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
0367         if (ret)
0368             return ret;
0369     } else {
0370         f12->sensor_pdata = pdata->sensor_pdata;
0371     }
0372 
0373     ret = rmi_read_register_desc(rmi_dev, query_addr,
0374                     &f12->query_reg_desc);
0375     if (ret) {
0376         dev_err(&fn->dev,
0377             "Failed to read the Query Register Descriptor: %d\n",
0378             ret);
0379         return ret;
0380     }
0381     query_addr += 3;
0382 
0383     ret = rmi_read_register_desc(rmi_dev, query_addr,
0384                         &f12->control_reg_desc);
0385     if (ret) {
0386         dev_err(&fn->dev,
0387             "Failed to read the Control Register Descriptor: %d\n",
0388             ret);
0389         return ret;
0390     }
0391     query_addr += 3;
0392 
0393     ret = rmi_read_register_desc(rmi_dev, query_addr,
0394                         &f12->data_reg_desc);
0395     if (ret) {
0396         dev_err(&fn->dev,
0397             "Failed to read the Data Register Descriptor: %d\n",
0398             ret);
0399         return ret;
0400     }
0401     query_addr += 3;
0402 
0403     sensor = &f12->sensor;
0404     sensor->fn = fn;
0405     f12->data_addr = fn->fd.data_base_addr;
0406     sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);
0407 
0408     sensor->axis_align =
0409         f12->sensor_pdata.axis_align;
0410 
0411     sensor->x_mm = f12->sensor_pdata.x_mm;
0412     sensor->y_mm = f12->sensor_pdata.y_mm;
0413     sensor->dribble = f12->sensor_pdata.dribble;
0414 
0415     if (sensor->sensor_type == rmi_sensor_default)
0416         sensor->sensor_type =
0417             f12->sensor_pdata.sensor_type;
0418 
0419     rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__,
0420         sensor->pkt_size);
0421     sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
0422     if (!sensor->data_pkt)
0423         return -ENOMEM;
0424 
0425     dev_set_drvdata(&fn->dev, f12);
0426 
0427     ret = rmi_f12_read_sensor_tuning(f12);
0428     if (ret)
0429         return ret;
0430 
0431     /*
0432      * Figure out what data is contained in the data registers. HID devices
0433      * may have registers defined, but their data is not reported in the
0434      * HID attention report. Registers which are not reported in the HID
0435      * attention report check to see if the device is receiving data from
0436      * HID attention reports.
0437      */
0438     item = rmi_get_register_desc_item(&f12->data_reg_desc, 0);
0439     if (item && !drvdata->attn_data.data)
0440         data_offset += item->reg_size;
0441 
0442     item = rmi_get_register_desc_item(&f12->data_reg_desc, 1);
0443     if (item) {
0444         f12->data1 = item;
0445         f12->data1_offset = data_offset;
0446         data_offset += item->reg_size;
0447         sensor->nbr_fingers = item->num_subpackets;
0448         sensor->report_abs = 1;
0449         sensor->attn_size += item->reg_size;
0450     }
0451 
0452     item = rmi_get_register_desc_item(&f12->data_reg_desc, 2);
0453     if (item && !drvdata->attn_data.data)
0454         data_offset += item->reg_size;
0455 
0456     item = rmi_get_register_desc_item(&f12->data_reg_desc, 3);
0457     if (item && !drvdata->attn_data.data)
0458         data_offset += item->reg_size;
0459 
0460     item = rmi_get_register_desc_item(&f12->data_reg_desc, 4);
0461     if (item && !drvdata->attn_data.data)
0462         data_offset += item->reg_size;
0463 
0464     item = rmi_get_register_desc_item(&f12->data_reg_desc, 5);
0465     if (item) {
0466         f12->data5 = item;
0467         f12->data5_offset = data_offset;
0468         data_offset += item->reg_size;
0469         sensor->attn_size += item->reg_size;
0470     }
0471 
0472     item = rmi_get_register_desc_item(&f12->data_reg_desc, 6);
0473     if (item && !drvdata->attn_data.data) {
0474         f12->data6 = item;
0475         f12->data6_offset = data_offset;
0476         data_offset += item->reg_size;
0477     }
0478 
0479     item = rmi_get_register_desc_item(&f12->data_reg_desc, 7);
0480     if (item && !drvdata->attn_data.data)
0481         data_offset += item->reg_size;
0482 
0483     item = rmi_get_register_desc_item(&f12->data_reg_desc, 8);
0484     if (item && !drvdata->attn_data.data)
0485         data_offset += item->reg_size;
0486 
0487     item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
0488     if (item && !drvdata->attn_data.data) {
0489         f12->data9 = item;
0490         f12->data9_offset = data_offset;
0491         data_offset += item->reg_size;
0492         if (!sensor->report_abs)
0493             sensor->report_rel = 1;
0494     }
0495 
0496     item = rmi_get_register_desc_item(&f12->data_reg_desc, 10);
0497     if (item && !drvdata->attn_data.data)
0498         data_offset += item->reg_size;
0499 
0500     item = rmi_get_register_desc_item(&f12->data_reg_desc, 11);
0501     if (item && !drvdata->attn_data.data)
0502         data_offset += item->reg_size;
0503 
0504     item = rmi_get_register_desc_item(&f12->data_reg_desc, 12);
0505     if (item && !drvdata->attn_data.data)
0506         data_offset += item->reg_size;
0507 
0508     item = rmi_get_register_desc_item(&f12->data_reg_desc, 13);
0509     if (item && !drvdata->attn_data.data)
0510         data_offset += item->reg_size;
0511 
0512     item = rmi_get_register_desc_item(&f12->data_reg_desc, 14);
0513     if (item && !drvdata->attn_data.data)
0514         data_offset += item->reg_size;
0515 
0516     item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
0517     if (item && !drvdata->attn_data.data) {
0518         f12->data15 = item;
0519         f12->data15_offset = data_offset;
0520         data_offset += item->reg_size;
0521     }
0522 
0523     /* allocate the in-kernel tracking buffers */
0524     sensor->tracking_pos = devm_kcalloc(&fn->dev,
0525             sensor->nbr_fingers, sizeof(struct input_mt_pos),
0526             GFP_KERNEL);
0527     sensor->tracking_slots = devm_kcalloc(&fn->dev,
0528             sensor->nbr_fingers, sizeof(int), GFP_KERNEL);
0529     sensor->objs = devm_kcalloc(&fn->dev,
0530             sensor->nbr_fingers,
0531             sizeof(struct rmi_2d_sensor_abs_object),
0532             GFP_KERNEL);
0533     if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
0534         return -ENOMEM;
0535 
0536     ret = rmi_2d_sensor_configure_input(fn, sensor);
0537     if (ret)
0538         return ret;
0539 
0540     return 0;
0541 }
0542 
0543 struct rmi_function_handler rmi_f12_handler = {
0544     .driver = {
0545         .name = "rmi4_f12",
0546     },
0547     .func = 0x12,
0548     .probe = rmi_f12_probe,
0549     .config = rmi_f12_config,
0550     .attention = rmi_f12_attention,
0551 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!