041c830501efc7846fffdd73f9fc128ea374ed65
[linux-3.10.git] / drivers / media / platform / tegra / camera.c
1 /*
2  * camera.c - generic camera device driver
3  *
4  * Copyright (c) 2013-2016, NVIDIA CORPORATION.  All rights reserved.
5  *
6  * Contributors:
7  *      Charlie Huang <chahuang@nvidia.com>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms and conditions of the GNU General Public License,
11  * version 2, as published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20  */
21
22 /* Implementation
23  * --------------
24  * The board level details about the device are to be provided in the board
25  * file with the <device>_platform_data structure.
26  * Standard among NVC kernel drivers in this structure is:
27  * .dev_name = The MISC driver name the device registers as.  If not used,
28  *           then the part number of the device is used for the driver name.
29  *           If using the NVC user driver then use the name found in this
30  *           driver under _default_pdata.
31  */
32
33 #define CAMERA_DEVICE_INTERNAL
34 #include <linux/fs.h>
35 #include <linux/platform_device.h>
36 #include <linux/slab.h>
37 #include <linux/uaccess.h>
38 #include <linux/regulator/consumer.h>
39 #include <linux/gpio.h>
40 #include <linux/i2c.h>
41 #include <linux/module.h>
42 #include <linux/seq_file.h>
43 #include <linux/debugfs.h>
44 #include <linux/clk.h>
45
46 #include "t124/t124.h"
47 #include <isp.h>
48 #include <media/camera.h>
49
50 static struct camera_platform_data camera_dflt_pdata = {
51         .cfg = 0,
52 };
53
54 static atomic_t cam_ref;
55 static DEFINE_MUTEX(cam_mutex);
56
57 static DEFINE_MUTEX(app_mutex);
58 static DEFINE_MUTEX(dev_mutex);
59 static DEFINE_MUTEX(chip_mutex);
60 static LIST_HEAD(app_list);
61 static LIST_HEAD(dev_list);
62 static LIST_HEAD(chip_list);
63
64 static struct camera_platform_info cam_desc = {
65         .in_use = ATOMIC_INIT(0),
66         .u_mutex = &app_mutex,
67         .d_mutex = &dev_mutex,
68         .c_mutex = &chip_mutex,
69         .app_list = &app_list,
70         .dev_list = &dev_list,
71         .chip_list = &chip_list,
72 };
73
74 static inline void camera_ref_init(void)
75 {
76         atomic_set(&cam_ref, 0);
77 }
78
79 static int camera_ref_raise(void)
80 {
81         mutex_lock(&cam_mutex);
82         if (atomic_read(&cam_ref) < 0) {
83                 mutex_unlock(&cam_mutex);
84                 dev_err(cam_desc.dev, "%s - CAMERA DOWN.\n", __func__);
85                 return -ENOTTY;
86         }
87         atomic_inc(&cam_ref);
88         mutex_unlock(&cam_mutex);
89
90         return 0;
91 }
92
93 static inline void camera_ref_down(void)
94 {
95         atomic_dec(&cam_ref);
96 }
97
98 static void camera_ref_lock(void)
99 {
100         int ref;
101
102         do {
103                 mutex_lock(&cam_mutex);
104                 ref = atomic_read(&cam_ref);
105                 if (ref <= 0) {
106                         atomic_set(&cam_ref, -1);
107                         mutex_unlock(&cam_mutex);
108                         break;
109                 }
110                 mutex_unlock(&cam_mutex);
111                 usleep_range(10000, 10200);
112         } while (true);
113 }
114
115 #ifdef CONFIG_COMPAT
116 int camera_copy_user_params(unsigned long arg, struct nvc_param *prm)
117 {
118         struct nvc_param_32 p32;
119
120         memcpy(&p32, prm, sizeof(p32));
121         p32.p_value = (u32)prm->p_value;
122
123         return copy_to_user(
124                 (void __user *)arg, (const void *)&p32, sizeof(p32));
125 }
126 #else
127 int camera_copy_user_params(unsigned long arg, struct nvc_param *prm)
128 {
129         return copy_to_user(
130                 MAKE_USER_PTR(arg), (const void *)prm, sizeof(*prm));
131 }
132 #endif
133
134 int __camera_get_params(
135         struct camera_info *cam, unsigned long arg, int u_size,
136         struct nvc_param *prm, void **data, bool zero_size_ok)
137 {
138         void *buf;
139         size_t size;
140
141 #ifdef CONFIG_COMPAT
142         memset(prm, 0, sizeof(*prm));
143         if (copy_from_user(
144                 prm, (const void __user *)arg, sizeof(struct nvc_param_32))) {
145                 dev_err(cam->dev, "%s copy_from_user err line %d\n",
146                         __func__, __LINE__);
147                 return -EFAULT;
148         }
149 #else
150         if (copy_from_user(prm, (const void __user *)arg, sizeof(*prm))) {
151                 dev_err(cam->dev, "%s copy_from_user err line %d\n",
152                         __func__, __LINE__);
153                 return -EFAULT;
154         }
155 #endif
156         if (!data)
157                 return 0;
158
159         if (zero_size_ok && prm->sizeofvalue == 0) {
160                 *data = ZERO_SIZE_PTR;
161                 return 0;
162         }
163
164         size = prm->sizeofvalue * u_size;
165         buf = kcalloc(prm->sizeofvalue, u_size, GFP_KERNEL);
166         if (ZERO_OR_NULL_PTR(buf)) {
167                 dev_err(cam->dev, "%s allocate memory failed!\n", __func__);
168                 return -ENOMEM;
169         }
170         if (copy_from_user(buf, MAKE_CONSTUSER_PTR(prm->p_value), size)) {
171                 dev_err(cam->dev, "%s copy_from_user err line %d\n",
172                         __func__, __LINE__);
173                 kfree(buf);
174                 return -EFAULT;
175         }
176         *data = buf;
177
178         return 0;
179 }
180
181 static int camera_validate_p_i2c_table(struct camera_info *cam,
182                 const struct nvc_param *params,
183                 const struct camera_reg *p_i2c_table, const char *caller)
184 {
185         u32 idx, last_idx = params->sizeofvalue / sizeof(p_i2c_table[0]);
186
187         for (idx = 0; idx < last_idx; idx++)
188                 if (p_i2c_table[idx].addr == CAMERA_TABLE_END)
189                         return 0;
190
191         dev_err(cam->dev, "%s: table is not properly terminated\n", caller);
192         return -EINVAL;
193 }
194
195 static int camera_seq_rd(struct camera_info *cam, unsigned long arg)
196 {
197         struct nvc_param params;
198         struct camera_reg *p_i2c_table;
199         int err;
200
201         dev_dbg(cam->dev, "%s %lx\n", __func__, arg);
202         err = camera_get_params(cam, arg, 1, &params, (void **)&p_i2c_table);
203         if (err)
204                 return err;
205
206         err = camera_validate_p_i2c_table(cam, &params, p_i2c_table, __func__);
207         if (err)
208                 goto seq_rd_end;
209
210         err = camera_dev_rd_table(cam->cdev, p_i2c_table);
211         if (!err && copy_to_user(MAKE_USER_PTR(params.p_value),
212                 p_i2c_table, params.sizeofvalue)) {
213                 dev_err(cam->dev, "%s copy_to_user err line %d\n",
214                         __func__, __LINE__);
215                 err = -EINVAL;
216         }
217
218 seq_rd_end:
219         kfree(p_i2c_table);
220         return err;
221 }
222
223 static int camera_seq_wr(struct camera_info *cam, unsigned long arg)
224 {
225         struct nvc_param params;
226         struct camera_device *cdev = cam->cdev;
227         struct camera_reg *p_i2c_table = NULL;
228         struct camera_seq_status seqs;
229         u8 pfree = 0;
230         int err = 0;
231         int idx;
232
233         dev_dbg(cam->dev, "%s %lx", __func__, arg);
234
235         err = camera_get_params(cam, arg, 0, &params, NULL);
236         if (err)
237                 return err;
238
239         dev_dbg(cam->dev, "param: %x, size %d\n", params.param,
240                 params.sizeofvalue);
241         if (params.param == CAMERA_SEQ_EXIST) {
242                 idx = params.variant & CAMERA_SEQ_INDEX_MASK;
243                 if (idx >= NUM_OF_SEQSTACK) {
244                         dev_err(cam->dev, "%s seq index out of range %d\n",
245                                 __func__, idx);
246                         return -EFAULT;
247                 }
248                 p_i2c_table = cdev->seq_stack[idx];
249                 if (p_i2c_table == NULL) {
250                         dev_err(cam->dev, "%s seq index empty! %d\n",
251                                 __func__, idx);
252                         return -EEXIST;
253                 }
254                 goto seq_wr_table;
255         }
256
257         p_i2c_table = devm_kzalloc(cdev->dev, params.sizeofvalue, GFP_KERNEL);
258         if (ZERO_OR_NULL_PTR(p_i2c_table)) {
259                 dev_err(cam->dev, "%s devm_kzalloc err line %d\n",
260                         __func__, __LINE__);
261                 return -ENOMEM;
262         }
263         pfree = 1;
264
265         if (copy_from_user(p_i2c_table,
266                 MAKE_CONSTUSER_PTR(params.p_value), params.sizeofvalue)) {
267                 dev_err(cam->dev, "%s copy_from_user err line %d\n",
268                         __func__, __LINE__);
269                 err = -EFAULT;
270                 goto seq_wr_end;
271         }
272
273         err = camera_validate_p_i2c_table(cam, &params, p_i2c_table, __func__);
274         if (err)
275                 goto seq_wr_end;
276
277         switch (params.param) {
278         case CAMERA_SEQ_REGISTER_EXEC:
279         case CAMERA_SEQ_REGISTER_ONLY:
280                 for (idx = 0; idx < NUM_OF_SEQSTACK; idx++) {
281                         if (!cdev->seq_stack[idx]) {
282                                 cdev->seq_stack[idx] = p_i2c_table;
283                                 pfree = 0;
284                                 break;
285                         }
286                 }
287                 if (idx >= NUM_OF_SEQSTACK) {
288                         dev_err(cam->dev, "%s seq index full!\n", __func__);
289                         err = -EINVAL;
290                         goto seq_wr_end;
291                 } else {
292                         params.variant = idx;
293                         goto seq_wr_upd;
294                 }
295                 if (params.param == CAMERA_SEQ_REGISTER_EXEC)
296                         goto seq_wr_table;
297                 break;
298         case CAMERA_SEQ_EXEC:
299                 break;
300         }
301
302 seq_wr_table:
303         if (err < 0)
304                 goto seq_wr_end;
305
306         memset(&seqs, 0, sizeof(seqs));
307         mutex_lock(&cdev->mutex);
308         err = camera_dev_wr_table(cdev, p_i2c_table, &seqs);
309         mutex_unlock(&cdev->mutex);
310         if (err < 0) {
311                 params.param = CAMERA_SEQ_STATUS_MASK | seqs.idx;
312                 params.variant = seqs.status;
313         }
314
315 seq_wr_upd:
316         if (camera_copy_user_params(arg, &params)) {
317                 dev_err(cam->dev, "%s copy_to_user err line %d\n",
318                         __func__, __LINE__);
319                 err = -EFAULT;
320         }
321
322 seq_wr_end:
323         if (pfree) {
324                 /* if table has been updated, send it back */
325                 if (err > 0 && copy_to_user(MAKE_USER_PTR(params.p_value),
326                         p_i2c_table, params.sizeofvalue)) {
327                         dev_err(cam->dev, "%s copy_to_user err line %d\n",
328                                 __func__, __LINE__);
329                         err = -EFAULT;
330                 }
331                 devm_kfree(cdev->dev, p_i2c_table);
332         }
333         return err;
334 }
335
336 static int camera_dev_pwr_set(struct camera_info *cam, unsigned long pwr)
337 {
338         struct camera_device *cdev = cam->cdev;
339         struct camera_chip *chip = cdev->chip;
340         int err = 0;
341
342         dev_dbg(cam->dev, "%s %lu %d\n", __func__, pwr, cdev->pwr_state);
343         if (pwr == cdev->pwr_state)     /* power state no change */
344                 goto dev_power_end;
345
346         switch (pwr) {
347         case NVC_PWR_OFF:
348         case NVC_PWR_STDBY_OFF:
349                 if (chip->power_off)
350                         err |= chip->power_off(cdev);
351                 camera_edp_lowest(cdev);
352                 break;
353         case NVC_PWR_STDBY:
354         case NVC_PWR_COMM:
355         case NVC_PWR_ON:
356                 if (chip->power_on)
357                         err = chip->power_on(cdev);
358                 break;
359         default:
360                 err = -EINVAL;
361                 break;
362         }
363
364         if (err < 0) {
365                 dev_err(cam->dev, "%s error\n", __func__);
366                 pwr = NVC_PWR_ERR;
367         }
368
369         cdev->pwr_state = pwr;
370         if (err > 0)
371                 err = 0;
372
373 dev_power_end:
374         return err;
375 }
376
377 static int camera_dev_pwr_get(struct camera_info *cam, unsigned long arg)
378 {
379         int pwr;
380         int err = 0;
381
382         pwr = cam->cdev->pwr_state;
383         dev_dbg(cam->dev, "%s PWR_RD: %d\n", __func__, pwr);
384         if (copy_to_user((void __user *)arg, (const void *)&pwr,
385                 sizeof(pwr))) {
386                 dev_err(cam->dev, "%s copy_to_user err line %d\n",
387                         __func__, __LINE__);
388                 err = -EFAULT;
389         }
390
391         return err;
392 }
393
394 static struct camera_chip *camera_chip_chk(char *name)
395 {
396         struct camera_chip *ccp;
397
398         mutex_lock(cam_desc.c_mutex);
399         list_for_each_entry(ccp, cam_desc.chip_list, list)
400                 if (!strcmp(ccp->name, name)) {
401                         dev_dbg(cam_desc.dev, "%s device %s found.\n",
402                                 __func__, name);
403                         mutex_unlock(cam_desc.c_mutex);
404                         return ccp;
405                 }
406         mutex_unlock(cam_desc.c_mutex);
407         return NULL;
408 }
409
410 int camera_chip_add(struct camera_chip *chip)
411 {
412         struct camera_chip *ccp;
413         int err = 0;
414
415         dev_dbg(cam_desc.dev, "%s add chip: %s\n", __func__, chip->name);
416         mutex_lock(cam_desc.c_mutex);
417         list_for_each_entry(ccp, cam_desc.chip_list, list)
418                 if (!strcmp(ccp->name, chip->name)) {
419                         dev_notice(cam_desc.dev, "%s chip %s already added.\n",
420                                 __func__, chip->name);
421                         mutex_unlock(cam_desc.c_mutex);
422                         return -EEXIST;
423                 }
424
425         list_add_tail(&chip->list, cam_desc.chip_list);
426         mutex_unlock(cam_desc.c_mutex);
427         return err;
428 }
429 EXPORT_SYMBOL_GPL(camera_chip_add);
430
431 static int camera_remove_device(struct camera_device *cdev, bool ref_dec)
432 {
433         dev_dbg(cdev->dev, "%s %s\n", __func__, cdev->name);
434         if (!cdev) {
435                 dev_err(cam_desc.dev, "%s cdev is NULL!\n", __func__);
436                 return -EFAULT;
437         }
438
439         WARN_ON(atomic_xchg(&cdev->in_use, 0));
440         if (cdev->cam) {
441                 struct camera_info *cam = cdev->cam;
442                 cam->cdev = NULL;
443                 cam->dev = cam_desc.dev;
444                 atomic_set(&cam->in_use, 0);
445         }
446         if (cdev->chip) {
447                 (cdev->chip->release)(cdev);
448                 if (ref_dec)
449                         atomic_dec(&cdev->chip->ref_cnt);
450         }
451         if (cdev->dev)
452                 i2c_unregister_device(to_i2c_client(cdev->dev));
453         kfree(cdev);
454         return 0;
455 }
456
457 static int camera_free_device(struct camera_info *cam, unsigned long arg)
458 {
459         struct camera_device *cdev = cam->cdev;
460
461         dev_dbg(cam->dev, "%s %lx", __func__, arg);
462         mutex_lock(cam_desc.d_mutex);
463         atomic_set(&cdev->in_use, 0);
464         mutex_unlock(cam_desc.d_mutex);
465
466         return 0;
467 }
468
469 static int camera_new_device(struct camera_info *cam, unsigned long arg)
470 {
471         struct camera_device_info dev_info;
472         struct camera_device *new_dev;
473         struct camera_device *next_dev;
474         struct camera_chip *c_chip;
475         struct i2c_adapter *adap;
476         struct i2c_board_info brd;
477         struct i2c_client *client;
478         int err = 0;
479
480         dev_dbg(cam->dev, "%s %lx", __func__, arg);
481         if (copy_from_user(
482                 &dev_info, (const void __user *)arg, sizeof(dev_info))) {
483                 dev_err(cam_desc.dev, "%s copy_from_user err line %d\n",
484                         __func__, __LINE__);
485                 err = -EFAULT;
486                 goto new_device_end;
487         }
488
489         dev_dbg(cam->dev, "%s - %d %d %x\n",
490                 dev_info.name, dev_info.type, dev_info.bus, dev_info.addr);
491
492         c_chip = camera_chip_chk(dev_info.name);
493         if (c_chip == NULL) {
494                 dev_err(cam->dev, "%s device %s not found\n",
495                         __func__, dev_info.name);
496                 err = -ENODEV;
497                 goto new_device_end;
498         }
499
500         adap = i2c_get_adapter(dev_info.bus);
501         if (!adap) {
502                 dev_err(cam_desc.dev, "%s no such i2c bus %d\n",
503                         __func__, dev_info.bus);
504                 err = -ENODEV;
505                 goto new_device_end;
506         }
507
508         new_dev = kzalloc(sizeof(*new_dev), GFP_KERNEL);
509         if (!new_dev) {
510                 dev_err(cam_desc.dev, "%s memory low!\n", __func__);
511                 err = -ENOMEM;
512                 goto new_device_end;
513         }
514
515         new_dev->chip = c_chip;
516         memset(&brd, 0, sizeof(brd));
517         strncpy(brd.type, dev_info.name, sizeof(brd.type));
518         brd.addr = dev_info.addr;
519
520         mutex_lock(cam_desc.d_mutex);
521
522         /* check if device exists, if yes and not occupied pick it and exit */
523         list_for_each_entry(next_dev, cam_desc.dev_list, list) {
524                 if (next_dev->client &&
525                         next_dev->client->adapter == adap &&
526                         next_dev->client->addr == dev_info.addr) {
527                         dev_dbg(cam_desc.dev,
528                                 "%s: device already exists.\n", __func__);
529                         camera_remove_device(new_dev, false);
530                         if (atomic_xchg(&next_dev->in_use, 1)) {
531                                 dev_err(cam_desc.dev, "%s device %s BUSY\n",
532                                         __func__, next_dev->name);
533                                 err = -EBUSY;
534                                 goto new_device_err;
535                         }
536                         new_dev = next_dev;
537                         goto new_device_done;
538                 }
539         }
540
541         /* device is not present in the dev_list, add it */
542         client = i2c_new_device(adap, &brd);
543         if (!client) {
544                 dev_err(cam_desc.dev,
545                         "%s cannot allocate client: %s bus %d, %x\n",
546                         __func__, dev_info.name, dev_info.bus, dev_info.addr);
547                 err = -EINVAL;
548                 goto new_device_err;
549         }
550         new_dev->dev = &client->dev;
551
552         new_dev->regmap = devm_regmap_init_i2c(client, &c_chip->regmap_cfg);
553         if (IS_ERR(new_dev->regmap)) {
554                 dev_err(new_dev->dev, "%s regmap init failed: %ld\n",
555                         __func__, PTR_ERR(new_dev->regmap));
556                 err = -ENODEV;
557                 goto new_device_err;
558         }
559         strncpy(new_dev->name, dev_info.name, sizeof(new_dev->name));
560         INIT_LIST_HEAD(&new_dev->list);
561         mutex_init(&new_dev->mutex);
562         new_dev->client = client;
563
564         err = (new_dev->chip->init)(new_dev, cam_desc.pdata);
565         if (err)
566                 goto new_device_err;
567
568         atomic_inc(&c_chip->ref_cnt);
569         atomic_set(&new_dev->in_use, 1);
570
571         list_add(&new_dev->list, cam_desc.dev_list);
572
573 new_device_done:
574         mutex_unlock(cam_desc.d_mutex);
575
576         cam->cdev = new_dev;
577         cam->dev = new_dev->dev;
578         new_dev->cam = cam;
579         goto new_device_end;
580
581 new_device_err:
582         mutex_unlock(cam_desc.d_mutex);
583         camera_remove_device(new_dev, false);
584
585 new_device_end:
586         return err;
587 }
588
589 static void camera_app_remove(struct camera_info *cam, bool ref_chk)
590 {
591         dev_dbg(cam->dev, "%s\n", __func__);
592
593         if (ref_chk)
594                 WARN_ON(atomic_xchg(&cam->in_use, 0));
595         if (cam->cdev) {
596                 if (ref_chk)
597                         WARN_ON(atomic_xchg(&cam->cdev->in_use, 0));
598                 cam->cdev->cam = NULL;
599         }
600         kfree(cam);
601 }
602
603 static int camera_update(struct camera_info *cam, unsigned long arg)
604 {
605         struct camera_device *cdev = cam->cdev;
606         struct camera_chip *chip = cdev->chip;
607         struct nvc_param param;
608         struct cam_update *upd = NULL;
609         int err = 0;
610
611         dev_dbg(cam->dev, "%s %lx", __func__, arg);
612         if (!chip->update) {
613                 dev_dbg(cam->dev, "no update pointer.\n");
614                 return err;
615         }
616
617         err = __camera_get_params(cam, arg, sizeof(*upd), &param, (void **)&upd,
618                         true);
619         if (err)
620                 return err;
621
622         err = chip->update(cdev, upd, param.sizeofvalue);
623
624         kfree(upd);
625         return err;
626 }
627
628 /* need this feature for auto detect to display notifications */
629 static int camera_msg(struct camera_info *cam, unsigned long arg)
630 {
631         struct nvc_param param;
632         char *str;
633         int err = 0;
634
635         dev_dbg(cam->dev, "%s %lx", __func__, arg);
636         err = camera_get_params(cam, arg, 1, &param, (void **)&str);
637         if (err)
638                 return err;
639         if (str[param.sizeofvalue - 1] == '\0')
640                 dev_info(cam->dev, "%s\n", str);
641         kfree(str);
642
643         return 0;
644 }
645
646 static int camera_layout_update(struct camera_info *cam, unsigned long arg)
647 {
648         struct nvc_param param;
649         void *upd = NULL;
650         int err = 0;
651
652         dev_dbg(cam->dev, "%s %lx", __func__, arg);
653         mutex_lock(cam_desc.u_mutex);
654         if (cam_desc.layout) {
655                 dev_notice(cam->dev, "layout already there.\n");
656                 err = -EEXIST;
657                 goto layout_end;
658         }
659
660         err = camera_get_params(cam, arg, 1, &param, &upd);
661         if (err)
662                 goto layout_end;
663
664         cam_desc.layout = upd;
665         cam_desc.size_layout = param.sizeofvalue;
666
667 layout_end:
668         mutex_unlock(cam_desc.u_mutex);
669         return err;
670 }
671
672 static int camera_layout_get(struct camera_info *cam, unsigned long arg)
673 {
674         struct nvc_param param;
675         int len;
676         int err = 0;
677
678         dev_dbg(cam->dev, "%s %lx", __func__, arg);
679         if (!cam_desc.layout) {
680                 dev_notice(cam->dev, "layout empty.\n");
681                 err = -EEXIST;
682                 goto getlayout_end;
683         }
684
685         err = camera_get_params(cam, arg, 0, &param, NULL);
686         if (err)
687                 return err;
688
689         if (param.variant > MAX_PARAM_VARIANT) {
690                 dev_err(cam->dev, "%s param variant is too large: %u\n",
691                 __func__, param.variant);
692                 return -EINVAL;
693         }
694         if (param.sizeofvalue > MAX_PARAM_SIZE_OF_VALUE) {
695                 dev_err(cam->dev, "%s size of param value is too large: %u\n",
696                 __func__, param.sizeofvalue);
697                 return -EINVAL;
698         }
699
700         len = (int)cam_desc.size_layout - param.variant;
701         if (len <= 0) {
702                 dev_err(cam->dev, "%s invalid offset %u\n",
703                         __func__, param.variant);
704                 err = -EINVAL;
705                 goto getlayout_end;
706         }
707         if (len > param.sizeofvalue) {
708                 len = param.sizeofvalue;
709                 err = -EAGAIN;
710         }
711         if (copy_to_user(MAKE_USER_PTR(param.p_value),
712                 cam_desc.layout + param.variant, len)) {
713                 dev_err(cam->dev, "%s copy_to_user err line %d\n",
714                         __func__, __LINE__);
715                 err = -EFAULT;
716                 goto getlayout_end;
717         }
718
719         param.sizeofvalue = len;
720         param.variant = cam_desc.size_layout;
721         if (camera_copy_user_params(arg, &param)) {
722                 dev_err(cam->dev, "%s copy_to_user err line %d\n",
723                         __func__, __LINE__);
724                 err = -EFAULT;
725         }
726
727 getlayout_end:
728         return err;
729 }
730
731 static int camera_add_dev_drv(
732         struct camera_info *cam,
733         struct i2c_adapter *adap,
734         struct camera_board *cb)
735 {
736         struct i2c_client *client = NULL;
737         struct i2c_board_info *bi = NULL;
738
739         bi = cb->bi;
740         if (bi && strlen(bi->type)) {
741                 if (!adap)
742                         adap = i2c_get_adapter(cb->busnum);
743                 dev_dbg(cam->dev, "%s: installing %s @ %d-%04x\n",
744                         __func__, bi->type, adap->nr, bi->addr);
745                 client = i2c_new_device(adap, bi);
746                 if (!client) {
747                         dev_err(cam->dev, "%s add driver %s fail\n",
748                                 __func__, bi->type);
749                         return -EFAULT;
750                 }
751         }
752         return 0;
753 }
754
755 static int camera_add_drv_by_sensor_name(
756         struct camera_info *cam, struct nvc_param *param)
757 {
758         struct camera_module *cm = cam_desc.pdata->modules;
759         struct i2c_adapter *adap = NULL;
760         struct i2c_board_info *bi = NULL;
761         char ref_name[CAMERA_MAX_NAME_LENGTH];
762         int err = 0;
763
764         if (param->sizeofvalue > sizeof(ref_name) - 1) {
765                 dev_err(cam->dev, "%s driver name too long %d\n",
766                         __func__, param->sizeofvalue);
767                 err = -EFAULT;
768                 goto add_sensor_driver_end;
769         }
770
771         memset(ref_name, 0, sizeof(ref_name));
772         if (copy_from_user(ref_name, MAKE_CONSTUSER_PTR(param->p_value),
773                 param->sizeofvalue)) {
774                 dev_err(cam->dev, "%s copy_from_user err line %d\n",
775                         __func__, __LINE__);
776                 err = -EFAULT;
777                 goto add_sensor_driver_end;
778         }
779
780         dev_dbg(cam->dev, "%s looking for %s on %d\n",
781                 __func__, ref_name, param->variant);
782         adap = i2c_get_adapter(param->variant);
783         while (cm) {
784                 bi = cm->sensor.bi;
785                 if (!bi || !strlen(bi->type))
786                         break;
787
788                 dev_dbg(cam->dev, "%s\n", bi->type);
789                 if (!strcmp(bi->type, ref_name)) {
790                         err = camera_add_dev_drv(cam, adap, &cm->sensor);
791                         if (err)
792                                 break;
793
794                         err = camera_add_dev_drv(cam, adap, &cm->focuser);
795                         if (err)
796                                 break;
797
798                         err = camera_add_dev_drv(cam, adap, &cm->flash);
799                         if (err)
800                                 break;
801                 }
802                 cm++;
803         }
804
805 add_sensor_driver_end:
806         return err;
807 }
808
809 static int camera_add_drv_by_module(
810         struct camera_info *cam, struct nvc_param *param)
811 {
812         struct camera_module *cm;
813         int err;
814
815         if (!cam_desc.pdata->modules ||
816                 param->variant >= cam_desc.pdata->mod_num) {
817                 dev_err(cam->dev, "%s module %p %d not exists\n",
818                         __func__, cam_desc.pdata->modules, param->variant);
819                 return -ENODEV;
820         }
821         dev_dbg(cam->dev, "%s install module %d\n", __func__, param->variant);
822         cm = &cam_desc.pdata->modules[param->variant];
823
824         err = camera_add_dev_drv(cam, NULL, &cm->sensor);
825         if (err)
826                 return err;
827
828         err = camera_add_dev_drv(cam, NULL, &cm->focuser);
829         if (err)
830                 return err;
831
832         err = camera_add_dev_drv(cam, NULL, &cm->flash);
833         return err;
834 }
835
836 static int camera_add_drivers(struct camera_info *cam, unsigned long arg)
837 {
838         struct nvc_param param;
839         int err;
840
841         dev_dbg(cam->dev, "%s %lx", __func__, arg);
842         err = camera_get_params(cam, arg, 0, &param, NULL);
843         if (err)
844                 return err;
845
846         if (param.param == 0)
847                 return camera_add_drv_by_sensor_name(cam, &param);
848         return camera_add_drv_by_module(cam, &param);
849 }
850
851 static long camera_ioctl(struct file *file,
852                          unsigned int cmd,
853                          unsigned long arg)
854 {
855         struct camera_info *cam;
856         int err = 0;
857
858         if (camera_ref_raise())
859                 return -ENOTTY;
860
861         cam = file->private_data;
862         if (!cam->cdev && ((cmd == PCLLK_IOCTL_SEQ_WR) ||
863                 (cmd == PCLLK_IOCTL_PWR_WR) ||
864                 (cmd == PCLLK_IOCTL_PWR_RD))) {
865                 dev_err(cam_desc.dev, "%s %x - no device activated.\n",
866                         __func__, cmd);
867                 err = -ENODEV;
868                 goto ioctl_end;
869         }
870
871         /* command distributor */
872         switch (cmd) {
873         case PCLLK_IOCTL_CHIP_REG:
874                 err = virtual_device_add(cam_desc.dev, arg);
875                 break;
876         case PCLLK_IOCTL_DEV_REG:
877                 err = camera_new_device(cam, arg);
878                 break;
879         case PCLLK_IOCTL_DEV_DEL:
880                 mutex_lock(cam_desc.d_mutex);
881                 if (!cam->cdev) {
882                         err = -ENODEV;
883                         mutex_unlock(cam_desc.d_mutex);
884                         break;
885                 }
886                 list_del(&cam->cdev->list);
887                 camera_remove_device(cam->cdev, true);
888                 mutex_unlock(cam_desc.d_mutex);
889                 break;
890         case PCLLK_IOCTL_DEV_FREE:
891                 err = camera_free_device(cam, arg);
892                 break;
893         case PCLLK_IOCTL_SEQ_WR:
894                 mutex_lock(cam_desc.d_mutex);
895                 err = camera_seq_wr(cam, arg);
896                 mutex_unlock(cam_desc.d_mutex);
897                 break;
898         case PCLLK_IOCTL_SEQ_RD:
899                 mutex_lock(cam_desc.d_mutex);
900                 err = camera_seq_rd(cam, arg);
901                 mutex_unlock(cam_desc.d_mutex);
902                 break;
903         case PCLLK_IOCTL_PARAM_RD:
904                 /* err = camera_param_rd(cam, arg); */
905                 break;
906         case PCLLK_IOCTL_PWR_WR:
907                 /* This is a Guaranteed Level of Service (GLOS) call */
908                 mutex_lock(cam_desc.d_mutex);
909                 err = camera_dev_pwr_set(cam, arg);
910                 mutex_unlock(cam_desc.d_mutex);
911                 break;
912         case PCLLK_IOCTL_PWR_RD:
913                 mutex_lock(cam_desc.d_mutex);
914                 err = camera_dev_pwr_get(cam, arg);
915                 mutex_unlock(cam_desc.d_mutex);
916                 break;
917         case PCLLK_IOCTL_UPDATE:
918                 mutex_lock(cam_desc.d_mutex);
919                 err = camera_update(cam, arg);
920                 mutex_unlock(cam_desc.d_mutex);
921                 break;
922         case PCLLK_IOCTL_LAYOUT_WR:
923                 err = camera_layout_update(cam, arg);
924                 break;
925         case PCLLK_IOCTL_LAYOUT_RD:
926                 err = camera_layout_get(cam, arg);
927                 break;
928         case PCLLK_IOCTL_DRV_ADD:
929                 err = camera_add_drivers(cam, arg);
930                 break;
931         case PCLLK_IOCTL_DT_GET:
932                 err = of_camera_get_property(cam, arg);
933                 break;
934         case PCLLK_IOCTL_MSG:
935                 err = camera_msg(cam, arg);
936                 break;
937 #ifdef CONFIG_COMPAT
938         case PCLLK_IOCTL_32_CHIP_REG:
939                 err = virtual_device_add(cam_desc.dev, arg);
940                 break;
941         case PCLLK_IOCTL_32_SEQ_WR:
942                 mutex_lock(cam_desc.d_mutex);
943                 err = camera_seq_wr(cam, arg);
944                 mutex_unlock(cam_desc.d_mutex);
945                 break;
946         case PCLLK_IOCTL_32_SEQ_RD:
947                 mutex_lock(cam_desc.d_mutex);
948                 err = camera_seq_rd(cam, arg);
949                 mutex_unlock(cam_desc.d_mutex);
950                 break;
951         case PCLLK_IOCTL_32_PARAM_RD:
952                 /* err = camera_param_rd(cam, arg); */
953                 break;
954         case PCLLK_IOCTL_32_UPDATE:
955                 mutex_lock(cam_desc.d_mutex);
956                 err = camera_update(cam, arg);
957                 mutex_unlock(cam_desc.d_mutex);
958                 break;
959         case PCLLK_IOCTL_32_LAYOUT_WR:
960                 err = camera_layout_update(cam, arg);
961                 break;
962         case PCLLK_IOCTL_32_LAYOUT_RD:
963                 err = camera_layout_get(cam, arg);
964                 break;
965         case PCLLK_IOCTL_32_DRV_ADD:
966                 err = camera_add_drivers(cam, arg);
967                 break;
968         case PCLLK_IOCTL_32_DT_GET:
969                 err = of_camera_get_property(cam, arg);
970                 break;
971         case PCLLK_IOCTL_32_MSG:
972                 err = camera_msg(cam, arg);
973                 break;
974 #endif
975         default:
976                 dev_err(cam->dev, "%s unsupported ioctl: %x\n",
977                         __func__, cmd);
978                 err = -EINVAL;
979         }
980
981 ioctl_end:
982         camera_ref_down();
983         if (err)
984                 dev_dbg(cam->dev, "err = %d\n", err);
985
986         return err;
987 }
988
989 static int camera_open(struct inode *inode, struct file *file)
990 {
991         struct camera_info *cam;
992
993         if (camera_ref_raise())
994                 return -ENOTTY;
995
996         cam = kzalloc(sizeof(*cam), GFP_KERNEL);
997         if (!cam) {
998                 camera_ref_down();
999                 dev_err(cam_desc.dev,
1000                         "%s unable to allocate memory!\n", __func__);
1001                 return -ENOMEM;
1002         }
1003
1004         mutex_init(&cam->k_mutex);
1005         atomic_set(&cam->in_use, 0);
1006         INIT_LIST_HEAD(&cam->list);
1007         cam->dev = cam_desc.dev;
1008         file->private_data = cam;
1009
1010         mutex_lock(cam_desc.u_mutex);
1011         list_add(&cam->list, cam_desc.app_list);
1012         mutex_unlock(cam_desc.u_mutex);
1013
1014         camera_ref_down();
1015         dev_dbg(cam_desc.dev, "%s\n", __func__);
1016         return 0;
1017 }
1018
1019 static int camera_release(struct inode *inode, struct file *file)
1020 {
1021         struct camera_info *cam;
1022
1023         dev_dbg(cam_desc.dev, "%s\n", __func__);
1024
1025         if (camera_ref_raise())
1026                 return -ENOTTY;
1027
1028         cam = file->private_data;
1029         mutex_lock(cam_desc.u_mutex);
1030         list_del(&cam->list);
1031         mutex_unlock(cam_desc.u_mutex);
1032
1033         camera_app_remove(cam, true);
1034
1035         camera_ref_down();
1036         file->private_data = NULL;
1037         return 0;
1038 }
1039
1040 static const struct file_operations camera_fileops = {
1041         .owner = THIS_MODULE,
1042         .open = camera_open,
1043         .unlocked_ioctl = camera_ioctl,
1044 #ifdef CONFIG_COMPAT
1045         .compat_ioctl = camera_ioctl,
1046 #endif
1047         .release = camera_release,
1048 };
1049
1050 static int camera_remove(struct platform_device *dev)
1051 {
1052         struct camera_info *cam;
1053         struct camera_device *cdev;
1054
1055         dev_dbg(cam_desc.dev, "%s\n", __func__);
1056
1057         camera_ref_lock();
1058
1059         atomic_xchg(&cam_desc.in_use, 0);
1060         misc_deregister(&cam_desc.miscdev);
1061
1062         list_for_each_entry(cam, cam_desc.app_list, list) {
1063                 mutex_lock(cam_desc.u_mutex);
1064                 list_del(&cam->list);
1065                 mutex_unlock(cam_desc.u_mutex);
1066                 camera_app_remove(cam, false);
1067         }
1068
1069         list_for_each_entry(cdev, cam_desc.dev_list, list) {
1070                 mutex_lock(cam_desc.d_mutex);
1071                 list_del(&cdev->list);
1072                 mutex_unlock(cam_desc.d_mutex);
1073                 camera_remove_device(cdev, true);
1074         }
1075
1076 #ifdef TEGRA_12X_OR_HIGHER_CONFIG
1077         tegra_isp_unregister_mfi_cb();
1078 #endif
1079         camera_debugfs_remove();
1080
1081         kfree(cam_desc.layout);
1082         cam_desc.layout = NULL;
1083         cam_desc.size_layout = 0;
1084         if (cam_desc.pdata->freeable)
1085                 kfree(cam_desc.pdata);
1086         cam_desc.pdata = NULL;
1087         return 0;
1088 }
1089
1090 static int camera_probe(struct platform_device *dev)
1091 {
1092         struct camera_platform_data *pd;
1093
1094         dev_dbg(&dev->dev, "%s\n", __func__);
1095         if (atomic_xchg(&cam_desc.in_use, 1)) {
1096                 dev_err(&dev->dev, "%s OCCUPIED!\n", __func__);
1097                 return -EBUSY;
1098         }
1099
1100         camera_ref_lock();
1101         cam_desc.dev = &dev->dev;
1102         if (dev->dev.of_node) {
1103                 pd = of_camera_create_pdata(dev);
1104                 if (IS_ERR(pd))
1105                         return (int)pd;
1106                 cam_desc.pdata = pd;
1107         } else if (dev->dev.platform_data) {
1108                 cam_desc.pdata = dev->dev.platform_data;
1109         } else {
1110                 cam_desc.pdata = &camera_dflt_pdata;
1111                 dev_dbg(cam_desc.dev, "%s No platform data.  Using defaults.\n",
1112                         __func__);
1113         }
1114         dev_dbg(&dev->dev, "%x\n", cam_desc.pdata->cfg);
1115
1116         strcpy(cam_desc.dname, "camera.pcl");
1117         dev_set_drvdata(&dev->dev, &cam_desc);
1118
1119 #ifdef TEGRA_12X_OR_HIGHER_CONFIG
1120         camera_dev_sync_init();
1121         tegra_isp_register_mfi_cb(camera_dev_sync_cb, NULL);
1122 #endif
1123         of_camera_init(&cam_desc);
1124
1125         cam_desc.miscdev.name = cam_desc.dname;
1126         cam_desc.miscdev.fops = &camera_fileops;
1127         cam_desc.miscdev.minor = MISC_DYNAMIC_MINOR;
1128         if (misc_register(&cam_desc.miscdev)) {
1129                 dev_err(cam_desc.dev, "%s unable to register misc device %s\n",
1130                         __func__, cam_desc.dname);
1131                 return -ENODEV;
1132         }
1133
1134         camera_debugfs_init(&cam_desc);
1135         camera_ref_init();
1136         return 0;
1137 }
1138
1139 static void camera_shutdown(struct platform_device *dev)
1140 {
1141         dev_dbg(&dev->dev, "%s ...\n", __func__);
1142
1143         camera_ref_lock();
1144         atomic_xchg(&cam_desc.in_use, 0);
1145         dev_info(&dev->dev, "%s locked.\n", __func__);
1146 }
1147
1148 static const struct platform_device_id camera_id[] = {
1149         { "pcl-generic", 0 },
1150         { },
1151 };
1152
1153 MODULE_DEVICE_TABLE(i2c, camera_id);
1154
1155 static struct platform_driver camera_driver = {
1156         .driver = {
1157                 .name = "pcl-generic",
1158                 .owner = THIS_MODULE,
1159         },
1160         .id_table = camera_id,
1161         .probe = camera_probe,
1162         .remove = camera_remove,
1163         .shutdown = camera_shutdown,
1164 };
1165
1166 module_platform_driver(camera_driver);
1167
1168 MODULE_DESCRIPTION("Generic Camera Device Driver");
1169 MODULE_AUTHOR("Charlie Huang <chahuang@nvidia.com>");
1170 MODULE_LICENSE("GPL v2");