drivers/nfc/bcm2079x-i2c.c

   1 /*
   2  * Copyright (C) 2012 Broadcom Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/module.h>
  22 #include <linux/fs.h>
  23 #include <linux/slab.h>
  24 #include <linux/init.h>
  25 #include <linux/list.h>
  26 #include <linux/i2c.h>
  27 #include <linux/irq.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/delay.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/io.h>
  33 #include <linux/platform_device.h>
  34 #include <linux/gpio.h>
  35 #include <linux/miscdevice.h>
  36 #include <linux/spinlock.h>
  37 #include <linux/poll.h>
  38 #include <linux/version.h>
  39 #ifdef CONFIG_OF
  40 #include <linux/of.h>
  41 #include <linux/of_device.h>
  42 #include <linux/of_gpio.h>
  43 #endif
  44
  45 #include <linux/bcm2079x.h>
  46
  47 #define USE_WAKE_LOCK
  48
  49 #ifdef USE_WAKE_LOCK
  50 #include <linux/wakelock.h>
  51 #endif
  52
  53 #define TRUE            1
  54 #define FALSE           0
  55 #define STATE_HIGH      1
  56 #define STATE_LOW       0
  57
  58 /* end of compile options */
  59
  60 /* do not change below */
  61 #define MAX_BUFFER_SIZE         780
  62
  63         /* Read data */
  64 #define PACKET_HEADER_SIZE_NCI  (4)
  65 #define PACKET_HEADER_SIZE_HCI  (3)
  66 #define PACKET_TYPE_NCI         (16)
  67 #define PACKET_TYPE_HCIEV       (4)
  68 #define MAX_PACKET_SIZE         (PACKET_HEADER_SIZE_NCI + 255)
  69
  70 struct bcm2079x_dev {
  71         wait_queue_head_t read_wq;
  72         struct mutex read_mutex;
  73         struct i2c_client *client;
  74         struct miscdevice bcm2079x_device;
  75         unsigned int wake_gpio;
  76         unsigned int en_gpio;
  77         unsigned int irq_gpio;
  78         bool irq_enabled;
  79         spinlock_t irq_enabled_lock;
  80         unsigned int error_write;
  81         unsigned int error_read;
  82         unsigned int count_read;
  83         unsigned int count_irq;
  84         int original_address;
  85 #ifdef USE_WAKE_LOCK
  86         struct wake_lock wake_lock;
  87 #endif
  88 };
  89
  90 #define BCM2079X_NAME   "bcm2079x-i2c"
  91 #define VERSION "AMPAK-BCM2079X-DRIVER-VERSION-1.0.0"
  92 unsigned int nfc_handle = -1;
  93 unsigned int bcm2079x_irq_handle(void *para);
  94
  95 static void bcm2079x_init_stat(struct bcm2079x_dev *bcm2079x_dev)
  96 {
  97         bcm2079x_dev->error_write = 0;
  98         bcm2079x_dev->error_read = 0;
  99         bcm2079x_dev->count_read = 0;
 100         bcm2079x_dev->count_irq = 0;
 101 }
 102
 103 static void bcm2079x_disable_irq(struct bcm2079x_dev *bcm2079x_dev)
 104 {
 105         unsigned long flags;
 106
 107         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
 108         if (bcm2079x_dev->irq_enabled) {
 109                 disable_irq_nosync(bcm2079x_dev->client->irq);
 110                 bcm2079x_dev->irq_enabled = false;
 111         }
 112         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
 113 }
 114
 115 static void bcm2079x_enable_irq(struct bcm2079x_dev *bcm2079x_dev)
 116 {
 117         unsigned long flags;
 118         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
 119         if (!bcm2079x_dev->irq_enabled) {
 120                 bcm2079x_dev->irq_enabled = true;
 121                 enable_irq(bcm2079x_dev->client->irq);
 122         }
 123         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
 124 }
 125
 126 /*
 127  The alias address 0x79, when sent as a 7-bit address from the host processor
 128  will match the first byte (highest 2 bits) of the default client address
 129  (0x1FA) that is programmed in bcm20791.
 130  When used together with the first byte (0xFA) of the byte sequence below,
 131  it can be used to address the bcm20791 in a system that does not support
 132  10-bit address and change the default address to 0x38.
 133  the new address can be changed by changing the CLIENT_ADDRESS below if 0x38
 134  conflicts with other device on the same i2c bus.
 135  */
 136 #define ALIAS_ADDRESS     0x79
 137
 138 static void set_client_addr(struct bcm2079x_dev *bcm2079x_dev, int addr)
 139 {
 140         struct i2c_client *client = bcm2079x_dev->client;
 141         client->addr = addr;
 142         if (addr > 0x7F)
 143                 client->flags |= I2C_CLIENT_TEN;
 144        else
 145                 client->flags &= ~I2C_CLIENT_TEN;
 146
 147         dev_info(&client->dev,
 148                 "Set client device changed to (0x%04X) flag = %04x\n",
 149                 client->addr, client->flags);
 150 }
 151
 152 static void change_client_addr(struct bcm2079x_dev *bcm2079x_dev, int addr)
 153 {
 154         struct i2c_client *client;
 155         int ret;
 156         int i;
 157         int offset = 1;
 158         char addr_data[] = {
 159                 0xFA, 0xF2, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x2A
 160         };
 161
 162         client = bcm2079x_dev->client;
 163         if ((client->flags & I2C_CLIENT_TEN) == I2C_CLIENT_TEN) {
 164                 client->addr = ALIAS_ADDRESS;
 165                 client->flags &= ~I2C_CLIENT_TEN;
 166                 offset = 0;
 167         }
 168
 169         addr_data[5] = addr & 0xFF;
 170         ret = 0;
 171         for (i = 1; i < sizeof(addr_data) - 1; ++i)
 172                 ret += addr_data[i];
 173         addr_data[sizeof(addr_data) - 1] = (ret & 0xFF);
 174         dev_info(&client->dev,
 175                  "Change client device from (0x%04X) flag = "\
 176                  "%04x, addr_data[%d] = %02x\n",
 177                  client->addr, client->flags, sizeof(addr_data) - 1,
 178                  addr_data[sizeof(addr_data) - 1]);
 179         ret = i2c_master_send(client, addr_data+offset, sizeof(addr_data)-offset);
 180         if (ret != sizeof(addr_data)-offset) {
 181                 client->addr = ALIAS_ADDRESS;
 182                 client->flags &= ~I2C_CLIENT_TEN;
 183                 dev_info(&client->dev,
 184                          "Change client device from (0x%04X) flag = "\
 185                          "%04x, addr_data[%d] = %02x\n",
 186                          client->addr, client->flags, sizeof(addr_data) - 1,
 187                          addr_data[sizeof(addr_data) - 1]);
 188                 ret = i2c_master_send(client, addr_data, sizeof(addr_data));
 189         }
 190         client->addr = addr_data[5];
 191
 192         dev_info(&client->dev,
 193                  "Change client device changed to (0x%04X) flag = %04x, ret = %d\n",
 194                  client->addr, client->flags, ret);
 195 }
 196
 197 static irqreturn_t bcm2079x_dev_irq_handler(int irq, void *dev_id)
 198 {
 199         struct bcm2079x_dev *bcm2079x_dev = dev_id;
 200         unsigned long flags;
 201 #ifdef USE_WAKE_LOCK
 202         int wakelockcnt = 0;
 203 #endif
 204
 205         printk("%s: nfc irq handler\n", __func__);
 206 #ifdef USE_WAKE_LOCK
 207         if(!(wakelockcnt =  wake_lock_active(&bcm2079x_dev->wake_lock )))
 208         {
 209                 printk("irq aquire wake lock\n");
 210                 wake_lock(&bcm2079x_dev->wake_lock);
 211         }else
 212         {
 213 //              printk("irq wake lock count = %d\n", wakelockcnt);
 214         }
 215         //printk("irq handler ( wake lock %d)...\n", wakelockcnt);
 216 #endif
 217
 218         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
 219         bcm2079x_dev->count_irq++;
 220         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
 221         wake_up(&bcm2079x_dev->read_wq);
 222
 223         return IRQ_HANDLED;
 224 }
 225
 226 static unsigned int bcm2079x_dev_poll(struct file *filp, poll_table *wait)
 227 {
 228         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
 229         unsigned int mask = 0;
 230         unsigned long flags;
 231
 232         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
 233         //Platform specific API
 234         //if(!__gpio_get_value(bcm2079x_dev->irq_gpio) && (bcm2079x_dev->count_irq < 1) )
 235         if(!gpio_get_value(bcm2079x_dev->irq_gpio) && (bcm2079x_dev->count_irq < 1) )
 236         {
 237                 spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
 238 //              printk("poll wait, irq count %d, irq_gpio %d\n", bcm2079x_dev->count_irq,  bcm2079x_dev->irq_gpio  );
 239                 poll_wait(filp, &bcm2079x_dev->read_wq, wait);
 240         }else
 241         {
 242                 if (bcm2079x_dev->count_irq < 1)
 243                         bcm2079x_dev->count_irq = 1;
 244
 245                 spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
 246 //              printk("poll there is data to read!!! no wait any more.\n");
 247                 return (POLLIN | POLLRDNORM);
 248         }
 249
 250         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
 251         if (bcm2079x_dev->count_irq > 0)
 252                 mask |= POLLIN | POLLRDNORM;
 253         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
 254
 255         return mask;
 256 }
 257
 258 static ssize_t bcm2079x_dev_read(struct file *filp, char __user *buf,
 259                                   size_t count, loff_t *offset)
 260 {
 261         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
 262         unsigned char tmp[MAX_BUFFER_SIZE];
 263         int total, len, ret;
 264
 265         total = 0;
 266         len = 0;
 267
 268         if (bcm2079x_dev->count_irq > 0)
 269                 bcm2079x_dev->count_irq--;
 270
 271         bcm2079x_dev->count_read++;
 272         if (count > MAX_BUFFER_SIZE)
 273                 count = MAX_BUFFER_SIZE;
 274
 275         mutex_lock(&bcm2079x_dev->read_mutex);
 276
 277         /** Read the first 4 bytes to include the length of the NCI or HCI packet.
 278         **/
 279         ret = i2c_master_recv(bcm2079x_dev->client, tmp, 4);
 280         if (ret == 4) {
 281                 total = ret;
 282                 /** First byte is the packet type
 283                 **/
 284                 switch(tmp[0]) {
 285                         case PACKET_TYPE_NCI:
 286                                 len = tmp[PACKET_HEADER_SIZE_NCI-1];
 287                                 break;
 288
 289                         case PACKET_TYPE_HCIEV:
 290                                 len = tmp[PACKET_HEADER_SIZE_HCI-1];
 291                                 if (len == 0)
 292                                         total--;                                /*Since payload is 0, decrement total size (from 4 to 3) */
 293                                 else
 294                                         len--;                                  /*First byte of payload is in tmp[3] already */
 295                                 break;
 296
 297                         default:
 298                                 len = 0;                                        /*Unknown packet byte */
 299                                 break;
 300                 } /* switch*/
 301
 302                 /** make sure full packet fits in the buffer
 303                 **/
 304                 if (len > 0 && (len + total) <= count) {
 305                         /** read the remainder of the packet.
 306                         **/
 307                         ret = i2c_master_recv(bcm2079x_dev->client, tmp+total, len);
 308                         if (ret == len)
 309                                 total += len;
 310                 } /* if */
 311         } /* if */
 312
 313         mutex_unlock(&bcm2079x_dev->read_mutex);
 314
 315         if (total > count || copy_to_user(buf, tmp, total)) {
 316                 dev_err(&bcm2079x_dev->client->dev,
 317                         "failed to copy to user space, total = %d\n", total);
 318                 total = -EFAULT;
 319                 bcm2079x_dev->error_read++;
 320         }
 321
 322         return total;
 323 }
 324
 325 static ssize_t bcm2079x_dev_write(struct file *filp, const char __user *buf,
 326                                    size_t count, loff_t *offset)
 327 {
 328         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
 329         char tmp[MAX_BUFFER_SIZE];
 330         int ret;
 331
 332         if (count > MAX_BUFFER_SIZE) {
 333                 dev_err(&bcm2079x_dev->client->dev, "out of memory\n");
 334                 return -ENOMEM;
 335         }
 336
 337         if (copy_from_user(tmp, buf, count)) {
 338                 dev_err(&bcm2079x_dev->client->dev,
 339                         "failed to copy from user space\n");
 340                 return -EFAULT;
 341         }
 342
 343         mutex_lock(&bcm2079x_dev->read_mutex);
 344         /* Write data */
 345
 346         ret = i2c_master_send(bcm2079x_dev->client, tmp, count);
 347         if (ret != count) {
 348                 if ((bcm2079x_dev->client->flags & I2C_CLIENT_TEN) != I2C_CLIENT_TEN && bcm2079x_dev->error_write == 0) {
 349                         set_client_addr(bcm2079x_dev, 0x1FA);
 350                         ret = i2c_master_send(bcm2079x_dev->client, tmp, count);
 351                         if (ret != count)
 352                                 bcm2079x_dev->error_write++;
 353                        set_client_addr(bcm2079x_dev, bcm2079x_dev->original_address);
 354                 } else {
 355                         dev_err(&bcm2079x_dev->client->dev,
 356                                 "failed to write %d\n", ret);
 357                         ret = -EIO;
 358                         bcm2079x_dev->error_write++;
 359                 }
 360         }
 361         mutex_unlock(&bcm2079x_dev->read_mutex);
 362
 363         return ret;
 364 }
 365
 366 static int bcm2079x_dev_open(struct inode *inode, struct file *filp)
 367 {
 368         int ret = 0;
 369
 370         struct bcm2079x_dev *bcm2079x_dev = container_of(filp->private_data,
 371                                                            struct bcm2079x_dev,
 372                                                            bcm2079x_device);
 373         filp->private_data = bcm2079x_dev;
 374         bcm2079x_init_stat(bcm2079x_dev);
 375         bcm2079x_enable_irq(bcm2079x_dev);
 376         dev_info(&bcm2079x_dev->client->dev,
 377                  "device node major=%d, minor=%d\n", imajor(inode), iminor(inode));
 378
 379         return ret;
 380 }
 381
 382 static long bcm2079x_dev_unlocked_ioctl(struct file *filp,
 383                                          unsigned int cmd, unsigned long arg)
 384 {
 385         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
 386
 387         switch (cmd) {
 388         case BCMNFC_READ_FULL_PACKET:
 389                 break;
 390         case BCMNFC_READ_MULTI_PACKETS:
 391                 break;
 392         case BCMNFC_CHANGE_ADDR:
 393                 dev_info(&bcm2079x_dev->client->dev,
 394                          "%s, BCMNFC_CHANGE_ADDR (%x, %lx):\n", __func__, cmd,
 395                          arg);
 396                 change_client_addr(bcm2079x_dev, arg);
 397                 break;
 398         case BCMNFC_POWER_CTL:
 399                 dev_info(&bcm2079x_dev->client->dev,
 400                          "%s, BCMNFC_POWER_CTL (%x, %lx):\n", __func__, cmd, arg);
 401                 if (arg != 1)
 402                         set_client_addr(bcm2079x_dev, bcm2079x_dev->original_address);
 403             gpio_direction_output(bcm2079x_dev->en_gpio, arg);
 404         gpio_set_value(bcm2079x_dev->en_gpio, arg);
 405                 break;
 406         case BCMNFC_WAKE_CTL:
 407                 dev_info(&bcm2079x_dev->client->dev,
 408                          "%s, BCMNFC_WAKE_CTL (%x, %lx):\n", __func__, cmd, arg);
 409 #ifdef USE_WAKE_LOCK
 410                 if(arg != 0)
 411                 {
 412                         while(wake_lock_active(&bcm2079x_dev->wake_lock ))
 413                         {
 414                                 printk("release wake lock!!!\n");
 415                                 wake_unlock(&bcm2079x_dev->wake_lock);
 416                         }
 417                         //wake_lock_timeout(&bcm2079x_dev->wake_lock, HZ*2);
 418                 }
 419 #endif
 420             gpio_direction_output(bcm2079x_dev->wake_gpio, arg);
 421         gpio_set_value(bcm2079x_dev->wake_gpio, arg);
 422                 break;
 423         default:
 424                 dev_err(&bcm2079x_dev->client->dev,
 425                         "%s, unknown cmd (%x, %lx)\n", __func__, cmd, arg);
 426                 return 0;
 427         }
 428
 429         return 0;
 430 }
 431
 432 static const struct file_operations bcm2079x_dev_fops = {
 433         .owner = THIS_MODULE,
 434         .llseek = no_llseek,
 435         .poll = bcm2079x_dev_poll,
 436         .read = bcm2079x_dev_read,
 437         .write = bcm2079x_dev_write,
 438         .open = bcm2079x_dev_open,
 439         .unlocked_ioctl = bcm2079x_dev_unlocked_ioctl
 440 };
 441
 442 unsigned int bcm2079x_irq_handle(void *para)
 443 {
 444         bcm2079x_dev_irq_handler(0, para);
 445         return 0;
 446 }
 447
 448 #ifdef CONFIG_OF
 449 static int nfc_platdata_parse_dt(struct device *dev, struct bcm2079x_platform_data *data)
 450 {
 451     int ret = 0;
 452     int gpio = -1;
 453     enum of_gpio_flags flags;
 454     struct device_node *node = dev->of_node;
 455
 456     if (!node)
 457         return -ENODEV;
 458
 459     memset(data, 0, sizeof(*data));
 460
 461     gpio = of_get_named_gpio_flags(node, "en_gpio", 0, &flags);
 462     if (gpio_is_valid(gpio)){
 463         data->en_gpio = gpio;
 464         dev_err(dev, "%s: get property: en_gpio = %d\n", __func__, gpio);
 465     } else ret = -1;
 466     gpio = of_get_named_gpio_flags(node, "wake_gpio", 0, &flags);
 467     if (gpio_is_valid(gpio)){
 468         data->wake_gpio = gpio;
 469         dev_err(dev, "%s: get property: wake_gpio = %d\n", __func__, gpio);
 470     } else ret = -1;
 471     gpio = of_get_named_gpio_flags(node, "irq_gpio", 0, &flags);
 472     if (gpio_is_valid(gpio)){
 473         data->irq_gpio = gpio;
 474         dev_err(dev, "%s: get property: irq_gpio = %d\n", __func__, gpio);
 475     } else ret = -1;
 476
 477     return ret;
 478 }
 479 #endif
 480
 481 static int bcm2079x_probe(struct i2c_client *client,
 482                            const struct i2c_device_id *id)
 483 {
 484         int ret, err = -1;
 485         struct bcm2079x_platform_data *platform_data;
 486         struct bcm2079x_dev *bcm2079x_dev;
 487
 488     err = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
 489     if (!err) {
 490         dev_info(&client->dev, "Check I2C Functionality Failed.\n");
 491         return -ENODEV;
 492     }
 493
 494     dev_info(&client->dev, "Driver Version: %s\n", VERSION);
 495         dev_info(&client->dev, "%s, probing bcm2079x driver flags = %x\n", __func__, client->flags);
 496
 497         platform_data = client->dev.platform_data;
 498         if (platform_data == NULL) {
 499 #ifdef CONFIG_OF
 500         platform_data = devm_kzalloc(&client->dev, sizeof(struct bcm2079x_platform_data), GFP_KERNEL);
 501         if (!platform_data)
 502             return -ENOMEM;
 503
 504         if (nfc_platdata_parse_dt(&client->dev, platform_data)) {
 505 #endif
 506                  dev_err(&client->dev, "nfc probe fail\n");
 507                  return -ENODEV;
 508 #ifdef CONFIG_OF
 509         }
 510         client->dev.platform_data = platform_data;
 511 #endif
 512         }
 513
 514         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 515                 dev_err(&client->dev, "need I2C_FUNC_I2C\n");
 516                 return -ENODEV;
 517         }
 518
 519         ret = gpio_request(platform_data->irq_gpio, "nfc_int");
 520         if (ret)
 521                 return -ENODEV;
 522         ret = gpio_request(platform_data->en_gpio, "nfc_ven");
 523         if (ret)
 524                 goto err_en;
 525         ret = gpio_request(platform_data->wake_gpio, "nfc_firm");
 526         if (ret)
 527                 goto err_firm;
 528
 529         gpio_direction_output(platform_data->en_gpio, 0 );
 530         gpio_direction_output(platform_data->wake_gpio, 0);
 531         gpio_set_value(platform_data->en_gpio, 0);
 532         gpio_set_value(platform_data->wake_gpio, 0);
 533
 534         //gpio_direction_input(platform_data->irq_gpio );
 535
 536         bcm2079x_dev = kzalloc(sizeof(*bcm2079x_dev), GFP_KERNEL);
 537         if (bcm2079x_dev == NULL) {
 538                 dev_err(&client->dev,
 539                         "failed to allocate memory for module data\n");
 540                 ret = -ENOMEM;
 541                 goto err_exit;
 542         }
 543
 544         client->irq = gpio_to_irq(platform_data->irq_gpio);
 545         if (client->irq == -ENXIO) {
 546                 dev_err(&client->dev,"[bcm2079x]: get gpio irq fail.\n");
 547                 goto err_exit;
 548         }
 549
 550         bcm2079x_dev->wake_gpio = platform_data->wake_gpio;
 551         bcm2079x_dev->irq_gpio = platform_data->irq_gpio;
 552         bcm2079x_dev->en_gpio = platform_data->en_gpio;
 553         bcm2079x_dev->client = client;
 554
 555         /* init mutex and queues */
 556         init_waitqueue_head(&bcm2079x_dev->read_wq);
 557         mutex_init(&bcm2079x_dev->read_mutex);
 558         spin_lock_init(&bcm2079x_dev->irq_enabled_lock);
 559
 560         bcm2079x_dev->bcm2079x_device.minor = MISC_DYNAMIC_MINOR;
 561         bcm2079x_dev->bcm2079x_device.name = "bcm2079x";
 562         bcm2079x_dev->bcm2079x_device.fops = &bcm2079x_dev_fops;
 563
 564         ret = misc_register(&bcm2079x_dev->bcm2079x_device);
 565         if (ret) {
 566                 dev_err(&client->dev, "misc_register failed\n");
 567                 goto err_misc_register;
 568         }
 569
 570         dev_info(&client->dev,
 571                  "%s, saving address %d\n",
 572                  __func__, client->addr);
 573         bcm2079x_dev->original_address = client->addr;
 574
 575         /* request irq.  the irq is set whenever the chip has data available
 576          * for reading.  it is cleared when all data has been read.
 577          */
 578         dev_info(&client->dev, "requesting IRQ %d with IRQF_NO_SUSPEND\n", client->irq);
 579         bcm2079x_dev->irq_enabled = true;
 580
 581         //ret = request_irq(client->irq, bcm2079x_dev_irq_handler,
 582         //                IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND, client->name, bcm2079x_dev);
 583         //if (ret) {
 584         //      dev_err(&client->dev, "request_irq failed\n");
 585         //      goto err_request_irq_failed;
 586         //}
 587         //enable_irq_wake(client->irq);
 588
 589         //Platform specific API
 590         //nfc_handle = sw_gpio_irq_request(bcm2079x_dev->irq_gpio, TRIG_EDGE_POSITIVE,
 591         //                                       bcm2079x_irq_handle, bcm2079x_dev);
 592
 593         nfc_handle = request_irq(client->irq, bcm2079x_dev_irq_handler,
 594                           IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND, client->name, bcm2079x_dev);
 595         if (nfc_handle != 0) {
 596                 dev_err(&client->dev, "request_irq failed.\n");
 597                 goto err_request_irq_failed;
 598         }
 599         enable_irq_wake(client->irq);
 600
 601         bcm2079x_disable_irq(bcm2079x_dev);
 602         i2c_set_clientdata(client, bcm2079x_dev);
 603         dev_info(&client->dev,
 604                  "%s, probing bcm2079x driver exited successfully\n",
 605                  __func__);
 606
 607 #ifdef USE_WAKE_LOCK
 608         wake_lock_init(&bcm2079x_dev->wake_lock , WAKE_LOCK_SUSPEND, "nfcwakelock" );
 609 #endif
 610         return 0;
 611
 612 err_request_irq_failed:
 613         misc_deregister(&bcm2079x_dev->bcm2079x_device);
 614 err_misc_register:
 615         mutex_destroy(&bcm2079x_dev->read_mutex);
 616         kfree(bcm2079x_dev);
 617 err_exit:
 618         gpio_free(platform_data->wake_gpio);
 619 err_firm:
 620         gpio_free(platform_data->en_gpio);
 621 err_en:
 622         gpio_free(platform_data->irq_gpio);
 623         return ret;
 624 }
 625
 626 static int bcm2079x_remove(struct i2c_client *client)
 627 {
 628         struct bcm2079x_dev *bcm2079x_dev;
 629
 630         bcm2079x_dev = i2c_get_clientdata(client);
 631
 632         //Platform specific API
 633         if (nfc_handle == 0)
 634             free_irq(client->irq, bcm2079x_dev);
 635                 //sw_gpio_irq_free(nfc_handle);
 636
 637         misc_deregister(&bcm2079x_dev->bcm2079x_device);
 638         mutex_destroy(&bcm2079x_dev->read_mutex);
 639         gpio_free(bcm2079x_dev->irq_gpio);
 640         gpio_free(bcm2079x_dev->en_gpio);
 641         gpio_free(bcm2079x_dev->wake_gpio);
 642         kfree(bcm2079x_dev);
 643
 644         return 0;
 645 }
 646
 647 /*******************************************************************/
 648 /*                           AP6493                                */
 649 /*******************************************************************/
 650 //static const unsigned short normal_i2c[] = {0x77, I2C_CLIENT_END};
 651 /*******************************************************************/
 652 /*                           AP6441                                */
 653 /*******************************************************************/
 654 //static const unsigned short normal_i2c[] = {0x76, I2C_CLIENT_END};
 655 static const struct i2c_device_id bcm2079x_id[] = {
 656     {"bcm2079x-i2c", 0},
 657     {}
 658 };
 659 MODULE_DEVICE_TABLE(i2c, bcm2079x_id);
 660
 661 static struct of_device_id bcm2079x_ids[] = {
 662     { .compatible = "nfc-bcm2079x.ap6441" },
 663     { .compatible = "nfc-bcm2079x.ap6493" },
 664     { }
 665 };
 666
 667 static struct i2c_driver bcm2079x_driver = {
 668         .probe = bcm2079x_probe,
 669         .remove = bcm2079x_remove,
 670         .id_table = bcm2079x_id,
 671         .driver = {
 672                 .owner = THIS_MODULE,
 673                 .name = "bcm2079x-i2c",
 674         .of_match_table = of_match_ptr(bcm2079x_ids),
 675         },
 676 };
 677
 678 /*
 679  * module load/unload record keeping
 680  */
 681
 682 static int __init bcm2079x_dev_init(void)
 683 {
 684     printk("Enter %s\n", __func__);
 685         return i2c_add_driver(&bcm2079x_driver);
 686 }
 687 module_init(bcm2079x_dev_init);
 688
 689 static void __exit bcm2079x_dev_exit(void)
 690 {
 691     printk("Enter %s\n", __func__);
 692         i2c_del_driver(&bcm2079x_driver);
 693 }
 694 module_exit(bcm2079x_dev_exit);
 695
 696 MODULE_AUTHOR("Broadcom");
 697 MODULE_DESCRIPTION("NFC bcm2079x driver");
 698 MODULE_LICENSE("GPL");