tw9910.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979
  1. /*
  2. * tw9910 Video Driver
  3. *
  4. * Copyright (C) 2008 Renesas Solutions Corp.
  5. * Kuninori Morimoto <morimoto.kuninori@renesas.com>
  6. *
  7. * Based on ov772x driver,
  8. *
  9. * Copyright (C) 2008 Kuninori Morimoto <morimoto.kuninori@renesas.com>
  10. * Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
  11. * Copyright (C) 2008 Magnus Damm
  12. * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
  13. *
  14. * This program is free software; you can redistribute it and/or modify
  15. * it under the terms of the GNU General Public License version 2 as
  16. * published by the Free Software Foundation.
  17. */
  18. #include <linux/init.h>
  19. #include <linux/module.h>
  20. #include <linux/i2c.h>
  21. #include <linux/slab.h>
  22. #include <linux/kernel.h>
  23. #include <linux/delay.h>
  24. #include <linux/videodev2.h>
  25. #include <media/v4l2-chip-ident.h>
  26. #include <media/v4l2-common.h>
  27. #include <media/soc_camera.h>
  28. #include <media/tw9910.h>
  29. #define GET_ID(val) ((val & 0xF8) >> 3)
  30. #define GET_ReV(val) (val & 0x07)
  31. /*
  32. * register offset
  33. */
  34. #define ID 0x00 /* Product ID Code Register */
  35. #define STATUS1 0x01 /* Chip Status Register I */
  36. #define INFORM 0x02 /* Input Format */
  37. #define OPFORM 0x03 /* Output Format Control Register */
  38. #define DLYCTR 0x04 /* Hysteresis and HSYNC Delay Control */
  39. #define OUTCTR1 0x05 /* Output Control I */
  40. #define ACNTL1 0x06 /* Analog Control Register 1 */
  41. #define CROP_HI 0x07 /* Cropping Register, High */
  42. #define VDELAY_LO 0x08 /* Vertical Delay Register, Low */
  43. #define VACTIVE_LO 0x09 /* Vertical Active Register, Low */
  44. #define HDELAY_LO 0x0A /* Horizontal Delay Register, Low */
  45. #define HACTIVE_LO 0x0B /* Horizontal Active Register, Low */
  46. #define CNTRL1 0x0C /* Control Register I */
  47. #define VSCALE_LO 0x0D /* Vertical Scaling Register, Low */
  48. #define SCALE_HI 0x0E /* Scaling Register, High */
  49. #define HSCALE_LO 0x0F /* Horizontal Scaling Register, Low */
  50. #define BRIGHT 0x10 /* BRIGHTNESS Control Register */
  51. #define CONTRAST 0x11 /* CONTRAST Control Register */
  52. #define SHARPNESS 0x12 /* SHARPNESS Control Register I */
  53. #define SAT_U 0x13 /* Chroma (U) Gain Register */
  54. #define SAT_V 0x14 /* Chroma (V) Gain Register */
  55. #define HUE 0x15 /* Hue Control Register */
  56. #define CORING1 0x17
  57. #define CORING2 0x18 /* Coring and IF compensation */
  58. #define VBICNTL 0x19 /* VBI Control Register */
  59. #define ACNTL2 0x1A /* Analog Control 2 */
  60. #define OUTCTR2 0x1B /* Output Control 2 */
  61. #define SDT 0x1C /* Standard Selection */
  62. #define SDTR 0x1D /* Standard Recognition */
  63. #define TEST 0x1F /* Test Control Register */
  64. #define CLMPG 0x20 /* Clamping Gain */
  65. #define IAGC 0x21 /* Individual AGC Gain */
  66. #define AGCGAIN 0x22 /* AGC Gain */
  67. #define PEAKWT 0x23 /* White Peak Threshold */
  68. #define CLMPL 0x24 /* Clamp level */
  69. #define SYNCT 0x25 /* Sync Amplitude */
  70. #define MISSCNT 0x26 /* Sync Miss Count Register */
  71. #define PCLAMP 0x27 /* Clamp Position Register */
  72. #define VCNTL1 0x28 /* Vertical Control I */
  73. #define VCNTL2 0x29 /* Vertical Control II */
  74. #define CKILL 0x2A /* Color Killer Level Control */
  75. #define COMB 0x2B /* Comb Filter Control */
  76. #define LDLY 0x2C /* Luma Delay and H Filter Control */
  77. #define MISC1 0x2D /* Miscellaneous Control I */
  78. #define LOOP 0x2E /* LOOP Control Register */
  79. #define MISC2 0x2F /* Miscellaneous Control II */
  80. #define MVSN 0x30 /* Macrovision Detection */
  81. #define STATUS2 0x31 /* Chip STATUS II */
  82. #define HFREF 0x32 /* H monitor */
  83. #define CLMD 0x33 /* CLAMP MODE */
  84. #define IDCNTL 0x34 /* ID Detection Control */
  85. #define CLCNTL1 0x35 /* Clamp Control I */
  86. #define ANAPLLCTL 0x4C
  87. #define VBIMIN 0x4D
  88. #define HSLOWCTL 0x4E
  89. #define WSS3 0x4F
  90. #define FILLDATA 0x50
  91. #define SDID 0x51
  92. #define DID 0x52
  93. #define WSS1 0x53
  94. #define WSS2 0x54
  95. #define VVBI 0x55
  96. #define LCTL6 0x56
  97. #define LCTL7 0x57
  98. #define LCTL8 0x58
  99. #define LCTL9 0x59
  100. #define LCTL10 0x5A
  101. #define LCTL11 0x5B
  102. #define LCTL12 0x5C
  103. #define LCTL13 0x5D
  104. #define LCTL14 0x5E
  105. #define LCTL15 0x5F
  106. #define LCTL16 0x60
  107. #define LCTL17 0x61
  108. #define LCTL18 0x62
  109. #define LCTL19 0x63
  110. #define LCTL20 0x64
  111. #define LCTL21 0x65
  112. #define LCTL22 0x66
  113. #define LCTL23 0x67
  114. #define LCTL24 0x68
  115. #define LCTL25 0x69
  116. #define LCTL26 0x6A
  117. #define HSGEGIN 0x6B
  118. #define HSEND 0x6C
  119. #define OVSDLY 0x6D
  120. #define OVSEND 0x6E
  121. #define VBIDELAY 0x6F
  122. /*
  123. * register detail
  124. */
  125. /* INFORM */
  126. #define FC27_ON 0x40 /* 1 : Input crystal clock frequency is 27MHz */
  127. #define FC27_FF 0x00 /* 0 : Square pixel mode. */
  128. /* Must use 24.54MHz for 60Hz field rate */
  129. /* source or 29.5MHz for 50Hz field rate */
  130. #define IFSEL_S 0x10 /* 01 : S-video decoding */
  131. #define IFSEL_C 0x00 /* 00 : Composite video decoding */
  132. /* Y input video selection */
  133. #define YSEL_M0 0x00 /* 00 : Mux0 selected */
  134. #define YSEL_M1 0x04 /* 01 : Mux1 selected */
  135. #define YSEL_M2 0x08 /* 10 : Mux2 selected */
  136. #define YSEL_M3 0x10 /* 11 : Mux3 selected */
  137. /* OPFORM */
  138. #define MODE 0x80 /* 0 : CCIR601 compatible YCrCb 4:2:2 format */
  139. /* 1 : ITU-R-656 compatible data sequence format */
  140. #define LEN 0x40 /* 0 : 8-bit YCrCb 4:2:2 output format */
  141. /* 1 : 16-bit YCrCb 4:2:2 output format.*/
  142. #define LLCMODE 0x20 /* 1 : LLC output mode. */
  143. /* 0 : free-run output mode */
  144. #define AINC 0x10 /* Serial interface auto-indexing control */
  145. /* 0 : auto-increment */
  146. /* 1 : non-auto */
  147. #define VSCTL 0x08 /* 1 : Vertical out ctrl by DVALID */
  148. /* 0 : Vertical out ctrl by HACTIVE and DVALID */
  149. #define OEN 0x04 /* Output Enable together with TRI_SEL. */
  150. /* OUTCTR1 */
  151. #define VSP_LO 0x00 /* 0 : VS pin output polarity is active low */
  152. #define VSP_HI 0x80 /* 1 : VS pin output polarity is active high. */
  153. /* VS pin output control */
  154. #define VSSL_VSYNC 0x00 /* 0 : VSYNC */
  155. #define VSSL_VACT 0x10 /* 1 : VACT */
  156. #define VSSL_FIELD 0x20 /* 2 : FIELD */
  157. #define VSSL_VVALID 0x30 /* 3 : VVALID */
  158. #define VSSL_ZERO 0x70 /* 7 : 0 */
  159. #define HSP_LOW 0x00 /* 0 : HS pin output polarity is active low */
  160. #define HSP_HI 0x08 /* 1 : HS pin output polarity is active high.*/
  161. /* HS pin output control */
  162. #define HSSL_HACT 0x00 /* 0 : HACT */
  163. #define HSSL_HSYNC 0x01 /* 1 : HSYNC */
  164. #define HSSL_DVALID 0x02 /* 2 : DVALID */
  165. #define HSSL_HLOCK 0x03 /* 3 : HLOCK */
  166. #define HSSL_ASYNCW 0x04 /* 4 : ASYNCW */
  167. #define HSSL_ZERO 0x07 /* 7 : 0 */
  168. /* ACNTL1 */
  169. #define SRESET 0x80 /* resets the device to its default state
  170. * but all register content remain unchanged.
  171. * This bit is self-resetting.
  172. */
  173. /* VBICNTL */
  174. /* RTSEL : control the real time signal
  175. * output from the MPOUT pin
  176. */
  177. #define RTSEL_MASK 0x07
  178. #define RTSEL_VLOSS 0x00 /* 0000 = Video loss */
  179. #define RTSEL_HLOCK 0x01 /* 0001 = H-lock */
  180. #define RTSEL_SLOCK 0x02 /* 0010 = S-lock */
  181. #define RTSEL_VLOCK 0x03 /* 0011 = V-lock */
  182. #define RTSEL_MONO 0x04 /* 0100 = MONO */
  183. #define RTSEL_DET50 0x05 /* 0101 = DET50 */
  184. #define RTSEL_FIELD 0x06 /* 0110 = FIELD */
  185. #define RTSEL_RTCO 0x07 /* 0111 = RTCO ( Real Time Control ) */
  186. /*
  187. * structure
  188. */
  189. struct regval_list {
  190. unsigned char reg_num;
  191. unsigned char value;
  192. };
  193. struct tw9910_scale_ctrl {
  194. char *name;
  195. unsigned short width;
  196. unsigned short height;
  197. u16 hscale;
  198. u16 vscale;
  199. };
  200. struct tw9910_cropping_ctrl {
  201. u16 vdelay;
  202. u16 vactive;
  203. u16 hdelay;
  204. u16 hactive;
  205. };
  206. struct tw9910_hsync_ctrl {
  207. u16 start;
  208. u16 end;
  209. };
  210. struct tw9910_priv {
  211. struct tw9910_video_info *info;
  212. struct i2c_client *client;
  213. struct soc_camera_device icd;
  214. const struct tw9910_scale_ctrl *scale;
  215. };
  216. /*
  217. * register settings
  218. */
  219. #define ENDMARKER { 0xff, 0xff }
  220. static const struct regval_list tw9910_default_regs[] =
  221. {
  222. { OPFORM, 0x00 },
  223. { OUTCTR1, VSP_LO | VSSL_VVALID | HSP_HI | HSSL_HSYNC },
  224. ENDMARKER,
  225. };
  226. static const struct soc_camera_data_format tw9910_color_fmt[] = {
  227. {
  228. .name = "VYUY",
  229. .fourcc = V4L2_PIX_FMT_VYUY,
  230. .depth = 16,
  231. .colorspace = V4L2_COLORSPACE_SMPTE170M,
  232. }
  233. };
  234. static const struct tw9910_scale_ctrl tw9910_ntsc_scales[] = {
  235. {
  236. .name = "NTSC SQ",
  237. .width = 640,
  238. .height = 480,
  239. .hscale = 0x0100,
  240. .vscale = 0x0100,
  241. },
  242. {
  243. .name = "NTSC CCIR601",
  244. .width = 720,
  245. .height = 480,
  246. .hscale = 0x0100,
  247. .vscale = 0x0100,
  248. },
  249. {
  250. .name = "NTSC SQ (CIF)",
  251. .width = 320,
  252. .height = 240,
  253. .hscale = 0x0200,
  254. .vscale = 0x0200,
  255. },
  256. {
  257. .name = "NTSC CCIR601 (CIF)",
  258. .width = 360,
  259. .height = 240,
  260. .hscale = 0x0200,
  261. .vscale = 0x0200,
  262. },
  263. {
  264. .name = "NTSC SQ (QCIF)",
  265. .width = 160,
  266. .height = 120,
  267. .hscale = 0x0400,
  268. .vscale = 0x0400,
  269. },
  270. {
  271. .name = "NTSC CCIR601 (QCIF)",
  272. .width = 180,
  273. .height = 120,
  274. .hscale = 0x0400,
  275. .vscale = 0x0400,
  276. },
  277. };
  278. static const struct tw9910_scale_ctrl tw9910_pal_scales[] = {
  279. {
  280. .name = "PAL SQ",
  281. .width = 768,
  282. .height = 576,
  283. .hscale = 0x0100,
  284. .vscale = 0x0100,
  285. },
  286. {
  287. .name = "PAL CCIR601",
  288. .width = 720,
  289. .height = 576,
  290. .hscale = 0x0100,
  291. .vscale = 0x0100,
  292. },
  293. {
  294. .name = "PAL SQ (CIF)",
  295. .width = 384,
  296. .height = 288,
  297. .hscale = 0x0200,
  298. .vscale = 0x0200,
  299. },
  300. {
  301. .name = "PAL CCIR601 (CIF)",
  302. .width = 360,
  303. .height = 288,
  304. .hscale = 0x0200,
  305. .vscale = 0x0200,
  306. },
  307. {
  308. .name = "PAL SQ (QCIF)",
  309. .width = 192,
  310. .height = 144,
  311. .hscale = 0x0400,
  312. .vscale = 0x0400,
  313. },
  314. {
  315. .name = "PAL CCIR601 (QCIF)",
  316. .width = 180,
  317. .height = 144,
  318. .hscale = 0x0400,
  319. .vscale = 0x0400,
  320. },
  321. };
  322. static const struct tw9910_cropping_ctrl tw9910_cropping_ctrl = {
  323. .vdelay = 0x0012,
  324. .vactive = 0x00F0,
  325. .hdelay = 0x0010,
  326. .hactive = 0x02D0,
  327. };
  328. static const struct tw9910_hsync_ctrl tw9910_hsync_ctrl = {
  329. .start = 0x0260,
  330. .end = 0x0300,
  331. };
  332. /*
  333. * general function
  334. */
  335. static int tw9910_set_scale(struct i2c_client *client,
  336. const struct tw9910_scale_ctrl *scale)
  337. {
  338. int ret;
  339. ret = i2c_smbus_write_byte_data(client, SCALE_HI,
  340. (scale->vscale & 0x0F00) >> 4 |
  341. (scale->hscale & 0x0F00) >> 8);
  342. if (ret < 0)
  343. return ret;
  344. ret = i2c_smbus_write_byte_data(client, HSCALE_LO,
  345. scale->hscale & 0x00FF);
  346. if (ret < 0)
  347. return ret;
  348. ret = i2c_smbus_write_byte_data(client, VSCALE_LO,
  349. scale->vscale & 0x00FF);
  350. return ret;
  351. }
  352. static int tw9910_set_cropping(struct i2c_client *client,
  353. const struct tw9910_cropping_ctrl *cropping)
  354. {
  355. int ret;
  356. ret = i2c_smbus_write_byte_data(client, CROP_HI,
  357. (cropping->vdelay & 0x0300) >> 2 |
  358. (cropping->vactive & 0x0300) >> 4 |
  359. (cropping->hdelay & 0x0300) >> 6 |
  360. (cropping->hactive & 0x0300) >> 8);
  361. if (ret < 0)
  362. return ret;
  363. ret = i2c_smbus_write_byte_data(client, VDELAY_LO,
  364. cropping->vdelay & 0x00FF);
  365. if (ret < 0)
  366. return ret;
  367. ret = i2c_smbus_write_byte_data(client, VACTIVE_LO,
  368. cropping->vactive & 0x00FF);
  369. if (ret < 0)
  370. return ret;
  371. ret = i2c_smbus_write_byte_data(client, HDELAY_LO,
  372. cropping->hdelay & 0x00FF);
  373. if (ret < 0)
  374. return ret;
  375. ret = i2c_smbus_write_byte_data(client, HACTIVE_LO,
  376. cropping->hactive & 0x00FF);
  377. return ret;
  378. }
  379. static int tw9910_set_hsync(struct i2c_client *client,
  380. const struct tw9910_hsync_ctrl *hsync)
  381. {
  382. int ret;
  383. /* bit 10 - 3 */
  384. ret = i2c_smbus_write_byte_data(client, HSGEGIN,
  385. (hsync->start & 0x07F8) >> 3);
  386. if (ret < 0)
  387. return ret;
  388. /* bit 10 - 3 */
  389. ret = i2c_smbus_write_byte_data(client, HSEND,
  390. (hsync->end & 0x07F8) >> 3);
  391. if (ret < 0)
  392. return ret;
  393. /* bit 2 - 0 */
  394. ret = i2c_smbus_read_byte_data(client, HSLOWCTL);
  395. if (ret < 0)
  396. return ret;
  397. ret = i2c_smbus_write_byte_data(client, HSLOWCTL,
  398. (ret & 0x88) |
  399. (hsync->start & 0x0007) << 4 |
  400. (hsync->end & 0x0007));
  401. return ret;
  402. }
  403. static int tw9910_write_array(struct i2c_client *client,
  404. const struct regval_list *vals)
  405. {
  406. while (vals->reg_num != 0xff) {
  407. int ret = i2c_smbus_write_byte_data(client,
  408. vals->reg_num,
  409. vals->value);
  410. if (ret < 0)
  411. return ret;
  412. vals++;
  413. }
  414. return 0;
  415. }
  416. static int tw9910_mask_set(struct i2c_client *client, u8 command,
  417. u8 mask, u8 set)
  418. {
  419. s32 val = i2c_smbus_read_byte_data(client, command);
  420. if (val < 0)
  421. return val;
  422. val &= ~mask;
  423. val |= set & mask;
  424. return i2c_smbus_write_byte_data(client, command, val);
  425. }
  426. static void tw9910_reset(struct i2c_client *client)
  427. {
  428. i2c_smbus_write_byte_data(client, ACNTL1, SRESET);
  429. msleep(1);
  430. }
  431. static const struct tw9910_scale_ctrl*
  432. tw9910_select_norm(struct soc_camera_device *icd, u32 width, u32 height)
  433. {
  434. const struct tw9910_scale_ctrl *scale;
  435. const struct tw9910_scale_ctrl *ret = NULL;
  436. v4l2_std_id norm = icd->vdev->current_norm;
  437. __u32 diff = 0xffffffff, tmp;
  438. int size, i;
  439. if (norm & V4L2_STD_NTSC) {
  440. scale = tw9910_ntsc_scales;
  441. size = ARRAY_SIZE(tw9910_ntsc_scales);
  442. } else if (norm & V4L2_STD_PAL) {
  443. scale = tw9910_pal_scales;
  444. size = ARRAY_SIZE(tw9910_pal_scales);
  445. } else {
  446. return NULL;
  447. }
  448. for (i = 0; i < size; i++) {
  449. tmp = abs(width - scale[i].width) +
  450. abs(height - scale[i].height);
  451. if (tmp < diff) {
  452. diff = tmp;
  453. ret = scale + i;
  454. }
  455. }
  456. return ret;
  457. }
  458. /*
  459. * soc_camera_ops function
  460. */
  461. static int tw9910_init(struct soc_camera_device *icd)
  462. {
  463. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  464. int ret = 0;
  465. if (priv->info->link.power) {
  466. ret = priv->info->link.power(&priv->client->dev, 1);
  467. if (ret < 0)
  468. return ret;
  469. }
  470. if (priv->info->link.reset)
  471. ret = priv->info->link.reset(&priv->client->dev);
  472. return ret;
  473. }
  474. static int tw9910_release(struct soc_camera_device *icd)
  475. {
  476. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  477. int ret = 0;
  478. if (priv->info->link.power)
  479. ret = priv->info->link.power(&priv->client->dev, 0);
  480. return ret;
  481. }
  482. static int tw9910_start_capture(struct soc_camera_device *icd)
  483. {
  484. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  485. if (!priv->scale) {
  486. dev_err(&icd->dev, "norm select error\n");
  487. return -EPERM;
  488. }
  489. dev_dbg(&icd->dev, "%s %dx%d\n",
  490. priv->scale->name,
  491. priv->scale->width,
  492. priv->scale->height);
  493. return 0;
  494. }
  495. static int tw9910_stop_capture(struct soc_camera_device *icd)
  496. {
  497. return 0;
  498. }
  499. static int tw9910_set_bus_param(struct soc_camera_device *icd,
  500. unsigned long flags)
  501. {
  502. return 0;
  503. }
  504. static unsigned long tw9910_query_bus_param(struct soc_camera_device *icd)
  505. {
  506. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  507. struct soc_camera_link *icl = priv->client->dev.platform_data;
  508. unsigned long flags = SOCAM_PCLK_SAMPLE_RISING | SOCAM_MASTER |
  509. SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_HIGH |
  510. SOCAM_DATA_ACTIVE_HIGH | priv->info->buswidth;
  511. return soc_camera_apply_sensor_flags(icl, flags);
  512. }
  513. static int tw9910_get_chip_id(struct soc_camera_device *icd,
  514. struct v4l2_dbg_chip_ident *id)
  515. {
  516. id->ident = V4L2_IDENT_TW9910;
  517. id->revision = 0;
  518. return 0;
  519. }
  520. static int tw9910_set_std(struct soc_camera_device *icd,
  521. v4l2_std_id *a)
  522. {
  523. int ret = -EINVAL;
  524. if (*a & (V4L2_STD_NTSC | V4L2_STD_PAL))
  525. ret = 0;
  526. return ret;
  527. }
  528. static int tw9910_enum_input(struct soc_camera_device *icd,
  529. struct v4l2_input *inp)
  530. {
  531. inp->type = V4L2_INPUT_TYPE_TUNER;
  532. inp->std = V4L2_STD_UNKNOWN;
  533. strcpy(inp->name, "Video");
  534. return 0;
  535. }
  536. #ifdef CONFIG_VIDEO_ADV_DEBUG
  537. static int tw9910_get_register(struct soc_camera_device *icd,
  538. struct v4l2_dbg_register *reg)
  539. {
  540. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  541. int ret;
  542. if (reg->reg > 0xff)
  543. return -EINVAL;
  544. ret = i2c_smbus_read_byte_data(priv->client, reg->reg);
  545. if (ret < 0)
  546. return ret;
  547. /* ret = int
  548. * reg->val = __u64
  549. */
  550. reg->val = (__u64)ret;
  551. return 0;
  552. }
  553. static int tw9910_set_register(struct soc_camera_device *icd,
  554. struct v4l2_dbg_register *reg)
  555. {
  556. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  557. if (reg->reg > 0xff ||
  558. reg->val > 0xff)
  559. return -EINVAL;
  560. return i2c_smbus_write_byte_data(priv->client, reg->reg, reg->val);
  561. }
  562. #endif
  563. static int tw9910_set_crop(struct soc_camera_device *icd,
  564. struct v4l2_rect *rect)
  565. {
  566. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  567. int ret = -EINVAL;
  568. u8 val;
  569. /*
  570. * select suitable norm
  571. */
  572. priv->scale = tw9910_select_norm(icd, rect->width, rect->height);
  573. if (!priv->scale)
  574. goto tw9910_set_fmt_error;
  575. /*
  576. * reset hardware
  577. */
  578. tw9910_reset(priv->client);
  579. ret = tw9910_write_array(priv->client, tw9910_default_regs);
  580. if (ret < 0)
  581. goto tw9910_set_fmt_error;
  582. /*
  583. * set bus width
  584. */
  585. val = 0x00;
  586. if (SOCAM_DATAWIDTH_16 == priv->info->buswidth)
  587. val = LEN;
  588. ret = tw9910_mask_set(priv->client, OPFORM, LEN, val);
  589. if (ret < 0)
  590. goto tw9910_set_fmt_error;
  591. /*
  592. * select MPOUT behavior
  593. */
  594. switch (priv->info->mpout) {
  595. case TW9910_MPO_VLOSS:
  596. val = RTSEL_VLOSS; break;
  597. case TW9910_MPO_HLOCK:
  598. val = RTSEL_HLOCK; break;
  599. case TW9910_MPO_SLOCK:
  600. val = RTSEL_SLOCK; break;
  601. case TW9910_MPO_VLOCK:
  602. val = RTSEL_VLOCK; break;
  603. case TW9910_MPO_MONO:
  604. val = RTSEL_MONO; break;
  605. case TW9910_MPO_DET50:
  606. val = RTSEL_DET50; break;
  607. case TW9910_MPO_FIELD:
  608. val = RTSEL_FIELD; break;
  609. case TW9910_MPO_RTCO:
  610. val = RTSEL_RTCO; break;
  611. default:
  612. val = 0;
  613. }
  614. ret = tw9910_mask_set(priv->client, VBICNTL, RTSEL_MASK, val);
  615. if (ret < 0)
  616. goto tw9910_set_fmt_error;
  617. /*
  618. * set scale
  619. */
  620. ret = tw9910_set_scale(priv->client, priv->scale);
  621. if (ret < 0)
  622. goto tw9910_set_fmt_error;
  623. /*
  624. * set cropping
  625. */
  626. ret = tw9910_set_cropping(priv->client, &tw9910_cropping_ctrl);
  627. if (ret < 0)
  628. goto tw9910_set_fmt_error;
  629. /*
  630. * set hsync
  631. */
  632. ret = tw9910_set_hsync(priv->client, &tw9910_hsync_ctrl);
  633. if (ret < 0)
  634. goto tw9910_set_fmt_error;
  635. return ret;
  636. tw9910_set_fmt_error:
  637. tw9910_reset(priv->client);
  638. priv->scale = NULL;
  639. return ret;
  640. }
  641. static int tw9910_set_fmt(struct soc_camera_device *icd,
  642. struct v4l2_format *f)
  643. {
  644. struct v4l2_pix_format *pix = &f->fmt.pix;
  645. struct v4l2_rect rect = {
  646. .left = icd->x_current,
  647. .top = icd->y_current,
  648. .width = pix->width,
  649. .height = pix->height,
  650. };
  651. int i;
  652. /*
  653. * check color format
  654. */
  655. for (i = 0; i < ARRAY_SIZE(tw9910_color_fmt); i++)
  656. if (pix->pixelformat == tw9910_color_fmt[i].fourcc)
  657. break;
  658. if (i == ARRAY_SIZE(tw9910_color_fmt))
  659. return -EINVAL;
  660. return tw9910_set_crop(icd, &rect);
  661. }
  662. static int tw9910_try_fmt(struct soc_camera_device *icd,
  663. struct v4l2_format *f)
  664. {
  665. struct v4l2_pix_format *pix = &f->fmt.pix;
  666. const struct tw9910_scale_ctrl *scale;
  667. if (V4L2_FIELD_ANY == pix->field) {
  668. pix->field = V4L2_FIELD_INTERLACED;
  669. } else if (V4L2_FIELD_INTERLACED != pix->field) {
  670. dev_err(&icd->dev, "Field type invalid.\n");
  671. return -EINVAL;
  672. }
  673. /*
  674. * select suitable norm
  675. */
  676. scale = tw9910_select_norm(icd, pix->width, pix->height);
  677. if (!scale)
  678. return -EINVAL;
  679. pix->width = scale->width;
  680. pix->height = scale->height;
  681. return 0;
  682. }
  683. static int tw9910_video_probe(struct soc_camera_device *icd)
  684. {
  685. struct tw9910_priv *priv = container_of(icd, struct tw9910_priv, icd);
  686. s32 val;
  687. int ret;
  688. /*
  689. * We must have a parent by now. And it cannot be a wrong one.
  690. * So this entire test is completely redundant.
  691. */
  692. if (!icd->dev.parent ||
  693. to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
  694. return -ENODEV;
  695. /*
  696. * tw9910 only use 8 or 16 bit bus width
  697. */
  698. if (SOCAM_DATAWIDTH_16 != priv->info->buswidth &&
  699. SOCAM_DATAWIDTH_8 != priv->info->buswidth) {
  700. dev_err(&icd->dev, "bus width error\n");
  701. return -ENODEV;
  702. }
  703. icd->formats = tw9910_color_fmt;
  704. icd->num_formats = ARRAY_SIZE(tw9910_color_fmt);
  705. /*
  706. * check and show Product ID
  707. */
  708. val = i2c_smbus_read_byte_data(priv->client, ID);
  709. if (0x0B != GET_ID(val) ||
  710. 0x00 != GET_ReV(val)) {
  711. dev_err(&icd->dev,
  712. "Product ID error %x:%x\n", GET_ID(val), GET_ReV(val));
  713. return -ENODEV;
  714. }
  715. dev_info(&icd->dev,
  716. "tw9910 Product ID %0x:%0x\n", GET_ID(val), GET_ReV(val));
  717. ret = soc_camera_video_start(icd);
  718. if (ret < 0)
  719. return ret;
  720. icd->vdev->tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL;
  721. icd->vdev->current_norm = V4L2_STD_NTSC;
  722. return ret;
  723. }
  724. static void tw9910_video_remove(struct soc_camera_device *icd)
  725. {
  726. soc_camera_video_stop(icd);
  727. }
  728. static struct soc_camera_ops tw9910_ops = {
  729. .owner = THIS_MODULE,
  730. .probe = tw9910_video_probe,
  731. .remove = tw9910_video_remove,
  732. .init = tw9910_init,
  733. .release = tw9910_release,
  734. .start_capture = tw9910_start_capture,
  735. .stop_capture = tw9910_stop_capture,
  736. .set_crop = tw9910_set_crop,
  737. .set_fmt = tw9910_set_fmt,
  738. .try_fmt = tw9910_try_fmt,
  739. .set_bus_param = tw9910_set_bus_param,
  740. .query_bus_param = tw9910_query_bus_param,
  741. .get_chip_id = tw9910_get_chip_id,
  742. .set_std = tw9910_set_std,
  743. .enum_input = tw9910_enum_input,
  744. #ifdef CONFIG_VIDEO_ADV_DEBUG
  745. .get_register = tw9910_get_register,
  746. .set_register = tw9910_set_register,
  747. #endif
  748. };
  749. /*
  750. * i2c_driver function
  751. */
  752. static int tw9910_probe(struct i2c_client *client,
  753. const struct i2c_device_id *did)
  754. {
  755. struct tw9910_priv *priv;
  756. struct tw9910_video_info *info;
  757. struct soc_camera_device *icd;
  758. const struct tw9910_scale_ctrl *scale;
  759. int i, ret;
  760. info = client->dev.platform_data;
  761. if (!info)
  762. return -EINVAL;
  763. if (!i2c_check_functionality(to_i2c_adapter(client->dev.parent),
  764. I2C_FUNC_SMBUS_BYTE_DATA)) {
  765. dev_err(&client->dev,
  766. "I2C-Adapter doesn't support "
  767. "I2C_FUNC_SMBUS_BYTE_DATA\n");
  768. return -EIO;
  769. }
  770. priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  771. if (!priv)
  772. return -ENOMEM;
  773. priv->info = info;
  774. priv->client = client;
  775. i2c_set_clientdata(client, priv);
  776. icd = &priv->icd;
  777. icd->ops = &tw9910_ops;
  778. icd->control = &client->dev;
  779. icd->iface = info->link.bus_id;
  780. /*
  781. * set width and height
  782. */
  783. icd->width_max = tw9910_ntsc_scales[0].width; /* set default */
  784. icd->width_min = tw9910_ntsc_scales[0].width;
  785. icd->height_max = tw9910_ntsc_scales[0].height;
  786. icd->height_min = tw9910_ntsc_scales[0].height;
  787. scale = tw9910_ntsc_scales;
  788. for (i = 0; i < ARRAY_SIZE(tw9910_ntsc_scales); i++) {
  789. icd->width_max = max(scale[i].width, icd->width_max);
  790. icd->width_min = min(scale[i].width, icd->width_min);
  791. icd->height_max = max(scale[i].height, icd->height_max);
  792. icd->height_min = min(scale[i].height, icd->height_min);
  793. }
  794. scale = tw9910_pal_scales;
  795. for (i = 0; i < ARRAY_SIZE(tw9910_pal_scales); i++) {
  796. icd->width_max = max(scale[i].width, icd->width_max);
  797. icd->width_min = min(scale[i].width, icd->width_min);
  798. icd->height_max = max(scale[i].height, icd->height_max);
  799. icd->height_min = min(scale[i].height, icd->height_min);
  800. }
  801. ret = soc_camera_device_register(icd);
  802. if (ret) {
  803. i2c_set_clientdata(client, NULL);
  804. kfree(priv);
  805. }
  806. return ret;
  807. }
  808. static int tw9910_remove(struct i2c_client *client)
  809. {
  810. struct tw9910_priv *priv = i2c_get_clientdata(client);
  811. soc_camera_device_unregister(&priv->icd);
  812. i2c_set_clientdata(client, NULL);
  813. kfree(priv);
  814. return 0;
  815. }
  816. static const struct i2c_device_id tw9910_id[] = {
  817. { "tw9910", 0 },
  818. { }
  819. };
  820. MODULE_DEVICE_TABLE(i2c, tw9910_id);
  821. static struct i2c_driver tw9910_i2c_driver = {
  822. .driver = {
  823. .name = "tw9910",
  824. },
  825. .probe = tw9910_probe,
  826. .remove = tw9910_remove,
  827. .id_table = tw9910_id,
  828. };
  829. /*
  830. * module function
  831. */
  832. static int __init tw9910_module_init(void)
  833. {
  834. return i2c_add_driver(&tw9910_i2c_driver);
  835. }
  836. static void __exit tw9910_module_exit(void)
  837. {
  838. i2c_del_driver(&tw9910_i2c_driver);
  839. }
  840. module_init(tw9910_module_init);
  841. module_exit(tw9910_module_exit);
  842. MODULE_DESCRIPTION("SoC Camera driver for tw9910");
  843. MODULE_AUTHOR("Kuninori Morimoto");
  844. MODULE_LICENSE("GPL v2");