V4L/DVB (9222): S2API: Add Multiple-frontend on a single adapter support.
[linux-2.6.git] / drivers / media / video / mt9m001.c
1 /*
2  * Driver for MT9M001 CMOS Image Sensor from Micron
3  *
4  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
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
11 #include <linux/videodev2.h>
12 #include <linux/slab.h>
13 #include <linux/i2c.h>
14 #include <linux/log2.h>
15 #include <linux/gpio.h>
16
17 #include <media/v4l2-common.h>
18 #include <media/v4l2-chip-ident.h>
19 #include <media/soc_camera.h>
20
21 /* mt9m001 i2c address 0x5d
22  * The platform has to define i2c_board_info
23  * and call i2c_register_board_info() */
24
25 /* mt9m001 selected register addresses */
26 #define MT9M001_CHIP_VERSION            0x00
27 #define MT9M001_ROW_START               0x01
28 #define MT9M001_COLUMN_START            0x02
29 #define MT9M001_WINDOW_HEIGHT           0x03
30 #define MT9M001_WINDOW_WIDTH            0x04
31 #define MT9M001_HORIZONTAL_BLANKING     0x05
32 #define MT9M001_VERTICAL_BLANKING       0x06
33 #define MT9M001_OUTPUT_CONTROL          0x07
34 #define MT9M001_SHUTTER_WIDTH           0x09
35 #define MT9M001_FRAME_RESTART           0x0b
36 #define MT9M001_SHUTTER_DELAY           0x0c
37 #define MT9M001_RESET                   0x0d
38 #define MT9M001_READ_OPTIONS1           0x1e
39 #define MT9M001_READ_OPTIONS2           0x20
40 #define MT9M001_GLOBAL_GAIN             0x35
41 #define MT9M001_CHIP_ENABLE             0xF1
42
43 static const struct soc_camera_data_format mt9m001_colour_formats[] = {
44         /* Order important: first natively supported,
45          * second supported with a GPIO extender */
46         {
47                 .name           = "Bayer (sRGB) 10 bit",
48                 .depth          = 10,
49                 .fourcc         = V4L2_PIX_FMT_SBGGR16,
50                 .colorspace     = V4L2_COLORSPACE_SRGB,
51         }, {
52                 .name           = "Bayer (sRGB) 8 bit",
53                 .depth          = 8,
54                 .fourcc         = V4L2_PIX_FMT_SBGGR8,
55                 .colorspace     = V4L2_COLORSPACE_SRGB,
56         }
57 };
58
59 static const struct soc_camera_data_format mt9m001_monochrome_formats[] = {
60         /* Order important - see above */
61         {
62                 .name           = "Monochrome 10 bit",
63                 .depth          = 10,
64                 .fourcc         = V4L2_PIX_FMT_Y16,
65         }, {
66                 .name           = "Monochrome 8 bit",
67                 .depth          = 8,
68                 .fourcc         = V4L2_PIX_FMT_GREY,
69         },
70 };
71
72 struct mt9m001 {
73         struct i2c_client *client;
74         struct soc_camera_device icd;
75         int model;      /* V4L2_IDENT_MT9M001* codes from v4l2-chip-ident.h */
76         int switch_gpio;
77         unsigned char autoexposure;
78         unsigned char datawidth;
79 };
80
81 static int reg_read(struct soc_camera_device *icd, const u8 reg)
82 {
83         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
84         struct i2c_client *client = mt9m001->client;
85         s32 data = i2c_smbus_read_word_data(client, reg);
86         return data < 0 ? data : swab16(data);
87 }
88
89 static int reg_write(struct soc_camera_device *icd, const u8 reg,
90                      const u16 data)
91 {
92         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
93         return i2c_smbus_write_word_data(mt9m001->client, reg, swab16(data));
94 }
95
96 static int reg_set(struct soc_camera_device *icd, const u8 reg,
97                    const u16 data)
98 {
99         int ret;
100
101         ret = reg_read(icd, reg);
102         if (ret < 0)
103                 return ret;
104         return reg_write(icd, reg, ret | data);
105 }
106
107 static int reg_clear(struct soc_camera_device *icd, const u8 reg,
108                      const u16 data)
109 {
110         int ret;
111
112         ret = reg_read(icd, reg);
113         if (ret < 0)
114                 return ret;
115         return reg_write(icd, reg, ret & ~data);
116 }
117
118 static int mt9m001_init(struct soc_camera_device *icd)
119 {
120         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
121         struct soc_camera_link *icl = mt9m001->client->dev.platform_data;
122         int ret;
123
124         dev_dbg(icd->vdev->parent, "%s\n", __func__);
125
126         if (icl->power) {
127                 ret = icl->power(&mt9m001->client->dev, 1);
128                 if (ret < 0) {
129                         dev_err(icd->vdev->parent,
130                                 "Platform failed to power-on the camera.\n");
131                         return ret;
132                 }
133         }
134
135         /* The camera could have been already on, we reset it additionally */
136         if (icl->reset)
137                 ret = icl->reset(&mt9m001->client->dev);
138         else
139                 ret = -ENODEV;
140
141         if (ret < 0) {
142                 /* Either no platform reset, or platform reset failed */
143                 ret = reg_write(icd, MT9M001_RESET, 1);
144                 if (!ret)
145                         ret = reg_write(icd, MT9M001_RESET, 0);
146         }
147         /* Disable chip, synchronous option update */
148         if (!ret)
149                 ret = reg_write(icd, MT9M001_OUTPUT_CONTROL, 0);
150
151         return ret;
152 }
153
154 static int mt9m001_release(struct soc_camera_device *icd)
155 {
156         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
157         struct soc_camera_link *icl = mt9m001->client->dev.platform_data;
158
159         /* Disable the chip */
160         reg_write(icd, MT9M001_OUTPUT_CONTROL, 0);
161
162         if (icl->power)
163                 icl->power(&mt9m001->client->dev, 0);
164
165         return 0;
166 }
167
168 static int mt9m001_start_capture(struct soc_camera_device *icd)
169 {
170         /* Switch to master "normal" mode */
171         if (reg_write(icd, MT9M001_OUTPUT_CONTROL, 2) < 0)
172                 return -EIO;
173         return 0;
174 }
175
176 static int mt9m001_stop_capture(struct soc_camera_device *icd)
177 {
178         /* Stop sensor readout */
179         if (reg_write(icd, MT9M001_OUTPUT_CONTROL, 0) < 0)
180                 return -EIO;
181         return 0;
182 }
183
184 static int bus_switch_request(struct mt9m001 *mt9m001,
185                               struct soc_camera_link *icl)
186 {
187 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
188         int ret;
189         unsigned int gpio = icl->gpio;
190
191         if (gpio_is_valid(gpio)) {
192                 /* We have a data bus switch. */
193                 ret = gpio_request(gpio, "mt9m001");
194                 if (ret < 0) {
195                         dev_err(&mt9m001->client->dev, "Cannot get GPIO %u\n",
196                                 gpio);
197                         return ret;
198                 }
199
200                 ret = gpio_direction_output(gpio, 0);
201                 if (ret < 0) {
202                         dev_err(&mt9m001->client->dev,
203                                 "Cannot set GPIO %u to output\n", gpio);
204                         gpio_free(gpio);
205                         return ret;
206                 }
207         }
208
209         mt9m001->switch_gpio = gpio;
210 #else
211         mt9m001->switch_gpio = -EINVAL;
212 #endif
213         return 0;
214 }
215
216 static void bus_switch_release(struct mt9m001 *mt9m001)
217 {
218 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
219         if (gpio_is_valid(mt9m001->switch_gpio))
220                 gpio_free(mt9m001->switch_gpio);
221 #endif
222 }
223
224 static int bus_switch_act(struct mt9m001 *mt9m001, int go8bit)
225 {
226 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
227         if (!gpio_is_valid(mt9m001->switch_gpio))
228                 return -ENODEV;
229
230         gpio_set_value_cansleep(mt9m001->switch_gpio, go8bit);
231         return 0;
232 #else
233         return -ENODEV;
234 #endif
235 }
236
237 static int bus_switch_possible(struct mt9m001 *mt9m001)
238 {
239 #ifdef CONFIG_MT9M001_PCA9536_SWITCH
240         return gpio_is_valid(mt9m001->switch_gpio);
241 #else
242         return 0;
243 #endif
244 }
245
246 static int mt9m001_set_bus_param(struct soc_camera_device *icd,
247                                  unsigned long flags)
248 {
249         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
250         unsigned int width_flag = flags & SOCAM_DATAWIDTH_MASK;
251         int ret;
252
253         /* Flags validity verified in test_bus_param */
254
255         if ((mt9m001->datawidth != 10 && (width_flag == SOCAM_DATAWIDTH_10)) ||
256             (mt9m001->datawidth != 9  && (width_flag == SOCAM_DATAWIDTH_9)) ||
257             (mt9m001->datawidth != 8  && (width_flag == SOCAM_DATAWIDTH_8))) {
258                 /* Well, we actually only can do 10 or 8 bits... */
259                 if (width_flag == SOCAM_DATAWIDTH_9)
260                         return -EINVAL;
261                 ret = bus_switch_act(mt9m001,
262                                      width_flag == SOCAM_DATAWIDTH_8);
263                 if (ret < 0)
264                         return ret;
265
266                 mt9m001->datawidth = width_flag == SOCAM_DATAWIDTH_8 ? 8 : 10;
267         }
268
269         return 0;
270 }
271
272 static unsigned long mt9m001_query_bus_param(struct soc_camera_device *icd)
273 {
274         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
275         unsigned int width_flag = SOCAM_DATAWIDTH_10;
276
277         if (bus_switch_possible(mt9m001))
278                 width_flag |= SOCAM_DATAWIDTH_8;
279
280         /* MT9M001 has all capture_format parameters fixed */
281         return SOCAM_PCLK_SAMPLE_RISING |
282                 SOCAM_HSYNC_ACTIVE_HIGH |
283                 SOCAM_VSYNC_ACTIVE_HIGH |
284                 SOCAM_MASTER |
285                 width_flag;
286 }
287
288 static int mt9m001_set_fmt_cap(struct soc_camera_device *icd,
289                 __u32 pixfmt, struct v4l2_rect *rect)
290 {
291         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
292         int ret;
293         const u16 hblank = 9, vblank = 25;
294
295         /* Blanking and start values - default... */
296         ret = reg_write(icd, MT9M001_HORIZONTAL_BLANKING, hblank);
297         if (!ret)
298                 ret = reg_write(icd, MT9M001_VERTICAL_BLANKING, vblank);
299
300         /* The caller provides a supported format, as verified per
301          * call to icd->try_fmt_cap() */
302         if (!ret)
303                 ret = reg_write(icd, MT9M001_COLUMN_START, rect->left);
304         if (!ret)
305                 ret = reg_write(icd, MT9M001_ROW_START, rect->top);
306         if (!ret)
307                 ret = reg_write(icd, MT9M001_WINDOW_WIDTH, rect->width - 1);
308         if (!ret)
309                 ret = reg_write(icd, MT9M001_WINDOW_HEIGHT,
310                                 rect->height + icd->y_skip_top - 1);
311         if (!ret && mt9m001->autoexposure) {
312                 ret = reg_write(icd, MT9M001_SHUTTER_WIDTH,
313                                 rect->height + icd->y_skip_top + vblank);
314                 if (!ret) {
315                         const struct v4l2_queryctrl *qctrl =
316                                 soc_camera_find_qctrl(icd->ops,
317                                                       V4L2_CID_EXPOSURE);
318                         icd->exposure = (524 + (rect->height + icd->y_skip_top +
319                                                 vblank - 1) *
320                                          (qctrl->maximum - qctrl->minimum)) /
321                                 1048 + qctrl->minimum;
322                 }
323         }
324
325         return ret;
326 }
327
328 static int mt9m001_try_fmt_cap(struct soc_camera_device *icd,
329                                struct v4l2_format *f)
330 {
331         if (f->fmt.pix.height < 32 + icd->y_skip_top)
332                 f->fmt.pix.height = 32 + icd->y_skip_top;
333         if (f->fmt.pix.height > 1024 + icd->y_skip_top)
334                 f->fmt.pix.height = 1024 + icd->y_skip_top;
335         if (f->fmt.pix.width < 48)
336                 f->fmt.pix.width = 48;
337         if (f->fmt.pix.width > 1280)
338                 f->fmt.pix.width = 1280;
339         f->fmt.pix.width &= ~0x01; /* has to be even, unsure why was ~3 */
340
341         return 0;
342 }
343
344 static int mt9m001_get_chip_id(struct soc_camera_device *icd,
345                                struct v4l2_chip_ident *id)
346 {
347         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
348
349         if (id->match_type != V4L2_CHIP_MATCH_I2C_ADDR)
350                 return -EINVAL;
351
352         if (id->match_chip != mt9m001->client->addr)
353                 return -ENODEV;
354
355         id->ident       = mt9m001->model;
356         id->revision    = 0;
357
358         return 0;
359 }
360
361 #ifdef CONFIG_VIDEO_ADV_DEBUG
362 static int mt9m001_get_register(struct soc_camera_device *icd,
363                                 struct v4l2_register *reg)
364 {
365         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
366
367         if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
368                 return -EINVAL;
369
370         if (reg->match_chip != mt9m001->client->addr)
371                 return -ENODEV;
372
373         reg->val = reg_read(icd, reg->reg);
374
375         if (reg->val > 0xffff)
376                 return -EIO;
377
378         return 0;
379 }
380
381 static int mt9m001_set_register(struct soc_camera_device *icd,
382                                 struct v4l2_register *reg)
383 {
384         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
385
386         if (reg->match_type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
387                 return -EINVAL;
388
389         if (reg->match_chip != mt9m001->client->addr)
390                 return -ENODEV;
391
392         if (reg_write(icd, reg->reg, reg->val) < 0)
393                 return -EIO;
394
395         return 0;
396 }
397 #endif
398
399 static const struct v4l2_queryctrl mt9m001_controls[] = {
400         {
401                 .id             = V4L2_CID_VFLIP,
402                 .type           = V4L2_CTRL_TYPE_BOOLEAN,
403                 .name           = "Flip Vertically",
404                 .minimum        = 0,
405                 .maximum        = 1,
406                 .step           = 1,
407                 .default_value  = 0,
408         }, {
409                 .id             = V4L2_CID_GAIN,
410                 .type           = V4L2_CTRL_TYPE_INTEGER,
411                 .name           = "Gain",
412                 .minimum        = 0,
413                 .maximum        = 127,
414                 .step           = 1,
415                 .default_value  = 64,
416                 .flags          = V4L2_CTRL_FLAG_SLIDER,
417         }, {
418                 .id             = V4L2_CID_EXPOSURE,
419                 .type           = V4L2_CTRL_TYPE_INTEGER,
420                 .name           = "Exposure",
421                 .minimum        = 1,
422                 .maximum        = 255,
423                 .step           = 1,
424                 .default_value  = 255,
425                 .flags          = V4L2_CTRL_FLAG_SLIDER,
426         }, {
427                 .id             = V4L2_CID_EXPOSURE_AUTO,
428                 .type           = V4L2_CTRL_TYPE_BOOLEAN,
429                 .name           = "Automatic Exposure",
430                 .minimum        = 0,
431                 .maximum        = 1,
432                 .step           = 1,
433                 .default_value  = 1,
434         }
435 };
436
437 static int mt9m001_video_probe(struct soc_camera_device *);
438 static void mt9m001_video_remove(struct soc_camera_device *);
439 static int mt9m001_get_control(struct soc_camera_device *, struct v4l2_control *);
440 static int mt9m001_set_control(struct soc_camera_device *, struct v4l2_control *);
441
442 static struct soc_camera_ops mt9m001_ops = {
443         .owner                  = THIS_MODULE,
444         .probe                  = mt9m001_video_probe,
445         .remove                 = mt9m001_video_remove,
446         .init                   = mt9m001_init,
447         .release                = mt9m001_release,
448         .start_capture          = mt9m001_start_capture,
449         .stop_capture           = mt9m001_stop_capture,
450         .set_fmt_cap            = mt9m001_set_fmt_cap,
451         .try_fmt_cap            = mt9m001_try_fmt_cap,
452         .set_bus_param          = mt9m001_set_bus_param,
453         .query_bus_param        = mt9m001_query_bus_param,
454         .controls               = mt9m001_controls,
455         .num_controls           = ARRAY_SIZE(mt9m001_controls),
456         .get_control            = mt9m001_get_control,
457         .set_control            = mt9m001_set_control,
458         .get_chip_id            = mt9m001_get_chip_id,
459 #ifdef CONFIG_VIDEO_ADV_DEBUG
460         .get_register           = mt9m001_get_register,
461         .set_register           = mt9m001_set_register,
462 #endif
463 };
464
465 static int mt9m001_get_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)
466 {
467         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
468         int data;
469
470         switch (ctrl->id) {
471         case V4L2_CID_VFLIP:
472                 data = reg_read(icd, MT9M001_READ_OPTIONS2);
473                 if (data < 0)
474                         return -EIO;
475                 ctrl->value = !!(data & 0x8000);
476                 break;
477         case V4L2_CID_EXPOSURE_AUTO:
478                 ctrl->value = mt9m001->autoexposure;
479                 break;
480         }
481         return 0;
482 }
483
484 static int mt9m001_set_control(struct soc_camera_device *icd, struct v4l2_control *ctrl)
485 {
486         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
487         const struct v4l2_queryctrl *qctrl;
488         int data;
489
490         qctrl = soc_camera_find_qctrl(&mt9m001_ops, ctrl->id);
491
492         if (!qctrl)
493                 return -EINVAL;
494
495         switch (ctrl->id) {
496         case V4L2_CID_VFLIP:
497                 if (ctrl->value)
498                         data = reg_set(icd, MT9M001_READ_OPTIONS2, 0x8000);
499                 else
500                         data = reg_clear(icd, MT9M001_READ_OPTIONS2, 0x8000);
501                 if (data < 0)
502                         return -EIO;
503                 break;
504         case V4L2_CID_GAIN:
505                 if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum)
506                         return -EINVAL;
507                 /* See Datasheet Table 7, Gain settings. */
508                 if (ctrl->value <= qctrl->default_value) {
509                         /* Pack it into 0..1 step 0.125, register values 0..8 */
510                         unsigned long range = qctrl->default_value - qctrl->minimum;
511                         data = ((ctrl->value - qctrl->minimum) * 8 + range / 2) / range;
512
513                         dev_dbg(&icd->dev, "Setting gain %d\n", data);
514                         data = reg_write(icd, MT9M001_GLOBAL_GAIN, data);
515                         if (data < 0)
516                                 return -EIO;
517                 } else {
518                         /* Pack it into 1.125..15 variable step, register values 9..67 */
519                         /* We assume qctrl->maximum - qctrl->default_value - 1 > 0 */
520                         unsigned long range = qctrl->maximum - qctrl->default_value - 1;
521                         unsigned long gain = ((ctrl->value - qctrl->default_value - 1) *
522                                                111 + range / 2) / range + 9;
523
524                         if (gain <= 32)
525                                 data = gain;
526                         else if (gain <= 64)
527                                 data = ((gain - 32) * 16 + 16) / 32 + 80;
528                         else
529                                 data = ((gain - 64) * 7 + 28) / 56 + 96;
530
531                         dev_dbg(&icd->dev, "Setting gain from %d to %d\n",
532                                  reg_read(icd, MT9M001_GLOBAL_GAIN), data);
533                         data = reg_write(icd, MT9M001_GLOBAL_GAIN, data);
534                         if (data < 0)
535                                 return -EIO;
536                 }
537
538                 /* Success */
539                 icd->gain = ctrl->value;
540                 break;
541         case V4L2_CID_EXPOSURE:
542                 /* mt9m001 has maximum == default */
543                 if (ctrl->value > qctrl->maximum || ctrl->value < qctrl->minimum)
544                         return -EINVAL;
545                 else {
546                         unsigned long range = qctrl->maximum - qctrl->minimum;
547                         unsigned long shutter = ((ctrl->value - qctrl->minimum) * 1048 +
548                                                  range / 2) / range + 1;
549
550                         dev_dbg(&icd->dev, "Setting shutter width from %d to %lu\n",
551                                  reg_read(icd, MT9M001_SHUTTER_WIDTH), shutter);
552                         if (reg_write(icd, MT9M001_SHUTTER_WIDTH, shutter) < 0)
553                                 return -EIO;
554                         icd->exposure = ctrl->value;
555                         mt9m001->autoexposure = 0;
556                 }
557                 break;
558         case V4L2_CID_EXPOSURE_AUTO:
559                 if (ctrl->value) {
560                         const u16 vblank = 25;
561                         if (reg_write(icd, MT9M001_SHUTTER_WIDTH, icd->height +
562                                       icd->y_skip_top + vblank) < 0)
563                                 return -EIO;
564                         qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
565                         icd->exposure = (524 + (icd->height + icd->y_skip_top + vblank - 1) *
566                                          (qctrl->maximum - qctrl->minimum)) /
567                                 1048 + qctrl->minimum;
568                         mt9m001->autoexposure = 1;
569                 } else
570                         mt9m001->autoexposure = 0;
571                 break;
572         }
573         return 0;
574 }
575
576 /* Interface active, can use i2c. If it fails, it can indeed mean, that
577  * this wasn't our capture interface, so, we wait for the right one */
578 static int mt9m001_video_probe(struct soc_camera_device *icd)
579 {
580         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
581         s32 data;
582         int ret;
583
584         /* We must have a parent by now. And it cannot be a wrong one.
585          * So this entire test is completely redundant. */
586         if (!icd->dev.parent ||
587             to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
588                 return -ENODEV;
589
590         /* Enable the chip */
591         data = reg_write(&mt9m001->icd, MT9M001_CHIP_ENABLE, 1);
592         dev_dbg(&icd->dev, "write: %d\n", data);
593
594         /* Read out the chip version register */
595         data = reg_read(icd, MT9M001_CHIP_VERSION);
596
597         /* must be 0x8411 or 0x8421 for colour sensor and 8431 for bw */
598         switch (data) {
599         case 0x8411:
600         case 0x8421:
601                 mt9m001->model = V4L2_IDENT_MT9M001C12ST;
602                 icd->formats = mt9m001_colour_formats;
603                 if (mt9m001->client->dev.platform_data)
604                         icd->num_formats = ARRAY_SIZE(mt9m001_colour_formats);
605                 else
606                         icd->num_formats = 1;
607                 break;
608         case 0x8431:
609                 mt9m001->model = V4L2_IDENT_MT9M001C12STM;
610                 icd->formats = mt9m001_monochrome_formats;
611                 if (mt9m001->client->dev.platform_data)
612                         icd->num_formats = ARRAY_SIZE(mt9m001_monochrome_formats);
613                 else
614                         icd->num_formats = 1;
615                 break;
616         default:
617                 ret = -ENODEV;
618                 dev_err(&icd->dev,
619                         "No MT9M001 chip detected, register read %x\n", data);
620                 goto ei2c;
621         }
622
623         dev_info(&icd->dev, "Detected a MT9M001 chip ID %x (%s)\n", data,
624                  data == 0x8431 ? "C12STM" : "C12ST");
625
626         /* Now that we know the model, we can start video */
627         ret = soc_camera_video_start(icd);
628         if (ret)
629                 goto eisis;
630
631         return 0;
632
633 eisis:
634 ei2c:
635         return ret;
636 }
637
638 static void mt9m001_video_remove(struct soc_camera_device *icd)
639 {
640         struct mt9m001 *mt9m001 = container_of(icd, struct mt9m001, icd);
641
642         dev_dbg(&icd->dev, "Video %x removed: %p, %p\n", mt9m001->client->addr,
643                 mt9m001->icd.dev.parent, mt9m001->icd.vdev);
644         soc_camera_video_stop(&mt9m001->icd);
645 }
646
647 static int mt9m001_probe(struct i2c_client *client,
648                          const struct i2c_device_id *did)
649 {
650         struct mt9m001 *mt9m001;
651         struct soc_camera_device *icd;
652         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
653         struct soc_camera_link *icl = client->dev.platform_data;
654         int ret;
655
656         if (!icl) {
657                 dev_err(&client->dev, "MT9M001 driver needs platform data\n");
658                 return -EINVAL;
659         }
660
661         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
662                 dev_warn(&adapter->dev,
663                          "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
664                 return -EIO;
665         }
666
667         mt9m001 = kzalloc(sizeof(struct mt9m001), GFP_KERNEL);
668         if (!mt9m001)
669                 return -ENOMEM;
670
671         mt9m001->client = client;
672         i2c_set_clientdata(client, mt9m001);
673
674         /* Second stage probe - when a capture adapter is there */
675         icd = &mt9m001->icd;
676         icd->ops        = &mt9m001_ops;
677         icd->control    = &client->dev;
678         icd->x_min      = 20;
679         icd->y_min      = 12;
680         icd->x_current  = 20;
681         icd->y_current  = 12;
682         icd->width_min  = 48;
683         icd->width_max  = 1280;
684         icd->height_min = 32;
685         icd->height_max = 1024;
686         icd->y_skip_top = 1;
687         icd->iface      = icl->bus_id;
688         /* Default datawidth - this is the only width this camera (normally)
689          * supports. It is only with extra logic that it can support
690          * other widths. Therefore it seems to be a sensible default. */
691         mt9m001->datawidth = 10;
692         /* Simulated autoexposure. If enabled, we calculate shutter width
693          * ourselves in the driver based on vertical blanking and frame width */
694         mt9m001->autoexposure = 1;
695
696         ret = bus_switch_request(mt9m001, icl);
697         if (ret)
698                 goto eswinit;
699
700         ret = soc_camera_device_register(icd);
701         if (ret)
702                 goto eisdr;
703
704         return 0;
705
706 eisdr:
707         bus_switch_release(mt9m001);
708 eswinit:
709         kfree(mt9m001);
710         return ret;
711 }
712
713 static int mt9m001_remove(struct i2c_client *client)
714 {
715         struct mt9m001 *mt9m001 = i2c_get_clientdata(client);
716
717         soc_camera_device_unregister(&mt9m001->icd);
718         bus_switch_release(mt9m001);
719         kfree(mt9m001);
720
721         return 0;
722 }
723
724 static const struct i2c_device_id mt9m001_id[] = {
725         { "mt9m001", 0 },
726         { }
727 };
728 MODULE_DEVICE_TABLE(i2c, mt9m001_id);
729
730 static struct i2c_driver mt9m001_i2c_driver = {
731         .driver = {
732                 .name = "mt9m001",
733         },
734         .probe          = mt9m001_probe,
735         .remove         = mt9m001_remove,
736         .id_table       = mt9m001_id,
737 };
738
739 static int __init mt9m001_mod_init(void)
740 {
741         return i2c_add_driver(&mt9m001_i2c_driver);
742 }
743
744 static void __exit mt9m001_mod_exit(void)
745 {
746         i2c_del_driver(&mt9m001_i2c_driver);
747 }
748
749 module_init(mt9m001_mod_init);
750 module_exit(mt9m001_mod_exit);
751
752 MODULE_DESCRIPTION("Micron MT9M001 Camera driver");
753 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
754 MODULE_LICENSE("GPL");