bf516d4348ee795fd721bdc0c1a3961f9cce230d
[linux-2.6.git] / 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
40 #include <linux/nfc/bcm2079x.h>
41
42 #define TRUE            1
43 #define FALSE           0
44 #define STATE_HIGH      1
45 #define STATE_LOW       0
46
47 /* end of compile options */
48
49 /* do not change below */
50 #define MAX_BUFFER_SIZE         780
51
52         /* Read data */
53 #define PACKET_HEADER_SIZE_NCI  (4)
54 #define PACKET_HEADER_SIZE_HCI  (3)
55 #define PACKET_TYPE_NCI         (16)
56 #define PACKET_TYPE_HCIEV       (4)
57 #define MAX_PACKET_SIZE         (PACKET_HEADER_SIZE_NCI + 255)
58
59 struct bcm2079x_dev {
60         wait_queue_head_t read_wq;
61         struct mutex read_mutex;
62         struct i2c_client *client;
63         struct miscdevice bcm2079x_device;
64         unsigned int wake_gpio;
65         unsigned int en_gpio;
66         unsigned int irq_gpio;
67         bool irq_enabled;
68         spinlock_t irq_enabled_lock;
69         unsigned int error_write;
70         unsigned int error_read;
71         unsigned int count_read;
72         unsigned int count_irq;
73     int original_address;
74 };
75
76 static void bcm2079x_init_stat(struct bcm2079x_dev *bcm2079x_dev)
77 {
78         bcm2079x_dev->error_write = 0;
79         bcm2079x_dev->error_read = 0;
80         bcm2079x_dev->count_read = 0;
81         bcm2079x_dev->count_irq = 0;
82 }
83
84 static void bcm2079x_disable_irq(struct bcm2079x_dev *bcm2079x_dev)
85 {
86         unsigned long flags;
87         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
88         if (bcm2079x_dev->irq_enabled) {
89                 disable_irq_nosync(bcm2079x_dev->client->irq);
90                 bcm2079x_dev->irq_enabled = false;
91         }
92         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
93 }
94
95 static void bcm2079x_enable_irq(struct bcm2079x_dev *bcm2079x_dev)
96 {
97         unsigned long flags;
98         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
99         if (!bcm2079x_dev->irq_enabled) {
100                 bcm2079x_dev->irq_enabled = true;
101                 enable_irq(bcm2079x_dev->client->irq);
102         }
103         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
104 }
105
106 /*
107  The alias address 0x79, when sent as a 7-bit address from the host processor
108  will match the first byte (highest 2 bits) of the default client address
109  (0x1FA) that is programmed in bcm20791.
110  When used together with the first byte (0xFA) of the byte sequence below,
111  it can be used to address the bcm20791 in a system that does not support
112  10-bit address and change the default address to 0x38.
113  the new address can be changed by changing the CLIENT_ADDRESS below if 0x38
114  conflicts with other device on the same i2c bus.
115  */
116 #define ALIAS_ADDRESS     0x79
117
118 static void set_client_addr(struct bcm2079x_dev *bcm2079x_dev, int addr)
119 {
120         struct i2c_client *client = bcm2079x_dev->client;
121         client->addr = addr;
122         if (addr > 0x7F)
123                 client->flags |= I2C_CLIENT_TEN;
124     else
125                 client->flags &= ~I2C_CLIENT_TEN;
126
127         dev_info(&client->dev,
128                 "set_client_addr changed to (0x%04X) flag = %04x\n",
129                 client->addr, client->flags);
130 }
131
132 static void change_client_addr(struct bcm2079x_dev *bcm2079x_dev, int addr)
133 {
134         struct i2c_client *client;
135         int ret;
136         int i;
137         int offset = 1;
138         char addr_data[] = {
139         0xEE, 0xF2, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00
140         };
141
142         client = bcm2079x_dev->client;
143         if ((client->flags & I2C_CLIENT_TEN) == I2C_CLIENT_TEN) {
144                 client->addr = ALIAS_ADDRESS;
145                 client->flags &= ~I2C_CLIENT_TEN;
146                 offset = 0;
147         }
148
149         addr_data[5] = addr & 0xFF;
150         ret = 0;
151         for (i = 1; i < sizeof(addr_data) - 1; ++i)
152                 ret += addr_data[i];
153         addr_data[sizeof(addr_data) - 1] = (ret & 0xFF);
154         dev_info(&client->dev,
155                  "change_client_addr from (0x%04X) flag = "\
156                  "%04x, addr_data[%d] = %02x\n",
157                  client->addr, client->flags, sizeof(addr_data) - 1,
158                  addr_data[sizeof(addr_data) - 1]);
159         ret = i2c_master_send(client, addr_data+offset, sizeof(addr_data)-offset);
160         client->addr = addr_data[5];
161         dev_info(&client->dev,
162                  "change_client_addr to (0x%04X) flag = %04x, ret = %d\n",
163                  client->addr, client->flags, ret);
164 }
165
166 static irqreturn_t bcm2079x_dev_irq_handler(int irq, void *dev_id)
167 {
168         struct bcm2079x_dev *bcm2079x_dev = dev_id;
169         unsigned long flags;
170
171         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
172         bcm2079x_dev->count_irq++;
173         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
174         wake_up(&bcm2079x_dev->read_wq);
175
176         return IRQ_HANDLED;
177 }
178
179 static unsigned int bcm2079x_dev_poll(struct file *filp, poll_table *wait)
180 {
181         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
182         unsigned int mask = 0;
183         unsigned long flags;
184
185         poll_wait(filp, &bcm2079x_dev->read_wq, wait);
186
187         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
188         if (bcm2079x_dev->count_irq > 0)
189                 mask |= POLLIN | POLLRDNORM;
190         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
191
192         return mask;
193 }
194
195 static ssize_t bcm2079x_dev_read(struct file *filp, char __user *buf,
196                                   size_t count, loff_t *offset)
197 {
198         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
199         unsigned char tmp[MAX_BUFFER_SIZE];
200         int total, len, ret;
201
202         total = 0;
203         len = 0;
204         if (bcm2079x_dev->count_irq > 0)
205                 bcm2079x_dev->count_irq--;
206
207         bcm2079x_dev->count_read++;
208         if (count > MAX_BUFFER_SIZE)
209                 count = MAX_BUFFER_SIZE;
210
211         mutex_lock(&bcm2079x_dev->read_mutex);
212
213         /** Read the first 4 bytes to include the length of the NCI or HCI packet.
214         **/
215         ret = i2c_master_recv(bcm2079x_dev->client, tmp, 4);
216         if (ret == 4) {
217                 total = ret;
218                 /** First byte is the packet type
219                 **/
220                 switch(tmp[0]) {
221                         case PACKET_TYPE_NCI:
222                                 len = tmp[PACKET_HEADER_SIZE_NCI-1];
223                                 break;
224
225                         case PACKET_TYPE_HCIEV:
226                                 len = tmp[PACKET_HEADER_SIZE_HCI-1];
227                                 if (len == 0)
228                                         total--;                                /*Since payload is 0, decrement total size (from 4 to 3) */
229                                 else
230                                         len--;                                  /*First byte of payload is in tmp[3] already */
231                                 break;
232
233                         default:
234                                 len = 0;                                        /*Unknown packet byte */
235                                 break;
236                 } /* switch*/
237
238                 /** make sure full packet fits in the buffer
239                 **/
240                 if (len > 0 && (len + total) <= count) {
241                         /** read the remainder of the packet.
242                         **/
243                         ret = i2c_master_recv(bcm2079x_dev->client, tmp+total, len);
244                         if (ret == len)
245                                 total += len;
246                 } /* if */
247         } /* if */
248
249         mutex_unlock(&bcm2079x_dev->read_mutex);
250
251         if (total > count || copy_to_user(buf, tmp, total)) {
252                 dev_err(&bcm2079x_dev->client->dev,
253                         "failed to copy to user space, total = %d\n", total);
254                 total = -EFAULT;
255                 bcm2079x_dev->error_read++;
256         }
257
258         return total;
259 }
260
261 static ssize_t bcm2079x_dev_write(struct file *filp, const char __user *buf,
262                                    size_t count, loff_t *offset)
263 {
264         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
265         char tmp[MAX_BUFFER_SIZE];
266         int ret;
267
268         if (count > MAX_BUFFER_SIZE) {
269                 dev_err(&bcm2079x_dev->client->dev, "out of memory\n");
270                 return -ENOMEM;
271         }
272
273         if (copy_from_user(tmp, buf, count)) {
274                 dev_err(&bcm2079x_dev->client->dev,
275                         "failed to copy from user space\n");
276                 return -EFAULT;
277         }
278
279         mutex_lock(&bcm2079x_dev->read_mutex);
280         /* Write data */
281
282         ret = i2c_master_send(bcm2079x_dev->client, tmp, count);
283         if (ret != count) {
284         dev_err(&bcm2079x_dev->client->dev,
285             "failed to write %d\n", ret);
286         ret = -EIO;
287         bcm2079x_dev->error_write++;
288         }
289         mutex_unlock(&bcm2079x_dev->read_mutex);
290
291         return ret;
292 }
293
294 static int bcm2079x_dev_open(struct inode *inode, struct file *filp)
295 {
296         int ret = 0;
297
298         struct bcm2079x_dev *bcm2079x_dev = container_of(filp->private_data,
299                                                            struct bcm2079x_dev,
300                                                            bcm2079x_device);
301         filp->private_data = bcm2079x_dev;
302         bcm2079x_init_stat(bcm2079x_dev);
303         bcm2079x_enable_irq(bcm2079x_dev);
304         dev_info(&bcm2079x_dev->client->dev,
305                  "device node major=%d, minor=%d\n", imajor(inode), iminor(inode));
306
307         return ret;
308 }
309
310 static long bcm2079x_dev_unlocked_ioctl(struct file *filp,
311                                          unsigned int cmd, unsigned long arg)
312 {
313         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
314
315         switch (cmd) {
316         case BCMNFC_READ_FULL_PACKET:
317                 break;
318         case BCMNFC_READ_MULTI_PACKETS:
319                 break;
320         case BCMNFC_CHANGE_ADDR:
321                 dev_info(&bcm2079x_dev->client->dev,
322                          "%s, BCMNFC_CHANGE_ADDR (%x, %lx):\n", __func__, cmd,
323                          arg);
324                 change_client_addr(bcm2079x_dev, arg);
325                 break;
326         case BCMNFC_POWER_CTL:
327                 dev_info(&bcm2079x_dev->client->dev,
328                          "%s, BCMNFC_POWER_CTL (%x, %lx):\n", __func__, cmd,
329                          arg);
330                 if (arg == 1) set_client_addr(bcm2079x_dev, bcm2079x_dev->original_address);
331                 gpio_set_value(bcm2079x_dev->en_gpio, arg);
332                 break;
333         case BCMNFC_WAKE_CTL:
334                 dev_info(&bcm2079x_dev->client->dev,
335                          "%s, BCMNFC_WAKE_CTL (%x, %lx):\n", __func__, cmd,
336                          arg);
337                 gpio_set_value(bcm2079x_dev->wake_gpio, arg);
338                 break;
339         default:
340                 dev_err(&bcm2079x_dev->client->dev,
341                         "%s, unknown cmd (%x, %lx)\n", __func__, cmd, arg);
342                 return 0;
343         }
344
345         return 0;
346 }
347
348 static const struct file_operations bcm2079x_dev_fops = {
349         .owner = THIS_MODULE,
350         .llseek = no_llseek,
351         .poll = bcm2079x_dev_poll,
352         .read = bcm2079x_dev_read,
353         .write = bcm2079x_dev_write,
354         .open = bcm2079x_dev_open,
355         .unlocked_ioctl = bcm2079x_dev_unlocked_ioctl
356 };
357
358 static int bcm2079x_probe(struct i2c_client *client,
359                            const struct i2c_device_id *id)
360 {
361         int ret;
362         struct bcm2079x_platform_data *platform_data;
363         struct bcm2079x_dev *bcm2079x_dev;
364
365         platform_data = client->dev.platform_data;
366
367         dev_info(&client->dev, "%s, probing bcm2079x driver flags = %x\n", __func__, client->flags);
368         if (platform_data == NULL) {
369                 dev_err(&client->dev, "nfc probe fail\n");
370                 return -ENODEV;
371         }
372
373         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
374                 dev_err(&client->dev, "need I2C_FUNC_I2C\n");
375                 return -ENODEV;
376         }
377
378         ret = gpio_request(platform_data->irq_gpio, "I2C_REQ");
379         if (ret)
380         return -ENODEV;
381         ret = gpio_request(platform_data->en_gpio, "REG_PU");
382         if (ret)
383                 goto err_en;
384         ret = gpio_request(platform_data->wake_gpio, "NFC_WAKE");
385         if (ret)
386         goto err_firm;
387
388         bcm2079x_dev = kzalloc(sizeof(*bcm2079x_dev), GFP_KERNEL);
389         if (bcm2079x_dev == NULL) {
390                 dev_err(&client->dev,
391                         "failed to allocate memory for module data\n");
392                 ret = -ENOMEM;
393                 goto err_exit;
394         }
395
396         bcm2079x_dev->wake_gpio = platform_data->wake_gpio;
397         bcm2079x_dev->irq_gpio = platform_data->irq_gpio;
398         bcm2079x_dev->en_gpio = platform_data->en_gpio;
399         bcm2079x_dev->client = client;
400
401         ret = gpio_direction_input(bcm2079x_dev->irq_gpio);
402         if (ret < 0) {
403                 pr_err("%s : not able to set I2C_REQ as input\n", __func__);
404                 goto err_en;
405         }
406         ret = gpio_direction_output(bcm2079x_dev->en_gpio, 0);
407         if (ret < 0) {
408                 pr_err("%s : not able to set REG_PU as output\n", __func__);
409                 goto err_firm;
410         }
411     ret = gpio_direction_output(bcm2079x_dev->wake_gpio, 0);
412     if (ret < 0) {
413         pr_err("%s : not able to set NFC_WAKE as output\n", __func__);
414         goto err_exit;
415     }
416
417         gpio_set_value(platform_data->en_gpio, 0);
418         gpio_set_value(platform_data->wake_gpio, 0);
419
420         /* init mutex and queues */
421         init_waitqueue_head(&bcm2079x_dev->read_wq);
422         mutex_init(&bcm2079x_dev->read_mutex);
423         spin_lock_init(&bcm2079x_dev->irq_enabled_lock);
424
425         bcm2079x_dev->bcm2079x_device.minor = MISC_DYNAMIC_MINOR;
426         bcm2079x_dev->bcm2079x_device.name = "bcm2079x";
427         bcm2079x_dev->bcm2079x_device.fops = &bcm2079x_dev_fops;
428
429         ret = misc_register(&bcm2079x_dev->bcm2079x_device);
430         if (ret) {
431                 dev_err(&client->dev, "misc_register failed\n");
432                 goto err_misc_register;
433         }
434         dev_info(&client->dev,
435                  "%s, saving address 0x%02x\n",
436                  __func__, client->addr);
437     bcm2079x_dev->original_address = client->addr;
438
439         /* request irq.  the irq is set whenever the chip has data available
440          * for reading.  it is cleared when all data has been read.
441          */
442         dev_info(&client->dev, "requesting IRQ %d with IRQF_NO_SUSPEND\n", client->irq);
443         bcm2079x_dev->irq_enabled = true;
444         ret = request_irq(client->irq, bcm2079x_dev_irq_handler,
445                           IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND, client->name, bcm2079x_dev);
446         if (ret) {
447                 dev_err(&client->dev, "request_irq failed\n");
448                 goto err_request_irq_failed;
449         }
450         bcm2079x_disable_irq(bcm2079x_dev);
451         i2c_set_clientdata(client, bcm2079x_dev);
452         dev_info(&client->dev,
453                  "%s, probing bcm2079x driver exited successfully\n",
454                  __func__);
455         return 0;
456
457 err_request_irq_failed:
458         misc_deregister(&bcm2079x_dev->bcm2079x_device);
459 err_misc_register:
460         mutex_destroy(&bcm2079x_dev->read_mutex);
461         kfree(bcm2079x_dev);
462 err_exit:
463         gpio_free(platform_data->wake_gpio);
464 err_firm:
465         gpio_free(platform_data->en_gpio);
466 err_en:
467         gpio_free(platform_data->irq_gpio);
468         return ret;
469 }
470
471 static int bcm2079x_remove(struct i2c_client *client)
472 {
473         struct bcm2079x_dev *bcm2079x_dev;
474
475         bcm2079x_dev = i2c_get_clientdata(client);
476         free_irq(client->irq, bcm2079x_dev);
477         misc_deregister(&bcm2079x_dev->bcm2079x_device);
478         mutex_destroy(&bcm2079x_dev->read_mutex);
479         gpio_free(bcm2079x_dev->irq_gpio);
480         gpio_free(bcm2079x_dev->en_gpio);
481         gpio_free(bcm2079x_dev->wake_gpio);
482         kfree(bcm2079x_dev);
483
484         return 0;
485 }
486
487 static const struct i2c_device_id bcm2079x_id[] = {
488         {"bcm2079x-i2c", 0},
489         {}
490 };
491
492 static struct i2c_driver bcm2079x_driver = {
493         .id_table = bcm2079x_id,
494         .probe = bcm2079x_probe,
495         .remove = bcm2079x_remove,
496         .driver = {
497                 .owner = THIS_MODULE,
498                 .name = "bcm2079x-i2c",
499         },
500 };
501
502 /*
503  * module load/unload record keeping
504  */
505
506 static int __init bcm2079x_dev_init(void)
507 {
508         return i2c_add_driver(&bcm2079x_driver);
509 }
510 module_init(bcm2079x_dev_init);
511
512 static void __exit bcm2079x_dev_exit(void)
513 {
514         i2c_del_driver(&bcm2079x_driver);
515 }
516 module_exit(bcm2079x_dev_exit);
517
518 MODULE_AUTHOR("Broadcom");
519 MODULE_DESCRIPTION("NFC bcm2079x driver");
520 MODULE_LICENSE("GPL");