media: video: tegra: SH532U: fix formatting errors
[linux-3.10.git] / drivers / media / video / tegra / sh532u.c
1 /*
2  * SH532U focuser driver.
3  *
4  * Copyright (C) 2011 NVIDIA Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18  * 02111-1307, USA
19  */
20
21 #include <linux/delay.h>
22 #include <linux/fs.h>
23 #include <linux/i2c.h>
24 #include <linux/miscdevice.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
27 #include <linux/module.h>
28
29 #include <media/sh532u.h>
30
31 #include <asm/traps.h>
32
33 #define POS_LOW (0xA000)
34 #define POS_HIGH (0x6000)
35 #define SETTLETIME_MS (7)
36 #define FOCAL_LENGTH 0x408d70a4 /* (4.42f) */
37 #define FNUMBER 0x40333333 /* (2.8f) */
38
39
40 struct sh532u_info {
41         struct i2c_client *i2c_client;
42         struct sh532u_config config;
43 };
44
45 static struct sh532u_info *info;
46
47 static int sh532u_read_u8(u8 dev, u8 addr, u8 *val)
48 {
49         struct i2c_client *client = info->i2c_client;
50         struct i2c_msg msg[2];
51         unsigned char data[3];
52
53         if (dev)
54                 msg[0].addr = dev;
55         else
56                 msg[0].addr = client->addr;
57         msg[0].flags = 0;
58         msg[0].len = 1;
59         msg[0].buf = data;
60
61         data[0] = (u8)addr;
62
63         if (dev)
64                 msg[1].addr = dev;
65         else
66                 msg[1].addr = client->addr;
67         msg[1].flags = I2C_M_RD;
68         msg[1].len = 1;
69         msg[1].buf = data + 2;
70
71         if (i2c_transfer(client->adapter, msg, 2) != 2)
72                 return -1;
73         *val = data[2];
74         return 0;
75 }
76
77 static int sh532u_read_u16(u8 addr, u16 *val)
78 {
79         struct i2c_client *client = info->i2c_client;
80         struct i2c_msg msg[2];
81         u8 buf[4];
82
83         msg[0].addr = client->addr;
84         msg[0].flags = 0;
85         msg[0].len = 1;
86         msg[0].buf = &buf[0];
87
88         /* high byte goes out first */
89         buf[0] = (u8) (addr);
90
91         msg[1].addr = client->addr;
92         msg[1].flags = I2C_M_RD;
93         msg[1].len = 2;
94         msg[1].buf = &buf[1];
95
96         if (i2c_transfer(client->adapter, msg, 2) != 2)
97                 return -1;
98         *val = (((u16)buf[1] << 8) | (u16)buf[2]);
99         return 0;
100 }
101
102 static int eeprom_read_u32(u8 addr, u32 *val)
103 {
104         struct i2c_client *client = info->i2c_client;
105         struct i2c_msg msg[2];
106         union {
107                 u8   dataU8[8];
108                 u32  dataU32[2];
109         } buffer;
110
111         msg[0].addr = 0x50;
112         msg[0].flags = 0;
113         msg[0].len = 1;
114         msg[0].buf = &(buffer.dataU8[0]);
115
116         /* high byte goes out first */
117         buffer.dataU8[0] = (u8) (addr);
118         buffer.dataU8[1] = (u8) (0);
119
120         msg[1].addr = 0x50;
121         msg[1].flags = I2C_M_RD;
122         msg[1].len = 4;
123         msg[1].buf = (u8 *)&(buffer.dataU32[1]);
124
125         if (i2c_transfer(client->adapter, msg, 2) != 2)
126                 return -1;
127         *val = buffer.dataU32[1];
128         return 0;
129 }
130
131 static int sh532u_write_u8(u16 addr, u8 val)
132 {
133         struct i2c_client *client = info->i2c_client;
134         struct i2c_msg msg;
135         unsigned char data[2];
136         u8 tmp;
137
138         data[0] = (u8) (addr & 0xff);
139         data[1] = (u8) (val & 0xff);
140
141         msg.addr = client->addr;
142         msg.flags = 0;
143         msg.len = 2;
144         msg.buf = data;
145
146         if (i2c_transfer(client->adapter, &msg, 1) != 1)
147                 return -1;
148
149         return 0;
150 }
151
152 static int sh532u_write_u16(u16 addr, u16 val)
153 {
154         struct i2c_client *client = info->i2c_client;
155         struct i2c_msg msg;
156         unsigned char data[3];
157
158         data[0] = (u8) (addr & 0xff);
159         data[1] = (u8) (val >> 8);
160         data[2] = (u8) (val & 0xff);
161
162         msg.addr = client->addr;
163         msg.flags = 0;
164         msg.len = 3;
165         msg.buf = data;
166
167         if (i2c_transfer(client->adapter, &msg, 1) != 1)
168                 return -1;
169         return 0;
170 }
171
172 static void move_driver(s16 tarPos)
173 {
174         s16 curPos, moveStep;
175         u16 moveDistance;
176         int err;
177
178         /* Read Current Position */
179         err = sh532u_read_u16(RZ_211H, &curPos);
180         if (err)
181                 goto move_driver_error;
182         /* Check move distance to Target Position */
183         moveDistance = abs((int)curPos - (int)tarPos);
184
185         /* if move distance is shorter than MS1Z12(=Step width) */
186         if (moveDistance <= STMV_SIZE) {
187                 err = sh532u_write_u8(MSSET_211, (INI_MSSET_211 | 0x01));
188                 err = err | sh532u_write_u16(MS1Z22_211H, tarPos);
189                 if (err)
190                         goto move_driver_error;
191         } else {
192                 if (curPos < tarPos)
193                         moveStep = STMV_SIZE;
194                 else
195                         moveStep = -STMV_SIZE;
196
197                 /* Set StepMove Target Positon */
198                 err = sh532u_write_u16(MS1Z12_211H, moveStep);
199                 err = err | sh532u_write_u16(STMVENDH_211, tarPos);
200                 /* Start StepMove */
201                 err = err |
202                       sh532u_write_u8(
203                         STMVEN_211,
204                         (STMCHTG_ON | STMSV_ON | STMLFF_OFF | STMVEN_ON));
205                 if (err)
206                         goto move_driver_error;
207         }
208
209         return;
210 move_driver_error:
211         pr_err("Focuser: %s failed!\n", __func__);
212 }
213
214 static void wait_for_move(void)
215 {
216         u16 usSmvFin;
217         u8 moveTime, ucParMod, tmp;
218         int err;
219
220         moveTime = 0;
221         do {
222                 mdelay(1);
223                 err = sh532u_read_u8(0, STMVEN_211, &ucParMod);
224                 err = err | sh532u_read_u16(RZ_211H, &usSmvFin);
225                 if (err)
226                         goto wait_for_move_error;
227                 /* StepMove Error Handling, Unexpected Position */
228                 if ((usSmvFin == 0x7FFF) || (usSmvFin == 0x8001)) {
229                         /* Stop StepMove Operation */
230                         err = sh532u_write_u8(STMVEN_211, ucParMod & 0xFE);
231                         if (err)
232                                 goto wait_for_move_error;
233                 }
234                 moveTime++;
235                 /* Wait StepMove operation end */
236         } while ((ucParMod & STMVEN_ON) && (moveTime < 50));
237
238         moveTime = 0;
239         if ((ucParMod & 0x08) == STMCHTG_ON) {
240                 mdelay(5);
241                 do {
242                         mdelay(1);
243                         moveTime++;
244                         err = sh532u_read_u8(0, MSSET_211, &tmp);
245                         if (err)
246                                 goto wait_for_move_error;
247                 } while ((tmp & CHTGST_ON) && (moveTime < 15));
248         }
249
250         return;
251 wait_for_move_error:
252         pr_err("Focuser: %s failed!\n", __func__);
253 }
254
255 static void lens_move_pulse(s16 position)
256 {
257         move_driver(position);
258         wait_for_move();
259 }
260
261 static void get_rom_info(void)
262 {
263         u8 tmp;
264         int err;
265
266         /* Get Inf1, Mac1
267         Inf1 and Mac1 are the mechanical limit position.
268         Inf1     : Bottom limit.
269         Mac1 : Top limit. */
270         err = sh532u_read_u8(0x50, addrMac1, &tmp);
271         if (err)
272                 goto get_rom_info_error;
273         info->config.limit_low = (tmp<<8) & 0xff00;
274         err = sh532u_read_u8(0x50, addrInf1, &tmp);
275         if (err)
276                 goto get_rom_info_error;
277         info->config.limit_high = (tmp<<8) & 0xff00;
278
279         /* Get Inf2, Mac2
280         Inf2 and Mac2 are the calibration data for SEMCO AF lens.
281         Inf2: Best focus (lens position) when object distance is 1.2M.
282         Mac2: Best focus (lens position) when object distance is 10cm. */
283         err = sh532u_read_u8(0x50, addrMac2, &tmp);
284         if (err)
285                 goto get_rom_info_error;
286         info->config.pos_low = (tmp << 8) & 0xff00;
287         err = sh532u_read_u8(0x50, addrInf2, &tmp);
288         if (err)
289                 goto get_rom_info_error;
290         info->config.pos_high = (tmp << 8) & 0xff00;
291
292         return;
293 get_rom_info_error:
294         pr_err("Focuser: %s failed!\n", __func__);
295         info->config.limit_high = POS_HIGH;
296         info->config.limit_low = POS_LOW;
297         info->config.pos_high = POS_HIGH;
298         info->config.pos_low = POS_LOW;
299 }
300
301 static void init_hvca_pos(void)
302 {
303         short sBottomLimit, sTopLimit;
304
305         get_rom_info();
306         sBottomLimit = (((int)info->config.limit_low * 5) >> 3) & 0xFFC0;
307         lens_move_pulse(sBottomLimit);
308         sTopLimit = (((int)info->config.limit_high * 5) >> 3) & 0xFFC0;
309         lens_move_pulse(sTopLimit);
310         lens_move_pulse(info->config.pos_high);
311 }
312
313 static unsigned int a2buf[] = {
314         0x0018019c,
315         0x0018019d,
316         0x0000019e,
317         0x007f0192,
318         0x00000194,
319         0x00f00184,
320         0x00850187,
321         0x0000018a,
322         0x00fd7187,
323         0x007f7183,
324         0x0008025a,
325         0x05042218,
326         0x80010216,
327         0x000601a0,
328         0x00808183,
329         0xffffffff
330 };
331
332 /* Write 1 byte data to the HVCA Drive IC by data type */
333 static void sh532u_hvca_wr1(u8 ep_type, u8 ep_data1, u8 ep_addr)
334 {
335         int err = 0;
336         u8 us_data;
337
338         switch (ep_type & 0xF0) {
339         case DIRECT_MODE:
340                 us_data = ep_data1;
341                 break;
342
343         case INDIRECT_EEPROM:
344                 err = sh532u_read_u8(0x50, ep_data1, &us_data);
345                 break;
346
347         case INDIRECT_HVCA:
348                 err = sh532u_read_u8(0, (u16)ep_data1, &us_data);
349                 break;
350
351         case MASK_AND:
352                 err = sh532u_read_u8(0, (u16)ep_addr, &us_data);
353                 us_data = us_data & ep_data1;
354                 break;
355
356         case MASK_OR:
357                 err = sh532u_read_u8(0, (u16)ep_addr, &us_data);
358                 us_data = us_data | ep_data1;
359                 break;
360
361         default:
362                 err = 1;
363         }
364         if (!err)
365                 err = sh532u_write_u8((u16)ep_addr, us_data);
366         if (err)
367                 pr_err("Focuser: Failed to init!\n");
368 }
369
370 /* Write 2 byte data to the HVCA Drive IC by data type */
371 static void sh532u_hvca_wr2(u8 ep_type, u8 ep_data1, u8 ep_data2, u8 ep_addr)
372 {
373         int err = 0;
374         u8 uc_data1;
375         u8 uc_data2;
376         u16 us_data;
377
378         switch (ep_type & 0xF0) {
379         case DIRECT_MODE:
380                 us_data = (((u16)ep_data1 << 8) & 0xFF00) |
381                         ((u16)ep_data2 & 0x00FF);
382                 break;
383
384         case INDIRECT_EEPROM:
385                 err = sh532u_read_u8(0x50, (u16)ep_data1, &uc_data1);
386                 err = err | sh532u_read_u8(0x50, (u16)ep_data2, &uc_data2);
387                 us_data = (((u16)uc_data1 << 8) & 0xFF00) |
388                         ((u16)uc_data2 & 0x00FF);
389                 break;
390
391         case INDIRECT_HVCA:
392                 err = sh532u_read_u8(0, (u16)ep_data1, &uc_data1);
393                 err = err | sh532u_read_u8(0, (u16)ep_data2, &uc_data2);
394                 us_data = (((u16)uc_data1 << 8) & 0xFF00) |
395                         ((u16)uc_data2 & 0x00FF);
396                 break;
397
398         case MASK_AND:
399                 err = sh532u_read_u16((u16)ep_addr, &us_data);
400                 us_data = us_data & ((((u16)ep_data1 << 8) & 0xFF00) |
401                         ((u16)ep_data2 & 0x00FF));
402                 break;
403
404         case MASK_OR:
405                 err = sh532u_read_u16((u16)ep_addr, &us_data);
406                 us_data = us_data | ((((u16)ep_data1 << 8) & 0xFF00) |
407                         ((u16)ep_data2 & 0x00FF));
408                 break;
409
410         default:
411                 err = 1;
412         }
413         if (!err)
414                 err = sh532u_write_u16((u16)ep_addr, us_data);
415         if (err)
416                 pr_err("Focuser: Failed to init!\n");
417 }
418
419 static void init_driver(void)
420 {
421         int eeprom_addr;
422         unsigned int eeprom_data;
423         u8 ep_addr, ep_type, ep_data1, ep_data2, uc_data;
424
425         for (eeprom_addr = 0x30; eeprom_addr <= 0x013C; eeprom_addr += 4) {
426                 if (eeprom_addr > 0xff) {
427                         /* use hardcoded data instead */
428                         eeprom_data = a2buf[(eeprom_addr & 0xFF) / 4];
429                 } else {
430                         if (eeprom_read_u32(eeprom_addr & 0xFF, &eeprom_data))
431                                 pr_info("sh532u: cannot read eeprom\n");
432                 }
433
434                 /* HVCA Address to write eeprom Data1,Data2 by the Data type */
435                 ep_addr = (u8)(eeprom_data & 0x000000ff);
436                 ep_type = (u8)((eeprom_data & 0x0000ff00) >> 8);
437                 ep_data1 = (u8)((eeprom_data & 0x00ff0000) >> 16);
438                 ep_data2 = (u8)((eeprom_data & 0xff000000) >> 24);
439
440                 if (ep_addr == 0xFF)
441                         break;
442
443                 if (ep_addr == 0xDD) {
444                         mdelay((unsigned int)((ep_data1 << 8) | ep_data2));
445                 } else {
446                         if ((ep_type & 0x0F) == DATA_1BYTE) {
447                                 sh532u_hvca_wr1(ep_type, ep_data1, ep_addr);
448                         } else {
449                                 sh532u_hvca_wr2(ep_type,
450                                                 ep_data1,
451                                                 ep_data2,
452                                                 ep_addr);
453                         }
454                 }
455         }
456         msleep(300);
457
458         init_hvca_pos();
459 }
460
461
462 static int sh532u_set_position(struct sh532u_info *info, s16 position)
463 {
464         if (position > info->config.limit_high)
465                 return -1;
466         lens_move_pulse(position);
467         return 0;
468 }
469
470 static long sh532u_ioctl(
471         struct file *file,
472         unsigned int cmd,
473         unsigned long arg)
474 {
475         struct sh532u_info *info = file->private_data;
476
477         switch (cmd) {
478         case SH532U_IOCTL_GET_CONFIG:
479                 if (copy_to_user((void __user *) arg,
480                                  &info->config,
481                                  sizeof(info->config))) {
482                         pr_err("%s: 0x%x\n", __func__, __LINE__);
483                         return -EFAULT;
484                 }
485                 return 0;
486
487         case SH532U_IOCTL_SET_POSITION:
488                 return sh532u_set_position(info, (s16)(arg & 0xffff));
489
490         default:
491                 return -EINVAL;
492         }
493 }
494
495
496 static int sh532u_open(struct inode *inode, struct file *file)
497 {
498         pr_info("sh532 open\n");
499         file->private_data = info;
500         init_driver();
501         return 0;
502 }
503
504 int sh532u_release(struct inode *inode, struct file *file)
505 {
506         pr_info("sh532 release\n");
507         file->private_data = NULL;
508         return 0;
509 }
510
511
512 static const struct file_operations sh532u_fileops = {
513         .owner = THIS_MODULE,
514         .open = sh532u_open,
515         .unlocked_ioctl = sh532u_ioctl,
516         .release = sh532u_release,
517 };
518
519 static struct miscdevice sh532u_device = {
520         .minor = MISC_DYNAMIC_MINOR,
521         .name = "sh532u",
522         .fops = &sh532u_fileops,
523 };
524
525 static int sh532u_probe(
526         struct i2c_client *client,
527         const struct i2c_device_id *id)
528 {
529         int err;
530
531         pr_info("sh532u: probing sensor.\n");
532         info = kzalloc(sizeof(struct sh532u_info), GFP_KERNEL);
533         if (!info) {
534                 pr_err("sh532u: Unable to allocate memory!\n");
535                 return -ENOMEM;
536         }
537         err = misc_register(&sh532u_device);
538         if (err) {
539                 pr_err("sh532u: Unable to register misc device!\n");
540                 kfree(info);
541                 return err;
542         }
543         info->i2c_client = client;
544         info->config.settle_time = SETTLETIME_MS;
545         info->config.focal_length = FOCAL_LENGTH;
546         info->config.fnumber = FNUMBER;
547         info->config.pos_low = POS_LOW;
548         info->config.pos_high = POS_HIGH;
549         i2c_set_clientdata(client, info);
550         return 0;
551 }
552
553 static int sh532u_remove(struct i2c_client *client)
554 {
555         struct sh532u_info *info;
556         info = i2c_get_clientdata(client);
557         misc_deregister(&sh532u_device);
558         kfree(info);
559         return 0;
560 }
561
562 static const struct i2c_device_id sh532u_id[] = {
563         { "sh532u", 0 },
564         { },
565 };
566
567 MODULE_DEVICE_TABLE(i2c, sh532u_id);
568
569 static struct i2c_driver sh532u_i2c_driver = {
570         .driver = {
571                 .name = "sh532u",
572                 .owner = THIS_MODULE,
573         },
574         .probe = sh532u_probe,
575         .remove = sh532u_remove,
576         .id_table = sh532u_id,
577 };
578
579 static int __init sh532u_init(void)
580 {
581         return i2c_add_driver(&sh532u_i2c_driver);
582 }
583
584 static void __exit sh532u_exit(void)
585 {
586         i2c_del_driver(&sh532u_i2c_driver);
587 }
588
589 module_init(sh532u_init);
590 module_exit(sh532u_exit);
591