kernel/drivers/staging/ste_rmi4/synaptics_i2c_rmi4.c

   1 /**
   2  *
   3  * Synaptics Register Mapped Interface (RMI4) I2C Physical Layer Driver.
   4  * Copyright (c) 2007-2010, Synaptics Incorporated
   5  *
   6  * Author: Js HA <js.ha@stericsson.com> for ST-Ericsson
   7  * Author: Naveen Kumar G <naveen.gaddipati@stericsson.com> for ST-Ericsson
   8  * Copyright 2010 (c) ST-Ericsson AB
   9  */
  10 /*
  11  * This file is licensed under the GPL2 license.
  12  *
  13  *#############################################################################
  14  * GPL
  15  *
  16  * This program is free software; you can redistribute it and/or modify it
  17  * under the terms of the GNU General Public License version 2 as published
  18  * by the Free Software Foundation.
  19  *
  20  * This program is distributed in the hope that it will be useful, but
  21  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  22  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  23  * for more details.
  24  *
  25  *#############################################################################
  26  */
  27
  28 #include <linux/input.h>
  29 #include <linux/slab.h>
  30 #include <linux/i2c.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/regulator/consumer.h>
  33 #include <linux/module.h>
  34 #include <linux/input/mt.h>
  35 #include "synaptics_i2c_rmi4.h"
  36
  37 /* TODO: for multiple device support will need a per-device mutex */
  38 #define DRIVER_NAME "synaptics_rmi4_i2c"
  39
  40 #define MAX_ERROR_REPORT        6
  41 #define MAX_TOUCH_MAJOR         15
  42 #define MAX_RETRY_COUNT         5
  43 #define STD_QUERY_LEN           21
  44 #define PAGE_LEN                2
  45 #define DATA_BUF_LEN            32
  46 #define BUF_LEN                 37
  47 #define QUERY_LEN               9
  48 #define DATA_LEN                12
  49 #define HAS_TAP                 0x01
  50 #define HAS_PALMDETECT          0x01
  51 #define HAS_ROTATE              0x02
  52 #define HAS_TAPANDHOLD          0x02
  53 #define HAS_DOUBLETAP           0x04
  54 #define HAS_EARLYTAP            0x08
  55 #define HAS_RELEASE             0x08
  56 #define HAS_FLICK               0x10
  57 #define HAS_PRESS               0x20
  58 #define HAS_PINCH               0x40
  59
  60 #define MASK_16BIT              0xFFFF
  61 #define MASK_8BIT               0xFF
  62 #define MASK_7BIT               0x7F
  63 #define MASK_5BIT               0x1F
  64 #define MASK_4BIT               0x0F
  65 #define MASK_3BIT               0x07
  66 #define MASK_2BIT               0x03
  67 #define TOUCHPAD_CTRL_INTR      0x8
  68 #define PDT_START_SCAN_LOCATION (0x00E9)
  69 #define PDT_END_SCAN_LOCATION   (0x000A)
  70 #define PDT_ENTRY_SIZE          (0x0006)
  71 #define SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM        (0x11)
  72 #define SYNAPTICS_RMI4_DEVICE_CONTROL_FUNC_NUM  (0x01)
  73
  74 /**
  75  * struct synaptics_rmi4_fn_desc - contains the function descriptor information
  76  * @query_base_addr: base address for query
  77  * @cmd_base_addr: base address for command
  78  * @ctrl_base_addr: base address for control
  79  * @data_base_addr: base address for data
  80  * @intr_src_count: count for the interrupt source
  81  * @fn_number: function number
  82  *
  83  * This structure is used to gives the function descriptor information
  84  * of the particular functionality.
  85  */
  86 struct synaptics_rmi4_fn_desc {
  87         unsigned char   query_base_addr;
  88         unsigned char   cmd_base_addr;
  89         unsigned char   ctrl_base_addr;
  90         unsigned char   data_base_addr;
  91         unsigned char   intr_src_count;
  92         unsigned char   fn_number;
  93 };
  94
  95 /**
  96  * struct synaptics_rmi4_fn - contains the function information
  97  * @fn_number: function number
  98  * @num_of_data_sources: number of data sources
  99  * @num_of_data_points: number of fingers touched
 100  * @size_of_data_register_block: data register block size
 101  * @index_to_intr_reg: index for interrupt register
 102  * @intr_mask: interrupt mask value
 103  * @fn_desc: variable for function descriptor structure
 104  * @link: linked list for function descriptors
 105  *
 106  * This structure gives information about the number of data sources and
 107  * the number of data registers associated with the function.
 108  */
 109 struct synaptics_rmi4_fn {
 110         unsigned char           fn_number;
 111         unsigned char           num_of_data_sources;
 112         unsigned char           num_of_data_points;
 113         unsigned char           size_of_data_register_block;
 114         unsigned char           index_to_intr_reg;
 115         unsigned char           intr_mask;
 116         struct synaptics_rmi4_fn_desc   fn_desc;
 117         struct list_head        link;
 118 };
 119
 120 /**
 121  * struct synaptics_rmi4_device_info - contains the rmi4 device information
 122  * @version_major: protocol major version number
 123  * @version_minor: protocol minor version number
 124  * @manufacturer_id: manufacturer identification byte
 125  * @product_props: product properties information
 126  * @product_info: product info array
 127  * @date_code: device manufacture date
 128  * @tester_id: tester id array
 129  * @serial_number: serial number for that device
 130  * @product_id_string: product id for the device
 131  * @support_fn_list: linked list for device information
 132  *
 133  * This structure gives information about the number of data sources and
 134  * the number of data registers associated with the function.
 135  */
 136 struct synaptics_rmi4_device_info {
 137         unsigned int            version_major;
 138         unsigned int            version_minor;
 139         unsigned char           manufacturer_id;
 140         unsigned char           product_props;
 141         unsigned char           product_info[2];
 142         unsigned char           date_code[3];
 143         unsigned short          tester_id;
 144         unsigned short          serial_number;
 145         unsigned char           product_id_string[11];
 146         struct list_head        support_fn_list;
 147 };
 148
 149 /**
 150  * struct synaptics_rmi4_data - contains the rmi4 device data
 151  * @rmi4_mod_info: structure variable for rmi4 device info
 152  * @input_dev: pointer for input device
 153  * @i2c_client: pointer for i2c client
 154  * @board: constant pointer for touch platform data
 155  * @fn_list_mutex: mutex for function list
 156  * @rmi4_page_mutex: mutex for rmi4 page
 157  * @current_page: variable for integer
 158  * @number_of_interrupt_register: interrupt registers count
 159  * @fn01_ctrl_base_addr: control base address for fn01
 160  * @fn01_query_base_addr: query base address for fn01
 161  * @fn01_data_base_addr: data base address for fn01
 162  * @sensor_max_x: sensor maximum x value
 163  * @sensor_max_y: sensor maximum y value
 164  * @regulator: pointer to the regulator structure
 165  * @wait: wait queue structure variable
 166  * @touch_stopped: flag to stop the thread function
 167  * @fingers_supported: maximum supported fingers
 168  *
 169  * This structure gives the device data information.
 170  */
 171 struct synaptics_rmi4_data {
 172         struct synaptics_rmi4_device_info rmi4_mod_info;
 173         struct input_dev        *input_dev;
 174         struct i2c_client       *i2c_client;
 175         const struct synaptics_rmi4_platform_data *board;
 176         struct mutex            fn_list_mutex;
 177         struct mutex            rmi4_page_mutex;
 178         int                     current_page;
 179         unsigned int            number_of_interrupt_register;
 180         unsigned short          fn01_ctrl_base_addr;
 181         unsigned short          fn01_query_base_addr;
 182         unsigned short          fn01_data_base_addr;
 183         int                     sensor_max_x;
 184         int                     sensor_max_y;
 185         struct regulator        *regulator;
 186         wait_queue_head_t       wait;
 187         bool                    touch_stopped;
 188         unsigned char           fingers_supported;
 189 };
 190
 191 /**
 192  * synaptics_rmi4_set_page() - sets the page
 193  * @pdata: pointer to synaptics_rmi4_data structure
 194  * @address: set the address of the page
 195  *
 196  * This function is used to set the page and returns integer.
 197  */
 198 static int synaptics_rmi4_set_page(struct synaptics_rmi4_data *pdata,
 199                                         unsigned int address)
 200 {
 201         unsigned char   txbuf[PAGE_LEN];
 202         int             retval;
 203         unsigned int    page;
 204         struct i2c_client *i2c = pdata->i2c_client;
 205
 206         page    = ((address >> 8) & MASK_8BIT);
 207         if (page != pdata->current_page) {
 208                 txbuf[0]        = MASK_8BIT;
 209                 txbuf[1]        = page;
 210                 retval  = i2c_master_send(i2c, txbuf, PAGE_LEN);
 211                 if (retval != PAGE_LEN)
 212                         dev_err(&i2c->dev, "failed:%d\n", retval);
 213                 else
 214                         pdata->current_page = page;
 215         } else
 216                 retval = PAGE_LEN;
 217         return retval;
 218 }
 219 /**
 220  * synaptics_rmi4_i2c_block_read() - read the block of data
 221  * @pdata: pointer to synaptics_rmi4_data structure
 222  * @address: read the block of data from this offset
 223  * @valp: pointer to a buffer containing the data to be read
 224  * @size: number of bytes to read
 225  *
 226  * This function is to read the block of data and returns integer.
 227  */
 228 static int synaptics_rmi4_i2c_block_read(struct synaptics_rmi4_data *pdata,
 229                                                 unsigned short address,
 230                                                 unsigned char *valp, int size)
 231 {
 232         int retval = 0;
 233         int retry_count = 0;
 234         int index;
 235         struct i2c_client *i2c = pdata->i2c_client;
 236
 237         mutex_lock(&(pdata->rmi4_page_mutex));
 238         retval = synaptics_rmi4_set_page(pdata, address);
 239         if (retval != PAGE_LEN)
 240                 goto exit;
 241         index = address & MASK_8BIT;
 242 retry:
 243         retval = i2c_smbus_read_i2c_block_data(i2c, index, size, valp);
 244         if (retval != size) {
 245                 if (++retry_count == MAX_RETRY_COUNT)
 246                         dev_err(&i2c->dev,
 247                                 "%s:address 0x%04x size %d failed:%d\n",
 248                                         __func__, address, size, retval);
 249                 else {
 250                         synaptics_rmi4_set_page(pdata, address);
 251                         goto retry;
 252                 }
 253         }
 254 exit:
 255         mutex_unlock(&(pdata->rmi4_page_mutex));
 256         return retval;
 257 }
 258
 259 /**
 260  * synaptics_rmi4_i2c_byte_write() - write the single byte data
 261  * @pdata: pointer to synaptics_rmi4_data structure
 262  * @address: write the block of data from this offset
 263  * @data: data to be write
 264  *
 265  * This function is to write the single byte data and returns integer.
 266  */
 267 static int synaptics_rmi4_i2c_byte_write(struct synaptics_rmi4_data *pdata,
 268                                                 unsigned short address,
 269                                                 unsigned char data)
 270 {
 271         unsigned char txbuf[2];
 272         int retval = 0;
 273         struct i2c_client *i2c = pdata->i2c_client;
 274
 275         /* Can't have anyone else changing the page behind our backs */
 276         mutex_lock(&(pdata->rmi4_page_mutex));
 277
 278         retval = synaptics_rmi4_set_page(pdata, address);
 279         if (retval != PAGE_LEN)
 280                 goto exit;
 281         txbuf[0]        = address & MASK_8BIT;
 282         txbuf[1]        = data;
 283         retval          = i2c_master_send(pdata->i2c_client, txbuf, 2);
 284         /* Add in retry on writes only in certain error return values */
 285         if (retval != 2) {
 286                 dev_err(&i2c->dev, "failed:%d\n", retval);
 287                 retval = -EIO;
 288         } else
 289                 retval = 1;
 290 exit:
 291         mutex_unlock(&(pdata->rmi4_page_mutex));
 292         return retval;
 293 }
 294
 295 /**
 296  * synpatics_rmi4_touchpad_report() - reports for the rmi4 touchpad device
 297  * @pdata: pointer to synaptics_rmi4_data structure
 298  * @rfi: pointer to synaptics_rmi4_fn structure
 299  *
 300  * This function calls to reports for the rmi4 touchpad device
 301  */
 302 static int synpatics_rmi4_touchpad_report(struct synaptics_rmi4_data *pdata,
 303                                                 struct synaptics_rmi4_fn *rfi)
 304 {
 305         /* number of touch points - fingers down in this case */
 306         int     touch_count = 0;
 307         int     finger;
 308         int     finger_registers;
 309         int     reg;
 310         int     finger_shift;
 311         int     finger_status;
 312         int     retval;
 313         int     x, y;
 314         int     wx, wy;
 315         unsigned short  data_base_addr;
 316         unsigned short  data_offset;
 317         unsigned char   data_reg_blk_size;
 318         unsigned char   values[2];
 319         unsigned char   data[DATA_LEN];
 320         unsigned char   fingers_supported = pdata->fingers_supported;
 321         struct  i2c_client *client = pdata->i2c_client;
 322         struct  input_dev *input_dev = pdata->input_dev;
 323
 324         /* get 2D sensor finger data */
 325         /*
 326          * First get the finger status field - the size of the finger status
 327          * field is determined by the number of finger supporte - 2 bits per
 328          * finger, so the number of registers to read is:
 329          * registerCount = ceil(numberOfFingers/4).
 330          * Read the required number of registers and check each 2 bit field to
 331          * determine if a finger is down:
 332          *      00 = finger not present,
 333          *      01 = finger present and data accurate,
 334          *      10 = finger present but data may not be accurate,
 335          *      11 = reserved for product use.
 336          */
 337         finger_registers        = (fingers_supported + 3)/4;
 338         data_base_addr          = rfi->fn_desc.data_base_addr;
 339         retval = synaptics_rmi4_i2c_block_read(pdata, data_base_addr, values,
 340                                                         finger_registers);
 341         if (retval != finger_registers) {
 342                 dev_err(&client->dev, "%s:read status registers failed\n",
 343                                                                 __func__);
 344                 return 0;
 345         }
 346         /*
 347          * For each finger present, read the proper number of registers
 348          * to get absolute data.
 349          */
 350         data_reg_blk_size = rfi->size_of_data_register_block;
 351         for (finger = 0; finger < fingers_supported; finger++) {
 352                 /* determine which data byte the finger status is in */
 353                 reg = finger/4;
 354                 /* bit shift to get finger's status */
 355                 finger_shift    = (finger % 4) * 2;
 356                 finger_status   = (values[reg] >> finger_shift) & 3;
 357                 /*
 358                  * if finger status indicates a finger is present then
 359                  * read the finger data and report it
 360                  */
 361                 input_mt_slot(input_dev, finger);
 362                 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
 363                                                         finger_status != 0);
 364
 365                 if (finger_status) {
 366                         /* Read the finger data */
 367                         data_offset = data_base_addr +
 368                                         ((finger * data_reg_blk_size) +
 369                                         finger_registers);
 370                         retval = synaptics_rmi4_i2c_block_read(pdata,
 371                                                 data_offset, data,
 372                                                 data_reg_blk_size);
 373                         if (retval != data_reg_blk_size) {
 374                                 dev_err(&client->dev, "%s:read data failed\n",
 375                                                                 __func__);
 376                                 return 0;
 377                         }
 378                         x = (data[0] << 4) | (data[2] & MASK_4BIT);
 379                         y = (data[1] << 4) | ((data[2] >> 4) & MASK_4BIT);
 380                         wy = (data[3] >> 4) & MASK_4BIT;
 381                         wx = (data[3] & MASK_4BIT);
 382
 383                         if (pdata->board->x_flip)
 384                                 x = pdata->sensor_max_x - x;
 385                         if (pdata->board->y_flip)
 386                                 y = pdata->sensor_max_y - y;
 387
 388                         input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,
 389                                                                 max(wx, wy));
 390                         input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 391                         input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 392
 393                         /* number of active touch points */
 394                         touch_count++;
 395                 }
 396         }
 397
 398         /* sync after groups of events */
 399         input_mt_sync_frame(input_dev);
 400         input_sync(input_dev);
 401         /* return the number of touch points */
 402         return touch_count;
 403 }
 404
 405 /**
 406  * synaptics_rmi4_report_device() - reports the rmi4 device
 407  * @pdata: pointer to synaptics_rmi4_data structure
 408  * @rfi: pointer to synaptics_rmi4_fn
 409  *
 410  * This function is used to call the report function of the rmi4 device.
 411  */
 412 static int synaptics_rmi4_report_device(struct synaptics_rmi4_data *pdata,
 413                                         struct synaptics_rmi4_fn *rfi)
 414 {
 415         int touch = 0;
 416         struct  i2c_client *client = pdata->i2c_client;
 417         static int num_error_reports;
 418
 419         if (rfi->fn_number != SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM) {
 420                 num_error_reports++;
 421                 if (num_error_reports < MAX_ERROR_REPORT)
 422                         dev_err(&client->dev, "%s:report not supported\n",
 423                                                                 __func__);
 424         } else
 425                 touch = synpatics_rmi4_touchpad_report(pdata, rfi);
 426         return touch;
 427 }
 428 /**
 429  * synaptics_rmi4_sensor_report() - reports to input subsystem
 430  * @pdata: pointer to synaptics_rmi4_data structure
 431  *
 432  * This function is used to reads in all data sources and reports
 433  * them to the input subsystem.
 434  */
 435 static int synaptics_rmi4_sensor_report(struct synaptics_rmi4_data *pdata)
 436 {
 437         unsigned char   intr_status[4];
 438         /* number of touch points - fingers or buttons */
 439         int touch = 0;
 440         unsigned int retval;
 441         struct synaptics_rmi4_fn                *rfi;
 442         struct synaptics_rmi4_device_info       *rmi;
 443         struct  i2c_client *client = pdata->i2c_client;
 444
 445         /*
 446          * Get the interrupt status from the function $01
 447          * control register+1 to find which source(s) were interrupting
 448          * so we can read the data from the source(s) (2D sensor, buttons..)
 449          */
 450         retval = synaptics_rmi4_i2c_block_read(pdata,
 451                                         pdata->fn01_data_base_addr + 1,
 452                                         intr_status,
 453                                         pdata->number_of_interrupt_register);
 454         if (retval != pdata->number_of_interrupt_register) {
 455                 dev_err(&client->dev,
 456                                 "could not read interrupt status registers\n");
 457                 return 0;
 458         }
 459         /*
 460          * check each function that has data sources and if the interrupt for
 461          * that triggered then call that RMI4 functions report() function to
 462          * gather data and report it to the input subsystem
 463          */
 464         rmi = &(pdata->rmi4_mod_info);
 465         list_for_each_entry(rfi, &rmi->support_fn_list, link) {
 466                 if (rfi->num_of_data_sources) {
 467                         if (intr_status[rfi->index_to_intr_reg] &
 468                                                         rfi->intr_mask)
 469                                 touch = synaptics_rmi4_report_device(pdata,
 470                                                                         rfi);
 471                 }
 472         }
 473         /* return the number of touch points */
 474         return touch;
 475 }
 476
 477 /**
 478  * synaptics_rmi4_irq() - thread function for rmi4 attention line
 479  * @irq: irq value
 480  * @data: void pointer
 481  *
 482  * This function is interrupt thread function. It just notifies the
 483  * application layer that attention is required.
 484  */
 485 static irqreturn_t synaptics_rmi4_irq(int irq, void *data)
 486 {
 487         struct synaptics_rmi4_data *pdata = data;
 488         int touch_count;
 489
 490         do {
 491                 touch_count = synaptics_rmi4_sensor_report(pdata);
 492                 if (touch_count)
 493                         wait_event_timeout(pdata->wait, pdata->touch_stopped,
 494                                                         msecs_to_jiffies(1));
 495                 else
 496                         break;
 497         } while (!pdata->touch_stopped);
 498         return IRQ_HANDLED;
 499 }
 500
 501 /**
 502  * synpatics_rmi4_touchpad_detect() - detects the rmi4 touchpad device
 503  * @pdata: pointer to synaptics_rmi4_data structure
 504  * @rfi: pointer to synaptics_rmi4_fn structure
 505  * @fd: pointer to synaptics_rmi4_fn_desc structure
 506  * @interruptcount: count the number of interrupts
 507  *
 508  * This function calls to detects the rmi4 touchpad device
 509  */
 510 static int synpatics_rmi4_touchpad_detect(struct synaptics_rmi4_data *pdata,
 511                                         struct synaptics_rmi4_fn *rfi,
 512                                         struct synaptics_rmi4_fn_desc *fd,
 513                                         unsigned int interruptcount)
 514 {
 515         unsigned char   queries[QUERY_LEN];
 516         unsigned short  intr_offset;
 517         unsigned char   abs_data_size;
 518         unsigned char   abs_data_blk_size;
 519         unsigned char   egr_0, egr_1;
 520         unsigned int    all_data_blk_size;
 521         int     has_pinch, has_flick, has_tap;
 522         int     has_tapandhold, has_doubletap;
 523         int     has_earlytap, has_press;
 524         int     has_palmdetect, has_rotate;
 525         int     has_rel;
 526         int     i;
 527         int     retval;
 528         struct  i2c_client *client = pdata->i2c_client;
 529
 530         rfi->fn_desc.query_base_addr    = fd->query_base_addr;
 531         rfi->fn_desc.data_base_addr     = fd->data_base_addr;
 532         rfi->fn_desc.intr_src_count     = fd->intr_src_count;
 533         rfi->fn_desc.fn_number          = fd->fn_number;
 534         rfi->fn_number                  = fd->fn_number;
 535         rfi->num_of_data_sources        = fd->intr_src_count;
 536         rfi->fn_desc.ctrl_base_addr     = fd->ctrl_base_addr;
 537         rfi->fn_desc.cmd_base_addr      = fd->cmd_base_addr;
 538
 539         /*
 540          * need to get number of fingers supported, data size, etc.
 541          * to be used when getting data since the number of registers to
 542          * read depends on the number of fingers supported and data size.
 543          */
 544         retval = synaptics_rmi4_i2c_block_read(pdata, fd->query_base_addr,
 545                                                         queries,
 546                                                         sizeof(queries));
 547         if (retval != sizeof(queries)) {
 548                 dev_err(&client->dev, "%s:read function query registers\n",
 549                                                         __func__);
 550                 return retval;
 551         }
 552         /*
 553          * 2D data sources have only 3 bits for the number of fingers
 554          * supported - so the encoding is a bit weird.
 555          */
 556         if ((queries[1] & MASK_3BIT) <= 4)
 557                 /* add 1 since zero based */
 558                 rfi->num_of_data_points = (queries[1] & MASK_3BIT) + 1;
 559         else {
 560                 /*
 561                  * a value of 5 is up to 10 fingers - 6 and 7 are reserved
 562                  * (shouldn't get these i int retval;n a normal 2D source).
 563                  */
 564                 if ((queries[1] & MASK_3BIT) == 5)
 565                         rfi->num_of_data_points = 10;
 566         }
 567         pdata->fingers_supported = rfi->num_of_data_points;
 568         /* Need to get interrupt info for handling interrupts */
 569         rfi->index_to_intr_reg = (interruptcount + 7)/8;
 570         if (rfi->index_to_intr_reg != 0)
 571                 rfi->index_to_intr_reg -= 1;
 572         /*
 573          * loop through interrupts for each source in fn $11
 574          * and or in a bit to the interrupt mask for each.
 575          */
 576         intr_offset = interruptcount % 8;
 577         rfi->intr_mask = 0;
 578         for (i = intr_offset;
 579                 i < ((fd->intr_src_count & MASK_3BIT) + intr_offset); i++)
 580                 rfi->intr_mask |= 1 << i;
 581
 582         /* Size of just the absolute data for one finger */
 583         abs_data_size   = queries[5] & MASK_2BIT;
 584         /* One each for X and Y, one for LSB for X & Y, one for W, one for Z */
 585         abs_data_blk_size = 3 + (2 * (abs_data_size == 0 ? 1 : 0));
 586         rfi->size_of_data_register_block = abs_data_blk_size;
 587
 588         /*
 589          * need to determine the size of data to read - this depends on
 590          * conditions such as whether Relative data is reported and if Gesture
 591          * data is reported.
 592          */
 593         egr_0 = queries[7];
 594         egr_1 = queries[8];
 595
 596         /*
 597          * Get info about what EGR data is supported, whether it has
 598          * Relative data supported, etc.
 599          */
 600         has_pinch       = egr_0 & HAS_PINCH;
 601         has_flick       = egr_0 & HAS_FLICK;
 602         has_tap         = egr_0 & HAS_TAP;
 603         has_earlytap    = egr_0 & HAS_EARLYTAP;
 604         has_press       = egr_0 & HAS_PRESS;
 605         has_rotate      = egr_1 & HAS_ROTATE;
 606         has_rel         = queries[1] & HAS_RELEASE;
 607         has_tapandhold  = egr_0 & HAS_TAPANDHOLD;
 608         has_doubletap   = egr_0 & HAS_DOUBLETAP;
 609         has_palmdetect  = egr_1 & HAS_PALMDETECT;
 610
 611         /*
 612          * Size of all data including finger status, absolute data for each
 613          * finger, relative data and EGR data
 614          */
 615         all_data_blk_size =
 616                 /* finger status, four fingers per register */
 617                 ((rfi->num_of_data_points + 3) / 4) +
 618                 /* absolute data, per finger times number of fingers */
 619                 (abs_data_blk_size * rfi->num_of_data_points) +
 620                 /*
 621                  * two relative registers (if relative is being reported)
 622                  */
 623                 2 * has_rel +
 624                 /*
 625                  * F11_2D_data8 is only present if the egr_0
 626                  * register is non-zero.
 627                  */
 628                 !!(egr_0) +
 629                 /*
 630                  * F11_2D_data9 is only present if either egr_0 or
 631                  * egr_1 registers are non-zero.
 632                  */
 633                 (egr_0 || egr_1) +
 634                 /*
 635                  * F11_2D_data10 is only present if EGR_PINCH or EGR_FLICK of
 636                  * egr_0 reports as 1.
 637                  */
 638                 !!(has_pinch | has_flick) +
 639                 /*
 640                  * F11_2D_data11 and F11_2D_data12 are only present if
 641                  * EGR_FLICK of egr_0 reports as 1.
 642                  */
 643                 2 * !!(has_flick);
 644         return retval;
 645 }
 646
 647 /**
 648  * synaptics_rmi4_touchpad_config() - configures the rmi4 touchpad device
 649  * @pdata: pointer to synaptics_rmi4_data structure
 650  * @rfi: pointer to synaptics_rmi4_fn structure
 651  *
 652  * This function calls to configures the rmi4 touchpad device
 653  */
 654 static int synaptics_rmi4_touchpad_config(struct synaptics_rmi4_data *pdata,
 655                                                 struct synaptics_rmi4_fn *rfi)
 656 {
 657         /*
 658          * For the data source - print info and do any
 659          * source specific configuration.
 660          */
 661         unsigned char data[BUF_LEN];
 662         int retval = 0;
 663         struct  i2c_client *client = pdata->i2c_client;
 664
 665         /* Get and print some info about the data source... */
 666         /* To Query 2D devices we need to read from the address obtained
 667          * from the function descriptor stored in the RMI function info.
 668          */
 669         retval = synaptics_rmi4_i2c_block_read(pdata,
 670                                                 rfi->fn_desc.query_base_addr,
 671                                                 data, QUERY_LEN);
 672         if (retval != QUERY_LEN)
 673                 dev_err(&client->dev, "%s:read query registers failed\n",
 674                                                                 __func__);
 675         else {
 676                 retval = synaptics_rmi4_i2c_block_read(pdata,
 677                                                 rfi->fn_desc.ctrl_base_addr,
 678                                                 data, DATA_BUF_LEN);
 679                 if (retval != DATA_BUF_LEN) {
 680                         dev_err(&client->dev,
 681                                 "%s:read control registers failed\n",
 682                                                                 __func__);
 683                         return retval;
 684                 }
 685                 /* Store these for use later*/
 686                 pdata->sensor_max_x = ((data[6] & MASK_8BIT) << 0) |
 687                                                 ((data[7] & MASK_4BIT) << 8);
 688                 pdata->sensor_max_y = ((data[8] & MASK_5BIT) << 0) |
 689                                                 ((data[9] & MASK_4BIT) << 8);
 690         }
 691         return retval;
 692 }
 693
 694 /**
 695  * synaptics_rmi4_i2c_query_device() - query the rmi4 device
 696  * @pdata: pointer to synaptics_rmi4_data structure
 697  *
 698  * This function is used to query the rmi4 device.
 699  */
 700 static int synaptics_rmi4_i2c_query_device(struct synaptics_rmi4_data *pdata)
 701 {
 702         int i;
 703         int retval;
 704         unsigned char std_queries[STD_QUERY_LEN];
 705         unsigned char intr_count = 0;
 706         int data_sources = 0;
 707         unsigned int ctrl_offset;
 708         struct synaptics_rmi4_fn *rfi;
 709         struct synaptics_rmi4_fn_desc   rmi_fd;
 710         struct synaptics_rmi4_device_info *rmi;
 711         struct  i2c_client *client = pdata->i2c_client;
 712
 713         /*
 714          * init the physical drivers RMI module
 715          * info list of functions
 716          */
 717         INIT_LIST_HEAD(&pdata->rmi4_mod_info.support_fn_list);
 718
 719         /*
 720          * Read the Page Descriptor Table to determine what functions
 721          * are present
 722          */
 723         for (i = PDT_START_SCAN_LOCATION; i > PDT_END_SCAN_LOCATION;
 724                                                 i -= PDT_ENTRY_SIZE) {
 725                 retval = synaptics_rmi4_i2c_block_read(pdata, i,
 726                                                 (unsigned char *)&rmi_fd,
 727                                                 sizeof(rmi_fd));
 728                 if (retval != sizeof(rmi_fd)) {
 729                         /* failed to read next PDT entry */
 730                         dev_err(&client->dev, "%s: read error\n", __func__);
 731                         return -EIO;
 732                 }
 733                 rfi = NULL;
 734                 if (rmi_fd.fn_number) {
 735                         switch (rmi_fd.fn_number & MASK_8BIT) {
 736                         case SYNAPTICS_RMI4_DEVICE_CONTROL_FUNC_NUM:
 737                                 pdata->fn01_query_base_addr =
 738                                                 rmi_fd.query_base_addr;
 739                                 pdata->fn01_ctrl_base_addr =
 740                                                 rmi_fd.ctrl_base_addr;
 741                                 pdata->fn01_data_base_addr =
 742                                                 rmi_fd.data_base_addr;
 743                                 break;
 744                         case SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM:
 745                                 if (rmi_fd.intr_src_count) {
 746                                         rfi = kmalloc(sizeof(*rfi),
 747                                                       GFP_KERNEL);
 748                                         if (!rfi)
 749                                                 return -ENOMEM;
 750                                         retval = synpatics_rmi4_touchpad_detect
 751                                                                 (pdata, rfi,
 752                                                                 &rmi_fd,
 753                                                                 intr_count);
 754                                         if (retval < 0) {
 755                                                 kfree(rfi);
 756                                                 return retval;
 757                                         }
 758                                 }
 759                                 break;
 760                         }
 761                         /* interrupt count for next iteration */
 762                         intr_count += (rmi_fd.intr_src_count & MASK_3BIT);
 763                         /*
 764                          * We only want to add functions to the list
 765                          * that have data associated with them.
 766                          */
 767                         if (rfi && rmi_fd.intr_src_count) {
 768                                 /* link this function info to the RMI module */
 769                                 mutex_lock(&(pdata->fn_list_mutex));
 770                                 list_add_tail(&rfi->link,
 771                                         &pdata->rmi4_mod_info.support_fn_list);
 772                                 mutex_unlock(&(pdata->fn_list_mutex));
 773                         }
 774                 } else {
 775                         /*
 776                          * A zero in the function number
 777                          * signals the end of the PDT
 778                          */
 779                         dev_dbg(&client->dev,
 780                                 "%s:end of PDT\n", __func__);
 781                         break;
 782                 }
 783         }
 784         /*
 785          * calculate the interrupt register count - used in the
 786          * ISR to read the correct number of interrupt registers
 787          */
 788         pdata->number_of_interrupt_register = (intr_count + 7) / 8;
 789         /*
 790          * Function $01 will be used to query the product properties,
 791          * and product ID  so we had to read the PDT above first to get
 792          * the Fn $01 query address and prior to filling in the product
 793          * info. NOTE: Even an unflashed device will still have FN $01.
 794          */
 795
 796         /* Load up the standard queries and get the RMI4 module info */
 797         retval = synaptics_rmi4_i2c_block_read(pdata,
 798                                         pdata->fn01_query_base_addr,
 799                                         std_queries,
 800                                         sizeof(std_queries));
 801         if (retval != sizeof(std_queries)) {
 802                 dev_err(&client->dev, "%s:Failed reading queries\n",
 803                                                         __func__);
 804                  return -EIO;
 805         }
 806
 807         /* Currently supported RMI version is 4.0 */
 808         pdata->rmi4_mod_info.version_major      = 4;
 809         pdata->rmi4_mod_info.version_minor      = 0;
 810         /*
 811          * get manufacturer id, product_props, product info,
 812          * date code, tester id, serial num and product id (name)
 813          */
 814         pdata->rmi4_mod_info.manufacturer_id    = std_queries[0];
 815         pdata->rmi4_mod_info.product_props      = std_queries[1];
 816         pdata->rmi4_mod_info.product_info[0]    = std_queries[2];
 817         pdata->rmi4_mod_info.product_info[1]    = std_queries[3];
 818         /* year - 2001-2032 */
 819         pdata->rmi4_mod_info.date_code[0]       = std_queries[4] & MASK_5BIT;
 820         /* month - 1-12 */
 821         pdata->rmi4_mod_info.date_code[1]       = std_queries[5] & MASK_4BIT;
 822         /* day - 1-31 */
 823         pdata->rmi4_mod_info.date_code[2]       = std_queries[6] & MASK_5BIT;
 824         pdata->rmi4_mod_info.tester_id = ((std_queries[7] & MASK_7BIT) << 8) |
 825                                                 (std_queries[8] & MASK_7BIT);
 826         pdata->rmi4_mod_info.serial_number =
 827                 ((std_queries[9] & MASK_7BIT) << 8) |
 828                                 (std_queries[10] & MASK_7BIT);
 829         memcpy(pdata->rmi4_mod_info.product_id_string, &std_queries[11], 10);
 830
 831         /* Check if this is a Synaptics device - report if not. */
 832         if (pdata->rmi4_mod_info.manufacturer_id != 1)
 833                 dev_err(&client->dev, "non-Synaptics mfg id:%d\n",
 834                         pdata->rmi4_mod_info.manufacturer_id);
 835
 836         list_for_each_entry(rfi, &pdata->rmi4_mod_info.support_fn_list, link)
 837                 data_sources += rfi->num_of_data_sources;
 838         if (data_sources) {
 839                 rmi = &(pdata->rmi4_mod_info);
 840                 list_for_each_entry(rfi, &rmi->support_fn_list, link) {
 841                         if (rfi->num_of_data_sources) {
 842                                 if (rfi->fn_number ==
 843                                         SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM) {
 844                                         retval = synaptics_rmi4_touchpad_config
 845                                                                 (pdata, rfi);
 846                                         if (retval < 0)
 847                                                 return retval;
 848                                 } else
 849                                         dev_err(&client->dev,
 850                                                 "%s:fn_number not supported\n",
 851                                                                 __func__);
 852                                 /*
 853                                  * Turn on interrupts for this
 854                                  * function's data sources.
 855                                  */
 856                                 ctrl_offset = pdata->fn01_ctrl_base_addr + 1 +
 857                                                         rfi->index_to_intr_reg;
 858                                 retval = synaptics_rmi4_i2c_byte_write(pdata,
 859                                                         ctrl_offset,
 860                                                         rfi->intr_mask);
 861                                 if (retval < 0)
 862                                         return retval;
 863                         }
 864                 }
 865         }
 866         return 0;
 867 }
 868
 869 /*
 870  * Descriptor structure.
 871  * Describes the number of i2c devices on the bus that speak RMI.
 872  */
 873 static struct synaptics_rmi4_platform_data synaptics_rmi4_platformdata = {
 874         .irq_type       = (IRQF_TRIGGER_FALLING | IRQF_SHARED),
 875         .x_flip         = false,
 876         .y_flip         = true,
 877 };
 878
 879 /**
 880  * synaptics_rmi4_probe() - Initialze the i2c-client touchscreen driver
 881  * @i2c: i2c client structure pointer
 882  * @id:i2c device id pointer
 883  *
 884  * This function will allocate and initialize the instance
 885  * data and request the irq and set the instance data as the clients
 886  * platform data then register the physical driver which will do a scan of
 887  * the rmi4 Physical Device Table and enumerate any rmi4 functions that
 888  * have data sources associated with them.
 889  */
 890 static int synaptics_rmi4_probe
 891         (struct i2c_client *client, const struct i2c_device_id *dev_id)
 892 {
 893         int retval;
 894         unsigned char intr_status[4];
 895         struct synaptics_rmi4_data *rmi4_data;
 896         const struct synaptics_rmi4_platform_data *platformdata =
 897                                                 client->dev.platform_data;
 898
 899         if (!i2c_check_functionality(client->adapter,
 900                                         I2C_FUNC_SMBUS_BYTE_DATA)) {
 901                 dev_err(&client->dev, "i2c smbus byte data not supported\n");
 902                 return -EIO;
 903         }
 904
 905         if (!platformdata)
 906                 platformdata = &synaptics_rmi4_platformdata;
 907
 908         /* Allocate and initialize the instance data for this client */
 909         rmi4_data = kcalloc(2, sizeof(struct synaptics_rmi4_data),
 910                             GFP_KERNEL);
 911         if (!rmi4_data)
 912                 return -ENOMEM;
 913
 914         rmi4_data->input_dev = input_allocate_device();
 915         if (rmi4_data->input_dev == NULL) {
 916                 retval = -ENOMEM;
 917                 goto err_input;
 918         }
 919
 920         rmi4_data->regulator = regulator_get(&client->dev, "vdd");
 921         if (IS_ERR(rmi4_data->regulator)) {
 922                 dev_err(&client->dev, "%s:get regulator failed\n",
 923                                                         __func__);
 924                 retval = PTR_ERR(rmi4_data->regulator);
 925                 goto err_get_regulator;
 926         }
 927         retval = regulator_enable(rmi4_data->regulator);
 928         if (retval < 0) {
 929                 dev_err(&client->dev, "%s:regulator enable failed\n",
 930                                                         __func__);
 931                 goto err_regulator_enable;
 932         }
 933         init_waitqueue_head(&rmi4_data->wait);
 934         /*
 935          * Copy i2c_client pointer into RTID's i2c_client pointer for
 936          * later use in rmi4_read, rmi4_write, etc.
 937          */
 938         rmi4_data->i2c_client           = client;
 939         /* So we set the page correctly the first time */
 940         rmi4_data->current_page         = MASK_16BIT;
 941         rmi4_data->board                = platformdata;
 942         rmi4_data->touch_stopped        = false;
 943
 944         /* init the mutexes for maintain the lists */
 945         mutex_init(&(rmi4_data->fn_list_mutex));
 946         mutex_init(&(rmi4_data->rmi4_page_mutex));
 947
 948         /*
 949          * Register physical driver - this will call the detect function that
 950          * will then scan the device and determine the supported
 951          * rmi4 functions.
 952          */
 953         retval = synaptics_rmi4_i2c_query_device(rmi4_data);
 954         if (retval) {
 955                 dev_err(&client->dev, "%s: rmi4 query device failed\n",
 956                                                         __func__);
 957                 goto err_query_dev;
 958         }
 959
 960         /* Store the instance data in the i2c_client */
 961         i2c_set_clientdata(client, rmi4_data);
 962
 963         /*initialize the input device parameters */
 964         rmi4_data->input_dev->name      = DRIVER_NAME;
 965         rmi4_data->input_dev->phys      = "Synaptics_Clearpad";
 966         rmi4_data->input_dev->id.bustype = BUS_I2C;
 967         rmi4_data->input_dev->dev.parent = &client->dev;
 968         input_set_drvdata(rmi4_data->input_dev, rmi4_data);
 969
 970         /* Initialize the function handlers for rmi4 */
 971         set_bit(EV_SYN, rmi4_data->input_dev->evbit);
 972         set_bit(EV_KEY, rmi4_data->input_dev->evbit);
 973         set_bit(EV_ABS, rmi4_data->input_dev->evbit);
 974
 975         input_set_abs_params(rmi4_data->input_dev, ABS_MT_POSITION_X, 0,
 976                                         rmi4_data->sensor_max_x, 0, 0);
 977         input_set_abs_params(rmi4_data->input_dev, ABS_MT_POSITION_Y, 0,
 978                                         rmi4_data->sensor_max_y, 0, 0);
 979         input_set_abs_params(rmi4_data->input_dev, ABS_MT_TOUCH_MAJOR, 0,
 980                                                 MAX_TOUCH_MAJOR, 0, 0);
 981         input_mt_init_slots(rmi4_data->input_dev,
 982                                 rmi4_data->fingers_supported, 0);
 983
 984         /* Clear interrupts */
 985         synaptics_rmi4_i2c_block_read(rmi4_data,
 986                         rmi4_data->fn01_data_base_addr + 1, intr_status,
 987                                 rmi4_data->number_of_interrupt_register);
 988         retval = request_threaded_irq(client->irq, NULL,
 989                                         synaptics_rmi4_irq,
 990                                         platformdata->irq_type,
 991                                         DRIVER_NAME, rmi4_data);
 992         if (retval) {
 993                 dev_err(&client->dev, "Unable to get attn irq %d\n",
 994                         client->irq);
 995                 goto err_query_dev;
 996         }
 997
 998         retval = input_register_device(rmi4_data->input_dev);
 999         if (retval) {
1000                 dev_err(&client->dev, "%s:input register failed\n", __func__);
1001                 goto err_free_irq;
1002         }
1003
1004         return retval;
1005
1006 err_free_irq:
1007         free_irq(client->irq, rmi4_data);
1008 err_query_dev:
1009         regulator_disable(rmi4_data->regulator);
1010 err_regulator_enable:
1011         regulator_put(rmi4_data->regulator);
1012 err_get_regulator:
1013         input_free_device(rmi4_data->input_dev);
1014         rmi4_data->input_dev = NULL;
1015 err_input:
1016         kfree(rmi4_data);
1017
1018         return retval;
1019 }
1020 /**
1021  * synaptics_rmi4_remove() - Removes the i2c-client touchscreen driver
1022  * @client: i2c client structure pointer
1023  *
1024  * This function uses to remove the i2c-client
1025  * touchscreen driver and returns integer.
1026  */
1027 static int synaptics_rmi4_remove(struct i2c_client *client)
1028 {
1029         struct synaptics_rmi4_data *rmi4_data = i2c_get_clientdata(client);
1030
1031         rmi4_data->touch_stopped = true;
1032         wake_up(&rmi4_data->wait);
1033         free_irq(client->irq, rmi4_data);
1034         input_unregister_device(rmi4_data->input_dev);
1035         regulator_disable(rmi4_data->regulator);
1036         regulator_put(rmi4_data->regulator);
1037         kfree(rmi4_data);
1038
1039         return 0;
1040 }
1041
1042 #ifdef CONFIG_PM
1043 /**
1044  * synaptics_rmi4_suspend() - suspend the touch screen controller
1045  * @dev: pointer to device structure
1046  *
1047  * This function is used to suspend the
1048  * touch panel controller and returns integer
1049  */
1050 static int synaptics_rmi4_suspend(struct device *dev)
1051 {
1052         /* Touch sleep mode */
1053         int retval;
1054         unsigned char intr_status;
1055         struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
1056
1057         rmi4_data->touch_stopped = true;
1058         disable_irq(rmi4_data->i2c_client->irq);
1059
1060         retval = synaptics_rmi4_i2c_block_read(rmi4_data,
1061                                 rmi4_data->fn01_data_base_addr + 1,
1062                                 &intr_status,
1063                                 rmi4_data->number_of_interrupt_register);
1064         if (retval < 0)
1065                 return retval;
1066
1067         retval = synaptics_rmi4_i2c_byte_write(rmi4_data,
1068                                         rmi4_data->fn01_ctrl_base_addr + 1,
1069                                         (intr_status & ~TOUCHPAD_CTRL_INTR));
1070         if (retval < 0)
1071                 return retval;
1072
1073         regulator_disable(rmi4_data->regulator);
1074
1075         return 0;
1076 }
1077 /**
1078  * synaptics_rmi4_resume() - resume the touch screen controller
1079  * @dev: pointer to device structure
1080  *
1081  * This function is used to resume the touch panel
1082  * controller and returns integer.
1083  */
1084 static int synaptics_rmi4_resume(struct device *dev)
1085 {
1086         int retval;
1087         unsigned char intr_status;
1088         struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
1089
1090         retval = regulator_enable(rmi4_data->regulator);
1091         if (retval) {
1092                 dev_err(dev, "Regulator enable failed (%d)\n", retval);
1093                 return retval;
1094         }
1095
1096         enable_irq(rmi4_data->i2c_client->irq);
1097         rmi4_data->touch_stopped = false;
1098
1099         retval = synaptics_rmi4_i2c_block_read(rmi4_data,
1100                                 rmi4_data->fn01_data_base_addr + 1,
1101                                 &intr_status,
1102                                 rmi4_data->number_of_interrupt_register);
1103         if (retval < 0)
1104                 return retval;
1105
1106         retval = synaptics_rmi4_i2c_byte_write(rmi4_data,
1107                                         rmi4_data->fn01_ctrl_base_addr + 1,
1108                                         (intr_status | TOUCHPAD_CTRL_INTR));
1109         if (retval < 0)
1110                 return retval;
1111
1112         return 0;
1113 }
1114
1115 #endif
1116
1117 static SIMPLE_DEV_PM_OPS(synaptics_rmi4_dev_pm_ops, synaptics_rmi4_suspend,
1118                          synaptics_rmi4_resume);
1119
1120 static const struct i2c_device_id synaptics_rmi4_id_table[] = {
1121         { DRIVER_NAME, 0 },
1122         { },
1123 };
1124 MODULE_DEVICE_TABLE(i2c, synaptics_rmi4_id_table);
1125
1126 static struct i2c_driver synaptics_rmi4_driver = {
1127         .driver = {
1128                 .name   =       DRIVER_NAME,
1129                 .owner  =       THIS_MODULE,
1130                 .pm     =       &synaptics_rmi4_dev_pm_ops,
1131         },
1132         .probe          =       synaptics_rmi4_probe,
1133         .remove         =       synaptics_rmi4_remove,
1134         .id_table       =       synaptics_rmi4_id_table,
1135 };
1136
1137 module_i2c_driver(synaptics_rmi4_driver);
1138
1139 MODULE_LICENSE("GPL v2");
1140 MODULE_AUTHOR("naveen.gaddipati@stericsson.com, js.ha@stericsson.com");
1141 MODULE_DESCRIPTION("synaptics rmi4 i2c touch Driver");
1142 MODULE_ALIAS("i2c:synaptics_rmi4_ts");