m5mols_core.c 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038
  1. /*
  2. * Driver for M-5MOLS 8M Pixel camera sensor with ISP
  3. *
  4. * Copyright (C) 2011 Samsung Electronics Co., Ltd.
  5. * Author: HeungJun Kim <riverful.kim@samsung.com>
  6. *
  7. * Copyright (C) 2009 Samsung Electronics Co., Ltd.
  8. * Author: Dongsoo Nathaniel Kim <dongsoo45.kim@samsung.com>
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. */
  15. #include <linux/i2c.h>
  16. #include <linux/slab.h>
  17. #include <linux/irq.h>
  18. #include <linux/interrupt.h>
  19. #include <linux/delay.h>
  20. #include <linux/gpio.h>
  21. #include <linux/regulator/consumer.h>
  22. #include <linux/videodev2.h>
  23. #include <linux/module.h>
  24. #include <media/v4l2-ctrls.h>
  25. #include <media/v4l2-device.h>
  26. #include <media/v4l2-subdev.h>
  27. #include <media/m5mols.h>
  28. #include "m5mols.h"
  29. #include "m5mols_reg.h"
  30. int m5mols_debug;
  31. module_param(m5mols_debug, int, 0644);
  32. #define MODULE_NAME "M5MOLS"
  33. #define M5MOLS_I2C_CHECK_RETRY 500
  34. /* The regulator consumer names for external voltage regulators */
  35. static struct regulator_bulk_data supplies[] = {
  36. {
  37. .supply = "core", /* ARM core power, 1.2V */
  38. }, {
  39. .supply = "dig_18", /* digital power 1, 1.8V */
  40. }, {
  41. .supply = "d_sensor", /* sensor power 1, 1.8V */
  42. }, {
  43. .supply = "dig_28", /* digital power 2, 2.8V */
  44. }, {
  45. .supply = "a_sensor", /* analog power */
  46. }, {
  47. .supply = "dig_12", /* digital power 3, 1.2V */
  48. },
  49. };
  50. static struct v4l2_mbus_framefmt m5mols_default_ffmt[M5MOLS_RESTYPE_MAX] = {
  51. [M5MOLS_RESTYPE_MONITOR] = {
  52. .width = 1920,
  53. .height = 1080,
  54. .code = V4L2_MBUS_FMT_VYUY8_2X8,
  55. .field = V4L2_FIELD_NONE,
  56. .colorspace = V4L2_COLORSPACE_JPEG,
  57. },
  58. [M5MOLS_RESTYPE_CAPTURE] = {
  59. .width = 1920,
  60. .height = 1080,
  61. .code = V4L2_MBUS_FMT_JPEG_1X8,
  62. .field = V4L2_FIELD_NONE,
  63. .colorspace = V4L2_COLORSPACE_JPEG,
  64. },
  65. };
  66. #define SIZE_DEFAULT_FFMT ARRAY_SIZE(m5mols_default_ffmt)
  67. static const struct m5mols_resolution m5mols_reg_res[] = {
  68. { 0x01, M5MOLS_RESTYPE_MONITOR, 128, 96 }, /* SUB-QCIF */
  69. { 0x03, M5MOLS_RESTYPE_MONITOR, 160, 120 }, /* QQVGA */
  70. { 0x05, M5MOLS_RESTYPE_MONITOR, 176, 144 }, /* QCIF */
  71. { 0x06, M5MOLS_RESTYPE_MONITOR, 176, 176 },
  72. { 0x08, M5MOLS_RESTYPE_MONITOR, 240, 320 }, /* QVGA */
  73. { 0x09, M5MOLS_RESTYPE_MONITOR, 320, 240 }, /* QVGA */
  74. { 0x0c, M5MOLS_RESTYPE_MONITOR, 240, 400 }, /* WQVGA */
  75. { 0x0d, M5MOLS_RESTYPE_MONITOR, 400, 240 }, /* WQVGA */
  76. { 0x0e, M5MOLS_RESTYPE_MONITOR, 352, 288 }, /* CIF */
  77. { 0x13, M5MOLS_RESTYPE_MONITOR, 480, 360 },
  78. { 0x15, M5MOLS_RESTYPE_MONITOR, 640, 360 }, /* qHD */
  79. { 0x17, M5MOLS_RESTYPE_MONITOR, 640, 480 }, /* VGA */
  80. { 0x18, M5MOLS_RESTYPE_MONITOR, 720, 480 },
  81. { 0x1a, M5MOLS_RESTYPE_MONITOR, 800, 480 }, /* WVGA */
  82. { 0x1f, M5MOLS_RESTYPE_MONITOR, 800, 600 }, /* SVGA */
  83. { 0x21, M5MOLS_RESTYPE_MONITOR, 1280, 720 }, /* HD */
  84. { 0x25, M5MOLS_RESTYPE_MONITOR, 1920, 1080 }, /* 1080p */
  85. { 0x29, M5MOLS_RESTYPE_MONITOR, 3264, 2448 }, /* 2.63fps 8M */
  86. { 0x39, M5MOLS_RESTYPE_MONITOR, 800, 602 }, /* AHS_MON debug */
  87. { 0x02, M5MOLS_RESTYPE_CAPTURE, 320, 240 }, /* QVGA */
  88. { 0x04, M5MOLS_RESTYPE_CAPTURE, 400, 240 }, /* WQVGA */
  89. { 0x07, M5MOLS_RESTYPE_CAPTURE, 480, 360 },
  90. { 0x08, M5MOLS_RESTYPE_CAPTURE, 640, 360 }, /* qHD */
  91. { 0x09, M5MOLS_RESTYPE_CAPTURE, 640, 480 }, /* VGA */
  92. { 0x0a, M5MOLS_RESTYPE_CAPTURE, 800, 480 }, /* WVGA */
  93. { 0x10, M5MOLS_RESTYPE_CAPTURE, 1280, 720 }, /* HD */
  94. { 0x14, M5MOLS_RESTYPE_CAPTURE, 1280, 960 }, /* 1M */
  95. { 0x17, M5MOLS_RESTYPE_CAPTURE, 1600, 1200 }, /* 2M */
  96. { 0x19, M5MOLS_RESTYPE_CAPTURE, 1920, 1080 }, /* Full-HD */
  97. { 0x1a, M5MOLS_RESTYPE_CAPTURE, 2048, 1152 }, /* 3Mega */
  98. { 0x1b, M5MOLS_RESTYPE_CAPTURE, 2048, 1536 },
  99. { 0x1c, M5MOLS_RESTYPE_CAPTURE, 2560, 1440 }, /* 4Mega */
  100. { 0x1d, M5MOLS_RESTYPE_CAPTURE, 2560, 1536 },
  101. { 0x1f, M5MOLS_RESTYPE_CAPTURE, 2560, 1920 }, /* 5Mega */
  102. { 0x21, M5MOLS_RESTYPE_CAPTURE, 3264, 1836 }, /* 6Mega */
  103. { 0x22, M5MOLS_RESTYPE_CAPTURE, 3264, 1960 },
  104. { 0x25, M5MOLS_RESTYPE_CAPTURE, 3264, 2448 }, /* 8Mega */
  105. };
  106. /**
  107. * m5mols_swap_byte - an byte array to integer conversion function
  108. * @size: size in bytes of I2C packet defined in the M-5MOLS datasheet
  109. *
  110. * Convert I2C data byte array with performing any required byte
  111. * reordering to assure proper values for each data type, regardless
  112. * of the architecture endianness.
  113. */
  114. static u32 m5mols_swap_byte(u8 *data, u8 length)
  115. {
  116. if (length == 1)
  117. return *data;
  118. else if (length == 2)
  119. return be16_to_cpu(*((u16 *)data));
  120. else
  121. return be32_to_cpu(*((u32 *)data));
  122. }
  123. /**
  124. * m5mols_read - I2C read function
  125. * @reg: combination of size, category and command for the I2C packet
  126. * @size: desired size of I2C packet
  127. * @val: read value
  128. */
  129. static int m5mols_read(struct v4l2_subdev *sd, u32 size, u32 reg, u32 *val)
  130. {
  131. struct i2c_client *client = v4l2_get_subdevdata(sd);
  132. u8 rbuf[M5MOLS_I2C_MAX_SIZE + 1];
  133. u8 category = I2C_CATEGORY(reg);
  134. u8 cmd = I2C_COMMAND(reg);
  135. struct i2c_msg msg[2];
  136. u8 wbuf[5];
  137. int ret;
  138. if (!client->adapter)
  139. return -ENODEV;
  140. msg[0].addr = client->addr;
  141. msg[0].flags = 0;
  142. msg[0].len = 5;
  143. msg[0].buf = wbuf;
  144. wbuf[0] = 5;
  145. wbuf[1] = M5MOLS_BYTE_READ;
  146. wbuf[2] = category;
  147. wbuf[3] = cmd;
  148. wbuf[4] = size;
  149. msg[1].addr = client->addr;
  150. msg[1].flags = I2C_M_RD;
  151. msg[1].len = size + 1;
  152. msg[1].buf = rbuf;
  153. /* minimum stabilization time */
  154. usleep_range(200, 200);
  155. ret = i2c_transfer(client->adapter, msg, 2);
  156. if (ret < 0) {
  157. v4l2_err(sd, "read failed: size:%d cat:%02x cmd:%02x. %d\n",
  158. size, category, cmd, ret);
  159. return ret;
  160. }
  161. *val = m5mols_swap_byte(&rbuf[1], size);
  162. return 0;
  163. }
  164. int m5mols_read_u8(struct v4l2_subdev *sd, u32 reg, u8 *val)
  165. {
  166. u32 val_32;
  167. int ret;
  168. if (I2C_SIZE(reg) != 1) {
  169. v4l2_err(sd, "Wrong data size\n");
  170. return -EINVAL;
  171. }
  172. ret = m5mols_read(sd, I2C_SIZE(reg), reg, &val_32);
  173. if (ret)
  174. return ret;
  175. *val = (u8)val_32;
  176. return ret;
  177. }
  178. int m5mols_read_u16(struct v4l2_subdev *sd, u32 reg, u16 *val)
  179. {
  180. u32 val_32;
  181. int ret;
  182. if (I2C_SIZE(reg) != 2) {
  183. v4l2_err(sd, "Wrong data size\n");
  184. return -EINVAL;
  185. }
  186. ret = m5mols_read(sd, I2C_SIZE(reg), reg, &val_32);
  187. if (ret)
  188. return ret;
  189. *val = (u16)val_32;
  190. return ret;
  191. }
  192. int m5mols_read_u32(struct v4l2_subdev *sd, u32 reg, u32 *val)
  193. {
  194. if (I2C_SIZE(reg) != 4) {
  195. v4l2_err(sd, "Wrong data size\n");
  196. return -EINVAL;
  197. }
  198. return m5mols_read(sd, I2C_SIZE(reg), reg, val);
  199. }
  200. /**
  201. * m5mols_write - I2C command write function
  202. * @reg: combination of size, category and command for the I2C packet
  203. * @val: value to write
  204. */
  205. int m5mols_write(struct v4l2_subdev *sd, u32 reg, u32 val)
  206. {
  207. struct i2c_client *client = v4l2_get_subdevdata(sd);
  208. u8 wbuf[M5MOLS_I2C_MAX_SIZE + 4];
  209. u8 category = I2C_CATEGORY(reg);
  210. u8 cmd = I2C_COMMAND(reg);
  211. u8 size = I2C_SIZE(reg);
  212. u32 *buf = (u32 *)&wbuf[4];
  213. struct i2c_msg msg[1];
  214. int ret;
  215. if (!client->adapter)
  216. return -ENODEV;
  217. if (size != 1 && size != 2 && size != 4) {
  218. v4l2_err(sd, "Wrong data size\n");
  219. return -EINVAL;
  220. }
  221. msg->addr = client->addr;
  222. msg->flags = 0;
  223. msg->len = (u16)size + 4;
  224. msg->buf = wbuf;
  225. wbuf[0] = size + 4;
  226. wbuf[1] = M5MOLS_BYTE_WRITE;
  227. wbuf[2] = category;
  228. wbuf[3] = cmd;
  229. *buf = m5mols_swap_byte((u8 *)&val, size);
  230. usleep_range(200, 200);
  231. ret = i2c_transfer(client->adapter, msg, 1);
  232. if (ret < 0) {
  233. v4l2_err(sd, "write failed: size:%d cat:%02x cmd:%02x. %d\n",
  234. size, category, cmd, ret);
  235. return ret;
  236. }
  237. return 0;
  238. }
  239. int m5mols_busy(struct v4l2_subdev *sd, u8 category, u8 cmd, u8 mask)
  240. {
  241. u8 busy;
  242. int i;
  243. int ret;
  244. for (i = 0; i < M5MOLS_I2C_CHECK_RETRY; i++) {
  245. ret = m5mols_read_u8(sd, I2C_REG(category, cmd, 1), &busy);
  246. if (ret < 0)
  247. return ret;
  248. if ((busy & mask) == mask)
  249. return 0;
  250. }
  251. return -EBUSY;
  252. }
  253. /**
  254. * m5mols_enable_interrupt - Clear interrupt pending bits and unmask interrupts
  255. *
  256. * Before writing desired interrupt value the INT_FACTOR register should
  257. * be read to clear pending interrupts.
  258. */
  259. int m5mols_enable_interrupt(struct v4l2_subdev *sd, u8 reg)
  260. {
  261. struct m5mols_info *info = to_m5mols(sd);
  262. u8 mask = is_available_af(info) ? REG_INT_AF : 0;
  263. u8 dummy;
  264. int ret;
  265. ret = m5mols_read_u8(sd, SYSTEM_INT_FACTOR, &dummy);
  266. if (!ret)
  267. ret = m5mols_write(sd, SYSTEM_INT_ENABLE, reg & ~mask);
  268. return ret;
  269. }
  270. /**
  271. * m5mols_reg_mode - Write the mode and check busy status
  272. *
  273. * It always accompanies a little delay changing the M-5MOLS mode, so it is
  274. * needed checking current busy status to guarantee right mode.
  275. */
  276. static int m5mols_reg_mode(struct v4l2_subdev *sd, u8 mode)
  277. {
  278. int ret = m5mols_write(sd, SYSTEM_SYSMODE, mode);
  279. return ret ? ret : m5mols_busy(sd, CAT_SYSTEM, CAT0_SYSMODE, mode);
  280. }
  281. /**
  282. * m5mols_mode - manage the M-5MOLS's mode
  283. * @mode: the required operation mode
  284. *
  285. * The commands of M-5MOLS are grouped into specific modes. Each functionality
  286. * can be guaranteed only when the sensor is operating in mode which which
  287. * a command belongs to.
  288. */
  289. int m5mols_mode(struct m5mols_info *info, u8 mode)
  290. {
  291. struct v4l2_subdev *sd = &info->sd;
  292. int ret = -EINVAL;
  293. u8 reg;
  294. if (mode < REG_PARAMETER || mode > REG_CAPTURE)
  295. return ret;
  296. ret = m5mols_read_u8(sd, SYSTEM_SYSMODE, &reg);
  297. if ((!ret && reg == mode) || ret)
  298. return ret;
  299. switch (reg) {
  300. case REG_PARAMETER:
  301. ret = m5mols_reg_mode(sd, REG_MONITOR);
  302. if (!ret && mode == REG_MONITOR)
  303. break;
  304. if (!ret)
  305. ret = m5mols_reg_mode(sd, REG_CAPTURE);
  306. break;
  307. case REG_MONITOR:
  308. if (mode == REG_PARAMETER) {
  309. ret = m5mols_reg_mode(sd, REG_PARAMETER);
  310. break;
  311. }
  312. ret = m5mols_reg_mode(sd, REG_CAPTURE);
  313. break;
  314. case REG_CAPTURE:
  315. ret = m5mols_reg_mode(sd, REG_MONITOR);
  316. if (!ret && mode == REG_MONITOR)
  317. break;
  318. if (!ret)
  319. ret = m5mols_reg_mode(sd, REG_PARAMETER);
  320. break;
  321. default:
  322. v4l2_warn(sd, "Wrong mode: %d\n", mode);
  323. }
  324. if (!ret)
  325. info->mode = mode;
  326. return ret;
  327. }
  328. /**
  329. * m5mols_get_version - retrieve full revisions information of M-5MOLS
  330. *
  331. * The version information includes revisions of hardware and firmware,
  332. * AutoFocus alghorithm version and the version string.
  333. */
  334. static int m5mols_get_version(struct v4l2_subdev *sd)
  335. {
  336. struct m5mols_info *info = to_m5mols(sd);
  337. struct m5mols_version *ver = &info->ver;
  338. u8 *str = ver->str;
  339. int i;
  340. int ret;
  341. ret = m5mols_read_u8(sd, SYSTEM_VER_CUSTOMER, &ver->customer);
  342. if (!ret)
  343. ret = m5mols_read_u8(sd, SYSTEM_VER_PROJECT, &ver->project);
  344. if (!ret)
  345. ret = m5mols_read_u16(sd, SYSTEM_VER_FIRMWARE, &ver->fw);
  346. if (!ret)
  347. ret = m5mols_read_u16(sd, SYSTEM_VER_HARDWARE, &ver->hw);
  348. if (!ret)
  349. ret = m5mols_read_u16(sd, SYSTEM_VER_PARAMETER, &ver->param);
  350. if (!ret)
  351. ret = m5mols_read_u16(sd, SYSTEM_VER_AWB, &ver->awb);
  352. if (!ret)
  353. ret = m5mols_read_u8(sd, AF_VERSION, &ver->af);
  354. if (ret)
  355. return ret;
  356. for (i = 0; i < VERSION_STRING_SIZE; i++) {
  357. ret = m5mols_read_u8(sd, SYSTEM_VER_STRING, &str[i]);
  358. if (ret)
  359. return ret;
  360. }
  361. ver->fw = be16_to_cpu(ver->fw);
  362. ver->hw = be16_to_cpu(ver->hw);
  363. ver->param = be16_to_cpu(ver->param);
  364. ver->awb = be16_to_cpu(ver->awb);
  365. v4l2_info(sd, "Manufacturer\t[%s]\n",
  366. is_manufacturer(info, REG_SAMSUNG_ELECTRO) ?
  367. "Samsung Electro-Machanics" :
  368. is_manufacturer(info, REG_SAMSUNG_OPTICS) ?
  369. "Samsung Fiber-Optics" :
  370. is_manufacturer(info, REG_SAMSUNG_TECHWIN) ?
  371. "Samsung Techwin" : "None");
  372. v4l2_info(sd, "Customer/Project\t[0x%02x/0x%02x]\n",
  373. info->ver.customer, info->ver.project);
  374. if (!is_available_af(info))
  375. v4l2_info(sd, "No support Auto Focus on this firmware\n");
  376. return ret;
  377. }
  378. /**
  379. * __find_restype - Lookup M-5MOLS resolution type according to pixel code
  380. * @code: pixel code
  381. */
  382. static enum m5mols_restype __find_restype(enum v4l2_mbus_pixelcode code)
  383. {
  384. enum m5mols_restype type = M5MOLS_RESTYPE_MONITOR;
  385. do {
  386. if (code == m5mols_default_ffmt[type].code)
  387. return type;
  388. } while (type++ != SIZE_DEFAULT_FFMT);
  389. return 0;
  390. }
  391. /**
  392. * __find_resolution - Lookup preset and type of M-5MOLS's resolution
  393. * @mf: pixel format to find/negotiate the resolution preset for
  394. * @type: M-5MOLS resolution type
  395. * @resolution: M-5MOLS resolution preset register value
  396. *
  397. * Find nearest resolution matching resolution preset and adjust mf
  398. * to supported values.
  399. */
  400. static int __find_resolution(struct v4l2_subdev *sd,
  401. struct v4l2_mbus_framefmt *mf,
  402. enum m5mols_restype *type,
  403. u32 *resolution)
  404. {
  405. const struct m5mols_resolution *fsize = &m5mols_reg_res[0];
  406. const struct m5mols_resolution *match = NULL;
  407. enum m5mols_restype stype = __find_restype(mf->code);
  408. int i = ARRAY_SIZE(m5mols_reg_res);
  409. unsigned int min_err = ~0;
  410. while (i--) {
  411. int err;
  412. if (stype == fsize->type) {
  413. err = abs(fsize->width - mf->width)
  414. + abs(fsize->height - mf->height);
  415. if (err < min_err) {
  416. min_err = err;
  417. match = fsize;
  418. }
  419. }
  420. fsize++;
  421. }
  422. if (match) {
  423. mf->width = match->width;
  424. mf->height = match->height;
  425. *resolution = match->reg;
  426. *type = stype;
  427. return 0;
  428. }
  429. return -EINVAL;
  430. }
  431. static struct v4l2_mbus_framefmt *__find_format(struct m5mols_info *info,
  432. struct v4l2_subdev_fh *fh,
  433. enum v4l2_subdev_format_whence which,
  434. enum m5mols_restype type)
  435. {
  436. if (which == V4L2_SUBDEV_FORMAT_TRY)
  437. return fh ? v4l2_subdev_get_try_format(fh, 0) : NULL;
  438. return &info->ffmt[type];
  439. }
  440. static int m5mols_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
  441. struct v4l2_subdev_format *fmt)
  442. {
  443. struct m5mols_info *info = to_m5mols(sd);
  444. struct v4l2_mbus_framefmt *format;
  445. format = __find_format(info, fh, fmt->which, info->res_type);
  446. if (!format)
  447. return -EINVAL;
  448. fmt->format = *format;
  449. return 0;
  450. }
  451. static int m5mols_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
  452. struct v4l2_subdev_format *fmt)
  453. {
  454. struct m5mols_info *info = to_m5mols(sd);
  455. struct v4l2_mbus_framefmt *format = &fmt->format;
  456. struct v4l2_mbus_framefmt *sfmt;
  457. enum m5mols_restype type;
  458. u32 resolution = 0;
  459. int ret;
  460. ret = __find_resolution(sd, format, &type, &resolution);
  461. if (ret < 0)
  462. return ret;
  463. sfmt = __find_format(info, fh, fmt->which, type);
  464. if (!sfmt)
  465. return 0;
  466. format->code = m5mols_default_ffmt[type].code;
  467. format->colorspace = V4L2_COLORSPACE_JPEG;
  468. format->field = V4L2_FIELD_NONE;
  469. if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
  470. *sfmt = *format;
  471. info->resolution = resolution;
  472. info->res_type = type;
  473. }
  474. return 0;
  475. }
  476. static int m5mols_enum_mbus_code(struct v4l2_subdev *sd,
  477. struct v4l2_subdev_fh *fh,
  478. struct v4l2_subdev_mbus_code_enum *code)
  479. {
  480. if (!code || code->index >= SIZE_DEFAULT_FFMT)
  481. return -EINVAL;
  482. code->code = m5mols_default_ffmt[code->index].code;
  483. return 0;
  484. }
  485. static struct v4l2_subdev_pad_ops m5mols_pad_ops = {
  486. .enum_mbus_code = m5mols_enum_mbus_code,
  487. .get_fmt = m5mols_get_fmt,
  488. .set_fmt = m5mols_set_fmt,
  489. };
  490. /**
  491. * m5mols_sync_controls - Apply default scene mode and the current controls
  492. *
  493. * This is used only streaming for syncing between v4l2_ctrl framework and
  494. * m5mols's controls. First, do the scenemode to the sensor, then call
  495. * v4l2_ctrl_handler_setup. It can be same between some commands and
  496. * the scenemode's in the default v4l2_ctrls. But, such commands of control
  497. * should be prior to the scenemode's one.
  498. */
  499. int m5mols_sync_controls(struct m5mols_info *info)
  500. {
  501. int ret = -EINVAL;
  502. if (!is_ctrl_synced(info)) {
  503. ret = m5mols_do_scenemode(info, REG_SCENE_NORMAL);
  504. if (ret)
  505. return ret;
  506. v4l2_ctrl_handler_setup(&info->handle);
  507. info->ctrl_sync = true;
  508. }
  509. return ret;
  510. }
  511. /**
  512. * m5mols_start_monitor - Start the monitor mode
  513. *
  514. * Before applying the controls setup the resolution and frame rate
  515. * in PARAMETER mode, and then switch over to MONITOR mode.
  516. */
  517. static int m5mols_start_monitor(struct m5mols_info *info)
  518. {
  519. struct v4l2_subdev *sd = &info->sd;
  520. int ret;
  521. ret = m5mols_mode(info, REG_PARAMETER);
  522. if (!ret)
  523. ret = m5mols_write(sd, PARM_MON_SIZE, info->resolution);
  524. if (!ret)
  525. ret = m5mols_write(sd, PARM_MON_FPS, REG_FPS_30);
  526. if (!ret)
  527. ret = m5mols_mode(info, REG_MONITOR);
  528. if (!ret)
  529. ret = m5mols_sync_controls(info);
  530. return ret;
  531. }
  532. static int m5mols_s_stream(struct v4l2_subdev *sd, int enable)
  533. {
  534. struct m5mols_info *info = to_m5mols(sd);
  535. u32 code = info->ffmt[info->res_type].code;
  536. if (enable) {
  537. int ret = -EINVAL;
  538. if (is_code(code, M5MOLS_RESTYPE_MONITOR))
  539. ret = m5mols_start_monitor(info);
  540. if (is_code(code, M5MOLS_RESTYPE_CAPTURE))
  541. ret = m5mols_start_capture(info);
  542. return ret;
  543. }
  544. return m5mols_mode(info, REG_PARAMETER);
  545. }
  546. static const struct v4l2_subdev_video_ops m5mols_video_ops = {
  547. .s_stream = m5mols_s_stream,
  548. };
  549. static int m5mols_s_ctrl(struct v4l2_ctrl *ctrl)
  550. {
  551. struct v4l2_subdev *sd = to_sd(ctrl);
  552. struct m5mols_info *info = to_m5mols(sd);
  553. int ret;
  554. info->mode_save = info->mode;
  555. ret = m5mols_mode(info, REG_PARAMETER);
  556. if (!ret)
  557. ret = m5mols_set_ctrl(ctrl);
  558. if (!ret)
  559. ret = m5mols_mode(info, info->mode_save);
  560. return ret;
  561. }
  562. static const struct v4l2_ctrl_ops m5mols_ctrl_ops = {
  563. .s_ctrl = m5mols_s_ctrl,
  564. };
  565. static int m5mols_sensor_power(struct m5mols_info *info, bool enable)
  566. {
  567. struct v4l2_subdev *sd = &info->sd;
  568. struct i2c_client *client = v4l2_get_subdevdata(sd);
  569. const struct m5mols_platform_data *pdata = info->pdata;
  570. int ret;
  571. if (enable) {
  572. if (is_powered(info))
  573. return 0;
  574. if (info->set_power) {
  575. ret = info->set_power(&client->dev, 1);
  576. if (ret)
  577. return ret;
  578. }
  579. ret = regulator_bulk_enable(ARRAY_SIZE(supplies), supplies);
  580. if (ret) {
  581. info->set_power(&client->dev, 0);
  582. return ret;
  583. }
  584. gpio_set_value(pdata->gpio_reset, !pdata->reset_polarity);
  585. usleep_range(1000, 1000);
  586. info->power = true;
  587. return ret;
  588. }
  589. if (!is_powered(info))
  590. return 0;
  591. ret = regulator_bulk_disable(ARRAY_SIZE(supplies), supplies);
  592. if (ret)
  593. return ret;
  594. if (info->set_power)
  595. info->set_power(&client->dev, 0);
  596. gpio_set_value(pdata->gpio_reset, pdata->reset_polarity);
  597. usleep_range(1000, 1000);
  598. info->power = false;
  599. return ret;
  600. }
  601. /* m5mols_update_fw - optional firmware update routine */
  602. int __attribute__ ((weak)) m5mols_update_fw(struct v4l2_subdev *sd,
  603. int (*set_power)(struct m5mols_info *, bool))
  604. {
  605. return 0;
  606. }
  607. /**
  608. * m5mols_sensor_armboot - Booting M-5MOLS internal ARM core.
  609. *
  610. * Booting internal ARM core makes the M-5MOLS is ready for getting commands
  611. * with I2C. It's the first thing to be done after it powered up. It must wait
  612. * at least 520ms recommended by M-5MOLS datasheet, after executing arm booting.
  613. */
  614. static int m5mols_sensor_armboot(struct v4l2_subdev *sd)
  615. {
  616. int ret;
  617. ret = m5mols_write(sd, FLASH_CAM_START, REG_START_ARM_BOOT);
  618. if (ret < 0)
  619. return ret;
  620. msleep(520);
  621. ret = m5mols_get_version(sd);
  622. if (!ret)
  623. ret = m5mols_update_fw(sd, m5mols_sensor_power);
  624. if (ret)
  625. return ret;
  626. v4l2_dbg(1, m5mols_debug, sd, "Success ARM Booting\n");
  627. ret = m5mols_write(sd, PARM_INTERFACE, REG_INTERFACE_MIPI);
  628. if (!ret)
  629. ret = m5mols_enable_interrupt(sd, REG_INT_AF);
  630. return ret;
  631. }
  632. static int m5mols_init_controls(struct m5mols_info *info)
  633. {
  634. struct v4l2_subdev *sd = &info->sd;
  635. u16 max_exposure;
  636. u16 step_zoom;
  637. int ret;
  638. /* Determine value's range & step of controls for various FW version */
  639. ret = m5mols_read_u16(sd, AE_MAX_GAIN_MON, &max_exposure);
  640. if (!ret)
  641. step_zoom = is_manufacturer(info, REG_SAMSUNG_OPTICS) ? 31 : 1;
  642. if (ret)
  643. return ret;
  644. v4l2_ctrl_handler_init(&info->handle, 6);
  645. info->autowb = v4l2_ctrl_new_std(&info->handle,
  646. &m5mols_ctrl_ops, V4L2_CID_AUTO_WHITE_BALANCE,
  647. 0, 1, 1, 0);
  648. info->saturation = v4l2_ctrl_new_std(&info->handle,
  649. &m5mols_ctrl_ops, V4L2_CID_SATURATION,
  650. 1, 5, 1, 3);
  651. info->zoom = v4l2_ctrl_new_std(&info->handle,
  652. &m5mols_ctrl_ops, V4L2_CID_ZOOM_ABSOLUTE,
  653. 1, 70, step_zoom, 1);
  654. info->exposure = v4l2_ctrl_new_std(&info->handle,
  655. &m5mols_ctrl_ops, V4L2_CID_EXPOSURE,
  656. 0, max_exposure, 1, (int)max_exposure/2);
  657. info->colorfx = v4l2_ctrl_new_std_menu(&info->handle,
  658. &m5mols_ctrl_ops, V4L2_CID_COLORFX,
  659. 4, (1 << V4L2_COLORFX_BW), V4L2_COLORFX_NONE);
  660. info->autoexposure = v4l2_ctrl_new_std_menu(&info->handle,
  661. &m5mols_ctrl_ops, V4L2_CID_EXPOSURE_AUTO,
  662. 1, 0, V4L2_EXPOSURE_MANUAL);
  663. sd->ctrl_handler = &info->handle;
  664. if (info->handle.error) {
  665. v4l2_err(sd, "Failed to initialize controls: %d\n", ret);
  666. v4l2_ctrl_handler_free(&info->handle);
  667. return info->handle.error;
  668. }
  669. v4l2_ctrl_cluster(2, &info->autoexposure);
  670. return 0;
  671. }
  672. /**
  673. * m5mols_s_power - Main sensor power control function
  674. *
  675. * To prevent breaking the lens when the sensor is powered off the Soft-Landing
  676. * algorithm is called where available. The Soft-Landing algorithm availability
  677. * dependends on the firmware provider.
  678. */
  679. static int m5mols_s_power(struct v4l2_subdev *sd, int on)
  680. {
  681. struct m5mols_info *info = to_m5mols(sd);
  682. int ret;
  683. if (on) {
  684. ret = m5mols_sensor_power(info, true);
  685. if (!ret)
  686. ret = m5mols_sensor_armboot(sd);
  687. if (!ret)
  688. ret = m5mols_init_controls(info);
  689. if (ret)
  690. return ret;
  691. info->ffmt[M5MOLS_RESTYPE_MONITOR] =
  692. m5mols_default_ffmt[M5MOLS_RESTYPE_MONITOR];
  693. info->ffmt[M5MOLS_RESTYPE_CAPTURE] =
  694. m5mols_default_ffmt[M5MOLS_RESTYPE_CAPTURE];
  695. return ret;
  696. }
  697. if (is_manufacturer(info, REG_SAMSUNG_TECHWIN)) {
  698. ret = m5mols_mode(info, REG_MONITOR);
  699. if (!ret)
  700. ret = m5mols_write(sd, AF_EXECUTE, REG_AF_STOP);
  701. if (!ret)
  702. ret = m5mols_write(sd, AF_MODE, REG_AF_POWEROFF);
  703. if (!ret)
  704. ret = m5mols_busy(sd, CAT_SYSTEM, CAT0_STATUS,
  705. REG_AF_IDLE);
  706. if (!ret)
  707. v4l2_info(sd, "Success soft-landing lens\n");
  708. }
  709. ret = m5mols_sensor_power(info, false);
  710. if (!ret) {
  711. v4l2_ctrl_handler_free(&info->handle);
  712. info->ctrl_sync = false;
  713. }
  714. return ret;
  715. }
  716. static int m5mols_log_status(struct v4l2_subdev *sd)
  717. {
  718. struct m5mols_info *info = to_m5mols(sd);
  719. v4l2_ctrl_handler_log_status(&info->handle, sd->name);
  720. return 0;
  721. }
  722. static const struct v4l2_subdev_core_ops m5mols_core_ops = {
  723. .s_power = m5mols_s_power,
  724. .g_ctrl = v4l2_subdev_g_ctrl,
  725. .s_ctrl = v4l2_subdev_s_ctrl,
  726. .queryctrl = v4l2_subdev_queryctrl,
  727. .querymenu = v4l2_subdev_querymenu,
  728. .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
  729. .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
  730. .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
  731. .log_status = m5mols_log_status,
  732. };
  733. static const struct v4l2_subdev_ops m5mols_ops = {
  734. .core = &m5mols_core_ops,
  735. .pad = &m5mols_pad_ops,
  736. .video = &m5mols_video_ops,
  737. };
  738. static void m5mols_irq_work(struct work_struct *work)
  739. {
  740. struct m5mols_info *info =
  741. container_of(work, struct m5mols_info, work_irq);
  742. struct v4l2_subdev *sd = &info->sd;
  743. u8 reg;
  744. int ret;
  745. if (!is_powered(info) ||
  746. m5mols_read_u8(sd, SYSTEM_INT_FACTOR, &info->interrupt))
  747. return;
  748. switch (info->interrupt & REG_INT_MASK) {
  749. case REG_INT_AF:
  750. if (!is_available_af(info))
  751. break;
  752. ret = m5mols_read_u8(sd, AF_STATUS, &reg);
  753. v4l2_dbg(2, m5mols_debug, sd, "AF %s\n",
  754. reg == REG_AF_FAIL ? "Failed" :
  755. reg == REG_AF_SUCCESS ? "Success" :
  756. reg == REG_AF_IDLE ? "Idle" : "Busy");
  757. break;
  758. case REG_INT_CAPTURE:
  759. if (!test_and_set_bit(ST_CAPT_IRQ, &info->flags))
  760. wake_up_interruptible(&info->irq_waitq);
  761. v4l2_dbg(2, m5mols_debug, sd, "CAPTURE\n");
  762. break;
  763. default:
  764. v4l2_dbg(2, m5mols_debug, sd, "Undefined: %02x\n", reg);
  765. break;
  766. };
  767. }
  768. static irqreturn_t m5mols_irq_handler(int irq, void *data)
  769. {
  770. struct v4l2_subdev *sd = data;
  771. struct m5mols_info *info = to_m5mols(sd);
  772. schedule_work(&info->work_irq);
  773. return IRQ_HANDLED;
  774. }
  775. static int __devinit m5mols_probe(struct i2c_client *client,
  776. const struct i2c_device_id *id)
  777. {
  778. const struct m5mols_platform_data *pdata = client->dev.platform_data;
  779. struct m5mols_info *info;
  780. struct v4l2_subdev *sd;
  781. int ret;
  782. if (pdata == NULL) {
  783. dev_err(&client->dev, "No platform data\n");
  784. return -EINVAL;
  785. }
  786. if (!gpio_is_valid(pdata->gpio_reset)) {
  787. dev_err(&client->dev, "No valid RESET GPIO specified\n");
  788. return -EINVAL;
  789. }
  790. if (!client->irq) {
  791. dev_err(&client->dev, "Interrupt not assigned\n");
  792. return -EINVAL;
  793. }
  794. info = kzalloc(sizeof(struct m5mols_info), GFP_KERNEL);
  795. if (!info)
  796. return -ENOMEM;
  797. info->pdata = pdata;
  798. info->set_power = pdata->set_power;
  799. ret = gpio_request(pdata->gpio_reset, "M5MOLS_NRST");
  800. if (ret) {
  801. dev_err(&client->dev, "Failed to request gpio: %d\n", ret);
  802. goto out_free;
  803. }
  804. gpio_direction_output(pdata->gpio_reset, pdata->reset_polarity);
  805. ret = regulator_bulk_get(&client->dev, ARRAY_SIZE(supplies), supplies);
  806. if (ret) {
  807. dev_err(&client->dev, "Failed to get regulators: %d\n", ret);
  808. goto out_gpio;
  809. }
  810. sd = &info->sd;
  811. strlcpy(sd->name, MODULE_NAME, sizeof(sd->name));
  812. v4l2_i2c_subdev_init(sd, client, &m5mols_ops);
  813. info->pad.flags = MEDIA_PAD_FL_SOURCE;
  814. ret = media_entity_init(&sd->entity, 1, &info->pad, 0);
  815. if (ret < 0)
  816. goto out_reg;
  817. sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
  818. init_waitqueue_head(&info->irq_waitq);
  819. INIT_WORK(&info->work_irq, m5mols_irq_work);
  820. ret = request_irq(client->irq, m5mols_irq_handler,
  821. IRQF_TRIGGER_RISING, MODULE_NAME, sd);
  822. if (ret) {
  823. dev_err(&client->dev, "Interrupt request failed: %d\n", ret);
  824. goto out_me;
  825. }
  826. info->res_type = M5MOLS_RESTYPE_MONITOR;
  827. return 0;
  828. out_me:
  829. media_entity_cleanup(&sd->entity);
  830. out_reg:
  831. regulator_bulk_free(ARRAY_SIZE(supplies), supplies);
  832. out_gpio:
  833. gpio_free(pdata->gpio_reset);
  834. out_free:
  835. kfree(info);
  836. return ret;
  837. }
  838. static int __devexit m5mols_remove(struct i2c_client *client)
  839. {
  840. struct v4l2_subdev *sd = i2c_get_clientdata(client);
  841. struct m5mols_info *info = to_m5mols(sd);
  842. v4l2_device_unregister_subdev(sd);
  843. free_irq(client->irq, sd);
  844. regulator_bulk_free(ARRAY_SIZE(supplies), supplies);
  845. gpio_free(info->pdata->gpio_reset);
  846. media_entity_cleanup(&sd->entity);
  847. kfree(info);
  848. return 0;
  849. }
  850. static const struct i2c_device_id m5mols_id[] = {
  851. { MODULE_NAME, 0 },
  852. { },
  853. };
  854. MODULE_DEVICE_TABLE(i2c, m5mols_id);
  855. static struct i2c_driver m5mols_i2c_driver = {
  856. .driver = {
  857. .name = MODULE_NAME,
  858. },
  859. .probe = m5mols_probe,
  860. .remove = __devexit_p(m5mols_remove),
  861. .id_table = m5mols_id,
  862. };
  863. static int __init m5mols_mod_init(void)
  864. {
  865. return i2c_add_driver(&m5mols_i2c_driver);
  866. }
  867. static void __exit m5mols_mod_exit(void)
  868. {
  869. i2c_del_driver(&m5mols_i2c_driver);
  870. }
  871. module_init(m5mols_mod_init);
  872. module_exit(m5mols_mod_exit);
  873. MODULE_AUTHOR("HeungJun Kim <riverful.kim@samsung.com>");
  874. MODULE_AUTHOR("Dongsoo Kim <dongsoo45.kim@samsung.com>");
  875. MODULE_DESCRIPTION("Fujitsu M-5MOLS 8M Pixel camera driver");
  876. MODULE_LICENSE("GPL");