sonixj.c 93 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093
  1. /*
  2. * Sonix sn9c102p sn9c105 sn9c120 (jpeg) subdriver
  3. *
  4. * Copyright (C) 2009-2010 Jean-François Moine <http://moinejf.free.fr>
  5. * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation; either version 2 of the License, or
  10. * any later version.
  11. *
  12. * This program is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with this program; if not, write to the Free Software
  19. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20. */
  21. #define MODULE_NAME "sonixj"
  22. #include <linux/input.h>
  23. #include "gspca.h"
  24. #include "jpeg.h"
  25. #define V4L2_CID_INFRARED (V4L2_CID_PRIVATE_BASE + 0)
  26. MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
  27. MODULE_DESCRIPTION("GSPCA/SONIX JPEG USB Camera Driver");
  28. MODULE_LICENSE("GPL");
  29. /* specific webcam descriptor */
  30. struct sd {
  31. struct gspca_dev gspca_dev; /* !! must be the first item */
  32. atomic_t avg_lum;
  33. u32 exposure;
  34. u16 brightness;
  35. u8 contrast;
  36. u8 colors;
  37. u8 autogain;
  38. u8 blue;
  39. u8 red;
  40. u8 gamma;
  41. u8 vflip; /* ov7630/ov7648 only */
  42. u8 sharpness;
  43. u8 infrared; /* mt9v111 only */
  44. u8 freq; /* ov76xx only */
  45. u8 quality; /* image quality */
  46. #define QUALITY_MIN 60
  47. #define QUALITY_MAX 95
  48. #define QUALITY_DEF 80
  49. u8 jpegqual; /* webcam quality */
  50. u8 reg18;
  51. s8 ag_cnt;
  52. #define AG_CNT_START 13
  53. u8 bridge;
  54. #define BRIDGE_SN9C102P 0
  55. #define BRIDGE_SN9C105 1
  56. #define BRIDGE_SN9C110 2
  57. #define BRIDGE_SN9C120 3
  58. u8 sensor; /* Type of image sensor chip */
  59. u8 i2c_addr;
  60. u8 jpeg_hdr[JPEG_HDR_SZ];
  61. };
  62. enum sensors {
  63. SENSOR_ADCM1700,
  64. SENSOR_GC0307,
  65. SENSOR_HV7131R,
  66. SENSOR_MI0360,
  67. SENSOR_MO4000,
  68. SENSOR_MT9V111,
  69. SENSOR_OM6802,
  70. SENSOR_OV7630,
  71. SENSOR_OV7648,
  72. SENSOR_OV7660,
  73. SENSOR_PO1030,
  74. SENSOR_PO2030N,
  75. SENSOR_SOI768,
  76. SENSOR_SP80708,
  77. };
  78. /* V4L2 controls supported by the driver */
  79. static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
  80. static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
  81. static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
  82. static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
  83. static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
  84. static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
  85. static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val);
  86. static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val);
  87. static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val);
  88. static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val);
  89. static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
  90. static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
  91. static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
  92. static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val);
  93. static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
  94. static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
  95. static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
  96. static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
  97. static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val);
  98. static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val);
  99. static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
  100. static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
  101. static const struct ctrl sd_ctrls[] = {
  102. #define BRIGHTNESS_IDX 0
  103. {
  104. {
  105. .id = V4L2_CID_BRIGHTNESS,
  106. .type = V4L2_CTRL_TYPE_INTEGER,
  107. .name = "Brightness",
  108. .minimum = 0,
  109. #define BRIGHTNESS_MAX 0xffff
  110. .maximum = BRIGHTNESS_MAX,
  111. .step = 1,
  112. #define BRIGHTNESS_DEF 0x8000
  113. .default_value = BRIGHTNESS_DEF,
  114. },
  115. .set = sd_setbrightness,
  116. .get = sd_getbrightness,
  117. },
  118. #define CONTRAST_IDX 1
  119. {
  120. {
  121. .id = V4L2_CID_CONTRAST,
  122. .type = V4L2_CTRL_TYPE_INTEGER,
  123. .name = "Contrast",
  124. .minimum = 0,
  125. #define CONTRAST_MAX 127
  126. .maximum = CONTRAST_MAX,
  127. .step = 1,
  128. #define CONTRAST_DEF 63
  129. .default_value = CONTRAST_DEF,
  130. },
  131. .set = sd_setcontrast,
  132. .get = sd_getcontrast,
  133. },
  134. #define COLOR_IDX 2
  135. {
  136. {
  137. .id = V4L2_CID_SATURATION,
  138. .type = V4L2_CTRL_TYPE_INTEGER,
  139. .name = "Saturation",
  140. .minimum = 0,
  141. .maximum = 40,
  142. .step = 1,
  143. #define COLOR_DEF 25
  144. .default_value = COLOR_DEF,
  145. },
  146. .set = sd_setcolors,
  147. .get = sd_getcolors,
  148. },
  149. #define BLUE_BALANCE_IDX 3
  150. {
  151. {
  152. .id = V4L2_CID_BLUE_BALANCE,
  153. .type = V4L2_CTRL_TYPE_INTEGER,
  154. .name = "Blue Balance",
  155. .minimum = 24,
  156. .maximum = 40,
  157. .step = 1,
  158. #define BLUE_BALANCE_DEF 32
  159. .default_value = BLUE_BALANCE_DEF,
  160. },
  161. .set = sd_setblue_balance,
  162. .get = sd_getblue_balance,
  163. },
  164. #define RED_BALANCE_IDX 4
  165. {
  166. {
  167. .id = V4L2_CID_RED_BALANCE,
  168. .type = V4L2_CTRL_TYPE_INTEGER,
  169. .name = "Red Balance",
  170. .minimum = 24,
  171. .maximum = 40,
  172. .step = 1,
  173. #define RED_BALANCE_DEF 32
  174. .default_value = RED_BALANCE_DEF,
  175. },
  176. .set = sd_setred_balance,
  177. .get = sd_getred_balance,
  178. },
  179. #define GAMMA_IDX 5
  180. {
  181. {
  182. .id = V4L2_CID_GAMMA,
  183. .type = V4L2_CTRL_TYPE_INTEGER,
  184. .name = "Gamma",
  185. .minimum = 0,
  186. .maximum = 40,
  187. .step = 1,
  188. #define GAMMA_DEF 20
  189. .default_value = GAMMA_DEF,
  190. },
  191. .set = sd_setgamma,
  192. .get = sd_getgamma,
  193. },
  194. #define AUTOGAIN_IDX 6
  195. {
  196. {
  197. .id = V4L2_CID_AUTOGAIN,
  198. .type = V4L2_CTRL_TYPE_BOOLEAN,
  199. .name = "Auto Gain",
  200. .minimum = 0,
  201. .maximum = 1,
  202. .step = 1,
  203. #define AUTOGAIN_DEF 1
  204. .default_value = AUTOGAIN_DEF,
  205. },
  206. .set = sd_setautogain,
  207. .get = sd_getautogain,
  208. },
  209. /* ov7630/ov7648 only */
  210. #define VFLIP_IDX 7
  211. {
  212. {
  213. .id = V4L2_CID_VFLIP,
  214. .type = V4L2_CTRL_TYPE_BOOLEAN,
  215. .name = "Vflip",
  216. .minimum = 0,
  217. .maximum = 1,
  218. .step = 1,
  219. #define VFLIP_DEF 0
  220. .default_value = VFLIP_DEF,
  221. },
  222. .set = sd_setvflip,
  223. .get = sd_getvflip,
  224. },
  225. #define SHARPNESS_IDX 8
  226. {
  227. {
  228. .id = V4L2_CID_SHARPNESS,
  229. .type = V4L2_CTRL_TYPE_INTEGER,
  230. .name = "Sharpness",
  231. .minimum = 0,
  232. .maximum = 255,
  233. .step = 1,
  234. #define SHARPNESS_DEF 90
  235. .default_value = SHARPNESS_DEF,
  236. },
  237. .set = sd_setsharpness,
  238. .get = sd_getsharpness,
  239. },
  240. /* mt9v111 only */
  241. #define INFRARED_IDX 9
  242. {
  243. {
  244. .id = V4L2_CID_INFRARED,
  245. .type = V4L2_CTRL_TYPE_BOOLEAN,
  246. .name = "Infrared",
  247. .minimum = 0,
  248. .maximum = 1,
  249. .step = 1,
  250. #define INFRARED_DEF 0
  251. .default_value = INFRARED_DEF,
  252. },
  253. .set = sd_setinfrared,
  254. .get = sd_getinfrared,
  255. },
  256. /* ov7630/ov7648/ov7660 only */
  257. #define FREQ_IDX 10
  258. {
  259. {
  260. .id = V4L2_CID_POWER_LINE_FREQUENCY,
  261. .type = V4L2_CTRL_TYPE_MENU,
  262. .name = "Light frequency filter",
  263. .minimum = 0,
  264. .maximum = 2, /* 0: 0, 1: 50Hz, 2:60Hz */
  265. .step = 1,
  266. #define FREQ_DEF 1
  267. .default_value = FREQ_DEF,
  268. },
  269. .set = sd_setfreq,
  270. .get = sd_getfreq,
  271. },
  272. };
  273. /* table of the disabled controls */
  274. static const __u32 ctrl_dis[] = {
  275. [SENSOR_ADCM1700] = (1 << AUTOGAIN_IDX) |
  276. (1 << INFRARED_IDX) |
  277. (1 << VFLIP_IDX) |
  278. (1 << FREQ_IDX),
  279. [SENSOR_GC0307] = (1 << INFRARED_IDX) |
  280. (1 << VFLIP_IDX) |
  281. (1 << FREQ_IDX),
  282. [SENSOR_HV7131R] = (1 << INFRARED_IDX) |
  283. (1 << FREQ_IDX),
  284. [SENSOR_MI0360] = (1 << INFRARED_IDX) |
  285. (1 << VFLIP_IDX) |
  286. (1 << FREQ_IDX),
  287. [SENSOR_MO4000] = (1 << INFRARED_IDX) |
  288. (1 << VFLIP_IDX) |
  289. (1 << FREQ_IDX),
  290. [SENSOR_MT9V111] = (1 << VFLIP_IDX) |
  291. (1 << FREQ_IDX),
  292. [SENSOR_OM6802] = (1 << INFRARED_IDX) |
  293. (1 << VFLIP_IDX) |
  294. (1 << FREQ_IDX),
  295. [SENSOR_OV7630] = (1 << INFRARED_IDX),
  296. [SENSOR_OV7648] = (1 << INFRARED_IDX),
  297. [SENSOR_OV7660] = (1 << AUTOGAIN_IDX) |
  298. (1 << INFRARED_IDX) |
  299. (1 << VFLIP_IDX),
  300. [SENSOR_PO1030] = (1 << AUTOGAIN_IDX) |
  301. (1 << INFRARED_IDX) |
  302. (1 << VFLIP_IDX) |
  303. (1 << FREQ_IDX),
  304. [SENSOR_PO2030N] = (1 << AUTOGAIN_IDX) |
  305. (1 << INFRARED_IDX) |
  306. (1 << VFLIP_IDX) |
  307. (1 << FREQ_IDX),
  308. [SENSOR_SOI768] = (1 << AUTOGAIN_IDX) |
  309. (1 << INFRARED_IDX) |
  310. (1 << VFLIP_IDX) |
  311. (1 << FREQ_IDX),
  312. [SENSOR_SP80708] = (1 << AUTOGAIN_IDX) |
  313. (1 << INFRARED_IDX) |
  314. (1 << VFLIP_IDX) |
  315. (1 << FREQ_IDX),
  316. };
  317. static const struct v4l2_pix_format cif_mode[] = {
  318. {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  319. .bytesperline = 352,
  320. .sizeimage = 352 * 288 * 4 / 8 + 590,
  321. .colorspace = V4L2_COLORSPACE_JPEG,
  322. .priv = 0},
  323. };
  324. static const struct v4l2_pix_format vga_mode[] = {
  325. {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  326. .bytesperline = 160,
  327. .sizeimage = 160 * 120 * 4 / 8 + 590,
  328. .colorspace = V4L2_COLORSPACE_JPEG,
  329. .priv = 2},
  330. {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  331. .bytesperline = 320,
  332. .sizeimage = 320 * 240 * 3 / 8 + 590,
  333. .colorspace = V4L2_COLORSPACE_JPEG,
  334. .priv = 1},
  335. {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
  336. .bytesperline = 640,
  337. /* Note 3 / 8 is not large enough, not even 5 / 8 is ?! */
  338. .sizeimage = 640 * 480 * 3 / 4 + 590,
  339. .colorspace = V4L2_COLORSPACE_JPEG,
  340. .priv = 0},
  341. };
  342. static const u8 sn_adcm1700[0x1c] = {
  343. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  344. 0x00, 0x43, 0x60, 0x00, 0x1a, 0x00, 0x00, 0x00,
  345. /* reg8 reg9 rega regb regc regd rege regf */
  346. 0x80, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  347. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  348. 0x03, 0x00, 0x05, 0x01, 0x05, 0x16, 0x12, 0x42,
  349. /* reg18 reg19 reg1a reg1b */
  350. 0x06, 0x00, 0x00, 0x00
  351. };
  352. static const u8 sn_gc0307[0x1c] = {
  353. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  354. 0x00, 0x61, 0x62, 0x00, 0x1a, 0x00, 0x00, 0x00,
  355. /* reg8 reg9 rega regb regc regd rege regf */
  356. 0x80, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  357. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  358. 0x03, 0x00, 0x03, 0x01, 0x08, 0x28, 0x1e, 0x02,
  359. /* reg18 reg19 reg1a reg1b */
  360. 0x06, 0x00, 0x00, 0x00
  361. };
  362. static const u8 sn_hv7131[0x1c] = {
  363. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  364. 0x00, 0x03, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
  365. /* reg8 reg9 rega regb regc regd rege regf */
  366. 0x81, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  367. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  368. 0x03, 0x00, 0x00, 0x01, 0x03, 0x28, 0x1e, 0x41,
  369. /* reg18 reg19 reg1a reg1b */
  370. 0x0a, 0x00, 0x00, 0x00
  371. };
  372. static const u8 sn_mi0360[0x1c] = {
  373. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  374. 0x00, 0x61, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
  375. /* reg8 reg9 rega regb regc regd rege regf */
  376. 0x81, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  377. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  378. 0x03, 0x00, 0x00, 0x02, 0x0a, 0x28, 0x1e, 0x61,
  379. /* reg18 reg19 reg1a reg1b */
  380. 0x06, 0x00, 0x00, 0x00
  381. };
  382. static const u8 sn_mo4000[0x1c] = {
  383. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  384. 0x00, 0x23, 0x60, 0x00, 0x1a, 0x00, 0x20, 0x18,
  385. /* reg8 reg9 rega regb regc regd rege regf */
  386. 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  387. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  388. 0x03, 0x00, 0x0b, 0x0f, 0x14, 0x28, 0x1e, 0x40,
  389. /* reg18 reg19 reg1a reg1b */
  390. 0x08, 0x00, 0x00, 0x00
  391. };
  392. static const u8 sn_mt9v111[0x1c] = {
  393. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  394. 0x00, 0x61, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
  395. /* reg8 reg9 rega regb regc regd rege regf */
  396. 0x81, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  397. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  398. 0x03, 0x00, 0x00, 0x02, 0x1c, 0x28, 0x1e, 0x40,
  399. /* reg18 reg19 reg1a reg1b */
  400. 0x06, 0x00, 0x00, 0x00
  401. };
  402. static const u8 sn_om6802[0x1c] = {
  403. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  404. 0x00, 0x23, 0x72, 0x00, 0x1a, 0x20, 0x20, 0x19,
  405. /* reg8 reg9 rega regb regc regd rege regf */
  406. 0x80, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  407. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  408. 0x03, 0x00, 0x51, 0x01, 0x00, 0x28, 0x1e, 0x40,
  409. /* reg18 reg19 reg1a reg1b */
  410. 0x05, 0x00, 0x00, 0x00
  411. };
  412. static const u8 sn_ov7630[0x1c] = {
  413. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  414. 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
  415. /* reg8 reg9 rega regb regc regd rege regf */
  416. 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  417. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  418. 0x03, 0x00, 0x04, 0x01, 0x0a, 0x28, 0x1e, 0xc2,
  419. /* reg18 reg19 reg1a reg1b */
  420. 0x0b, 0x00, 0x00, 0x00
  421. };
  422. static const u8 sn_ov7648[0x1c] = {
  423. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  424. 0x00, 0x63, 0x40, 0x00, 0x1a, 0x20, 0x20, 0x20,
  425. /* reg8 reg9 rega regb regc regd rege regf */
  426. 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  427. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  428. 0x03, 0x00, 0x00, 0x01, 0x00, 0x28, 0x1e, 0x00,
  429. /* reg18 reg19 reg1a reg1b */
  430. 0x0b, 0x00, 0x00, 0x00
  431. };
  432. static const u8 sn_ov7660[0x1c] = {
  433. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  434. 0x00, 0x61, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
  435. /* reg8 reg9 rega regb regc regd rege regf */
  436. 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  437. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  438. 0x03, 0x00, 0x01, 0x01, 0x08, 0x28, 0x1e, 0x20,
  439. /* reg18 reg19 reg1a reg1b */
  440. 0x07, 0x00, 0x00, 0x00
  441. };
  442. static const u8 sn_po1030[0x1c] = {
  443. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  444. 0x00, 0x21, 0x62, 0x00, 0x1a, 0x20, 0x20, 0x20,
  445. /* reg8 reg9 rega regb regc regd rege regf */
  446. 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  447. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  448. 0x03, 0x00, 0x00, 0x06, 0x06, 0x28, 0x1e, 0x00,
  449. /* reg18 reg19 reg1a reg1b */
  450. 0x07, 0x00, 0x00, 0x00
  451. };
  452. static const u8 sn_po2030n[0x1c] = {
  453. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  454. 0x00, 0x63, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
  455. /* reg8 reg9 rega regb regc regd rege regf */
  456. 0x81, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  457. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  458. 0x03, 0x00, 0x00, 0x01, 0x14, 0x28, 0x1e, 0x00,
  459. /* reg18 reg19 reg1a reg1b */
  460. 0x07, 0x00, 0x00, 0x00
  461. };
  462. static const u8 sn_soi768[0x1c] = {
  463. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  464. 0x00, 0x21, 0x40, 0x00, 0x1a, 0x00, 0x00, 0x00,
  465. /* reg8 reg9 rega regb regc regd rege regf */
  466. 0x81, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  467. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  468. 0x03, 0x00, 0x00, 0x01, 0x08, 0x28, 0x1e, 0x00,
  469. /* reg18 reg19 reg1a reg1b */
  470. 0x07, 0x00, 0x00, 0x00
  471. };
  472. static const u8 sn_sp80708[0x1c] = {
  473. /* reg0 reg1 reg2 reg3 reg4 reg5 reg6 reg7 */
  474. 0x00, 0x63, 0x60, 0x00, 0x1a, 0x20, 0x20, 0x20,
  475. /* reg8 reg9 rega regb regc regd rege regf */
  476. 0x81, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  477. /* reg10 reg11 reg12 reg13 reg14 reg15 reg16 reg17 */
  478. 0x03, 0x00, 0x00, 0x03, 0x04, 0x28, 0x1e, 0x00,
  479. /* reg18 reg19 reg1a reg1b */
  480. 0x07, 0x00, 0x00, 0x00
  481. };
  482. /* sequence specific to the sensors - !! index = SENSOR_xxx */
  483. static const u8 *sn_tb[] = {
  484. [SENSOR_ADCM1700] = sn_adcm1700,
  485. [SENSOR_GC0307] = sn_gc0307,
  486. [SENSOR_HV7131R] = sn_hv7131,
  487. [SENSOR_MI0360] = sn_mi0360,
  488. [SENSOR_MO4000] = sn_mo4000,
  489. [SENSOR_MT9V111] = sn_mt9v111,
  490. [SENSOR_OM6802] = sn_om6802,
  491. [SENSOR_OV7630] = sn_ov7630,
  492. [SENSOR_OV7648] = sn_ov7648,
  493. [SENSOR_OV7660] = sn_ov7660,
  494. [SENSOR_PO1030] = sn_po1030,
  495. [SENSOR_PO2030N] = sn_po2030n,
  496. [SENSOR_SOI768] = sn_soi768,
  497. [SENSOR_SP80708] = sn_sp80708,
  498. };
  499. /* default gamma table */
  500. static const u8 gamma_def[17] = {
  501. 0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
  502. 0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
  503. };
  504. /* gamma for sensor ADCM1700 */
  505. static const u8 gamma_spec_0[17] = {
  506. 0x0f, 0x39, 0x5a, 0x74, 0x86, 0x95, 0xa6, 0xb4,
  507. 0xbd, 0xc4, 0xcc, 0xd4, 0xd5, 0xde, 0xe4, 0xed, 0xf5
  508. };
  509. /* gamma for sensors HV7131R and MT9V111 */
  510. static const u8 gamma_spec_1[17] = {
  511. 0x08, 0x3a, 0x52, 0x65, 0x75, 0x83, 0x91, 0x9d,
  512. 0xa9, 0xb4, 0xbe, 0xc8, 0xd2, 0xdb, 0xe4, 0xed, 0xf5
  513. };
  514. /* gamma for sensor GC0307 */
  515. static const u8 gamma_spec_2[17] = {
  516. 0x14, 0x37, 0x50, 0x6a, 0x7c, 0x8d, 0x9d, 0xab,
  517. 0xb5, 0xbf, 0xc2, 0xcb, 0xd1, 0xd6, 0xdb, 0xe1, 0xeb
  518. };
  519. /* gamma for sensor SP80708 */
  520. static const u8 gamma_spec_3[17] = {
  521. 0x0a, 0x2d, 0x4e, 0x68, 0x7d, 0x8f, 0x9f, 0xab,
  522. 0xb7, 0xc2, 0xcc, 0xd3, 0xd8, 0xde, 0xe2, 0xe5, 0xe6
  523. };
  524. /* color matrix and offsets */
  525. static const u8 reg84[] = {
  526. 0x14, 0x00, 0x27, 0x00, 0x07, 0x00, /* YR YG YB gains */
  527. 0xe8, 0x0f, 0xda, 0x0f, 0x40, 0x00, /* UR UG UB */
  528. 0x3e, 0x00, 0xcd, 0x0f, 0xf7, 0x0f, /* VR VG VB */
  529. 0x00, 0x00, 0x00 /* YUV offsets */
  530. };
  531. static const u8 adcm1700_sensor_init[][8] = {
  532. {0xa0, 0x51, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x10},
  533. {0xb0, 0x51, 0x04, 0x08, 0x00, 0x00, 0x00, 0x10}, /* reset */
  534. {0xdd, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  535. {0xb0, 0x51, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
  536. {0xdd, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  537. {0xb0, 0x51, 0x0c, 0xe0, 0x2e, 0x00, 0x00, 0x10},
  538. {0xb0, 0x51, 0x10, 0x02, 0x02, 0x00, 0x00, 0x10},
  539. {0xb0, 0x51, 0x14, 0x0e, 0x0e, 0x00, 0x00, 0x10},
  540. {0xb0, 0x51, 0x1c, 0x00, 0x80, 0x00, 0x00, 0x10},
  541. {0xb0, 0x51, 0x20, 0x01, 0x00, 0x00, 0x00, 0x10},
  542. {0xdd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  543. {0xb0, 0x51, 0x04, 0x04, 0x00, 0x00, 0x00, 0x10},
  544. {0xdd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  545. {0xb0, 0x51, 0x04, 0x01, 0x00, 0x00, 0x00, 0x10},
  546. {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
  547. {0xb0, 0x51, 0x14, 0x01, 0x00, 0x00, 0x00, 0x10},
  548. {0xb0, 0x51, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
  549. {}
  550. };
  551. static const u8 adcm1700_sensor_param1[][8] = {
  552. {0xb0, 0x51, 0x26, 0xf9, 0x01, 0x00, 0x00, 0x10}, /* exposure? */
  553. {0xd0, 0x51, 0x1e, 0x8e, 0x8e, 0x8e, 0x8e, 0x10},
  554. {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
  555. {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
  556. {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
  557. {0xb0, 0x51, 0x32, 0x00, 0x72, 0x00, 0x00, 0x10},
  558. {0xd0, 0x51, 0x1e, 0xbe, 0xd7, 0xe8, 0xbe, 0x10}, /* exposure? */
  559. {0xa0, 0x51, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x10},
  560. {0xb0, 0x51, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10},
  561. {0xa0, 0x51, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x10},
  562. {0xb0, 0x51, 0x32, 0x00, 0xa2, 0x00, 0x00, 0x10},
  563. {}
  564. };
  565. static const u8 gc0307_sensor_init[][8] = {
  566. {0xa0, 0x21, 0x43, 0x00, 0x00, 0x00, 0x00, 0x10},
  567. {0xa0, 0x21, 0x44, 0xa2, 0x00, 0x00, 0x00, 0x10},
  568. {0xa0, 0x21, 0x01, 0x6a, 0x00, 0x00, 0x00, 0x10},
  569. {0xa0, 0x21, 0x02, 0x70, 0x00, 0x00, 0x00, 0x10},
  570. {0xa0, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
  571. {0xa0, 0x21, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
  572. {0xa0, 0x21, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
  573. {0xa0, 0x21, 0x11, 0x05, 0x00, 0x00, 0x00, 0x10},
  574. {0xa0, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
  575. {0xa0, 0x21, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
  576. {0xa0, 0x21, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10},
  577. {0xa0, 0x21, 0x08, 0x02, 0x00, 0x00, 0x00, 0x10},
  578. {0xa0, 0x21, 0x09, 0x01, 0x00, 0x00, 0x00, 0x10},
  579. {0xa0, 0x21, 0x0a, 0xe8, 0x00, 0x00, 0x00, 0x10},
  580. {0xa0, 0x21, 0x0b, 0x02, 0x00, 0x00, 0x00, 0x10},
  581. {0xa0, 0x21, 0x0c, 0x80, 0x00, 0x00, 0x00, 0x10},
  582. {0xa0, 0x21, 0x0d, 0x22, 0x00, 0x00, 0x00, 0x10},
  583. {0xa0, 0x21, 0x0e, 0x02, 0x00, 0x00, 0x00, 0x10},
  584. {0xa0, 0x21, 0x0f, 0xb2, 0x00, 0x00, 0x00, 0x10},
  585. {0xa0, 0x21, 0x12, 0x70, 0x00, 0x00, 0x00, 0x10},
  586. {0xdd, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*delay 10ms*/
  587. {0xa0, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10},
  588. {0xa0, 0x21, 0x15, 0xb8, 0x00, 0x00, 0x00, 0x10},
  589. {0xa0, 0x21, 0x16, 0x13, 0x00, 0x00, 0x00, 0x10},
  590. {0xa0, 0x21, 0x17, 0x52, 0x00, 0x00, 0x00, 0x10},
  591. {0xa0, 0x21, 0x18, 0x50, 0x00, 0x00, 0x00, 0x10},
  592. {0xa0, 0x21, 0x1e, 0x0d, 0x00, 0x00, 0x00, 0x10},
  593. {0xa0, 0x21, 0x1f, 0x32, 0x00, 0x00, 0x00, 0x10},
  594. {0xa0, 0x21, 0x61, 0x90, 0x00, 0x00, 0x00, 0x10},
  595. {0xa0, 0x21, 0x63, 0x70, 0x00, 0x00, 0x00, 0x10},
  596. {0xa0, 0x21, 0x65, 0x98, 0x00, 0x00, 0x00, 0x10},
  597. {0xa0, 0x21, 0x67, 0x90, 0x00, 0x00, 0x00, 0x10},
  598. {0xa0, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
  599. {0xa0, 0x21, 0x04, 0x96, 0x00, 0x00, 0x00, 0x10},
  600. {0xa0, 0x21, 0x45, 0x27, 0x00, 0x00, 0x00, 0x10},
  601. {0xa0, 0x21, 0x47, 0x2c, 0x00, 0x00, 0x00, 0x10},
  602. {0xa0, 0x21, 0x43, 0x47, 0x00, 0x00, 0x00, 0x10},
  603. {0xa0, 0x21, 0x44, 0xd8, 0x00, 0x00, 0x00, 0x10},
  604. {}
  605. };
  606. static const u8 gc0307_sensor_param1[][8] = {
  607. {0xa0, 0x21, 0x68, 0x13, 0x00, 0x00, 0x00, 0x10},
  608. {0xd0, 0x21, 0x61, 0x80, 0x00, 0x80, 0x00, 0x10},
  609. {0xc0, 0x21, 0x65, 0x80, 0x00, 0x80, 0x00, 0x10},
  610. {0xc0, 0x21, 0x63, 0xa0, 0x00, 0xa6, 0x00, 0x10},
  611. /*param3*/
  612. {0xa0, 0x21, 0x01, 0x6e, 0x00, 0x00, 0x00, 0x10},
  613. {0xa0, 0x21, 0x02, 0x88, 0x00, 0x00, 0x00, 0x10},
  614. {}
  615. };
  616. static const u8 hv7131r_sensor_init[][8] = {
  617. {0xc1, 0x11, 0x01, 0x08, 0x01, 0x00, 0x00, 0x10},
  618. {0xb1, 0x11, 0x34, 0x17, 0x7f, 0x00, 0x00, 0x10},
  619. {0xd1, 0x11, 0x40, 0xff, 0x7f, 0x7f, 0x7f, 0x10},
  620. /* {0x91, 0x11, 0x44, 0x00, 0x00, 0x00, 0x00, 0x10}, */
  621. {0xd1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
  622. {0xd1, 0x11, 0x14, 0x01, 0xe2, 0x02, 0x82, 0x10},
  623. /* {0x91, 0x11, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10}, */
  624. {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
  625. {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
  626. {0xc1, 0x11, 0x25, 0x00, 0x61, 0xa8, 0x00, 0x10},
  627. {0xa1, 0x11, 0x30, 0x22, 0x00, 0x00, 0x00, 0x10},
  628. {0xc1, 0x11, 0x31, 0x20, 0x2e, 0x20, 0x00, 0x10},
  629. {0xc1, 0x11, 0x25, 0x00, 0xc3, 0x50, 0x00, 0x10},
  630. {0xa1, 0x11, 0x30, 0x07, 0x00, 0x00, 0x00, 0x10}, /* gain14 */
  631. {0xc1, 0x11, 0x31, 0x10, 0x10, 0x10, 0x00, 0x10}, /* r g b 101a10 */
  632. {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
  633. {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
  634. {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
  635. {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
  636. {0xa1, 0x11, 0x23, 0x09, 0x00, 0x00, 0x00, 0x10},
  637. {0xa1, 0x11, 0x01, 0x08, 0x00, 0x00, 0x00, 0x10},
  638. {0xa1, 0x11, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
  639. {0xa1, 0x11, 0x21, 0xd0, 0x00, 0x00, 0x00, 0x10},
  640. {0xa1, 0x11, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
  641. {0xa1, 0x11, 0x23, 0x10, 0x00, 0x00, 0x00, 0x10},
  642. {0xa1, 0x11, 0x01, 0x18, 0x00, 0x00, 0x00, 0x10},
  643. /* set sensor clock */
  644. {}
  645. };
  646. static const u8 mi0360_sensor_init[][8] = {
  647. {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
  648. {0xb1, 0x5d, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10},
  649. {0xb1, 0x5d, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
  650. {0xd1, 0x5d, 0x01, 0x00, 0x08, 0x00, 0x16, 0x10},
  651. {0xd1, 0x5d, 0x03, 0x01, 0xe2, 0x02, 0x82, 0x10},
  652. {0xd1, 0x5d, 0x05, 0x00, 0x09, 0x00, 0x53, 0x10},
  653. {0xb1, 0x5d, 0x0d, 0x00, 0x02, 0x00, 0x00, 0x10},
  654. {0xd1, 0x5d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
  655. {0xd1, 0x5d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10},
  656. {0xd1, 0x5d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
  657. {0xd1, 0x5d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
  658. {0xd1, 0x5d, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
  659. {0xd1, 0x5d, 0x14, 0x00, 0x00, 0x00, 0x00, 0x10},
  660. {0xd1, 0x5d, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10},
  661. {0xd1, 0x5d, 0x18, 0x00, 0x00, 0x00, 0x00, 0x10},
  662. {0xd1, 0x5d, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x10},
  663. {0xd1, 0x5d, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x10},
  664. {0xb1, 0x5d, 0x32, 0x00, 0x00, 0x00, 0x00, 0x10},
  665. {0xd1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
  666. {0xd1, 0x5d, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
  667. {0xd1, 0x5d, 0x24, 0x00, 0x00, 0x00, 0x00, 0x10},
  668. {0xd1, 0x5d, 0x26, 0x00, 0x00, 0x00, 0x24, 0x10},
  669. {0xd1, 0x5d, 0x2f, 0xf7, 0xB0, 0x00, 0x04, 0x10},
  670. {0xd1, 0x5d, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
  671. {0xd1, 0x5d, 0x33, 0x00, 0x00, 0x01, 0x00, 0x10},
  672. {0xb1, 0x5d, 0x3d, 0x06, 0x8f, 0x00, 0x00, 0x10},
  673. {0xd1, 0x5d, 0x40, 0x01, 0xe0, 0x00, 0xd1, 0x10},
  674. {0xb1, 0x5d, 0x44, 0x00, 0x82, 0x00, 0x00, 0x10},
  675. {0xd1, 0x5d, 0x58, 0x00, 0x78, 0x00, 0x43, 0x10},
  676. {0xd1, 0x5d, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x10},
  677. {0xd1, 0x5d, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x10},
  678. {0xd1, 0x5d, 0x5e, 0x00, 0x00, 0xa3, 0x1d, 0x10},
  679. {0xb1, 0x5d, 0x62, 0x04, 0x11, 0x00, 0x00, 0x10},
  680. {0xb1, 0x5d, 0x20, 0x91, 0x01, 0x00, 0x00, 0x10},
  681. {0xb1, 0x5d, 0x20, 0x11, 0x01, 0x00, 0x00, 0x10},
  682. {0xb1, 0x5d, 0x09, 0x00, 0x64, 0x00, 0x00, 0x10},
  683. {0xd1, 0x5d, 0x2b, 0x00, 0xa0, 0x00, 0xb0, 0x10},
  684. {0xd1, 0x5d, 0x2d, 0x00, 0xa0, 0x00, 0xa0, 0x10},
  685. {0xb1, 0x5d, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor clck ?2 */
  686. {0xb1, 0x5d, 0x06, 0x00, 0x30, 0x00, 0x00, 0x10},
  687. {0xb1, 0x5d, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10},
  688. {0xb1, 0x5d, 0x09, 0x02, 0x35, 0x00, 0x00, 0x10}, /* exposure 2 */
  689. {0xd1, 0x5d, 0x2b, 0x00, 0xb9, 0x00, 0xe3, 0x10},
  690. {0xd1, 0x5d, 0x2d, 0x00, 0x5f, 0x00, 0xb9, 0x10}, /* 42 */
  691. /* {0xb1, 0x5d, 0x35, 0x00, 0x67, 0x00, 0x00, 0x10}, * gain orig */
  692. /* {0xb1, 0x5d, 0x35, 0x00, 0x20, 0x00, 0x00, 0x10}, * gain */
  693. {0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10}, /* update */
  694. {0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10}, /* sensor on */
  695. {}
  696. };
  697. static const u8 mo4000_sensor_init[][8] = {
  698. {0xa1, 0x21, 0x01, 0x02, 0x00, 0x00, 0x00, 0x10},
  699. {0xa1, 0x21, 0x02, 0x00, 0x00, 0x00, 0x00, 0x10},
  700. {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
  701. {0xa1, 0x21, 0x04, 0x00, 0x00, 0x00, 0x00, 0x10},
  702. {0xa1, 0x21, 0x05, 0x00, 0x00, 0x00, 0x00, 0x10},
  703. {0xa1, 0x21, 0x05, 0x04, 0x00, 0x00, 0x00, 0x10},
  704. {0xa1, 0x21, 0x06, 0x80, 0x00, 0x00, 0x00, 0x10},
  705. {0xa1, 0x21, 0x06, 0x81, 0x00, 0x00, 0x00, 0x10},
  706. {0xa1, 0x21, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x10},
  707. {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
  708. {0xa1, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x10},
  709. {0xa1, 0x21, 0x11, 0x30, 0x00, 0x00, 0x00, 0x10},
  710. {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
  711. {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
  712. {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
  713. {0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10},
  714. {0xa1, 0x21, 0x0f, 0x20, 0x00, 0x00, 0x00, 0x10},
  715. {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10},
  716. {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  717. {0xa1, 0x21, 0x11, 0x38, 0x00, 0x00, 0x00, 0x10},
  718. {}
  719. };
  720. static const u8 mt9v111_sensor_init[][8] = {
  721. {0xb1, 0x5c, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x10}, /* reset? */
  722. {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
  723. {0xb1, 0x5c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x10},
  724. {0xb1, 0x5c, 0x01, 0x00, 0x01, 0x00, 0x00, 0x10}, /* IFP select */
  725. {0xb1, 0x5c, 0x08, 0x04, 0x80, 0x00, 0x00, 0x10}, /* output fmt ctrl */
  726. {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10}, /* op mode ctrl */
  727. {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
  728. {0xb1, 0x5c, 0x03, 0x01, 0xe1, 0x00, 0x00, 0x10},
  729. {0xb1, 0x5c, 0x04, 0x02, 0x81, 0x00, 0x00, 0x10},
  730. {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
  731. {0xb1, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10}, /* sensor select */
  732. {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10},
  733. {0xb1, 0x5c, 0x03, 0x01, 0xe6, 0x00, 0x00, 0x10},
  734. {0xb1, 0x5c, 0x04, 0x02, 0x86, 0x00, 0x00, 0x10},
  735. {0xb1, 0x5c, 0x05, 0x00, 0x04, 0x00, 0x00, 0x10},
  736. {0xb1, 0x5c, 0x06, 0x00, 0x00, 0x00, 0x00, 0x10},
  737. {0xb1, 0x5c, 0x08, 0x00, 0x08, 0x00, 0x00, 0x10}, /* row start */
  738. {0xb1, 0x5c, 0x0e, 0x00, 0x08, 0x00, 0x00, 0x10},
  739. {0xb1, 0x5c, 0x02, 0x00, 0x16, 0x00, 0x00, 0x10}, /* col start */
  740. {0xb1, 0x5c, 0x03, 0x01, 0xe7, 0x00, 0x00, 0x10}, /* window height */
  741. {0xb1, 0x5c, 0x04, 0x02, 0x87, 0x00, 0x00, 0x10}, /* window width */
  742. {0xb1, 0x5c, 0x07, 0x30, 0x02, 0x00, 0x00, 0x10}, /* output ctrl */
  743. {0xb1, 0x5c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x10}, /* shutter delay */
  744. {0xb1, 0x5c, 0x12, 0x00, 0xb0, 0x00, 0x00, 0x10}, /* zoom col start */
  745. {0xb1, 0x5c, 0x13, 0x00, 0x7c, 0x00, 0x00, 0x10}, /* zoom row start */
  746. {0xb1, 0x5c, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* digital zoom */
  747. {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10}, /* read mode */
  748. {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
  749. {}
  750. };
  751. static const u8 mt9v111_sensor_param1[][8] = {
  752. {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
  753. {0xb1, 0x5c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10},
  754. {0xb1, 0x5c, 0x09, 0x01, 0x2c, 0x00, 0x00, 0x10},
  755. {0xd1, 0x5c, 0x2b, 0x00, 0x33, 0x00, 0xa0, 0x10}, /* green1 gain */
  756. {0xd1, 0x5c, 0x2d, 0x00, 0xa0, 0x00, 0x33, 0x10}, /* red gain */
  757. /*******/
  758. {0xb1, 0x5c, 0x06, 0x00, 0x1e, 0x00, 0x00, 0x10}, /* vert blanking */
  759. {0xb1, 0x5c, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x10}, /* horiz blanking */
  760. {0xd1, 0x5c, 0x2c, 0x00, 0xad, 0x00, 0xad, 0x10}, /* blue gain */
  761. {0xb1, 0x5c, 0x35, 0x01, 0xc0, 0x00, 0x00, 0x10}, /* global gain */
  762. {}
  763. };
  764. static const u8 om6802_init0[2][8] = {
  765. /*fixme: variable*/
  766. {0xa0, 0x34, 0x29, 0x0e, 0x00, 0x00, 0x00, 0x10},
  767. {0xa0, 0x34, 0x23, 0xb0, 0x00, 0x00, 0x00, 0x10},
  768. };
  769. static const u8 om6802_sensor_init[][8] = {
  770. {0xa0, 0x34, 0xdf, 0x6d, 0x00, 0x00, 0x00, 0x10},
  771. /* factory mode */
  772. {0xa0, 0x34, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10},
  773. /* output raw RGB */
  774. {0xa0, 0x34, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
  775. /* {0xa0, 0x34, 0xfb, 0x11, 0x00, 0x00, 0x00, 0x10}, */
  776. {0xa0, 0x34, 0xf0, 0x04, 0x00, 0x00, 0x00, 0x10},
  777. /* auto-exposure speed (0) / white balance mode (auto RGB) */
  778. /* {0xa0, 0x34, 0xf1, 0x02, 0x00, 0x00, 0x00, 0x10},
  779. * set color mode */
  780. /* {0xa0, 0x34, 0xfe, 0x5b, 0x00, 0x00, 0x00, 0x10},
  781. * max AGC value in AE */
  782. /* {0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10},
  783. * preset AGC */
  784. /* {0xa0, 0x34, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x10},
  785. * preset brightness */
  786. /* {0xa0, 0x34, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x10},
  787. * preset contrast */
  788. /* {0xa0, 0x34, 0xe8, 0x31, 0x00, 0x00, 0x00, 0x10},
  789. * preset gamma */
  790. {0xa0, 0x34, 0xe9, 0x0f, 0x00, 0x00, 0x00, 0x10},
  791. /* luminance mode (0x4f -> AutoExpo on) */
  792. {0xa0, 0x34, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
  793. /* preset shutter */
  794. /* {0xa0, 0x34, 0xef, 0x00, 0x00, 0x00, 0x00, 0x10},
  795. * auto frame rate */
  796. /* {0xa0, 0x34, 0xfb, 0xee, 0x00, 0x00, 0x00, 0x10}, */
  797. {0xa0, 0x34, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
  798. {}
  799. };
  800. static const u8 om6802_sensor_param1[][8] = {
  801. {0xa0, 0x34, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10},
  802. {0xa0, 0x34, 0x72, 0x05, 0x00, 0x00, 0x00, 0x10},
  803. {0xa0, 0x34, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10},
  804. {0xa0, 0x34, 0x69, 0x01, 0x00, 0x00, 0x00, 0x10},
  805. {}
  806. };
  807. static const u8 ov7630_sensor_init[][8] = {
  808. {0xa1, 0x21, 0x76, 0x01, 0x00, 0x00, 0x00, 0x10},
  809. {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
  810. {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
  811. {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
  812. {0xa1, 0x21, 0x12, 0xc8, 0x00, 0x00, 0x00, 0x10},
  813. {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
  814. {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
  815. /* win: i2c_r from 00 to 80 */
  816. {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
  817. {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
  818. /* HDG: 0x11 was 0x00 change to 0x01 for better exposure (15 fps instead of 30)
  819. 0x13 was 0xc0 change to 0xc3 for auto gain and exposure */
  820. {0xd1, 0x21, 0x11, 0x01, 0x48, 0xc3, 0x00, 0x10},
  821. {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
  822. {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
  823. {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
  824. {0xd1, 0x21, 0x1f, 0x00, 0x80, 0x80, 0x80, 0x10},
  825. {0xd1, 0x21, 0x23, 0xde, 0x10, 0x8a, 0xa0, 0x10},
  826. {0xc1, 0x21, 0x27, 0xca, 0xa2, 0x74, 0x00, 0x10},
  827. {0xd1, 0x21, 0x2a, 0x88, 0x00, 0x88, 0x01, 0x10},
  828. {0xc1, 0x21, 0x2e, 0x80, 0x00, 0x18, 0x00, 0x10},
  829. {0xa1, 0x21, 0x21, 0x08, 0x00, 0x00, 0x00, 0x10},
  830. {0xa1, 0x21, 0x22, 0x00, 0x00, 0x00, 0x00, 0x10},
  831. {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
  832. {0xb1, 0x21, 0x32, 0xc2, 0x08, 0x00, 0x00, 0x10},
  833. {0xb1, 0x21, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x10},
  834. {0xd1, 0x21, 0x60, 0x05, 0x40, 0x12, 0x57, 0x10},
  835. {0xa1, 0x21, 0x64, 0x73, 0x00, 0x00, 0x00, 0x10},
  836. {0xd1, 0x21, 0x65, 0x00, 0x55, 0x01, 0xac, 0x10},
  837. {0xa1, 0x21, 0x69, 0x38, 0x00, 0x00, 0x00, 0x10},
  838. {0xd1, 0x21, 0x6f, 0x1f, 0x01, 0x00, 0x10, 0x10},
  839. {0xd1, 0x21, 0x73, 0x50, 0x20, 0x02, 0x01, 0x10},
  840. {0xd1, 0x21, 0x77, 0xf3, 0x90, 0x98, 0x98, 0x10},
  841. {0xc1, 0x21, 0x7b, 0x00, 0x4c, 0xf7, 0x00, 0x10},
  842. {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
  843. {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
  844. {}
  845. };
  846. static const u8 ov7630_sensor_param1[][8] = {
  847. {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
  848. {0xa1, 0x21, 0x12, 0x48, 0x00, 0x00, 0x00, 0x10},
  849. /*fixme: + 0x12, 0x04*/
  850. /* {0xa1, 0x21, 0x75, 0x82, 0x00, 0x00, 0x00, 0x10}, * COMN
  851. * set by setvflip */
  852. {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
  853. {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  854. {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
  855. /* */
  856. /* {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
  857. /* {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
  858. /* */
  859. {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
  860. /* {0xb1, 0x21, 0x01, 0x88, 0x70, 0x00, 0x00, 0x10}, */
  861. {}
  862. };
  863. static const u8 ov7648_sensor_init[][8] = {
  864. {0xa1, 0x21, 0x76, 0x00, 0x00, 0x00, 0x00, 0x10},
  865. {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
  866. {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
  867. {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
  868. {0xd1, 0x21, 0x03, 0xa4, 0x30, 0x88, 0x00, 0x10},
  869. {0xb1, 0x21, 0x11, 0x80, 0x08, 0x00, 0x00, 0x10},
  870. {0xc1, 0x21, 0x13, 0xa0, 0x04, 0x84, 0x00, 0x10},
  871. {0xd1, 0x21, 0x17, 0x1a, 0x02, 0xba, 0xf4, 0x10},
  872. {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
  873. {0xd1, 0x21, 0x1f, 0x41, 0xc0, 0x80, 0x80, 0x10},
  874. {0xd1, 0x21, 0x23, 0xde, 0xa0, 0x80, 0x32, 0x10},
  875. {0xd1, 0x21, 0x27, 0xfe, 0xa0, 0x00, 0x91, 0x10},
  876. {0xd1, 0x21, 0x2b, 0x00, 0x88, 0x85, 0x80, 0x10},
  877. {0xc1, 0x21, 0x2f, 0x9c, 0x00, 0xc4, 0x00, 0x10},
  878. {0xd1, 0x21, 0x60, 0xa6, 0x60, 0x88, 0x12, 0x10},
  879. {0xd1, 0x21, 0x64, 0x88, 0x00, 0x00, 0x94, 0x10},
  880. {0xd1, 0x21, 0x68, 0x7a, 0x0c, 0x00, 0x00, 0x10},
  881. {0xd1, 0x21, 0x6c, 0x11, 0x33, 0x22, 0x00, 0x10},
  882. {0xd1, 0x21, 0x70, 0x11, 0x00, 0x10, 0x50, 0x10},
  883. {0xd1, 0x21, 0x74, 0x20, 0x06, 0x00, 0xb5, 0x10},
  884. {0xd1, 0x21, 0x78, 0x8a, 0x00, 0x00, 0x00, 0x10},
  885. {0xb1, 0x21, 0x7c, 0x00, 0x43, 0x00, 0x00, 0x10},
  886. {0xd1, 0x21, 0x21, 0x86, 0x00, 0xde, 0xa0, 0x10},
  887. /* {0xd1, 0x21, 0x25, 0x80, 0x32, 0xfe, 0xa0, 0x10}, jfm done */
  888. /* {0xd1, 0x21, 0x29, 0x00, 0x91, 0x00, 0x88, 0x10}, jfm done */
  889. /* {0xb1, 0x21, 0x2d, 0x85, 0x00, 0x00, 0x00, 0x10}, set by setfreq */
  890. {}
  891. };
  892. static const u8 ov7648_sensor_param1[][8] = {
  893. /* {0xa1, 0x21, 0x12, 0x08, 0x00, 0x00, 0x00, 0x10}, jfm done */
  894. /* {0xa1, 0x21, 0x75, 0x06, 0x00, 0x00, 0x00, 0x10}, * COMN
  895. * set by setvflip */
  896. {0xa1, 0x21, 0x19, 0x02, 0x00, 0x00, 0x00, 0x10},
  897. {0xa1, 0x21, 0x10, 0x32, 0x00, 0x00, 0x00, 0x10},
  898. /* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
  899. /* {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}, * GAIN - def */
  900. /* {0xb1, 0x21, 0x01, 0x6c, 0x6c, 0x00, 0x00, 0x10}, * B R - def: 80 */
  901. /*...*/
  902. {0xa1, 0x21, 0x11, 0x81, 0x00, 0x00, 0x00, 0x10}, /* CLKRC */
  903. /* {0xa1, 0x21, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
  904. /* {0xa1, 0x21, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
  905. /* {0xa1, 0x21, 0x2a, 0x91, 0x00, 0x00, 0x00, 0x10}, jfm done */
  906. /* {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, jfm done */
  907. /* {0xb1, 0x21, 0x01, 0x64, 0x84, 0x00, 0x00, 0x10}, * B R - def: 80 */
  908. {}
  909. };
  910. static const u8 ov7660_sensor_init[][8] = {
  911. {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
  912. {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
  913. {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
  914. /* Outformat = rawRGB */
  915. {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
  916. {0xd1, 0x21, 0x00, 0x01, 0x74, 0x92, 0x00, 0x10},
  917. /* GAIN BLUE RED VREF */
  918. {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
  919. /* COM 1 BAVE GEAVE AECHH */
  920. {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10}, /* RAVE COM2 */
  921. {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10}, /* COM 3 4 5 6 */
  922. {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
  923. /* AECH CLKRC COM7 COM8 */
  924. {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10}, /* COM9 COM10 */
  925. {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
  926. /* HSTART HSTOP VSTRT VSTOP */
  927. {0xa1, 0x21, 0x1b, 0x02, 0x00, 0x00, 0x00, 0x10}, /* PSHFT */
  928. {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10}, /* MVFP LAEC */
  929. {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
  930. /* BOS GBOS GROS ROS (BGGR offset) */
  931. /* {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10}, */
  932. {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
  933. /* AEW AEB VPT BBIAS */
  934. {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
  935. /* GbBIAS RSVD EXHCH EXHCL */
  936. {0xd1, 0x21, 0x2c, 0x80, 0x00, 0x00, 0x62, 0x10},
  937. /* RBIAS ADVFL ASDVFH YAVE */
  938. {0xc1, 0x21, 0x30, 0x08, 0x30, 0xb4, 0x00, 0x10},
  939. /* HSYST HSYEN HREF */
  940. {0xd1, 0x21, 0x33, 0x00, 0x07, 0x84, 0x00, 0x10}, /* reserved */
  941. {0xd1, 0x21, 0x37, 0x0c, 0x02, 0x43, 0x00, 0x10},
  942. /* ADC ACOM OFON TSLB */
  943. {0xd1, 0x21, 0x3b, 0x02, 0x6c, 0x19, 0x0e, 0x10},
  944. /* COM11 COM12 COM13 COM14 */
  945. {0xd1, 0x21, 0x3f, 0x41, 0xc1, 0x22, 0x08, 0x10},
  946. /* EDGE COM15 COM16 COM17 */
  947. {0xd1, 0x21, 0x43, 0xf0, 0x10, 0x78, 0xa8, 0x10}, /* reserved */
  948. {0xd1, 0x21, 0x47, 0x60, 0x80, 0x00, 0x00, 0x10}, /* reserved */
  949. {0xd1, 0x21, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* reserved */
  950. {0xd1, 0x21, 0x4f, 0x46, 0x36, 0x0f, 0x17, 0x10}, /* MTX 1 2 3 4 */
  951. {0xd1, 0x21, 0x53, 0x7f, 0x96, 0x40, 0x40, 0x10}, /* MTX 5 6 7 8 */
  952. {0xb1, 0x21, 0x57, 0x40, 0x0f, 0x00, 0x00, 0x10}, /* MTX9 MTXS */
  953. {0xd1, 0x21, 0x59, 0xba, 0x9a, 0x22, 0xb9, 0x10}, /* reserved */
  954. {0xd1, 0x21, 0x5d, 0x9b, 0x10, 0xf0, 0x05, 0x10}, /* reserved */
  955. {0xa1, 0x21, 0x61, 0x60, 0x00, 0x00, 0x00, 0x10}, /* reserved */
  956. {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
  957. /* LCC1 LCC2 LCC3 LCC4 */
  958. {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10}, /* LCC5 */
  959. {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10}, /* MANU */
  960. {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
  961. /* band gap reference [0:3] DBLV */
  962. {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10}, /* gamma curve */
  963. {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10}, /* gamma curve */
  964. {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10}, /* gamma curve */
  965. {0xd1, 0x21, 0x78, 0x34, 0x30, 0x2f, 0x2b, 0x10}, /* gamma curve */
  966. {0xd1, 0x21, 0x7c, 0x03, 0x07, 0x17, 0x34, 0x10}, /* gamma curve */
  967. {0xd1, 0x21, 0x80, 0x41, 0x4d, 0x58, 0x63, 0x10}, /* gamma curve */
  968. {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10}, /* gamma curve */
  969. {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
  970. {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
  971. {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
  972. /* not in all ms-win traces*/
  973. {0xa1, 0x21, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x10},
  974. {}
  975. };
  976. static const u8 ov7660_sensor_param1[][8] = {
  977. {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
  978. /* bits[3..0]reserved */
  979. {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
  980. {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
  981. /* VREF vertical frame ctrl */
  982. {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
  983. {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* AECH 0x20 */
  984. {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFL */
  985. {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFH */
  986. {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, /* GAIN */
  987. /* {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10}, * BLUE */
  988. /****** (some exchanges in the win trace) ******/
  989. /*fixme:param2*/
  990. {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},/* dummy line hight */
  991. {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10}, /* dummy line low */
  992. {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCH */
  993. {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCL */
  994. /* {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10}, * RED */
  995. /****** (some exchanges in the win trace) ******/
  996. /******!! startsensor KO if changed !!****/
  997. /*fixme: param3*/
  998. {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
  999. {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
  1000. {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
  1001. {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
  1002. {}
  1003. };
  1004. static const u8 po1030_sensor_init[][8] = {
  1005. /* the sensor registers are described in m5602/m5602_po1030.h */
  1006. {0xa1, 0x6e, 0x3f, 0x20, 0x00, 0x00, 0x00, 0x10}, /* sensor reset */
  1007. {0xdd, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 20ms */
  1008. {0xa1, 0x6e, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x10},
  1009. {0xa1, 0x6e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x10},
  1010. {0xd1, 0x6e, 0x04, 0x02, 0xb1, 0x02, 0x39, 0x10},
  1011. {0xd1, 0x6e, 0x08, 0x00, 0x01, 0x00, 0x00, 0x10},
  1012. {0xd1, 0x6e, 0x0c, 0x02, 0x7f, 0x01, 0xe0, 0x10},
  1013. {0xd1, 0x6e, 0x12, 0x03, 0x02, 0x00, 0x03, 0x10},
  1014. {0xd1, 0x6e, 0x16, 0x85, 0x40, 0x4a, 0x40, 0x10}, /* r/g1/b/g2 gains */
  1015. {0xc1, 0x6e, 0x1a, 0x00, 0x80, 0x00, 0x00, 0x10},
  1016. {0xd1, 0x6e, 0x1d, 0x08, 0x03, 0x00, 0x00, 0x10},
  1017. {0xd1, 0x6e, 0x23, 0x00, 0xb0, 0x00, 0x94, 0x10},
  1018. {0xd1, 0x6e, 0x27, 0x58, 0x00, 0x00, 0x00, 0x10},
  1019. {0xb1, 0x6e, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
  1020. {0xd1, 0x6e, 0x2d, 0x14, 0x35, 0x61, 0x84, 0x10}, /* gamma corr */
  1021. {0xd1, 0x6e, 0x31, 0xa2, 0xbd, 0xd8, 0xff, 0x10},
  1022. {0xd1, 0x6e, 0x35, 0x06, 0x1e, 0x12, 0x02, 0x10}, /* color matrix */
  1023. {0xd1, 0x6e, 0x39, 0xaa, 0x53, 0x37, 0xd5, 0x10},
  1024. {0xa1, 0x6e, 0x3d, 0xf2, 0x00, 0x00, 0x00, 0x10},
  1025. {0xd1, 0x6e, 0x3e, 0x00, 0x00, 0x80, 0x03, 0x10},
  1026. {0xd1, 0x6e, 0x42, 0x03, 0x00, 0x00, 0x00, 0x10},
  1027. {0xc1, 0x6e, 0x46, 0x00, 0x80, 0x80, 0x00, 0x10},
  1028. {0xd1, 0x6e, 0x4b, 0x02, 0xef, 0x08, 0xcd, 0x10},
  1029. {0xd1, 0x6e, 0x4f, 0x00, 0xd0, 0x00, 0xa0, 0x10},
  1030. {0xd1, 0x6e, 0x53, 0x01, 0xaa, 0x01, 0x40, 0x10},
  1031. {0xd1, 0x6e, 0x5a, 0x50, 0x04, 0x30, 0x03, 0x10}, /* raw rgb bayer */
  1032. {0xa1, 0x6e, 0x5e, 0x00, 0x00, 0x00, 0x00, 0x10},
  1033. {0xd1, 0x6e, 0x5f, 0x10, 0x40, 0xff, 0x00, 0x10},
  1034. {0xd1, 0x6e, 0x63, 0x40, 0x40, 0x00, 0x00, 0x10},
  1035. {0xd1, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x10},
  1036. {0xd1, 0x6e, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x10},
  1037. {0xd1, 0x6e, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x10},
  1038. {0xc1, 0x6e, 0x73, 0x10, 0x80, 0xeb, 0x00, 0x10},
  1039. {}
  1040. };
  1041. static const u8 po1030_sensor_param1[][8] = {
  1042. /* from ms-win traces - these values change with auto gain/expo/wb.. */
  1043. {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
  1044. {0xa1, 0x6e, 0x1e, 0x03, 0x00, 0x00, 0x00, 0x10},
  1045. /* mean values */
  1046. {0xc1, 0x6e, 0x1a, 0x02, 0xd4, 0xa4, 0x00, 0x10}, /* integlines */
  1047. {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10}, /* global gain */
  1048. {0xc1, 0x6e, 0x16, 0x40, 0x40, 0x40, 0x00, 0x10}, /* r/g1/b gains */
  1049. {0xa1, 0x6e, 0x1d, 0x08, 0x00, 0x00, 0x00, 0x10}, /* control1 */
  1050. {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10}, /* frameheight */
  1051. {0xa1, 0x6e, 0x07, 0xd5, 0x00, 0x00, 0x00, 0x10},
  1052. /* {0xc1, 0x6e, 0x16, 0x49, 0x40, 0x45, 0x00, 0x10}, */
  1053. {}
  1054. };
  1055. static const u8 po2030n_sensor_init[][8] = {
  1056. {0xa1, 0x6e, 0x1e, 0x1a, 0x00, 0x00, 0x00, 0x10},
  1057. {0xa1, 0x6e, 0x1f, 0x99, 0x00, 0x00, 0x00, 0x10},
  1058. {0xdd, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
  1059. {0xa1, 0x6e, 0x1e, 0x0a, 0x00, 0x00, 0x00, 0x10},
  1060. {0xa1, 0x6e, 0x1f, 0x19, 0x00, 0x00, 0x00, 0x10},
  1061. {0xdd, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 10ms */
  1062. {0xa1, 0x6e, 0x20, 0x44, 0x00, 0x00, 0x00, 0x10},
  1063. {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
  1064. {0xa1, 0x6e, 0x05, 0x70, 0x00, 0x00, 0x00, 0x10},
  1065. {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
  1066. {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
  1067. {0xd1, 0x6e, 0x08, 0x00, 0xd0, 0x00, 0x08, 0x10},
  1068. {0xd1, 0x6e, 0x0c, 0x03, 0x50, 0x01, 0xe8, 0x10},
  1069. {0xd1, 0x6e, 0x1d, 0x20, 0x0a, 0x19, 0x44, 0x10},
  1070. {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
  1071. {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x00, 0x10},
  1072. {0xd1, 0x6e, 0x29, 0x00, 0x00, 0x00, 0x00, 0x10},
  1073. {0xd1, 0x6e, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1074. {0xd1, 0x6e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x10},
  1075. {0xd1, 0x6e, 0x35, 0x00, 0x00, 0x00, 0x00, 0x10},
  1076. {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x00, 0x00, 0x10},
  1077. {0xd1, 0x6e, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1078. {0xd1, 0x6e, 0x41, 0x00, 0x00, 0x00, 0x00, 0x10},
  1079. {0xd1, 0x6e, 0x45, 0x00, 0x00, 0x00, 0x00, 0x10},
  1080. {0xd1, 0x6e, 0x49, 0x00, 0x00, 0x00, 0x00, 0x10},
  1081. {0xd1, 0x6e, 0x4d, 0x00, 0x00, 0x00, 0xed, 0x10},
  1082. {0xd1, 0x6e, 0x51, 0x17, 0x4a, 0x2f, 0xc0, 0x10},
  1083. {0xd1, 0x6e, 0x55, 0x00, 0x00, 0x00, 0x00, 0x10},
  1084. {0xd1, 0x6e, 0x59, 0x00, 0x00, 0x00, 0x00, 0x10},
  1085. {0xd1, 0x6e, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1086. {0xd1, 0x6e, 0x61, 0x00, 0x00, 0x00, 0x00, 0x10},
  1087. {0xd1, 0x6e, 0x65, 0x00, 0x00, 0x00, 0x00, 0x10},
  1088. {0xd1, 0x6e, 0x69, 0x00, 0x00, 0x00, 0x00, 0x10},
  1089. {0xd1, 0x6e, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1090. {0xd1, 0x6e, 0x71, 0x00, 0x00, 0x00, 0x00, 0x10},
  1091. {0xd1, 0x6e, 0x75, 0x00, 0x00, 0x00, 0x00, 0x10},
  1092. {0xd1, 0x6e, 0x79, 0x00, 0x00, 0x00, 0x00, 0x10},
  1093. {0xd1, 0x6e, 0x7d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1094. {0xd1, 0x6e, 0x81, 0x00, 0x00, 0x00, 0x00, 0x10},
  1095. {0xd1, 0x6e, 0x85, 0x00, 0x00, 0x00, 0x08, 0x10},
  1096. {0xd1, 0x6e, 0x89, 0x01, 0xe8, 0x00, 0x01, 0x10},
  1097. {0xa1, 0x6e, 0x8d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1098. {0xd1, 0x6e, 0x21, 0x00, 0x00, 0x00, 0x00, 0x10},
  1099. {0xd1, 0x6e, 0x25, 0x00, 0x00, 0x00, 0x01, 0x10},
  1100. {0xd1, 0x6e, 0x29, 0xe6, 0x00, 0xbd, 0x03, 0x10},
  1101. {0xd1, 0x6e, 0x2d, 0x41, 0x38, 0x68, 0x40, 0x10},
  1102. {0xd1, 0x6e, 0x31, 0x2b, 0x00, 0x36, 0x00, 0x10},
  1103. {0xd1, 0x6e, 0x35, 0x30, 0x30, 0x08, 0x00, 0x10},
  1104. {0xd1, 0x6e, 0x39, 0x00, 0x00, 0x33, 0x06, 0x10},
  1105. {0xb1, 0x6e, 0x3d, 0x06, 0x02, 0x00, 0x00, 0x10},
  1106. {}
  1107. };
  1108. static const u8 po2030n_sensor_param1[][8] = {
  1109. {0xa1, 0x6e, 0x1a, 0x01, 0x00, 0x00, 0x00, 0x10},
  1110. {0xdd, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 8ms */
  1111. {0xa1, 0x6e, 0x1b, 0xf4, 0x00, 0x00, 0x00, 0x10},
  1112. {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
  1113. {0xd1, 0x6e, 0x16, 0x50, 0x40, 0x49, 0x40, 0x10},
  1114. /*param2*/
  1115. {0xa1, 0x6e, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1116. {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
  1117. {0xa1, 0x6e, 0x05, 0x6f, 0x00, 0x00, 0x00, 0x10},
  1118. {0xa1, 0x6e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x10},
  1119. {0xa1, 0x6e, 0x07, 0x25, 0x00, 0x00, 0x00, 0x10},
  1120. {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
  1121. {0xc1, 0x6e, 0x16, 0x52, 0x40, 0x48, 0x00, 0x10},
  1122. /*after start*/
  1123. {0xa1, 0x6e, 0x15, 0x0f, 0x00, 0x00, 0x00, 0x10},
  1124. {0xdd, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
  1125. {0xa1, 0x6e, 0x1a, 0x05, 0x00, 0x00, 0x00, 0x10},
  1126. {0xdd, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 5ms */
  1127. {0xa1, 0x6e, 0x1b, 0x53, 0x00, 0x00, 0x00, 0x10},
  1128. {}
  1129. };
  1130. static const u8 soi768_sensor_init[][8] = {
  1131. {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset */
  1132. {0xdd, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 96ms */
  1133. {0xa1, 0x21, 0x12, 0x00, 0x00, 0x00, 0x00, 0x10},
  1134. {0xa1, 0x21, 0x13, 0x80, 0x00, 0x00, 0x00, 0x10},
  1135. {0xa1, 0x21, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x10},
  1136. {0xa1, 0x21, 0x19, 0x00, 0x00, 0x00, 0x00, 0x10},
  1137. {}
  1138. };
  1139. static const u8 soi768_sensor_param1[][8] = {
  1140. {0xa1, 0x21, 0x10, 0x10, 0x00, 0x00, 0x00, 0x10},
  1141. {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
  1142. {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
  1143. {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  1144. {0xb1, 0x21, 0x01, 0x7f, 0x7f, 0x00, 0x00, 0x10},
  1145. /* */
  1146. /* {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, */
  1147. /* {0xa1, 0x21, 0x2d, 0x25, 0x00, 0x00, 0x00, 0x10}, */
  1148. {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
  1149. /* {0xb1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, */
  1150. {0xa1, 0x21, 0x02, 0x8d, 0x00, 0x00, 0x00, 0x10},
  1151. /* the next sequence should be used for auto gain */
  1152. {0xa1, 0x21, 0x00, 0x07, 0x00, 0x00, 0x00, 0x10},
  1153. /* global gain ? : 07 - change with 0x15 at the end */
  1154. {0xa1, 0x21, 0x10, 0x3f, 0x00, 0x00, 0x00, 0x10}, /* ???? : 063f */
  1155. {0xa1, 0x21, 0x04, 0x06, 0x00, 0x00, 0x00, 0x10},
  1156. {0xb1, 0x21, 0x2d, 0x00, 0x02, 0x00, 0x00, 0x10},
  1157. /* exposure ? : 0200 - change with 0x1e at the end */
  1158. {}
  1159. };
  1160. static const u8 sp80708_sensor_init[][8] = {
  1161. {0xa1, 0x18, 0x06, 0xf9, 0x00, 0x00, 0x00, 0x10},
  1162. {0xa1, 0x18, 0x09, 0x1f, 0x00, 0x00, 0x00, 0x10},
  1163. {0xa1, 0x18, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x10},
  1164. {0xa1, 0x18, 0x0d, 0xc0, 0x00, 0x00, 0x00, 0x10},
  1165. {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
  1166. {0xa1, 0x18, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x10},
  1167. {0xa1, 0x18, 0x10, 0x40, 0x00, 0x00, 0x00, 0x10},
  1168. {0xa1, 0x18, 0x11, 0x4e, 0x00, 0x00, 0x00, 0x10},
  1169. {0xa1, 0x18, 0x12, 0x53, 0x00, 0x00, 0x00, 0x10},
  1170. {0xa1, 0x18, 0x15, 0x80, 0x00, 0x00, 0x00, 0x10},
  1171. {0xa1, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x10},
  1172. {0xa1, 0x18, 0x19, 0x18, 0x00, 0x00, 0x00, 0x10},
  1173. {0xa1, 0x18, 0x1a, 0x10, 0x00, 0x00, 0x00, 0x10},
  1174. {0xa1, 0x18, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x10},
  1175. {0xa1, 0x18, 0x1c, 0x28, 0x00, 0x00, 0x00, 0x10},
  1176. {0xa1, 0x18, 0x1d, 0x02, 0x00, 0x00, 0x00, 0x10},
  1177. {0xa1, 0x18, 0x1e, 0x10, 0x00, 0x00, 0x00, 0x10},
  1178. {0xa1, 0x18, 0x26, 0x04, 0x00, 0x00, 0x00, 0x10},
  1179. {0xa1, 0x18, 0x27, 0x1e, 0x00, 0x00, 0x00, 0x10},
  1180. {0xa1, 0x18, 0x28, 0x5a, 0x00, 0x00, 0x00, 0x10},
  1181. {0xa1, 0x18, 0x29, 0x28, 0x00, 0x00, 0x00, 0x10},
  1182. {0xa1, 0x18, 0x2a, 0x78, 0x00, 0x00, 0x00, 0x10},
  1183. {0xa1, 0x18, 0x2b, 0x01, 0x00, 0x00, 0x00, 0x10},
  1184. {0xa1, 0x18, 0x2c, 0xf7, 0x00, 0x00, 0x00, 0x10},
  1185. {0xa1, 0x18, 0x2d, 0x2d, 0x00, 0x00, 0x00, 0x10},
  1186. {0xa1, 0x18, 0x2e, 0xd5, 0x00, 0x00, 0x00, 0x10},
  1187. {0xa1, 0x18, 0x39, 0x42, 0x00, 0x00, 0x00, 0x10},
  1188. {0xa1, 0x18, 0x3a, 0x67, 0x00, 0x00, 0x00, 0x10},
  1189. {0xa1, 0x18, 0x3b, 0x87, 0x00, 0x00, 0x00, 0x10},
  1190. {0xa1, 0x18, 0x3c, 0xa3, 0x00, 0x00, 0x00, 0x10},
  1191. {0xa1, 0x18, 0x3d, 0xb0, 0x00, 0x00, 0x00, 0x10},
  1192. {0xa1, 0x18, 0x3e, 0xbc, 0x00, 0x00, 0x00, 0x10},
  1193. {0xa1, 0x18, 0x3f, 0xc8, 0x00, 0x00, 0x00, 0x10},
  1194. {0xa1, 0x18, 0x40, 0xd4, 0x00, 0x00, 0x00, 0x10},
  1195. {0xa1, 0x18, 0x41, 0xdf, 0x00, 0x00, 0x00, 0x10},
  1196. {0xa1, 0x18, 0x42, 0xea, 0x00, 0x00, 0x00, 0x10},
  1197. {0xa1, 0x18, 0x43, 0xf5, 0x00, 0x00, 0x00, 0x10},
  1198. {0xa1, 0x18, 0x45, 0x80, 0x00, 0x00, 0x00, 0x10},
  1199. {0xa1, 0x18, 0x46, 0x60, 0x00, 0x00, 0x00, 0x10},
  1200. {0xa1, 0x18, 0x47, 0x50, 0x00, 0x00, 0x00, 0x10},
  1201. {0xa1, 0x18, 0x48, 0x30, 0x00, 0x00, 0x00, 0x10},
  1202. {0xa1, 0x18, 0x49, 0x01, 0x00, 0x00, 0x00, 0x10},
  1203. {0xa1, 0x18, 0x4d, 0xae, 0x00, 0x00, 0x00, 0x10},
  1204. {0xa1, 0x18, 0x4e, 0x03, 0x00, 0x00, 0x00, 0x10},
  1205. {0xa1, 0x18, 0x4f, 0x66, 0x00, 0x00, 0x00, 0x10},
  1206. {0xa1, 0x18, 0x50, 0x1c, 0x00, 0x00, 0x00, 0x10},
  1207. {0xa1, 0x18, 0x44, 0x10, 0x00, 0x00, 0x00, 0x10},
  1208. {0xa1, 0x18, 0x4a, 0x30, 0x00, 0x00, 0x00, 0x10},
  1209. {0xa1, 0x18, 0x51, 0x80, 0x00, 0x00, 0x00, 0x10},
  1210. {0xa1, 0x18, 0x52, 0x80, 0x00, 0x00, 0x00, 0x10},
  1211. {0xa1, 0x18, 0x53, 0x80, 0x00, 0x00, 0x00, 0x10},
  1212. {0xa1, 0x18, 0x54, 0x80, 0x00, 0x00, 0x00, 0x10},
  1213. {0xa1, 0x18, 0x55, 0x80, 0x00, 0x00, 0x00, 0x10},
  1214. {0xa1, 0x18, 0x56, 0x80, 0x00, 0x00, 0x00, 0x10},
  1215. {0xa1, 0x18, 0x57, 0xe0, 0x00, 0x00, 0x00, 0x10},
  1216. {0xa1, 0x18, 0x58, 0xc0, 0x00, 0x00, 0x00, 0x10},
  1217. {0xa1, 0x18, 0x59, 0xab, 0x00, 0x00, 0x00, 0x10},
  1218. {0xa1, 0x18, 0x5a, 0xa0, 0x00, 0x00, 0x00, 0x10},
  1219. {0xa1, 0x18, 0x5b, 0x99, 0x00, 0x00, 0x00, 0x10},
  1220. {0xa1, 0x18, 0x5c, 0x90, 0x00, 0x00, 0x00, 0x10},
  1221. {0xa1, 0x18, 0x5e, 0x24, 0x00, 0x00, 0x00, 0x10},
  1222. {0xa1, 0x18, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x10},
  1223. {0xa1, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00, 0x10},
  1224. {0xa1, 0x18, 0x61, 0x73, 0x00, 0x00, 0x00, 0x10},
  1225. {0xa1, 0x18, 0x63, 0x42, 0x00, 0x00, 0x00, 0x10},
  1226. {0xa1, 0x18, 0x64, 0x42, 0x00, 0x00, 0x00, 0x10},
  1227. {0xa1, 0x18, 0x65, 0x42, 0x00, 0x00, 0x00, 0x10},
  1228. {0xa1, 0x18, 0x66, 0x24, 0x00, 0x00, 0x00, 0x10},
  1229. {0xa1, 0x18, 0x67, 0x24, 0x00, 0x00, 0x00, 0x10},
  1230. {0xa1, 0x18, 0x68, 0x08, 0x00, 0x00, 0x00, 0x10},
  1231. {0xa1, 0x18, 0x2f, 0xc9, 0x00, 0x00, 0x00, 0x10},
  1232. {}
  1233. };
  1234. static const u8 sp80708_sensor_param1[][8] = {
  1235. {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
  1236. {0xa1, 0x18, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x10},
  1237. {0xa1, 0x18, 0x03, 0x01, 0x00, 0x00, 0x00, 0x10},
  1238. {0xa1, 0x18, 0x04, 0xa4, 0x00, 0x00, 0x00, 0x10},
  1239. {0xa1, 0x18, 0x14, 0x3f, 0x00, 0x00, 0x00, 0x10},
  1240. {0xa1, 0x18, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
  1241. {0xb1, 0x18, 0x11, 0x40, 0x40, 0x00, 0x00, 0x10},
  1242. {}
  1243. };
  1244. static const u8 (*sensor_init[])[8] = {
  1245. [SENSOR_ADCM1700] = adcm1700_sensor_init,
  1246. [SENSOR_GC0307] = gc0307_sensor_init,
  1247. [SENSOR_HV7131R] = hv7131r_sensor_init,
  1248. [SENSOR_MI0360] = mi0360_sensor_init,
  1249. [SENSOR_MO4000] = mo4000_sensor_init,
  1250. [SENSOR_MT9V111] = mt9v111_sensor_init,
  1251. [SENSOR_OM6802] = om6802_sensor_init,
  1252. [SENSOR_OV7630] = ov7630_sensor_init,
  1253. [SENSOR_OV7648] = ov7648_sensor_init,
  1254. [SENSOR_OV7660] = ov7660_sensor_init,
  1255. [SENSOR_PO1030] = po1030_sensor_init,
  1256. [SENSOR_PO2030N] = po2030n_sensor_init,
  1257. [SENSOR_SOI768] = soi768_sensor_init,
  1258. [SENSOR_SP80708] = sp80708_sensor_init,
  1259. };
  1260. /* read <len> bytes to gspca_dev->usb_buf */
  1261. static void reg_r(struct gspca_dev *gspca_dev,
  1262. u16 value, int len)
  1263. {
  1264. #ifdef GSPCA_DEBUG
  1265. if (len > USB_BUF_SZ) {
  1266. err("reg_r: buffer overflow");
  1267. return;
  1268. }
  1269. #endif
  1270. usb_control_msg(gspca_dev->dev,
  1271. usb_rcvctrlpipe(gspca_dev->dev, 0),
  1272. 0,
  1273. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
  1274. value, 0,
  1275. gspca_dev->usb_buf, len,
  1276. 500);
  1277. PDEBUG(D_USBI, "reg_r [%02x] -> %02x", value, gspca_dev->usb_buf[0]);
  1278. }
  1279. static void reg_w1(struct gspca_dev *gspca_dev,
  1280. u16 value,
  1281. u8 data)
  1282. {
  1283. PDEBUG(D_USBO, "reg_w1 [%04x] = %02x", value, data);
  1284. gspca_dev->usb_buf[0] = data;
  1285. usb_control_msg(gspca_dev->dev,
  1286. usb_sndctrlpipe(gspca_dev->dev, 0),
  1287. 0x08,
  1288. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
  1289. value,
  1290. 0,
  1291. gspca_dev->usb_buf, 1,
  1292. 500);
  1293. }
  1294. static void reg_w(struct gspca_dev *gspca_dev,
  1295. u16 value,
  1296. const u8 *buffer,
  1297. int len)
  1298. {
  1299. PDEBUG(D_USBO, "reg_w [%04x] = %02x %02x ..",
  1300. value, buffer[0], buffer[1]);
  1301. #ifdef GSPCA_DEBUG
  1302. if (len > USB_BUF_SZ) {
  1303. err("reg_w: buffer overflow");
  1304. return;
  1305. }
  1306. #endif
  1307. memcpy(gspca_dev->usb_buf, buffer, len);
  1308. usb_control_msg(gspca_dev->dev,
  1309. usb_sndctrlpipe(gspca_dev->dev, 0),
  1310. 0x08,
  1311. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
  1312. value, 0,
  1313. gspca_dev->usb_buf, len,
  1314. 500);
  1315. }
  1316. /* I2C write 1 byte */
  1317. static void i2c_w1(struct gspca_dev *gspca_dev, u8 reg, u8 val)
  1318. {
  1319. struct sd *sd = (struct sd *) gspca_dev;
  1320. PDEBUG(D_USBO, "i2c_w1 [%02x] = %02x", reg, val);
  1321. switch (sd->sensor) {
  1322. case SENSOR_ADCM1700:
  1323. case SENSOR_OM6802:
  1324. case SENSOR_GC0307: /* i2c command = a0 (100 kHz) */
  1325. gspca_dev->usb_buf[0] = 0x80 | (2 << 4);
  1326. break;
  1327. default: /* i2c command = a1 (400 kHz) */
  1328. gspca_dev->usb_buf[0] = 0x81 | (2 << 4);
  1329. break;
  1330. }
  1331. gspca_dev->usb_buf[1] = sd->i2c_addr;
  1332. gspca_dev->usb_buf[2] = reg;
  1333. gspca_dev->usb_buf[3] = val;
  1334. gspca_dev->usb_buf[4] = 0;
  1335. gspca_dev->usb_buf[5] = 0;
  1336. gspca_dev->usb_buf[6] = 0;
  1337. gspca_dev->usb_buf[7] = 0x10;
  1338. usb_control_msg(gspca_dev->dev,
  1339. usb_sndctrlpipe(gspca_dev->dev, 0),
  1340. 0x08,
  1341. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
  1342. 0x08, /* value = i2c */
  1343. 0,
  1344. gspca_dev->usb_buf, 8,
  1345. 500);
  1346. }
  1347. /* I2C write 8 bytes */
  1348. static void i2c_w8(struct gspca_dev *gspca_dev,
  1349. const u8 *buffer)
  1350. {
  1351. PDEBUG(D_USBO, "i2c_w8 [%02x] = %02x ..",
  1352. buffer[2], buffer[3]);
  1353. memcpy(gspca_dev->usb_buf, buffer, 8);
  1354. usb_control_msg(gspca_dev->dev,
  1355. usb_sndctrlpipe(gspca_dev->dev, 0),
  1356. 0x08,
  1357. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
  1358. 0x08, 0, /* value, index */
  1359. gspca_dev->usb_buf, 8,
  1360. 500);
  1361. msleep(2);
  1362. }
  1363. /* sensor read 'len' (1..5) bytes in gspca_dev->usb_buf */
  1364. static void i2c_r(struct gspca_dev *gspca_dev, u8 reg, int len)
  1365. {
  1366. struct sd *sd = (struct sd *) gspca_dev;
  1367. u8 mode[8];
  1368. switch (sd->sensor) {
  1369. case SENSOR_ADCM1700:
  1370. case SENSOR_OM6802:
  1371. case SENSOR_GC0307: /* i2c command = a0 (100 kHz) */
  1372. mode[0] = 0x80 | 0x10;
  1373. break;
  1374. default: /* i2c command = 91 (400 kHz) */
  1375. mode[0] = 0x81 | 0x10;
  1376. break;
  1377. }
  1378. mode[1] = sd->i2c_addr;
  1379. mode[2] = reg;
  1380. mode[3] = 0;
  1381. mode[4] = 0;
  1382. mode[5] = 0;
  1383. mode[6] = 0;
  1384. mode[7] = 0x10;
  1385. i2c_w8(gspca_dev, mode);
  1386. msleep(2);
  1387. mode[0] = (mode[0] & 0x81) | (len << 4) | 0x02;
  1388. mode[2] = 0;
  1389. i2c_w8(gspca_dev, mode);
  1390. msleep(2);
  1391. reg_r(gspca_dev, 0x0a, 5);
  1392. }
  1393. static void i2c_w_seq(struct gspca_dev *gspca_dev,
  1394. const u8 (*data)[8])
  1395. {
  1396. while ((*data)[0] != 0) {
  1397. if ((*data)[0] != 0xdd)
  1398. i2c_w8(gspca_dev, *data);
  1399. else
  1400. msleep((*data)[1]);
  1401. data++;
  1402. }
  1403. }
  1404. static void hv7131r_probe(struct gspca_dev *gspca_dev)
  1405. {
  1406. i2c_w1(gspca_dev, 0x02, 0); /* sensor wakeup */
  1407. msleep(10);
  1408. reg_w1(gspca_dev, 0x02, 0x66); /* Gpio on */
  1409. msleep(10);
  1410. i2c_r(gspca_dev, 0, 5); /* read sensor id */
  1411. if (gspca_dev->usb_buf[0] == 0x02
  1412. && gspca_dev->usb_buf[1] == 0x09
  1413. && gspca_dev->usb_buf[2] == 0x01
  1414. && gspca_dev->usb_buf[3] == 0x00
  1415. && gspca_dev->usb_buf[4] == 0x00) {
  1416. PDEBUG(D_PROBE, "Sensor sn9c102P HV7131R found");
  1417. return;
  1418. }
  1419. PDEBUG(D_PROBE, "Sensor 0x%02x 0x%02x 0x%02x - sn9c102P not found",
  1420. gspca_dev->usb_buf[0], gspca_dev->usb_buf[1],
  1421. gspca_dev->usb_buf[2]);
  1422. }
  1423. static void mi0360_probe(struct gspca_dev *gspca_dev)
  1424. {
  1425. struct sd *sd = (struct sd *) gspca_dev;
  1426. int i, j;
  1427. u16 val = 0;
  1428. static const u8 probe_tb[][4][8] = {
  1429. { /* mi0360 */
  1430. {0xb0, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10},
  1431. {0x90, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  1432. {0xa2, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  1433. {0xb0, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10}
  1434. },
  1435. { /* mt9v111 */
  1436. {0xb0, 0x5c, 0x01, 0x00, 0x04, 0x00, 0x00, 0x10},
  1437. {0x90, 0x5c, 0x36, 0x00, 0x00, 0x00, 0x00, 0x10},
  1438. {0xa2, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
  1439. {}
  1440. },
  1441. };
  1442. for (i = 0; i < ARRAY_SIZE(probe_tb); i++) {
  1443. reg_w1(gspca_dev, 0x17, 0x62);
  1444. reg_w1(gspca_dev, 0x01, 0x08);
  1445. for (j = 0; j < 3; j++)
  1446. i2c_w8(gspca_dev, probe_tb[i][j]);
  1447. msleep(2);
  1448. reg_r(gspca_dev, 0x0a, 5);
  1449. val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
  1450. if (probe_tb[i][3][0] != 0)
  1451. i2c_w8(gspca_dev, probe_tb[i][3]);
  1452. reg_w1(gspca_dev, 0x01, 0x29);
  1453. reg_w1(gspca_dev, 0x17, 0x42);
  1454. if (val != 0xffff)
  1455. break;
  1456. }
  1457. switch (val) {
  1458. case 0x823a:
  1459. PDEBUG(D_PROBE, "Sensor mt9v111");
  1460. sd->sensor = SENSOR_MT9V111;
  1461. break;
  1462. case 0x8243:
  1463. PDEBUG(D_PROBE, "Sensor mi0360");
  1464. break;
  1465. default:
  1466. PDEBUG(D_PROBE, "Unknown sensor %04x - forced to mi0360", val);
  1467. break;
  1468. }
  1469. }
  1470. static void ov7630_probe(struct gspca_dev *gspca_dev)
  1471. {
  1472. struct sd *sd = (struct sd *) gspca_dev;
  1473. u16 val;
  1474. /* check ov76xx */
  1475. reg_w1(gspca_dev, 0x17, 0x62);
  1476. reg_w1(gspca_dev, 0x01, 0x08);
  1477. sd->i2c_addr = 0x21;
  1478. i2c_r(gspca_dev, 0x0a, 2);
  1479. val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
  1480. reg_w1(gspca_dev, 0x01, 0x29);
  1481. reg_w1(gspca_dev, 0x17, 0x42);
  1482. if (val == 0x7628) { /* soi768 */
  1483. sd->sensor = SENSOR_SOI768;
  1484. /*fixme: only valid for 0c45:613e?*/
  1485. gspca_dev->cam.input_flags =
  1486. V4L2_IN_ST_VFLIP | V4L2_IN_ST_HFLIP;
  1487. PDEBUG(D_PROBE, "Sensor soi768");
  1488. return;
  1489. }
  1490. PDEBUG(D_PROBE, "Sensor ov%04x", val);
  1491. }
  1492. static void ov7648_probe(struct gspca_dev *gspca_dev)
  1493. {
  1494. struct sd *sd = (struct sd *) gspca_dev;
  1495. u16 val;
  1496. /* check ov76xx */
  1497. reg_w1(gspca_dev, 0x17, 0x62);
  1498. reg_w1(gspca_dev, 0x01, 0x08);
  1499. sd->i2c_addr = 0x21;
  1500. i2c_r(gspca_dev, 0x0a, 2);
  1501. val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
  1502. reg_w1(gspca_dev, 0x01, 0x29);
  1503. reg_w1(gspca_dev, 0x17, 0x42);
  1504. if ((val & 0xff00) == 0x7600) { /* ov76xx */
  1505. PDEBUG(D_PROBE, "Sensor ov%04x", val);
  1506. return;
  1507. }
  1508. /* check po1030 */
  1509. reg_w1(gspca_dev, 0x17, 0x62);
  1510. reg_w1(gspca_dev, 0x01, 0x08);
  1511. sd->i2c_addr = 0x6e;
  1512. i2c_r(gspca_dev, 0x00, 2);
  1513. val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
  1514. reg_w1(gspca_dev, 0x01, 0x29);
  1515. reg_w1(gspca_dev, 0x17, 0x42);
  1516. if (val == 0x1030) { /* po1030 */
  1517. PDEBUG(D_PROBE, "Sensor po1030");
  1518. sd->sensor = SENSOR_PO1030;
  1519. return;
  1520. }
  1521. PDEBUG(D_PROBE, "Unknown sensor %04x", val);
  1522. }
  1523. /* 0c45:6142 sensor may be po2030n, gc0305 or gc0307 */
  1524. static void po2030n_probe(struct gspca_dev *gspca_dev)
  1525. {
  1526. struct sd *sd = (struct sd *) gspca_dev;
  1527. u16 val;
  1528. /* check gc0307 */
  1529. reg_w1(gspca_dev, 0x17, 0x62);
  1530. reg_w1(gspca_dev, 0x01, 0x08);
  1531. reg_w1(gspca_dev, 0x02, 0x22);
  1532. sd->i2c_addr = 0x21;
  1533. i2c_r(gspca_dev, 0x00, 1);
  1534. val = gspca_dev->usb_buf[4];
  1535. reg_w1(gspca_dev, 0x01, 0x29); /* reset */
  1536. reg_w1(gspca_dev, 0x17, 0x42);
  1537. if (val == 0x99) { /* gc0307 (?) */
  1538. PDEBUG(D_PROBE, "Sensor gc0307");
  1539. sd->sensor = SENSOR_GC0307;
  1540. return;
  1541. }
  1542. /* check po2030n */
  1543. reg_w1(gspca_dev, 0x17, 0x62);
  1544. reg_w1(gspca_dev, 0x01, 0x0a);
  1545. sd->i2c_addr = 0x6e;
  1546. i2c_r(gspca_dev, 0x00, 2);
  1547. val = (gspca_dev->usb_buf[3] << 8) | gspca_dev->usb_buf[4];
  1548. reg_w1(gspca_dev, 0x01, 0x29);
  1549. reg_w1(gspca_dev, 0x17, 0x42);
  1550. if (val == 0x2030) {
  1551. PDEBUG(D_PROBE, "Sensor po2030n");
  1552. /* sd->sensor = SENSOR_PO2030N; */
  1553. } else {
  1554. PDEBUG(D_PROBE, "Unknown sensor ID %04x", val);
  1555. }
  1556. }
  1557. static void bridge_init(struct gspca_dev *gspca_dev,
  1558. const u8 *sn9c1xx)
  1559. {
  1560. struct sd *sd = (struct sd *) gspca_dev;
  1561. u8 reg0102[2];
  1562. const u8 *reg9a;
  1563. static const u8 reg9a_def[] =
  1564. {0x00, 0x40, 0x20, 0x00, 0x00, 0x00};
  1565. static const u8 reg9a_spec[] =
  1566. {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
  1567. static const u8 regd4[] = {0x60, 0x00, 0x00};
  1568. /* sensor clock already enabled in sd_init */
  1569. /* reg_w1(gspca_dev, 0xf1, 0x00); */
  1570. reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
  1571. /* configure gpio */
  1572. reg0102[0] = sn9c1xx[1];
  1573. reg0102[1] = sn9c1xx[2];
  1574. if (gspca_dev->audio)
  1575. reg0102[1] |= 0x04; /* keep the audio connection */
  1576. reg_w(gspca_dev, 0x01, reg0102, 2);
  1577. reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
  1578. reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);
  1579. switch (sd->sensor) {
  1580. case SENSOR_GC0307:
  1581. case SENSOR_OV7660:
  1582. case SENSOR_PO1030:
  1583. case SENSOR_PO2030N:
  1584. case SENSOR_SOI768:
  1585. case SENSOR_SP80708:
  1586. reg9a = reg9a_spec;
  1587. break;
  1588. default:
  1589. reg9a = reg9a_def;
  1590. break;
  1591. }
  1592. reg_w(gspca_dev, 0x9a, reg9a, 6);
  1593. reg_w(gspca_dev, 0xd4, regd4, sizeof regd4);
  1594. reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
  1595. switch (sd->sensor) {
  1596. case SENSOR_ADCM1700:
  1597. reg_w1(gspca_dev, 0x01, 0x43);
  1598. reg_w1(gspca_dev, 0x17, 0x62);
  1599. reg_w1(gspca_dev, 0x01, 0x42);
  1600. reg_w1(gspca_dev, 0x01, 0x42);
  1601. break;
  1602. case SENSOR_GC0307:
  1603. msleep(50);
  1604. reg_w1(gspca_dev, 0x01, 0x61);
  1605. reg_w1(gspca_dev, 0x17, 0x22);
  1606. reg_w1(gspca_dev, 0x01, 0x60);
  1607. reg_w1(gspca_dev, 0x01, 0x40);
  1608. msleep(50);
  1609. break;
  1610. case SENSOR_MT9V111:
  1611. reg_w1(gspca_dev, 0x01, 0x61);
  1612. reg_w1(gspca_dev, 0x17, 0x61);
  1613. reg_w1(gspca_dev, 0x01, 0x60);
  1614. reg_w1(gspca_dev, 0x01, 0x40);
  1615. break;
  1616. case SENSOR_OM6802:
  1617. msleep(10);
  1618. reg_w1(gspca_dev, 0x02, 0x73);
  1619. reg_w1(gspca_dev, 0x17, 0x60);
  1620. reg_w1(gspca_dev, 0x01, 0x22);
  1621. msleep(100);
  1622. reg_w1(gspca_dev, 0x01, 0x62);
  1623. reg_w1(gspca_dev, 0x17, 0x64);
  1624. reg_w1(gspca_dev, 0x17, 0x64);
  1625. reg_w1(gspca_dev, 0x01, 0x42);
  1626. msleep(10);
  1627. reg_w1(gspca_dev, 0x01, 0x42);
  1628. i2c_w8(gspca_dev, om6802_init0[0]);
  1629. i2c_w8(gspca_dev, om6802_init0[1]);
  1630. msleep(15);
  1631. reg_w1(gspca_dev, 0x02, 0x71);
  1632. msleep(150);
  1633. break;
  1634. case SENSOR_OV7630:
  1635. reg_w1(gspca_dev, 0x01, 0x61);
  1636. reg_w1(gspca_dev, 0x17, 0xe2);
  1637. reg_w1(gspca_dev, 0x01, 0x60);
  1638. reg_w1(gspca_dev, 0x01, 0x40);
  1639. break;
  1640. case SENSOR_OV7648:
  1641. reg_w1(gspca_dev, 0x01, 0x63);
  1642. reg_w1(gspca_dev, 0x17, 0x20);
  1643. reg_w1(gspca_dev, 0x01, 0x62);
  1644. reg_w1(gspca_dev, 0x01, 0x42);
  1645. break;
  1646. case SENSOR_PO1030:
  1647. case SENSOR_SOI768:
  1648. reg_w1(gspca_dev, 0x01, 0x61);
  1649. reg_w1(gspca_dev, 0x17, 0x20);
  1650. reg_w1(gspca_dev, 0x01, 0x60);
  1651. reg_w1(gspca_dev, 0x01, 0x40);
  1652. break;
  1653. case SENSOR_PO2030N:
  1654. case SENSOR_OV7660:
  1655. reg_w1(gspca_dev, 0x01, 0x63);
  1656. reg_w1(gspca_dev, 0x17, 0x20);
  1657. reg_w1(gspca_dev, 0x01, 0x62);
  1658. reg_w1(gspca_dev, 0x01, 0x42);
  1659. break;
  1660. case SENSOR_SP80708:
  1661. reg_w1(gspca_dev, 0x01, 0x63);
  1662. reg_w1(gspca_dev, 0x17, 0x20);
  1663. reg_w1(gspca_dev, 0x01, 0x62);
  1664. reg_w1(gspca_dev, 0x01, 0x42);
  1665. msleep(100);
  1666. reg_w1(gspca_dev, 0x02, 0x62);
  1667. break;
  1668. default:
  1669. /* case SENSOR_HV7131R: */
  1670. /* case SENSOR_MI0360: */
  1671. /* case SENSOR_MO4000: */
  1672. reg_w1(gspca_dev, 0x01, 0x43);
  1673. reg_w1(gspca_dev, 0x17, 0x61);
  1674. reg_w1(gspca_dev, 0x01, 0x42);
  1675. if (sd->sensor == SENSOR_HV7131R
  1676. && sd->bridge == BRIDGE_SN9C102P)
  1677. hv7131r_probe(gspca_dev);
  1678. break;
  1679. }
  1680. }
  1681. /* this function is called at probe time */
  1682. static int sd_config(struct gspca_dev *gspca_dev,
  1683. const struct usb_device_id *id)
  1684. {
  1685. struct sd *sd = (struct sd *) gspca_dev;
  1686. struct cam *cam;
  1687. sd->bridge = id->driver_info >> 16;
  1688. sd->sensor = id->driver_info;
  1689. cam = &gspca_dev->cam;
  1690. if (sd->sensor == SENSOR_ADCM1700) {
  1691. cam->cam_mode = cif_mode;
  1692. cam->nmodes = ARRAY_SIZE(cif_mode);
  1693. } else {
  1694. cam->cam_mode = vga_mode;
  1695. cam->nmodes = ARRAY_SIZE(vga_mode);
  1696. }
  1697. cam->npkt = 24; /* 24 packets per ISOC message */
  1698. sd->brightness = BRIGHTNESS_DEF;
  1699. sd->contrast = CONTRAST_DEF;
  1700. sd->colors = COLOR_DEF;
  1701. sd->blue = BLUE_BALANCE_DEF;
  1702. sd->red = RED_BALANCE_DEF;
  1703. sd->gamma = GAMMA_DEF;
  1704. sd->autogain = AUTOGAIN_DEF;
  1705. sd->ag_cnt = -1;
  1706. sd->vflip = VFLIP_DEF;
  1707. switch (sd->sensor) {
  1708. case SENSOR_OM6802:
  1709. sd->sharpness = 0x10;
  1710. break;
  1711. default:
  1712. sd->sharpness = SHARPNESS_DEF;
  1713. break;
  1714. }
  1715. sd->infrared = INFRARED_DEF;
  1716. sd->freq = FREQ_DEF;
  1717. sd->quality = QUALITY_DEF;
  1718. sd->jpegqual = 80;
  1719. return 0;
  1720. }
  1721. /* this function is called at probe and resume time */
  1722. static int sd_init(struct gspca_dev *gspca_dev)
  1723. {
  1724. struct sd *sd = (struct sd *) gspca_dev;
  1725. const u8 *sn9c1xx;
  1726. u8 regGpio[] = { 0x29, 0x74 }; /* with audio */
  1727. u8 regF1;
  1728. /* setup a selector by bridge */
  1729. reg_w1(gspca_dev, 0xf1, 0x01);
  1730. reg_r(gspca_dev, 0x00, 1);
  1731. reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]);
  1732. reg_r(gspca_dev, 0x00, 1); /* get sonix chip id */
  1733. regF1 = gspca_dev->usb_buf[0];
  1734. PDEBUG(D_PROBE, "Sonix chip id: %02x", regF1);
  1735. switch (sd->bridge) {
  1736. case BRIDGE_SN9C102P:
  1737. if (regF1 != 0x11)
  1738. return -ENODEV;
  1739. reg_w1(gspca_dev, 0x02, regGpio[1]);
  1740. break;
  1741. case BRIDGE_SN9C105:
  1742. if (regF1 != 0x11)
  1743. return -ENODEV;
  1744. if (sd->sensor == SENSOR_MI0360)
  1745. mi0360_probe(gspca_dev);
  1746. reg_w(gspca_dev, 0x01, regGpio, 2);
  1747. break;
  1748. case BRIDGE_SN9C120:
  1749. if (regF1 != 0x12)
  1750. return -ENODEV;
  1751. switch (sd->sensor) {
  1752. case SENSOR_MI0360:
  1753. mi0360_probe(gspca_dev);
  1754. break;
  1755. case SENSOR_OV7630:
  1756. ov7630_probe(gspca_dev);
  1757. break;
  1758. case SENSOR_OV7648:
  1759. ov7648_probe(gspca_dev);
  1760. break;
  1761. case SENSOR_PO2030N:
  1762. po2030n_probe(gspca_dev);
  1763. break;
  1764. }
  1765. regGpio[1] = 0x70; /* no audio */
  1766. reg_w(gspca_dev, 0x01, regGpio, 2);
  1767. break;
  1768. default:
  1769. /* case BRIDGE_SN9C110: */
  1770. /* case BRIDGE_SN9C325: */
  1771. if (regF1 != 0x12)
  1772. return -ENODEV;
  1773. reg_w1(gspca_dev, 0x02, 0x62);
  1774. break;
  1775. }
  1776. /* Note we do not disable the sensor clock here (power saving mode),
  1777. as that also disables the button on the cam. */
  1778. reg_w1(gspca_dev, 0xf1, 0x00);
  1779. /* set the i2c address */
  1780. sn9c1xx = sn_tb[sd->sensor];
  1781. sd->i2c_addr = sn9c1xx[9];
  1782. gspca_dev->ctrl_dis = ctrl_dis[sd->sensor];
  1783. return 0;
  1784. }
  1785. static u32 setexposure(struct gspca_dev *gspca_dev,
  1786. u32 expo)
  1787. {
  1788. struct sd *sd = (struct sd *) gspca_dev;
  1789. switch (sd->sensor) {
  1790. case SENSOR_GC0307: {
  1791. int a, b;
  1792. /* expo = 0..255 -> a = 19..43 */
  1793. a = 19 + expo * 25 / 256;
  1794. i2c_w1(gspca_dev, 0x68, a);
  1795. a -= 12;
  1796. b = a * a * 4; /* heuristic */
  1797. i2c_w1(gspca_dev, 0x03, b >> 8);
  1798. i2c_w1(gspca_dev, 0x04, b);
  1799. break;
  1800. }
  1801. case SENSOR_HV7131R: {
  1802. u8 Expodoit[] =
  1803. { 0xc1, 0x11, 0x25, 0x00, 0x00, 0x00, 0x00, 0x16 };
  1804. Expodoit[3] = expo >> 16;
  1805. Expodoit[4] = expo >> 8;
  1806. Expodoit[5] = expo;
  1807. i2c_w8(gspca_dev, Expodoit);
  1808. break;
  1809. }
  1810. case SENSOR_MI0360: {
  1811. u8 expoMi[] = /* exposure 0x0635 -> 4 fp/s 0x10 */
  1812. { 0xb1, 0x5d, 0x09, 0x00, 0x00, 0x00, 0x00, 0x16 };
  1813. static const u8 doit[] = /* update sensor */
  1814. { 0xb1, 0x5d, 0x07, 0x00, 0x03, 0x00, 0x00, 0x10 };
  1815. static const u8 sensorgo[] = /* sensor on */
  1816. { 0xb1, 0x5d, 0x07, 0x00, 0x02, 0x00, 0x00, 0x10 };
  1817. if (expo > 0x0635)
  1818. expo = 0x0635;
  1819. else if (expo < 0x0001)
  1820. expo = 0x0001;
  1821. expoMi[3] = expo >> 8;
  1822. expoMi[4] = expo;
  1823. i2c_w8(gspca_dev, expoMi);
  1824. i2c_w8(gspca_dev, doit);
  1825. i2c_w8(gspca_dev, sensorgo);
  1826. break;
  1827. }
  1828. case SENSOR_MO4000: {
  1829. u8 expoMof[] =
  1830. { 0xa1, 0x21, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x10 };
  1831. u8 expoMo10[] =
  1832. { 0xa1, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x10 };
  1833. static const u8 gainMo[] =
  1834. { 0xa1, 0x21, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1d };
  1835. if (expo > 0x1fff)
  1836. expo = 0x1fff;
  1837. else if (expo < 0x0001)
  1838. expo = 0x0001;
  1839. expoMof[3] = (expo & 0x03fc) >> 2;
  1840. i2c_w8(gspca_dev, expoMof);
  1841. expoMo10[3] = ((expo & 0x1c00) >> 10)
  1842. | ((expo & 0x0003) << 4);
  1843. i2c_w8(gspca_dev, expoMo10);
  1844. i2c_w8(gspca_dev, gainMo);
  1845. PDEBUG(D_FRAM, "set exposure %d",
  1846. ((expoMo10[3] & 0x07) << 10)
  1847. | (expoMof[3] << 2)
  1848. | ((expoMo10[3] & 0x30) >> 4));
  1849. break;
  1850. }
  1851. case SENSOR_MT9V111: {
  1852. u8 expo_c1[] =
  1853. { 0xb1, 0x5c, 0x09, 0x00, 0x00, 0x00, 0x00, 0x10 };
  1854. if (expo > 0x0280)
  1855. expo = 0x0280;
  1856. else if (expo < 0x0040)
  1857. expo = 0x0040;
  1858. expo_c1[3] = expo >> 8;
  1859. expo_c1[4] = expo;
  1860. i2c_w8(gspca_dev, expo_c1);
  1861. break;
  1862. }
  1863. case SENSOR_OM6802: {
  1864. u8 gainOm[] =
  1865. { 0xa0, 0x34, 0xe5, 0x00, 0x00, 0x00, 0x00, 0x10 };
  1866. /* preset AGC - works when AutoExpo = off */
  1867. if (expo > 0x03ff)
  1868. expo = 0x03ff;
  1869. if (expo < 0x0001)
  1870. expo = 0x0001;
  1871. gainOm[3] = expo >> 2;
  1872. i2c_w8(gspca_dev, gainOm);
  1873. reg_w1(gspca_dev, 0x96, expo >> 5);
  1874. PDEBUG(D_FRAM, "set exposure %d", gainOm[3]);
  1875. break;
  1876. }
  1877. }
  1878. return expo;
  1879. }
  1880. static void setbrightness(struct gspca_dev *gspca_dev)
  1881. {
  1882. struct sd *sd = (struct sd *) gspca_dev;
  1883. unsigned int expo;
  1884. u8 k2;
  1885. k2 = ((int) sd->brightness - 0x8000) >> 10;
  1886. switch (sd->sensor) {
  1887. case SENSOR_ADCM1700:
  1888. if (k2 > 0x1f)
  1889. k2 = 0; /* only positive Y offset */
  1890. break;
  1891. case SENSOR_HV7131R:
  1892. expo = sd->brightness << 4;
  1893. if (expo > 0x002dc6c0)
  1894. expo = 0x002dc6c0;
  1895. else if (expo < 0x02a0)
  1896. expo = 0x02a0;
  1897. sd->exposure = setexposure(gspca_dev, expo);
  1898. break;
  1899. case SENSOR_MI0360:
  1900. case SENSOR_MO4000:
  1901. expo = sd->brightness >> 4;
  1902. sd->exposure = setexposure(gspca_dev, expo);
  1903. break;
  1904. case SENSOR_GC0307:
  1905. case SENSOR_MT9V111:
  1906. expo = sd->brightness >> 8;
  1907. sd->exposure = setexposure(gspca_dev, expo);
  1908. return; /* don't set the Y offset */
  1909. case SENSOR_OM6802:
  1910. expo = sd->brightness >> 6;
  1911. sd->exposure = setexposure(gspca_dev, expo);
  1912. k2 = sd->brightness >> 11;
  1913. break;
  1914. }
  1915. reg_w1(gspca_dev, 0x96, k2); /* color matrix Y offset */
  1916. }
  1917. static void setcontrast(struct gspca_dev *gspca_dev)
  1918. {
  1919. struct sd *sd = (struct sd *) gspca_dev;
  1920. u8 k2;
  1921. u8 contrast[6];
  1922. k2 = sd->contrast * 0x30 / (CONTRAST_MAX + 1) + 0x10; /* 10..40 */
  1923. contrast[0] = (k2 + 1) / 2; /* red */
  1924. contrast[1] = 0;
  1925. contrast[2] = k2; /* green */
  1926. contrast[3] = 0;
  1927. contrast[4] = (k2 + 1) / 5; /* blue */
  1928. contrast[5] = 0;
  1929. reg_w(gspca_dev, 0x84, contrast, sizeof contrast);
  1930. }
  1931. static void setcolors(struct gspca_dev *gspca_dev)
  1932. {
  1933. struct sd *sd = (struct sd *) gspca_dev;
  1934. int i, v;
  1935. u8 reg8a[12]; /* U & V gains */
  1936. static const s16 uv[6] = { /* same as reg84 in signed decimal */
  1937. -24, -38, 64, /* UR UG UB */
  1938. 62, -51, -9 /* VR VG VB */
  1939. };
  1940. for (i = 0; i < 6; i++) {
  1941. v = uv[i] * sd->colors / COLOR_DEF;
  1942. reg8a[i * 2] = v;
  1943. reg8a[i * 2 + 1] = (v >> 8) & 0x0f;
  1944. }
  1945. reg_w(gspca_dev, 0x8a, reg8a, sizeof reg8a);
  1946. }
  1947. static void setredblue(struct gspca_dev *gspca_dev)
  1948. {
  1949. struct sd *sd = (struct sd *) gspca_dev;
  1950. reg_w1(gspca_dev, 0x05, sd->red);
  1951. /* reg_w1(gspca_dev, 0x07, 32); */
  1952. reg_w1(gspca_dev, 0x06, sd->blue);
  1953. }
  1954. static void setgamma(struct gspca_dev *gspca_dev)
  1955. {
  1956. struct sd *sd = (struct sd *) gspca_dev;
  1957. int i;
  1958. u8 gamma[17];
  1959. const u8 *gamma_base;
  1960. static const u8 delta[17] = {
  1961. 0x00, 0x14, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1a,
  1962. 0x18, 0x13, 0x10, 0x0e, 0x08, 0x07, 0x04, 0x02, 0x00
  1963. };
  1964. switch (sd->sensor) {
  1965. case SENSOR_ADCM1700:
  1966. gamma_base = gamma_spec_0;
  1967. break;
  1968. case SENSOR_HV7131R:
  1969. case SENSOR_MT9V111:
  1970. gamma_base = gamma_spec_1;
  1971. break;
  1972. case SENSOR_GC0307:
  1973. gamma_base = gamma_spec_2;
  1974. break;
  1975. case SENSOR_SP80708:
  1976. gamma_base = gamma_spec_3;
  1977. break;
  1978. default:
  1979. gamma_base = gamma_def;
  1980. break;
  1981. }
  1982. for (i = 0; i < sizeof gamma; i++)
  1983. gamma[i] = gamma_base[i]
  1984. + delta[i] * (sd->gamma - GAMMA_DEF) / 32;
  1985. reg_w(gspca_dev, 0x20, gamma, sizeof gamma);
  1986. }
  1987. static void setautogain(struct gspca_dev *gspca_dev)
  1988. {
  1989. struct sd *sd = (struct sd *) gspca_dev;
  1990. if (gspca_dev->ctrl_dis & (1 << AUTOGAIN_IDX))
  1991. return;
  1992. switch (sd->sensor) {
  1993. case SENSOR_OV7630:
  1994. case SENSOR_OV7648: {
  1995. u8 comb;
  1996. if (sd->sensor == SENSOR_OV7630)
  1997. comb = 0xc0;
  1998. else
  1999. comb = 0xa0;
  2000. if (sd->autogain)
  2001. comb |= 0x03;
  2002. i2c_w1(&sd->gspca_dev, 0x13, comb);
  2003. return;
  2004. }
  2005. }
  2006. if (sd->autogain)
  2007. sd->ag_cnt = AG_CNT_START;
  2008. else
  2009. sd->ag_cnt = -1;
  2010. }
  2011. /* hv7131r/ov7630/ov7648 only */
  2012. static void setvflip(struct sd *sd)
  2013. {
  2014. u8 comn;
  2015. if (sd->gspca_dev.ctrl_dis & (1 << VFLIP_IDX))
  2016. return;
  2017. switch (sd->sensor) {
  2018. case SENSOR_HV7131R:
  2019. comn = 0x18; /* clkdiv = 1, ablcen = 1 */
  2020. if (sd->vflip)
  2021. comn |= 0x01;
  2022. i2c_w1(&sd->gspca_dev, 0x01, comn); /* sctra */
  2023. break;
  2024. case SENSOR_OV7630:
  2025. comn = 0x02;
  2026. if (!sd->vflip)
  2027. comn |= 0x80;
  2028. i2c_w1(&sd->gspca_dev, 0x75, comn);
  2029. break;
  2030. default:
  2031. /* case SENSOR_OV7648: */
  2032. comn = 0x06;
  2033. if (sd->vflip)
  2034. comn |= 0x80;
  2035. i2c_w1(&sd->gspca_dev, 0x75, comn);
  2036. break;
  2037. }
  2038. }
  2039. static void setsharpness(struct sd *sd)
  2040. {
  2041. reg_w1(&sd->gspca_dev, 0x99, sd->sharpness);
  2042. }
  2043. static void setinfrared(struct sd *sd)
  2044. {
  2045. if (sd->gspca_dev.ctrl_dis & (1 << INFRARED_IDX))
  2046. return;
  2047. /*fixme: different sequence for StarCam Clip and StarCam 370i */
  2048. /* Clip */
  2049. i2c_w1(&sd->gspca_dev, 0x02, /* gpio */
  2050. sd->infrared ? 0x66 : 0x64);
  2051. }
  2052. static void setfreq(struct gspca_dev *gspca_dev)
  2053. {
  2054. struct sd *sd = (struct sd *) gspca_dev;
  2055. if (gspca_dev->ctrl_dis & (1 << FREQ_IDX))
  2056. return;
  2057. if (sd->sensor == SENSOR_OV7660) {
  2058. u8 com8;
  2059. com8 = 0xdf; /* auto gain/wb/expo */
  2060. switch (sd->freq) {
  2061. case 0: /* Banding filter disabled */
  2062. i2c_w1(gspca_dev, 0x13, com8 | 0x20);
  2063. break;
  2064. case 1: /* 50 hz */
  2065. i2c_w1(gspca_dev, 0x13, com8);
  2066. i2c_w1(gspca_dev, 0x3b, 0x0a);
  2067. break;
  2068. case 2: /* 60 hz */
  2069. i2c_w1(gspca_dev, 0x13, com8);
  2070. i2c_w1(gspca_dev, 0x3b, 0x02);
  2071. break;
  2072. }
  2073. } else {
  2074. u8 reg2a = 0, reg2b = 0, reg2d = 0;
  2075. /* Get reg2a / reg2d base values */
  2076. switch (sd->sensor) {
  2077. case SENSOR_OV7630:
  2078. reg2a = 0x08;
  2079. reg2d = 0x01;
  2080. break;
  2081. case SENSOR_OV7648:
  2082. reg2a = 0x11;
  2083. reg2d = 0x81;
  2084. break;
  2085. }
  2086. switch (sd->freq) {
  2087. case 0: /* Banding filter disabled */
  2088. break;
  2089. case 1: /* 50 hz (filter on and framerate adj) */
  2090. reg2a |= 0x80;
  2091. reg2b = 0xac;
  2092. reg2d |= 0x04;
  2093. break;
  2094. case 2: /* 60 hz (filter on, no framerate adj) */
  2095. reg2a |= 0x80;
  2096. reg2d |= 0x04;
  2097. break;
  2098. }
  2099. i2c_w1(gspca_dev, 0x2a, reg2a);
  2100. i2c_w1(gspca_dev, 0x2b, reg2b);
  2101. i2c_w1(gspca_dev, 0x2d, reg2d);
  2102. }
  2103. }
  2104. static void setjpegqual(struct gspca_dev *gspca_dev)
  2105. {
  2106. struct sd *sd = (struct sd *) gspca_dev;
  2107. int i, sc;
  2108. if (sd->jpegqual < 50)
  2109. sc = 5000 / sd->jpegqual;
  2110. else
  2111. sc = 200 - sd->jpegqual * 2;
  2112. #if USB_BUF_SZ < 64
  2113. #error "No room enough in usb_buf for quantization table"
  2114. #endif
  2115. for (i = 0; i < 64; i++)
  2116. gspca_dev->usb_buf[i] =
  2117. (jpeg_head[JPEG_QT0_OFFSET + i] * sc + 50) / 100;
  2118. usb_control_msg(gspca_dev->dev,
  2119. usb_sndctrlpipe(gspca_dev->dev, 0),
  2120. 0x08,
  2121. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
  2122. 0x0100, 0,
  2123. gspca_dev->usb_buf, 64,
  2124. 500);
  2125. for (i = 0; i < 64; i++)
  2126. gspca_dev->usb_buf[i] =
  2127. (jpeg_head[JPEG_QT1_OFFSET + i] * sc + 50) / 100;
  2128. usb_control_msg(gspca_dev->dev,
  2129. usb_sndctrlpipe(gspca_dev->dev, 0),
  2130. 0x08,
  2131. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
  2132. 0x0140, 0,
  2133. gspca_dev->usb_buf, 64,
  2134. 500);
  2135. sd->reg18 ^= 0x40;
  2136. reg_w1(gspca_dev, 0x18, sd->reg18);
  2137. }
  2138. /* -- start the camera -- */
  2139. static int sd_start(struct gspca_dev *gspca_dev)
  2140. {
  2141. struct sd *sd = (struct sd *) gspca_dev;
  2142. int i;
  2143. u8 reg1, reg17;
  2144. const u8 *sn9c1xx;
  2145. const u8 (*init)[8];
  2146. int mode;
  2147. static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
  2148. static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
  2149. static const u8 CA_adcm1700[] =
  2150. { 0x14, 0xec, 0x0a, 0xf6 };
  2151. static const u8 CA_po2030n[] =
  2152. { 0x1e, 0xe2, 0x14, 0xec };
  2153. static const u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd }; /* MI0360 */
  2154. static const u8 CE_gc0307[] =
  2155. { 0x32, 0xce, 0x2d, 0xd3 };
  2156. static const u8 CE_ov76xx[] =
  2157. { 0x32, 0xdd, 0x32, 0xdd };
  2158. static const u8 CE_po2030n[] =
  2159. { 0x14, 0xe7, 0x1e, 0xdd };
  2160. /* create the JPEG header */
  2161. jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
  2162. 0x21); /* JPEG 422 */
  2163. jpeg_set_qual(sd->jpeg_hdr, sd->quality);
  2164. /* initialize the bridge */
  2165. sn9c1xx = sn_tb[sd->sensor];
  2166. bridge_init(gspca_dev, sn9c1xx);
  2167. /* initialize the sensor */
  2168. i2c_w_seq(gspca_dev, sensor_init[sd->sensor]);
  2169. reg_w1(gspca_dev, 0x15, sn9c1xx[0x15]);
  2170. reg_w1(gspca_dev, 0x16, sn9c1xx[0x16]);
  2171. reg_w1(gspca_dev, 0x12, sn9c1xx[0x12]);
  2172. reg_w1(gspca_dev, 0x13, sn9c1xx[0x13]);
  2173. reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
  2174. if (sd->sensor == SENSOR_ADCM1700) {
  2175. reg_w1(gspca_dev, 0xd2, 0x3a); /* AE_H_SIZE = 116 */
  2176. reg_w1(gspca_dev, 0xd3, 0x30); /* AE_V_SIZE = 96 */
  2177. } else {
  2178. reg_w1(gspca_dev, 0xd2, 0x6a); /* AE_H_SIZE = 212 */
  2179. reg_w1(gspca_dev, 0xd3, 0x50); /* AE_V_SIZE = 160 */
  2180. }
  2181. reg_w1(gspca_dev, 0xc6, 0x00);
  2182. reg_w1(gspca_dev, 0xc7, 0x00);
  2183. if (sd->sensor == SENSOR_ADCM1700) {
  2184. reg_w1(gspca_dev, 0xc8, 0x2c); /* AW_H_STOP = 352 */
  2185. reg_w1(gspca_dev, 0xc9, 0x24); /* AW_V_STOP = 288 */
  2186. } else {
  2187. reg_w1(gspca_dev, 0xc8, 0x50); /* AW_H_STOP = 640 */
  2188. reg_w1(gspca_dev, 0xc9, 0x3c); /* AW_V_STOP = 480 */
  2189. }
  2190. reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
  2191. switch (sd->sensor) {
  2192. case SENSOR_GC0307:
  2193. reg17 = 0xa2;
  2194. break;
  2195. case SENSOR_MT9V111:
  2196. reg17 = 0xe0;
  2197. break;
  2198. case SENSOR_ADCM1700:
  2199. case SENSOR_OV7630:
  2200. reg17 = 0xe2;
  2201. break;
  2202. case SENSOR_OV7648:
  2203. reg17 = 0x20;
  2204. break;
  2205. case SENSOR_OV7660:
  2206. case SENSOR_SOI768:
  2207. reg17 = 0xa0;
  2208. break;
  2209. case SENSOR_PO1030:
  2210. case SENSOR_PO2030N:
  2211. reg17 = 0xa0;
  2212. break;
  2213. default:
  2214. reg17 = 0x60;
  2215. break;
  2216. }
  2217. reg_w1(gspca_dev, 0x17, reg17);
  2218. reg_w1(gspca_dev, 0x05, 0x00); /* red */
  2219. reg_w1(gspca_dev, 0x07, 0x00); /* green */
  2220. reg_w1(gspca_dev, 0x06, 0x00); /* blue */
  2221. reg_w1(gspca_dev, 0x14, sn9c1xx[0x14]);
  2222. setgamma(gspca_dev);
  2223. /*fixme: 8 times with all zeroes and 1 or 2 times with normal values */
  2224. for (i = 0; i < 8; i++)
  2225. reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
  2226. switch (sd->sensor) {
  2227. case SENSOR_ADCM1700:
  2228. case SENSOR_OV7660:
  2229. case SENSOR_SP80708:
  2230. reg_w1(gspca_dev, 0x9a, 0x05);
  2231. break;
  2232. case SENSOR_GC0307:
  2233. case SENSOR_MT9V111:
  2234. reg_w1(gspca_dev, 0x9a, 0x07);
  2235. break;
  2236. case SENSOR_OV7630:
  2237. case SENSOR_OV7648:
  2238. reg_w1(gspca_dev, 0x9a, 0x0a);
  2239. break;
  2240. case SENSOR_PO2030N:
  2241. case SENSOR_SOI768:
  2242. reg_w1(gspca_dev, 0x9a, 0x06);
  2243. break;
  2244. default:
  2245. reg_w1(gspca_dev, 0x9a, 0x08);
  2246. break;
  2247. }
  2248. setsharpness(sd);
  2249. reg_w(gspca_dev, 0x84, reg84, sizeof reg84);
  2250. reg_w1(gspca_dev, 0x05, 0x20); /* red */
  2251. reg_w1(gspca_dev, 0x07, 0x20); /* green */
  2252. reg_w1(gspca_dev, 0x06, 0x20); /* blue */
  2253. init = NULL;
  2254. mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
  2255. if (mode)
  2256. reg1 = 0x46; /* 320x240: clk 48Mhz, video trf enable */
  2257. else
  2258. reg1 = 0x06; /* 640x480: clk 24Mhz, video trf enable */
  2259. reg17 = 0x61; /* 0x:20: enable sensor clock */
  2260. switch (sd->sensor) {
  2261. case SENSOR_ADCM1700:
  2262. init = adcm1700_sensor_param1;
  2263. reg1 = 0x46;
  2264. reg17 = 0xe2;
  2265. break;
  2266. case SENSOR_GC0307:
  2267. init = gc0307_sensor_param1;
  2268. reg17 = 0xa2;
  2269. reg1 = 0x44;
  2270. break;
  2271. case SENSOR_MO4000:
  2272. if (mode) {
  2273. /* reg1 = 0x46; * 320 clk 48Mhz 60fp/s */
  2274. reg1 = 0x06; /* clk 24Mz */
  2275. } else {
  2276. reg17 = 0x22; /* 640 MCKSIZE */
  2277. /* reg1 = 0x06; * 640 clk 24Mz (done) */
  2278. }
  2279. break;
  2280. case SENSOR_MT9V111:
  2281. init = mt9v111_sensor_param1;
  2282. if (mode) {
  2283. reg1 = 0x04; /* 320 clk 48Mhz */
  2284. } else {
  2285. /* reg1 = 0x06; * 640 clk 24Mz (done) */
  2286. reg17 = 0xc2;
  2287. }
  2288. break;
  2289. case SENSOR_OM6802:
  2290. init = om6802_sensor_param1;
  2291. reg17 = 0x64; /* 640 MCKSIZE */
  2292. break;
  2293. case SENSOR_OV7630:
  2294. init = ov7630_sensor_param1;
  2295. reg17 = 0xe2;
  2296. reg1 = 0x44;
  2297. break;
  2298. case SENSOR_OV7648:
  2299. init = ov7648_sensor_param1;
  2300. reg17 = 0x21;
  2301. /* reg1 = 0x42; * 42 - 46? */
  2302. break;
  2303. case SENSOR_OV7660:
  2304. init = ov7660_sensor_param1;
  2305. if (sd->bridge == BRIDGE_SN9C120) {
  2306. if (mode) { /* 320x240 - 160x120 */
  2307. reg17 = 0xa2;
  2308. reg1 = 0x44; /* 48 Mhz, video trf eneble */
  2309. }
  2310. } else {
  2311. reg17 = 0x22;
  2312. reg1 = 0x06; /* 24 Mhz, video trf eneble
  2313. * inverse power down */
  2314. }
  2315. break;
  2316. case SENSOR_PO1030:
  2317. init = po1030_sensor_param1;
  2318. reg17 = 0xa2;
  2319. reg1 = 0x44;
  2320. break;
  2321. case SENSOR_PO2030N:
  2322. init = po2030n_sensor_param1;
  2323. reg1 = 0x46;
  2324. reg17 = 0xa2;
  2325. break;
  2326. case SENSOR_SOI768:
  2327. init = soi768_sensor_param1;
  2328. reg1 = 0x44;
  2329. reg17 = 0xa2;
  2330. break;
  2331. default:
  2332. /* case SENSOR_SP80708: */
  2333. init = sp80708_sensor_param1;
  2334. if (mode) {
  2335. /*?? reg1 = 0x04; * 320 clk 48Mhz */
  2336. } else {
  2337. reg1 = 0x46; /* 640 clk 48Mz */
  2338. reg17 = 0xa2;
  2339. }
  2340. break;
  2341. }
  2342. /* more sensor initialization - param1 */
  2343. if (init != NULL) {
  2344. i2c_w_seq(gspca_dev, init);
  2345. /* init = NULL; */
  2346. }
  2347. reg_w(gspca_dev, 0xc0, C0, 6);
  2348. switch (sd->sensor) {
  2349. case SENSOR_ADCM1700:
  2350. case SENSOR_GC0307:
  2351. case SENSOR_SOI768:
  2352. reg_w(gspca_dev, 0xca, CA_adcm1700, 4);
  2353. break;
  2354. case SENSOR_PO2030N:
  2355. reg_w(gspca_dev, 0xca, CA_po2030n, 4);
  2356. break;
  2357. default:
  2358. reg_w(gspca_dev, 0xca, CA, 4);
  2359. break;
  2360. }
  2361. switch (sd->sensor) {
  2362. case SENSOR_ADCM1700:
  2363. case SENSOR_OV7630:
  2364. case SENSOR_OV7648:
  2365. case SENSOR_OV7660:
  2366. case SENSOR_SOI768:
  2367. reg_w(gspca_dev, 0xce, CE_ov76xx, 4);
  2368. break;
  2369. case SENSOR_GC0307:
  2370. reg_w(gspca_dev, 0xce, CE_gc0307, 4);
  2371. break;
  2372. case SENSOR_PO2030N:
  2373. reg_w(gspca_dev, 0xce, CE_po2030n, 4);
  2374. break;
  2375. default:
  2376. reg_w(gspca_dev, 0xce, CE, 4);
  2377. /* ?? {0x1e, 0xdd, 0x2d, 0xe7} */
  2378. break;
  2379. }
  2380. /* here change size mode 0 -> VGA; 1 -> CIF */
  2381. sd->reg18 = sn9c1xx[0x18] | (mode << 4) | 0x40;
  2382. reg_w1(gspca_dev, 0x18, sd->reg18);
  2383. setjpegqual(gspca_dev);
  2384. reg_w1(gspca_dev, 0x17, reg17);
  2385. reg_w1(gspca_dev, 0x01, reg1);
  2386. setvflip(sd);
  2387. setbrightness(gspca_dev);
  2388. setcontrast(gspca_dev);
  2389. setcolors(gspca_dev);
  2390. setautogain(gspca_dev);
  2391. setfreq(gspca_dev);
  2392. return 0;
  2393. }
  2394. static void sd_stopN(struct gspca_dev *gspca_dev)
  2395. {
  2396. struct sd *sd = (struct sd *) gspca_dev;
  2397. static const u8 stophv7131[] =
  2398. { 0xa1, 0x11, 0x02, 0x09, 0x00, 0x00, 0x00, 0x10 };
  2399. static const u8 stopmi0360[] =
  2400. { 0xb1, 0x5d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10 };
  2401. static const u8 stopov7648[] =
  2402. { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
  2403. static const u8 stopsoi768[] =
  2404. { 0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10 };
  2405. u8 data;
  2406. const u8 *sn9c1xx;
  2407. data = 0x0b;
  2408. switch (sd->sensor) {
  2409. case SENSOR_GC0307:
  2410. data = 0x29;
  2411. break;
  2412. case SENSOR_HV7131R:
  2413. i2c_w8(gspca_dev, stophv7131);
  2414. data = 0x2b;
  2415. break;
  2416. case SENSOR_MI0360:
  2417. i2c_w8(gspca_dev, stopmi0360);
  2418. data = 0x29;
  2419. break;
  2420. case SENSOR_OV7648:
  2421. i2c_w8(gspca_dev, stopov7648);
  2422. /* fall thru */
  2423. case SENSOR_MT9V111:
  2424. case SENSOR_OV7630:
  2425. case SENSOR_PO1030:
  2426. data = 0x29;
  2427. break;
  2428. case SENSOR_SOI768:
  2429. i2c_w8(gspca_dev, stopsoi768);
  2430. data = 0x29;
  2431. break;
  2432. }
  2433. sn9c1xx = sn_tb[sd->sensor];
  2434. reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
  2435. reg_w1(gspca_dev, 0x17, sn9c1xx[0x17]);
  2436. reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
  2437. reg_w1(gspca_dev, 0x01, data);
  2438. /* Don't disable sensor clock as that disables the button on the cam */
  2439. /* reg_w1(gspca_dev, 0xf1, 0x01); */
  2440. }
  2441. static void do_autogain(struct gspca_dev *gspca_dev)
  2442. {
  2443. struct sd *sd = (struct sd *) gspca_dev;
  2444. int delta;
  2445. int expotimes;
  2446. u8 luma_mean = 130;
  2447. u8 luma_delta = 20;
  2448. /* Thanks S., without your advice, autobright should not work :) */
  2449. if (sd->ag_cnt < 0)
  2450. return;
  2451. if (--sd->ag_cnt >= 0)
  2452. return;
  2453. sd->ag_cnt = AG_CNT_START;
  2454. delta = atomic_read(&sd->avg_lum);
  2455. PDEBUG(D_FRAM, "mean lum %d", delta);
  2456. if (delta < luma_mean - luma_delta ||
  2457. delta > luma_mean + luma_delta) {
  2458. switch (sd->sensor) {
  2459. case SENSOR_GC0307:
  2460. expotimes = sd->exposure;
  2461. expotimes += (luma_mean - delta) >> 6;
  2462. if (expotimes < 0)
  2463. expotimes = 0;
  2464. sd->exposure = setexposure(gspca_dev,
  2465. (unsigned int) expotimes);
  2466. break;
  2467. case SENSOR_HV7131R:
  2468. expotimes = sd->exposure >> 8;
  2469. expotimes += (luma_mean - delta) >> 4;
  2470. if (expotimes < 0)
  2471. expotimes = 0;
  2472. sd->exposure = setexposure(gspca_dev,
  2473. (unsigned int) (expotimes << 8));
  2474. break;
  2475. case SENSOR_OM6802:
  2476. expotimes = sd->exposure;
  2477. expotimes += (luma_mean - delta) >> 2;
  2478. if (expotimes < 0)
  2479. expotimes = 0;
  2480. sd->exposure = setexposure(gspca_dev,
  2481. (unsigned int) expotimes);
  2482. setredblue(gspca_dev);
  2483. break;
  2484. default:
  2485. /* case SENSOR_MO4000: */
  2486. /* case SENSOR_MI0360: */
  2487. /* case SENSOR_MT9V111: */
  2488. expotimes = sd->exposure;
  2489. expotimes += (luma_mean - delta) >> 6;
  2490. if (expotimes < 0)
  2491. expotimes = 0;
  2492. sd->exposure = setexposure(gspca_dev,
  2493. (unsigned int) expotimes);
  2494. setredblue(gspca_dev);
  2495. break;
  2496. }
  2497. }
  2498. }
  2499. /* scan the URB packets */
  2500. /* This function is run at interrupt level. */
  2501. static void sd_pkt_scan(struct gspca_dev *gspca_dev,
  2502. u8 *data, /* isoc packet */
  2503. int len) /* iso packet length */
  2504. {
  2505. struct sd *sd = (struct sd *) gspca_dev;
  2506. int sof, avg_lum;
  2507. sof = len - 64;
  2508. if (sof >= 0 && data[sof] == 0xff && data[sof + 1] == 0xd9) {
  2509. /* end of frame */
  2510. gspca_frame_add(gspca_dev, LAST_PACKET,
  2511. data, sof + 2);
  2512. if (sd->ag_cnt < 0)
  2513. return;
  2514. /* w1 w2 w3 */
  2515. /* w4 w5 w6 */
  2516. /* w7 w8 */
  2517. /* w4 */
  2518. avg_lum = ((data[sof + 29] << 8) | data[sof + 30]) >> 6;
  2519. /* w6 */
  2520. avg_lum += ((data[sof + 33] << 8) | data[sof + 34]) >> 6;
  2521. /* w2 */
  2522. avg_lum += ((data[sof + 25] << 8) | data[sof + 26]) >> 6;
  2523. /* w8 */
  2524. avg_lum += ((data[sof + 37] << 8) | data[sof + 38]) >> 6;
  2525. /* w5 */
  2526. avg_lum += ((data[sof + 31] << 8) | data[sof + 32]) >> 4;
  2527. avg_lum >>= 4;
  2528. atomic_set(&sd->avg_lum, avg_lum);
  2529. return;
  2530. }
  2531. if (gspca_dev->last_packet_type == LAST_PACKET) {
  2532. /* put the JPEG 422 header */
  2533. gspca_frame_add(gspca_dev, FIRST_PACKET,
  2534. sd->jpeg_hdr, JPEG_HDR_SZ);
  2535. }
  2536. gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
  2537. }
  2538. static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
  2539. {
  2540. struct sd *sd = (struct sd *) gspca_dev;
  2541. sd->brightness = val;
  2542. if (gspca_dev->streaming)
  2543. setbrightness(gspca_dev);
  2544. return 0;
  2545. }
  2546. static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
  2547. {
  2548. struct sd *sd = (struct sd *) gspca_dev;
  2549. *val = sd->brightness;
  2550. return 0;
  2551. }
  2552. static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
  2553. {
  2554. struct sd *sd = (struct sd *) gspca_dev;
  2555. sd->contrast = val;
  2556. if (gspca_dev->streaming)
  2557. setcontrast(gspca_dev);
  2558. return 0;
  2559. }
  2560. static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
  2561. {
  2562. struct sd *sd = (struct sd *) gspca_dev;
  2563. *val = sd->contrast;
  2564. return 0;
  2565. }
  2566. static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
  2567. {
  2568. struct sd *sd = (struct sd *) gspca_dev;
  2569. sd->colors = val;
  2570. if (gspca_dev->streaming)
  2571. setcolors(gspca_dev);
  2572. return 0;
  2573. }
  2574. static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
  2575. {
  2576. struct sd *sd = (struct sd *) gspca_dev;
  2577. *val = sd->colors;
  2578. return 0;
  2579. }
  2580. static int sd_setblue_balance(struct gspca_dev *gspca_dev, __s32 val)
  2581. {
  2582. struct sd *sd = (struct sd *) gspca_dev;
  2583. sd->blue = val;
  2584. if (gspca_dev->streaming)
  2585. setredblue(gspca_dev);
  2586. return 0;
  2587. }
  2588. static int sd_getblue_balance(struct gspca_dev *gspca_dev, __s32 *val)
  2589. {
  2590. struct sd *sd = (struct sd *) gspca_dev;
  2591. *val = sd->blue;
  2592. return 0;
  2593. }
  2594. static int sd_setred_balance(struct gspca_dev *gspca_dev, __s32 val)
  2595. {
  2596. struct sd *sd = (struct sd *) gspca_dev;
  2597. sd->red = val;
  2598. if (gspca_dev->streaming)
  2599. setredblue(gspca_dev);
  2600. return 0;
  2601. }
  2602. static int sd_getred_balance(struct gspca_dev *gspca_dev, __s32 *val)
  2603. {
  2604. struct sd *sd = (struct sd *) gspca_dev;
  2605. *val = sd->red;
  2606. return 0;
  2607. }
  2608. static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
  2609. {
  2610. struct sd *sd = (struct sd *) gspca_dev;
  2611. sd->gamma = val;
  2612. if (gspca_dev->streaming)
  2613. setgamma(gspca_dev);
  2614. return 0;
  2615. }
  2616. static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
  2617. {
  2618. struct sd *sd = (struct sd *) gspca_dev;
  2619. *val = sd->gamma;
  2620. return 0;
  2621. }
  2622. static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
  2623. {
  2624. struct sd *sd = (struct sd *) gspca_dev;
  2625. sd->autogain = val;
  2626. if (gspca_dev->streaming)
  2627. setautogain(gspca_dev);
  2628. return 0;
  2629. }
  2630. static int sd_getautogain(struct gspca_dev *gspca_dev, __s32 *val)
  2631. {
  2632. struct sd *sd = (struct sd *) gspca_dev;
  2633. *val = sd->autogain;
  2634. return 0;
  2635. }
  2636. static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
  2637. {
  2638. struct sd *sd = (struct sd *) gspca_dev;
  2639. sd->sharpness = val;
  2640. if (gspca_dev->streaming)
  2641. setsharpness(sd);
  2642. return 0;
  2643. }
  2644. static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
  2645. {
  2646. struct sd *sd = (struct sd *) gspca_dev;
  2647. *val = sd->sharpness;
  2648. return 0;
  2649. }
  2650. static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
  2651. {
  2652. struct sd *sd = (struct sd *) gspca_dev;
  2653. sd->vflip = val;
  2654. if (gspca_dev->streaming)
  2655. setvflip(sd);
  2656. return 0;
  2657. }
  2658. static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
  2659. {
  2660. struct sd *sd = (struct sd *) gspca_dev;
  2661. *val = sd->vflip;
  2662. return 0;
  2663. }
  2664. static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val)
  2665. {
  2666. struct sd *sd = (struct sd *) gspca_dev;
  2667. sd->infrared = val;
  2668. if (gspca_dev->streaming)
  2669. setinfrared(sd);
  2670. return 0;
  2671. }
  2672. static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val)
  2673. {
  2674. struct sd *sd = (struct sd *) gspca_dev;
  2675. *val = sd->infrared;
  2676. return 0;
  2677. }
  2678. static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
  2679. {
  2680. struct sd *sd = (struct sd *) gspca_dev;
  2681. sd->freq = val;
  2682. if (gspca_dev->streaming)
  2683. setfreq(gspca_dev);
  2684. return 0;
  2685. }
  2686. static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
  2687. {
  2688. struct sd *sd = (struct sd *) gspca_dev;
  2689. *val = sd->freq;
  2690. return 0;
  2691. }
  2692. static int sd_set_jcomp(struct gspca_dev *gspca_dev,
  2693. struct v4l2_jpegcompression *jcomp)
  2694. {
  2695. struct sd *sd = (struct sd *) gspca_dev;
  2696. if (jcomp->quality < QUALITY_MIN)
  2697. sd->quality = QUALITY_MIN;
  2698. else if (jcomp->quality > QUALITY_MAX)
  2699. sd->quality = QUALITY_MAX;
  2700. else
  2701. sd->quality = jcomp->quality;
  2702. if (gspca_dev->streaming)
  2703. jpeg_set_qual(sd->jpeg_hdr, sd->quality);
  2704. return 0;
  2705. }
  2706. static int sd_get_jcomp(struct gspca_dev *gspca_dev,
  2707. struct v4l2_jpegcompression *jcomp)
  2708. {
  2709. struct sd *sd = (struct sd *) gspca_dev;
  2710. memset(jcomp, 0, sizeof *jcomp);
  2711. jcomp->quality = sd->quality;
  2712. jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
  2713. | V4L2_JPEG_MARKER_DQT;
  2714. return 0;
  2715. }
  2716. static int sd_querymenu(struct gspca_dev *gspca_dev,
  2717. struct v4l2_querymenu *menu)
  2718. {
  2719. switch (menu->id) {
  2720. case V4L2_CID_POWER_LINE_FREQUENCY:
  2721. switch (menu->index) {
  2722. case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
  2723. strcpy((char *) menu->name, "NoFliker");
  2724. return 0;
  2725. case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
  2726. strcpy((char *) menu->name, "50 Hz");
  2727. return 0;
  2728. case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
  2729. strcpy((char *) menu->name, "60 Hz");
  2730. return 0;
  2731. }
  2732. break;
  2733. }
  2734. return -EINVAL;
  2735. }
  2736. #ifdef CONFIG_INPUT
  2737. static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
  2738. u8 *data, /* interrupt packet data */
  2739. int len) /* interrupt packet length */
  2740. {
  2741. int ret = -EINVAL;
  2742. if (len == 1 && data[0] == 1) {
  2743. input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
  2744. input_sync(gspca_dev->input_dev);
  2745. input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
  2746. input_sync(gspca_dev->input_dev);
  2747. ret = 0;
  2748. }
  2749. return ret;
  2750. }
  2751. #endif
  2752. /* sub-driver description */
  2753. static const struct sd_desc sd_desc = {
  2754. .name = MODULE_NAME,
  2755. .ctrls = sd_ctrls,
  2756. .nctrls = ARRAY_SIZE(sd_ctrls),
  2757. .config = sd_config,
  2758. .init = sd_init,
  2759. .start = sd_start,
  2760. .stopN = sd_stopN,
  2761. .pkt_scan = sd_pkt_scan,
  2762. .dq_callback = do_autogain,
  2763. .get_jcomp = sd_get_jcomp,
  2764. .set_jcomp = sd_set_jcomp,
  2765. .querymenu = sd_querymenu,
  2766. #ifdef CONFIG_INPUT
  2767. .int_pkt_scan = sd_int_pkt_scan,
  2768. #endif
  2769. };
  2770. /* -- module initialisation -- */
  2771. #define BS(bridge, sensor) \
  2772. .driver_info = (BRIDGE_ ## bridge << 16) \
  2773. | SENSOR_ ## sensor
  2774. static const __devinitdata struct usb_device_id device_table[] = {
  2775. #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
  2776. {USB_DEVICE(0x0458, 0x7025), BS(SN9C120, MI0360)},
  2777. {USB_DEVICE(0x0458, 0x702e), BS(SN9C120, OV7660)},
  2778. #endif
  2779. {USB_DEVICE(0x045e, 0x00f5), BS(SN9C105, OV7660)},
  2780. {USB_DEVICE(0x045e, 0x00f7), BS(SN9C105, OV7660)},
  2781. {USB_DEVICE(0x0471, 0x0327), BS(SN9C105, MI0360)},
  2782. {USB_DEVICE(0x0471, 0x0328), BS(SN9C105, MI0360)},
  2783. {USB_DEVICE(0x0471, 0x0330), BS(SN9C105, MI0360)},
  2784. {USB_DEVICE(0x06f8, 0x3004), BS(SN9C105, OV7660)},
  2785. {USB_DEVICE(0x06f8, 0x3008), BS(SN9C105, OV7660)},
  2786. /* {USB_DEVICE(0x0c45, 0x603a), BS(SN9C102P, OV7648)}, */
  2787. {USB_DEVICE(0x0c45, 0x6040), BS(SN9C102P, HV7131R)},
  2788. /* {USB_DEVICE(0x0c45, 0x607a), BS(SN9C102P, OV7648)}, */
  2789. /* {USB_DEVICE(0x0c45, 0x607b), BS(SN9C102P, OV7660)}, */
  2790. {USB_DEVICE(0x0c45, 0x607c), BS(SN9C102P, HV7131R)},
  2791. /* {USB_DEVICE(0x0c45, 0x607e), BS(SN9C102P, OV7630)}, */
  2792. {USB_DEVICE(0x0c45, 0x60c0), BS(SN9C105, MI0360)},
  2793. /* {USB_DEVICE(0x0c45, 0x60c2), BS(SN9C105, P1030xC)}, */
  2794. /* {USB_DEVICE(0x0c45, 0x60c8), BS(SN9C105, OM6802)}, */
  2795. /* {USB_DEVICE(0x0c45, 0x60cc), BS(SN9C105, HV7131GP)}, */
  2796. {USB_DEVICE(0x0c45, 0x60ce), BS(SN9C105, SP80708)},
  2797. {USB_DEVICE(0x0c45, 0x60ec), BS(SN9C105, MO4000)},
  2798. /* {USB_DEVICE(0x0c45, 0x60ef), BS(SN9C105, ICM105C)}, */
  2799. /* {USB_DEVICE(0x0c45, 0x60fa), BS(SN9C105, OV7648)}, */
  2800. /* {USB_DEVICE(0x0c45, 0x60f2), BS(SN9C105, OV7660)}, */
  2801. {USB_DEVICE(0x0c45, 0x60fb), BS(SN9C105, OV7660)},
  2802. #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
  2803. {USB_DEVICE(0x0c45, 0x60fc), BS(SN9C105, HV7131R)},
  2804. {USB_DEVICE(0x0c45, 0x60fe), BS(SN9C105, OV7630)},
  2805. #endif
  2806. {USB_DEVICE(0x0c45, 0x6100), BS(SN9C120, MI0360)}, /*sn9c128*/
  2807. /* {USB_DEVICE(0x0c45, 0x6102), BS(SN9C120, PO2030N)}, * / GC0305*/
  2808. /* {USB_DEVICE(0x0c45, 0x6108), BS(SN9C120, OM6802)}, */
  2809. {USB_DEVICE(0x0c45, 0x610a), BS(SN9C120, OV7648)}, /*sn9c128*/
  2810. {USB_DEVICE(0x0c45, 0x610b), BS(SN9C120, OV7660)}, /*sn9c128*/
  2811. {USB_DEVICE(0x0c45, 0x610c), BS(SN9C120, HV7131R)}, /*sn9c128*/
  2812. {USB_DEVICE(0x0c45, 0x610e), BS(SN9C120, OV7630)}, /*sn9c128*/
  2813. /* {USB_DEVICE(0x0c45, 0x610f), BS(SN9C120, S5K53BEB)}, */
  2814. /* {USB_DEVICE(0x0c45, 0x6122), BS(SN9C110, ICM105C)}, */
  2815. /* {USB_DEVICE(0x0c45, 0x6123), BS(SN9C110, SanyoCCD)}, */
  2816. {USB_DEVICE(0x0c45, 0x6128), BS(SN9C120, OM6802)}, /*sn9c325?*/
  2817. /*bw600.inf:*/
  2818. {USB_DEVICE(0x0c45, 0x612a), BS(SN9C120, OV7648)}, /*sn9c325?*/
  2819. {USB_DEVICE(0x0c45, 0x612c), BS(SN9C110, MO4000)},
  2820. {USB_DEVICE(0x0c45, 0x612e), BS(SN9C110, OV7630)},
  2821. /* {USB_DEVICE(0x0c45, 0x612f), BS(SN9C110, ICM105C)}, */
  2822. #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
  2823. {USB_DEVICE(0x0c45, 0x6130), BS(SN9C120, MI0360)},
  2824. #endif
  2825. /* {USB_DEVICE(0x0c45, 0x6132), BS(SN9C120, OV7670)}, */
  2826. {USB_DEVICE(0x0c45, 0x6138), BS(SN9C120, MO4000)},
  2827. {USB_DEVICE(0x0c45, 0x613a), BS(SN9C120, OV7648)},
  2828. #if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
  2829. {USB_DEVICE(0x0c45, 0x613b), BS(SN9C120, OV7660)},
  2830. #endif
  2831. {USB_DEVICE(0x0c45, 0x613c), BS(SN9C120, HV7131R)},
  2832. {USB_DEVICE(0x0c45, 0x613e), BS(SN9C120, OV7630)},
  2833. {USB_DEVICE(0x0c45, 0x6142), BS(SN9C120, PO2030N)}, /*sn9c120b*/
  2834. /* or GC0305 / GC0307 */
  2835. {USB_DEVICE(0x0c45, 0x6143), BS(SN9C120, SP80708)}, /*sn9c120b*/
  2836. {USB_DEVICE(0x0c45, 0x6148), BS(SN9C120, OM6802)}, /*sn9c120b*/
  2837. {USB_DEVICE(0x0c45, 0x614a), BS(SN9C120, ADCM1700)}, /*sn9c120b*/
  2838. {}
  2839. };
  2840. MODULE_DEVICE_TABLE(usb, device_table);
  2841. /* -- device connect -- */
  2842. static int sd_probe(struct usb_interface *intf,
  2843. const struct usb_device_id *id)
  2844. {
  2845. return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
  2846. THIS_MODULE);
  2847. }
  2848. static struct usb_driver sd_driver = {
  2849. .name = MODULE_NAME,
  2850. .id_table = device_table,
  2851. .probe = sd_probe,
  2852. .disconnect = gspca_disconnect,
  2853. #ifdef CONFIG_PM
  2854. .suspend = gspca_suspend,
  2855. .resume = gspca_resume,
  2856. #endif
  2857. };
  2858. /* -- module insert / remove -- */
  2859. static int __init sd_mod_init(void)
  2860. {
  2861. int ret;
  2862. ret = usb_register(&sd_driver);
  2863. if (ret < 0)
  2864. return ret;
  2865. info("registered");
  2866. return 0;
  2867. }
  2868. static void __exit sd_mod_exit(void)
  2869. {
  2870. usb_deregister(&sd_driver);
  2871. info("deregistered");
  2872. }
  2873. module_init(sd_mod_init);
  2874. module_exit(sd_mod_exit);