ed113b3a187c010cc05297036f85fa2fb45589a1
[linux-2.6.git] / drivers / media / video / tegra / ad5816.c
1 /* Copyright (C) 2011-2012 NVIDIA Corporation.
2  *
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License version 2 as
5  * published by the Free Software Foundation.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
15  * 02111-1307, USA
16  */
17 /* This is a NVC kernel driver for a focuser device called
18  * ad5816.
19  */
20 /* Implementation
21  * --------------
22  * The board level details about the device need to be provided in the board
23  * file with the <device>_platform_data structure.
24  * Standard among NVC kernel drivers in this structure is:
25  * .cfg = Use the NVC_CFG_ defines that are in nvc.h.
26  *  Descriptions of the configuration options are with the defines.
27  *      This value is typically 0.
28  * .num = The number of the instance of the device.  This should start at 1 and
29  *      and increment for each device on the board.  This number will be
30  *      appended to the MISC driver name, Example: /dev/focuser.1
31  *      If not used or 0, then nothing is appended to the name.
32  * .sync = If there is a need to synchronize two devices, then this value is
33  *       the number of the device instance (.num above) this device is to
34  *       sync to.  For example:
35  *       Device 1 platform entries =
36  *       .num = 1,
37  *       .sync = 2,
38  *       Device 2 platfrom entries =
39  *       .num = 2,
40  *       .sync = 1,
41  *       The above example sync's device 1 and 2.
42  *       To disable sync, set .sync = 0.  Note that the .num = 0 device is not
43  *       allowed to be synced to.
44  *       This is typically used for stereo applications.
45  * .dev_name = The MISC driver name the device registers as.  If not used,
46  *       then the part number of the device is used for the driver name.
47  *       If using the NVC user driver then use the name found in this
48  *       driver under _default_pdata.
49  * .gpio_count = The ARRAY_SIZE of the nvc_gpio_pdata table.
50  * .gpio = A pointer to the nvc_gpio_pdata structure's platform GPIO data.
51  *       The GPIO mechanism works by cross referencing the .gpio_type key
52  *       among the nvc_gpio_pdata GPIO data and the driver's nvc_gpio_init
53  *       GPIO data to build a GPIO table the driver can use.  The GPIO's
54  *       defined in the device header file's _gpio_type enum are the
55  *       gpio_type keys for the nvc_gpio_pdata and nvc_gpio_init structures.
56  *       These need to be present in the board file's nvc_gpio_pdata
57  *       structure for the GPIO's that are used.
58  *       The driver's GPIO logic uses assert/deassert throughout until the
59  *       low level _gpio_wr/rd calls where the .assert_high is used to
60  *       convert the value to the correct signal level.
61  *       See the GPIO notes in nvc.h for additional information.
62  *
63  * The following is specific to NVC kernel focus drivers:
64  * .nvc = Pointer to the nvc_focus_nvc structure.  This structure needs to
65  *      be defined and populated if overriding the driver defaults.
66  * .cap = Pointer to the nvc_focus_cap structure.  This structure needs to
67  *      be defined and populated if overriding the driver defaults.
68  *
69  * The following is specific to this NVC kernel focus driver:
70  * .info = Pointer to the ad5816_pdata_info structure.  This structure does
71  *       not need to be defined and populated unless overriding ROM data.
72  *
73  * Power Requirements:
74  * The device's header file defines the voltage regulators needed with the
75  * enumeration <device>_vreg.  The order these are enumerated is the order
76  * the regulators will be enabled when powering on the device.  When the
77  * device is powered off the regulators are disabled in descending order.
78  * The <device>_vregs table in this driver uses the nvc_regulator_init
79  * structure to define the regulator ID strings that go with the regulators
80  * defined with <device>_vreg.  These regulator ID strings (or supply names)
81  * will be used in the regulator_get function in the _vreg_init function.
82  * The board power file and <device>_vregs regulator ID strings must match.
83  */
84
85 #include <linux/fs.h>
86 #include <linux/i2c.h>
87 #include <linux/miscdevice.h>
88 #include <linux/slab.h>
89 #include <linux/delay.h>
90 #include <linux/uaccess.h>
91 #include <linux/list.h>
92 #include <linux/regulator/consumer.h>
93 #include <linux/gpio.h>
94 #include <media/ad5816.h>
95
96 #define AD5816_ID                               0x04
97 #define AD5816_FOCAL_LENGTH      (4.570f)
98 #define AD5816_FNUMBER                  (2.8f)
99 #define AD5816_ACTUATOR_RANGE   680
100 #define AD5816_SETTLETIME               110
101 #define AD5816_FOCUS_MACRO              810
102 #define AD5816_FOCUS_INFINITY   50 /* Exact value needs to be decided */
103 #define AD5816_POS_LOW_DEFAULT  220
104 #define AD5816_POS_HIGH_DEFAULT 900
105 /* Need to decide exact value of VCM_THRESHOLD and its use */
106 /* define AD5816_VCM_THRESHOLD  20 */
107
108 static u8 ad5816_ids[] = {
109         0x04,
110 };
111
112 static struct nvc_gpio_init ad5816_gpios[] = {
113         { AD5816_GPIO_RESET, GPIOF_OUT_INIT_LOW, "reset", false, true, },
114         { AD5816_GPIO_I2CMUX, 0, "i2c_mux", 0, false},
115         { AD5816_GPIO_GP1, 0, "gp1", 0, false},
116         { AD5816_GPIO_GP2, 0, "gp2", 0, false},
117         { AD5816_GPIO_GP3, 0, "gp3", 0, false},
118 };
119
120 static struct nvc_regulator_init ad5816_vregs[] = {
121         { AD5816_VREG_VDD, "vdd"},
122         { AD5816_VREG_VDD_AF, "vdd_af"},
123         { AD5816_VREG_VDD_I2C, "vdd_i2c"},
124 };
125
126 struct ad5816_info {
127         atomic_t in_use;
128         struct i2c_client *i2c_client;
129         struct ad5816_platform_data *pdata;
130         struct miscdevice miscdev;
131         struct list_head list;
132         struct nvc_gpio gpio[ARRAY_SIZE(ad5816_gpios)];
133         struct nvc_regulator vreg[ARRAY_SIZE(ad5816_vregs)];
134         int pwr_api;
135         int pwr_dev;
136         int id_minor;
137         u32 pos;
138         u8 s_mode;
139         bool reset_flag;
140         struct ad5816_info *s_info;
141         struct nvc_focus_nvc nvc;
142         struct nvc_focus_cap cap;
143         struct ad5816_pdata_info config;
144 };
145
146 /**
147  * The following are default values
148  */
149
150 static struct ad5816_pdata_info ad5816_default_info = {
151         .pos_low = AD5816_POS_LOW_DEFAULT,
152         .pos_high = AD5816_POS_HIGH_DEFAULT,
153 };
154
155 static struct nvc_focus_cap ad5816_default_cap = {
156         .version = NVC_FOCUS_CAP_VER2,
157         .actuator_range = AD5816_ACTUATOR_RANGE,
158         .settle_time = AD5816_SETTLETIME,
159         .focus_macro = AD5816_FOCUS_MACRO,
160         .focus_infinity = AD5816_FOCUS_INFINITY,
161 };
162
163 static struct nvc_focus_nvc ad5816_default_nvc = {
164         .focal_length = AD5816_FOCAL_LENGTH,
165         .fnumber = AD5816_FNUMBER,
166 };
167
168 static struct ad5816_platform_data ad5816_default_pdata = {
169         .cfg = 0,
170         .num = 0,
171         .sync = 0,
172         .dev_name = "focuser",
173 };
174 static LIST_HEAD(ad5816_info_list);
175 static DEFINE_SPINLOCK(ad5816_spinlock);
176
177 static int ad5816_i2c_rd8(struct ad5816_info *info, u8 addr, u8 reg, u8 *val)
178 {
179         struct i2c_msg msg[2];
180         u8 buf[2];
181         buf[0] = reg;
182         if (addr) {
183                 msg[0].addr = addr;
184                 msg[1].addr = addr;
185         } else {
186                 msg[0].addr = info->i2c_client->addr;
187                 msg[1].addr = info->i2c_client->addr;
188         }
189         msg[0].flags = 0;
190         msg[0].len = 1;
191         msg[0].buf = &buf[0];
192         msg[1].flags = I2C_M_RD;
193         msg[1].len = 1;
194         msg[1].buf = &buf[1];
195         *val = 0;
196         if (i2c_transfer(info->i2c_client->adapter, msg, 2) != 2)
197                 return -EIO;
198         *val = buf[1];
199         return 0;
200 }
201
202 static int ad5816_i2c_wr8(struct ad5816_info *info, u8 reg, u8 val)
203 {
204         struct i2c_msg msg;
205         u8 buf[2];
206         buf[0] = reg;
207         buf[1] = val;
208         msg.addr = info->i2c_client->addr;
209         msg.flags = 0;
210         msg.len = 2;
211         msg.buf = &buf[0];
212         if (i2c_transfer(info->i2c_client->adapter, &msg, 1) != 1)
213                 return -EIO;
214         return 0;
215 }
216
217 static int ad5816_i2c_rd16(struct ad5816_info *info, u8 reg, u16 *val)
218 {
219         struct i2c_msg msg[2];
220         u8 buf[3];
221         buf[0] = reg;
222         msg[0].addr = info->i2c_client->addr;
223         msg[0].flags = 0;
224         msg[0].len = 1;
225         msg[0].buf = &buf[0];
226         msg[1].addr = info->i2c_client->addr;
227         msg[1].flags = I2C_M_RD;
228         msg[1].len = 2;
229         msg[1].buf = &buf[1];
230         if (i2c_transfer(info->i2c_client->adapter, msg, 2) != 2)
231                 return -EIO;
232         *val = (((u16)buf[1] << 8) | (u16)buf[2]);
233         return 0;
234 }
235
236 static int ad5816_i2c_wr16(struct ad5816_info *info, u8 reg, u16 val)
237 {
238         struct i2c_msg msg;
239         u8 buf[3];
240         buf[0] = reg;
241         buf[1] = (u8)(val >> 8);
242         buf[2] = (u8)(val & 0xff);
243         msg.addr = info->i2c_client->addr;
244         msg.flags = 0;
245         msg.len = 3;
246         msg.buf = &buf[0];
247         if (i2c_transfer(info->i2c_client->adapter, &msg, 1) != 1)
248                 return -EIO;
249         return 0;
250 }
251
252 static int ad5816_gpio_wr(struct ad5816_info *info, ad5816_gpio_types i,
253                                 int val) /* val: 0=deassert, 1=assert */
254 {
255         int err = -EINVAL;
256         if (info->gpio[i].valid) {
257                 if (val)
258                         val = 1;
259                 if (!info->gpio[i].active_high)
260                         val = !val;
261                 val &= 1;
262                 err = val;
263                 gpio_set_value_cansleep(info->gpio[i].gpio, val);
264                 dev_dbg(&info->i2c_client->dev, "%s %u %d\n", __func__, info->gpio[i].gpio, val);
265         }
266         return err; /* return value written or error */
267 }
268
269 static int ad5816_gpio_reset(struct ad5816_info *info, int val)
270 {
271         int err = 0;
272
273         if (val) {
274                 if (!info->reset_flag) {
275                         info->reset_flag = true;
276                         err = ad5816_gpio_wr(info, AD5816_GPIO_RESET, 1);
277                         if (err < 0)
278                                 return 0; /* flag no reset */
279
280                         mdelay(1);
281                         ad5816_gpio_wr(info, AD5816_GPIO_RESET, 0);
282                         mdelay(10); /* startup delay needs to be modified*/
283                         err = 1; /* flag that a reset was done */
284                 }
285         } else {
286                 info->reset_flag = false;
287         }
288         return err;
289 }
290
291 static void ad5816_gpio_able(struct ad5816_info *info, int val)
292 {
293         /**
294         * This is a feature that allows driver to control GPIOs
295         * that may be needed for the board (not the device).
296         * */
297         if (val) {
298                 ad5816_gpio_wr(info, AD5816_GPIO_GP1, val);
299                 ad5816_gpio_wr(info, AD5816_GPIO_GP2, val);
300                 ad5816_gpio_wr(info, AD5816_GPIO_GP3, val);
301         } else {
302                 ad5816_gpio_wr(info, AD5816_GPIO_GP3, val);
303                 ad5816_gpio_wr(info, AD5816_GPIO_GP2, val);
304                 ad5816_gpio_wr(info, AD5816_GPIO_GP1, val);
305         }
306 }
307 static void ad5816_gpio_exit(struct ad5816_info *info)
308 {
309         unsigned i;
310         for (i = 0; i <= ARRAY_SIZE(ad5816_gpios); i++) {
311                 if (info->gpio[i].flag && info->gpio[i].own) {
312                         gpio_free(info->gpio[i].gpio);
313                         info->gpio[i].own = false;
314                 }
315         }
316 }
317
318 static void ad5816_gpio_init(struct ad5816_info *info)
319 {
320         char label[32];
321         unsigned long flags;
322         unsigned type;
323         unsigned i;
324         unsigned j;
325         int err;
326         for (i = 0; i < ARRAY_SIZE(ad5816_gpios); i++)
327                 info->gpio[i].flag = false;
328
329         if (!info->pdata->gpio_count || !info->pdata->gpio)
330                 return;
331
332         for (i = 0; i < ARRAY_SIZE(ad5816_gpios); i++) {
333                 type = ad5816_gpios[i].gpio_type;
334
335                 for (j = 0; j < info->pdata->gpio_count; j++) {
336                         if (type == info->pdata->gpio[j].gpio_type)
337                                 break;
338                 }
339
340                 if (j == info->pdata->gpio_count)
341                         continue;
342                 info->gpio[type].gpio = info->pdata->gpio[j].gpio;
343                 info->gpio[type].flag = true;
344
345                 if (ad5816_gpios[i].use_flags) {
346                         flags = ad5816_gpios[i].flags;
347                         info->gpio[type].active_high = ad5816_gpios[i].active_high;
348                 } else {
349                         info->gpio[type].active_high = info->pdata->gpio[j].active_high;
350                         if (info->gpio[type].active_high)
351                                 flags = GPIOF_OUT_INIT_LOW;
352                         else
353                                 flags = GPIOF_OUT_INIT_HIGH;
354                 }
355
356                 if (!info->pdata->gpio[j].init_en)
357                         continue;
358                 snprintf(label, sizeof(label), "ad5816_%u_%s",
359                                 info->pdata->num, ad5816_gpios[i].label);
360                 err = gpio_request_one(info->gpio[type].gpio, flags, label);
361                 if (err) {
362                         dev_err(&info->i2c_client->dev, "%s ERR %s %u\n",
363                                         __func__, label, info->gpio[type].gpio);
364                 } else {
365                         info->gpio[type].own = true;
366                         dev_dbg(&info->i2c_client->dev, "%s %s %u\n",
367                                         __func__, label, info->gpio[type].gpio);
368                 }
369         }
370 }
371
372 static int ad5816_vreg_dis(struct ad5816_info *info, ad5816_vreg i)
373 {
374         int err = 0;
375         if (info->vreg[i].vreg_flag && (info->vreg[i].vreg != NULL)) {
376                 err = regulator_disable(info->vreg[i].vreg);
377                 if (!err)
378                         dev_dbg(&info->i2c_client->dev, "%s: %s\n",
379                                         __func__, info->vreg[i].vreg_name);
380                 else
381                         dev_err(&info->i2c_client->dev, "%s %s ERR\n",
382                                         __func__, info->vreg[i].vreg_name);
383         }
384         info->vreg[i].vreg_flag = false;
385         return err;
386 }
387
388 static int ad5816_vreg_dis_all(struct ad5816_info *info)
389 {
390         unsigned i;
391         int err = 0;
392         for (i = ARRAY_SIZE(ad5816_vregs); i > 0; i--)
393                 err |= ad5816_vreg_dis(info, (i - 1));
394         return err;
395 }
396
397 static int ad5816_vreg_en(struct ad5816_info *info, ad5816_vreg i)
398 {
399         int err = 0;
400         if (!info->vreg[i].vreg_flag && (info->vreg[i].vreg != NULL)) {
401                 err = regulator_enable(info->vreg[i].vreg);
402
403                 if (!err) {
404                         dev_dbg(&info->i2c_client->dev, "%s: %s\n",
405                                         __func__, info->vreg[i].vreg_name);
406                         info->vreg[i].vreg_flag = true;
407                         err = 1; /* flag regulator state change */
408                 } else {
409                         dev_err(&info->i2c_client->dev, "%s %s ERR\n",
410                                         __func__, info->vreg[i].vreg_name);
411                 }
412
413         }
414         return err;
415 }
416
417 static int ad5816_vreg_en_all(struct ad5816_info *info)
418 {
419         unsigned i;
420         int err = 0;
421         for (i = 0; i < ARRAY_SIZE(ad5816_vregs); i++)
422                 err |= ad5816_vreg_en(info, i);
423         return err;
424 }
425
426 static void ad5816_vreg_exit(struct ad5816_info *info)
427 {
428         unsigned i;
429         for (i = 0; i < ARRAY_SIZE(ad5816_vregs); i++) {
430                 regulator_put(info->vreg[i].vreg);
431                 info->vreg[i].vreg = NULL;
432         }
433 }
434
435 static int ad5816_vreg_init(struct ad5816_info *info)
436 {
437         unsigned i;
438         unsigned j;
439         int err = 0;
440         for (i = 0; i < ARRAY_SIZE(ad5816_vregs); i++) {
441                 j = ad5816_vregs[i].vreg_num;
442                 info->vreg[j].vreg_name = ad5816_vregs[i].vreg_name;
443                 info->vreg[j].vreg_flag = false;
444                 info->vreg[j].vreg = regulator_get(&info->i2c_client->dev,
445                                                                 info->vreg[j].vreg_name);
446                 if (IS_ERR_OR_NULL(info->vreg[j].vreg)) {
447                         dev_dbg(&info->i2c_client->dev, "%s %s ERR: %d\n",
448                                         __func__, info->vreg[j].vreg_name,
449                                         (int)info->vreg[j].vreg);
450                         err |= PTR_ERR(info->vreg[j].vreg);
451                         info->vreg[j].vreg = NULL;
452                 } else {
453                         dev_dbg(&info->i2c_client->dev, "%s: %s\n",
454                                         __func__, info->vreg[j].vreg_name);
455                 }
456         }
457         return err;
458 }
459
460 void ad5816_set_power_down(struct ad5816_info *info)
461 {
462         int err;
463         u16 data = 0x0000;
464         err = ad5816_i2c_wr16(info, VCM_CODE_MSB, data);
465         if (err)
466                 dev_err(&info->i2c_client->dev, " %s: failed \n",
467                         __func__);
468 }
469
470 void ad5816_set_arc_mode(struct ad5816_info *info)
471 {
472         int err = 0;
473         /* set ARC enable */
474         err = ad5816_i2c_wr8(info, CONTROL, 0x02);
475         if (err)
476                 dev_err(&info->i2c_client->dev,
477                 "%s: CONTROL reg write failed \n", __func__);
478
479         /* set the ARC RES2 */
480         err = ad5816_i2c_wr8(info, MODE, 0x01);
481         if (err)
482                 dev_err(&info->i2c_client->dev,
483                 "%s: MODE reg write failed \n", __func__);
484
485         /* set the VCM_FREQ to 12.8mS */
486         err = ad5816_i2c_wr8(info, VCM_FREQ, 0x80);
487         if (err)
488                 dev_err(&info->i2c_client->dev,
489                 "%s: VCM_FREQ reg write failed \n", __func__);
490 }
491
492 static int ad5816_pm_wr(struct ad5816_info *info, int pwr)
493 {
494         int err = 0;
495
496         if ((info->pdata->cfg & (NVC_CFG_OFF2STDBY | NVC_CFG_BOOT_INIT)) &&
497                 (pwr == NVC_PWR_OFF ||
498                 pwr == NVC_PWR_STDBY_OFF))
499                         pwr = NVC_PWR_STDBY;
500
501         if (pwr == info->pwr_dev)
502                 return 0;
503
504         switch (pwr)
505         {
506                 case NVC_PWR_OFF_FORCE:
507                 case NVC_PWR_OFF:
508                         err = ad5816_vreg_dis_all(info);
509                         ad5816_gpio_able(info, 0);
510                         ad5816_gpio_reset(info, 0);
511                         break;
512                 case NVC_PWR_STDBY_OFF:
513                 case NVC_PWR_STDBY:
514                         err = ad5816_vreg_en_all(info);
515                         ad5816_gpio_able(info, 1);
516                         ad5816_gpio_reset(info, 1);
517                         break;
518                 case NVC_PWR_COMM:
519                 case NVC_PWR_ON:
520                         err = ad5816_vreg_en_all(info);
521                         ad5816_gpio_able(info, 1);
522                         ad5816_gpio_reset(info, 1);
523                         break;
524                 default:
525                         err = -EINVAL;
526                         break;
527         }
528
529         if (err < 0) {
530                 dev_err(&info->i2c_client->dev, "%s err %d\n", __func__, err);
531                 pwr = NVC_PWR_ERR;
532         }
533
534         info->pwr_dev = pwr;
535         dev_dbg(&info->i2c_client->dev, "%s pwr_dev=%d\n", __func__, info->pwr_dev);
536
537         if (err > 0)
538                 return 0;
539
540         return err;
541 }
542 static int ad5816_pm_wr_s(struct ad5816_info *info, int pwr)
543 {
544         int err1 = 0;
545         int err2 = 0;
546         if ((info->s_mode == NVC_SYNC_OFF) ||
547                 (info->s_mode == NVC_SYNC_MASTER) ||
548                 (info->s_mode == NVC_SYNC_STEREO))
549                 err1 = ad5816_pm_wr(info, pwr);
550         if ((info->s_mode == NVC_SYNC_SLAVE) ||
551                 (info->s_mode == NVC_SYNC_STEREO))
552                 err2 = ad5816_pm_wr(info->s_info, pwr);
553         return err1 | err2;
554 }
555
556 static int ad5816_pm_api_wr(struct ad5816_info *info, int pwr)
557 {
558         int err = 0;
559         if (!pwr || (pwr > NVC_PWR_ON))
560                 return 0;
561         if (pwr > info->pwr_dev) {
562                 err = ad5816_pm_wr_s(info, pwr);
563         }
564         if (!err) {
565                 info->pwr_api = pwr;
566         } else
567                 info->pwr_api = NVC_PWR_ERR;
568         if (info->pdata->cfg & NVC_CFG_NOERR)
569                 return 0;
570         return err;
571 }
572
573 static int ad5816_pm_dev_wr(struct ad5816_info *info, int pwr)
574 {
575         if (pwr < info->pwr_api)
576                 pwr = info->pwr_api;
577         return ad5816_pm_wr(info, pwr);
578 }
579
580 static void ad5816_pm_exit(struct ad5816_info *info)
581 {
582         ad5816_pm_wr(info, NVC_PWR_OFF_FORCE);
583         ad5816_vreg_exit(info);
584         ad5816_gpio_exit(info);
585 }
586 static void ad5816_pm_init(struct ad5816_info *info)
587 {
588         ad5816_gpio_init(info);
589         ad5816_vreg_init(info);
590 }
591
592 static int ad5816_reset(struct ad5816_info *info, u32 level)
593 {
594         int err;
595         if (level == NVC_RESET_SOFT) {
596                 err = ad5816_pm_wr(info, NVC_PWR_COMM);
597                 err |= ad5816_i2c_wr8(info, CONTROL, 0x01); /* SW reset */
598         } else {
599                 err = ad5816_pm_wr(info, NVC_PWR_OFF_FORCE);
600         }
601         err |= ad5816_pm_wr(info, info->pwr_api);
602         return err;
603 }
604
605 static int ad5816_dev_id(struct ad5816_info *info)
606 {
607         u16 val = 0;
608         unsigned i;
609         int err;
610         ad5816_pm_dev_wr(info, NVC_PWR_COMM);
611         err = ad5816_i2c_rd16(info, IC_INFO, &val);
612         if (!err) {
613                 dev_dbg(&info->i2c_client->dev, "%s found devId: %x\n", __func__, val);
614                 info->id_minor = 0;
615                 val = val & 0xff;
616                 for (i = 0; i < ARRAY_SIZE(ad5816_ids); i++) {
617                         if (val == ad5816_ids[i]) {
618                                 info->id_minor = val;
619                                 break;
620                         }
621                 }
622                 if (!info->id_minor) {
623                         err = -ENODEV;
624                         dev_dbg(&info->i2c_client->dev, "%s No devId match\n", __func__);
625                 }
626         }
627         ad5816_pm_dev_wr(info, NVC_PWR_OFF);
628         return err;
629 }
630
631 static void ad5816_sts_rd(struct ad5816_info *info)
632 {
633         /**
634         * Device specific code for status
635         *
636         * TODO: Ad5816 has support to get status for over/under
637         * voltage conditions but currently this feature is not
638         * required.
639         */
640 }
641 /**
642  * Below are device specific functions.
643  */
644
645 static int ad5816_position_rd(struct ad5816_info *info, unsigned *position)
646 {
647
648         u16 pos = 0;
649         u8 t1 = 0;
650         int err = 0;
651
652         err = ad5816_i2c_rd8(info, 0, VCM_CODE_MSB, &t1);
653         pos = t1 & 0x03;
654         err  = ad5816_i2c_rd8(info, 0, VCM_CODE_LSB, &t1);
655         pos = (pos << 8) | t1;
656         if(pos)
657                 *position = pos - info->config.pos_low;
658         else
659                 *position = info->config.pos_low;
660
661         return 0;
662 }
663
664 static int ad5816_position_wr(struct ad5816_info *info, unsigned position)
665 {
666         position = position + info->config.pos_low;
667
668         if(position > info->config.pos_high)
669                 position = info->config.pos_high;
670
671         u16 data = position & 0x03ff;
672
673         return ad5816_i2c_wr16(info, VCM_CODE_MSB, data);
674 }
675
676 static int ad5816_param_rd(struct ad5816_info *info, unsigned long arg)
677 {
678         struct nvc_param params;
679         const void *data_ptr;
680         u32 data_size = 0;
681         u32 position;
682         int err;
683         if (copy_from_user(&params,
684                 (const void __user *)arg,
685                 sizeof(struct nvc_param))) {
686                 dev_err(&info->i2c_client->dev, "%s %d copy_from_user err\n", __func__, __LINE__);
687                 return -EFAULT;
688         }
689         if (info->s_mode == NVC_SYNC_SLAVE)
690                 info = info->s_info;
691         switch (params.param) {
692                 case NVC_PARAM_LOCUS:
693                         ad5816_pm_dev_wr(info, NVC_PWR_COMM);
694                         err = ad5816_position_rd(info, &position);
695                         if (err && !(info->pdata->cfg & NVC_CFG_NOERR))
696                                 return err;
697                         data_ptr = &position;
698                         data_size = sizeof(position);
699                         ad5816_pm_dev_wr(info, NVC_PWR_STDBY);
700                         dev_dbg(&info->i2c_client->dev, "%s LOCUS: %d\n",
701                                         __func__, position);
702                         break;
703                 case NVC_PARAM_FOCAL_LEN:
704                         info->nvc.focal_length = AD5816_FOCAL_LENGTH;
705                         data_ptr = &info->nvc.focal_length;
706                         data_size = sizeof(info->nvc.focal_length);
707                         break;
708                 case NVC_PARAM_MAX_APERTURE:
709                         data_ptr = &info->nvc.max_aperature;
710                         data_size = sizeof(info->nvc.max_aperature);
711                         dev_dbg(&info->i2c_client->dev, "%s MAX_APERTURE: %x\n",
712                                         __func__, info->nvc.max_aperature);
713                         break;
714                 case NVC_PARAM_FNUMBER:
715                         data_ptr = &info->nvc.fnumber;
716                         data_size = sizeof(info->nvc.fnumber);
717                         dev_dbg(&info->i2c_client->dev, "%s FNUMBER: %u\n",
718                                         __func__, info->nvc.fnumber);
719                         break;
720                 case NVC_PARAM_CAPS:
721                         data_ptr = &info->cap;
722                         /* there are different sizes depending on the version */
723                         /* send back just what's requested or our max size */
724                         if (params.sizeofvalue < sizeof(info->cap))
725                                 data_size = params.sizeofvalue;
726                         else
727                                 data_size = sizeof(info->cap);
728                         dev_err(&info->i2c_client->dev, "%s CAPS\n", __func__);
729                         break;
730                 case NVC_PARAM_STS:
731                         /*data_ptr = &info->sts;
732                         data_size = sizeof(info->sts);*/
733                         dev_dbg(&info->i2c_client->dev, "%s \n", __func__);
734                         break;
735                 case NVC_PARAM_STEREO:
736                         data_ptr = &info->s_mode;
737                         data_size = sizeof(info->s_mode);
738                         dev_err(&info->i2c_client->dev, "%s STEREO: %d\n", __func__, info->s_mode);
739                         break;
740                 default:
741                         dev_err(&info->i2c_client->dev, "%s unsupported parameter: %d\n",
742                                         __func__, params.param);
743                         return -EINVAL;
744         }
745         if (params.sizeofvalue < data_size) {
746                 dev_err(&info->i2c_client->dev,
747                         "%s data size mismatch %d != %d Param: %d\n",
748                         __func__, params.sizeofvalue, data_size, params.param);
749                 return -EINVAL;
750         }
751         if (copy_to_user((void __user *)params.p_value, data_ptr, data_size)) {
752                 dev_err(&info->i2c_client->dev, "%s copy_to_user err line %d\n",
753                                 __func__, __LINE__);
754                 return -EFAULT;
755         }
756         return 0;
757 }
758
759 static int ad5816_param_wr_s(struct ad5816_info *info,
760                                                                 struct nvc_param *params,
761                                                                 u32 u32val)
762 {
763         struct nvc_focus_cap cap;
764         u8 u8val;
765         int err = 0;
766         u8val = (u8)u32val;
767         switch (params->param) {
768                 case NVC_PARAM_LOCUS:
769                         dev_dbg(&info->i2c_client->dev, "%s LOCUS: %u\n", __func__, u32val);
770                         err = ad5816_position_wr(info, u32val);
771                         return err;
772                 case NVC_PARAM_RESET:
773                         err = ad5816_reset(info, u32val);
774                         dev_dbg(&info->i2c_client->dev, "%s RESET: %d\n", __func__, err);
775                         return err;
776                 case NVC_PARAM_SELF_TEST:
777                         err = 0;
778                         dev_dbg(&info->i2c_client->dev, "%s SELF_TEST: %d\n", __func__, err);
779                         return err;
780                 default:
781                         dev_dbg(&info->i2c_client->dev,
782                                 "%s unsupported parameter: %d\n",
783                                         __func__, params->param);
784                         return -EINVAL;
785         }
786 }
787
788 static int ad5816_param_wr(struct ad5816_info *info, unsigned long arg)
789 {
790         struct nvc_param params;
791         u8 u8val;
792         u32 u32val;
793         int err = 0;
794         if (copy_from_user(&params, (const void __user *)arg,
795                 sizeof(struct nvc_param))) {
796                 dev_err(&info->i2c_client->dev, "%s copy_from_user err line %d\n",
797                                 __func__, __LINE__);
798                 return -EFAULT;
799         }
800         if (copy_from_user(&u32val, (const void __user *)params.p_value, sizeof(u32val))) {
801                 dev_err(&info->i2c_client->dev, "%s %d copy_from_user err\n", __func__, __LINE__);
802                 return -EFAULT;
803         }
804         u8val = (u8)u32val;
805         /* parameters independent of sync mode */
806         switch (params.param) {
807                 case NVC_PARAM_STEREO:
808                         dev_dbg(&info->i2c_client->dev, "%s STEREO: %d\n", __func__, u8val);
809                         if (u8val == info->s_mode)
810                                 return 0;
811                         switch (u8val) {
812                                 case NVC_SYNC_OFF:
813                                         info->s_mode = u8val;
814                                         ad5816_gpio_wr(info, AD5816_GPIO_I2CMUX, 0);
815                                         if (info->s_info != NULL) {
816                                                 info->s_info->s_mode = u8val;
817                                                 ad5816_pm_wr(info->s_info, NVC_PWR_OFF);
818                                         }
819                                         break;
820                                 case NVC_SYNC_MASTER:
821                                         info->s_mode = u8val;
822                                         ad5816_gpio_wr(info, AD5816_GPIO_I2CMUX, 0);
823                                         if (info->s_info != NULL)
824                                                 info->s_info->s_mode = u8val;
825                                         break;
826                                 case NVC_SYNC_SLAVE:
827                                         if (info->s_info != NULL) {
828                                                 /* default slave lens position */
829                                                 err = ad5816_position_wr(info->s_info,
830                                                                 info->s_info->cap.focus_infinity);
831                                                 if (!err) {
832                                                         info->s_mode = u8val;
833                                                         info->s_info->s_mode = u8val;
834                                                         ad5816_gpio_wr(info,
835                                                         AD5816_GPIO_I2CMUX, 0);
836                                                 }
837                                                 else {
838                                                         if (info->s_mode != NVC_SYNC_STEREO)
839                                                                 ad5816_pm_wr(info->s_info,
840                                                                 NVC_PWR_OFF);
841                                                                 err = -EIO;
842                                                 }
843                                         } else {
844                                                 err = -EINVAL;
845                                         }
846                                         break;
847                                 case NVC_SYNC_STEREO:
848                                         if (info->s_info != NULL) {
849                                                 /* sync power */
850                                                 info->s_info->pwr_api = info->pwr_api;
851                                                 /* move slave lens to master position */
852                                                 err = ad5816_position_wr(info->s_info, info->pos);
853                                                 if (!err) {
854                                                         info->s_mode = u8val;
855                                                         info->s_info->s_mode = u8val;
856                                                         ad5816_gpio_wr(info, AD5816_GPIO_I2CMUX, 1);
857                                                 }
858                                                 else {
859                                                         if (info->s_mode != NVC_SYNC_SLAVE)
860                                                         ad5816_pm_wr(info->s_info, NVC_PWR_OFF);
861                                                         err = -EIO;
862                                                 }
863                                         } else {
864                                                 err = -EINVAL;
865                                         }
866                                         break;
867                                 default:
868                                         err = -EINVAL;
869                         }
870                         if (info->pdata->cfg & NVC_CFG_NOERR)
871                                 return 0;
872                         return err;
873                 default:
874                         /* parameters dependent on sync mode */
875                         switch (info->s_mode) {
876                                 case NVC_SYNC_OFF:
877                                 case NVC_SYNC_MASTER:
878                                         return ad5816_param_wr_s(info, &params, u32val);
879                                 case NVC_SYNC_SLAVE:
880                                         return ad5816_param_wr_s(info->s_info, &params, u32val);
881                                 case NVC_SYNC_STEREO:
882                                         err = ad5816_param_wr_s(info, &params, u32val);
883                                         if (!(info->pdata->cfg & NVC_CFG_SYNC_I2C_MUX))
884                                                 err |= ad5816_param_wr_s(info->s_info,
885                                                                 &params,
886                                                                 u32val);
887                                         return err;
888                                 default:
889                                         dev_err(&info->i2c_client->dev, "%s %d internal err\n",
890                                                         __func__, __LINE__);
891                                         return -EINVAL;
892                         }
893                 }
894 }
895
896 static long ad5816_ioctl(struct file *file,
897                                                         unsigned int cmd,
898                                                         unsigned long arg)
899 {
900         struct ad5816_info *info = file->private_data;
901         int pwr;
902         int err = 0;
903         switch (cmd) {
904                 case NVC_IOCTL_PARAM_WR:
905                         err = ad5816_param_wr(info, arg);
906                         return err;
907                 case NVC_IOCTL_PARAM_RD:
908                         err = ad5816_param_rd(info, arg);
909                         return err;
910                 case NVC_IOCTL_PWR_WR:
911                         /* This is a Guaranteed Level of Service (GLOS) call */
912                         pwr = (int)arg * 2;
913                         dev_dbg(&info->i2c_client->dev, "%s PWR_WR: %d\n",
914                                         __func__, pwr);
915                         err = ad5816_pm_api_wr(info, pwr);
916                         return err;
917                 case NVC_IOCTL_PWR_RD:
918                         if (info->s_mode == NVC_SYNC_SLAVE)
919                                 pwr = info->s_info->pwr_api / 2;
920                         else
921                                 pwr = info->pwr_api / 2;
922                         dev_dbg(&info->i2c_client->dev, "%s PWR_RD: %d\n",
923                                         __func__, pwr);
924                         if (copy_to_user((void __user *)arg, (const void *)&pwr, sizeof(pwr))) {
925                                 dev_err(&info->i2c_client->dev, "%s copy_to_user err line %d\n",
926                                                 __func__, __LINE__);
927                                 return -EFAULT;
928                         }
929                         return 0;
930                 default:
931                         dev_dbg(&info->i2c_client->dev, "%s unsupported ioctl: %x\n", __func__, cmd);
932         }
933         return -EINVAL;
934 }
935
936
937 static void ad5816_sdata_init(struct ad5816_info *info)
938 {
939         /* set defaults */
940         memcpy(&info->config, &ad5816_default_info, sizeof(info->config));
941         memcpy(&info->nvc, &ad5816_default_nvc, sizeof(info->nvc));
942         memcpy(&info->cap, &ad5816_default_cap, sizeof(info->cap));
943
944         info->config.settle_time = AD5816_SETTLETIME;
945         info->config.focal_length = AD5816_FOCAL_LENGTH;
946         info->config.fnumber = AD5816_FNUMBER;
947         info->config.pos_low = AD5816_POS_LOW_DEFAULT;
948         info->config.pos_high = AD5816_POS_HIGH_DEFAULT;
949
950         /* set to proper value */
951         info->cap.actuator_range = info->config.pos_high - info->config.pos_low;
952
953         /* set overrides if any */
954         if (info->pdata->nvc) {
955                 if (info->pdata->nvc->fnumber)
956                         info->nvc.fnumber = info->pdata->nvc->fnumber;
957                 if (info->pdata->nvc->focal_length)
958                         info->nvc.focal_length = info->pdata->nvc->focal_length;
959                 if (info->pdata->nvc->max_aperature)
960                         info->nvc.max_aperature = info->pdata->nvc->max_aperature;
961         }
962
963         if (info->pdata->cap) {
964                 if (info->pdata->cap->actuator_range)
965                         info->cap.actuator_range = info->pdata->cap->actuator_range;
966                 if (info->pdata->cap->settle_time)
967                         info->cap.settle_time = info->pdata->cap->settle_time;
968                 if (info->pdata->cap->focus_macro)
969                         info->cap.focus_macro = info->pdata->cap->focus_macro;
970                 if (info->pdata->cap->focus_hyper)
971                         info->cap.focus_hyper = info->pdata->cap->focus_hyper;
972                 if (info->pdata->cap->focus_infinity)
973                         info->cap.focus_infinity = info->pdata->cap->focus_infinity;
974         }
975 }
976
977 static int ad5816_sync_en(unsigned num, unsigned sync)
978 {
979         struct ad5816_info *master = NULL;
980         struct ad5816_info *slave = NULL;
981         struct ad5816_info *pos = NULL;
982         rcu_read_lock();
983         list_for_each_entry_rcu(pos, &ad5816_info_list, list) {
984                 if (pos->pdata->num == num) {
985                         master = pos;
986                         break;
987                 }
988         }
989         pos = NULL;
990         list_for_each_entry_rcu(pos, &ad5816_info_list, list) {
991                 if (pos->pdata->num == sync) {
992                         slave = pos;
993                         break;
994                 }
995         }
996         rcu_read_unlock();
997         if (master != NULL)
998                 master->s_info = NULL;
999         if (slave != NULL)
1000                 slave->s_info = NULL;
1001         if (!sync)
1002                 return 0; /* no err if sync disabled */
1003         if (num == sync)
1004                 return -EINVAL; /* err if sync instance is itself */
1005         if ((master != NULL) && (slave != NULL)) {
1006                 master->s_info = slave;
1007                 slave->s_info = master;
1008         }
1009         return 0;
1010 }
1011
1012 static int ad5816_sync_dis(struct ad5816_info *info)
1013 {
1014         if (info->s_info != NULL) {
1015                 info->s_info->s_mode = 0;
1016                 info->s_info->s_info = NULL;
1017                 info->s_mode = 0;
1018                 info->s_info = NULL;
1019                 return 0;
1020         }
1021         return -EINVAL;
1022 }
1023
1024 static int ad5816_open(struct inode *inode, struct file *file)
1025 {
1026         struct ad5816_info *info = NULL;
1027         struct ad5816_info *pos = NULL;
1028         int err;
1029         rcu_read_lock();
1030         list_for_each_entry_rcu(pos, &ad5816_info_list, list) {
1031                 if (pos->miscdev.minor == iminor(inode)) {
1032                         info = pos;
1033                         break;
1034                 }
1035         }
1036         rcu_read_unlock();
1037         if (!info)
1038                 return -ENODEV;
1039         err = ad5816_sync_en(info->pdata->num, info->pdata->sync);
1040         if (err == -EINVAL)
1041                 dev_err(&info->i2c_client->dev, "%s err: invalid num (%u) and sync (%u) instance\n",
1042                 __func__, info->pdata->num, info->pdata->sync);
1043         if (atomic_xchg(&info->in_use, 1))
1044                 return -EBUSY;
1045         if (info->s_info != NULL) {
1046                 if (atomic_xchg(&info->s_info->in_use, 1))
1047                         return -EBUSY;
1048         }
1049         file->private_data = info;
1050         ad5816_pm_dev_wr(info, NVC_PWR_ON);
1051         /* set ARC Mode to ensure faster focus */
1052         ad5816_set_arc_mode(info);
1053         dev_dbg(&info->i2c_client->dev, "%s\n", __func__);
1054
1055         return 0;
1056 }
1057
1058 static int ad5816_release(struct inode *inode, struct file *file)
1059 {
1060         struct ad5816_info *info = file->private_data;
1061         dev_dbg(&info->i2c_client->dev, "%s\n", __func__);
1062         ad5816_pm_wr_s(info, NVC_PWR_OFF);
1063         file->private_data = NULL;
1064         WARN_ON(!atomic_xchg(&info->in_use, 0));
1065         if (info->s_info != NULL)
1066                 WARN_ON(!atomic_xchg(&info->s_info->in_use, 0));
1067         ad5816_sync_dis(info);
1068         return 0;
1069 }
1070
1071 static const struct file_operations ad5816_fileops = {
1072         .owner = THIS_MODULE,
1073         .open = ad5816_open,
1074         .unlocked_ioctl = ad5816_ioctl,
1075         .release = ad5816_release,
1076 };
1077
1078 static void ad5816_del(struct ad5816_info *info)
1079 {
1080         ad5816_pm_exit(info);
1081         if ((info->s_mode == NVC_SYNC_SLAVE) ||
1082                 (info->s_mode == NVC_SYNC_STEREO))
1083                 ad5816_pm_exit(info->s_info);
1084
1085         ad5816_sync_dis(info);
1086         spin_lock(&ad5816_spinlock);
1087         list_del_rcu(&info->list);
1088         spin_unlock(&ad5816_spinlock);
1089         synchronize_rcu();
1090 }
1091
1092 static int ad5816_remove(struct i2c_client *client)
1093 {
1094         struct ad5816_info *info = i2c_get_clientdata(client);
1095         dev_dbg(&info->i2c_client->dev, "%s\n", __func__);
1096         misc_deregister(&info->miscdev);
1097         ad5816_del(info);
1098         return 0;
1099 }
1100
1101 static int ad5816_probe(
1102                 struct i2c_client *client,
1103                 const struct i2c_device_id *id)
1104 {
1105         pr_info("ad5816: probing focuser.\n");
1106         struct ad5816_info *info;
1107         char dname[16];
1108         int err;
1109         dev_dbg(&client->dev, "%s\n", __func__);
1110         info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL);
1111         if (info == NULL) {
1112                 dev_err(&client->dev, "%s: kzalloc error\n", __func__);
1113                 return -ENOMEM;
1114         }
1115         info->i2c_client = client;
1116         if (client->dev.platform_data) {
1117                 info->pdata = client->dev.platform_data;
1118         } else {
1119                 info->pdata = &ad5816_default_pdata;
1120                 dev_dbg(&client->dev,"%s No platform data.  Using defaults.\n", __func__);
1121         }
1122
1123         i2c_set_clientdata(client, info);
1124         INIT_LIST_HEAD(&info->list);
1125         spin_lock(&ad5816_spinlock);
1126         list_add_rcu(&info->list, &ad5816_info_list);
1127         spin_unlock(&ad5816_spinlock);
1128         ad5816_pm_init(info);
1129         ad5816_sdata_init(info);
1130
1131         err = ad5816_dev_id(info);
1132         if (err < 0) {
1133                 dev_err(&client->dev, "%s device not found\n", __func__);
1134                 ad5816_pm_wr(info, NVC_PWR_OFF);
1135                 if (info->pdata->cfg & NVC_CFG_NODEV) {
1136                         ad5816_del(info);
1137                         return -ENODEV;
1138                 }
1139         } else {
1140                 dev_dbg(&client->dev, "%s device found\n", __func__);
1141                 if (info->pdata->cfg & NVC_CFG_BOOT_INIT) {
1142                         /* initial move causes full initialization */
1143                         ad5816_pm_dev_wr(info, NVC_PWR_ON);
1144                         ad5816_position_wr(info, info->cap.focus_infinity);
1145                         ad5816_pm_dev_wr(info, NVC_PWR_OFF);
1146                 }
1147         }
1148
1149         if (info->pdata->dev_name != 0)
1150                 strcpy(dname, info->pdata->dev_name);
1151         else
1152                 strcpy(dname, "ad5816");
1153
1154         if (info->pdata->num)
1155                 snprintf(dname, sizeof(dname), "%s.%u", dname, info->pdata->num);
1156
1157         info->miscdev.name = dname;
1158         info->miscdev.fops = &ad5816_fileops;
1159         info->miscdev.minor = MISC_DYNAMIC_MINOR;
1160         if (misc_register(&info->miscdev)) {
1161                 dev_err(&client->dev, "%s unable to register misc device %s\n",
1162                         __func__, dname);
1163                 ad5816_del(info);
1164                 return -ENODEV;
1165         }
1166
1167         return 0;
1168 }
1169
1170
1171 static const struct i2c_device_id ad5816_id[] = {
1172         { "ad5816", 0 },
1173         { },
1174 };
1175
1176
1177 MODULE_DEVICE_TABLE(i2c, ad5816_id);
1178
1179 static struct i2c_driver ad5816_i2c_driver = {
1180         .driver = {
1181                 .name = "ad5816",
1182                 .owner = THIS_MODULE,
1183         },
1184         .id_table = ad5816_id,
1185         .probe = ad5816_probe,
1186         .remove = ad5816_remove,
1187 };
1188
1189 static int __init ad5816_init(void)
1190 {
1191         return i2c_add_driver(&ad5816_i2c_driver);
1192 }
1193
1194 static void __exit ad5816_exit(void)
1195 {
1196         i2c_del_driver(&ad5816_i2c_driver);
1197 }
1198
1199 module_init(ad5816_init);
1200 module_exit(ad5816_exit);
1201 MODULE_LICENSE("GPL");