mt9m032.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Driver for MT9M032 CMOS Image Sensor from Micron
  4. *
  5. * Copyright (C) 2010-2011 Lund Engineering
  6. * Contact: Gil Lund <gwlund@lundeng.com>
  7. * Author: Martin Hostettler <martin@neutronstar.dyndns.org>
  8. */
  9. #include <linux/delay.h>
  10. #include <linux/i2c.h>
  11. #include <linux/init.h>
  12. #include <linux/kernel.h>
  13. #include <linux/math64.h>
  14. #include <linux/module.h>
  15. #include <linux/mutex.h>
  16. #include <linux/slab.h>
  17. #include <linux/v4l2-mediabus.h>
  18. #include <media/media-entity.h>
  19. #include <media/i2c/mt9m032.h>
  20. #include <media/v4l2-ctrls.h>
  21. #include <media/v4l2-device.h>
  22. #include <media/v4l2-subdev.h>
  23. #include "aptina-pll.h"
  24. /*
  25. * width and height include active boundary and black parts
  26. *
  27. * column 0- 15 active boundary
  28. * column 16-1455 image
  29. * column 1456-1471 active boundary
  30. * column 1472-1599 black
  31. *
  32. * row 0- 51 black
  33. * row 53- 59 active boundary
  34. * row 60-1139 image
  35. * row 1140-1147 active boundary
  36. * row 1148-1151 black
  37. */
  38. #define MT9M032_PIXEL_ARRAY_WIDTH 1600
  39. #define MT9M032_PIXEL_ARRAY_HEIGHT 1152
  40. #define MT9M032_CHIP_VERSION 0x00
  41. #define MT9M032_CHIP_VERSION_VALUE 0x1402
  42. #define MT9M032_ROW_START 0x01
  43. #define MT9M032_ROW_START_MIN 0
  44. #define MT9M032_ROW_START_MAX 1152
  45. #define MT9M032_ROW_START_DEF 60
  46. #define MT9M032_COLUMN_START 0x02
  47. #define MT9M032_COLUMN_START_MIN 0
  48. #define MT9M032_COLUMN_START_MAX 1600
  49. #define MT9M032_COLUMN_START_DEF 16
  50. #define MT9M032_ROW_SIZE 0x03
  51. #define MT9M032_ROW_SIZE_MIN 32
  52. #define MT9M032_ROW_SIZE_MAX 1152
  53. #define MT9M032_ROW_SIZE_DEF 1080
  54. #define MT9M032_COLUMN_SIZE 0x04
  55. #define MT9M032_COLUMN_SIZE_MIN 32
  56. #define MT9M032_COLUMN_SIZE_MAX 1600
  57. #define MT9M032_COLUMN_SIZE_DEF 1440
  58. #define MT9M032_HBLANK 0x05
  59. #define MT9M032_VBLANK 0x06
  60. #define MT9M032_VBLANK_MAX 0x7ff
  61. #define MT9M032_SHUTTER_WIDTH_HIGH 0x08
  62. #define MT9M032_SHUTTER_WIDTH_LOW 0x09
  63. #define MT9M032_SHUTTER_WIDTH_MIN 1
  64. #define MT9M032_SHUTTER_WIDTH_MAX 1048575
  65. #define MT9M032_SHUTTER_WIDTH_DEF 1943
  66. #define MT9M032_PIX_CLK_CTRL 0x0a
  67. #define MT9M032_PIX_CLK_CTRL_INV_PIXCLK 0x8000
  68. #define MT9M032_RESTART 0x0b
  69. #define MT9M032_RESET 0x0d
  70. #define MT9M032_PLL_CONFIG1 0x11
  71. #define MT9M032_PLL_CONFIG1_PREDIV_MASK 0x3f
  72. #define MT9M032_PLL_CONFIG1_MUL_SHIFT 8
  73. #define MT9M032_READ_MODE1 0x1e
  74. #define MT9M032_READ_MODE1_OUTPUT_BAD_FRAMES (1 << 13)
  75. #define MT9M032_READ_MODE1_MAINTAIN_FRAME_RATE (1 << 12)
  76. #define MT9M032_READ_MODE1_XOR_LINE_VALID (1 << 11)
  77. #define MT9M032_READ_MODE1_CONT_LINE_VALID (1 << 10)
  78. #define MT9M032_READ_MODE1_INVERT_TRIGGER (1 << 9)
  79. #define MT9M032_READ_MODE1_SNAPSHOT (1 << 8)
  80. #define MT9M032_READ_MODE1_GLOBAL_RESET (1 << 7)
  81. #define MT9M032_READ_MODE1_BULB_EXPOSURE (1 << 6)
  82. #define MT9M032_READ_MODE1_INVERT_STROBE (1 << 5)
  83. #define MT9M032_READ_MODE1_STROBE_ENABLE (1 << 4)
  84. #define MT9M032_READ_MODE1_STROBE_START_TRIG1 (0 << 2)
  85. #define MT9M032_READ_MODE1_STROBE_START_EXP (1 << 2)
  86. #define MT9M032_READ_MODE1_STROBE_START_SHUTTER (2 << 2)
  87. #define MT9M032_READ_MODE1_STROBE_START_TRIG2 (3 << 2)
  88. #define MT9M032_READ_MODE1_STROBE_END_TRIG1 (0 << 0)
  89. #define MT9M032_READ_MODE1_STROBE_END_EXP (1 << 0)
  90. #define MT9M032_READ_MODE1_STROBE_END_SHUTTER (2 << 0)
  91. #define MT9M032_READ_MODE1_STROBE_END_TRIG2 (3 << 0)
  92. #define MT9M032_READ_MODE2 0x20
  93. #define MT9M032_READ_MODE2_VFLIP_SHIFT 15
  94. #define MT9M032_READ_MODE2_HFLIP_SHIFT 14
  95. #define MT9M032_READ_MODE2_ROW_BLC 0x40
  96. #define MT9M032_GAIN_GREEN1 0x2b
  97. #define MT9M032_GAIN_BLUE 0x2c
  98. #define MT9M032_GAIN_RED 0x2d
  99. #define MT9M032_GAIN_GREEN2 0x2e
  100. /* write only */
  101. #define MT9M032_GAIN_ALL 0x35
  102. #define MT9M032_GAIN_DIGITAL_MASK 0x7f
  103. #define MT9M032_GAIN_DIGITAL_SHIFT 8
  104. #define MT9M032_GAIN_AMUL_SHIFT 6
  105. #define MT9M032_GAIN_ANALOG_MASK 0x3f
  106. #define MT9M032_FORMATTER1 0x9e
  107. #define MT9M032_FORMATTER1_PLL_P1_6 (1 << 8)
  108. #define MT9M032_FORMATTER1_PARALLEL (1 << 12)
  109. #define MT9M032_FORMATTER2 0x9f
  110. #define MT9M032_FORMATTER2_DOUT_EN 0x1000
  111. #define MT9M032_FORMATTER2_PIXCLK_EN 0x2000
  112. /*
  113. * The available MT9M032 datasheet is missing documentation for register 0x10
  114. * MT9P031 seems to be close enough, so use constants from that datasheet for
  115. * now.
  116. * But keep the name MT9P031 to remind us, that this isn't really confirmed
  117. * for this sensor.
  118. */
  119. #define MT9P031_PLL_CONTROL 0x10
  120. #define MT9P031_PLL_CONTROL_PWROFF 0x0050
  121. #define MT9P031_PLL_CONTROL_PWRON 0x0051
  122. #define MT9P031_PLL_CONTROL_USEPLL 0x0052
  123. struct mt9m032 {
  124. struct v4l2_subdev subdev;
  125. struct media_pad pad;
  126. struct mt9m032_platform_data *pdata;
  127. unsigned int pix_clock;
  128. struct v4l2_ctrl_handler ctrls;
  129. struct {
  130. struct v4l2_ctrl *hflip;
  131. struct v4l2_ctrl *vflip;
  132. };
  133. struct mutex lock; /* Protects streaming, format, interval and crop */
  134. bool streaming;
  135. struct v4l2_mbus_framefmt format;
  136. struct v4l2_rect crop;
  137. struct v4l2_fract frame_interval;
  138. };
  139. #define to_mt9m032(sd) container_of(sd, struct mt9m032, subdev)
  140. #define to_dev(sensor) \
  141. (&((struct i2c_client *)v4l2_get_subdevdata(&(sensor)->subdev))->dev)
  142. static int mt9m032_read(struct i2c_client *client, u8 reg)
  143. {
  144. return i2c_smbus_read_word_swapped(client, reg);
  145. }
  146. static int mt9m032_write(struct i2c_client *client, u8 reg, const u16 data)
  147. {
  148. return i2c_smbus_write_word_swapped(client, reg, data);
  149. }
  150. static u32 mt9m032_row_time(struct mt9m032 *sensor, unsigned int width)
  151. {
  152. unsigned int effective_width;
  153. u32 ns;
  154. effective_width = width + 716; /* empirical value */
  155. ns = div_u64(1000000000ULL * effective_width, sensor->pix_clock);
  156. dev_dbg(to_dev(sensor), "MT9M032 line time: %u ns\n", ns);
  157. return ns;
  158. }
  159. static int mt9m032_update_timing(struct mt9m032 *sensor,
  160. struct v4l2_fract *interval)
  161. {
  162. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  163. struct v4l2_rect *crop = &sensor->crop;
  164. unsigned int min_vblank;
  165. unsigned int vblank;
  166. u32 row_time;
  167. if (!interval)
  168. interval = &sensor->frame_interval;
  169. row_time = mt9m032_row_time(sensor, crop->width);
  170. vblank = div_u64(1000000000ULL * interval->numerator,
  171. (u64)row_time * interval->denominator)
  172. - crop->height;
  173. if (vblank > MT9M032_VBLANK_MAX) {
  174. /* hardware limits to 11 bit values */
  175. interval->denominator = 1000;
  176. interval->numerator =
  177. div_u64((crop->height + MT9M032_VBLANK_MAX) *
  178. (u64)row_time * interval->denominator,
  179. 1000000000ULL);
  180. vblank = div_u64(1000000000ULL * interval->numerator,
  181. (u64)row_time * interval->denominator)
  182. - crop->height;
  183. }
  184. /* enforce minimal 1.6ms blanking time. */
  185. min_vblank = 1600000 / row_time;
  186. vblank = clamp_t(unsigned int, vblank, min_vblank, MT9M032_VBLANK_MAX);
  187. return mt9m032_write(client, MT9M032_VBLANK, vblank);
  188. }
  189. static int mt9m032_update_geom_timing(struct mt9m032 *sensor)
  190. {
  191. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  192. int ret;
  193. ret = mt9m032_write(client, MT9M032_COLUMN_SIZE,
  194. sensor->crop.width - 1);
  195. if (!ret)
  196. ret = mt9m032_write(client, MT9M032_ROW_SIZE,
  197. sensor->crop.height - 1);
  198. if (!ret)
  199. ret = mt9m032_write(client, MT9M032_COLUMN_START,
  200. sensor->crop.left);
  201. if (!ret)
  202. ret = mt9m032_write(client, MT9M032_ROW_START,
  203. sensor->crop.top);
  204. if (!ret)
  205. ret = mt9m032_update_timing(sensor, NULL);
  206. return ret;
  207. }
  208. static int update_formatter2(struct mt9m032 *sensor, bool streaming)
  209. {
  210. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  211. u16 reg_val = MT9M032_FORMATTER2_DOUT_EN
  212. | 0x0070; /* parts reserved! */
  213. /* possibly for changing to 14-bit mode */
  214. if (streaming)
  215. reg_val |= MT9M032_FORMATTER2_PIXCLK_EN; /* pixclock enable */
  216. return mt9m032_write(client, MT9M032_FORMATTER2, reg_val);
  217. }
  218. static int mt9m032_setup_pll(struct mt9m032 *sensor)
  219. {
  220. static const struct aptina_pll_limits limits = {
  221. .ext_clock_min = 8000000,
  222. .ext_clock_max = 16500000,
  223. .int_clock_min = 2000000,
  224. .int_clock_max = 24000000,
  225. .out_clock_min = 322000000,
  226. .out_clock_max = 693000000,
  227. .pix_clock_max = 99000000,
  228. .n_min = 1,
  229. .n_max = 64,
  230. .m_min = 16,
  231. .m_max = 255,
  232. .p1_min = 6,
  233. .p1_max = 7,
  234. };
  235. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  236. struct mt9m032_platform_data *pdata = sensor->pdata;
  237. struct aptina_pll pll;
  238. u16 reg_val;
  239. int ret;
  240. pll.ext_clock = pdata->ext_clock;
  241. pll.pix_clock = pdata->pix_clock;
  242. ret = aptina_pll_calculate(&client->dev, &limits, &pll);
  243. if (ret < 0)
  244. return ret;
  245. sensor->pix_clock = pdata->pix_clock;
  246. ret = mt9m032_write(client, MT9M032_PLL_CONFIG1,
  247. (pll.m << MT9M032_PLL_CONFIG1_MUL_SHIFT) |
  248. ((pll.n - 1) & MT9M032_PLL_CONFIG1_PREDIV_MASK));
  249. if (!ret)
  250. ret = mt9m032_write(client, MT9P031_PLL_CONTROL,
  251. MT9P031_PLL_CONTROL_PWRON |
  252. MT9P031_PLL_CONTROL_USEPLL);
  253. if (!ret) /* more reserved, Continuous, Master Mode */
  254. ret = mt9m032_write(client, MT9M032_READ_MODE1, 0x8000 |
  255. MT9M032_READ_MODE1_STROBE_START_EXP |
  256. MT9M032_READ_MODE1_STROBE_END_SHUTTER);
  257. if (!ret) {
  258. reg_val = (pll.p1 == 6 ? MT9M032_FORMATTER1_PLL_P1_6 : 0)
  259. | MT9M032_FORMATTER1_PARALLEL | 0x001e; /* 14-bit */
  260. ret = mt9m032_write(client, MT9M032_FORMATTER1, reg_val);
  261. }
  262. return ret;
  263. }
  264. /* -----------------------------------------------------------------------------
  265. * Subdev pad operations
  266. */
  267. static int mt9m032_enum_mbus_code(struct v4l2_subdev *subdev,
  268. struct v4l2_subdev_pad_config *cfg,
  269. struct v4l2_subdev_mbus_code_enum *code)
  270. {
  271. if (code->index != 0)
  272. return -EINVAL;
  273. code->code = MEDIA_BUS_FMT_Y8_1X8;
  274. return 0;
  275. }
  276. static int mt9m032_enum_frame_size(struct v4l2_subdev *subdev,
  277. struct v4l2_subdev_pad_config *cfg,
  278. struct v4l2_subdev_frame_size_enum *fse)
  279. {
  280. if (fse->index != 0 || fse->code != MEDIA_BUS_FMT_Y8_1X8)
  281. return -EINVAL;
  282. fse->min_width = MT9M032_COLUMN_SIZE_DEF;
  283. fse->max_width = MT9M032_COLUMN_SIZE_DEF;
  284. fse->min_height = MT9M032_ROW_SIZE_DEF;
  285. fse->max_height = MT9M032_ROW_SIZE_DEF;
  286. return 0;
  287. }
  288. /**
  289. * __mt9m032_get_pad_crop() - get crop rect
  290. * @sensor: pointer to the sensor struct
  291. * @cfg: v4l2_subdev_pad_config for getting the try crop rect from
  292. * @which: select try or active crop rect
  293. *
  294. * Returns a pointer the current active or fh relative try crop rect
  295. */
  296. static struct v4l2_rect *
  297. __mt9m032_get_pad_crop(struct mt9m032 *sensor, struct v4l2_subdev_pad_config *cfg,
  298. enum v4l2_subdev_format_whence which)
  299. {
  300. switch (which) {
  301. case V4L2_SUBDEV_FORMAT_TRY:
  302. return v4l2_subdev_get_try_crop(&sensor->subdev, cfg, 0);
  303. case V4L2_SUBDEV_FORMAT_ACTIVE:
  304. return &sensor->crop;
  305. default:
  306. return NULL;
  307. }
  308. }
  309. /**
  310. * __mt9m032_get_pad_format() - get format
  311. * @sensor: pointer to the sensor struct
  312. * @cfg: v4l2_subdev_pad_config for getting the try format from
  313. * @which: select try or active format
  314. *
  315. * Returns a pointer the current active or fh relative try format
  316. */
  317. static struct v4l2_mbus_framefmt *
  318. __mt9m032_get_pad_format(struct mt9m032 *sensor, struct v4l2_subdev_pad_config *cfg,
  319. enum v4l2_subdev_format_whence which)
  320. {
  321. switch (which) {
  322. case V4L2_SUBDEV_FORMAT_TRY:
  323. return v4l2_subdev_get_try_format(&sensor->subdev, cfg, 0);
  324. case V4L2_SUBDEV_FORMAT_ACTIVE:
  325. return &sensor->format;
  326. default:
  327. return NULL;
  328. }
  329. }
  330. static int mt9m032_get_pad_format(struct v4l2_subdev *subdev,
  331. struct v4l2_subdev_pad_config *cfg,
  332. struct v4l2_subdev_format *fmt)
  333. {
  334. struct mt9m032 *sensor = to_mt9m032(subdev);
  335. mutex_lock(&sensor->lock);
  336. fmt->format = *__mt9m032_get_pad_format(sensor, cfg, fmt->which);
  337. mutex_unlock(&sensor->lock);
  338. return 0;
  339. }
  340. static int mt9m032_set_pad_format(struct v4l2_subdev *subdev,
  341. struct v4l2_subdev_pad_config *cfg,
  342. struct v4l2_subdev_format *fmt)
  343. {
  344. struct mt9m032 *sensor = to_mt9m032(subdev);
  345. int ret;
  346. mutex_lock(&sensor->lock);
  347. if (sensor->streaming && fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
  348. ret = -EBUSY;
  349. goto done;
  350. }
  351. /* Scaling is not supported, the format is thus fixed. */
  352. fmt->format = *__mt9m032_get_pad_format(sensor, cfg, fmt->which);
  353. ret = 0;
  354. done:
  355. mutex_unlock(&sensor->lock);
  356. return ret;
  357. }
  358. static int mt9m032_get_pad_selection(struct v4l2_subdev *subdev,
  359. struct v4l2_subdev_pad_config *cfg,
  360. struct v4l2_subdev_selection *sel)
  361. {
  362. struct mt9m032 *sensor = to_mt9m032(subdev);
  363. if (sel->target != V4L2_SEL_TGT_CROP)
  364. return -EINVAL;
  365. mutex_lock(&sensor->lock);
  366. sel->r = *__mt9m032_get_pad_crop(sensor, cfg, sel->which);
  367. mutex_unlock(&sensor->lock);
  368. return 0;
  369. }
  370. static int mt9m032_set_pad_selection(struct v4l2_subdev *subdev,
  371. struct v4l2_subdev_pad_config *cfg,
  372. struct v4l2_subdev_selection *sel)
  373. {
  374. struct mt9m032 *sensor = to_mt9m032(subdev);
  375. struct v4l2_mbus_framefmt *format;
  376. struct v4l2_rect *__crop;
  377. struct v4l2_rect rect;
  378. int ret = 0;
  379. if (sel->target != V4L2_SEL_TGT_CROP)
  380. return -EINVAL;
  381. mutex_lock(&sensor->lock);
  382. if (sensor->streaming && sel->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
  383. ret = -EBUSY;
  384. goto done;
  385. }
  386. /* Clamp the crop rectangle boundaries and align them to a multiple of 2
  387. * pixels to ensure a GRBG Bayer pattern.
  388. */
  389. rect.left = clamp(ALIGN(sel->r.left, 2), MT9M032_COLUMN_START_MIN,
  390. MT9M032_COLUMN_START_MAX);
  391. rect.top = clamp(ALIGN(sel->r.top, 2), MT9M032_ROW_START_MIN,
  392. MT9M032_ROW_START_MAX);
  393. rect.width = clamp_t(unsigned int, ALIGN(sel->r.width, 2),
  394. MT9M032_COLUMN_SIZE_MIN, MT9M032_COLUMN_SIZE_MAX);
  395. rect.height = clamp_t(unsigned int, ALIGN(sel->r.height, 2),
  396. MT9M032_ROW_SIZE_MIN, MT9M032_ROW_SIZE_MAX);
  397. rect.width = min_t(unsigned int, rect.width,
  398. MT9M032_PIXEL_ARRAY_WIDTH - rect.left);
  399. rect.height = min_t(unsigned int, rect.height,
  400. MT9M032_PIXEL_ARRAY_HEIGHT - rect.top);
  401. __crop = __mt9m032_get_pad_crop(sensor, cfg, sel->which);
  402. if (rect.width != __crop->width || rect.height != __crop->height) {
  403. /* Reset the output image size if the crop rectangle size has
  404. * been modified.
  405. */
  406. format = __mt9m032_get_pad_format(sensor, cfg, sel->which);
  407. format->width = rect.width;
  408. format->height = rect.height;
  409. }
  410. *__crop = rect;
  411. sel->r = rect;
  412. if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE)
  413. ret = mt9m032_update_geom_timing(sensor);
  414. done:
  415. mutex_unlock(&sensor->lock);
  416. return ret;
  417. }
  418. static int mt9m032_get_frame_interval(struct v4l2_subdev *subdev,
  419. struct v4l2_subdev_frame_interval *fi)
  420. {
  421. struct mt9m032 *sensor = to_mt9m032(subdev);
  422. mutex_lock(&sensor->lock);
  423. memset(fi, 0, sizeof(*fi));
  424. fi->interval = sensor->frame_interval;
  425. mutex_unlock(&sensor->lock);
  426. return 0;
  427. }
  428. static int mt9m032_set_frame_interval(struct v4l2_subdev *subdev,
  429. struct v4l2_subdev_frame_interval *fi)
  430. {
  431. struct mt9m032 *sensor = to_mt9m032(subdev);
  432. int ret;
  433. mutex_lock(&sensor->lock);
  434. if (sensor->streaming) {
  435. ret = -EBUSY;
  436. goto done;
  437. }
  438. /* Avoid divisions by 0. */
  439. if (fi->interval.denominator == 0)
  440. fi->interval.denominator = 1;
  441. ret = mt9m032_update_timing(sensor, &fi->interval);
  442. if (!ret)
  443. sensor->frame_interval = fi->interval;
  444. done:
  445. mutex_unlock(&sensor->lock);
  446. return ret;
  447. }
  448. static int mt9m032_s_stream(struct v4l2_subdev *subdev, int streaming)
  449. {
  450. struct mt9m032 *sensor = to_mt9m032(subdev);
  451. int ret;
  452. mutex_lock(&sensor->lock);
  453. ret = update_formatter2(sensor, streaming);
  454. if (!ret)
  455. sensor->streaming = streaming;
  456. mutex_unlock(&sensor->lock);
  457. return ret;
  458. }
  459. /* -----------------------------------------------------------------------------
  460. * V4L2 subdev core operations
  461. */
  462. #ifdef CONFIG_VIDEO_ADV_DEBUG
  463. static int mt9m032_g_register(struct v4l2_subdev *sd,
  464. struct v4l2_dbg_register *reg)
  465. {
  466. struct mt9m032 *sensor = to_mt9m032(sd);
  467. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  468. int val;
  469. if (reg->reg > 0xff)
  470. return -EINVAL;
  471. val = mt9m032_read(client, reg->reg);
  472. if (val < 0)
  473. return -EIO;
  474. reg->size = 2;
  475. reg->val = val;
  476. return 0;
  477. }
  478. static int mt9m032_s_register(struct v4l2_subdev *sd,
  479. const struct v4l2_dbg_register *reg)
  480. {
  481. struct mt9m032 *sensor = to_mt9m032(sd);
  482. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  483. if (reg->reg > 0xff)
  484. return -EINVAL;
  485. return mt9m032_write(client, reg->reg, reg->val);
  486. }
  487. #endif
  488. /* -----------------------------------------------------------------------------
  489. * V4L2 subdev control operations
  490. */
  491. static int update_read_mode2(struct mt9m032 *sensor, bool vflip, bool hflip)
  492. {
  493. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  494. int reg_val = (vflip << MT9M032_READ_MODE2_VFLIP_SHIFT)
  495. | (hflip << MT9M032_READ_MODE2_HFLIP_SHIFT)
  496. | MT9M032_READ_MODE2_ROW_BLC
  497. | 0x0007;
  498. return mt9m032_write(client, MT9M032_READ_MODE2, reg_val);
  499. }
  500. static int mt9m032_set_gain(struct mt9m032 *sensor, s32 val)
  501. {
  502. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  503. int digital_gain_val; /* in 1/8th (0..127) */
  504. int analog_mul; /* 0 or 1 */
  505. int analog_gain_val; /* in 1/16th. (0..63) */
  506. u16 reg_val;
  507. digital_gain_val = 51; /* from setup example */
  508. if (val < 63) {
  509. analog_mul = 0;
  510. analog_gain_val = val;
  511. } else {
  512. analog_mul = 1;
  513. analog_gain_val = val / 2;
  514. }
  515. /* a_gain = (1 + analog_mul) + (analog_gain_val + 1) / 16 */
  516. /* overall_gain = a_gain * (1 + digital_gain_val / 8) */
  517. reg_val = ((digital_gain_val & MT9M032_GAIN_DIGITAL_MASK)
  518. << MT9M032_GAIN_DIGITAL_SHIFT)
  519. | ((analog_mul & 1) << MT9M032_GAIN_AMUL_SHIFT)
  520. | (analog_gain_val & MT9M032_GAIN_ANALOG_MASK);
  521. return mt9m032_write(client, MT9M032_GAIN_ALL, reg_val);
  522. }
  523. static int mt9m032_try_ctrl(struct v4l2_ctrl *ctrl)
  524. {
  525. if (ctrl->id == V4L2_CID_GAIN && ctrl->val >= 63) {
  526. /* round because of multiplier used for values >= 63 */
  527. ctrl->val &= ~1;
  528. }
  529. return 0;
  530. }
  531. static int mt9m032_set_ctrl(struct v4l2_ctrl *ctrl)
  532. {
  533. struct mt9m032 *sensor =
  534. container_of(ctrl->handler, struct mt9m032, ctrls);
  535. struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
  536. int ret;
  537. switch (ctrl->id) {
  538. case V4L2_CID_GAIN:
  539. return mt9m032_set_gain(sensor, ctrl->val);
  540. case V4L2_CID_HFLIP:
  541. /* case V4L2_CID_VFLIP: -- In the same cluster */
  542. return update_read_mode2(sensor, sensor->vflip->val,
  543. sensor->hflip->val);
  544. case V4L2_CID_EXPOSURE:
  545. ret = mt9m032_write(client, MT9M032_SHUTTER_WIDTH_HIGH,
  546. (ctrl->val >> 16) & 0xffff);
  547. if (ret < 0)
  548. return ret;
  549. return mt9m032_write(client, MT9M032_SHUTTER_WIDTH_LOW,
  550. ctrl->val & 0xffff);
  551. }
  552. return 0;
  553. }
  554. static const struct v4l2_ctrl_ops mt9m032_ctrl_ops = {
  555. .s_ctrl = mt9m032_set_ctrl,
  556. .try_ctrl = mt9m032_try_ctrl,
  557. };
  558. /* -------------------------------------------------------------------------- */
  559. static const struct v4l2_subdev_core_ops mt9m032_core_ops = {
  560. #ifdef CONFIG_VIDEO_ADV_DEBUG
  561. .g_register = mt9m032_g_register,
  562. .s_register = mt9m032_s_register,
  563. #endif
  564. };
  565. static const struct v4l2_subdev_video_ops mt9m032_video_ops = {
  566. .s_stream = mt9m032_s_stream,
  567. .g_frame_interval = mt9m032_get_frame_interval,
  568. .s_frame_interval = mt9m032_set_frame_interval,
  569. };
  570. static const struct v4l2_subdev_pad_ops mt9m032_pad_ops = {
  571. .enum_mbus_code = mt9m032_enum_mbus_code,
  572. .enum_frame_size = mt9m032_enum_frame_size,
  573. .get_fmt = mt9m032_get_pad_format,
  574. .set_fmt = mt9m032_set_pad_format,
  575. .set_selection = mt9m032_set_pad_selection,
  576. .get_selection = mt9m032_get_pad_selection,
  577. };
  578. static const struct v4l2_subdev_ops mt9m032_ops = {
  579. .core = &mt9m032_core_ops,
  580. .video = &mt9m032_video_ops,
  581. .pad = &mt9m032_pad_ops,
  582. };
  583. /* -----------------------------------------------------------------------------
  584. * Driver initialization and probing
  585. */
  586. static int mt9m032_probe(struct i2c_client *client,
  587. const struct i2c_device_id *devid)
  588. {
  589. struct mt9m032_platform_data *pdata = client->dev.platform_data;
  590. struct i2c_adapter *adapter = client->adapter;
  591. struct mt9m032 *sensor;
  592. int chip_version;
  593. int ret;
  594. if (pdata == NULL) {
  595. dev_err(&client->dev, "No platform data\n");
  596. return -EINVAL;
  597. }
  598. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
  599. dev_warn(&client->dev,
  600. "I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
  601. return -EIO;
  602. }
  603. if (!client->dev.platform_data)
  604. return -ENODEV;
  605. sensor = devm_kzalloc(&client->dev, sizeof(*sensor), GFP_KERNEL);
  606. if (sensor == NULL)
  607. return -ENOMEM;
  608. mutex_init(&sensor->lock);
  609. sensor->pdata = pdata;
  610. v4l2_i2c_subdev_init(&sensor->subdev, client, &mt9m032_ops);
  611. sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
  612. chip_version = mt9m032_read(client, MT9M032_CHIP_VERSION);
  613. if (chip_version != MT9M032_CHIP_VERSION_VALUE) {
  614. dev_err(&client->dev, "MT9M032 not detected, wrong version "
  615. "0x%04x\n", chip_version);
  616. ret = -ENODEV;
  617. goto error_sensor;
  618. }
  619. dev_info(&client->dev, "MT9M032 detected at address 0x%02x\n",
  620. client->addr);
  621. sensor->frame_interval.numerator = 1;
  622. sensor->frame_interval.denominator = 30;
  623. sensor->crop.left = MT9M032_COLUMN_START_DEF;
  624. sensor->crop.top = MT9M032_ROW_START_DEF;
  625. sensor->crop.width = MT9M032_COLUMN_SIZE_DEF;
  626. sensor->crop.height = MT9M032_ROW_SIZE_DEF;
  627. sensor->format.width = sensor->crop.width;
  628. sensor->format.height = sensor->crop.height;
  629. sensor->format.code = MEDIA_BUS_FMT_Y8_1X8;
  630. sensor->format.field = V4L2_FIELD_NONE;
  631. sensor->format.colorspace = V4L2_COLORSPACE_SRGB;
  632. v4l2_ctrl_handler_init(&sensor->ctrls, 5);
  633. v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
  634. V4L2_CID_GAIN, 0, 127, 1, 64);
  635. sensor->hflip = v4l2_ctrl_new_std(&sensor->ctrls,
  636. &mt9m032_ctrl_ops,
  637. V4L2_CID_HFLIP, 0, 1, 1, 0);
  638. sensor->vflip = v4l2_ctrl_new_std(&sensor->ctrls,
  639. &mt9m032_ctrl_ops,
  640. V4L2_CID_VFLIP, 0, 1, 1, 0);
  641. v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
  642. V4L2_CID_EXPOSURE, MT9M032_SHUTTER_WIDTH_MIN,
  643. MT9M032_SHUTTER_WIDTH_MAX, 1,
  644. MT9M032_SHUTTER_WIDTH_DEF);
  645. v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
  646. V4L2_CID_PIXEL_RATE, pdata->pix_clock,
  647. pdata->pix_clock, 1, pdata->pix_clock);
  648. if (sensor->ctrls.error) {
  649. ret = sensor->ctrls.error;
  650. dev_err(&client->dev, "control initialization error %d\n", ret);
  651. goto error_ctrl;
  652. }
  653. v4l2_ctrl_cluster(2, &sensor->hflip);
  654. sensor->subdev.ctrl_handler = &sensor->ctrls;
  655. sensor->subdev.entity.function = MEDIA_ENT_F_CAM_SENSOR;
  656. sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
  657. ret = media_entity_pads_init(&sensor->subdev.entity, 1, &sensor->pad);
  658. if (ret < 0)
  659. goto error_ctrl;
  660. ret = mt9m032_write(client, MT9M032_RESET, 1); /* reset on */
  661. if (ret < 0)
  662. goto error_entity;
  663. ret = mt9m032_write(client, MT9M032_RESET, 0); /* reset off */
  664. if (ret < 0)
  665. goto error_entity;
  666. ret = mt9m032_setup_pll(sensor);
  667. if (ret < 0)
  668. goto error_entity;
  669. usleep_range(10000, 11000);
  670. ret = v4l2_ctrl_handler_setup(&sensor->ctrls);
  671. if (ret < 0)
  672. goto error_entity;
  673. /* SIZE */
  674. ret = mt9m032_update_geom_timing(sensor);
  675. if (ret < 0)
  676. goto error_entity;
  677. ret = mt9m032_write(client, 0x41, 0x0000); /* reserved !!! */
  678. if (ret < 0)
  679. goto error_entity;
  680. ret = mt9m032_write(client, 0x42, 0x0003); /* reserved !!! */
  681. if (ret < 0)
  682. goto error_entity;
  683. ret = mt9m032_write(client, 0x43, 0x0003); /* reserved !!! */
  684. if (ret < 0)
  685. goto error_entity;
  686. ret = mt9m032_write(client, 0x7f, 0x0000); /* reserved !!! */
  687. if (ret < 0)
  688. goto error_entity;
  689. if (sensor->pdata->invert_pixclock) {
  690. ret = mt9m032_write(client, MT9M032_PIX_CLK_CTRL,
  691. MT9M032_PIX_CLK_CTRL_INV_PIXCLK);
  692. if (ret < 0)
  693. goto error_entity;
  694. }
  695. ret = mt9m032_write(client, MT9M032_RESTART, 1); /* Restart on */
  696. if (ret < 0)
  697. goto error_entity;
  698. msleep(100);
  699. ret = mt9m032_write(client, MT9M032_RESTART, 0); /* Restart off */
  700. if (ret < 0)
  701. goto error_entity;
  702. msleep(100);
  703. ret = update_formatter2(sensor, false);
  704. if (ret < 0)
  705. goto error_entity;
  706. return ret;
  707. error_entity:
  708. media_entity_cleanup(&sensor->subdev.entity);
  709. error_ctrl:
  710. v4l2_ctrl_handler_free(&sensor->ctrls);
  711. error_sensor:
  712. mutex_destroy(&sensor->lock);
  713. return ret;
  714. }
  715. static int mt9m032_remove(struct i2c_client *client)
  716. {
  717. struct v4l2_subdev *subdev = i2c_get_clientdata(client);
  718. struct mt9m032 *sensor = to_mt9m032(subdev);
  719. v4l2_device_unregister_subdev(subdev);
  720. v4l2_ctrl_handler_free(&sensor->ctrls);
  721. media_entity_cleanup(&subdev->entity);
  722. mutex_destroy(&sensor->lock);
  723. return 0;
  724. }
  725. static const struct i2c_device_id mt9m032_id_table[] = {
  726. { MT9M032_NAME, 0 },
  727. { }
  728. };
  729. MODULE_DEVICE_TABLE(i2c, mt9m032_id_table);
  730. static struct i2c_driver mt9m032_i2c_driver = {
  731. .driver = {
  732. .name = MT9M032_NAME,
  733. },
  734. .probe = mt9m032_probe,
  735. .remove = mt9m032_remove,
  736. .id_table = mt9m032_id_table,
  737. };
  738. module_i2c_driver(mt9m032_i2c_driver);
  739. MODULE_AUTHOR("Martin Hostettler <martin@neutronstar.dyndns.org>");
  740. MODULE_DESCRIPTION("MT9M032 camera sensor driver");
  741. MODULE_LICENSE("GPL v2");