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