m5602_ov9650.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767
  1. /*
  2. * Driver for the ov9650 sensor
  3. *
  4. * Copyright (C) 2008 Erik Andrén
  5. * Copyright (C) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
  6. * Copyright (C) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
  7. *
  8. * Portions of code to USB interface and ALi driver software,
  9. * Copyright (c) 2006 Willem Duinker
  10. * v4l2 interface modeled after the V4L2 driver
  11. * for SN9C10x PC Camera Controllers
  12. *
  13. * This program is free software; you can redistribute it and/or
  14. * modify it under the terms of the GNU General Public License as
  15. * published by the Free Software Foundation, version 2.
  16. *
  17. */
  18. #include "m5602_ov9650.h"
  19. /* Vertically and horizontally flips the image if matched, needed for machines
  20. where the sensor is mounted upside down */
  21. static
  22. const
  23. struct dmi_system_id ov9650_flip_dmi_table[] = {
  24. {
  25. .ident = "ASUS A6VC",
  26. .matches = {
  27. DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
  28. DMI_MATCH(DMI_PRODUCT_NAME, "A6VC")
  29. }
  30. },
  31. {
  32. .ident = "ASUS A6VM",
  33. .matches = {
  34. DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
  35. DMI_MATCH(DMI_PRODUCT_NAME, "A6VM")
  36. }
  37. },
  38. {
  39. .ident = "ASUS A6JC",
  40. .matches = {
  41. DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
  42. DMI_MATCH(DMI_PRODUCT_NAME, "A6JC")
  43. }
  44. },
  45. {
  46. .ident = "ASUS A6Ja",
  47. .matches = {
  48. DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
  49. DMI_MATCH(DMI_PRODUCT_NAME, "A6J")
  50. }
  51. },
  52. {
  53. .ident = "ASUS A6Kt",
  54. .matches = {
  55. DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
  56. DMI_MATCH(DMI_PRODUCT_NAME, "A6Kt")
  57. }
  58. },
  59. {
  60. .ident = "Alienware Aurora m9700",
  61. .matches = {
  62. DMI_MATCH(DMI_SYS_VENDOR, "alienware"),
  63. DMI_MATCH(DMI_PRODUCT_NAME, "Aurora m9700")
  64. }
  65. },
  66. { }
  67. };
  68. const static struct ctrl ov9650_ctrls[] = {
  69. {
  70. {
  71. .id = V4L2_CID_EXPOSURE,
  72. .type = V4L2_CTRL_TYPE_INTEGER,
  73. .name = "exposure",
  74. .minimum = 0x00,
  75. .maximum = 0xffff,
  76. .step = 0x1,
  77. .default_value = EXPOSURE_DEFAULT,
  78. .flags = V4L2_CTRL_FLAG_SLIDER
  79. },
  80. .set = ov9650_set_exposure,
  81. .get = ov9650_get_exposure
  82. }, {
  83. {
  84. .id = V4L2_CID_GAIN,
  85. .type = V4L2_CTRL_TYPE_INTEGER,
  86. .name = "gain",
  87. .minimum = 0x00,
  88. .maximum = 0x3ff,
  89. .step = 0x1,
  90. .default_value = GAIN_DEFAULT,
  91. .flags = V4L2_CTRL_FLAG_SLIDER
  92. },
  93. .set = ov9650_set_gain,
  94. .get = ov9650_get_gain
  95. }, {
  96. {
  97. .type = V4L2_CTRL_TYPE_INTEGER,
  98. .name = "red balance",
  99. .minimum = 0x00,
  100. .maximum = 0xff,
  101. .step = 0x1,
  102. .default_value = RED_GAIN_DEFAULT,
  103. .flags = V4L2_CTRL_FLAG_SLIDER
  104. },
  105. .set = ov9650_set_red_balance,
  106. .get = ov9650_get_red_balance
  107. }, {
  108. {
  109. .type = V4L2_CTRL_TYPE_INTEGER,
  110. .name = "blue balance",
  111. .minimum = 0x00,
  112. .maximum = 0xff,
  113. .step = 0x1,
  114. .default_value = BLUE_GAIN_DEFAULT,
  115. .flags = V4L2_CTRL_FLAG_SLIDER
  116. },
  117. .set = ov9650_set_blue_balance,
  118. .get = ov9650_get_blue_balance
  119. }, {
  120. {
  121. .id = V4L2_CID_HFLIP,
  122. .type = V4L2_CTRL_TYPE_BOOLEAN,
  123. .name = "horizontal flip",
  124. .minimum = 0,
  125. .maximum = 1,
  126. .step = 1,
  127. .default_value = 0
  128. },
  129. .set = ov9650_set_hflip,
  130. .get = ov9650_get_hflip
  131. }, {
  132. {
  133. .id = V4L2_CID_VFLIP,
  134. .type = V4L2_CTRL_TYPE_BOOLEAN,
  135. .name = "vertical flip",
  136. .minimum = 0,
  137. .maximum = 1,
  138. .step = 1,
  139. .default_value = 0
  140. },
  141. .set = ov9650_set_vflip,
  142. .get = ov9650_get_vflip
  143. }, {
  144. {
  145. .id = V4L2_CID_AUTO_WHITE_BALANCE,
  146. .type = V4L2_CTRL_TYPE_BOOLEAN,
  147. .name = "auto white balance",
  148. .minimum = 0,
  149. .maximum = 1,
  150. .step = 1,
  151. .default_value = 1
  152. },
  153. .set = ov9650_set_auto_white_balance,
  154. .get = ov9650_get_auto_white_balance
  155. }, {
  156. {
  157. .id = V4L2_CID_AUTOGAIN,
  158. .type = V4L2_CTRL_TYPE_BOOLEAN,
  159. .name = "auto gain control",
  160. .minimum = 0,
  161. .maximum = 1,
  162. .step = 1,
  163. .default_value = 1
  164. },
  165. .set = ov9650_set_auto_gain,
  166. .get = ov9650_get_auto_gain
  167. }
  168. };
  169. static struct v4l2_pix_format ov9650_modes[] = {
  170. {
  171. 176,
  172. 144,
  173. V4L2_PIX_FMT_SBGGR8,
  174. V4L2_FIELD_NONE,
  175. .sizeimage =
  176. 176 * 144,
  177. .bytesperline = 176,
  178. .colorspace = V4L2_COLORSPACE_SRGB,
  179. .priv = 0
  180. }, {
  181. 320,
  182. 240,
  183. V4L2_PIX_FMT_SBGGR8,
  184. V4L2_FIELD_NONE,
  185. .sizeimage =
  186. 320 * 240,
  187. .bytesperline = 320,
  188. .colorspace = V4L2_COLORSPACE_SRGB,
  189. .priv = 0
  190. }, {
  191. 352,
  192. 288,
  193. V4L2_PIX_FMT_SBGGR8,
  194. V4L2_FIELD_NONE,
  195. .sizeimage =
  196. 352 * 288,
  197. .bytesperline = 352,
  198. .colorspace = V4L2_COLORSPACE_SRGB,
  199. .priv = 0
  200. }, {
  201. 640,
  202. 480,
  203. V4L2_PIX_FMT_SBGGR8,
  204. V4L2_FIELD_NONE,
  205. .sizeimage =
  206. 640 * 480,
  207. .bytesperline = 640,
  208. .colorspace = V4L2_COLORSPACE_SRGB,
  209. .priv = 0
  210. }
  211. };
  212. static void ov9650_dump_registers(struct sd *sd);
  213. int ov9650_probe(struct sd *sd)
  214. {
  215. u8 prod_id = 0, ver_id = 0, i;
  216. if (force_sensor) {
  217. if (force_sensor == OV9650_SENSOR) {
  218. info("Forcing an %s sensor", ov9650.name);
  219. goto sensor_found;
  220. }
  221. /* If we want to force another sensor,
  222. don't try to probe this one */
  223. return -ENODEV;
  224. }
  225. info("Probing for an ov9650 sensor");
  226. /* Run the pre-init to actually probe the unit */
  227. for (i = 0; i < ARRAY_SIZE(preinit_ov9650); i++) {
  228. u8 data = preinit_ov9650[i][2];
  229. if (preinit_ov9650[i][0] == SENSOR)
  230. m5602_write_sensor(sd,
  231. preinit_ov9650[i][1], &data, 1);
  232. else
  233. m5602_write_bridge(sd, preinit_ov9650[i][1], data);
  234. }
  235. if (m5602_read_sensor(sd, OV9650_PID, &prod_id, 1))
  236. return -ENODEV;
  237. if (m5602_read_sensor(sd, OV9650_VER, &ver_id, 1))
  238. return -ENODEV;
  239. if ((prod_id == 0x96) && (ver_id == 0x52)) {
  240. info("Detected an ov9650 sensor");
  241. goto sensor_found;
  242. }
  243. return -ENODEV;
  244. sensor_found:
  245. sd->gspca_dev.cam.cam_mode = ov9650_modes;
  246. sd->gspca_dev.cam.nmodes = ARRAY_SIZE(ov9650_modes);
  247. sd->desc->ctrls = ov9650_ctrls;
  248. sd->desc->nctrls = ARRAY_SIZE(ov9650_ctrls);
  249. return 0;
  250. }
  251. int ov9650_init(struct sd *sd)
  252. {
  253. int i, err = 0;
  254. u8 data;
  255. if (dump_sensor)
  256. ov9650_dump_registers(sd);
  257. for (i = 0; i < ARRAY_SIZE(init_ov9650) && !err; i++) {
  258. data = init_ov9650[i][2];
  259. if (init_ov9650[i][0] == SENSOR)
  260. err = m5602_write_sensor(sd, init_ov9650[i][1],
  261. &data, 1);
  262. else
  263. err = m5602_write_bridge(sd, init_ov9650[i][1], data);
  264. }
  265. if (dmi_check_system(ov9650_flip_dmi_table) && !err) {
  266. info("vflip quirk active");
  267. data = 0x30;
  268. err = m5602_write_sensor(sd, OV9650_MVFP, &data, 1);
  269. }
  270. return err;
  271. }
  272. int ov9650_start(struct sd *sd)
  273. {
  274. int i, err = 0;
  275. struct cam *cam = &sd->gspca_dev.cam;
  276. err = ov9650_init(sd);
  277. if (err < 0)
  278. return err;
  279. for (i = 0; i < ARRAY_SIZE(res_init_ov9650) && !err; i++) {
  280. if (res_init_ov9650[i][0] == BRIDGE)
  281. err = m5602_write_bridge(sd, res_init_ov9650[i][1],
  282. res_init_ov9650[i][2]);
  283. else if (res_init_ov9650[i][0] == SENSOR) {
  284. u8 data = res_init_ov9650[i][2];
  285. err = m5602_write_sensor(sd,
  286. res_init_ov9650[i][1], &data, 1);
  287. }
  288. }
  289. if (err < 0)
  290. return err;
  291. switch (cam->cam_mode[sd->gspca_dev.curr_mode].width) {
  292. case 640:
  293. PDEBUG(D_V4L2, "Configuring camera for VGA mode");
  294. for (i = 0; i < ARRAY_SIZE(VGA_ov9650) && !err; i++) {
  295. if (VGA_ov9650[i][0] == SENSOR) {
  296. u8 data = VGA_ov9650[i][2];
  297. err = m5602_write_sensor(sd,
  298. VGA_ov9650[i][1], &data, 1);
  299. } else {
  300. err = m5602_write_bridge(sd, VGA_ov9650[i][1],
  301. VGA_ov9650[i][2]);
  302. }
  303. }
  304. break;
  305. case 352:
  306. PDEBUG(D_V4L2, "Configuring camera for CIF mode");
  307. for (i = 0; i < ARRAY_SIZE(CIF_ov9650) && !err; i++) {
  308. if (CIF_ov9650[i][0] == SENSOR) {
  309. u8 data = CIF_ov9650[i][2];
  310. err = m5602_write_sensor(sd,
  311. CIF_ov9650[i][1], &data, 1);
  312. } else {
  313. err = m5602_write_bridge(sd, CIF_ov9650[i][1],
  314. CIF_ov9650[i][2]);
  315. }
  316. }
  317. break;
  318. case 320:
  319. PDEBUG(D_V4L2, "Configuring camera for QVGA mode");
  320. for (i = 0; i < ARRAY_SIZE(QVGA_ov9650) && !err; i++) {
  321. if (QVGA_ov9650[i][0] == SENSOR) {
  322. u8 data = QVGA_ov9650[i][2];
  323. err = m5602_write_sensor(sd,
  324. QVGA_ov9650[i][1], &data, 1);
  325. } else {
  326. err = m5602_write_bridge(sd, QVGA_ov9650[i][1],
  327. QVGA_ov9650[i][2]);
  328. }
  329. }
  330. break;
  331. case 176:
  332. PDEBUG(D_V4L2, "Configuring camera for QCIF mode");
  333. for (i = 0; i < ARRAY_SIZE(QCIF_ov9650) && !err; i++) {
  334. if (QCIF_ov9650[i][0] == SENSOR) {
  335. u8 data = QCIF_ov9650[i][2];
  336. err = m5602_write_sensor(sd,
  337. QCIF_ov9650[i][1], &data, 1);
  338. } else {
  339. err = m5602_write_bridge(sd, QCIF_ov9650[i][1],
  340. QCIF_ov9650[i][2]);
  341. }
  342. }
  343. break;
  344. }
  345. return err;
  346. }
  347. int ov9650_stop(struct sd *sd)
  348. {
  349. u8 data = OV9650_SOFT_SLEEP | OV9650_OUTPUT_DRIVE_2X;
  350. return m5602_write_sensor(sd, OV9650_COM2, &data, 1);
  351. }
  352. int ov9650_power_down(struct sd *sd)
  353. {
  354. int i, err = 0;
  355. for (i = 0; i < ARRAY_SIZE(power_down_ov9650) && !err; i++) {
  356. u8 data = power_down_ov9650[i][2];
  357. if (power_down_ov9650[i][0] == SENSOR)
  358. err = m5602_write_sensor(sd,
  359. power_down_ov9650[i][1], &data, 1);
  360. else
  361. err = m5602_write_bridge(sd, power_down_ov9650[i][1],
  362. data);
  363. }
  364. return err;
  365. }
  366. int ov9650_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
  367. {
  368. struct sd *sd = (struct sd *) gspca_dev;
  369. u8 i2c_data;
  370. int err;
  371. err = m5602_read_sensor(sd, OV9650_COM1, &i2c_data, 1);
  372. if (err < 0)
  373. return err;
  374. *val = i2c_data & 0x03;
  375. err = m5602_read_sensor(sd, OV9650_AECH, &i2c_data, 1);
  376. if (err < 0)
  377. return err;
  378. *val |= (i2c_data << 2);
  379. err = m5602_read_sensor(sd, OV9650_AECHM, &i2c_data, 1);
  380. if (err < 0)
  381. return err;
  382. *val |= (i2c_data & 0x3f) << 10;
  383. PDEBUG(D_V4L2, "Read exposure %d", *val);
  384. return err;
  385. }
  386. int ov9650_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
  387. {
  388. struct sd *sd = (struct sd *) gspca_dev;
  389. u8 i2c_data;
  390. int err;
  391. PDEBUG(D_V4L2, "Set exposure to %d",
  392. val & 0xffff);
  393. /* The 6 MSBs */
  394. i2c_data = (val >> 10) & 0x3f;
  395. err = m5602_write_sensor(sd, OV9650_AECHM,
  396. &i2c_data, 1);
  397. if (err < 0)
  398. return err;
  399. /* The 8 middle bits */
  400. i2c_data = (val >> 2) & 0xff;
  401. err = m5602_write_sensor(sd, OV9650_AECH,
  402. &i2c_data, 1);
  403. if (err < 0)
  404. return err;
  405. /* The 2 LSBs */
  406. i2c_data = val & 0x03;
  407. err = m5602_write_sensor(sd, OV9650_COM1, &i2c_data, 1);
  408. return err;
  409. }
  410. int ov9650_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
  411. {
  412. int err;
  413. u8 i2c_data;
  414. struct sd *sd = (struct sd *) gspca_dev;
  415. m5602_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
  416. *val = (i2c_data & 0x03) << 8;
  417. err = m5602_read_sensor(sd, OV9650_GAIN, &i2c_data, 1);
  418. *val |= i2c_data;
  419. PDEBUG(D_V4L2, "Read gain %d", *val);
  420. return err;
  421. }
  422. int ov9650_set_gain(struct gspca_dev *gspca_dev, __s32 val)
  423. {
  424. int err;
  425. u8 i2c_data;
  426. struct sd *sd = (struct sd *) gspca_dev;
  427. /* The 2 MSB */
  428. /* Read the OV9650_VREF register first to avoid
  429. corrupting the VREF high and low bits */
  430. m5602_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
  431. /* Mask away all uninteresting bits */
  432. i2c_data = ((val & 0x0300) >> 2) |
  433. (i2c_data & 0x3F);
  434. err = m5602_write_sensor(sd, OV9650_VREF, &i2c_data, 1);
  435. /* The 8 LSBs */
  436. i2c_data = val & 0xff;
  437. err = m5602_write_sensor(sd, OV9650_GAIN, &i2c_data, 1);
  438. return err;
  439. }
  440. int ov9650_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val)
  441. {
  442. int err;
  443. u8 i2c_data;
  444. struct sd *sd = (struct sd *) gspca_dev;
  445. err = m5602_read_sensor(sd, OV9650_RED, &i2c_data, 1);
  446. *val = i2c_data;
  447. PDEBUG(D_V4L2, "Read red gain %d", *val);
  448. return err;
  449. }
  450. int ov9650_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
  451. {
  452. int err;
  453. u8 i2c_data;
  454. struct sd *sd = (struct sd *) gspca_dev;
  455. PDEBUG(D_V4L2, "Set red gain to %d",
  456. val & 0xff);
  457. i2c_data = val & 0xff;
  458. err = m5602_write_sensor(sd, OV9650_RED, &i2c_data, 1);
  459. return err;
  460. }
  461. int ov9650_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val)
  462. {
  463. int err;
  464. u8 i2c_data;
  465. struct sd *sd = (struct sd *) gspca_dev;
  466. err = m5602_read_sensor(sd, OV9650_BLUE, &i2c_data, 1);
  467. *val = i2c_data;
  468. PDEBUG(D_V4L2, "Read blue gain %d", *val);
  469. return err;
  470. }
  471. int ov9650_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
  472. {
  473. int err;
  474. u8 i2c_data;
  475. struct sd *sd = (struct sd *) gspca_dev;
  476. PDEBUG(D_V4L2, "Set blue gain to %d",
  477. val & 0xff);
  478. i2c_data = val & 0xff;
  479. err = m5602_write_sensor(sd, OV9650_BLUE, &i2c_data, 1);
  480. return err;
  481. }
  482. int ov9650_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
  483. {
  484. int err;
  485. u8 i2c_data;
  486. struct sd *sd = (struct sd *) gspca_dev;
  487. err = m5602_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
  488. if (dmi_check_system(ov9650_flip_dmi_table))
  489. *val = ((i2c_data & OV9650_HFLIP) >> 5) ? 0 : 1;
  490. else
  491. *val = (i2c_data & OV9650_HFLIP) >> 5;
  492. PDEBUG(D_V4L2, "Read horizontal flip %d", *val);
  493. return err;
  494. }
  495. int ov9650_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
  496. {
  497. int err;
  498. u8 i2c_data;
  499. struct sd *sd = (struct sd *) gspca_dev;
  500. PDEBUG(D_V4L2, "Set horizontal flip to %d", val);
  501. err = m5602_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
  502. if (err < 0)
  503. return err;
  504. if (dmi_check_system(ov9650_flip_dmi_table))
  505. i2c_data = ((i2c_data & 0xdf) |
  506. (((val ? 0 : 1) & 0x01) << 5));
  507. else
  508. i2c_data = ((i2c_data & 0xdf) |
  509. ((val & 0x01) << 5));
  510. err = m5602_write_sensor(sd, OV9650_MVFP, &i2c_data, 1);
  511. return err;
  512. }
  513. int ov9650_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
  514. {
  515. int err;
  516. u8 i2c_data;
  517. struct sd *sd = (struct sd *) gspca_dev;
  518. err = m5602_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
  519. if (dmi_check_system(ov9650_flip_dmi_table))
  520. *val = ((i2c_data & 0x10) >> 4) ? 0 : 1;
  521. else
  522. *val = (i2c_data & 0x10) >> 4;
  523. PDEBUG(D_V4L2, "Read vertical flip %d", *val);
  524. return err;
  525. }
  526. int ov9650_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
  527. {
  528. int err;
  529. u8 i2c_data;
  530. struct sd *sd = (struct sd *) gspca_dev;
  531. PDEBUG(D_V4L2, "Set vertical flip to %d", val);
  532. err = m5602_read_sensor(sd, OV9650_MVFP, &i2c_data, 1);
  533. if (err < 0)
  534. return err;
  535. if (dmi_check_system(ov9650_flip_dmi_table))
  536. i2c_data = ((i2c_data & 0xef) |
  537. (((val ? 0 : 1) & 0x01) << 4));
  538. else
  539. i2c_data = ((i2c_data & 0xef) |
  540. ((val & 0x01) << 4));
  541. err = m5602_write_sensor(sd, OV9650_MVFP, &i2c_data, 1);
  542. return err;
  543. }
  544. int ov9650_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
  545. {
  546. int err;
  547. u8 i2c_data;
  548. struct sd *sd = (struct sd *) gspca_dev;
  549. err = m5602_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
  550. if (err < 0)
  551. return err;
  552. *val = (i2c_data & 0x03) << 8;
  553. err = m5602_read_sensor(sd, OV9650_GAIN, &i2c_data, 1);
  554. *val |= i2c_data;
  555. PDEBUG(D_V4L2, "Read gain %d", *val);
  556. return err;
  557. }
  558. int ov9650_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
  559. {
  560. int err;
  561. u8 i2c_data;
  562. struct sd *sd = (struct sd *) gspca_dev;
  563. PDEBUG(D_V4L2, "Set gain to %d", val & 0x3ff);
  564. /* Read the OV9650_VREF register first to avoid
  565. corrupting the VREF high and low bits */
  566. err = m5602_read_sensor(sd, OV9650_VREF, &i2c_data, 1);
  567. if (err < 0)
  568. return err;
  569. /* Mask away all uninteresting bits */
  570. i2c_data = ((val & 0x0300) >> 2) | (i2c_data & 0x3F);
  571. err = m5602_write_sensor(sd, OV9650_VREF, &i2c_data, 1);
  572. if (err < 0)
  573. return err;
  574. /* The 8 LSBs */
  575. i2c_data = val & 0xff;
  576. err = m5602_write_sensor(sd, OV9650_GAIN, &i2c_data, 1);
  577. return err;
  578. }
  579. int ov9650_get_auto_white_balance(struct gspca_dev *gspca_dev, __s32 *val)
  580. {
  581. int err;
  582. u8 i2c_data;
  583. struct sd *sd = (struct sd *) gspca_dev;
  584. err = m5602_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
  585. *val = (i2c_data & OV9650_AWB_EN) >> 1;
  586. PDEBUG(D_V4L2, "Read auto white balance %d", *val);
  587. return err;
  588. }
  589. int ov9650_set_auto_white_balance(struct gspca_dev *gspca_dev, __s32 val)
  590. {
  591. int err;
  592. u8 i2c_data;
  593. struct sd *sd = (struct sd *) gspca_dev;
  594. PDEBUG(D_V4L2, "Set auto white balance to %d", val);
  595. err = m5602_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
  596. if (err < 0)
  597. return err;
  598. i2c_data = ((i2c_data & 0xfd) | ((val & 0x01) << 1));
  599. err = m5602_write_sensor(sd, OV9650_COM8, &i2c_data, 1);
  600. return err;
  601. }
  602. int ov9650_get_auto_gain(struct gspca_dev *gspca_dev, __s32 *val)
  603. {
  604. int err;
  605. u8 i2c_data;
  606. struct sd *sd = (struct sd *) gspca_dev;
  607. err = m5602_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
  608. *val = (i2c_data & OV9650_AGC_EN) >> 2;
  609. PDEBUG(D_V4L2, "Read auto gain control %d", *val);
  610. return err;
  611. }
  612. int ov9650_set_auto_gain(struct gspca_dev *gspca_dev, __s32 val)
  613. {
  614. int err;
  615. u8 i2c_data;
  616. struct sd *sd = (struct sd *) gspca_dev;
  617. PDEBUG(D_V4L2, "Set auto gain control to %d", val);
  618. err = m5602_read_sensor(sd, OV9650_COM8, &i2c_data, 1);
  619. if (err < 0)
  620. return err;
  621. i2c_data = ((i2c_data & 0xfb) | ((val & 0x01) << 2));
  622. err = m5602_write_sensor(sd, OV9650_COM8, &i2c_data, 1);
  623. return err;
  624. }
  625. static void ov9650_dump_registers(struct sd *sd)
  626. {
  627. int address;
  628. info("Dumping the ov9650 register state");
  629. for (address = 0; address < 0xa9; address++) {
  630. u8 value;
  631. m5602_read_sensor(sd, address, &value, 1);
  632. info("register 0x%x contains 0x%x",
  633. address, value);
  634. }
  635. info("ov9650 register state dump complete");
  636. info("Probing for which registers that are read/write");
  637. for (address = 0; address < 0xff; address++) {
  638. u8 old_value, ctrl_value;
  639. u8 test_value[2] = {0xff, 0xff};
  640. m5602_read_sensor(sd, address, &old_value, 1);
  641. m5602_write_sensor(sd, address, test_value, 1);
  642. m5602_read_sensor(sd, address, &ctrl_value, 1);
  643. if (ctrl_value == test_value[0])
  644. info("register 0x%x is writeable", address);
  645. else
  646. info("register 0x%x is read only", address);
  647. /* Restore original value */
  648. m5602_write_sensor(sd, address, &old_value, 1);
  649. }
  650. }