drivers/misc/pn544.c

   1 /*
   2  * Copyright (C) 2010 Trusted Logic S.A.
   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/pn544.h>
  38
  39 #define MAX_BUFFER_SIZE 512
  40
  41 #define NXP_KR_READ_IRQ_MODIFY
  42
  43 #ifdef NXP_KR_READ_IRQ_MODIFY
  44 static bool do_reading;
  45 static bool cancle_read;
  46 #endif
  47
  48 #define NFC_DEBUG 0
  49
  50 struct pn544_dev        {
  51         wait_queue_head_t       read_wq;
  52         struct mutex            read_mutex;
  53         struct i2c_client       *client;
  54         struct miscdevice       pn544_device;
  55         unsigned int            ven_gpio;
  56         unsigned int            firm_gpio;
  57         unsigned int            irq_gpio;
  58         bool                    irq_enabled;
  59         spinlock_t              irq_enabled_lock;
  60 };
  61
  62 static void pn544_disable_irq(struct pn544_dev *pn544_dev)
  63 {
  64         unsigned long flags;
  65
  66         spin_lock_irqsave(&pn544_dev->irq_enabled_lock, flags);
  67         if (pn544_dev->irq_enabled) {
  68                 disable_irq_nosync(pn544_dev->client->irq);
  69                 pn544_dev->irq_enabled = false;
  70         }
  71         spin_unlock_irqrestore(&pn544_dev->irq_enabled_lock, flags);
  72 }
  73
  74 static irqreturn_t pn544_dev_irq_handler(int irq, void *dev_id)
  75 {
  76         struct pn544_dev *pn544_dev = dev_id;
  77
  78         if (!gpio_get_value(pn544_dev->irq_gpio))
  79                 return IRQ_HANDLED;
  80
  81 #ifdef NXP_KR_READ_IRQ_MODIFY
  82         do_reading = true;
  83 #endif
  84         pn544_disable_irq(pn544_dev);
  85         /* Wake up waiting readers */
  86         wake_up(&pn544_dev->read_wq);
  87
  88 #if NFC_DEBUG
  89         dev_info(&pn544_dev->client->dev, "pn544 : call\n");
  90 #endif
  91
  92         return IRQ_HANDLED;
  93 }
  94
  95 static ssize_t pn544_dev_read(struct file *filp, char __user *buf,
  96                               size_t count, loff_t *offset)
  97 {
  98         struct pn544_dev *pn544_dev = filp->private_data;
  99         char tmp[MAX_BUFFER_SIZE];
 100         int ret;
 101
 102         if (count > MAX_BUFFER_SIZE)
 103                 count = MAX_BUFFER_SIZE;
 104
 105 #if NFC_DEBUG
 106         dev_dbg(&pn544_dev->client->dev, "%s : reading %zu bytes. irq=%s\n",
 107                 __func__, count,
 108                 gpio_get_value(pn544_dev->irq_gpio) ? "1" : "0");
 109         dev_info(&pn544_dev->client->dev, "pn544 : + r\n");
 110 #endif
 111
 112         mutex_lock(&pn544_dev->read_mutex);
 113
 114 /*wait_irq:*/
 115         if (!gpio_get_value(pn544_dev->irq_gpio)) {
 116                 if (filp->f_flags & O_NONBLOCK) {
 117                         dev_info(&pn544_dev->client->dev, "%s : O_NONBLOCK\n",
 118                                  __func__);
 119                         ret = -EAGAIN;
 120                         goto fail;
 121                 }
 122
 123                 pn544_dev->irq_enabled = true;
 124
 125 #ifdef NXP_KR_READ_IRQ_MODIFY
 126                 do_reading = false;
 127 #endif
 128
 129                 enable_irq(pn544_dev->client->irq);
 130                 if (gpio_get_value(pn544_dev->irq_gpio))
 131                         pn544_disable_irq(pn544_dev);
 132                 else {
 133 #ifdef NXP_KR_READ_IRQ_MODIFY
 134                         ret = wait_event_interruptible(pn544_dev->read_wq,
 135                                 do_reading);
 136 #else
 137                         ret = wait_event_interruptible(pn544_dev->read_wq,
 138                                 gpio_get_value(pn544_dev->irq_gpio));
 139 #endif
 140                         pn544_disable_irq(pn544_dev);
 141
 142 #if NFC_DEBUG
 143                         dev_info(&pn544_dev->client->dev, "pn544 : h\n");
 144 #endif
 145
 146 #ifdef NXP_KR_READ_IRQ_MODIFY
 147                         if (cancle_read == true) {
 148                                 cancle_read = false;
 149                                 ret = -1;
 150                                 goto fail;
 151                         }
 152 #endif
 153
 154                         if (ret)
 155                                 goto fail;
 156                 }
 157
 158         }
 159
 160         /* Read data */
 161         ret = i2c_master_recv(pn544_dev->client, tmp, count);
 162         mutex_unlock(&pn544_dev->read_mutex);
 163
 164         if (ret < 0) {
 165                 dev_err(&pn544_dev->client->dev,
 166                         "%s: i2c_master_recv returned %d\n", __func__,
 167                         ret);
 168                 return ret;
 169         }
 170         if (ret > count) {
 171                 dev_err(&pn544_dev->client->dev,
 172                         "%s: received too many bytes from i2c (%d)\n",
 173                         __func__, ret);
 174                 return -EIO;
 175         }
 176
 177         if (copy_to_user(buf, tmp, ret)) {
 178                 dev_err(&pn544_dev->client->dev,
 179                         "%s : failed to copy to user space\n",
 180                         __func__);
 181                 return -EFAULT;
 182         }
 183         return ret;
 184
 185 fail:
 186         mutex_unlock(&pn544_dev->read_mutex);
 187         return ret;
 188 }
 189
 190 static ssize_t pn544_dev_write(struct file *filp, const char __user *buf,
 191                                size_t count, loff_t *offset)
 192 {
 193         struct pn544_dev *pn544_dev;
 194         char tmp[MAX_BUFFER_SIZE];
 195         int ret = 0, retry = 2;
 196 #if NFC_DEBUG
 197         int i = 0;
 198 #endif
 199
 200         pn544_dev = filp->private_data;
 201
 202 #if NFC_DEBUG
 203         dev_info(&pn544_dev->client->dev, "pn544 : + w\n");
 204         for (i = 0; i < count; i++)
 205                 dev_info(&pn544_dev->client->dev, "buf[%d] = 0x%x\n",
 206                 i, buf[i]);
 207 #endif
 208
 209         if (count > MAX_BUFFER_SIZE)
 210                 count = MAX_BUFFER_SIZE;
 211
 212         if (copy_from_user(tmp, buf, count)) {
 213                 dev_err(&pn544_dev->client->dev,
 214                         "%s : failed to copy from user space\n", __func__);
 215                 return -EFAULT;
 216         }
 217 #if NFC_DEBUG
 218         dev_dbg(&pn544_dev->client->dev, "%s : writing %zu bytes.\n", __func__,
 219                 count);
 220 #endif
 221         /* Write data */
 222         do {
 223                 retry--;
 224                 ret = i2c_master_send(pn544_dev->client, tmp, count);
 225                 if (ret == count)
 226                         break;
 227                 usleep_range(6000, 10000); /* Retry, chip was in standby */
 228 #if NFC_DEBUG
 229                 dev_info(&pn544_dev->client->dev, "retry = %d\n", retry);
 230 #endif
 231         } while (retry);
 232
 233 #if NFC_DEBUG
 234         dev_info(&pn544_dev->client->dev, "pn544 : - w\n");
 235 #endif
 236
 237         if (ret != count) {
 238                 dev_err(&pn544_dev->client->dev,
 239                         "%s : i2c_master_send returned %d, %d\n", __func__, ret, retry);
 240                 ret = -EIO;
 241         }
 242
 243         return ret;
 244 }
 245
 246 static int pn544_dev_open(struct inode *inode, struct file *filp)
 247 {
 248         struct pn544_dev *pn544_dev = container_of(filp->private_data,
 249                                                    struct pn544_dev,
 250                                                    pn544_device);
 251
 252         filp->private_data = pn544_dev;
 253
 254         dev_dbg(&pn544_dev->client->dev, "%s : %d,%d\n", __func__,
 255                 imajor(inode), iminor(inode));
 256
 257         return 0;
 258 }
 259
 260 static long pn544_dev_ioctl(struct file *filp,
 261                             unsigned int cmd, unsigned long arg)
 262 {
 263         struct pn544_dev *pn544_dev = filp->private_data;
 264
 265         switch (cmd) {
 266         case PN544_SET_PWR:
 267                 if (arg == 2) {
 268                         /* power on with firmware download (requires hw reset)
 269                          */
 270                         dev_info(&pn544_dev->client->dev,
 271                                  "%s power on with firmware\n", __func__);
 272                         gpio_set_value(pn544_dev->ven_gpio, 1);
 273                         gpio_set_value(pn544_dev->firm_gpio, 1);
 274                         usleep_range(10000, 10000);
 275                         gpio_set_value(pn544_dev->ven_gpio, 0);
 276                         usleep_range(10000, 10000);
 277                         gpio_set_value(pn544_dev->ven_gpio, 1);
 278                         usleep_range(10000, 10000);
 279                 } else if (arg == 1) {
 280                         /* power on */
 281                         dev_info(&pn544_dev->client->dev, "%s power on\n",
 282                                  __func__);
 283                         gpio_set_value(pn544_dev->firm_gpio, 0);
 284                         gpio_set_value(pn544_dev->ven_gpio, 1);
 285                         usleep_range(10000, 10000);
 286                 } else if (arg == 0) {
 287                         /* power off */
 288                         dev_info(&pn544_dev->client->dev, "%s power off\n",
 289                                  __func__);
 290                         gpio_set_value(pn544_dev->firm_gpio, 0);
 291                         gpio_set_value(pn544_dev->ven_gpio, 0);
 292                         usleep_range(10000, 10000);
 293 #ifdef NXP_KR_READ_IRQ_MODIFY
 294                 } else if (arg == 3) {
 295                         pr_info("%s Read Cancle\n", __func__);
 296                         cancle_read = true;
 297                         do_reading = true;
 298                         wake_up(&pn544_dev->read_wq);
 299 #endif
 300                 } else {
 301                         dev_err(&pn544_dev->client->dev, "%s bad arg %lu\n",
 302                                 __func__, arg);
 303                         return -EINVAL;
 304                 }
 305                 break;
 306         default:
 307                 dev_err(&pn544_dev->client->dev, "%s bad ioctl %u\n", __func__,
 308                         cmd);
 309                 return -EINVAL;
 310         }
 311
 312         return 0;
 313 }
 314
 315 static const struct file_operations pn544_dev_fops = {
 316         .owner  = THIS_MODULE,
 317         .llseek = no_llseek,
 318         .read   = pn544_dev_read,
 319         .write  = pn544_dev_write,
 320         .open   = pn544_dev_open,
 321         .unlocked_ioctl  = pn544_dev_ioctl,
 322 };
 323
 324 static int pn544_probe(struct i2c_client *client,
 325                        const struct i2c_device_id *id)
 326 {
 327         int ret;
 328         struct pn544_i2c_platform_data *platform_data;
 329         struct pn544_dev *pn544_dev;
 330
 331         /*+Check the NFC Chip+*/
 332         char tmp[MAX_BUFFER_SIZE] = {0, };
 333         char datasizelength = 1;
 334         /*-Check the NFC Chip-*/
 335
 336         platform_data = client->dev.platform_data;
 337
 338         if (platform_data == NULL) {
 339                 dev_err(&client->dev, "%s : nfc probe fail\n", __func__);
 340                 return -ENODEV;
 341         }
 342
 343         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 344                 dev_err(&client->dev, "%s : need I2C_FUNC_I2C\n", __func__);
 345                 return -ENODEV;
 346         }
 347
 348         ret = gpio_request(platform_data->irq_gpio, "nfc_int");
 349         if (ret)
 350                 return -ENODEV;
 351         ret = gpio_request(platform_data->ven_gpio, "nfc_ven");
 352         if (ret)
 353                 goto err_ven;
 354         ret = gpio_request(platform_data->firm_gpio, "nfc_firm");
 355         if (ret)
 356                 goto err_firm;
 357
 358         pn544_dev = kzalloc(sizeof(*pn544_dev), GFP_KERNEL);
 359         if (pn544_dev == NULL) {
 360                 dev_err(&client->dev,
 361                         "failed to allocate memory for module data\n");
 362                 ret = -ENOMEM;
 363                 goto err_exit;
 364         }
 365
 366         dev_info(&client->dev, "%s : IRQ num %d\n", __func__, client->irq);
 367
 368         pn544_dev->irq_gpio = platform_data->irq_gpio;
 369         pn544_dev->ven_gpio = platform_data->ven_gpio;
 370         pn544_dev->firm_gpio = platform_data->firm_gpio;
 371         pn544_dev->client = client;
 372
 373         /* init mutex and queues */
 374         init_waitqueue_head(&pn544_dev->read_wq);
 375         mutex_init(&pn544_dev->read_mutex);
 376         spin_lock_init(&pn544_dev->irq_enabled_lock);
 377
 378         pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR;
 379         pn544_dev->pn544_device.name = "pn544";
 380         pn544_dev->pn544_device.fops = &pn544_dev_fops;
 381
 382         ret = misc_register(&pn544_dev->pn544_device);
 383         if (ret) {
 384                 dev_err(&client->dev, "%s : misc_register failed. ret = %d\n",
 385                         __FILE__, ret);
 386                 goto err_misc_register;
 387         }
 388
 389         i2c_set_clientdata(client, pn544_dev);
 390         /* request irq.  the irq is set whenever the chip has data available
 391          * for reading.  it is cleared when all data has been read.
 392          */
 393         dev_info(&pn544_dev->client->dev, "%s : requesting IRQ %d\n", __func__,
 394                  client->irq);
 395         pn544_dev->irq_enabled = true;
 396         ret = gpio_direction_input(pn544_dev->irq_gpio);
 397         if (ret) {
 398                 dev_err(&client->dev, "%s : gpio_direction_input failed. ret = %d\n",
 399                         __FILE__, ret);
 400                 goto err_request_irq_failed;
 401         }
 402
 403         ret = request_irq(client->irq, pn544_dev_irq_handler,
 404                           IRQF_TRIGGER_RISING, "pn544", pn544_dev);
 405         if (ret) {
 406                 dev_err(&client->dev, "request_irq failed. ret = %d\n", ret);
 407                 goto err_request_irq_failed;
 408         }
 409
 410         /*+Check the NFC Chip+*/
 411         gpio_set_value(pn544_dev->firm_gpio, 0);
 412         gpio_set_value(pn544_dev->ven_gpio, 1);
 413         usleep_range(10000, 10000);
 414
 415         ret = i2c_master_recv(pn544_dev->client, tmp, datasizelength);
 416
 417         gpio_set_value(pn544_dev->firm_gpio, 0);
 418         gpio_set_value(pn544_dev->ven_gpio, 0);
 419         usleep_range(10000, 10000);
 420
 421         if (tmp[0] != 0x57 )/*Error Case*/
 422         {
 423                 dev_err(&pn544_dev->client->dev, "%s : No NFC Chip!! %x\n", __func__, tmp[0]);
 424                 goto err_request_irq_failed;
 425         }
 426         /*-Check the NFC Chip-*/
 427
 428         pn544_disable_irq(pn544_dev);
 429         ret = enable_irq_wake(client->irq);
 430         if (ret < 0) {
 431                 dev_err(&client->dev, "enable_irq_wake failed. ret = %d\n",
 432                         ret);
 433                 goto err_renable_irq_wake;
 434         }
 435
 436         return 0;
 437
 438 err_renable_irq_wake:
 439         free_irq(client->irq, pn544_dev);
 440 err_request_irq_failed:
 441         misc_deregister(&pn544_dev->pn544_device);
 442 err_misc_register:
 443         mutex_destroy(&pn544_dev->read_mutex);
 444         kfree(pn544_dev);
 445 err_exit:
 446         gpio_free(platform_data->firm_gpio);
 447 err_firm:
 448         gpio_free(platform_data->ven_gpio);
 449 err_ven:
 450         gpio_free(platform_data->irq_gpio);
 451         return ret;
 452 }
 453
 454 static int pn544_remove(struct i2c_client *client)
 455 {
 456         struct pn544_dev *pn544_dev;
 457
 458         pn544_dev = i2c_get_clientdata(client);
 459         free_irq(client->irq, pn544_dev);
 460         misc_deregister(&pn544_dev->pn544_device);
 461         mutex_destroy(&pn544_dev->read_mutex);
 462         gpio_free(pn544_dev->irq_gpio);
 463         gpio_free(pn544_dev->ven_gpio);
 464         gpio_free(pn544_dev->firm_gpio);
 465         kfree(pn544_dev);
 466
 467         return 0;
 468 }
 469
 470 static const struct i2c_device_id pn544_id[] = {
 471         { "pn544", 0 },
 472         { }
 473 };
 474
 475 static struct i2c_driver pn544_driver = {
 476         .id_table       = pn544_id,
 477         .probe          = pn544_probe,
 478         .remove         = pn544_remove,
 479         .driver         = {
 480                 .owner  = THIS_MODULE,
 481                 .name   = "pn544",
 482         },
 483 };
 484
 485 /*
 486  * module load/unload record keeping
 487  */
 488
 489 static int __init pn544_dev_init(void)
 490 {
 491         pr_info("Loading pn544 driver\n");
 492         return i2c_add_driver(&pn544_driver);
 493 }
 494 module_init(pn544_dev_init);
 495
 496 static void __exit pn544_dev_exit(void)
 497 {
 498         pr_info("Unloading pn544 driver\n");
 499         i2c_del_driver(&pn544_driver);
 500 }
 501 module_exit(pn544_dev_exit);
 502
 503 MODULE_AUTHOR("Sylvain Fonteneau");
 504 MODULE_DESCRIPTION("NFC pn544 driver");
 505 MODULE_LICENSE("GPL");