media: video: tegra: Add OV9772 Camera sensor support.
[linux-2.6.git] / drivers / media / video / tegra / ov9772.c
1 /*
2  * ov9772.c - ov9772 sensor driver
3  *
4  *  * Copyright (c) 2012 NVIDIA Corporation.  All rights reserved.
5  *
6  * Contributors:
7  *        Krupal Divvela <kdivvela@nvidia.com>
8  *
9  * This file is licensed under the terms of the GNU General Public License
10  * version 2. This program is licensed "as is" without any warranty of any
11  * kind, whether express or implied.
12  */
13
14 #include <linux/delay.h>
15 #include <linux/fs.h>
16 #include <linux/i2c.h>
17 #include <linux/miscdevice.h>
18 #include <linux/slab.h>
19 #include <linux/uaccess.h>
20 #include <media/ov9772.h>
21 #include <linux/gpio.h>
22 #include <linux/module.h>
23
24 struct ov9772_reg {
25         u16 addr;
26         u16 val;
27 };
28
29 struct ov9772_info {
30         int                         mode;
31         struct ov9772_sensordata    sensor_data;
32         struct i2c_client           *i2c_client;
33         struct ov9772_platform_data *pdata;
34         atomic_t                    in_use;
35 };
36
37 #define OV9772_TABLE_WAIT_MS            0
38 #define OV9772_TABLE_END                1
39 #define OV9772_MAX_RETRIES              3
40
41 #define OV9772_WAIT_MS_100              100
42
43 static struct ov9772_reg mode_1284x724[] = {
44         /* Stand by */
45         {0x0103, 0x01},
46         {OV9772_TABLE_WAIT_MS, OV9772_WAIT_MS_100},
47
48         {0x0200, 0x00},
49         {0x0201, 0x00},
50
51         {0x0301, 0x0a},
52         {0x0303, 0x02},
53         {0x0305, 0x02},
54         {0x0307, 0x3c},
55
56         {0x0340, 0x02},
57         {0x0341, 0xf8},
58         {0x0342, 0x06},
59         {0x0343, 0x2a},
60         {0x034c, 0x05},
61         {0x034d, 0x04},
62         {0x034e, 0x02},
63         {0x034f, 0xd4},
64
65         {0x300c, 0x22},
66         {0x300d, 0x1e},
67         {0x300e, 0xc2},
68         {0x3010, 0x81},
69         {0x3012, 0x70},
70         {0x3014, 0x0d},
71         {0x3022, 0x20},
72         {0x3025, 0x03},
73         {0x303c, 0x23},
74
75         {0x3103, 0x01},
76         {0x3104, 0x00},
77
78         {0x3503, 0x14},
79
80         {0x3602, 0xc0},
81         {0x3611, 0x10},
82         {0x3613, 0x83},
83         {0x3620, 0x24},
84         {0x3622, 0x2c},
85         {0x3631, 0xc2},
86         {0x3634, 0x04},
87
88         {0x3708, 0x24},
89         {0x3709, 0x10},
90         {0x370e, 0x00},
91         {0x371b, 0x60},
92         {0x3724, 0x1c},
93         {0x372c, 0x00},
94         {0x372d, 0x00},
95         {0x3745, 0x00},
96         {0x3746, 0x18},
97
98         {0x3811, 0x0e},
99         {0x3813, 0x08},
100
101         {0x3a0c, 0x20},
102
103         {0x3b01, 0x32},
104         {0x3b02, 0xa4},
105
106         {0x3c00, 0x00},
107
108         {0x3f00, 0x2a},
109         {0x3f01, 0x8c},
110         {0x3f0f, 0xf5},
111
112         {0x4000, 0x07},
113
114         {0x4001, 0x02},
115
116         {0x460e, 0xb1},
117
118         {0x4800, 0x44},
119         {0x4801, 0x0f},
120         {0x4805, 0x10},
121         {0x4815, 0x00},
122         {0x4837, 0x36},
123
124         {0x5000, 0x06},
125         {0x5001, 0x31},
126         {0x5005, 0x08},
127
128         {0x5100, 0x00},
129
130         {0x5310, 0x01},
131         {0x5311, 0xff},
132         {0x53b9, 0x0f},
133         {0x53ba, 0x04},
134         {0x53bb, 0x4a},
135         {0x53bc, 0xd3},
136         {0x53bd, 0x41},
137         {0x53be, 0x00},
138         {0x53c4, 0x03},
139
140         /* Start Streaming */
141         {0x0100, 0x01},
142
143         {OV9772_TABLE_WAIT_MS, OV9772_WAIT_MS_100},
144         {OV9772_TABLE_END, 0x00}
145 };
146
147 enum {
148         ov9772_MODE_1284x724,
149 };
150
151 static struct ov9772_reg *mode_table[] = {
152         [ov9772_MODE_1284x724] = mode_1284x724,
153 };
154
155 static inline void msleep_range(unsigned int delay_base)
156 {
157         usleep_range(delay_base*1000, delay_base*1000+500);
158 }
159
160 static inline void ov9772_get_frame_length_regs(struct ov9772_reg *regs,
161                                                 u32 frame_length)
162 {
163         regs->addr = OV9772_REG_FRAME_LENGTH_HI;
164         regs->val = (frame_length >> 8) & 0xff;
165         regs++;
166         regs->addr = OV9772_REG_FRAME_LENGTH_LO;
167         regs->val = frame_length & 0xff;
168 }
169
170 static inline void ov9772_get_coarse_time_regs(struct ov9772_reg *regs,
171                                                u32 coarse_time)
172 {
173         regs->addr = OV9772_REG_COARSE_TIME_HI;
174         regs->val = (coarse_time >> 8) & 0xff;
175         regs++;
176         regs->addr = OV9772_REG_COARSE_TIME_LO;
177         regs->val = coarse_time & 0xff;
178 }
179
180 static inline void ov9772_get_gain_reg(struct ov9772_reg *regs, u16 gain)
181 {
182         regs->addr = OV9772_REG_GAIN_HI;
183         regs->val  = gain;
184 }
185
186 static int ov9772_read_reg(struct i2c_client *client, u16 addr, u8 *val)
187 {
188         int err;
189         struct i2c_msg msg[2];
190         unsigned char data[3];
191
192         if (!client->adapter)
193                 return -ENODEV;
194
195         msg[0].addr = client->addr;
196         msg[0].flags = 0;
197         msg[0].len = 2;
198         msg[0].buf = data;
199
200         /* high byte goes out first */
201         data[0] = (u8) (addr >> 8);
202         data[1] = (u8) (addr & 0xff);
203
204         msg[1].addr = client->addr;
205         msg[1].flags = I2C_M_RD;
206         msg[1].len = 1;
207         msg[1].buf = data + 2;
208
209         err = i2c_transfer(client->adapter, msg, 2);
210
211         if (err != 2)
212                 return -EINVAL;
213
214         *val = data[2];
215         return 0;
216 }
217
218 static int ov9772_write_reg(struct i2c_client *client, u16 addr, u8 val)
219 {
220         int err;
221         struct i2c_msg msg;
222         unsigned char data[3];
223         int retry = 0;
224
225         if (!client->adapter)
226                 return -ENODEV;
227
228         data[0] = (u8) (addr >> 8);
229         data[1] = (u8) (addr & 0xff);
230         data[2] = (u8) (val & 0xff);
231
232         msg.addr = client->addr;
233         msg.flags = 0;
234         msg.len = 3;
235         msg.buf = data;
236
237         do {
238                 err = i2c_transfer(client->adapter, &msg, 1);
239                 if (err == 1)
240                         return 0;
241                 retry++;
242                 pr_err("[ov9772]:%s:i2c transfer failed, retrying %x %x\n",
243                        __func__, addr, val);
244                 msleep_range(3);
245         } while (retry <= OV9772_MAX_RETRIES);
246
247         return err;
248 }
249
250 static int ov9772_write_table(struct i2c_client *client,
251                                  const struct ov9772_reg table[],
252                                  const struct ov9772_reg override_list[],
253                                  int num_override_regs)
254 {
255         int err;
256         const struct ov9772_reg *next;
257         int i;
258         u16 val;
259
260         for (next = table; next->addr != OV9772_TABLE_END; next++) {
261                 if (next->addr == OV9772_TABLE_WAIT_MS) {
262                         msleep_range(next->val);
263                         continue;
264                 }
265
266                 val = next->val;
267
268                 /* When an override list is passed in, replace the reg */
269                 /* value to write if the reg is in the list            */
270                 if (override_list) {
271                         for (i = 0; i < num_override_regs; i++) {
272                                 if (next->addr == override_list[i].addr) {
273                                         val = override_list[i].val;
274                                         break;
275                                 }
276                         }
277                 }
278
279                 err = ov9772_write_reg(client, next->addr, val);
280                 if (err) {
281                         pr_err("[ov9772]:%s:ov9772_write_table:%d",
282                                __func__, err);
283                         return err;
284                 }
285         }
286         return 0;
287 }
288
289 static int ov9772_set_mode(struct ov9772_info *info, struct ov9772_mode *mode)
290 {
291         int sensor_mode;
292         int err;
293         struct ov9772_reg reg_list[5];
294
295         pr_info("[ov9772]:%s: xres %u yres %u framelength %u coarsetime %u \
296                 gain %u\n", __func__, mode->xres, mode->yres, mode->frame_length,
297                          mode->coarse_time, mode->gain);
298
299         if (mode->xres == 1284 && mode->yres == 724)
300                 sensor_mode = ov9772_MODE_1284x724;
301         else {
302                 pr_err("[ov9772]:%s: invalid resolution supplied to set \
303                 mode %d %d\n", __func__, mode->xres, mode->yres);
304                 return -EINVAL;
305         }
306
307         /* get a list of override regs for the asking frame length, */
308         /* coarse integration time, and gain.                       */
309         ov9772_get_frame_length_regs(reg_list, mode->frame_length);
310         ov9772_get_coarse_time_regs(reg_list + 2, mode->coarse_time);
311         ov9772_get_gain_reg(reg_list + 4, mode->gain);
312
313         err = ov9772_write_table(info->i2c_client, mode_table[sensor_mode],
314                                                          reg_list, 5);
315         if (err)
316                 return err;
317
318         info->mode = sensor_mode;
319         pr_info("[ov9772]: stream on.\n");
320         return 0;
321 }
322
323 static int ov9772_get_status(struct ov9772_info *info, u8 *dev_status)
324 {
325         *dev_status = 0;
326         return 0;
327 }
328
329 static int ov9772_set_frame_length(struct ov9772_info *info, u32 frame_length,
330                                                  bool group_hold)
331 {
332         struct ov9772_reg reg_list[2];
333         int i = 0;
334         int ret;
335
336         ov9772_get_frame_length_regs(reg_list, frame_length);
337
338         if (group_hold) {
339                 ret = ov9772_write_reg(info->i2c_client, 0x0104, 0x01);
340                 if (ret)
341                         return ret;
342         }
343
344         for (i = 0; i < 2; i++) {
345                 ret = ov9772_write_reg(info->i2c_client, reg_list[i].addr,
346                          reg_list[i].val);
347                 if (ret)
348                         return ret;
349         }
350
351         if (group_hold) {
352                 ret = ov9772_write_reg(info->i2c_client, 0x0104, 0x0);
353                 if (ret)
354                         return ret;
355         }
356
357         return 0;
358 }
359
360 static int ov9772_set_coarse_time(struct ov9772_info *info, u32 coarse_time,
361                                                  bool group_hold)
362 {
363         int ret;
364
365         struct ov9772_reg reg_list[2];
366         int i = 0;
367
368         ov9772_get_coarse_time_regs(reg_list, coarse_time);
369
370         if (group_hold) {
371                 ret = ov9772_write_reg(info->i2c_client, 0x104, 0x01);
372                 if (ret)
373                         return ret;
374         }
375
376         for (i = 0; i < 2; i++) {
377                 ret = ov9772_write_reg(info->i2c_client, reg_list[i].addr,
378                          reg_list[i].val);
379                 if (ret)
380                         return ret;
381         }
382
383         if (group_hold) {
384                 ret = ov9772_write_reg(info->i2c_client, 0x104, 0x0);
385                 if (ret)
386                         return ret;
387         }
388         return 0;
389 }
390
391 static int ov9772_set_gain(struct ov9772_info *info, u16 gain, bool group_hold)
392 {
393         int ret;
394         struct ov9772_reg reg_list;
395
396         ov9772_get_gain_reg(&reg_list, gain);
397
398         if (group_hold) {
399                 ret = ov9772_write_reg(info->i2c_client, 0x104, 0x1);
400                 if (ret)
401                         return ret;
402         }
403
404         ret = ov9772_write_reg(info->i2c_client, reg_list.addr, reg_list.val);
405         if (ret)
406                 return ret;
407
408         if (group_hold) {
409                 ret = ov9772_write_reg(info->i2c_client, 0x104, 0x0);
410                 if (ret)
411                         return ret;
412         }
413         return 0;
414 }
415
416 static int ov9772_set_group_hold(struct ov9772_info *info, struct ov9772_ae *ae)
417 {
418         int ret;
419         int count = 0;
420         bool groupHoldEnabled = false;
421
422         if (ae->gain_enable)
423                 count++;
424         if (ae->coarse_time_enable)
425                 count++;
426         if (ae->frame_length_enable)
427                 count++;
428         if (count >= 2)
429                 groupHoldEnabled = true;
430
431         if (groupHoldEnabled) {
432                 ret = ov9772_write_reg(info->i2c_client, 0x104, 0x1);
433                 if (ret)
434                         return ret;
435         }
436
437         if (ae->gain_enable)
438                 ov9772_set_gain(info, ae->gain, false);
439         if (ae->coarse_time_enable)
440                 ov9772_set_coarse_time(info, ae->coarse_time, false);
441         if (ae->frame_length_enable)
442                 ov9772_set_frame_length(info, ae->frame_length, false);
443
444         if (groupHoldEnabled) {
445                 ret = ov9772_write_reg(info->i2c_client, 0x104, 0x0);
446                 if (ret)
447                         return ret;
448         }
449
450         return 0;
451 }
452
453 static int ov9772_get_sensor_id(struct ov9772_info *info)
454 {
455         int ret = 0;
456         int i;
457         u8 bak = 0;
458
459         pr_info("%s\n", __func__);
460         if (info->sensor_data.fuse_id_size)
461                 return 0;
462
463         /* Note 1: If the sensor does not have power at this point
464         Need to supply the power, e.g. by calling power on function */
465
466         for (i = 0; i < 5; i++) {
467                 ret |= ov9772_write_reg(info->i2c_client, 0x3d00, i);
468                 ret |= ov9772_read_reg(info->i2c_client, 0x3d04,
469                                 &bak);
470                 info->sensor_data.fuse_id[i] = bak;
471         }
472
473         if (!ret)
474                 info->sensor_data.fuse_id_size = i;
475
476         /* Note 2: Need to clean up any action carried out in Note 1 */
477
478         return ret;
479 }
480
481 static long ov9772_ioctl(struct file *file,
482                          unsigned int cmd, unsigned long arg)
483 {
484         int err;
485         struct ov9772_info *info = file->private_data;
486
487         switch (cmd) {
488         case OV9772_IOCTL_SET_MODE:
489         {
490                 struct ov9772_mode mode;
491                 if (copy_from_user(&mode,
492                          (const void __user *)arg,
493                          sizeof(struct ov9772_mode))) {
494                         pr_err("[ov9772]:%s:Failed to get mode from user.\n",
495                                __func__);
496                         return -EFAULT;
497                 }
498                 return ov9772_set_mode(info, &mode);
499         }
500         case OV9772_IOCTL_SET_FRAME_LENGTH:
501                 return ov9772_set_frame_length(info, (u32)arg, true);
502         case OV9772_IOCTL_SET_COARSE_TIME:
503                 return ov9772_set_coarse_time(info, (u32)arg, true);
504         case OV9772_IOCTL_SET_GAIN:
505                 return ov9772_set_gain(info, (u16)arg, true);
506         case OV9772_IOCTL_GET_STATUS:
507         {
508                 u8 status;
509
510                 err = ov9772_get_status(info, &status);
511                 if (err)
512                         return err;
513                 if (copy_to_user((void __user *)arg, &status, 1)) {
514                         pr_err("[ov9772]:%s:Failed to copy status to user.\n",
515                                __func__);
516                         return -EFAULT;
517                         }
518                 return 0;
519         }
520         case OV9772_IOCTL_GET_SENSORDATA:
521         {
522                 err = ov9772_get_sensor_id(info);
523
524                 if (err) {
525                         pr_err("[ov9772]:%s:Failed to get fuse id info.\n",
526                                __func__);
527                         return err;
528                 }
529                 if (copy_to_user((void __user *)arg,
530                                  &info->sensor_data,
531                                  sizeof(struct ov9772_sensordata))) {
532                         pr_info("[ov9772]:%s:Failed to copy fuse id to user \
533                                 space\n",__func__);
534                         return -EFAULT;
535                 }
536                 return 0;
537         }
538         case OV9772_IOCTL_SET_GROUP_HOLD:
539         {
540           struct ov9772_ae ae;
541           if (copy_from_user(&ae, (const void __user *)arg,
542                         sizeof(struct ov9772_ae))) {
543                 pr_info("[ov9772]:%s:fail group hold\n", __func__);
544                 return -EFAULT;
545           }
546           return ov9772_set_group_hold(info, &ae);
547         }
548         default:
549           pr_err("[ov9772]:%s:unknown cmd.\n", __func__);
550           return -EINVAL;
551         }
552         return 0;
553 }
554
555 static struct ov9772_info *info;
556
557 static int ov9772_open(struct inode *inode, struct file *file)
558 {
559         /* check if the device is in use */
560         if (atomic_xchg(&info->in_use, 1)) {
561                 pr_info("[ov9772]:%s:BUSY!\n", __func__);
562                 return -EBUSY;
563         }
564
565         file->private_data = info;
566
567         if (info->pdata && info->pdata->power_on)
568                 info->pdata->power_on();
569         else{
570                 pr_err("[ov9772]:%s:no valid power_on function.\n",
571                        __func__);
572                 return -EEXIST;
573         }
574
575         return 0;
576 }
577
578 static int ov9772_release(struct inode *inode, struct file *file)
579 {
580         if (info->pdata && info->pdata->power_off)
581                 info->pdata->power_off();
582         file->private_data = NULL;
583
584         /* warn if device is already released */
585         WARN_ON(!atomic_xchg(&info->in_use, 0));
586         return 0;
587 }
588
589
590 static const struct file_operations ov9772_fileops = {
591         .owner = THIS_MODULE,
592         .open = ov9772_open,
593         .unlocked_ioctl = ov9772_ioctl,
594         .release = ov9772_release,
595 };
596
597 static struct miscdevice ov9772_device = {
598         .minor = MISC_DYNAMIC_MINOR,
599         .name = "ov9772",
600         .fops = &ov9772_fileops,
601 };
602
603 static int ov9772_probe(struct i2c_client *client,
604                         const struct i2c_device_id *id)
605 {
606         int err;
607
608         pr_info("[ov9772]: probing sensor.\n");
609
610         info = kzalloc(sizeof(struct ov9772_info), GFP_KERNEL);
611         if (!info) {
612                 pr_err("[ov9772]:%s:Unable to allocate memory!\n", __func__);
613                 return -ENOMEM;
614         }
615
616         err = misc_register(&ov9772_device);
617         if (err) {
618                 pr_err("[ov9772]:%s:Unable to register misc device!\n",
619                        __func__);
620                 kfree(info);
621                 return err;
622         }
623
624         info->pdata = client->dev.platform_data;
625         info->i2c_client = client;
626         atomic_set(&info->in_use, 0);
627         info->mode = -1;
628
629         i2c_set_clientdata(client, info);
630
631         return 0;
632 }
633
634 static int ov9772_remove(struct i2c_client *client)
635 {
636         struct ov9772_info *info;
637         info = i2c_get_clientdata(client);
638         misc_deregister(&ov9772_device);
639         kfree(info);
640         return 0;
641 }
642
643 static const struct i2c_device_id ov9772_id[] = {
644         { "ov9772", 0 },
645 };
646
647 MODULE_DEVICE_TABLE(i2c, ov9772_id);
648
649 static struct i2c_driver ov9772_i2c_driver = {
650         .driver = {
651                 .name = "ov9772",
652                 .owner = THIS_MODULE,
653         },
654         .probe = ov9772_probe,
655         .remove = ov9772_remove,
656         .id_table = ov9772_id,
657 };
658
659 static int __init ov9772_init(void)
660 {
661         pr_info("[ov9772] sensor driver loading\n");
662         return i2c_add_driver(&ov9772_i2c_driver);
663 }
664
665 static void __exit ov9772_exit(void)
666 {
667         i2c_del_driver(&ov9772_i2c_driver);
668 }
669
670 module_init(ov9772_init);
671 module_exit(ov9772_exit);