arm: dts: Remove support for IMX208 sensor
[linux-3.10.git] / drivers / media / platform / tegra / imx208.c
1 /*
2  * imx208.c - imx208 sensor driver
3  *
4  * Copyright (c) 2014-2015, NVIDIA CORPORATION, All Rights Reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/delay.h>
20 #include <linux/fs.h>
21 #include <linux/i2c.h>
22 #include <linux/clk.h>
23 #include <linux/miscdevice.h>
24 #include <linux/slab.h>
25 #include <linux/uaccess.h>
26 #include <linux/regulator/consumer.h>
27 #include <linux/regmap.h>
28 #include <media/imx208.h>
29 #include <linux/gpio.h>
30 #include <linux/module.h>
31
32 #include <linux/kernel.h>
33 #include <linux/seq_file.h>
34 #include <linux/of.h>
35 #include <linux/of_device.h>
36 #include <linux/of_gpio.h>
37
38 #include "nvc_utilities.h"
39
40 struct imx208_reg {
41         u16 addr;
42         u8 val;
43 };
44
45 struct imx208_info {
46         struct miscdevice               miscdev_info;
47         int                             mode;
48         struct imx208_power_rail        power;
49         struct imx208_sensordata        sensor_data;
50         struct i2c_client               *i2c_client;
51         struct imx208_platform_data     *pdata;
52         struct clk                      *mclk;
53         struct regmap                   *regmap;
54         struct mutex                    imx208_camera_lock;
55         atomic_t                        in_use;
56 };
57
58 static const struct regmap_config sensor_regmap_config = {
59         .reg_bits = 16,
60         .val_bits = 8,
61         .cache_type = REGCACHE_RBTREE,
62 };
63
64 #define IMX208_TABLE_WAIT_MS 0
65 #define IMX208_TABLE_END 1
66 #define IMX208_MAX_RETRIES 3
67 #define IMX208_WAIT_MS 3
68
69 #define MAX_BUFFER_SIZE 32
70 #define IMX208_FRAME_LENGTH_ADDR_MSB 0x0340
71 #define IMX208_FRAME_LENGTH_ADDR_LSB 0x0341
72 #define IMX208_COARSE_TIME_ADDR_MSB 0x0202
73 #define IMX208_COARSE_TIME_ADDR_LSB 0x0203
74 #define IMX208_GAIN_ADDR 0x0205
75
76 static struct imx208_reg mode_1920x1080[] = {
77         /* PLL Setting */
78         {0x0305, 0x04},
79         {0x0307, 0x87},
80         {0x303C, 0x4B},
81         {0x30A4, 0x02},
82         /* Mode setting */
83         {0x0112, 0x0A},
84         {0x0113, 0x0A},
85         {0x0340, 0x04},
86         {0x0341, 0xB0},
87         {0x0342, 0x08},
88         {0x0343, 0xC8},
89         {0x0344, 0x00},
90         {0x0345, 0x08},
91         {0x0346, 0x00},
92         {0x0347, 0x08},
93         {0x0348, 0x07},
94         {0x0349, 0x87},
95         {0x034A, 0x04},
96         {0x034B, 0x3F},
97         {0x034C, 0x07},
98         {0x034D, 0x80},
99         {0x034E, 0x04},
100         {0x034F, 0x38},
101         {0x0381, 0x01},
102         {0x0383, 0x01},
103         {0x0385, 0x01},
104         {0x0387, 0x01},
105         {0x3048, 0x00},
106         {0x304E, 0x0A},
107         {0x3050, 0x02},
108         {0x309B, 0x00},
109         {0x30D5, 0x00},
110         {0x3301, 0x01},
111         {0x3318, 0x61},
112         /* Shutter Gain Setting */
113         {0x0202, 0x01},
114         {0x0203, 0x90},
115         {0x0205, 0x00},
116         {0x0100, 0x01},
117         {IMX208_TABLE_WAIT_MS, IMX208_WAIT_MS},
118         {IMX208_TABLE_END, 0x00}
119 };
120
121 enum {
122         IMX208_MODE_1920X1080,
123 };
124
125 static struct imx208_reg *mode_table[] = {
126         [IMX208_MODE_1920X1080] = mode_1920x1080,
127 };
128
129 static inline void
130 msleep_range(unsigned int delay_base)
131 {
132         usleep_range(delay_base*1000, delay_base*1000+500);
133 }
134
135 static inline void
136 imx208_get_frame_length_regs(struct imx208_reg *regs, u32 frame_length)
137 {
138         regs->addr = IMX208_FRAME_LENGTH_ADDR_MSB;
139         regs->val = (frame_length >> 8) & 0xff;
140         (regs + 1)->addr = IMX208_FRAME_LENGTH_ADDR_LSB;
141         (regs + 1)->val = (frame_length) & 0xff;
142 }
143
144 static inline void
145 imx208_get_coarse_time_regs(struct imx208_reg *regs, u32 coarse_time)
146 {
147         regs->addr = IMX208_COARSE_TIME_ADDR_MSB;
148         regs->val = (coarse_time >> 8) & 0xff;
149         (regs + 1)->addr = IMX208_COARSE_TIME_ADDR_LSB;
150         (regs + 1)->val = (coarse_time) & 0xff;
151 }
152
153 static inline void
154 imx208_get_gain_reg(struct imx208_reg *regs, u16 gain)
155 {
156         regs->addr = IMX208_GAIN_ADDR;
157         regs->val = gain;
158 }
159
160 static inline int
161 imx208_read_reg(struct imx208_info *info, u16 addr, u8 *val)
162 {
163         return regmap_read(info->regmap, addr, (unsigned int *) val);
164 }
165
166 static int
167 imx208_write_reg(struct imx208_info *info, u16 addr, u8 val)
168 {
169         int err;
170
171         err = regmap_write(info->regmap, addr, val);
172
173         if (err)
174                 pr_err("%s:i2c write failed, %x = %x\n",
175                         __func__, addr, val);
176
177         return err;
178 }
179
180 static int
181 imx208_write_table(struct imx208_info *info,
182                                  const struct imx208_reg table[],
183                                  const struct imx208_reg override_list[],
184                                  int num_override_regs)
185 {
186         int err;
187         const struct imx208_reg *next;
188         int i;
189         u16 val;
190
191         for (next = table; next->addr != IMX208_TABLE_END; next++) {
192                 if (next->addr == IMX208_TABLE_WAIT_MS) {
193                         msleep_range(next->val);
194                         continue;
195                 }
196
197                 val = next->val;
198
199                 /* When an override list is passed in, replace the reg */
200                 /* value to write if the reg is in the list            */
201                 if (override_list) {
202                         for (i = 0; i < num_override_regs; i++) {
203                                 if (next->addr == override_list[i].addr) {
204                                         val = override_list[i].val;
205                                         break;
206                                 }
207                         }
208                 }
209
210                 err = imx208_write_reg(info, next->addr, val);
211                 if (err) {
212                         pr_err("%s:imx208_write_table:%d", __func__, err);
213                         return err;
214                 }
215         }
216         return 0;
217 }
218
219 static int imx208_get_flash_cap(struct imx208_info *info)
220 {
221         struct imx208_flash_control *fctl;
222
223         dev_dbg(&info->i2c_client->dev, "%s: %p\n", __func__, info->pdata);
224         if (info->pdata) {
225                 fctl = &info->pdata->flash_cap;
226                 dev_dbg(&info->i2c_client->dev,
227                         "edg: %x, st: %x, rpt: %x, dl: %x\n",
228                         fctl->edge_trig_en,
229                         fctl->start_edge,
230                         fctl->repeat,
231                         fctl->delay_frm);
232
233                 if (fctl->enable)
234                         return 0;
235         }
236         return -ENODEV;
237 }
238
239 static inline int imx208_set_flash_control(
240         struct imx208_info *info, struct imx208_flash_control *fc)
241 {
242         dev_dbg(&info->i2c_client->dev, "%s\n", __func__);
243         return imx208_write_reg(info, 0x0802, 0x01);
244 }
245
246 static int
247 imx208_set_mode(struct imx208_info *info, struct imx208_mode *mode)
248 {
249         int sensor_mode;
250         int err;
251         struct imx208_reg reg_list[8];
252
253         pr_info("%s: xres %u yres %u framelength %u coarsetime %u gain %u\n",
254                          __func__, mode->xres, mode->yres, mode->frame_length,
255                          mode->coarse_time, mode->gain);
256
257         if (mode->xres == 1920 && mode->yres == 1080) {
258                 sensor_mode = IMX208_MODE_1920X1080;
259         } else {
260                 pr_err("%s: invalid resolution supplied to set mode %d %d\n",
261                          __func__, mode->xres, mode->yres);
262                 return -EINVAL;
263         }
264
265         /* get a list of override regs for the asking frame length, */
266         /* coarse integration time, and gain.                       */
267         imx208_get_frame_length_regs(reg_list, mode->frame_length);
268         imx208_get_coarse_time_regs(reg_list + 2, mode->coarse_time);
269         imx208_get_gain_reg(reg_list + 4, mode->gain);
270
271         err = imx208_write_table(info,
272                                 mode_table[sensor_mode],
273                                 reg_list, 5);
274         if (err)
275                 return err;
276         info->mode = sensor_mode;
277         pr_info("[IMX208]: stream on.\n");
278         return 0;
279 }
280
281 static int
282 imx208_get_status(struct imx208_info *info, u8 *dev_status)
283 {
284         *dev_status = 0;
285         return 0;
286 }
287
288 static int
289 imx208_set_frame_length(struct imx208_info *info, u32 frame_length,
290                                                  bool group_hold)
291 {
292         struct imx208_reg reg_list[2];
293         int i = 0;
294         int ret;
295
296         imx208_get_frame_length_regs(reg_list, frame_length);
297
298         if (group_hold) {
299                 ret = imx208_write_reg(info, 0x0104, 0x01);
300                 if (ret)
301                         return ret;
302         }
303
304         for (i = 0; i < 2; i++) {
305                 ret = imx208_write_reg(info, reg_list[i].addr,
306                          reg_list[i].val);
307                 if (ret)
308                         return ret;
309         }
310
311         if (group_hold) {
312                 ret = imx208_write_reg(info, 0x0104, 0x0);
313                 if (ret)
314                         return ret;
315         }
316
317         return 0;
318 }
319
320 static int
321 imx208_set_coarse_time(struct imx208_info *info, u32 coarse_time,
322                                                  bool group_hold)
323 {
324         int ret;
325
326         struct imx208_reg reg_list[2];
327         int i = 0;
328
329         imx208_get_coarse_time_regs(reg_list, coarse_time);
330
331         if (group_hold) {
332                 ret = imx208_write_reg(info, 0x104, 0x01);
333                 if (ret)
334                         return ret;
335         }
336
337         for (i = 0; i < 2; i++) {
338                 ret = imx208_write_reg(info, reg_list[i].addr,
339                          reg_list[i].val);
340                 if (ret)
341                         return ret;
342         }
343
344         if (group_hold) {
345                 ret = imx208_write_reg(info, 0x104, 0x0);
346                 if (ret)
347                         return ret;
348         }
349         return 0;
350 }
351
352 static int
353 imx208_set_gain(struct imx208_info *info, u16 gain, bool group_hold)
354 {
355         int ret;
356         struct imx208_reg reg_list;
357
358         imx208_get_gain_reg(&reg_list, gain);
359
360         if (group_hold) {
361                 ret = imx208_write_reg(info, 0x104, 0x1);
362                 if (ret)
363                         return ret;
364         }
365
366         ret = imx208_write_reg(info, reg_list.addr, reg_list.val);
367         if (ret)
368                 return ret;
369
370         if (group_hold) {
371                 ret = imx208_write_reg(info, 0x104, 0x0);
372                 if (ret)
373                         return ret;
374         }
375         return 0;
376 }
377
378 static int
379 imx208_set_group_hold(struct imx208_info *info, struct imx208_ae *ae)
380 {
381         int ret;
382         int count = 0;
383         bool group_hold_enabled = false;
384
385         if (ae->gain_enable)
386                 count++;
387         if (ae->coarse_time_enable)
388                 count++;
389         if (ae->frame_length_enable)
390                 count++;
391         if (count >= 2)
392                 group_hold_enabled = true;
393
394         if (group_hold_enabled) {
395                 ret = imx208_write_reg(info, 0x104, 0x1);
396                 if (ret)
397                         return ret;
398         }
399
400         if (ae->gain_enable)
401                 imx208_set_gain(info, ae->gain, false);
402         if (ae->coarse_time_enable)
403                 imx208_set_coarse_time(info, ae->coarse_time, true);
404         if (ae->frame_length_enable)
405                 imx208_set_frame_length(info, ae->frame_length, false);
406
407         if (group_hold_enabled) {
408                 ret = imx208_write_reg(info, 0x104, 0x0);
409                 if (ret)
410                         return ret;
411         }
412
413         return 0;
414 }
415
416 static int imx208_get_sensor_id(struct imx208_info *info)
417 {
418         int ret = 0;
419
420         pr_info("%s\n", __func__);
421         if (info->sensor_data.fuse_id_size)
422                 return 0;
423
424         /* Note 1: If the sensor does not have power at this point
425         Need to supply the power, e.g. by calling power on function */
426
427         /*ret |= imx208_write_reg(info, 0x3B02, 0x00);
428         ret |= imx208_write_reg(info, 0x3B00, 0x01);
429         for (i = 0; i < 9; i++) {
430                 ret |= imx208_read_reg(info, 0x3B24 + i, &bak);
431                 info->sensor_data.fuse_id[i] = bak;
432         }
433
434         if (!ret)
435                 info->sensor_data.fuse_id_size = i;*/
436
437         /* Note 2: Need to clean up any action carried out in Note 1 */
438
439         return ret;
440 }
441
442 static void imx208_mclk_disable(struct imx208_info *info)
443 {
444         dev_dbg(&info->i2c_client->dev, "%s: disable MCLK\n", __func__);
445         clk_disable_unprepare(info->mclk);
446 }
447
448 static int imx208_mclk_enable(struct imx208_info *info)
449 {
450         int err;
451         unsigned long mclk_init_rate = 24000000;
452
453         dev_dbg(&info->i2c_client->dev, "%s: enable MCLK with %lu Hz\n",
454                 __func__, mclk_init_rate);
455
456         err = clk_set_rate(info->mclk, mclk_init_rate);
457         if (!err)
458                 err = clk_prepare_enable(info->mclk);
459         return err;
460 }
461
462 static long
463 imx208_ioctl(struct file *file,
464                          unsigned int cmd, unsigned long arg)
465 {
466         int err = 0;
467         struct imx208_info *info = file->private_data;
468
469         switch (cmd) {
470         case IMX208_IOCTL_SET_POWER:
471                 if (!info->pdata)
472                         break;
473                 if (arg && info->pdata->power_on) {
474                         err = imx208_mclk_enable(info);
475                         if (!err)
476                                 err = info->pdata->power_on(&info->power);
477                         if (err < 0)
478                                 imx208_mclk_disable(info);
479                 }
480                 if (!arg && info->pdata->power_off) {
481                         info->pdata->power_off(&info->power);
482                         imx208_mclk_disable(info);
483                 }
484                 break;
485         case IMX208_IOCTL_SET_MODE:
486         {
487                 struct imx208_mode mode;
488                 if (copy_from_user(&mode, (const void __user *)arg,
489                         sizeof(struct imx208_mode))) {
490                         pr_err("%s:Failed to get mode from user.\n", __func__);
491                         return -EFAULT;
492                 }
493                 return imx208_set_mode(info, &mode);
494         }
495         case IMX208_IOCTL_SET_FRAME_LENGTH:
496                 return imx208_set_frame_length(info, (u32)arg, true);
497         case IMX208_IOCTL_SET_COARSE_TIME:
498                 return imx208_set_coarse_time(info, (u32)arg, true);
499         case IMX208_IOCTL_SET_GAIN:
500                 return imx208_set_gain(info, (u16)arg, true);
501         case IMX208_IOCTL_GET_STATUS:
502         {
503                 u8 status;
504
505                 err = imx208_get_status(info, &status);
506                 if (err)
507                         return err;
508                 if (copy_to_user((void __user *)arg, &status, 1)) {
509                         pr_err("%s:Failed to copy status to user\n", __func__);
510                         return -EFAULT;
511                 }
512                 return 0;
513         }
514         case IMX208_IOCTL_GET_SENSORDATA:
515         {
516                 err = imx208_get_sensor_id(info);
517
518                 if (err) {
519                         pr_err("%s:Failed to get fuse id info.\n", __func__);
520                         return err;
521                 }
522                 if (copy_to_user((void __user *)arg, &info->sensor_data,
523                                 sizeof(struct imx208_sensordata))) {
524                         pr_info("%s:Failed to copy fuse id to user space\n",
525                                 __func__);
526                         return -EFAULT;
527                 }
528                 return 0;
529         }
530         case IMX208_IOCTL_SET_GROUP_HOLD:
531         {
532                 struct imx208_ae ae;
533                 if (copy_from_user(&ae, (const void __user *)arg,
534                         sizeof(struct imx208_ae))) {
535                         pr_info("%s:fail group hold\n", __func__);
536                         return -EFAULT;
537                 }
538                 return imx208_set_group_hold(info, &ae);
539         }
540         case IMX208_IOCTL_SET_FLASH_MODE:
541         {
542                 struct imx208_flash_control values;
543
544                 dev_dbg(&info->i2c_client->dev,
545                         "IMX208_IOCTL_SET_FLASH_MODE\n");
546                 if (copy_from_user(&values,
547                         (const void __user *)arg,
548                         sizeof(struct imx208_flash_control))) {
549                         err = -EFAULT;
550                         break;
551                 }
552                 err = imx208_set_flash_control(info, &values);
553                 break;
554         }
555         case IMX208_IOCTL_GET_FLASH_CAP:
556                 err = imx208_get_flash_cap(info);
557                 break;
558         default:
559                 pr_err("%s:unknown cmd.\n", __func__);
560                 err = -EINVAL;
561         }
562
563         return err;
564 }
565
566 static int imx208_power_on(struct imx208_power_rail *pw)
567 {
568         int err;
569         struct imx208_info *info = container_of(pw, struct imx208_info, power);
570
571         if (unlikely(WARN_ON(!pw || !pw->iovdd || !pw->avdd || !pw->dvdd)))
572                 return -EFAULT;
573
574         gpio_set_value(info->pdata->cam2_gpio, 0);
575         usleep_range(10, 20);
576
577         err = regulator_enable(pw->avdd);
578         if (err)
579                 goto imx208_avdd_fail;
580
581         err = regulator_enable(pw->dvdd);
582         if (err)
583                 goto imx208_dvdd_fail;
584
585         err = regulator_enable(pw->iovdd);
586         if (err)
587                 goto imx208_iovdd_fail;
588
589         usleep_range(1, 2);
590         gpio_set_value(info->pdata->cam2_gpio, 1);
591
592         usleep_range(300, 310);
593
594         return 1;
595
596
597 imx208_iovdd_fail:
598         regulator_disable(pw->dvdd);
599
600 imx208_dvdd_fail:
601         regulator_disable(pw->avdd);
602
603 imx208_avdd_fail:
604         pr_err("%s failed.\n", __func__);
605         return -ENODEV;
606 }
607
608 static int imx208_power_off(struct imx208_power_rail *pw)
609 {
610         struct imx208_info *info = container_of(pw, struct imx208_info, power);
611
612         if (unlikely(WARN_ON(!pw || !pw->iovdd || !pw->avdd || !pw->dvdd)))
613                 return -EFAULT;
614
615         usleep_range(1, 2);
616         gpio_set_value(info->pdata->cam2_gpio, 0);
617         usleep_range(1, 2);
618
619         regulator_disable(pw->iovdd);
620         regulator_disable(pw->dvdd);
621         regulator_disable(pw->avdd);
622
623         return 0;
624 }
625
626 static int
627 imx208_open(struct inode *inode, struct file *file)
628 {
629         struct miscdevice       *miscdev = file->private_data;
630         struct imx208_info *info;
631
632         info = container_of(miscdev, struct imx208_info, miscdev_info);
633         /* check if the device is in use */
634         if (atomic_xchg(&info->in_use, 1)) {
635                 pr_info("%s:BUSY!\n", __func__);
636                 return -EBUSY;
637         }
638
639         file->private_data = info;
640
641         return 0;
642 }
643
644 static int
645 imx208_release(struct inode *inode, struct file *file)
646 {
647         struct imx208_info *info = file->private_data;
648
649         file->private_data = NULL;
650
651         /* warn if device is already released */
652         WARN_ON(!atomic_xchg(&info->in_use, 0));
653         return 0;
654 }
655
656 static int imx208_power_put(struct imx208_power_rail *pw)
657 {
658         if (unlikely(!pw))
659                 return -EFAULT;
660
661         if (likely(pw->avdd))
662                 regulator_put(pw->avdd);
663
664         if (likely(pw->iovdd))
665                 regulator_put(pw->iovdd);
666
667         if (likely(pw->dvdd))
668                 regulator_put(pw->dvdd);
669
670         pw->avdd = NULL;
671         pw->iovdd = NULL;
672         pw->dvdd = NULL;
673
674         return 0;
675 }
676
677 static int imx208_regulator_get(struct imx208_info *info,
678         struct regulator **vreg, char vreg_name[])
679 {
680         struct regulator *reg = NULL;
681         int err = 0;
682
683         reg = regulator_get(&info->i2c_client->dev, vreg_name);
684         if (unlikely(IS_ERR(reg))) {
685                 dev_err(&info->i2c_client->dev, "%s %s ERR: %d\n",
686                         __func__, vreg_name, (int)reg);
687                 err = PTR_ERR(reg);
688                 reg = NULL;
689         } else
690                 dev_dbg(&info->i2c_client->dev, "%s: %s\n",
691                         __func__, vreg_name);
692
693         *vreg = reg;
694         return err;
695 }
696
697 static int imx208_power_get(struct imx208_info *info)
698 {
699         struct imx208_power_rail *pw = &info->power;
700         int err = 0;
701
702         err |= imx208_regulator_get(info, &pw->avdd, "vana"); /* ananlog 2.7v */
703         err |= imx208_regulator_get(info, &pw->dvdd, "vdig"); /* digital 1.2v */
704         err |= imx208_regulator_get(info, &pw->iovdd, "vif"); /* IO 1.8v */
705
706         return err;
707 }
708
709 static const struct file_operations imx208_fileops = {
710         .owner = THIS_MODULE,
711         .open = imx208_open,
712         .unlocked_ioctl = imx208_ioctl,
713         .release = imx208_release,
714 };
715
716 static struct miscdevice imx208_device = {
717         .minor = MISC_DYNAMIC_MINOR,
718         .name = "imx208",
719         .fops = &imx208_fileops,
720 };
721
722 static struct of_device_id imx208_of_match[] = {
723         { .compatible = "nvidia,imx208", },
724         { },
725 };
726
727 MODULE_DEVICE_TABLE(of, imx208_of_match);
728
729 static struct imx208_platform_data *imx208_parse_dt(struct i2c_client *client)
730 {
731         struct device_node *np = client->dev.of_node;
732         struct imx208_platform_data *board_info_pdata;
733         const struct of_device_id *match;
734
735         match = of_match_device(imx208_of_match, &client->dev);
736         if (!match) {
737                 dev_err(&client->dev, "Failed to find matching dt id\n");
738                 return NULL;
739         }
740
741         board_info_pdata = devm_kzalloc(&client->dev, sizeof(*board_info_pdata),
742                         GFP_KERNEL);
743         if (!board_info_pdata) {
744                 dev_err(&client->dev, "Failed to allocate pdata\n");
745                 return NULL;
746         }
747
748         board_info_pdata->cam2_gpio = of_get_named_gpio(np, "cam1-gpios", 0);
749         board_info_pdata->ext_reg = of_property_read_bool(np, "nvidia,ext_reg");
750
751         board_info_pdata->power_on = imx208_power_on;
752         board_info_pdata->power_off = imx208_power_off;
753
754         return board_info_pdata;
755 }
756
757 static int
758 imx208_probe(struct i2c_client *client,
759                         const struct i2c_device_id *id)
760 {
761         struct imx208_info *info;
762         int err;
763         const char *mclk_name;
764
765         pr_err("[IMX208]: probing sensor.\n");
766
767         info = devm_kzalloc(&client->dev,
768                         sizeof(struct imx208_info), GFP_KERNEL);
769         if (!info) {
770                 pr_err("%s:Unable to allocate memory!\n", __func__);
771                 return -ENOMEM;
772         }
773
774         info->regmap = devm_regmap_init_i2c(client, &sensor_regmap_config);
775         if (IS_ERR(info->regmap)) {
776                 dev_err(&client->dev,
777                         "regmap init failed: %ld\n", PTR_ERR(info->regmap));
778                 return -ENODEV;
779         }
780
781         if (client->dev.of_node)
782                 info->pdata = imx208_parse_dt(client);
783         else
784                 info->pdata = client->dev.platform_data;
785
786         if (!info->pdata) {
787                 pr_err("[IMX208]:%s:Unable to get platform data\n", __func__);
788                 return -EFAULT;
789         }
790
791         info->i2c_client = client;
792         atomic_set(&info->in_use, 0);
793         info->mode = -1;
794
795         mclk_name = info->pdata->mclk_name ?
796                     info->pdata->mclk_name : "default_mclk";
797         info->mclk = devm_clk_get(&client->dev, mclk_name);
798         if (IS_ERR(info->mclk)) {
799                 dev_err(&client->dev, "%s: unable to get clock %s\n",
800                         __func__, mclk_name);
801                 return PTR_ERR(info->mclk);
802         }
803
804         imx208_power_get(info);
805
806         memcpy(&info->miscdev_info,
807                 &imx208_device,
808                 sizeof(struct miscdevice));
809
810         err = misc_register(&info->miscdev_info);
811         if (err) {
812                 pr_err("%s:Unable to register misc device!\n", __func__);
813                 goto imx208_probe_fail;
814         }
815
816         i2c_set_clientdata(client, info);
817
818         mutex_init(&info->imx208_camera_lock);
819         pr_err("[IMX208]: end of probing sensor.\n");
820         return 0;
821
822 imx208_probe_fail:
823         imx208_power_put(&info->power);
824
825         return err;
826 }
827
828 static int
829 imx208_remove(struct i2c_client *client)
830 {
831         struct imx208_info *info;
832         info = i2c_get_clientdata(client);
833         misc_deregister(&imx208_device);
834         mutex_destroy(&info->imx208_camera_lock);
835
836         imx208_power_put(&info->power);
837
838         return 0;
839 }
840
841 static const struct i2c_device_id imx208_id[] = {
842         { "imx208", 0 },
843         { }
844 };
845
846 MODULE_DEVICE_TABLE(i2c, imx208_id);
847
848 static struct i2c_driver imx208_i2c_driver = {
849         .driver = {
850                 .name = "imx208",
851                 .owner = THIS_MODULE,
852         },
853         .probe = imx208_probe,
854         .remove = imx208_remove,
855         .id_table = imx208_id,
856 };
857
858 static int __init imx208_init(void)
859 {
860         pr_info("[IMX208] sensor driver loading\n");
861         return i2c_add_driver(&imx208_i2c_driver);
862 }
863
864 static void __exit imx208_exit(void)
865 {
866         i2c_del_driver(&imx208_i2c_driver);
867 }
868
869 module_init(imx208_init);
870 module_exit(imx208_exit);