pac7302.c 32 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283
  1. /*
  2. * Pixart PAC7302 library
  3. * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
  4. *
  5. * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
  6. *
  7. * Separated from Pixart PAC7311 library by Márton Németh <nm127@freemail.hu>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License as published by
  11. * the Free Software Foundation; either version 2 of the License, or
  12. * any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. * GNU General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software
  21. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22. */
  23. /* Some documentation about various registers as determined by trial and error.
  24. When the register addresses differ between the 7202 and the 7311 the 2
  25. different addresses are written as 7302addr/7311addr, when one of the 2
  26. addresses is a - sign that register description is not valid for the
  27. matching IC.
  28. Register page 1:
  29. Address Description
  30. -/0x08 Unknown compressor related, must always be 8 except when not
  31. in 640x480 resolution and page 4 reg 2 <= 3 then set it to 9 !
  32. -/0x1b Auto white balance related, bit 0 is AWB enable (inverted)
  33. bits 345 seem to toggle per color gains on/off (inverted)
  34. 0x78 Global control, bit 6 controls the LED (inverted)
  35. -/0x80 JPEG compression ratio ? Best not touched
  36. Register page 3/4:
  37. Address Description
  38. 0x02 Clock divider 2-63, fps =~ 60 / val. Must be a multiple of 3 on
  39. the 7302, so one of 3, 6, 9, ..., except when between 6 and 12?
  40. -/0x0f Master gain 1-245, low value = high gain
  41. 0x10/- Master gain 0-31
  42. -/0x10 Another gain 0-15, limited influence (1-2x gain I guess)
  43. 0x21 Bitfield: 0-1 unused, 2-3 vflip/hflip, 4-5 unknown, 6-7 unused
  44. -/0x27 Seems to toggle various gains on / off, Setting bit 7 seems to
  45. completely disable the analog amplification block. Set to 0x68
  46. for max gain, 0x14 for minimal gain.
  47. The registers are accessed in the following functions:
  48. Page | Register | Function
  49. -----+------------+---------------------------------------------------
  50. 0 | 0x0f..0x20 | setcolors()
  51. 0 | 0xa2..0xab | setbrightcont()
  52. 0 | 0xc5 | setredbalance()
  53. 0 | 0xc6 | setwhitebalance()
  54. 0 | 0xc7 | setbluebalance()
  55. 0 | 0xdc | setbrightcont(), setcolors()
  56. 3 | 0x02 | setexposure()
  57. 3 | 0x10 | setgain()
  58. 3 | 0x11 | setcolors(), setgain(), setexposure(), sethvflip()
  59. 3 | 0x21 | sethvflip()
  60. */
  61. #define MODULE_NAME "pac7302"
  62. #include <media/v4l2-chip-ident.h>
  63. #include "gspca.h"
  64. MODULE_AUTHOR("Thomas Kaiser thomas@kaiser-linux.li");
  65. MODULE_DESCRIPTION("Pixart PAC7302");
  66. MODULE_LICENSE("GPL");
  67. /* specific webcam descriptor for pac7302 */
  68. struct sd {
  69. struct gspca_dev gspca_dev; /* !! must be the first item */
  70. unsigned char brightness;
  71. unsigned char contrast;
  72. unsigned char colors;
  73. unsigned char white_balance;
  74. unsigned char red_balance;
  75. unsigned char blue_balance;
  76. unsigned char gain;
  77. unsigned char exposure;
  78. unsigned char autogain;
  79. __u8 hflip;
  80. __u8 vflip;
  81. u8 flags;
  82. #define FL_HFLIP 0x01 /* mirrored by default */
  83. #define FL_VFLIP 0x02 /* vertical flipped by default */
  84. u8 sof_read;
  85. u8 autogain_ignore_frames;
  86. atomic_t avg_lum;
  87. };
  88. /* V4L2 controls supported by the driver */
  89. static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  90. static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  91. static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  92. static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  93. static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
  94. static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
  95. static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val);
  96. static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val);
  97. static int sd_setredbalance(struct gspca_dev *gspca_dev, __s32 val);
  98. static int sd_getredbalance(struct gspca_dev *gspca_dev, __s32 *val);
  99. static int sd_setbluebalance(struct gspca_dev *gspca_dev, __s32 val);
  100. static int sd_getbluebalance(struct gspca_dev *gspca_dev, __s32 *val);
  101. static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
  102. static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
  103. static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
  104. static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
  105. static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
  106. static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
  107. static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
  108. static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
  109. static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
  110. static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
  111. static struct ctrl sd_ctrls[] = {
  112. /* This control is pac7302 only */
  113. {
  114. {
  115. .id = V4L2_CID_BRIGHTNESS,
  116. .type = V4L2_CTRL_TYPE_INTEGER,
  117. .name = "Brightness",
  118. .minimum = 0,
  119. #define BRIGHTNESS_MAX 0x20
  120. .maximum = BRIGHTNESS_MAX,
  121. .step = 1,
  122. #define BRIGHTNESS_DEF 0x10
  123. .default_value = BRIGHTNESS_DEF,
  124. },
  125. .set = sd_setbrightness,
  126. .get = sd_getbrightness,
  127. },
  128. /* This control is for both the 7302 and the 7311 */
  129. {
  130. {
  131. .id = V4L2_CID_CONTRAST,
  132. .type = V4L2_CTRL_TYPE_INTEGER,
  133. .name = "Contrast",
  134. .minimum = 0,
  135. #define CONTRAST_MAX 255
  136. .maximum = CONTRAST_MAX,
  137. .step = 1,
  138. #define CONTRAST_DEF 127
  139. .default_value = CONTRAST_DEF,
  140. },
  141. .set = sd_setcontrast,
  142. .get = sd_getcontrast,
  143. },
  144. /* This control is pac7302 only */
  145. {
  146. {
  147. .id = V4L2_CID_SATURATION,
  148. .type = V4L2_CTRL_TYPE_INTEGER,
  149. .name = "Saturation",
  150. .minimum = 0,
  151. #define COLOR_MAX 255
  152. .maximum = COLOR_MAX,
  153. .step = 1,
  154. #define COLOR_DEF 127
  155. .default_value = COLOR_DEF,
  156. },
  157. .set = sd_setcolors,
  158. .get = sd_getcolors,
  159. },
  160. {
  161. {
  162. .id = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
  163. .type = V4L2_CTRL_TYPE_INTEGER,
  164. .name = "White Balance",
  165. .minimum = 0,
  166. .maximum = 255,
  167. .step = 1,
  168. #define WHITEBALANCE_DEF 4
  169. .default_value = WHITEBALANCE_DEF,
  170. },
  171. .set = sd_setwhitebalance,
  172. .get = sd_getwhitebalance,
  173. },
  174. {
  175. {
  176. .id = V4L2_CID_RED_BALANCE,
  177. .type = V4L2_CTRL_TYPE_INTEGER,
  178. .name = "Red",
  179. .minimum = 0,
  180. .maximum = 3,
  181. .step = 1,
  182. #define REDBALANCE_DEF 1
  183. .default_value = REDBALANCE_DEF,
  184. },
  185. .set = sd_setredbalance,
  186. .get = sd_getredbalance,
  187. },
  188. {
  189. {
  190. .id = V4L2_CID_BLUE_BALANCE,
  191. .type = V4L2_CTRL_TYPE_INTEGER,
  192. .name = "Blue",
  193. .minimum = 0,
  194. .maximum = 3,
  195. .step = 1,
  196. #define BLUEBALANCE_DEF 1
  197. .default_value = BLUEBALANCE_DEF,
  198. },
  199. .set = sd_setbluebalance,
  200. .get = sd_getbluebalance,
  201. },
  202. /* All controls below are for both the 7302 and the 7311 */
  203. {
  204. {
  205. .id = V4L2_CID_GAIN,
  206. .type = V4L2_CTRL_TYPE_INTEGER,
  207. .name = "Gain",
  208. .minimum = 0,
  209. #define GAIN_MAX 255
  210. .maximum = GAIN_MAX,
  211. .step = 1,
  212. #define GAIN_DEF 127
  213. #define GAIN_KNEE 255 /* Gain seems to cause little noise on the pac73xx */
  214. .default_value = GAIN_DEF,
  215. },
  216. .set = sd_setgain,
  217. .get = sd_getgain,
  218. },
  219. {
  220. {
  221. .id = V4L2_CID_EXPOSURE,
  222. .type = V4L2_CTRL_TYPE_INTEGER,
  223. .name = "Exposure",
  224. .minimum = 0,
  225. #define EXPOSURE_MAX 255
  226. .maximum = EXPOSURE_MAX,
  227. .step = 1,
  228. #define EXPOSURE_DEF 16 /* 32 ms / 30 fps */
  229. #define EXPOSURE_KNEE 50 /* 100 ms / 10 fps */
  230. .default_value = EXPOSURE_DEF,
  231. },
  232. .set = sd_setexposure,
  233. .get = sd_getexposure,
  234. },
  235. {
  236. {
  237. .id = V4L2_CID_AUTOGAIN,
  238. .type = V4L2_CTRL_TYPE_BOOLEAN,
  239. .name = "Auto Gain",
  240. .minimum = 0,
  241. .maximum = 1,
  242. .step = 1,
  243. #define AUTOGAIN_DEF 1
  244. .default_value = AUTOGAIN_DEF,
  245. },
  246. .set = sd_setautogain,
  247. .get = sd_getautogain,
  248. },
  249. {
  250. {
  251. .id = V4L2_CID_HFLIP,
  252. .type = V4L2_CTRL_TYPE_BOOLEAN,
  253. .name = "Mirror",
  254. .minimum = 0,
  255. .maximum = 1,
  256. .step = 1,
  257. #define HFLIP_DEF 0
  258. .default_value = HFLIP_DEF,
  259. },
  260. .set = sd_sethflip,
  261. .get = sd_gethflip,
  262. },
  263. {
  264. {
  265. .id = V4L2_CID_VFLIP,
  266. .type = V4L2_CTRL_TYPE_BOOLEAN,
  267. .name = "Vflip",
  268. .minimum = 0,
  269. .maximum = 1,
  270. .step = 1,
  271. #define VFLIP_DEF 0
  272. .default_value = VFLIP_DEF,
  273. },
  274. .set = sd_setvflip,
  275. .get = sd_getvflip,
  276. },
  277. };
  278. static const struct v4l2_pix_format vga_mode[] = {
  279. {640, 480, V4L2_PIX_FMT_PJPG, V4L2_FIELD_NONE,
  280. .bytesperline = 640,
  281. .sizeimage = 640 * 480 * 3 / 8 + 590,
  282. .colorspace = V4L2_COLORSPACE_JPEG,
  283. .priv = 0},
  284. };
  285. #define LOAD_PAGE3 255
  286. #define LOAD_PAGE4 254
  287. #define END_OF_SEQUENCE 0
  288. /* pac 7302 */
  289. static const __u8 init_7302[] = {
  290. /* index,value */
  291. 0xff, 0x01, /* page 1 */
  292. 0x78, 0x00, /* deactivate */
  293. 0xff, 0x01,
  294. 0x78, 0x40, /* led off */
  295. };
  296. static const __u8 start_7302[] = {
  297. /* index, len, [value]* */
  298. 0xff, 1, 0x00, /* page 0 */
  299. 0x00, 12, 0x01, 0x40, 0x40, 0x40, 0x01, 0xe0, 0x02, 0x80,
  300. 0x00, 0x00, 0x00, 0x00,
  301. 0x0d, 24, 0x03, 0x01, 0x00, 0xb5, 0x07, 0xcb, 0x00, 0x00,
  302. 0x07, 0xc8, 0x00, 0xea, 0x07, 0xcf, 0x07, 0xf7,
  303. 0x07, 0x7e, 0x01, 0x0b, 0x00, 0x00, 0x00, 0x11,
  304. 0x26, 2, 0xaa, 0xaa,
  305. 0x2e, 1, 0x31,
  306. 0x38, 1, 0x01,
  307. 0x3a, 3, 0x14, 0xff, 0x5a,
  308. 0x43, 11, 0x00, 0x0a, 0x18, 0x11, 0x01, 0x2c, 0x88, 0x11,
  309. 0x00, 0x54, 0x11,
  310. 0x55, 1, 0x00,
  311. 0x62, 4, 0x10, 0x1e, 0x1e, 0x18,
  312. 0x6b, 1, 0x00,
  313. 0x6e, 3, 0x08, 0x06, 0x00,
  314. 0x72, 3, 0x00, 0xff, 0x00,
  315. 0x7d, 23, 0x01, 0x01, 0x58, 0x46, 0x50, 0x3c, 0x50, 0x3c,
  316. 0x54, 0x46, 0x54, 0x56, 0x52, 0x50, 0x52, 0x50,
  317. 0x56, 0x64, 0xa4, 0x00, 0xda, 0x00, 0x00,
  318. 0xa2, 10, 0x22, 0x2c, 0x3c, 0x54, 0x69, 0x7c, 0x9c, 0xb9,
  319. 0xd2, 0xeb,
  320. 0xaf, 1, 0x02,
  321. 0xb5, 2, 0x08, 0x08,
  322. 0xb8, 2, 0x08, 0x88,
  323. 0xc4, 4, 0xae, 0x01, 0x04, 0x01,
  324. 0xcc, 1, 0x00,
  325. 0xd1, 11, 0x01, 0x30, 0x49, 0x5e, 0x6f, 0x7f, 0x8e, 0xa9,
  326. 0xc1, 0xd7, 0xec,
  327. 0xdc, 1, 0x01,
  328. 0xff, 1, 0x01, /* page 1 */
  329. 0x12, 3, 0x02, 0x00, 0x01,
  330. 0x3e, 2, 0x00, 0x00,
  331. 0x76, 5, 0x01, 0x20, 0x40, 0x00, 0xf2,
  332. 0x7c, 1, 0x00,
  333. 0x7f, 10, 0x4b, 0x0f, 0x01, 0x2c, 0x02, 0x58, 0x03, 0x20,
  334. 0x02, 0x00,
  335. 0x96, 5, 0x01, 0x10, 0x04, 0x01, 0x04,
  336. 0xc8, 14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
  337. 0x07, 0x00, 0x01, 0x07, 0x04, 0x01,
  338. 0xd8, 1, 0x01,
  339. 0xdb, 2, 0x00, 0x01,
  340. 0xde, 7, 0x00, 0x01, 0x04, 0x04, 0x00, 0x00, 0x00,
  341. 0xe6, 4, 0x00, 0x00, 0x00, 0x01,
  342. 0xeb, 1, 0x00,
  343. 0xff, 1, 0x02, /* page 2 */
  344. 0x22, 1, 0x00,
  345. 0xff, 1, 0x03, /* page 3 */
  346. 0, LOAD_PAGE3, /* load the page 3 */
  347. 0x11, 1, 0x01,
  348. 0xff, 1, 0x02, /* page 2 */
  349. 0x13, 1, 0x00,
  350. 0x22, 4, 0x1f, 0xa4, 0xf0, 0x96,
  351. 0x27, 2, 0x14, 0x0c,
  352. 0x2a, 5, 0xc8, 0x00, 0x18, 0x12, 0x22,
  353. 0x64, 8, 0x00, 0x00, 0xf0, 0x01, 0x14, 0x44, 0x44, 0x44,
  354. 0x6e, 1, 0x08,
  355. 0xff, 1, 0x01, /* page 1 */
  356. 0x78, 1, 0x00,
  357. 0, END_OF_SEQUENCE /* end of sequence */
  358. };
  359. #define SKIP 0xaa
  360. /* page 3 - the value SKIP says skip the index - see reg_w_page() */
  361. static const __u8 page3_7302[] = {
  362. 0x90, 0x40, 0x03, 0x50, 0xc2, 0x01, 0x14, 0x16,
  363. 0x14, 0x12, 0x00, 0x00, 0x00, 0x02, 0x33, 0x00,
  364. 0x0f, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  365. 0x00, 0x00, 0x00, 0x47, 0x01, 0xb3, 0x01, 0x00,
  366. 0x00, 0x08, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x21,
  367. 0x00, 0x00, 0x00, 0x54, 0xf4, 0x02, 0x52, 0x54,
  368. 0xa4, 0xb8, 0xe0, 0x2a, 0xf6, 0x00, 0x00, 0x00,
  369. 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  370. 0x00, 0xfc, 0x00, 0xf2, 0x1f, 0x04, 0x00, 0x00,
  371. 0x00, 0x00, 0x00, 0xc0, 0xc0, 0x10, 0x00, 0x00,
  372. 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  373. 0x00, 0x40, 0xff, 0x03, 0x19, 0x00, 0x00, 0x00,
  374. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  375. 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xc8, 0xc8,
  376. 0xc8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,
  377. 0x08, 0x10, 0x24, 0x40, 0x00, 0x00, 0x00, 0x00,
  378. 0x01, 0x00, 0x02, 0x47, 0x00, 0x00, 0x00, 0x00,
  379. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  380. 0x00, 0x02, 0xfa, 0x00, 0x64, 0x5a, 0x28, 0x00,
  381. 0x00
  382. };
  383. static int reg_w_buf(struct gspca_dev *gspca_dev,
  384. __u8 index,
  385. const char *buffer, int len)
  386. {
  387. int ret;
  388. memcpy(gspca_dev->usb_buf, buffer, len);
  389. ret = usb_control_msg(gspca_dev->dev,
  390. usb_sndctrlpipe(gspca_dev->dev, 0),
  391. 1, /* request */
  392. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  393. 0, /* value */
  394. index, gspca_dev->usb_buf, len,
  395. 500);
  396. if (ret < 0)
  397. PDEBUG(D_ERR, "reg_w_buf(): "
  398. "Failed to write registers to index 0x%x, error %i",
  399. index, ret);
  400. return ret;
  401. }
  402. static int reg_w(struct gspca_dev *gspca_dev,
  403. __u8 index,
  404. __u8 value)
  405. {
  406. int ret;
  407. gspca_dev->usb_buf[0] = value;
  408. ret = usb_control_msg(gspca_dev->dev,
  409. usb_sndctrlpipe(gspca_dev->dev, 0),
  410. 0, /* request */
  411. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  412. 0, index, gspca_dev->usb_buf, 1,
  413. 500);
  414. if (ret < 0)
  415. PDEBUG(D_ERR, "reg_w(): "
  416. "Failed to write register to index 0x%x, value 0x%x, error %i",
  417. index, value, ret);
  418. return ret;
  419. }
  420. static int reg_w_seq(struct gspca_dev *gspca_dev,
  421. const __u8 *seq, int len)
  422. {
  423. int ret = 0;
  424. while (--len >= 0) {
  425. if (0 <= ret)
  426. ret = reg_w(gspca_dev, seq[0], seq[1]);
  427. seq += 2;
  428. }
  429. return ret;
  430. }
  431. /* load the beginning of a page */
  432. static int reg_w_page(struct gspca_dev *gspca_dev,
  433. const __u8 *page, int len)
  434. {
  435. int index;
  436. int ret = 0;
  437. for (index = 0; index < len; index++) {
  438. if (page[index] == SKIP) /* skip this index */
  439. continue;
  440. gspca_dev->usb_buf[0] = page[index];
  441. ret = usb_control_msg(gspca_dev->dev,
  442. usb_sndctrlpipe(gspca_dev->dev, 0),
  443. 0, /* request */
  444. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  445. 0, index, gspca_dev->usb_buf, 1,
  446. 500);
  447. if (ret < 0) {
  448. PDEBUG(D_ERR, "reg_w_page(): "
  449. "Failed to write register to index 0x%x, "
  450. "value 0x%x, error %i",
  451. index, page[index], ret);
  452. break;
  453. }
  454. }
  455. return ret;
  456. }
  457. /* output a variable sequence */
  458. static int reg_w_var(struct gspca_dev *gspca_dev,
  459. const __u8 *seq,
  460. const __u8 *page3, unsigned int page3_len,
  461. const __u8 *page4, unsigned int page4_len)
  462. {
  463. int index, len;
  464. int ret = 0;
  465. for (;;) {
  466. index = *seq++;
  467. len = *seq++;
  468. switch (len) {
  469. case END_OF_SEQUENCE:
  470. return ret;
  471. case LOAD_PAGE4:
  472. ret = reg_w_page(gspca_dev, page4, page4_len);
  473. break;
  474. case LOAD_PAGE3:
  475. ret = reg_w_page(gspca_dev, page3, page3_len);
  476. break;
  477. default:
  478. if (len > USB_BUF_SZ) {
  479. PDEBUG(D_ERR|D_STREAM,
  480. "Incorrect variable sequence");
  481. return -EINVAL;
  482. }
  483. while (len > 0) {
  484. if (len < 8) {
  485. ret = reg_w_buf(gspca_dev,
  486. index, seq, len);
  487. if (ret < 0)
  488. return ret;
  489. seq += len;
  490. break;
  491. }
  492. ret = reg_w_buf(gspca_dev, index, seq, 8);
  493. seq += 8;
  494. index += 8;
  495. len -= 8;
  496. }
  497. }
  498. if (ret < 0)
  499. return ret;
  500. }
  501. /* not reached */
  502. }
  503. /* this function is called at probe time for pac7302 */
  504. static int sd_config(struct gspca_dev *gspca_dev,
  505. const struct usb_device_id *id)
  506. {
  507. struct sd *sd = (struct sd *) gspca_dev;
  508. struct cam *cam;
  509. cam = &gspca_dev->cam;
  510. PDEBUG(D_CONF, "Find Sensor PAC7302");
  511. cam->cam_mode = vga_mode; /* only 640x480 */
  512. cam->nmodes = ARRAY_SIZE(vga_mode);
  513. sd->brightness = BRIGHTNESS_DEF;
  514. sd->contrast = CONTRAST_DEF;
  515. sd->colors = COLOR_DEF;
  516. sd->white_balance = WHITEBALANCE_DEF;
  517. sd->red_balance = REDBALANCE_DEF;
  518. sd->blue_balance = BLUEBALANCE_DEF;
  519. sd->gain = GAIN_DEF;
  520. sd->exposure = EXPOSURE_DEF;
  521. sd->autogain = AUTOGAIN_DEF;
  522. sd->hflip = HFLIP_DEF;
  523. sd->vflip = VFLIP_DEF;
  524. sd->flags = id->driver_info;
  525. return 0;
  526. }
  527. /* This function is used by pac7302 only */
  528. static int setbrightcont(struct gspca_dev *gspca_dev)
  529. {
  530. struct sd *sd = (struct sd *) gspca_dev;
  531. int i, v;
  532. int ret;
  533. static const __u8 max[10] =
  534. {0x29, 0x33, 0x42, 0x5a, 0x6e, 0x80, 0x9f, 0xbb,
  535. 0xd4, 0xec};
  536. static const __u8 delta[10] =
  537. {0x35, 0x33, 0x33, 0x2f, 0x2a, 0x25, 0x1e, 0x17,
  538. 0x11, 0x0b};
  539. ret = reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
  540. for (i = 0; i < 10; i++) {
  541. v = max[i];
  542. v += (sd->brightness - BRIGHTNESS_MAX)
  543. * 150 / BRIGHTNESS_MAX; /* 200 ? */
  544. v -= delta[i] * sd->contrast / CONTRAST_MAX;
  545. if (v < 0)
  546. v = 0;
  547. else if (v > 0xff)
  548. v = 0xff;
  549. if (0 <= ret)
  550. ret = reg_w(gspca_dev, 0xa2 + i, v);
  551. }
  552. if (0 <= ret)
  553. ret = reg_w(gspca_dev, 0xdc, 0x01);
  554. return ret;
  555. }
  556. /* This function is used by pac7302 only */
  557. static int setcolors(struct gspca_dev *gspca_dev)
  558. {
  559. struct sd *sd = (struct sd *) gspca_dev;
  560. int i, v;
  561. int ret;
  562. static const int a[9] =
  563. {217, -212, 0, -101, 170, -67, -38, -315, 355};
  564. static const int b[9] =
  565. {19, 106, 0, 19, 106, 1, 19, 106, 1};
  566. ret = reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
  567. if (0 <= ret)
  568. ret = reg_w(gspca_dev, 0x11, 0x01);
  569. if (0 <= ret)
  570. ret = reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
  571. for (i = 0; i < 9; i++) {
  572. v = a[i] * sd->colors / COLOR_MAX + b[i];
  573. if (0 <= ret)
  574. ret = reg_w(gspca_dev, 0x0f + 2 * i, (v >> 8) & 0x07);
  575. if (0 <= ret)
  576. ret = reg_w(gspca_dev, 0x0f + 2 * i + 1, v);
  577. }
  578. if (0 <= ret)
  579. ret = reg_w(gspca_dev, 0xdc, 0x01);
  580. PDEBUG(D_CONF|D_STREAM, "color: %i", sd->colors);
  581. return ret;
  582. }
  583. static int setwhitebalance(struct gspca_dev *gspca_dev)
  584. {
  585. struct sd *sd = (struct sd *) gspca_dev;
  586. int ret;
  587. ret = reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
  588. if (0 <= ret)
  589. ret = reg_w(gspca_dev, 0xc6, sd->white_balance);
  590. if (0 <= ret)
  591. ret = reg_w(gspca_dev, 0xdc, 0x01);
  592. PDEBUG(D_CONF|D_STREAM, "white_balance: %i", sd->white_balance);
  593. return ret;
  594. }
  595. static int setredbalance(struct gspca_dev *gspca_dev)
  596. {
  597. struct sd *sd = (struct sd *) gspca_dev;
  598. int ret;
  599. ret = reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
  600. if (0 <= ret)
  601. ret = reg_w(gspca_dev, 0xc5, sd->red_balance);
  602. if (0 <= ret)
  603. ret = reg_w(gspca_dev, 0xdc, 0x01);
  604. PDEBUG(D_CONF|D_STREAM, "red_balance: %i", sd->red_balance);
  605. return ret;
  606. }
  607. static int setbluebalance(struct gspca_dev *gspca_dev)
  608. {
  609. struct sd *sd = (struct sd *) gspca_dev;
  610. int ret;
  611. ret = reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
  612. if (0 <= ret)
  613. ret = reg_w(gspca_dev, 0xc7, sd->blue_balance);
  614. if (0 <= ret)
  615. ret = reg_w(gspca_dev, 0xdc, 0x01);
  616. PDEBUG(D_CONF|D_STREAM, "blue_balance: %i", sd->blue_balance);
  617. return ret;
  618. }
  619. static int setgain(struct gspca_dev *gspca_dev)
  620. {
  621. struct sd *sd = (struct sd *) gspca_dev;
  622. int ret;
  623. ret = reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
  624. if (0 <= ret)
  625. ret = reg_w(gspca_dev, 0x10, sd->gain >> 3);
  626. /* load registers to sensor (Bit 0, auto clear) */
  627. if (0 <= ret)
  628. ret = reg_w(gspca_dev, 0x11, 0x01);
  629. return ret;
  630. }
  631. static int setexposure(struct gspca_dev *gspca_dev)
  632. {
  633. struct sd *sd = (struct sd *) gspca_dev;
  634. int ret;
  635. __u8 reg;
  636. /* register 2 of frame 3/4 contains the clock divider configuring the
  637. no fps according to the formula: 60 / reg. sd->exposure is the
  638. desired exposure time in ms. */
  639. reg = 120 * sd->exposure / 1000;
  640. if (reg < 2)
  641. reg = 2;
  642. else if (reg > 63)
  643. reg = 63;
  644. /* On the pac7302 reg2 MUST be a multiple of 3, so round it to
  645. the nearest multiple of 3, except when between 6 and 12? */
  646. if (reg < 6 || reg > 12)
  647. reg = ((reg + 1) / 3) * 3;
  648. ret = reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
  649. if (0 <= ret)
  650. ret = reg_w(gspca_dev, 0x02, reg);
  651. /* load registers to sensor (Bit 0, auto clear) */
  652. if (0 <= ret)
  653. ret = reg_w(gspca_dev, 0x11, 0x01);
  654. return ret;
  655. }
  656. static int sethvflip(struct gspca_dev *gspca_dev)
  657. {
  658. struct sd *sd = (struct sd *) gspca_dev;
  659. int ret;
  660. u8 data, hflip, vflip;
  661. hflip = sd->hflip;
  662. if (sd->flags & FL_HFLIP)
  663. hflip = !hflip;
  664. vflip = sd->vflip;
  665. if (sd->flags & FL_VFLIP)
  666. vflip = !vflip;
  667. ret = reg_w(gspca_dev, 0xff, 0x03); /* page 3 */
  668. data = (hflip ? 0x08 : 0x00) | (vflip ? 0x04 : 0x00);
  669. if (0 <= ret)
  670. ret = reg_w(gspca_dev, 0x21, data);
  671. /* load registers to sensor (Bit 0, auto clear) */
  672. if (0 <= ret)
  673. ret = reg_w(gspca_dev, 0x11, 0x01);
  674. return ret;
  675. }
  676. /* this function is called at probe and resume time for pac7302 */
  677. static int sd_init(struct gspca_dev *gspca_dev)
  678. {
  679. return reg_w_seq(gspca_dev, init_7302, sizeof(init_7302)/2);
  680. }
  681. static int sd_start(struct gspca_dev *gspca_dev)
  682. {
  683. struct sd *sd = (struct sd *) gspca_dev;
  684. int ret = 0;
  685. sd->sof_read = 0;
  686. ret = reg_w_var(gspca_dev, start_7302,
  687. page3_7302, sizeof(page3_7302),
  688. NULL, 0);
  689. if (0 <= ret)
  690. ret = setbrightcont(gspca_dev);
  691. if (0 <= ret)
  692. ret = setcolors(gspca_dev);
  693. if (0 <= ret)
  694. ret = setwhitebalance(gspca_dev);
  695. if (0 <= ret)
  696. ret = setredbalance(gspca_dev);
  697. if (0 <= ret)
  698. ret = setbluebalance(gspca_dev);
  699. if (0 <= ret)
  700. ret = setgain(gspca_dev);
  701. if (0 <= ret)
  702. ret = setexposure(gspca_dev);
  703. if (0 <= ret)
  704. ret = sethvflip(gspca_dev);
  705. /* only resolution 640x480 is supported for pac7302 */
  706. sd->sof_read = 0;
  707. sd->autogain_ignore_frames = 0;
  708. atomic_set(&sd->avg_lum, -1);
  709. /* start stream */
  710. if (0 <= ret)
  711. ret = reg_w(gspca_dev, 0xff, 0x01);
  712. if (0 <= ret)
  713. ret = reg_w(gspca_dev, 0x78, 0x01);
  714. return ret;
  715. }
  716. static void sd_stopN(struct gspca_dev *gspca_dev)
  717. {
  718. int ret;
  719. /* stop stream */
  720. ret = reg_w(gspca_dev, 0xff, 0x01);
  721. if (0 <= ret)
  722. ret = reg_w(gspca_dev, 0x78, 0x00);
  723. }
  724. /* called on streamoff with alt 0 and on disconnect for pac7302 */
  725. static void sd_stop0(struct gspca_dev *gspca_dev)
  726. {
  727. int ret;
  728. if (!gspca_dev->present)
  729. return;
  730. ret = reg_w(gspca_dev, 0xff, 0x01);
  731. if (0 <= ret)
  732. ret = reg_w(gspca_dev, 0x78, 0x40);
  733. }
  734. /* Include pac common sof detection functions */
  735. #include "pac_common.h"
  736. static void do_autogain(struct gspca_dev *gspca_dev)
  737. {
  738. struct sd *sd = (struct sd *) gspca_dev;
  739. int avg_lum = atomic_read(&sd->avg_lum);
  740. int desired_lum, deadzone;
  741. if (avg_lum == -1)
  742. return;
  743. desired_lum = 270 + sd->brightness * 4;
  744. /* Hack hack, with the 7202 the first exposure step is
  745. pretty large, so if we're about to make the first
  746. exposure increase make the deadzone large to avoid
  747. oscilating */
  748. if (desired_lum > avg_lum && sd->gain == GAIN_DEF &&
  749. sd->exposure > EXPOSURE_DEF &&
  750. sd->exposure < 42)
  751. deadzone = 90;
  752. else
  753. deadzone = 30;
  754. if (sd->autogain_ignore_frames > 0)
  755. sd->autogain_ignore_frames--;
  756. else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum, desired_lum,
  757. deadzone, GAIN_KNEE, EXPOSURE_KNEE))
  758. sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
  759. }
  760. /* JPEG header, part 1 */
  761. static const unsigned char pac_jpeg_header1[] = {
  762. 0xff, 0xd8, /* SOI: Start of Image */
  763. 0xff, 0xc0, /* SOF0: Start of Frame (Baseline DCT) */
  764. 0x00, 0x11, /* length = 17 bytes (including this length field) */
  765. 0x08 /* Precision: 8 */
  766. /* 2 bytes is placed here: number of image lines */
  767. /* 2 bytes is placed here: samples per line */
  768. };
  769. /* JPEG header, continued */
  770. static const unsigned char pac_jpeg_header2[] = {
  771. 0x03, /* Number of image components: 3 */
  772. 0x01, 0x21, 0x00, /* ID=1, Subsampling 1x1, Quantization table: 0 */
  773. 0x02, 0x11, 0x01, /* ID=2, Subsampling 2x1, Quantization table: 1 */
  774. 0x03, 0x11, 0x01, /* ID=3, Subsampling 2x1, Quantization table: 1 */
  775. 0xff, 0xda, /* SOS: Start Of Scan */
  776. 0x00, 0x0c, /* length = 12 bytes (including this length field) */
  777. 0x03, /* number of components: 3 */
  778. 0x01, 0x00, /* selector 1, table 0x00 */
  779. 0x02, 0x11, /* selector 2, table 0x11 */
  780. 0x03, 0x11, /* selector 3, table 0x11 */
  781. 0x00, 0x3f, /* Spectral selection: 0 .. 63 */
  782. 0x00 /* Successive approximation: 0 */
  783. };
  784. static void pac_start_frame(struct gspca_dev *gspca_dev,
  785. struct gspca_frame *frame,
  786. __u16 lines, __u16 samples_per_line)
  787. {
  788. unsigned char tmpbuf[4];
  789. gspca_frame_add(gspca_dev, FIRST_PACKET,
  790. pac_jpeg_header1, sizeof(pac_jpeg_header1));
  791. tmpbuf[0] = lines >> 8;
  792. tmpbuf[1] = lines & 0xff;
  793. tmpbuf[2] = samples_per_line >> 8;
  794. tmpbuf[3] = samples_per_line & 0xff;
  795. gspca_frame_add(gspca_dev, INTER_PACKET,
  796. tmpbuf, sizeof(tmpbuf));
  797. gspca_frame_add(gspca_dev, INTER_PACKET,
  798. pac_jpeg_header2, sizeof(pac_jpeg_header2));
  799. }
  800. /* this function is run at interrupt level */
  801. static void sd_pkt_scan(struct gspca_dev *gspca_dev,
  802. u8 *data, /* isoc packet */
  803. int len) /* iso packet length */
  804. {
  805. struct sd *sd = (struct sd *) gspca_dev;
  806. struct gspca_frame *frame;
  807. unsigned char *sof;
  808. sof = pac_find_sof(&sd->sof_read, data, len);
  809. if (sof) {
  810. int n, lum_offset, footer_length;
  811. frame = gspca_get_i_frame(gspca_dev);
  812. if (frame == NULL) {
  813. gspca_dev->last_packet_type = DISCARD_PACKET;
  814. return;
  815. }
  816. /* 6 bytes after the FF D9 EOF marker a number of lumination
  817. bytes are send corresponding to different parts of the
  818. image, the 14th and 15th byte after the EOF seem to
  819. correspond to the center of the image */
  820. lum_offset = 61 + sizeof pac_sof_marker;
  821. footer_length = 74;
  822. /* Finish decoding current frame */
  823. n = (sof - data) - (footer_length + sizeof pac_sof_marker);
  824. if (n < 0) {
  825. frame->data_end += n;
  826. n = 0;
  827. }
  828. gspca_frame_add(gspca_dev, INTER_PACKET,
  829. data, n);
  830. if (gspca_dev->last_packet_type != DISCARD_PACKET &&
  831. frame->data_end[-2] == 0xff &&
  832. frame->data_end[-1] == 0xd9)
  833. gspca_frame_add(gspca_dev, LAST_PACKET,
  834. NULL, 0);
  835. n = sof - data;
  836. len -= n;
  837. data = sof;
  838. /* Get average lumination */
  839. if (gspca_dev->last_packet_type == LAST_PACKET &&
  840. n >= lum_offset)
  841. atomic_set(&sd->avg_lum, data[-lum_offset] +
  842. data[-lum_offset + 1]);
  843. else
  844. atomic_set(&sd->avg_lum, -1);
  845. /* Start the new frame with the jpeg header */
  846. /* The PAC7302 has the image rotated 90 degrees */
  847. pac_start_frame(gspca_dev, frame,
  848. gspca_dev->width, gspca_dev->height);
  849. }
  850. gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
  851. }
  852. static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
  853. {
  854. struct sd *sd = (struct sd *) gspca_dev;
  855. sd->brightness = val;
  856. if (gspca_dev->streaming)
  857. setbrightcont(gspca_dev);
  858. return 0;
  859. }
  860. static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
  861. {
  862. struct sd *sd = (struct sd *) gspca_dev;
  863. *val = sd->brightness;
  864. return 0;
  865. }
  866. static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
  867. {
  868. struct sd *sd = (struct sd *) gspca_dev;
  869. sd->contrast = val;
  870. if (gspca_dev->streaming) {
  871. setbrightcont(gspca_dev);
  872. }
  873. return 0;
  874. }
  875. static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
  876. {
  877. struct sd *sd = (struct sd *) gspca_dev;
  878. *val = sd->contrast;
  879. return 0;
  880. }
  881. static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
  882. {
  883. struct sd *sd = (struct sd *) gspca_dev;
  884. sd->colors = val;
  885. if (gspca_dev->streaming)
  886. setcolors(gspca_dev);
  887. return 0;
  888. }
  889. static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
  890. {
  891. struct sd *sd = (struct sd *) gspca_dev;
  892. *val = sd->colors;
  893. return 0;
  894. }
  895. static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val)
  896. {
  897. struct sd *sd = (struct sd *) gspca_dev;
  898. int ret = 0;
  899. sd->white_balance = val;
  900. if (gspca_dev->streaming)
  901. ret = setwhitebalance(gspca_dev);
  902. if (0 <= ret)
  903. ret = 0;
  904. return ret;
  905. }
  906. static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
  907. {
  908. struct sd *sd = (struct sd *) gspca_dev;
  909. *val = sd->white_balance;
  910. return 0;
  911. }
  912. static int sd_setredbalance(struct gspca_dev *gspca_dev, __s32 val)
  913. {
  914. struct sd *sd = (struct sd *) gspca_dev;
  915. int ret = 0;
  916. sd->red_balance = val;
  917. if (gspca_dev->streaming)
  918. ret = setredbalance(gspca_dev);
  919. if (0 <= ret)
  920. ret = 0;
  921. return ret;
  922. }
  923. static int sd_getredbalance(struct gspca_dev *gspca_dev, __s32 *val)
  924. {
  925. struct sd *sd = (struct sd *) gspca_dev;
  926. *val = sd->red_balance;
  927. return 0;
  928. }
  929. static int sd_setbluebalance(struct gspca_dev *gspca_dev, __s32 val)
  930. {
  931. struct sd *sd = (struct sd *) gspca_dev;
  932. int ret = 0;
  933. sd->blue_balance = val;
  934. if (gspca_dev->streaming)
  935. ret = setbluebalance(gspca_dev);
  936. if (0 <= ret)
  937. ret = 0;
  938. return ret;
  939. }
  940. static int sd_getbluebalance(struct gspca_dev *gspca_dev, __s32 *val)
  941. {
  942. struct sd *sd = (struct sd *) gspca_dev;
  943. *val = sd->blue_balance;
  944. return 0;
  945. }
  946. static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
  947. {
  948. struct sd *sd = (struct sd *) gspca_dev;
  949. sd->gain = val;
  950. if (gspca_dev->streaming)
  951. setgain(gspca_dev);
  952. return 0;
  953. }
  954. static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
  955. {
  956. struct sd *sd = (struct sd *) gspca_dev;
  957. *val = sd->gain;
  958. return 0;
  959. }
  960. static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
  961. {
  962. struct sd *sd = (struct sd *) gspca_dev;
  963. sd->exposure = val;
  964. if (gspca_dev->streaming)
  965. setexposure(gspca_dev);
  966. return 0;
  967. }
  968. static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
  969. {
  970. struct sd *sd = (struct sd *) gspca_dev;
  971. *val = sd->exposure;
  972. return 0;
  973. }
  974. static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
  975. {
  976. struct sd *sd = (struct sd *) gspca_dev;
  977. sd->autogain = val;
  978. /* when switching to autogain set defaults to make sure
  979. we are on a valid point of the autogain gain /
  980. exposure knee graph, and give this change time to
  981. take effect before doing autogain. */
  982. if (sd->autogain) {
  983. sd->exposure = EXPOSURE_DEF;
  984. sd->gain = GAIN_DEF;
  985. if (gspca_dev->streaming) {
  986. sd->autogain_ignore_frames =
  987. PAC_AUTOGAIN_IGNORE_FRAMES;
  988. setexposure(gspca_dev);
  989. setgain(gspca_dev);
  990. }
  991. }
  992. return 0;
  993. }
  994. static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
  995. {
  996. struct sd *sd = (struct sd *) gspca_dev;
  997. *val = sd->autogain;
  998. return 0;
  999. }
  1000. static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
  1001. {
  1002. struct sd *sd = (struct sd *) gspca_dev;
  1003. sd->hflip = val;
  1004. if (gspca_dev->streaming)
  1005. sethvflip(gspca_dev);
  1006. return 0;
  1007. }
  1008. static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
  1009. {
  1010. struct sd *sd = (struct sd *) gspca_dev;
  1011. *val = sd->hflip;
  1012. return 0;
  1013. }
  1014. static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
  1015. {
  1016. struct sd *sd = (struct sd *) gspca_dev;
  1017. sd->vflip = val;
  1018. if (gspca_dev->streaming)
  1019. sethvflip(gspca_dev);
  1020. return 0;
  1021. }
  1022. static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
  1023. {
  1024. struct sd *sd = (struct sd *) gspca_dev;
  1025. *val = sd->vflip;
  1026. return 0;
  1027. }
  1028. #ifdef CONFIG_VIDEO_ADV_DEBUG
  1029. static int sd_dbg_s_register(struct gspca_dev *gspca_dev,
  1030. struct v4l2_dbg_register *reg)
  1031. {
  1032. int ret = -EINVAL;
  1033. __u8 index;
  1034. __u8 value;
  1035. /* reg->reg: bit0..15: reserved for register index (wIndex is 16bit
  1036. long on the USB bus)
  1037. */
  1038. if (reg->match.type == V4L2_CHIP_MATCH_HOST &&
  1039. reg->match.addr == 0 &&
  1040. (reg->reg < 0x000000ff) &&
  1041. (reg->val <= 0x000000ff)
  1042. ) {
  1043. /* Currently writing to page 0 is only supported. */
  1044. /* reg_w() only supports 8bit index */
  1045. index = reg->reg & 0x000000ff;
  1046. value = reg->val & 0x000000ff;
  1047. /* Note that there shall be no access to other page
  1048. by any other function between the page swith and
  1049. the actual register write */
  1050. ret = reg_w(gspca_dev, 0xff, 0x00); /* page 0 */
  1051. if (0 <= ret)
  1052. ret = reg_w(gspca_dev, index, value);
  1053. if (0 <= ret)
  1054. ret = reg_w(gspca_dev, 0xdc, 0x01);
  1055. }
  1056. return ret;
  1057. }
  1058. static int sd_chip_ident(struct gspca_dev *gspca_dev,
  1059. struct v4l2_dbg_chip_ident *chip)
  1060. {
  1061. int ret = -EINVAL;
  1062. if (chip->match.type == V4L2_CHIP_MATCH_HOST &&
  1063. chip->match.addr == 0) {
  1064. chip->revision = 0;
  1065. chip->ident = V4L2_IDENT_UNKNOWN;
  1066. ret = 0;
  1067. }
  1068. return ret;
  1069. }
  1070. #endif
  1071. /* sub-driver description for pac7302 */
  1072. static struct sd_desc sd_desc = {
  1073. .name = MODULE_NAME,
  1074. .ctrls = sd_ctrls,
  1075. .nctrls = ARRAY_SIZE(sd_ctrls),
  1076. .config = sd_config,
  1077. .init = sd_init,
  1078. .start = sd_start,
  1079. .stopN = sd_stopN,
  1080. .stop0 = sd_stop0,
  1081. .pkt_scan = sd_pkt_scan,
  1082. .dq_callback = do_autogain,
  1083. #ifdef CONFIG_VIDEO_ADV_DEBUG
  1084. .set_register = sd_dbg_s_register,
  1085. .get_chip_ident = sd_chip_ident,
  1086. #endif
  1087. };
  1088. /* -- module initialisation -- */
  1089. static const struct usb_device_id device_table[] __devinitconst = {
  1090. {USB_DEVICE(0x06f8, 0x3009)},
  1091. {USB_DEVICE(0x093a, 0x2620)},
  1092. {USB_DEVICE(0x093a, 0x2621)},
  1093. {USB_DEVICE(0x093a, 0x2622), .driver_info = FL_VFLIP},
  1094. {USB_DEVICE(0x093a, 0x2624), .driver_info = FL_VFLIP},
  1095. {USB_DEVICE(0x093a, 0x2626)},
  1096. {USB_DEVICE(0x093a, 0x2628)},
  1097. {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
  1098. {USB_DEVICE(0x093a, 0x262a)},
  1099. {USB_DEVICE(0x093a, 0x262c)},
  1100. {}
  1101. };
  1102. MODULE_DEVICE_TABLE(usb, device_table);
  1103. /* -- device connect -- */
  1104. static int __devinit sd_probe(struct usb_interface *intf,
  1105. const struct usb_device_id *id)
  1106. {
  1107. return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
  1108. THIS_MODULE);
  1109. }
  1110. static struct usb_driver sd_driver = {
  1111. .name = MODULE_NAME,
  1112. .id_table = device_table,
  1113. .probe = sd_probe,
  1114. .disconnect = gspca_disconnect,
  1115. #ifdef CONFIG_PM
  1116. .suspend = gspca_suspend,
  1117. .resume = gspca_resume,
  1118. #endif
  1119. };
  1120. /* -- module insert / remove -- */
  1121. static int __init sd_mod_init(void)
  1122. {
  1123. int ret;
  1124. ret = usb_register(&sd_driver);
  1125. if (ret < 0)
  1126. return ret;
  1127. PDEBUG(D_PROBE, "registered");
  1128. return 0;
  1129. }
  1130. static void __exit sd_mod_exit(void)
  1131. {
  1132. usb_deregister(&sd_driver);
  1133. PDEBUG(D_PROBE, "deregistered");
  1134. }
  1135. module_init(sd_mod_init);
  1136. module_exit(sd_mod_exit);