1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Driver for MT9M111/MT9M112/MT9M131 CMOS Image Sensor from Micron/Aptina
4 *
5 * Copyright (C) 2008, Robert Jarzmik <robert.jarzmik@free.fr>
6 */
7 #include <linux/clk.h>
8 #include <linux/videodev2.h>
9 #include <linux/slab.h>
10 #include <linux/i2c.h>
11 #include <linux/log2.h>
12 #include <linux/delay.h>
13 #include <linux/regulator/consumer.h>
14 #include <linux/v4l2-mediabus.h>
15 #include <linux/module.h>
16 #include <linux/property.h>
17
18 #include <media/v4l2-async.h>
19 #include <media/v4l2-common.h>
20 #include <media/v4l2-ctrls.h>
21 #include <media/v4l2-device.h>
22 #include <media/v4l2-event.h>
23 #include <media/v4l2-fwnode.h>
24
25 /*
26 * MT9M111, MT9M112 and MT9M131:
27 * i2c address is 0x48 or 0x5d (depending on SADDR pin)
28 * The platform has to define struct i2c_board_info objects and link to them
29 * from struct soc_camera_host_desc
30 */
31
32 /*
33 * Sensor core register addresses (0x000..0x0ff)
34 */
35 #define MT9M111_CHIP_VERSION 0x000
36 #define MT9M111_ROW_START 0x001
37 #define MT9M111_COLUMN_START 0x002
38 #define MT9M111_WINDOW_HEIGHT 0x003
39 #define MT9M111_WINDOW_WIDTH 0x004
40 #define MT9M111_HORIZONTAL_BLANKING_B 0x005
41 #define MT9M111_VERTICAL_BLANKING_B 0x006
42 #define MT9M111_HORIZONTAL_BLANKING_A 0x007
43 #define MT9M111_VERTICAL_BLANKING_A 0x008
44 #define MT9M111_SHUTTER_WIDTH 0x009
45 #define MT9M111_ROW_SPEED 0x00a
46 #define MT9M111_EXTRA_DELAY 0x00b
47 #define MT9M111_SHUTTER_DELAY 0x00c
48 #define MT9M111_RESET 0x00d
49 #define MT9M111_READ_MODE_B 0x020
50 #define MT9M111_READ_MODE_A 0x021
51 #define MT9M111_FLASH_CONTROL 0x023
52 #define MT9M111_GREEN1_GAIN 0x02b
53 #define MT9M111_BLUE_GAIN 0x02c
54 #define MT9M111_RED_GAIN 0x02d
55 #define MT9M111_GREEN2_GAIN 0x02e
56 #define MT9M111_GLOBAL_GAIN 0x02f
57 #define MT9M111_CONTEXT_CONTROL 0x0c8
58 #define MT9M111_PAGE_MAP 0x0f0
59 #define MT9M111_BYTE_WISE_ADDR 0x0f1
60
61 #define MT9M111_RESET_SYNC_CHANGES (1 << 15)
62 #define MT9M111_RESET_RESTART_BAD_FRAME (1 << 9)
63 #define MT9M111_RESET_SHOW_BAD_FRAMES (1 << 8)
64 #define MT9M111_RESET_RESET_SOC (1 << 5)
65 #define MT9M111_RESET_OUTPUT_DISABLE (1 << 4)
66 #define MT9M111_RESET_CHIP_ENABLE (1 << 3)
67 #define MT9M111_RESET_ANALOG_STANDBY (1 << 2)
68 #define MT9M111_RESET_RESTART_FRAME (1 << 1)
69 #define MT9M111_RESET_RESET_MODE (1 << 0)
70
71 #define MT9M111_RM_FULL_POWER_RD (0 << 10)
72 #define MT9M111_RM_LOW_POWER_RD (1 << 10)
73 #define MT9M111_RM_COL_SKIP_4X (1 << 5)
74 #define MT9M111_RM_ROW_SKIP_4X (1 << 4)
75 #define MT9M111_RM_COL_SKIP_2X (1 << 3)
76 #define MT9M111_RM_ROW_SKIP_2X (1 << 2)
77 #define MT9M111_RMB_MIRROR_COLS (1 << 1)
78 #define MT9M111_RMB_MIRROR_ROWS (1 << 0)
79 #define MT9M111_CTXT_CTRL_RESTART (1 << 15)
80 #define MT9M111_CTXT_CTRL_DEFECTCOR_B (1 << 12)
81 #define MT9M111_CTXT_CTRL_RESIZE_B (1 << 10)
82 #define MT9M111_CTXT_CTRL_CTRL2_B (1 << 9)
83 #define MT9M111_CTXT_CTRL_GAMMA_B (1 << 8)
84 #define MT9M111_CTXT_CTRL_XENON_EN (1 << 7)
85 #define MT9M111_CTXT_CTRL_READ_MODE_B (1 << 3)
86 #define MT9M111_CTXT_CTRL_LED_FLASH_EN (1 << 2)
87 #define MT9M111_CTXT_CTRL_VBLANK_SEL_B (1 << 1)
88 #define MT9M111_CTXT_CTRL_HBLANK_SEL_B (1 << 0)
89
90 /*
91 * Colorpipe register addresses (0x100..0x1ff)
92 */
93 #define MT9M111_OPER_MODE_CTRL 0x106
94 #define MT9M111_OUTPUT_FORMAT_CTRL 0x108
95 #define MT9M111_TPG_CTRL 0x148
96 #define MT9M111_REDUCER_XZOOM_B 0x1a0
97 #define MT9M111_REDUCER_XSIZE_B 0x1a1
98 #define MT9M111_REDUCER_YZOOM_B 0x1a3
99 #define MT9M111_REDUCER_YSIZE_B 0x1a4
100 #define MT9M111_REDUCER_XZOOM_A 0x1a6
101 #define MT9M111_REDUCER_XSIZE_A 0x1a7
102 #define MT9M111_REDUCER_YZOOM_A 0x1a9
103 #define MT9M111_REDUCER_YSIZE_A 0x1aa
104 #define MT9M111_EFFECTS_MODE 0x1e2
105
106 #define MT9M111_OUTPUT_FORMAT_CTRL2_A 0x13a
107 #define MT9M111_OUTPUT_FORMAT_CTRL2_B 0x19b
108
109 #define MT9M111_OPMODE_AUTOEXPO_EN (1 << 14)
110 #define MT9M111_OPMODE_AUTOWHITEBAL_EN (1 << 1)
111 #define MT9M111_OUTFMT_FLIP_BAYER_COL (1 << 9)
112 #define MT9M111_OUTFMT_FLIP_BAYER_ROW (1 << 8)
113 #define MT9M111_OUTFMT_PROCESSED_BAYER (1 << 14)
114 #define MT9M111_OUTFMT_BYPASS_IFP (1 << 10)
115 #define MT9M111_OUTFMT_INV_PIX_CLOCK (1 << 9)
116 #define MT9M111_OUTFMT_RGB (1 << 8)
117 #define MT9M111_OUTFMT_RGB565 (0 << 6)
118 #define MT9M111_OUTFMT_RGB555 (1 << 6)
119 #define MT9M111_OUTFMT_RGB444x (2 << 6)
120 #define MT9M111_OUTFMT_RGBx444 (3 << 6)
121 #define MT9M111_OUTFMT_TST_RAMP_OFF (0 << 4)
122 #define MT9M111_OUTFMT_TST_RAMP_COL (1 << 4)
123 #define MT9M111_OUTFMT_TST_RAMP_ROW (2 << 4)
124 #define MT9M111_OUTFMT_TST_RAMP_FRAME (3 << 4)
125 #define MT9M111_OUTFMT_SHIFT_3_UP (1 << 3)
126 #define MT9M111_OUTFMT_AVG_CHROMA (1 << 2)
127 #define MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN (1 << 1)
128 #define MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B (1 << 0)
129 #define MT9M111_TPG_SEL_MASK GENMASK(2, 0)
130 #define MT9M111_EFFECTS_MODE_MASK GENMASK(2, 0)
131 #define MT9M111_RM_PWR_MASK BIT(10)
132 #define MT9M111_RM_SKIP2_MASK GENMASK(3, 2)
133
134 /*
135 * Camera control register addresses (0x200..0x2ff not implemented)
136 */
137
138 #define reg_read(reg) mt9m111_reg_read(client, MT9M111_##reg)
139 #define reg_write(reg, val) mt9m111_reg_write(client, MT9M111_##reg, (val))
140 #define reg_set(reg, val) mt9m111_reg_set(client, MT9M111_##reg, (val))
141 #define reg_clear(reg, val) mt9m111_reg_clear(client, MT9M111_##reg, (val))
142 #define reg_mask(reg, val, mask) mt9m111_reg_mask(client, MT9M111_##reg, \
143 (val), (mask))
144
145 #define MT9M111_MIN_DARK_ROWS 8
146 #define MT9M111_MIN_DARK_COLS 26
147 #define MT9M111_MAX_HEIGHT 1024
148 #define MT9M111_MAX_WIDTH 1280
149
150 struct mt9m111_context {
151 u16 read_mode;
152 u16 blanking_h;
153 u16 blanking_v;
154 u16 reducer_xzoom;
155 u16 reducer_yzoom;
156 u16 reducer_xsize;
157 u16 reducer_ysize;
158 u16 output_fmt_ctrl2;
159 u16 control;
160 };
161
162 static struct mt9m111_context context_a = {
163 .read_mode = MT9M111_READ_MODE_A,
164 .blanking_h = MT9M111_HORIZONTAL_BLANKING_A,
165 .blanking_v = MT9M111_VERTICAL_BLANKING_A,
166 .reducer_xzoom = MT9M111_REDUCER_XZOOM_A,
167 .reducer_yzoom = MT9M111_REDUCER_YZOOM_A,
168 .reducer_xsize = MT9M111_REDUCER_XSIZE_A,
169 .reducer_ysize = MT9M111_REDUCER_YSIZE_A,
170 .output_fmt_ctrl2 = MT9M111_OUTPUT_FORMAT_CTRL2_A,
171 .control = MT9M111_CTXT_CTRL_RESTART,
172 };
173
174 static struct mt9m111_context context_b = {
175 .read_mode = MT9M111_READ_MODE_B,
176 .blanking_h = MT9M111_HORIZONTAL_BLANKING_B,
177 .blanking_v = MT9M111_VERTICAL_BLANKING_B,
178 .reducer_xzoom = MT9M111_REDUCER_XZOOM_B,
179 .reducer_yzoom = MT9M111_REDUCER_YZOOM_B,
180 .reducer_xsize = MT9M111_REDUCER_XSIZE_B,
181 .reducer_ysize = MT9M111_REDUCER_YSIZE_B,
182 .output_fmt_ctrl2 = MT9M111_OUTPUT_FORMAT_CTRL2_B,
183 .control = MT9M111_CTXT_CTRL_RESTART |
184 MT9M111_CTXT_CTRL_DEFECTCOR_B | MT9M111_CTXT_CTRL_RESIZE_B |
185 MT9M111_CTXT_CTRL_CTRL2_B | MT9M111_CTXT_CTRL_GAMMA_B |
186 MT9M111_CTXT_CTRL_READ_MODE_B | MT9M111_CTXT_CTRL_VBLANK_SEL_B |
187 MT9M111_CTXT_CTRL_HBLANK_SEL_B,
188 };
189
190 /* MT9M111 has only one fixed colorspace per pixelcode */
191 struct mt9m111_datafmt {
192 u32 code;
193 enum v4l2_colorspace colorspace;
194 };
195
196 static const struct mt9m111_datafmt mt9m111_colour_fmts[] = {
197 {MEDIA_BUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_SRGB},
198 {MEDIA_BUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_SRGB},
199 {MEDIA_BUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_SRGB},
200 {MEDIA_BUS_FMT_VYUY8_2X8, V4L2_COLORSPACE_SRGB},
201 {MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
202 {MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE, V4L2_COLORSPACE_SRGB},
203 {MEDIA_BUS_FMT_RGB565_2X8_LE, V4L2_COLORSPACE_SRGB},
204 {MEDIA_BUS_FMT_RGB565_2X8_BE, V4L2_COLORSPACE_SRGB},
205 {MEDIA_BUS_FMT_BGR565_2X8_LE, V4L2_COLORSPACE_SRGB},
206 {MEDIA_BUS_FMT_BGR565_2X8_BE, V4L2_COLORSPACE_SRGB},
207 {MEDIA_BUS_FMT_SBGGR8_1X8, V4L2_COLORSPACE_SRGB},
208 {MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
209 };
210
211 enum mt9m111_mode_id {
212 MT9M111_MODE_SXGA_8FPS,
213 MT9M111_MODE_SXGA_15FPS,
214 MT9M111_MODE_QSXGA_30FPS,
215 MT9M111_NUM_MODES,
216 };
217
218 struct mt9m111_mode_info {
219 unsigned int sensor_w;
220 unsigned int sensor_h;
221 unsigned int max_image_w;
222 unsigned int max_image_h;
223 unsigned int max_fps;
224 unsigned int reg_val;
225 unsigned int reg_mask;
226 };
227
228 struct mt9m111 {
229 struct v4l2_subdev subdev;
230 struct v4l2_ctrl_handler hdl;
231 struct v4l2_ctrl *gain;
232 struct mt9m111_context *ctx;
233 struct v4l2_rect rect; /* cropping rectangle */
234 struct clk *clk;
235 unsigned int width; /* output */
236 unsigned int height; /* sizes */
237 struct v4l2_fract frame_interval;
238 const struct mt9m111_mode_info *current_mode;
239 struct mutex power_lock; /* lock to protect power_count */
240 int power_count;
241 const struct mt9m111_datafmt *fmt;
242 int lastpage; /* PageMap cache value */
243 struct regulator *regulator;
244 bool is_streaming;
245 /* user point of view - 0: falling 1: rising edge */
246 unsigned int pclk_sample:1;
247 #ifdef CONFIG_MEDIA_CONTROLLER
248 struct media_pad pad;
249 #endif
250 };
251
252 static const struct mt9m111_mode_info mt9m111_mode_data[MT9M111_NUM_MODES] = {
253 [MT9M111_MODE_SXGA_8FPS] = {
254 .sensor_w = 1280,
255 .sensor_h = 1024,
256 .max_image_w = 1280,
257 .max_image_h = 1024,
258 .max_fps = 8,
259 .reg_val = MT9M111_RM_LOW_POWER_RD,
260 .reg_mask = MT9M111_RM_PWR_MASK | MT9M111_RM_SKIP2_MASK,
261 },
262 [MT9M111_MODE_SXGA_15FPS] = {
263 .sensor_w = 1280,
264 .sensor_h = 1024,
265 .max_image_w = 1280,
266 .max_image_h = 1024,
267 .max_fps = 15,
268 .reg_val = MT9M111_RM_FULL_POWER_RD,
269 .reg_mask = MT9M111_RM_PWR_MASK | MT9M111_RM_SKIP2_MASK,
270 },
271 [MT9M111_MODE_QSXGA_30FPS] = {
272 .sensor_w = 1280,
273 .sensor_h = 1024,
274 .max_image_w = 640,
275 .max_image_h = 512,
276 .max_fps = 30,
277 .reg_val = MT9M111_RM_LOW_POWER_RD | MT9M111_RM_COL_SKIP_2X |
278 MT9M111_RM_ROW_SKIP_2X,
279 .reg_mask = MT9M111_RM_PWR_MASK | MT9M111_RM_SKIP2_MASK,
280 },
281 };
282
283 /* Find a data format by a pixel code */
mt9m111_find_datafmt(struct mt9m111 * mt9m111,u32 code)284 static const struct mt9m111_datafmt *mt9m111_find_datafmt(struct mt9m111 *mt9m111,
285 u32 code)
286 {
287 int i;
288 for (i = 0; i < ARRAY_SIZE(mt9m111_colour_fmts); i++)
289 if (mt9m111_colour_fmts[i].code == code)
290 return mt9m111_colour_fmts + i;
291
292 return mt9m111->fmt;
293 }
294
to_mt9m111(const struct i2c_client * client)295 static struct mt9m111 *to_mt9m111(const struct i2c_client *client)
296 {
297 return container_of(i2c_get_clientdata(client), struct mt9m111, subdev);
298 }
299
reg_page_map_set(struct i2c_client * client,const u16 reg)300 static int reg_page_map_set(struct i2c_client *client, const u16 reg)
301 {
302 int ret;
303 u16 page;
304 struct mt9m111 *mt9m111 = to_mt9m111(client);
305
306 page = (reg >> 8);
307 if (page == mt9m111->lastpage)
308 return 0;
309 if (page > 2)
310 return -EINVAL;
311
312 ret = i2c_smbus_write_word_swapped(client, MT9M111_PAGE_MAP, page);
313 if (!ret)
314 mt9m111->lastpage = page;
315 return ret;
316 }
317
mt9m111_reg_read(struct i2c_client * client,const u16 reg)318 static int mt9m111_reg_read(struct i2c_client *client, const u16 reg)
319 {
320 int ret;
321
322 ret = reg_page_map_set(client, reg);
323 if (!ret)
324 ret = i2c_smbus_read_word_swapped(client, reg & 0xff);
325
326 dev_dbg(&client->dev, "read reg.%03x -> %04x\n", reg, ret);
327 return ret;
328 }
329
mt9m111_reg_write(struct i2c_client * client,const u16 reg,const u16 data)330 static int mt9m111_reg_write(struct i2c_client *client, const u16 reg,
331 const u16 data)
332 {
333 int ret;
334
335 ret = reg_page_map_set(client, reg);
336 if (!ret)
337 ret = i2c_smbus_write_word_swapped(client, reg & 0xff, data);
338 dev_dbg(&client->dev, "write reg.%03x = %04x -> %d\n", reg, data, ret);
339 return ret;
340 }
341
mt9m111_reg_set(struct i2c_client * client,const u16 reg,const u16 data)342 static int mt9m111_reg_set(struct i2c_client *client, const u16 reg,
343 const u16 data)
344 {
345 int ret;
346
347 ret = mt9m111_reg_read(client, reg);
348 if (ret >= 0)
349 ret = mt9m111_reg_write(client, reg, ret | data);
350 return ret;
351 }
352
mt9m111_reg_clear(struct i2c_client * client,const u16 reg,const u16 data)353 static int mt9m111_reg_clear(struct i2c_client *client, const u16 reg,
354 const u16 data)
355 {
356 int ret;
357
358 ret = mt9m111_reg_read(client, reg);
359 if (ret >= 0)
360 ret = mt9m111_reg_write(client, reg, ret & ~data);
361 return ret;
362 }
363
mt9m111_reg_mask(struct i2c_client * client,const u16 reg,const u16 data,const u16 mask)364 static int mt9m111_reg_mask(struct i2c_client *client, const u16 reg,
365 const u16 data, const u16 mask)
366 {
367 int ret;
368
369 ret = mt9m111_reg_read(client, reg);
370 if (ret >= 0)
371 ret = mt9m111_reg_write(client, reg, (ret & ~mask) | data);
372 return ret;
373 }
374
mt9m111_set_context(struct mt9m111 * mt9m111,struct mt9m111_context * ctx)375 static int mt9m111_set_context(struct mt9m111 *mt9m111,
376 struct mt9m111_context *ctx)
377 {
378 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
379 return reg_write(CONTEXT_CONTROL, ctx->control);
380 }
381
mt9m111_setup_rect_ctx(struct mt9m111 * mt9m111,struct mt9m111_context * ctx,struct v4l2_rect * rect,unsigned int width,unsigned int height)382 static int mt9m111_setup_rect_ctx(struct mt9m111 *mt9m111,
383 struct mt9m111_context *ctx, struct v4l2_rect *rect,
384 unsigned int width, unsigned int height)
385 {
386 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
387 int ret = mt9m111_reg_write(client, ctx->reducer_xzoom, rect->width);
388 if (!ret)
389 ret = mt9m111_reg_write(client, ctx->reducer_yzoom, rect->height);
390 if (!ret)
391 ret = mt9m111_reg_write(client, ctx->reducer_xsize, width);
392 if (!ret)
393 ret = mt9m111_reg_write(client, ctx->reducer_ysize, height);
394 return ret;
395 }
396
mt9m111_setup_geometry(struct mt9m111 * mt9m111,struct v4l2_rect * rect,int width,int height,u32 code)397 static int mt9m111_setup_geometry(struct mt9m111 *mt9m111, struct v4l2_rect *rect,
398 int width, int height, u32 code)
399 {
400 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
401 int ret;
402
403 ret = reg_write(COLUMN_START, rect->left);
404 if (!ret)
405 ret = reg_write(ROW_START, rect->top);
406
407 if (!ret)
408 ret = reg_write(WINDOW_WIDTH, rect->width);
409 if (!ret)
410 ret = reg_write(WINDOW_HEIGHT, rect->height);
411
412 if (code != MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE) {
413 /* IFP in use, down-scaling possible */
414 if (!ret)
415 ret = mt9m111_setup_rect_ctx(mt9m111, &context_b,
416 rect, width, height);
417 if (!ret)
418 ret = mt9m111_setup_rect_ctx(mt9m111, &context_a,
419 rect, width, height);
420 }
421
422 dev_dbg(&client->dev, "%s(%x): %ux%u@%u:%u -> %ux%u = %d\n",
423 __func__, code, rect->width, rect->height, rect->left, rect->top,
424 width, height, ret);
425
426 return ret;
427 }
428
mt9m111_enable(struct mt9m111 * mt9m111)429 static int mt9m111_enable(struct mt9m111 *mt9m111)
430 {
431 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
432 return reg_write(RESET, MT9M111_RESET_CHIP_ENABLE);
433 }
434
mt9m111_reset(struct mt9m111 * mt9m111)435 static int mt9m111_reset(struct mt9m111 *mt9m111)
436 {
437 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
438 int ret;
439
440 ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
441 if (!ret)
442 ret = reg_set(RESET, MT9M111_RESET_RESET_SOC);
443 if (!ret)
444 ret = reg_clear(RESET, MT9M111_RESET_RESET_MODE
445 | MT9M111_RESET_RESET_SOC);
446
447 return ret;
448 }
449
mt9m111_set_selection(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_selection * sel)450 static int mt9m111_set_selection(struct v4l2_subdev *sd,
451 struct v4l2_subdev_state *sd_state,
452 struct v4l2_subdev_selection *sel)
453 {
454 struct i2c_client *client = v4l2_get_subdevdata(sd);
455 struct mt9m111 *mt9m111 = to_mt9m111(client);
456 struct v4l2_rect rect = sel->r;
457 int width, height;
458 int ret, align = 0;
459
460 if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE ||
461 sel->target != V4L2_SEL_TGT_CROP)
462 return -EINVAL;
463
464 if (mt9m111->fmt->code == MEDIA_BUS_FMT_SBGGR8_1X8 ||
465 mt9m111->fmt->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE) {
466 /* Bayer format - even size lengths */
467 align = 1;
468 /* Let the user play with the starting pixel */
469 }
470
471 /* FIXME: the datasheet doesn't specify minimum sizes */
472 v4l_bound_align_image(&rect.width, 2, MT9M111_MAX_WIDTH, align,
473 &rect.height, 2, MT9M111_MAX_HEIGHT, align, 0);
474 rect.left = clamp(rect.left, MT9M111_MIN_DARK_COLS,
475 MT9M111_MIN_DARK_COLS + MT9M111_MAX_WIDTH -
476 (__s32)rect.width);
477 rect.top = clamp(rect.top, MT9M111_MIN_DARK_ROWS,
478 MT9M111_MIN_DARK_ROWS + MT9M111_MAX_HEIGHT -
479 (__s32)rect.height);
480
481 width = min(mt9m111->width, rect.width);
482 height = min(mt9m111->height, rect.height);
483
484 ret = mt9m111_setup_geometry(mt9m111, &rect, width, height, mt9m111->fmt->code);
485 if (!ret) {
486 mt9m111->rect = rect;
487 mt9m111->width = width;
488 mt9m111->height = height;
489 }
490
491 return ret;
492 }
493
mt9m111_get_selection(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_selection * sel)494 static int mt9m111_get_selection(struct v4l2_subdev *sd,
495 struct v4l2_subdev_state *sd_state,
496 struct v4l2_subdev_selection *sel)
497 {
498 struct i2c_client *client = v4l2_get_subdevdata(sd);
499 struct mt9m111 *mt9m111 = to_mt9m111(client);
500
501 if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)
502 return -EINVAL;
503
504 switch (sel->target) {
505 case V4L2_SEL_TGT_CROP_BOUNDS:
506 sel->r.left = MT9M111_MIN_DARK_COLS;
507 sel->r.top = MT9M111_MIN_DARK_ROWS;
508 sel->r.width = MT9M111_MAX_WIDTH;
509 sel->r.height = MT9M111_MAX_HEIGHT;
510 return 0;
511 case V4L2_SEL_TGT_CROP:
512 sel->r = mt9m111->rect;
513 return 0;
514 default:
515 return -EINVAL;
516 }
517 }
518
mt9m111_get_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)519 static int mt9m111_get_fmt(struct v4l2_subdev *sd,
520 struct v4l2_subdev_state *sd_state,
521 struct v4l2_subdev_format *format)
522 {
523 struct v4l2_mbus_framefmt *mf = &format->format;
524 struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
525
526 if (format->pad)
527 return -EINVAL;
528
529 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
530 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
531 mf = v4l2_subdev_get_try_format(sd, sd_state, format->pad);
532 format->format = *mf;
533 return 0;
534 #else
535 return -EINVAL;
536 #endif
537 }
538
539 mf->width = mt9m111->width;
540 mf->height = mt9m111->height;
541 mf->code = mt9m111->fmt->code;
542 mf->colorspace = mt9m111->fmt->colorspace;
543 mf->field = V4L2_FIELD_NONE;
544 mf->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
545 mf->quantization = V4L2_QUANTIZATION_DEFAULT;
546 mf->xfer_func = V4L2_XFER_FUNC_DEFAULT;
547
548 return 0;
549 }
550
mt9m111_set_pixfmt(struct mt9m111 * mt9m111,u32 code)551 static int mt9m111_set_pixfmt(struct mt9m111 *mt9m111,
552 u32 code)
553 {
554 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
555 u16 data_outfmt2, mask_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
556 MT9M111_OUTFMT_BYPASS_IFP | MT9M111_OUTFMT_RGB |
557 MT9M111_OUTFMT_RGB565 | MT9M111_OUTFMT_RGB555 |
558 MT9M111_OUTFMT_RGB444x | MT9M111_OUTFMT_RGBx444 |
559 MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
560 MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
561 int ret;
562
563 switch (code) {
564 case MEDIA_BUS_FMT_SBGGR8_1X8:
565 data_outfmt2 = MT9M111_OUTFMT_PROCESSED_BAYER |
566 MT9M111_OUTFMT_RGB;
567 break;
568 case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE:
569 data_outfmt2 = MT9M111_OUTFMT_BYPASS_IFP | MT9M111_OUTFMT_RGB;
570 break;
571 case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
572 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555 |
573 MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
574 break;
575 case MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE:
576 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB555;
577 break;
578 case MEDIA_BUS_FMT_RGB565_2X8_LE:
579 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
580 MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
581 break;
582 case MEDIA_BUS_FMT_RGB565_2X8_BE:
583 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565;
584 break;
585 case MEDIA_BUS_FMT_BGR565_2X8_BE:
586 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
587 MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
588 break;
589 case MEDIA_BUS_FMT_BGR565_2X8_LE:
590 data_outfmt2 = MT9M111_OUTFMT_RGB | MT9M111_OUTFMT_RGB565 |
591 MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
592 MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
593 break;
594 case MEDIA_BUS_FMT_UYVY8_2X8:
595 data_outfmt2 = 0;
596 break;
597 case MEDIA_BUS_FMT_VYUY8_2X8:
598 data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
599 break;
600 case MEDIA_BUS_FMT_YUYV8_2X8:
601 data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN;
602 break;
603 case MEDIA_BUS_FMT_YVYU8_2X8:
604 data_outfmt2 = MT9M111_OUTFMT_SWAP_YCbCr_C_Y_RGB_EVEN |
605 MT9M111_OUTFMT_SWAP_YCbCr_Cb_Cr_RGB_R_B;
606 break;
607 default:
608 dev_err(&client->dev, "Pixel format not handled: %x\n", code);
609 return -EINVAL;
610 }
611
612 /* receiver samples on falling edge, chip-hw default is rising */
613 if (mt9m111->pclk_sample == 0)
614 mask_outfmt2 |= MT9M111_OUTFMT_INV_PIX_CLOCK;
615
616 ret = mt9m111_reg_mask(client, context_a.output_fmt_ctrl2,
617 data_outfmt2, mask_outfmt2);
618 if (!ret)
619 ret = mt9m111_reg_mask(client, context_b.output_fmt_ctrl2,
620 data_outfmt2, mask_outfmt2);
621
622 return ret;
623 }
624
mt9m111_set_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_format * format)625 static int mt9m111_set_fmt(struct v4l2_subdev *sd,
626 struct v4l2_subdev_state *sd_state,
627 struct v4l2_subdev_format *format)
628 {
629 struct v4l2_mbus_framefmt *mf = &format->format;
630 struct i2c_client *client = v4l2_get_subdevdata(sd);
631 struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
632 const struct mt9m111_datafmt *fmt;
633 struct v4l2_rect *rect = &mt9m111->rect;
634 bool bayer;
635 int ret;
636
637 if (mt9m111->is_streaming)
638 return -EBUSY;
639
640 if (format->pad)
641 return -EINVAL;
642
643 fmt = mt9m111_find_datafmt(mt9m111, mf->code);
644
645 bayer = fmt->code == MEDIA_BUS_FMT_SBGGR8_1X8 ||
646 fmt->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE;
647
648 /*
649 * With Bayer format enforce even side lengths, but let the user play
650 * with the starting pixel
651 */
652 if (bayer) {
653 rect->width = ALIGN(rect->width, 2);
654 rect->height = ALIGN(rect->height, 2);
655 }
656
657 if (fmt->code == MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE) {
658 /* IFP bypass mode, no scaling */
659 mf->width = rect->width;
660 mf->height = rect->height;
661 } else {
662 /* No upscaling */
663 if (mf->width > rect->width)
664 mf->width = rect->width;
665 if (mf->height > rect->height)
666 mf->height = rect->height;
667 }
668
669 dev_dbg(&client->dev, "%s(): %ux%u, code=%x\n", __func__,
670 mf->width, mf->height, fmt->code);
671
672 mf->code = fmt->code;
673 mf->colorspace = fmt->colorspace;
674 mf->field = V4L2_FIELD_NONE;
675 mf->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
676 mf->quantization = V4L2_QUANTIZATION_DEFAULT;
677 mf->xfer_func = V4L2_XFER_FUNC_DEFAULT;
678
679 if (format->which == V4L2_SUBDEV_FORMAT_TRY) {
680 sd_state->pads->try_fmt = *mf;
681 return 0;
682 }
683
684 ret = mt9m111_setup_geometry(mt9m111, rect, mf->width, mf->height, mf->code);
685 if (!ret)
686 ret = mt9m111_set_pixfmt(mt9m111, mf->code);
687 if (!ret) {
688 mt9m111->width = mf->width;
689 mt9m111->height = mf->height;
690 mt9m111->fmt = fmt;
691 }
692
693 return ret;
694 }
695
696 static const struct mt9m111_mode_info *
mt9m111_find_mode(struct mt9m111 * mt9m111,unsigned int req_fps,unsigned int width,unsigned int height)697 mt9m111_find_mode(struct mt9m111 *mt9m111, unsigned int req_fps,
698 unsigned int width, unsigned int height)
699 {
700 const struct mt9m111_mode_info *mode;
701 struct v4l2_rect *sensor_rect = &mt9m111->rect;
702 unsigned int gap, gap_best = (unsigned int) -1;
703 int i, best_gap_idx = MT9M111_MODE_SXGA_15FPS;
704 bool skip_30fps = false;
705
706 /*
707 * The fps selection is based on the row, column skipping mechanism.
708 * So ensure that the sensor window is set to default else the fps
709 * aren't calculated correctly within the sensor hw.
710 */
711 if (sensor_rect->width != MT9M111_MAX_WIDTH ||
712 sensor_rect->height != MT9M111_MAX_HEIGHT) {
713 dev_info(mt9m111->subdev.dev,
714 "Framerate selection is not supported for cropped "
715 "images\n");
716 return NULL;
717 }
718
719 /* 30fps only supported for images not exceeding 640x512 */
720 if (width > MT9M111_MAX_WIDTH / 2 || height > MT9M111_MAX_HEIGHT / 2) {
721 dev_dbg(mt9m111->subdev.dev,
722 "Framerates > 15fps are supported only for images "
723 "not exceeding 640x512\n");
724 skip_30fps = true;
725 }
726
727 /* find best matched fps */
728 for (i = 0; i < MT9M111_NUM_MODES; i++) {
729 unsigned int fps = mt9m111_mode_data[i].max_fps;
730
731 if (fps == 30 && skip_30fps)
732 continue;
733
734 gap = abs(fps - req_fps);
735 if (gap < gap_best) {
736 best_gap_idx = i;
737 gap_best = gap;
738 }
739 }
740
741 /*
742 * Use context a/b default timing values instead of calculate blanking
743 * timing values.
744 */
745 mode = &mt9m111_mode_data[best_gap_idx];
746 mt9m111->ctx = (best_gap_idx == MT9M111_MODE_QSXGA_30FPS) ? &context_a :
747 &context_b;
748 return mode;
749 }
750
751 #ifdef CONFIG_VIDEO_ADV_DEBUG
mt9m111_g_register(struct v4l2_subdev * sd,struct v4l2_dbg_register * reg)752 static int mt9m111_g_register(struct v4l2_subdev *sd,
753 struct v4l2_dbg_register *reg)
754 {
755 struct i2c_client *client = v4l2_get_subdevdata(sd);
756 int val;
757
758 if (reg->reg > 0x2ff)
759 return -EINVAL;
760
761 val = mt9m111_reg_read(client, reg->reg);
762 reg->size = 2;
763 reg->val = (u64)val;
764
765 if (reg->val > 0xffff)
766 return -EIO;
767
768 return 0;
769 }
770
mt9m111_s_register(struct v4l2_subdev * sd,const struct v4l2_dbg_register * reg)771 static int mt9m111_s_register(struct v4l2_subdev *sd,
772 const struct v4l2_dbg_register *reg)
773 {
774 struct i2c_client *client = v4l2_get_subdevdata(sd);
775
776 if (reg->reg > 0x2ff)
777 return -EINVAL;
778
779 if (mt9m111_reg_write(client, reg->reg, reg->val) < 0)
780 return -EIO;
781
782 return 0;
783 }
784 #endif
785
mt9m111_set_flip(struct mt9m111 * mt9m111,int flip,int mask)786 static int mt9m111_set_flip(struct mt9m111 *mt9m111, int flip, int mask)
787 {
788 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
789 int ret;
790
791 if (flip)
792 ret = mt9m111_reg_set(client, mt9m111->ctx->read_mode, mask);
793 else
794 ret = mt9m111_reg_clear(client, mt9m111->ctx->read_mode, mask);
795
796 return ret;
797 }
798
mt9m111_get_global_gain(struct mt9m111 * mt9m111)799 static int mt9m111_get_global_gain(struct mt9m111 *mt9m111)
800 {
801 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
802 int data;
803
804 data = reg_read(GLOBAL_GAIN);
805 if (data >= 0)
806 return (data & 0x2f) * (1 << ((data >> 10) & 1)) *
807 (1 << ((data >> 9) & 1));
808 return data;
809 }
810
mt9m111_set_global_gain(struct mt9m111 * mt9m111,int gain)811 static int mt9m111_set_global_gain(struct mt9m111 *mt9m111, int gain)
812 {
813 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
814 u16 val;
815
816 if (gain > 63 * 2 * 2)
817 return -EINVAL;
818
819 if ((gain >= 64 * 2) && (gain < 63 * 2 * 2))
820 val = (1 << 10) | (1 << 9) | (gain / 4);
821 else if ((gain >= 64) && (gain < 64 * 2))
822 val = (1 << 9) | (gain / 2);
823 else
824 val = gain;
825
826 return reg_write(GLOBAL_GAIN, val);
827 }
828
mt9m111_set_autoexposure(struct mt9m111 * mt9m111,int val)829 static int mt9m111_set_autoexposure(struct mt9m111 *mt9m111, int val)
830 {
831 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
832
833 if (val == V4L2_EXPOSURE_AUTO)
834 return reg_set(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOEXPO_EN);
835 return reg_clear(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOEXPO_EN);
836 }
837
mt9m111_set_autowhitebalance(struct mt9m111 * mt9m111,int on)838 static int mt9m111_set_autowhitebalance(struct mt9m111 *mt9m111, int on)
839 {
840 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
841
842 if (on)
843 return reg_set(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOWHITEBAL_EN);
844 return reg_clear(OPER_MODE_CTRL, MT9M111_OPMODE_AUTOWHITEBAL_EN);
845 }
846
847 static const char * const mt9m111_test_pattern_menu[] = {
848 "Disabled",
849 "Vertical monochrome gradient",
850 "Flat color type 1",
851 "Flat color type 2",
852 "Flat color type 3",
853 "Flat color type 4",
854 "Flat color type 5",
855 "Color bar",
856 };
857
mt9m111_set_test_pattern(struct mt9m111 * mt9m111,int val)858 static int mt9m111_set_test_pattern(struct mt9m111 *mt9m111, int val)
859 {
860 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
861
862 return mt9m111_reg_mask(client, MT9M111_TPG_CTRL, val,
863 MT9M111_TPG_SEL_MASK);
864 }
865
mt9m111_set_colorfx(struct mt9m111 * mt9m111,int val)866 static int mt9m111_set_colorfx(struct mt9m111 *mt9m111, int val)
867 {
868 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
869 static const struct v4l2_control colorfx[] = {
870 { V4L2_COLORFX_NONE, 0 },
871 { V4L2_COLORFX_BW, 1 },
872 { V4L2_COLORFX_SEPIA, 2 },
873 { V4L2_COLORFX_NEGATIVE, 3 },
874 { V4L2_COLORFX_SOLARIZATION, 4 },
875 };
876 int i;
877
878 for (i = 0; i < ARRAY_SIZE(colorfx); i++) {
879 if (colorfx[i].id == val) {
880 return mt9m111_reg_mask(client, MT9M111_EFFECTS_MODE,
881 colorfx[i].value,
882 MT9M111_EFFECTS_MODE_MASK);
883 }
884 }
885
886 return -EINVAL;
887 }
888
mt9m111_s_ctrl(struct v4l2_ctrl * ctrl)889 static int mt9m111_s_ctrl(struct v4l2_ctrl *ctrl)
890 {
891 struct mt9m111 *mt9m111 = container_of(ctrl->handler,
892 struct mt9m111, hdl);
893
894 switch (ctrl->id) {
895 case V4L2_CID_VFLIP:
896 return mt9m111_set_flip(mt9m111, ctrl->val,
897 MT9M111_RMB_MIRROR_ROWS);
898 case V4L2_CID_HFLIP:
899 return mt9m111_set_flip(mt9m111, ctrl->val,
900 MT9M111_RMB_MIRROR_COLS);
901 case V4L2_CID_GAIN:
902 return mt9m111_set_global_gain(mt9m111, ctrl->val);
903 case V4L2_CID_EXPOSURE_AUTO:
904 return mt9m111_set_autoexposure(mt9m111, ctrl->val);
905 case V4L2_CID_AUTO_WHITE_BALANCE:
906 return mt9m111_set_autowhitebalance(mt9m111, ctrl->val);
907 case V4L2_CID_TEST_PATTERN:
908 return mt9m111_set_test_pattern(mt9m111, ctrl->val);
909 case V4L2_CID_COLORFX:
910 return mt9m111_set_colorfx(mt9m111, ctrl->val);
911 }
912
913 return -EINVAL;
914 }
915
mt9m111_suspend(struct mt9m111 * mt9m111)916 static int mt9m111_suspend(struct mt9m111 *mt9m111)
917 {
918 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
919 int ret;
920
921 v4l2_ctrl_s_ctrl(mt9m111->gain, mt9m111_get_global_gain(mt9m111));
922
923 ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
924 if (!ret)
925 ret = reg_set(RESET, MT9M111_RESET_RESET_SOC |
926 MT9M111_RESET_OUTPUT_DISABLE |
927 MT9M111_RESET_ANALOG_STANDBY);
928 if (!ret)
929 ret = reg_clear(RESET, MT9M111_RESET_CHIP_ENABLE);
930
931 return ret;
932 }
933
mt9m111_restore_state(struct mt9m111 * mt9m111)934 static void mt9m111_restore_state(struct mt9m111 *mt9m111)
935 {
936 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
937
938 mt9m111_set_context(mt9m111, mt9m111->ctx);
939 mt9m111_set_pixfmt(mt9m111, mt9m111->fmt->code);
940 mt9m111_setup_geometry(mt9m111, &mt9m111->rect,
941 mt9m111->width, mt9m111->height, mt9m111->fmt->code);
942 v4l2_ctrl_handler_setup(&mt9m111->hdl);
943 mt9m111_reg_mask(client, mt9m111->ctx->read_mode,
944 mt9m111->current_mode->reg_val,
945 mt9m111->current_mode->reg_mask);
946 }
947
mt9m111_resume(struct mt9m111 * mt9m111)948 static int mt9m111_resume(struct mt9m111 *mt9m111)
949 {
950 int ret = mt9m111_enable(mt9m111);
951 if (!ret)
952 ret = mt9m111_reset(mt9m111);
953 if (!ret)
954 mt9m111_restore_state(mt9m111);
955
956 return ret;
957 }
958
mt9m111_init(struct mt9m111 * mt9m111)959 static int mt9m111_init(struct mt9m111 *mt9m111)
960 {
961 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
962 int ret;
963
964 ret = mt9m111_enable(mt9m111);
965 if (!ret)
966 ret = mt9m111_reset(mt9m111);
967 if (!ret)
968 ret = mt9m111_set_context(mt9m111, mt9m111->ctx);
969 if (ret)
970 dev_err(&client->dev, "mt9m111 init failed: %d\n", ret);
971 return ret;
972 }
973
mt9m111_power_on(struct mt9m111 * mt9m111)974 static int mt9m111_power_on(struct mt9m111 *mt9m111)
975 {
976 struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
977 int ret;
978
979 ret = clk_prepare_enable(mt9m111->clk);
980 if (ret < 0)
981 return ret;
982
983 ret = regulator_enable(mt9m111->regulator);
984 if (ret < 0)
985 goto out_clk_disable;
986
987 ret = mt9m111_resume(mt9m111);
988 if (ret < 0)
989 goto out_regulator_disable;
990
991 return 0;
992
993 out_regulator_disable:
994 regulator_disable(mt9m111->regulator);
995
996 out_clk_disable:
997 clk_disable_unprepare(mt9m111->clk);
998
999 dev_err(&client->dev, "Failed to resume the sensor: %d\n", ret);
1000
1001 return ret;
1002 }
1003
mt9m111_power_off(struct mt9m111 * mt9m111)1004 static void mt9m111_power_off(struct mt9m111 *mt9m111)
1005 {
1006 mt9m111_suspend(mt9m111);
1007 regulator_disable(mt9m111->regulator);
1008 clk_disable_unprepare(mt9m111->clk);
1009 }
1010
mt9m111_s_power(struct v4l2_subdev * sd,int on)1011 static int mt9m111_s_power(struct v4l2_subdev *sd, int on)
1012 {
1013 struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
1014 int ret = 0;
1015
1016 mutex_lock(&mt9m111->power_lock);
1017
1018 /*
1019 * If the power count is modified from 0 to != 0 or from != 0 to 0,
1020 * update the power state.
1021 */
1022 if (mt9m111->power_count == !on) {
1023 if (on)
1024 ret = mt9m111_power_on(mt9m111);
1025 else
1026 mt9m111_power_off(mt9m111);
1027 }
1028
1029 if (!ret) {
1030 /* Update the power count. */
1031 mt9m111->power_count += on ? 1 : -1;
1032 WARN_ON(mt9m111->power_count < 0);
1033 }
1034
1035 mutex_unlock(&mt9m111->power_lock);
1036 return ret;
1037 }
1038
1039 static const struct v4l2_ctrl_ops mt9m111_ctrl_ops = {
1040 .s_ctrl = mt9m111_s_ctrl,
1041 };
1042
1043 static const struct v4l2_subdev_core_ops mt9m111_subdev_core_ops = {
1044 .s_power = mt9m111_s_power,
1045 .log_status = v4l2_ctrl_subdev_log_status,
1046 .subscribe_event = v4l2_ctrl_subdev_subscribe_event,
1047 .unsubscribe_event = v4l2_event_subdev_unsubscribe,
1048 #ifdef CONFIG_VIDEO_ADV_DEBUG
1049 .g_register = mt9m111_g_register,
1050 .s_register = mt9m111_s_register,
1051 #endif
1052 };
1053
mt9m111_g_frame_interval(struct v4l2_subdev * sd,struct v4l2_subdev_frame_interval * fi)1054 static int mt9m111_g_frame_interval(struct v4l2_subdev *sd,
1055 struct v4l2_subdev_frame_interval *fi)
1056 {
1057 struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
1058
1059 fi->interval = mt9m111->frame_interval;
1060
1061 return 0;
1062 }
1063
mt9m111_s_frame_interval(struct v4l2_subdev * sd,struct v4l2_subdev_frame_interval * fi)1064 static int mt9m111_s_frame_interval(struct v4l2_subdev *sd,
1065 struct v4l2_subdev_frame_interval *fi)
1066 {
1067 struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
1068 const struct mt9m111_mode_info *mode;
1069 struct v4l2_fract *fract = &fi->interval;
1070 int fps;
1071
1072 if (mt9m111->is_streaming)
1073 return -EBUSY;
1074
1075 if (fi->pad != 0)
1076 return -EINVAL;
1077
1078 if (fract->numerator == 0) {
1079 fract->denominator = 30;
1080 fract->numerator = 1;
1081 }
1082
1083 fps = DIV_ROUND_CLOSEST(fract->denominator, fract->numerator);
1084
1085 /* Find best fitting mode. Do not update the mode if no one was found. */
1086 mode = mt9m111_find_mode(mt9m111, fps, mt9m111->width, mt9m111->height);
1087 if (!mode)
1088 return 0;
1089
1090 if (mode->max_fps != fps) {
1091 fract->denominator = mode->max_fps;
1092 fract->numerator = 1;
1093 }
1094
1095 mt9m111->current_mode = mode;
1096 mt9m111->frame_interval = fi->interval;
1097
1098 return 0;
1099 }
1100
mt9m111_enum_mbus_code(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state,struct v4l2_subdev_mbus_code_enum * code)1101 static int mt9m111_enum_mbus_code(struct v4l2_subdev *sd,
1102 struct v4l2_subdev_state *sd_state,
1103 struct v4l2_subdev_mbus_code_enum *code)
1104 {
1105 if (code->pad || code->index >= ARRAY_SIZE(mt9m111_colour_fmts))
1106 return -EINVAL;
1107
1108 code->code = mt9m111_colour_fmts[code->index].code;
1109 return 0;
1110 }
1111
mt9m111_s_stream(struct v4l2_subdev * sd,int enable)1112 static int mt9m111_s_stream(struct v4l2_subdev *sd, int enable)
1113 {
1114 struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
1115
1116 mt9m111->is_streaming = !!enable;
1117 return 0;
1118 }
1119
mt9m111_init_cfg(struct v4l2_subdev * sd,struct v4l2_subdev_state * sd_state)1120 static int mt9m111_init_cfg(struct v4l2_subdev *sd,
1121 struct v4l2_subdev_state *sd_state)
1122 {
1123 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
1124 struct v4l2_mbus_framefmt *format =
1125 v4l2_subdev_get_try_format(sd, sd_state, 0);
1126
1127 format->width = MT9M111_MAX_WIDTH;
1128 format->height = MT9M111_MAX_HEIGHT;
1129 format->code = mt9m111_colour_fmts[0].code;
1130 format->colorspace = mt9m111_colour_fmts[0].colorspace;
1131 format->field = V4L2_FIELD_NONE;
1132 format->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
1133 format->quantization = V4L2_QUANTIZATION_DEFAULT;
1134 format->xfer_func = V4L2_XFER_FUNC_DEFAULT;
1135 #endif
1136 return 0;
1137 }
1138
mt9m111_get_mbus_config(struct v4l2_subdev * sd,unsigned int pad,struct v4l2_mbus_config * cfg)1139 static int mt9m111_get_mbus_config(struct v4l2_subdev *sd,
1140 unsigned int pad,
1141 struct v4l2_mbus_config *cfg)
1142 {
1143 struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
1144
1145 cfg->type = V4L2_MBUS_PARALLEL;
1146
1147 cfg->bus.parallel.flags = V4L2_MBUS_MASTER |
1148 V4L2_MBUS_HSYNC_ACTIVE_HIGH |
1149 V4L2_MBUS_VSYNC_ACTIVE_HIGH |
1150 V4L2_MBUS_DATA_ACTIVE_HIGH;
1151
1152 cfg->bus.parallel.flags |= mt9m111->pclk_sample ?
1153 V4L2_MBUS_PCLK_SAMPLE_RISING :
1154 V4L2_MBUS_PCLK_SAMPLE_FALLING;
1155
1156 return 0;
1157 }
1158
1159 static const struct v4l2_subdev_video_ops mt9m111_subdev_video_ops = {
1160 .s_stream = mt9m111_s_stream,
1161 .g_frame_interval = mt9m111_g_frame_interval,
1162 .s_frame_interval = mt9m111_s_frame_interval,
1163 };
1164
1165 static const struct v4l2_subdev_pad_ops mt9m111_subdev_pad_ops = {
1166 .init_cfg = mt9m111_init_cfg,
1167 .enum_mbus_code = mt9m111_enum_mbus_code,
1168 .get_selection = mt9m111_get_selection,
1169 .set_selection = mt9m111_set_selection,
1170 .get_fmt = mt9m111_get_fmt,
1171 .set_fmt = mt9m111_set_fmt,
1172 .get_mbus_config = mt9m111_get_mbus_config,
1173 };
1174
1175 static const struct v4l2_subdev_ops mt9m111_subdev_ops = {
1176 .core = &mt9m111_subdev_core_ops,
1177 .video = &mt9m111_subdev_video_ops,
1178 .pad = &mt9m111_subdev_pad_ops,
1179 };
1180
1181 /*
1182 * Interface active, can use i2c. If it fails, it can indeed mean, that
1183 * this wasn't our capture interface, so, we wait for the right one
1184 */
mt9m111_video_probe(struct i2c_client * client)1185 static int mt9m111_video_probe(struct i2c_client *client)
1186 {
1187 struct mt9m111 *mt9m111 = to_mt9m111(client);
1188 s32 data;
1189 int ret;
1190
1191 ret = mt9m111_s_power(&mt9m111->subdev, 1);
1192 if (ret < 0)
1193 return ret;
1194
1195 data = reg_read(CHIP_VERSION);
1196
1197 switch (data) {
1198 case 0x143a: /* MT9M111 or MT9M131 */
1199 dev_info(&client->dev,
1200 "Detected a MT9M111/MT9M131 chip ID %x\n", data);
1201 break;
1202 case 0x148c: /* MT9M112 */
1203 dev_info(&client->dev, "Detected a MT9M112 chip ID %x\n", data);
1204 break;
1205 default:
1206 dev_err(&client->dev,
1207 "No MT9M111/MT9M112/MT9M131 chip detected register read %x\n",
1208 data);
1209 ret = -ENODEV;
1210 goto done;
1211 }
1212
1213 ret = mt9m111_init(mt9m111);
1214 if (ret)
1215 goto done;
1216
1217 ret = v4l2_ctrl_handler_setup(&mt9m111->hdl);
1218
1219 done:
1220 mt9m111_s_power(&mt9m111->subdev, 0);
1221 return ret;
1222 }
1223
mt9m111_probe_fw(struct i2c_client * client,struct mt9m111 * mt9m111)1224 static int mt9m111_probe_fw(struct i2c_client *client, struct mt9m111 *mt9m111)
1225 {
1226 struct v4l2_fwnode_endpoint bus_cfg = {
1227 .bus_type = V4L2_MBUS_PARALLEL
1228 };
1229 struct fwnode_handle *np;
1230 int ret;
1231
1232 np = fwnode_graph_get_next_endpoint(dev_fwnode(&client->dev), NULL);
1233 if (!np)
1234 return -EINVAL;
1235
1236 ret = v4l2_fwnode_endpoint_parse(np, &bus_cfg);
1237 if (ret)
1238 goto out_put_fw;
1239
1240 mt9m111->pclk_sample = !!(bus_cfg.bus.parallel.flags &
1241 V4L2_MBUS_PCLK_SAMPLE_RISING);
1242
1243 out_put_fw:
1244 fwnode_handle_put(np);
1245 return ret;
1246 }
1247
mt9m111_probe(struct i2c_client * client)1248 static int mt9m111_probe(struct i2c_client *client)
1249 {
1250 struct mt9m111 *mt9m111;
1251 struct i2c_adapter *adapter = client->adapter;
1252 int ret;
1253
1254 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
1255 dev_warn(&adapter->dev,
1256 "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
1257 return -EIO;
1258 }
1259
1260 mt9m111 = devm_kzalloc(&client->dev, sizeof(struct mt9m111), GFP_KERNEL);
1261 if (!mt9m111)
1262 return -ENOMEM;
1263
1264 if (dev_fwnode(&client->dev)) {
1265 ret = mt9m111_probe_fw(client, mt9m111);
1266 if (ret)
1267 return ret;
1268 }
1269
1270 mt9m111->clk = devm_clk_get(&client->dev, "mclk");
1271 if (IS_ERR(mt9m111->clk))
1272 return PTR_ERR(mt9m111->clk);
1273
1274 mt9m111->regulator = devm_regulator_get(&client->dev, "vdd");
1275 if (IS_ERR(mt9m111->regulator)) {
1276 dev_err(&client->dev, "regulator not found: %ld\n",
1277 PTR_ERR(mt9m111->regulator));
1278 return PTR_ERR(mt9m111->regulator);
1279 }
1280
1281 /* Default HIGHPOWER context */
1282 mt9m111->ctx = &context_b;
1283
1284 v4l2_i2c_subdev_init(&mt9m111->subdev, client, &mt9m111_subdev_ops);
1285 mt9m111->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |
1286 V4L2_SUBDEV_FL_HAS_EVENTS;
1287
1288 v4l2_ctrl_handler_init(&mt9m111->hdl, 7);
1289 v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
1290 V4L2_CID_VFLIP, 0, 1, 1, 0);
1291 v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
1292 V4L2_CID_HFLIP, 0, 1, 1, 0);
1293 v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
1294 V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
1295 mt9m111->gain = v4l2_ctrl_new_std(&mt9m111->hdl, &mt9m111_ctrl_ops,
1296 V4L2_CID_GAIN, 0, 63 * 2 * 2, 1, 32);
1297 v4l2_ctrl_new_std_menu(&mt9m111->hdl,
1298 &mt9m111_ctrl_ops, V4L2_CID_EXPOSURE_AUTO, 1, 0,
1299 V4L2_EXPOSURE_AUTO);
1300 v4l2_ctrl_new_std_menu_items(&mt9m111->hdl,
1301 &mt9m111_ctrl_ops, V4L2_CID_TEST_PATTERN,
1302 ARRAY_SIZE(mt9m111_test_pattern_menu) - 1, 0, 0,
1303 mt9m111_test_pattern_menu);
1304 v4l2_ctrl_new_std_menu(&mt9m111->hdl, &mt9m111_ctrl_ops,
1305 V4L2_CID_COLORFX, V4L2_COLORFX_SOLARIZATION,
1306 ~(BIT(V4L2_COLORFX_NONE) |
1307 BIT(V4L2_COLORFX_BW) |
1308 BIT(V4L2_COLORFX_SEPIA) |
1309 BIT(V4L2_COLORFX_NEGATIVE) |
1310 BIT(V4L2_COLORFX_SOLARIZATION)),
1311 V4L2_COLORFX_NONE);
1312 mt9m111->subdev.ctrl_handler = &mt9m111->hdl;
1313 if (mt9m111->hdl.error) {
1314 ret = mt9m111->hdl.error;
1315 return ret;
1316 }
1317
1318 #ifdef CONFIG_MEDIA_CONTROLLER
1319 mt9m111->pad.flags = MEDIA_PAD_FL_SOURCE;
1320 mt9m111->subdev.entity.function = MEDIA_ENT_F_CAM_SENSOR;
1321 ret = media_entity_pads_init(&mt9m111->subdev.entity, 1, &mt9m111->pad);
1322 if (ret < 0)
1323 goto out_hdlfree;
1324 #endif
1325
1326 mt9m111->current_mode = &mt9m111_mode_data[MT9M111_MODE_SXGA_15FPS];
1327 mt9m111->frame_interval.numerator = 1;
1328 mt9m111->frame_interval.denominator = mt9m111->current_mode->max_fps;
1329
1330 /* Second stage probe - when a capture adapter is there */
1331 mt9m111->rect.left = MT9M111_MIN_DARK_COLS;
1332 mt9m111->rect.top = MT9M111_MIN_DARK_ROWS;
1333 mt9m111->rect.width = MT9M111_MAX_WIDTH;
1334 mt9m111->rect.height = MT9M111_MAX_HEIGHT;
1335 mt9m111->width = mt9m111->rect.width;
1336 mt9m111->height = mt9m111->rect.height;
1337 mt9m111->fmt = &mt9m111_colour_fmts[0];
1338 mt9m111->lastpage = -1;
1339 mutex_init(&mt9m111->power_lock);
1340
1341 ret = mt9m111_video_probe(client);
1342 if (ret < 0)
1343 goto out_entityclean;
1344
1345 mt9m111->subdev.dev = &client->dev;
1346 ret = v4l2_async_register_subdev(&mt9m111->subdev);
1347 if (ret < 0)
1348 goto out_entityclean;
1349
1350 return 0;
1351
1352 out_entityclean:
1353 #ifdef CONFIG_MEDIA_CONTROLLER
1354 media_entity_cleanup(&mt9m111->subdev.entity);
1355 out_hdlfree:
1356 #endif
1357 v4l2_ctrl_handler_free(&mt9m111->hdl);
1358
1359 return ret;
1360 }
1361
mt9m111_remove(struct i2c_client * client)1362 static void mt9m111_remove(struct i2c_client *client)
1363 {
1364 struct mt9m111 *mt9m111 = to_mt9m111(client);
1365
1366 v4l2_async_unregister_subdev(&mt9m111->subdev);
1367 media_entity_cleanup(&mt9m111->subdev.entity);
1368 v4l2_ctrl_handler_free(&mt9m111->hdl);
1369 }
1370 static const struct of_device_id mt9m111_of_match[] = {
1371 { .compatible = "micron,mt9m111", },
1372 {},
1373 };
1374 MODULE_DEVICE_TABLE(of, mt9m111_of_match);
1375
1376 static const struct i2c_device_id mt9m111_id[] = {
1377 { "mt9m111", 0 },
1378 { }
1379 };
1380 MODULE_DEVICE_TABLE(i2c, mt9m111_id);
1381
1382 static struct i2c_driver mt9m111_i2c_driver = {
1383 .driver = {
1384 .name = "mt9m111",
1385 .of_match_table = mt9m111_of_match,
1386 },
1387 .probe = mt9m111_probe,
1388 .remove = mt9m111_remove,
1389 .id_table = mt9m111_id,
1390 };
1391
1392 module_i2c_driver(mt9m111_i2c_driver);
1393
1394 MODULE_DESCRIPTION("Micron/Aptina MT9M111/MT9M112/MT9M131 Camera driver");
1395 MODULE_AUTHOR("Robert Jarzmik");
1396 MODULE_LICENSE("GPL");
1397