gpu: nvgpu: remove temporary gpfifo allocation in submit path
[linux-3.10.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 #include <linux/nfc/bcm2079x.h>
40
41 #define TRUE            1
42 #define FALSE           0
43 #define STATE_HIGH      1
44 #define STATE_LOW       0
45
46 /* end of compile options */
47
48 /* do not change below */
49 #define MAX_BUFFER_SIZE         780
50
51         /* Read data */
52 #define PACKET_HEADER_SIZE_NCI  (4)
53 #define PACKET_HEADER_SIZE_HCI  (3)
54 #define PACKET_TYPE_NCI         (16)
55 #define PACKET_TYPE_HCIEV       (4)
56 #define MAX_PACKET_SIZE         (PACKET_HEADER_SIZE_NCI + 255)
57
58 struct bcm2079x_dev {
59         wait_queue_head_t read_wq;
60         struct mutex read_mutex;
61         struct i2c_client *client;
62         struct miscdevice bcm2079x_device;
63         unsigned int wake_gpio;
64         unsigned int en_gpio;
65         unsigned int irq_gpio;
66         bool irq_enabled;
67         spinlock_t irq_enabled_lock;
68         unsigned int error_write;
69         unsigned int error_read;
70         unsigned int count_read;
71         unsigned int count_irq;
72         int original_address;
73         bool shutdown_complete;
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
160         mutex_lock(&bcm2079x_dev->read_mutex);
161         if (bcm2079x_dev && (bcm2079x_dev->shutdown_complete == true)) {
162                 dev_info(&client->dev, "%s: discarding as " \
163                 "NFC in shutdown state\n", __func__);
164                 mutex_unlock(&bcm2079x_dev->read_mutex);
165                 return;
166         }
167         ret = i2c_master_send(client, addr_data+offset,
168                 sizeof(addr_data)-offset);
169         mutex_unlock(&bcm2079x_dev->read_mutex);
170
171         client->addr = addr_data[5];
172         dev_info(&client->dev,
173                  "change_client_addr to (0x%04X) flag = %04x, ret = %d\n",
174                  client->addr, client->flags, ret);
175 }
176
177 static irqreturn_t bcm2079x_dev_irq_handler(int irq, void *dev_id)
178 {
179         struct bcm2079x_dev *bcm2079x_dev = dev_id;
180         unsigned long flags;
181
182         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
183         bcm2079x_dev->count_irq++;
184         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
185         wake_up(&bcm2079x_dev->read_wq);
186
187         return IRQ_HANDLED;
188 }
189
190 static unsigned int bcm2079x_dev_poll(struct file *filp, poll_table *wait)
191 {
192         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
193         unsigned int mask = 0;
194         unsigned long flags;
195
196         poll_wait(filp, &bcm2079x_dev->read_wq, wait);
197
198         spin_lock_irqsave(&bcm2079x_dev->irq_enabled_lock, flags);
199         if (bcm2079x_dev->count_irq > 0)
200                 mask |= POLLIN | POLLRDNORM;
201         spin_unlock_irqrestore(&bcm2079x_dev->irq_enabled_lock, flags);
202
203         return mask;
204 }
205
206 static ssize_t bcm2079x_dev_read(struct file *filp, char __user *buf,
207                                   size_t count, loff_t *offset)
208 {
209         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
210         unsigned char tmp[MAX_BUFFER_SIZE];
211         int total, len, ret;
212
213         total = 0;
214         len = 0;
215         if (bcm2079x_dev->count_irq > 0)
216                 bcm2079x_dev->count_irq--;
217
218         bcm2079x_dev->count_read++;
219         if (count > MAX_BUFFER_SIZE)
220                 count = MAX_BUFFER_SIZE;
221
222         mutex_lock(&bcm2079x_dev->read_mutex);
223
224         /*Check for shutdown condition*/
225         if (bcm2079x_dev && (bcm2079x_dev->shutdown_complete == true)) {
226                 dev_info(&bcm2079x_dev->client->dev, "%s: discarding read " \
227                 "as NFC in shutdown state\n", __func__);
228                 mutex_unlock(&bcm2079x_dev->read_mutex);
229                 return -ENODEV;
230         }
231
232         /** Read the first 4 bytes to include the length of
233         the NCI or HCI packet.**/
234         ret = i2c_master_recv(bcm2079x_dev->client, tmp, 4);
235         if (ret == 4) {
236                 total = ret;
237                 /** First byte is the packet type
238                 **/
239                 switch(tmp[0]) {
240                         case PACKET_TYPE_NCI:
241                                 len = tmp[PACKET_HEADER_SIZE_NCI-1];
242                                 break;
243
244                         case PACKET_TYPE_HCIEV:
245                                 len = tmp[PACKET_HEADER_SIZE_HCI-1];
246                         /** Since payload is 0, decrement
247                         * total size (from 4 to 3)  else
248                         * First byte of payload is in
249                         * tmp[3] already
250                         **/
251                                 if (len == 0)
252                                         total--;                                /*Since payload is 0, decrement total size (from 4 to 3) */
253                                 else
254                                         len--;                                  /*First byte of payload is in tmp[3] already */
255                                 break;
256
257                         default:
258                                 len = 0;                                        /*Unknown packet byte */
259                                 break;
260                 } /* switch*/
261
262                 /** make sure full packet fits in the buffer
263                 **/
264                 if (len > 0 && (len + total) <= count) {
265                         /** read the remainder of the packet.
266                         **/
267                         ret = i2c_master_recv(bcm2079x_dev->client,
268                                  tmp+total, len);
269                         if (ret == len)
270                                 total += len;
271                 } /* if */
272         } /* if */
273
274         mutex_unlock(&bcm2079x_dev->read_mutex);
275
276         if (total > count || copy_to_user(buf, tmp, total)) {
277                 dev_err(&bcm2079x_dev->client->dev,
278                         "failed to copy to user space, total = %d\n", total);
279                 total = -EFAULT;
280                 bcm2079x_dev->error_read++;
281         }
282
283         return total;
284 }
285
286 static ssize_t bcm2079x_dev_write(struct file *filp, const char __user *buf,
287                                    size_t count, loff_t *offset)
288 {
289         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
290         char tmp[MAX_BUFFER_SIZE];
291         int ret;
292
293         if (count > MAX_BUFFER_SIZE) {
294                 dev_err(&bcm2079x_dev->client->dev, "out of memory\n");
295                 return -ENOMEM;
296         }
297
298         if (copy_from_user(tmp, buf, count)) {
299                 dev_err(&bcm2079x_dev->client->dev,
300                         "failed to copy from user space\n");
301                 return -EFAULT;
302         }
303
304         mutex_lock(&bcm2079x_dev->read_mutex);
305
306         /*Check for shutdown condition*/
307         if (bcm2079x_dev && (bcm2079x_dev->shutdown_complete == true)) {
308                 dev_info(&bcm2079x_dev->client->dev, "%s: discarding write " \
309                         "as NFC in shutdown state\n", __func__);
310                 mutex_unlock(&bcm2079x_dev->read_mutex);
311                 return -ENODEV;
312         }
313
314         /* Write data */
315
316         ret = i2c_master_send(bcm2079x_dev->client, tmp, count);
317         if (ret != count) {
318         dev_err(&bcm2079x_dev->client->dev,
319             "failed to write %d\n", ret);
320         ret = -EIO;
321         bcm2079x_dev->error_write++;
322         }
323         mutex_unlock(&bcm2079x_dev->read_mutex);
324
325         return ret;
326 }
327
328 static int bcm2079x_dev_open(struct inode *inode, struct file *filp)
329 {
330         int ret = 0;
331
332         struct bcm2079x_dev *bcm2079x_dev = container_of(filp->private_data,
333                                                            struct bcm2079x_dev,
334                                                            bcm2079x_device);
335         filp->private_data = bcm2079x_dev;
336         bcm2079x_init_stat(bcm2079x_dev);
337         bcm2079x_enable_irq(bcm2079x_dev);
338         dev_info(&bcm2079x_dev->client->dev,
339                  "device node major=%d, minor=%d\n",
340                  imajor(inode), iminor(inode));
341
342         return ret;
343 }
344
345 static long bcm2079x_dev_unlocked_ioctl(struct file *filp,
346                                          unsigned int cmd, unsigned long arg)
347 {
348         struct bcm2079x_dev *bcm2079x_dev = filp->private_data;
349
350         switch (cmd) {
351         case BCMNFC_READ_FULL_PACKET:
352                 break;
353         case BCMNFC_READ_MULTI_PACKETS:
354                 break;
355         case BCMNFC_CHANGE_ADDR:
356                 dev_info(&bcm2079x_dev->client->dev,
357                          "%s, BCMNFC_CHANGE_ADDR (%x, %lx):\n", __func__, cmd,
358                          arg);
359                 change_client_addr(bcm2079x_dev, arg);
360                 break;
361         case BCMNFC_POWER_CTL:
362                 dev_info(&bcm2079x_dev->client->dev,
363                          "%s, BCMNFC_POWER_CTL (%x, %lx):\n",
364                          __func__, cmd, arg);
365                 if (arg == 1) {
366                         set_client_addr(bcm2079x_dev,
367                           bcm2079x_dev->original_address);
368                 }
369                 gpio_set_value(bcm2079x_dev->en_gpio, arg);
370                 break;
371         case BCMNFC_WAKE_CTL:
372                 dev_info(&bcm2079x_dev->client->dev,
373                          "%s, BCMNFC_WAKE_CTL (%x, %lx):\n",
374                          __func__, cmd, arg);
375                 gpio_set_value(bcm2079x_dev->wake_gpio, arg);
376                 break;
377         default:
378                 dev_err(&bcm2079x_dev->client->dev,
379                          "%s, unknown cmd (%x, %lx)\n",
380                          __func__, cmd, arg);
381                 return 0;
382         }
383
384         return 0;
385 }
386
387 static const struct file_operations bcm2079x_dev_fops = {
388         .owner = THIS_MODULE,
389         .llseek = no_llseek,
390         .poll = bcm2079x_dev_poll,
391         .read = bcm2079x_dev_read,
392         .write = bcm2079x_dev_write,
393         .open = bcm2079x_dev_open,
394         .unlocked_ioctl = bcm2079x_dev_unlocked_ioctl
395 };
396
397 static int bcm2079x_probe(struct i2c_client *client,
398                            const struct i2c_device_id *id)
399 {
400         int ret;
401         struct bcm2079x_platform_data *platform_data;
402         struct bcm2079x_dev *bcm2079x_dev;
403
404         platform_data = client->dev.platform_data;
405
406         dev_info(&client->dev, "%s, pro bcm2079x driver flags = %x\n",
407                          __func__, client->flags);
408         if (platform_data == NULL) {
409                 dev_err(&client->dev, "nfc probe fail\n");
410                 return -ENODEV;
411         }
412
413         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
414                 dev_err(&client->dev, "need I2C_FUNC_I2C\n");
415                 return -ENODEV;
416         }
417
418         ret = gpio_request(platform_data->irq_gpio, "I2C_REQ");
419         if (ret)
420         return -ENODEV;
421         ret = gpio_request(platform_data->en_gpio, "REG_PU");
422         if (ret)
423                 goto err_en;
424         ret = gpio_request(platform_data->wake_gpio, "NFC_WAKE");
425         if (ret)
426         goto err_firm;
427
428         bcm2079x_dev = kzalloc(sizeof(*bcm2079x_dev), GFP_KERNEL);
429         if (bcm2079x_dev == NULL) {
430                 dev_err(&client->dev, \
431                         "failed to allocate memory for module data\n");
432                 ret = -ENOMEM;
433                 goto err_exit;
434         }
435
436         bcm2079x_dev->wake_gpio = platform_data->wake_gpio;
437         bcm2079x_dev->irq_gpio = platform_data->irq_gpio;
438         bcm2079x_dev->en_gpio = platform_data->en_gpio;
439         bcm2079x_dev->client = client;
440
441         ret = gpio_direction_input(bcm2079x_dev->irq_gpio);
442         if (ret < 0) {
443                 pr_err("%s : not able to set I2C_REQ as input\n", __func__);
444                 goto err_en;
445         }
446         ret = gpio_direction_output(bcm2079x_dev->en_gpio, 0);
447         if (ret < 0) {
448                 pr_err("%s : not able to set REG_PU as output\n", __func__);
449                 goto err_firm;
450         }
451     ret = gpio_direction_output(bcm2079x_dev->wake_gpio, 0);
452     if (ret < 0) {
453         pr_err("%s : not able to set NFC_WAKE as output\n", __func__);
454         goto err_exit;
455     }
456
457         gpio_set_value(platform_data->en_gpio, 0);
458         gpio_set_value(platform_data->wake_gpio, 0);
459
460         /* init mutex and queues */
461         init_waitqueue_head(&bcm2079x_dev->read_wq);
462         mutex_init(&bcm2079x_dev->read_mutex);
463         spin_lock_init(&bcm2079x_dev->irq_enabled_lock);
464
465         bcm2079x_dev->bcm2079x_device.minor = MISC_DYNAMIC_MINOR;
466         bcm2079x_dev->bcm2079x_device.name = "bcm2079x";
467         bcm2079x_dev->bcm2079x_device.fops = &bcm2079x_dev_fops;
468
469         ret = misc_register(&bcm2079x_dev->bcm2079x_device);
470         if (ret) {
471                 dev_err(&client->dev, "misc_register failed\n");
472                 goto err_misc_register;
473         }
474         dev_info(&client->dev,
475                  "%s, saving address 0x%02x\n",
476                  __func__, client->addr);
477         bcm2079x_dev->original_address = client->addr;
478
479         /* request irq.  the irq is set whenever the chip has data available
480          * for reading.  it is cleared when all data has been read.
481          */
482         dev_info(&client->dev, "requesting IRQ %d with IRQF_NO_SUSPEND\n",
483                 client->irq);
484         bcm2079x_dev->irq_enabled = true;
485         ret = request_irq(client->irq, bcm2079x_dev_irq_handler,
486                           IRQF_TRIGGER_RISING|IRQF_NO_SUSPEND,
487                           client->name, bcm2079x_dev);
488         if (ret) {
489                 dev_err(&client->dev, "request_irq failed\n");
490                 goto err_request_irq_failed;
491         }
492         bcm2079x_disable_irq(bcm2079x_dev);
493         i2c_set_clientdata(client, bcm2079x_dev);
494         dev_info(&client->dev,
495                  "%s, probing bcm2079x driver exited successfully\n",
496                  __func__);
497         return 0;
498
499 err_request_irq_failed:
500         misc_deregister(&bcm2079x_dev->bcm2079x_device);
501 err_misc_register:
502         mutex_destroy(&bcm2079x_dev->read_mutex);
503         kfree(bcm2079x_dev);
504 err_exit:
505         gpio_free(platform_data->wake_gpio);
506 err_firm:
507         gpio_free(platform_data->en_gpio);
508 err_en:
509         gpio_free(platform_data->irq_gpio);
510         return ret;
511 }
512
513 static int bcm2079x_remove(struct i2c_client *client)
514 {
515         struct bcm2079x_dev *bcm2079x_dev;
516
517         bcm2079x_dev = i2c_get_clientdata(client);
518         free_irq(client->irq, bcm2079x_dev);
519         misc_deregister(&bcm2079x_dev->bcm2079x_device);
520         mutex_destroy(&bcm2079x_dev->read_mutex);
521         gpio_free(bcm2079x_dev->irq_gpio);
522         gpio_free(bcm2079x_dev->en_gpio);
523         gpio_free(bcm2079x_dev->wake_gpio);
524         kfree(bcm2079x_dev);
525
526         return 0;
527 }
528
529 static void bcm2079x_shutdown(struct i2c_client *client)
530 {
531         struct bcm2079x_dev *bcm2079x_data = i2c_get_clientdata(client);
532
533         mutex_lock(&bcm2079x_data->read_mutex);
534         if (client->irq)
535                 disable_irq(client->irq);
536         bcm2079x_data->shutdown_complete = true;
537         mutex_unlock(&bcm2079x_data->read_mutex);
538
539         dev_info(&bcm2079x_data->client->dev,
540         "%s: NFC shutting down\n", __func__);
541 }
542
543 static const struct i2c_device_id bcm2079x_id[] = {
544         {"bcm2079x-i2c", 0},
545         {}
546 };
547
548 static struct i2c_driver bcm2079x_driver = {
549         .id_table = bcm2079x_id,
550         .probe = bcm2079x_probe,
551         .remove = bcm2079x_remove,
552         .shutdown = bcm2079x_shutdown,
553         .driver = {
554                 .owner = THIS_MODULE,
555                 .name = "bcm2079x-i2c",
556         },
557 };
558
559 /*
560  * module load/unload record keeping
561  */
562
563 static int __init bcm2079x_dev_init(void)
564 {
565         return i2c_add_driver(&bcm2079x_driver);
566 }
567 module_init(bcm2079x_dev_init);
568
569 static void __exit bcm2079x_dev_exit(void)
570 {
571         i2c_del_driver(&bcm2079x_driver);
572 }
573 module_exit(bcm2079x_dev_exit);
574
575 MODULE_AUTHOR("Broadcom");
576 MODULE_DESCRIPTION("NFC bcm2079x driver");
577 MODULE_LICENSE("GPL");