2 * Copyright (C) 2012 Broadcom Corporation.
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.
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.
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
20 #include <linux/kernel.h>
21 #include <linux/module.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>
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>
41 #include <linux/of_device.h>
42 #include <linux/of_gpio.h>
45 #include <linux/bcm2079x.h>
50 #include <linux/wakelock.h>
58 /* end of compile options */
60 /* do not change below */
61 #define MAX_BUFFER_SIZE 780
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)
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;
77 unsigned int irq_gpio;
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;
86 struct wake_lock wake_lock;
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);
95 static void bcm2079x_init_stat(struct bcm2079x_dev *bcm2079x_dev)
97 bcm2079x_dev->error_write = 0;
98 bcm2079x_dev->error_read = 0;
99 bcm2079x_dev->count_read = 0;
100 bcm2079x_dev->count_irq = 0;
103 static void bcm2079x_disable_irq(struct bcm2079x_dev *bcm2079x_dev)
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;
112 spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
115 static void bcm2079x_enable_irq(struct bcm2079x_dev *bcm2079x_dev)
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);
123 spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
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.
136 #define ALIAS_ADDRESS 0x79
138 static void set_client_addr(struct bcm2079x_dev *bcm2079x_dev, int addr)
140 struct i2c_client *client = bcm2079x_dev->client;
143 client->flags |= I2C_CLIENT_TEN;
145 client->flags &= ~I2C_CLIENT_TEN;
147 dev_info(&client->dev,
148 "Set client device changed to (0x%04X) flag = %04x\n",
149 client->addr, client->flags);
152 static void change_client_addr(struct bcm2079x_dev *bcm2079x_dev, int addr)
154 struct i2c_client *client;
159 0xFA, 0xF2, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x2A
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;
169 addr_data[5] = addr & 0xFF;
171 for (i = 1; i < sizeof(addr_data) - 1; ++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));
190 client->addr = addr_data[5];
192 dev_info(&client->dev,
193 "Change client device changed to (0x%04X) flag = %04x, ret = %d\n",
194 client->addr, client->flags, ret);
197 static irqreturn_t bcm2079x_dev_irq_handler(int irq, void *dev_id)
199 struct bcm2079x_dev *bcm2079x_dev = dev_id;
205 printk("%s: nfc irq handler\n", __func__);
207 if(!(wakelockcnt = wake_lock_active(&bcm2079x_dev->wake_lock )))
209 printk("irq aquire wake lock\n");
210 wake_lock(&bcm2079x_dev->wake_lock);
213 // printk("irq wake lock count = %d\n", wakelockcnt);
215 //printk("irq handler ( wake lock %d)...\n", wakelockcnt);
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);
226 static unsigned int bcm2079x_dev_poll(struct file *filp, poll_table *wait)
228 struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
229 unsigned int mask = 0;
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) )
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);
242 if (bcm2079x_dev->count_irq < 1)
243 bcm2079x_dev->count_irq = 1;
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);
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);
258 static ssize_t bcm2079x_dev_read(struct file *filp, char __user *buf,
259 size_t count, loff_t *offset)
261 struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
262 unsigned char tmp[MAX_BUFFER_SIZE];
268 if (bcm2079x_dev->count_irq > 0)
269 bcm2079x_dev->count_irq--;
271 bcm2079x_dev->count_read++;
272 if (count > MAX_BUFFER_SIZE)
273 count = MAX_BUFFER_SIZE;
275 mutex_lock(&bcm2079x_dev->read_mutex);
277 /** Read the first 4 bytes to include the length of the NCI or HCI packet.
279 ret = i2c_master_recv(bcm2079x_dev->client, tmp, 4);
282 /** First byte is the packet type
285 case PACKET_TYPE_NCI:
286 len = tmp[PACKET_HEADER_SIZE_NCI-1];
289 case PACKET_TYPE_HCIEV:
290 len = tmp[PACKET_HEADER_SIZE_HCI-1];
292 total--; /*Since payload is 0, decrement total size (from 4 to 3) */
294 len--; /*First byte of payload is in tmp[3] already */
298 len = 0; /*Unknown packet byte */
302 /** make sure full packet fits in the buffer
304 if (len > 0 && (len + total) <= count) {
305 /** read the remainder of the packet.
307 ret = i2c_master_recv(bcm2079x_dev->client, tmp+total, len);
313 mutex_unlock(&bcm2079x_dev->read_mutex);
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);
319 bcm2079x_dev->error_read++;
325 static ssize_t bcm2079x_dev_write(struct file *filp, const char __user *buf,
326 size_t count, loff_t *offset)
328 struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
329 char tmp[MAX_BUFFER_SIZE];
332 if (count > MAX_BUFFER_SIZE) {
333 dev_err(&bcm2079x_dev->client->dev, "out of memory\n");
337 if (copy_from_user(tmp, buf, count)) {
338 dev_err(&bcm2079x_dev->client->dev,
339 "failed to copy from user space\n");
343 mutex_lock(&bcm2079x_dev->read_mutex);
346 ret = i2c_master_send(bcm2079x_dev->client, tmp, 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);
352 bcm2079x_dev->error_write++;
353 set_client_addr(bcm2079x_dev, bcm2079x_dev->original_address);
355 dev_err(&bcm2079x_dev->client->dev,
356 "failed to write %d\n", ret);
358 bcm2079x_dev->error_write++;
361 mutex_unlock(&bcm2079x_dev->read_mutex);
366 static int bcm2079x_dev_open(struct inode *inode, struct file *filp)
370 struct bcm2079x_dev *bcm2079x_dev = container_of(filp->private_data,
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));
382 static long bcm2079x_dev_unlocked_ioctl(struct file *filp,
383 unsigned int cmd, unsigned long arg)
385 struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
388 case BCMNFC_READ_FULL_PACKET:
390 case BCMNFC_READ_MULTI_PACKETS:
392 case BCMNFC_CHANGE_ADDR:
393 dev_info(&bcm2079x_dev->client->dev,
394 "%s, BCMNFC_CHANGE_ADDR (%x, %lx):\n", __func__, cmd,
396 change_client_addr(bcm2079x_dev, arg);
398 case BCMNFC_POWER_CTL:
399 dev_info(&bcm2079x_dev->client->dev,
400 "%s, BCMNFC_POWER_CTL (%x, %lx):\n", __func__, cmd, arg);
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);
406 case BCMNFC_WAKE_CTL:
407 dev_info(&bcm2079x_dev->client->dev,
408 "%s, BCMNFC_WAKE_CTL (%x, %lx):\n", __func__, cmd, arg);
412 while(wake_lock_active(&bcm2079x_dev->wake_lock ))
414 printk("release wake lock!!!\n");
415 wake_unlock(&bcm2079x_dev->wake_lock);
417 //wake_lock_timeout(&bcm2079x_dev->wake_lock, HZ*2);
420 gpio_direction_output(bcm2079x_dev->wake_gpio, arg);
421 gpio_set_value(bcm2079x_dev->wake_gpio, arg);
424 dev_err(&bcm2079x_dev->client->dev,
425 "%s, unknown cmd (%x, %lx)\n", __func__, cmd, arg);
432 static const struct file_operations bcm2079x_dev_fops = {
433 .owner = THIS_MODULE,
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
442 unsigned int bcm2079x_irq_handle(void *para)
444 bcm2079x_dev_irq_handler(0, para);
449 static int nfc_platdata_parse_dt(struct device *dev, struct bcm2079x_platform_data *data)
453 enum of_gpio_flags flags;
454 struct device_node *node = dev->of_node;
459 memset(data, 0, sizeof(*data));
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);
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);
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);
481 static int bcm2079x_probe(struct i2c_client *client,
482 const struct i2c_device_id *id)
485 struct bcm2079x_platform_data *platform_data;
486 struct bcm2079x_dev *bcm2079x_dev;
488 err = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
490 dev_info(&client->dev, "Check I2C Functionality Failed.\n");
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);
497 platform_data = client->dev.platform_data;
498 if (platform_data == NULL) {
500 platform_data = devm_kzalloc(&client->dev, sizeof(struct bcm2079x_platform_data), GFP_KERNEL);
504 if (nfc_platdata_parse_dt(&client->dev, platform_data)) {
506 dev_err(&client->dev, "nfc probe fail\n");
510 client->dev.platform_data = platform_data;
514 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
515 dev_err(&client->dev, "need I2C_FUNC_I2C\n");
519 ret = gpio_request(platform_data->irq_gpio, "nfc_int");
522 ret = gpio_request(platform_data->en_gpio, "nfc_ven");
525 ret = gpio_request(platform_data->wake_gpio, "nfc_firm");
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);
534 //gpio_direction_input(platform_data->irq_gpio );
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");
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");
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;
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);
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;
564 ret = misc_register(&bcm2079x_dev->bcm2079x_device);
566 dev_err(&client->dev, "misc_register failed\n");
567 goto err_misc_register;
570 dev_info(&client->dev,
571 "%s, saving address %d\n",
572 __func__, client->addr);
573 bcm2079x_dev->original_address = client->addr;
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.
578 dev_info(&client->dev, "requesting IRQ %d with IRQF_NO_SUSPEND\n", client->irq);
579 bcm2079x_dev->irq_enabled = true;
581 //ret = request_irq(client->irq, bcm2079x_dev_irq_handler,
582 // IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND, client->name, bcm2079x_dev);
584 // dev_err(&client->dev, "request_irq failed\n");
585 // goto err_request_irq_failed;
587 //enable_irq_wake(client->irq);
589 //Platform specific API
590 //nfc_handle = sw_gpio_irq_request(bcm2079x_dev->irq_gpio, TRIG_EDGE_POSITIVE,
591 // bcm2079x_irq_handle, bcm2079x_dev);
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;
599 enable_irq_wake(client->irq);
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",
608 wake_lock_init(&bcm2079x_dev->wake_lock , WAKE_LOCK_SUSPEND, "nfcwakelock" );
612 err_request_irq_failed:
613 misc_deregister(&bcm2079x_dev->bcm2079x_device);
615 mutex_destroy(&bcm2079x_dev->read_mutex);
618 gpio_free(platform_data->wake_gpio);
620 gpio_free(platform_data->en_gpio);
622 gpio_free(platform_data->irq_gpio);
626 static int bcm2079x_remove(struct i2c_client *client)
628 struct bcm2079x_dev *bcm2079x_dev;
630 bcm2079x_dev = i2c_get_clientdata(client);
632 //Platform specific API
634 free_irq(client->irq, bcm2079x_dev);
635 //sw_gpio_irq_free(nfc_handle);
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);
647 /*******************************************************************/
649 /*******************************************************************/
650 //static const unsigned short normal_i2c[] = {0x77, I2C_CLIENT_END};
651 /*******************************************************************/
653 /*******************************************************************/
654 //static const unsigned short normal_i2c[] = {0x76, I2C_CLIENT_END};
655 static const struct i2c_device_id bcm2079x_id[] = {
659 MODULE_DEVICE_TABLE(i2c, bcm2079x_id);
661 static struct of_device_id bcm2079x_ids[] = {
662 { .compatible = "nfc-bcm2079x.ap6441" },
663 { .compatible = "nfc-bcm2079x.ap6493" },
667 static struct i2c_driver bcm2079x_driver = {
668 .probe = bcm2079x_probe,
669 .remove = bcm2079x_remove,
670 .id_table = bcm2079x_id,
672 .owner = THIS_MODULE,
673 .name = "bcm2079x-i2c",
674 .of_match_table = of_match_ptr(bcm2079x_ids),
679 * module load/unload record keeping
682 static int __init bcm2079x_dev_init(void)
684 printk("Enter %s\n", __func__);
685 return i2c_add_driver(&bcm2079x_driver);
687 module_init(bcm2079x_dev_init);
689 static void __exit bcm2079x_dev_exit(void)
691 printk("Enter %s\n", __func__);
692 i2c_del_driver(&bcm2079x_driver);
694 module_exit(bcm2079x_dev_exit);
696 MODULE_AUTHOR("Broadcom");
697 MODULE_DESCRIPTION("NFC bcm2079x driver");
698 MODULE_LICENSE("GPL");