ibmcam.c
上传用户:lgb322
上传日期:2013-02-24
资源大小:30529k
文件大小:119k
源码类别:

嵌入式Linux

开发平台:

Unix_Linux

  1. /*
  2.  * USB IBM C-It Video Camera driver
  3.  *
  4.  * Supports IBM C-It Video Camera.
  5.  *
  6.  * This driver is based on earlier work of:
  7.  *
  8.  * (C) Copyright 1999 Johannes Erdfelt
  9.  * (C) Copyright 1999 Randy Dunlap
  10.  *
  11.  * 5/24/00 Removed optional (and unnecessary) locking of the driver while
  12.  * the device remains plugged in. Corrected race conditions in ibmcam_open
  13.  * and ibmcam_probe() routines using this as a guideline:
  14.  *
  15.  * (2) The big kernel lock is automatically released when a process sleeps
  16.  *   in the kernel and is automatically reacquired on reschedule if the
  17.  *   process had the lock originally.  Any code that can be compiled as
  18.  *   a module and is entered with the big kernel lock held *MUST*
  19.  *   increment the use count to activate the indirect module protection
  20.  *   before doing anything that might sleep.
  21.  *
  22.  *   In practice, this means that all routines that live in modules and
  23.  *   are invoked under the big kernel lock should do MOD_INC_USE_COUNT
  24.  *   as their very first action.  And all failure paths from that
  25.  *   routine must do MOD_DEC_USE_COUNT before returning.
  26.  */
  27. #include <linux/kernel.h>
  28. #include <linux/sched.h>
  29. #include <linux/wrapper.h>
  30. #include <linux/module.h>
  31. #include <linux/init.h>
  32. #include "usbvideo.h"
  33. #define IBMCAM_VENDOR_ID 0x0545
  34. #define IBMCAM_PRODUCT_ID 0x8080
  35. #define NETCAM_PRODUCT_ID 0x8002 /* IBM NetCamera, close to model 2 */
  36. #define MAX_IBMCAM 4 /* How many devices we allow to connect */
  37. #define USES_IBMCAM_PUTPIXEL    0       /* 0=Fast/oops 1=Slow/secure */
  38. /* Header signatures */
  39. /* Model 1 header: 00 FF 00 xx */
  40. #define HDRSIG_MODEL1_128x96 0x06 /* U Y V Y ... */
  41. #define HDRSIG_MODEL1_176x144 0x0e /* U Y V Y ... */
  42. #define HDRSIG_MODEL1_352x288 0x00 /* V Y U Y ... */
  43. #define IBMCAM_MODEL_1 1 /* XVP-501, 3 interfaces, rev. 0.02 */
  44. #define IBMCAM_MODEL_2 2 /* KSX-X9903, 2 interfaces, rev. 3.0a */
  45. #define IBMCAM_MODEL_3 3 /* KSX-X9902, 2 interfaces, rev. 3.01 */
  46. #define IBMCAM_MODEL_4 4 /* IBM NetCamera, 0545/8002/3.0a */
  47. /* Video sizes supported */
  48. #define VIDEOSIZE_128x96 VIDEOSIZE(128, 96)
  49. #define VIDEOSIZE_176x144 VIDEOSIZE(176,144)
  50. #define VIDEOSIZE_352x288 VIDEOSIZE(352,288)
  51. #define VIDEOSIZE_320x240 VIDEOSIZE(320,240)
  52. #define VIDEOSIZE_352x240 VIDEOSIZE(352,240)
  53. #define VIDEOSIZE_640x480 VIDEOSIZE(640,480)
  54. #define VIDEOSIZE_160x120 VIDEOSIZE(160,120)
  55. /* Video sizes supported */
  56. enum {
  57. SIZE_128x96 = 0,
  58. SIZE_160x120,
  59. SIZE_176x144,
  60. SIZE_320x240,
  61. SIZE_352x240,
  62. SIZE_352x288,
  63. SIZE_640x480,
  64. /* Add/remove/rearrange items before this line */
  65. SIZE_LastItem
  66. };
  67. /*
  68.  * This structure lives in uvd_t->user field.
  69.  */
  70. typedef struct {
  71. int initialized; /* Had we already sent init sequence? */
  72. int camera_model; /* What type of IBM camera we got? */
  73. int has_hdr;
  74. } ibmcam_t;
  75. #define IBMCAM_T(uvd) ((ibmcam_t *)((uvd)->user_data))
  76. usbvideo_t *cams = NULL;
  77. static int debug = 0;
  78. static int flags = 0; /* FLAGS_DISPLAY_HINTS | FLAGS_OVERLAY_STATS; */
  79. static const int min_canvasWidth  = 8;
  80. static const int min_canvasHeight = 4;
  81. static int lighting = 1; /* Medium */
  82. #define SHARPNESS_MIN 0
  83. #define SHARPNESS_MAX 6
  84. static int sharpness = 4; /* Low noise, good details */
  85. #define FRAMERATE_MIN 0
  86. #define FRAMERATE_MAX 6
  87. static int framerate = -1;
  88. static int size = SIZE_352x288;
  89. /*
  90.  * Here we define several initialization variables. They may
  91.  * be used to automatically set color, hue, brightness and
  92.  * contrast to desired values. This is particularly useful in
  93.  * case of webcams (which have no controls and no on-screen
  94.  * output) and also when a client V4L software is used that
  95.  * does not have some of those controls. In any case it's
  96.  * good to have startup values as options.
  97.  *
  98.  * These values are all in [0..255] range. This simplifies
  99.  * operation. Note that actual values of V4L variables may
  100.  * be scaled up (as much as << 8). User can see that only
  101.  * on overlay output, however, or through a V4L client.
  102.  */
  103. static int init_brightness = 128;
  104. static int init_contrast = 192;
  105. static int init_color = 128;
  106. static int init_hue = 128;
  107. static int hue_correction = 128;
  108. /* Settings for camera model 2 */
  109. static int init_model2_rg2 = -1;
  110. static int init_model2_sat = -1;
  111. static int init_model2_yb = -1;
  112. /* 01.01.08 - Added for RCA video in support -LO */
  113. /* Settings for camera model 3 */
  114. static int init_model3_input = 0;
  115. MODULE_PARM(debug, "i");
  116. MODULE_PARM_DESC(debug, "Debug level: 0-9 (default=0)");
  117. MODULE_PARM(flags, "i");
  118. MODULE_PARM_DESC(flags, "Bitfield: 0=VIDIOCSYNC, 1=B/W, 2=show hints, 3=show stats, 4=test pattern, 5=separate frames, 6=clean frames");
  119. MODULE_PARM(framerate, "i");
  120. MODULE_PARM_DESC(framerate, "Framerate setting: 0=slowest, 6=fastest (default=2)");
  121. MODULE_PARM(lighting, "i");
  122. MODULE_PARM_DESC(lighting, "Photosensitivity: 0=bright, 1=medium (default), 2=low light");
  123. MODULE_PARM(sharpness, "i");
  124. MODULE_PARM_DESC(sharpness, "Model1 noise reduction: 0=smooth, 6=sharp (default=4)");
  125. MODULE_PARM(size, "i");
  126. MODULE_PARM_DESC(size, "Image size: 0=128x96 1=160x120 2=176x144 3=320x240 4=352x240 5=352x288 6=640x480  (default=5)");
  127. MODULE_PARM(init_brightness, "i");
  128. MODULE_PARM_DESC(init_brightness, "Brightness preconfiguration: 0-255 (default=128)");
  129. MODULE_PARM(init_contrast, "i");
  130. MODULE_PARM_DESC(init_contrast, "Contrast preconfiguration: 0-255 (default=192)");
  131. MODULE_PARM(init_color, "i");
  132. MODULE_PARM_DESC(init_color, "Color preconfiguration: 0-255 (default=128)");
  133. MODULE_PARM(init_hue, "i");
  134. MODULE_PARM_DESC(init_hue, "Hue preconfiguration: 0-255 (default=128)");
  135. MODULE_PARM(hue_correction, "i");
  136. MODULE_PARM_DESC(hue_correction, "YUV colorspace regulation: 0-255 (default=128)");
  137. MODULE_PARM(init_model2_rg2, "i");
  138. MODULE_PARM_DESC(init_model2_rg2, "Model2 preconfiguration: 0-255 (default=47)");
  139. MODULE_PARM(init_model2_sat, "i");
  140. MODULE_PARM_DESC(init_model2_sat, "Model2 preconfiguration: 0-255 (default=52)");
  141. MODULE_PARM(init_model2_yb, "i");
  142. MODULE_PARM_DESC(init_model2_yb, "Model2 preconfiguration: 0-255 (default=160)");
  143. /* 01.01.08 - Added for RCA video in support -LO */
  144. MODULE_PARM(init_model3_input, "i");
  145. MODULE_PARM_DESC(init_model3_input, "Model3 input: 0=CCD 1=RCA");
  146. MODULE_AUTHOR ("Dmitri");
  147. MODULE_DESCRIPTION ("IBM/Xirlink C-it USB Camera Driver for Linux (c) 2000");
  148. MODULE_LICENSE("GPL");
  149. /* Still mysterious i2c commands */
  150. static const unsigned short unknown_88 = 0x0088;
  151. static const unsigned short unknown_89 = 0x0089;
  152. static const unsigned short bright_3x[3] = { 0x0031, 0x0032, 0x0033 };
  153. static const unsigned short contrast_14 = 0x0014;
  154. static const unsigned short light_27 = 0x0027;
  155. static const unsigned short sharp_13 = 0x0013;
  156. /* i2c commands for Model 2 cameras */
  157. static const unsigned short mod2_brightness = 0x001a; /* $5b .. $ee; default=$5a */
  158. static const unsigned short mod2_set_framerate = 0x001c; /* 0 (fast).. $1F (slow) */
  159. static const unsigned short mod2_color_balance_rg2 = 0x001e; /* 0 (red) .. $7F (green) */
  160. static const unsigned short mod2_saturation = 0x0020; /* 0 (b/w) - $7F (full color) */
  161. static const unsigned short mod2_color_balance_yb = 0x0022; /* 0..$7F, $50 is about right */
  162. static const unsigned short mod2_hue = 0x0024; /* 0..$7F, $70 is about right */
  163. static const unsigned short mod2_sensitivity = 0x0028; /* 0 (min) .. $1F (max) */
  164. struct struct_initData {
  165. unsigned char req;
  166. unsigned short value;
  167. unsigned short index;
  168. };
  169. /*
  170.  * ibmcam_size_to_videosize()
  171.  *
  172.  * This procedure converts module option 'size' into the actual
  173.  * videosize_t that defines the image size in pixels. We need
  174.  * simplified 'size' because user wants a simple enumerated list
  175.  * of choices, not an infinite set of possibilities.
  176.  */
  177. static videosize_t ibmcam_size_to_videosize(int size)
  178. {
  179. videosize_t vs = VIDEOSIZE_352x288;
  180. RESTRICT_TO_RANGE(size, 0, (SIZE_LastItem-1));
  181. switch (size) {
  182. case SIZE_128x96:
  183. vs = VIDEOSIZE_128x96;
  184. break;
  185. case SIZE_160x120:
  186. vs = VIDEOSIZE_160x120;
  187. break;
  188. case SIZE_176x144:
  189. vs = VIDEOSIZE_176x144;
  190. break;
  191. case SIZE_320x240:
  192. vs = VIDEOSIZE_320x240;
  193. break;
  194. case SIZE_352x240:
  195. vs = VIDEOSIZE_352x240;
  196. break;
  197. case SIZE_352x288:
  198. vs = VIDEOSIZE_352x288;
  199. break;
  200. case SIZE_640x480:
  201. vs = VIDEOSIZE_640x480;
  202. break;
  203. default:
  204. err("size=%d. is not valid", size);
  205. break;
  206. }
  207. return vs;
  208. }
  209. /*
  210.  * ibmcam_find_header()
  211.  *
  212.  * Locate one of supported header markers in the queue.
  213.  * Once found, remove all preceding bytes AND the marker (4 bytes)
  214.  * from the data pump queue. Whatever follows must be video lines.
  215.  *
  216.  * History:
  217.  * 1/21/00  Created.
  218.  */
  219. static ParseState_t ibmcam_find_header(uvd_t *uvd) /* FIXME: Add frame here */
  220. {
  221. usbvideo_frame_t *frame;
  222. ibmcam_t *icam;
  223. if ((uvd->curframe) < 0 || (uvd->curframe >= USBVIDEO_NUMFRAMES)) {
  224. err("ibmcam_find_header: Illegal frame %d.", uvd->curframe);
  225. return scan_EndParse;
  226. }
  227. icam = IBMCAM_T(uvd);
  228. assert(icam != NULL);
  229. frame = &uvd->frame[uvd->curframe];
  230. icam->has_hdr = 0;
  231. switch (icam->camera_model) {
  232. case IBMCAM_MODEL_1:
  233. {
  234. const int marker_len = 4;
  235. while (RingQueue_GetLength(&uvd->dp) >= marker_len) {
  236. if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
  237.     (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xFF) &&
  238.     (RING_QUEUE_PEEK(&uvd->dp, 2) == 0x00))
  239. {
  240. #if 0 /* This code helps to detect new frame markers */
  241. info("Header sig: 00 FF 00 %02X", RING_QUEUE_PEEK(&uvd->dp, 3));
  242. #endif
  243. frame->header = RING_QUEUE_PEEK(&uvd->dp, 3);
  244. if ((frame->header == HDRSIG_MODEL1_128x96) ||
  245.     (frame->header == HDRSIG_MODEL1_176x144) ||
  246.     (frame->header == HDRSIG_MODEL1_352x288))
  247. {
  248. #if 0
  249. info("Header found.");
  250. #endif
  251. RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, marker_len);
  252. icam->has_hdr = 1;
  253. break;
  254. }
  255. }
  256. /* If we are still here then this doesn't look like a header */
  257. RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
  258. }
  259. break;
  260. }
  261. case IBMCAM_MODEL_2:
  262. case IBMCAM_MODEL_4:
  263. {
  264. int marker_len = 0;
  265. switch (uvd->videosize) {
  266. case VIDEOSIZE_176x144:
  267. marker_len = 10;
  268. break;
  269. default:
  270. marker_len = 2;
  271. break;
  272. }
  273. while (RingQueue_GetLength(&uvd->dp) >= marker_len) {
  274. if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
  275.     (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xFF))
  276. {
  277. #if 0
  278. info("Header found.");
  279. #endif
  280. RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, marker_len);
  281. icam->has_hdr = 1;
  282. frame->header = HDRSIG_MODEL1_176x144;
  283. break;
  284. }
  285. /* If we are still here then this doesn't look like a header */
  286. RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
  287. }
  288. break;
  289. }
  290. case IBMCAM_MODEL_3:
  291. { /*
  292.  * Headers: (one precedes every frame). nc=no compression,
  293.  * bq=best quality bf=best frame rate.
  294.  *
  295.  * 176x144: 00 FF 02 { 0A=nc CA=bq EA=bf }
  296.  * 320x240: 00 FF 02 { 08=nc 28=bq 68=bf }
  297.  * 640x480: 00 FF 03 { 08=nc 28=bq 68=bf }
  298.  *
  299.  * Bytes '00 FF' seem to indicate header. Other two bytes
  300.  * encode the frame type. This is a set of bit fields that
  301.  * encode image size, compression type etc. These fields
  302.  * do NOT contain frame number because all frames carry
  303.  * the same header.
  304.  */
  305. const int marker_len = 4;
  306. while (RingQueue_GetLength(&uvd->dp) >= marker_len) {
  307. if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
  308.     (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xFF) &&
  309.     (RING_QUEUE_PEEK(&uvd->dp, 2) != 0xFF))
  310. {
  311. /*
  312.  * Combine 2 bytes of frame type into one
  313.  * easy to use value
  314.  */
  315. unsigned long byte3, byte4;
  316. byte3 = RING_QUEUE_PEEK(&uvd->dp, 2);
  317. byte4 = RING_QUEUE_PEEK(&uvd->dp, 3);
  318. frame->header = (byte3 << 8) | byte4;
  319. #if 0
  320. info("Header found.");
  321. #endif
  322. RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, marker_len);
  323. icam->has_hdr = 1;
  324. break;
  325. }
  326. /* If we are still here then this doesn't look like a header */
  327. RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
  328. }
  329. break;
  330. }
  331. default:
  332. break;
  333. }
  334. if (!icam->has_hdr) {
  335. if (uvd->debug > 2)
  336. info("Skipping frame, no header");
  337. return scan_EndParse;
  338. }
  339. /* Header found */
  340. icam->has_hdr = 1;
  341. uvd->stats.header_count++;
  342. frame->scanstate = ScanState_Lines;
  343. frame->curline = 0;
  344. if (flags & FLAGS_FORCE_TESTPATTERN) {
  345. usbvideo_TestPattern(uvd, 1, 1);
  346. return scan_NextFrame;
  347. }
  348. return scan_Continue;
  349. }
  350. /*
  351.  * ibmcam_parse_lines()
  352.  *
  353.  * Parse one line (interlaced) from the buffer, put
  354.  * decoded RGB value into the current frame buffer
  355.  * and add the written number of bytes (RGB) to
  356.  * the *pcopylen.
  357.  *
  358.  * History:
  359.  * 21-Jan-2000 Created.
  360.  * 12-Oct-2000 Reworked to reflect interlaced nature of the data.
  361.  */
  362. static ParseState_t ibmcam_parse_lines(
  363. uvd_t *uvd,
  364. usbvideo_frame_t *frame,
  365. long *pcopylen)
  366. {
  367. unsigned char *f;
  368. ibmcam_t *icam;
  369. unsigned int len, scanLength, scanHeight, order_uv, order_yc;
  370. int v4l_linesize; /* V4L line offset */
  371. const int hue_corr  = (uvd->vpic.hue - 0x8000) >> 10; /* -32..+31 */
  372. const int hue2_corr = (hue_correction - 128) / 4; /* -32..+31 */
  373. const int ccm = 128; /* Color correction median - see below */
  374. int y, u, v, i, frame_done=0, color_corr;
  375. static unsigned char lineBuffer[640*3];
  376. unsigned const char *chromaLine, *lumaLine;
  377. assert(uvd != NULL);
  378. assert(frame != NULL);
  379. icam = IBMCAM_T(uvd);
  380. assert(icam != NULL);
  381. color_corr = (uvd->vpic.colour - 0x8000) >> 8; /* -128..+127 = -ccm..+(ccm-1)*/
  382. RESTRICT_TO_RANGE(color_corr, -ccm, ccm+1);
  383. v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
  384. if (IBMCAM_T(uvd)->camera_model == IBMCAM_MODEL_4) {
  385. /* Model 4 frame markers do not carry image size identification */
  386. switch (uvd->videosize) {
  387. case VIDEOSIZE_128x96:
  388. case VIDEOSIZE_160x120:
  389. case VIDEOSIZE_176x144:
  390. scanLength = VIDEOSIZE_X(uvd->videosize);
  391. scanHeight = VIDEOSIZE_Y(uvd->videosize);
  392. break;
  393. default:
  394. err("ibmcam_parse_lines: Wrong mode.");
  395. return scan_Out;
  396. }
  397. order_yc = 1; /* order_yc: true=Yc false=cY ('c'=either U or V) */
  398. order_uv = 1; /* Always true in this algorithm */
  399. } else {
  400. switch (frame->header) {
  401. case HDRSIG_MODEL1_128x96:
  402. scanLength = 128;
  403. scanHeight = 96;
  404. order_uv = 1; /* U Y V Y ... */
  405. break;
  406. case HDRSIG_MODEL1_176x144:
  407. scanLength = 176;
  408. scanHeight = 144;
  409. order_uv = 1; /* U Y V Y ... */
  410. break;
  411. case HDRSIG_MODEL1_352x288:
  412. scanLength = 352;
  413. scanHeight = 288;
  414. order_uv = 0; /* Y V Y V ... */
  415. break;
  416. default:
  417. err("Unknown header signature 00 FF 00 %02lX", frame->header);
  418. return scan_NextFrame;
  419. }
  420. /* order_yc: true=Yc false=cY ('c'=either U or V) */
  421. order_yc = (IBMCAM_T(uvd)->camera_model == IBMCAM_MODEL_2);
  422. }
  423. len = scanLength * 3;
  424. assert(len <= sizeof(lineBuffer));
  425. /*
  426.  * Lines are organized this way:
  427.  *
  428.  * I420:
  429.  * ~~~~
  430.  * <scanLength->
  431.  * ___________________________________
  432.  * |-----Y-----|---UVUVUV...UVUV-----| 
  433.  * |-----------+---------------------|  
  434.  * |<-- 176 -->|<------ 176*2 ------>|  Total 72. lines (interlaced)
  435.  * |...    ... |        ...          |  /
  436.  * |<-- 352 -->|<------ 352*2 ------>|  Total 144. lines (interlaced)
  437.  * |___________|_____________________| /
  438.  *             
  439.  *   lumaLine    chromaLine
  440.  */
  441. /* Make sure there's enough data for the entire line */
  442. if (RingQueue_GetLength(&uvd->dp) < len)
  443. return scan_Out;
  444. /* Suck one line out of the ring queue */
  445. RingQueue_Dequeue(&uvd->dp, lineBuffer, len);
  446. /*
  447.  * Make sure that our writing into output buffer
  448.  * will not exceed the buffer. Mind that we may write
  449.  * not into current output scanline but in several after
  450.  * it as well (if we enlarge image vertically.)
  451.  */
  452. if ((frame->curline + 2) >= VIDEOSIZE_Y(frame->request))
  453. return scan_NextFrame;
  454. /*
  455.  * Now we are sure that entire line (representing all 'scanLength'
  456.  * pixels from the camera) is available in the buffer. We
  457.  * start copying the line left-aligned to the V4L buffer.
  458.  * If the camera line is shorter then we should pad the V4L
  459.  * buffer with something (black) to complete the line.
  460.  */
  461. assert(frame->data != NULL);
  462. f = frame->data + (v4l_linesize * frame->curline);
  463. /*
  464.  * To obtain chrominance data from the 'chromaLine' use this:
  465.  *   v = chromaLine[0]; // 0-1:[0], 2-3:[4], 4-5:[8]...
  466.  *   u = chromaLine[2]; // 0-1:[2], 2-3:[6], 4-5:[10]...
  467.  *
  468.  * Indices must be calculated this way:
  469.  * v_index = (i >> 1) << 2;
  470.  * u_index = (i >> 1) << 2 + 2;
  471.  *
  472.  * where 'i' is the column number [0..VIDEOSIZE_X(frame->request)-1]
  473.  */
  474. lumaLine = lineBuffer;
  475. chromaLine = lineBuffer + scanLength;
  476. for (i = 0; i < VIDEOSIZE_X(frame->request); i++)
  477. {
  478. unsigned char rv, gv, bv; /* RGB components */
  479. /* Check for various visual debugging hints (colorized pixels) */
  480. if ((flags & FLAGS_DISPLAY_HINTS) && (icam->has_hdr)) {
  481. /*
  482.  * This is bad and should not happen. This means that
  483.  * we somehow overshoot the line and encountered new
  484.  * frame! Obviously our camera/V4L frame size is out
  485.  * of whack. This cyan dot will help you to figure
  486.  * out where exactly the new frame arrived.
  487.  */
  488. if (icam->has_hdr == 1) {
  489. bv = 0; /* Yellow marker */
  490. gv = 0xFF;
  491. rv = 0xFF;
  492. } else {
  493. bv = 0xFF; /* Cyan marker */
  494. gv = 0xFF;
  495. rv = 0;
  496. }
  497. icam->has_hdr = 0;
  498. goto make_pixel;
  499. }
  500. /*
  501.  * Check if we are still in range. We may be out of range if our
  502.  * V4L canvas is wider or taller than the camera "native" image.
  503.  * Then we quickly fill the remainder of the line with zeros to
  504.  * make black color and quit the horizontal scanning loop.
  505.  */
  506. if (((frame->curline + 2) >= scanHeight) || (i >= scanLength)) {
  507. const int j = i * V4L_BYTES_PER_PIXEL;
  508. #if USES_IBMCAM_PUTPIXEL
  509. /* Refresh 'f' because we don't use it much with PUTPIXEL */
  510. f = frame->data + (v4l_linesize * frame->curline) + j;
  511. #endif
  512. memset(f, 0, v4l_linesize - j);
  513. break;
  514. }
  515. y = lumaLine[i];
  516. if (flags & FLAGS_MONOCHROME) /* Use monochrome for debugging */
  517. rv = gv = bv = y;
  518. else {
  519. int off_0, off_2;
  520. off_0 = (i >> 1) << 2;
  521. off_2 = off_0 + 2;
  522. if (order_yc) {
  523. off_0++;
  524. off_2++;
  525. }
  526. if (!order_uv) {
  527. off_0 += 2;
  528. off_2 -= 2;
  529. }
  530. u = chromaLine[off_0] + hue_corr;
  531. v = chromaLine[off_2] + hue2_corr;
  532. /* Apply color correction */
  533. if (color_corr != 0) {
  534. /* Magnify up to 2 times, reduce down to zero saturation */
  535. u = 128 + ((ccm + color_corr) * (u - 128)) / ccm;
  536. v = 128 + ((ccm + color_corr) * (v - 128)) / ccm;
  537. }
  538. YUV_TO_RGB_BY_THE_BOOK(y, u, v, rv, gv, bv);
  539. }
  540. make_pixel:
  541. /*
  542.  * The purpose of creating the pixel here, in one,
  543.  * dedicated place is that we may need to make the
  544.  * pixel wider and taller than it actually is. This
  545.  * may be used if camera generates small frames for
  546.  * sake of frame rate (or any other reason.)
  547.  *
  548.  * The output data consists of B, G, R bytes
  549.  * (in this order).
  550.  */
  551. #if USES_IBMCAM_PUTPIXEL
  552. RGB24_PUTPIXEL(frame, i, frame->curline, rv, gv, bv);
  553. #else
  554. *f++ = bv;
  555. *f++ = gv;
  556. *f++ = rv;
  557. #endif
  558. /*
  559.  * Typically we do not decide within a legitimate frame
  560.  * that we want to end the frame. However debugging code
  561.  * may detect marker of new frame within the data. Then
  562.  * this condition activates. The 'data' pointer is already
  563.  * pointing at the new marker, so we'd better leave it as is.
  564.  */
  565. if (frame_done)
  566. break; /* End scanning of lines */
  567. }
  568. /*
  569.  * Account for number of bytes that we wrote into output V4L frame.
  570.  * We do it here, after we are done with the scanline, because we
  571.  * may fill more than one output scanline if we do vertical
  572.  * enlargement.
  573.  */
  574. frame->curline += 2;
  575. if (pcopylen != NULL)
  576. *pcopylen += 2 * v4l_linesize;
  577. frame->deinterlace = Deinterlace_FillOddLines;
  578. if (frame_done || (frame->curline >= VIDEOSIZE_Y(frame->request)))
  579. return scan_NextFrame;
  580. else
  581. return scan_Continue;
  582. }
  583. /*
  584.  * ibmcam_model2_320x240_parse_lines()
  585.  *
  586.  * This procedure deals with a weird RGB format that is produced by IBM
  587.  * camera model 2 in modes 320x240 and above; 'x' below is 159 or 175,
  588.  * depending on horizontal size of the picture:
  589.  *
  590.  * <--- 160 or 176 pairs of RA,RB bytes ----->
  591.  * *-----------------------------------------* 
  592.  * | RA0 | RB0 | RA1 | RB1 | ... | RAx | RBx |     This is pair of horizontal lines,
  593.  * |-----+-----+-----+-----+ ... +-----+-----|   *- or one interlaced line, total
  594.  * | B0  | G0  | B1  | G1  | ... | Bx  | Gx  |  /   120 or 144 such pairs which yield
  595.  * |=====+=====+=====+=====+ ... +=====+=====| /    240 or 288 lines after deinterlacing.
  596.  *
  597.  * Each group of FOUR bytes (RAi, RBi, Bi, Gi) where i=0..frame_width/2-1
  598.  * defines ONE pixel. Therefore this format yields 176x144 "decoded"
  599.  * resolution at best. I do not know why camera sends such format - the
  600.  * previous model (1) just used interlaced I420 and everyone was happy.
  601.  *
  602.  * I do not know what is the difference between RAi and RBi bytes. Both
  603.  * seemingly represent R component, but slightly vary in value (so that
  604.  * the picture looks a bit colored if one or another is used). I use
  605.  * them both as R component in attempt to at least partially recover the
  606.  * lost resolution.
  607.  */
  608. static ParseState_t ibmcam_model2_320x240_parse_lines(
  609. uvd_t *uvd,
  610. usbvideo_frame_t *frame,
  611. long *pcopylen)
  612. {
  613. unsigned char *f, *la, *lb;
  614. unsigned int len;
  615. int v4l_linesize; /* V4L line offset */
  616. int i, j, frame_done=0, color_corr;
  617. int scanLength, scanHeight;
  618. static unsigned char lineBuffer[352*2];
  619. switch (uvd->videosize) {
  620. case VIDEOSIZE_320x240:
  621. case VIDEOSIZE_352x240:
  622. case VIDEOSIZE_352x288:
  623. scanLength = VIDEOSIZE_X(uvd->videosize);
  624. scanHeight = VIDEOSIZE_Y(uvd->videosize);
  625. break;
  626. default:
  627. err("ibmcam_model2_320x240_parse_lines: Wrong mode.");
  628. return scan_Out;
  629. }
  630. color_corr = (uvd->vpic.colour) >> 8; /* 0..+255 */
  631. v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
  632. len = scanLength * 2; /* See explanation above */
  633. assert(len <= sizeof(lineBuffer));
  634. /* Make sure there's enough data for the entire line */
  635. if (RingQueue_GetLength(&uvd->dp) < len)
  636. return scan_Out;
  637. /* Suck one line out of the ring queue */
  638. RingQueue_Dequeue(&uvd->dp, lineBuffer, len);
  639. /*
  640.  * Make sure that our writing into output buffer
  641.  * will not exceed the buffer. Mind that we may write
  642.  * not into current output scanline but in several after
  643.  * it as well (if we enlarge image vertically.)
  644.  */
  645. if ((frame->curline + 2) >= VIDEOSIZE_Y(frame->request))
  646. return scan_NextFrame;
  647. la = lineBuffer;
  648. lb = lineBuffer + scanLength;
  649. /*
  650.  * Now we are sure that entire line (representing all
  651.  *         VIDEOSIZE_X(frame->request)
  652.  * pixels from the camera) is available in the scratch buffer. We
  653.  * start copying the line left-aligned to the V4L buffer (which
  654.  * might be larger - not smaller, hopefully). If the camera
  655.  * line is shorter then we should pad the V4L buffer with something
  656.  * (black in this case) to complete the line.
  657.  */
  658. f = frame->data + (v4l_linesize * frame->curline);
  659. /* Fill the 2-line strip */
  660. for (i = 0; i < VIDEOSIZE_X(frame->request); i++) {
  661. int y, rv, gv, bv; /* RGB components */
  662. j = i & (~1);
  663. /* Check for various visual debugging hints (colorized pixels) */
  664. if ((flags & FLAGS_DISPLAY_HINTS) && (IBMCAM_T(uvd)->has_hdr)) {
  665. if (IBMCAM_T(uvd)->has_hdr == 1) {
  666. bv = 0; /* Yellow marker */
  667. gv = 0xFF;
  668. rv = 0xFF;
  669. } else {
  670. bv = 0xFF; /* Cyan marker */
  671. gv = 0xFF;
  672. rv = 0;
  673. }
  674. IBMCAM_T(uvd)->has_hdr = 0;
  675. goto make_pixel;
  676. }
  677. /*
  678.  * Check if we are still in range. We may be out of range if our
  679.  * V4L canvas is wider or taller than the camera "native" image.
  680.  * Then we quickly fill the remainder of the line with zeros to
  681.  * make black color and quit the horizontal scanning loop.
  682.  */
  683. if (((frame->curline + 2) >= scanHeight) || (i >= scanLength)) {
  684. const int j = i * V4L_BYTES_PER_PIXEL;
  685. #if USES_IBMCAM_PUTPIXEL
  686. /* Refresh 'f' because we don't use it much with PUTPIXEL */
  687. f = frame->data + (v4l_linesize * frame->curline) + j;
  688. #endif
  689. memset(f, 0, v4l_linesize - j);
  690. break;
  691. }
  692. /*
  693.  * Here I use RA and RB components, one per physical pixel.
  694.  * This causes fine vertical grid on the picture but may improve
  695.  * horizontal resolution. If you prefer replicating, use this:
  696.  *   rv = la[j + 0];   ... or ... rv = la[j + 1];
  697.  * then the pixel will be replicated.
  698.  */
  699. rv = la[i];
  700. gv = lb[j + 1];
  701. bv = lb[j + 0];
  702. y = (rv + gv + bv) / 3; /* Brightness (badly calculated) */
  703. if (flags & FLAGS_MONOCHROME) /* Use monochrome for debugging */
  704. rv = gv = bv = y;
  705. else if (color_corr != 128) {
  706. /* Calculate difference between color and brightness */
  707. rv -= y;
  708. gv -= y;
  709. bv -= y;
  710. /* Scale differences */
  711. rv = (rv * color_corr) / 128;
  712. gv = (gv * color_corr) / 128;
  713. bv = (bv * color_corr) / 128;
  714. /* Reapply brightness */
  715. rv += y;
  716. gv += y;
  717. bv += y;
  718. /* Watch for overflows */
  719. RESTRICT_TO_RANGE(rv, 0, 255);
  720. RESTRICT_TO_RANGE(gv, 0, 255);
  721. RESTRICT_TO_RANGE(bv, 0, 255);
  722. }
  723. make_pixel:
  724. RGB24_PUTPIXEL(frame, i, frame->curline, rv, gv, bv);
  725. }
  726. /*
  727.  * Account for number of bytes that we wrote into output V4L frame.
  728.  * We do it here, after we are done with the scanline, because we
  729.  * may fill more than one output scanline if we do vertical
  730.  * enlargement.
  731.  */
  732. frame->curline += 2;
  733. *pcopylen += v4l_linesize * 2;
  734. frame->deinterlace = Deinterlace_FillOddLines;
  735. if (frame_done || (frame->curline >= VIDEOSIZE_Y(frame->request)))
  736. return scan_NextFrame;
  737. else
  738. return scan_Continue;
  739. }
  740. static ParseState_t ibmcam_model3_parse_lines(
  741. uvd_t *uvd,
  742. usbvideo_frame_t *frame,
  743. long *pcopylen)
  744. {
  745. unsigned char *data;
  746. const unsigned char *color;
  747. unsigned int len;
  748. int v4l_linesize; /* V4L line offset */
  749. const int hue_corr  = (uvd->vpic.hue - 0x8000) >> 10; /* -32..+31 */
  750. const int hue2_corr = (hue_correction - 128) / 4; /* -32..+31 */
  751. const int ccm = 128; /* Color correction median - see below */
  752. int i, u, v, rw, data_w=0, data_h=0, color_corr;
  753. static unsigned char lineBuffer[640*3];
  754. color_corr = (uvd->vpic.colour - 0x8000) >> 8; /* -128..+127 = -ccm..+(ccm-1)*/
  755. RESTRICT_TO_RANGE(color_corr, -ccm, ccm+1);
  756. v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
  757. /* The header tells us what sort of data is in this frame */
  758. switch (frame->header) {
  759. /*
  760.  * Uncompressed modes (that are easy to decode).
  761.  */
  762. case 0x0308:
  763. data_w = 640;
  764. data_h = 480;
  765. break;
  766. case 0x0208:
  767. data_w = 320;
  768. data_h = 240;
  769. break;
  770. case 0x020A:
  771. data_w = 160;
  772. data_h = 120;
  773. break;
  774. /*
  775.  * Compressed modes (ViCE - that I don't know how to decode).
  776.  */
  777. case 0x0328: /* 640x480, best quality compression */
  778. case 0x0368: /* 640x480, best frame rate compression */
  779. case 0x0228: /* 320x240, best quality compression */
  780. case 0x0268: /* 320x240, best frame rate compression */
  781. case 0x02CA: /* 160x120, best quality compression */
  782. case 0x02EA: /* 160x120, best frame rate compression */
  783. /* Do nothing with this - not supported */
  784. err("Unsupported mode $%04lx", frame->header);
  785. return scan_NextFrame;
  786. default:
  787. /* Catch unknown headers, may help in learning new headers */
  788. err("Strange frame->header=$%08lx", frame->header);
  789. return scan_NextFrame;
  790. }
  791. /*
  792.  * Make sure that our writing into output buffer
  793.  * will not exceed the buffer. Note that we may write
  794.  * not into current output scanline but in several after
  795.  * it as well (if we enlarge image vertically.)
  796.  */
  797. if ((frame->curline + 1) >= data_h) {
  798. if (uvd->debug >= 3)
  799. info("Reached line %d. (frame is done)", frame->curline);
  800. return scan_NextFrame;
  801. }
  802. /* Make sure there's enough data for the entire line */
  803. len = 3 * data_w; /* <y-data> <uv-data> */
  804. assert(len <= sizeof(lineBuffer));
  805. /* Make sure there's enough data for the entire line */
  806. if (RingQueue_GetLength(&uvd->dp) < len)
  807. return scan_Out;
  808. /* Suck one line out of the ring queue */
  809. RingQueue_Dequeue(&uvd->dp, lineBuffer, len);
  810. data = lineBuffer;
  811. color = data + data_w; /* Point to where color planes begin */
  812. /* Bottom-to-top scanning */
  813. rw = (int)VIDEOSIZE_Y(frame->request) - (int)(frame->curline) - 1;
  814. RESTRICT_TO_RANGE(rw, 0, VIDEOSIZE_Y(frame->request)-1);
  815. for (i = 0; i < VIDEOSIZE_X(frame->request); i++) {
  816. int y, rv, gv, bv; /* RGB components */
  817. if (i < data_w) {
  818. y = data[i]; /* Luminosity is the first line */
  819. /* Apply static color correction */
  820. u = color[i*2] + hue_corr;
  821. v = color[i*2 + 1] + hue2_corr;
  822. /* Apply color correction */
  823. if (color_corr != 0) {
  824. /* Magnify up to 2 times, reduce down to zero saturation */
  825. u = 128 + ((ccm + color_corr) * (u - 128)) / ccm;
  826. v = 128 + ((ccm + color_corr) * (v - 128)) / ccm;
  827. }
  828. } else
  829. y = 0, u = v = 128;
  830. YUV_TO_RGB_BY_THE_BOOK(y, u, v, rv, gv, bv);
  831. RGB24_PUTPIXEL(frame, i, rw, rv, gv, bv); /* Done by deinterlacing now */
  832. }
  833. frame->deinterlace = Deinterlace_FillEvenLines;
  834. /*
  835.  * Account for number of bytes that we wrote into output V4L frame.
  836.  * We do it here, after we are done with the scanline, because we
  837.  * may fill more than one output scanline if we do vertical
  838.  * enlargement.
  839.  */
  840. frame->curline += 2;
  841. *pcopylen += 2 * v4l_linesize;
  842. if (frame->curline >= VIDEOSIZE_Y(frame->request)) {
  843. if (uvd->debug >= 3) {
  844. info("All requested lines (%ld.) done.",
  845.      VIDEOSIZE_Y(frame->request));
  846. }
  847. return scan_NextFrame;
  848. } else
  849. return scan_Continue;
  850. }
  851. /*
  852.  * ibmcam_model4_128x96_parse_lines()
  853.  *
  854.  * This decoder is for one strange data format that is produced by Model 4
  855.  * camera only in 128x96 mode. This is RGB format and here is its description.
  856.  * First of all, this is non-interlaced stream, meaning that all scan lines
  857.  * are present in the datastream. There are 96 consecutive blocks of data
  858.  * that describe all 96 lines of the image. Each block is 5*128 bytes long
  859.  * and carries R, G, B components. The format of the block is shown in the
  860.  * code below. First 128*2 bytes are interleaved R and G components. Then
  861.  * we have a gap (junk data) 64 bytes long. Then follow B and something
  862.  * else, also interleaved (this makes another 128*2 bytes). After that
  863.  * probably another 64 bytes of junk follow.
  864.  *
  865.  * History:
  866.  * 10-Feb-2001 Created.
  867.  */
  868. static ParseState_t ibmcam_model4_128x96_parse_lines(
  869. uvd_t *uvd,
  870. usbvideo_frame_t *frame,
  871. long *pcopylen)
  872. {
  873. const unsigned char *data_rv, *data_gv, *data_bv;
  874. unsigned int len;
  875. int i, v4l_linesize; /* V4L line offset */
  876. const int data_w=128, data_h=96;
  877. static unsigned char lineBuffer[128*5];
  878. v4l_linesize = VIDEOSIZE_X(frame->request) * V4L_BYTES_PER_PIXEL;
  879. /*
  880.  * Make sure that our writing into output buffer
  881.  * will not exceed the buffer. Note that we may write
  882.  * not into current output scanline but in several after
  883.  * it as well (if we enlarge image vertically.)
  884.  */
  885. if ((frame->curline + 1) >= data_h) {
  886. if (uvd->debug >= 3)
  887. info("Reached line %d. (frame is done)", frame->curline);
  888. return scan_NextFrame;
  889. }
  890. /*
  891.  * RGRGRG .... RGRG_____________B?B?B? ... B?B?____________
  892.  * <---- 128*2 ---><---- 64 ---><--- 128*2 ---><--- 64 --->
  893.  */
  894. /* Make sure there's enough data for the entire line */
  895. len = 5 * data_w;
  896. assert(len <= sizeof(lineBuffer));
  897. /* Make sure there's enough data for the entire line */
  898. if (RingQueue_GetLength(&uvd->dp) < len)
  899. return scan_Out;
  900. /* Suck one line out of the ring queue */
  901. RingQueue_Dequeue(&uvd->dp, lineBuffer, len);
  902. data_rv = lineBuffer;
  903. data_gv = lineBuffer + 1;
  904. data_bv = lineBuffer + data_w*2 + data_w/2;
  905. for (i = 0; i < VIDEOSIZE_X(frame->request); i++) {
  906. int rv, gv, bv; /* RGB components */
  907. if (i < data_w) {
  908. const int j = i * 2;
  909. gv = data_rv[j];
  910. rv = data_gv[j];
  911. bv = data_bv[j];
  912. if (flags & FLAGS_MONOCHROME) {
  913. unsigned long y;
  914. y = rv + gv + bv;
  915. y /= 3;
  916. if (y > 0xFF)
  917. y = 0xFF;
  918. rv = gv = bv = (unsigned char) y;
  919. }
  920. } else {
  921. rv = gv = bv = 0;
  922. }
  923. RGB24_PUTPIXEL(frame, i, frame->curline, rv, gv, bv);
  924. }
  925. frame->deinterlace = Deinterlace_None;
  926. frame->curline++;
  927. *pcopylen += v4l_linesize;
  928. if (frame->curline >= VIDEOSIZE_Y(frame->request)) {
  929. if (uvd->debug >= 3) {
  930. info("All requested lines (%ld.) done.",
  931.      VIDEOSIZE_Y(frame->request));
  932. }
  933. return scan_NextFrame;
  934. } else
  935. return scan_Continue;
  936. }
  937. /*
  938.  * ibmcam_ProcessIsocData()
  939.  *
  940.  * Generic routine to parse the ring queue data. It employs either
  941.  * ibmcam_find_header() or ibmcam_parse_lines() to do most
  942.  * of work.
  943.  *
  944.  * History:
  945.  * 1/21/00  Created.
  946.  */
  947. void ibmcam_ProcessIsocData(uvd_t *uvd, usbvideo_frame_t *frame)
  948. {
  949. ParseState_t newstate;
  950. long copylen = 0;
  951. int mod = IBMCAM_T(uvd)->camera_model;
  952. while (1) {
  953. newstate = scan_Out;
  954. if (RingQueue_GetLength(&uvd->dp) > 0) {
  955. if (frame->scanstate == ScanState_Scanning) {
  956. newstate = ibmcam_find_header(uvd);
  957. } else if (frame->scanstate == ScanState_Lines) {
  958. if ((mod == IBMCAM_MODEL_2) &&
  959.     ((uvd->videosize == VIDEOSIZE_352x288) ||
  960.      (uvd->videosize == VIDEOSIZE_320x240) ||
  961.      (uvd->videosize == VIDEOSIZE_352x240)))
  962. {
  963. newstate = ibmcam_model2_320x240_parse_lines(
  964. uvd, frame, &copylen);
  965. } else if (mod == IBMCAM_MODEL_4) {
  966. /*
  967.  * Model 4 cameras (IBM NetCamera) use Model 2 decoder (RGB)
  968.  * for 320x240 and above; 160x120 and 176x144 uses Model 1
  969.  * decoder (YUV), and 128x96 mode uses ???
  970.  */
  971. if ((uvd->videosize == VIDEOSIZE_352x288) ||
  972.     (uvd->videosize == VIDEOSIZE_320x240) ||
  973.     (uvd->videosize == VIDEOSIZE_352x240))
  974. {
  975. newstate = ibmcam_model2_320x240_parse_lines(uvd, frame, &copylen);
  976. } else if (uvd->videosize == VIDEOSIZE_128x96) {
  977. newstate = ibmcam_model4_128x96_parse_lines(uvd, frame, &copylen);
  978. } else {
  979. newstate = ibmcam_parse_lines(uvd, frame, &copylen);
  980. }
  981. } else if (mod == IBMCAM_MODEL_3) {
  982. newstate = ibmcam_model3_parse_lines(uvd, frame, &copylen);
  983. } else {
  984. newstate = ibmcam_parse_lines(uvd, frame, &copylen);
  985. }
  986. }
  987. }
  988. if (newstate == scan_Continue)
  989. continue;
  990. else if ((newstate == scan_NextFrame) || (newstate == scan_Out))
  991. break;
  992. else
  993. return; /* scan_EndParse */
  994. }
  995. if (newstate == scan_NextFrame) {
  996. frame->frameState = FrameState_Done;
  997. uvd->curframe = -1;
  998. uvd->stats.frame_num++;
  999. if ((mod == IBMCAM_MODEL_2) || (mod == IBMCAM_MODEL_4)) {
  1000. /* Need software contrast adjustment for those cameras */
  1001. frame->flags |= USBVIDEO_FRAME_FLAG_SOFTWARE_CONTRAST;
  1002. }
  1003. }
  1004. /* Update the frame's uncompressed length. */
  1005. frame->seqRead_Length += copylen;
  1006. #if 0
  1007. {
  1008. static unsigned char j=0;
  1009. memset(frame->data, j++, uvd->max_frame_size);
  1010. frame->frameState = FrameState_Ready;
  1011. }
  1012. #endif
  1013. }
  1014. /*
  1015.  * ibmcam_veio()
  1016.  *
  1017.  * History:
  1018.  * 1/27/00  Added check for dev == NULL; this happens if camera is unplugged.
  1019.  */
  1020. static int ibmcam_veio(
  1021. uvd_t *uvd,
  1022. unsigned char req,
  1023. unsigned short value,
  1024. unsigned short index)
  1025. {
  1026. static const char proc[] = "ibmcam_veio";
  1027. unsigned char cp[8] /* = { 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef } */;
  1028. int i;
  1029. if (!CAMERA_IS_OPERATIONAL(uvd))
  1030. return 0;
  1031. if (req == 1) {
  1032. i = usb_control_msg(
  1033. uvd->dev,
  1034. usb_rcvctrlpipe(uvd->dev, 0),
  1035. req,
  1036. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
  1037. value,
  1038. index,
  1039. cp,
  1040. sizeof(cp),
  1041. HZ);
  1042. #if 0
  1043. info("USB => %02x%02x%02x%02x%02x%02x%02x%02x "
  1044.        "(req=$%02x val=$%04x ind=$%04x)",
  1045.        cp[0],cp[1],cp[2],cp[3],cp[4],cp[5],cp[6],cp[7],
  1046.        req, value, index);
  1047. #endif
  1048. } else {
  1049. i = usb_control_msg(
  1050. uvd->dev,
  1051. usb_sndctrlpipe(uvd->dev, 0),
  1052. req,
  1053. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
  1054. value,
  1055. index,
  1056. NULL,
  1057. 0,
  1058. HZ);
  1059. }
  1060. if (i < 0) {
  1061. err("%s: ERROR=%d. Camera stopped; Reconnect or reload driver.",
  1062.     proc, i);
  1063. uvd->last_error = i;
  1064. }
  1065. return i;
  1066. }
  1067. /*
  1068.  * ibmcam_calculate_fps()
  1069.  *
  1070.  * This procedure roughly calculates the real frame rate based
  1071.  * on FPS code (framerate=NNN option). Actual FPS differs
  1072.  * slightly depending on lighting conditions, so that actual frame
  1073.  * rate is determined by the camera. Since I don't know how to ask
  1074.  * the camera what FPS is now I have to use the FPS code instead.
  1075.  *
  1076.  * The FPS code is in range [0..6], 0 is slowest, 6 is fastest.
  1077.  * Corresponding real FPS should be in range [3..30] frames per second.
  1078.  * The conversion formula is obvious:
  1079.  *
  1080.  * real_fps = 3 + (fps_code * 4.5)
  1081.  *
  1082.  * History:
  1083.  * 1/18/00  Created.
  1084.  */
  1085. static int ibmcam_calculate_fps(uvd_t *uvd)
  1086. {
  1087. return 3 + framerate*4 + framerate/2;
  1088. }
  1089. /*
  1090.  * ibmcam_send_FF_04_02()
  1091.  *
  1092.  * This procedure sends magic 3-command prefix to the camera.
  1093.  * The purpose of this prefix is not known.
  1094.  *
  1095.  * History:
  1096.  * 1/2/00   Created.
  1097.  */
  1098. static void ibmcam_send_FF_04_02(uvd_t *uvd)
  1099. {
  1100. ibmcam_veio(uvd, 0, 0x00FF, 0x0127);
  1101. ibmcam_veio(uvd, 0, 0x0004, 0x0124);
  1102. ibmcam_veio(uvd, 0, 0x0002, 0x0124);
  1103. }
  1104. static void ibmcam_send_00_04_06(uvd_t *uvd)
  1105. {
  1106. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  1107. ibmcam_veio(uvd, 0, 0x0004, 0x0124);
  1108. ibmcam_veio(uvd, 0, 0x0006, 0x0124);
  1109. }
  1110. static void ibmcam_send_x_00(uvd_t *uvd, unsigned short x)
  1111. {
  1112. ibmcam_veio(uvd, 0, x,      0x0127);
  1113. ibmcam_veio(uvd, 0, 0x0000, 0x0124);
  1114. }
  1115. static void ibmcam_send_x_00_05(uvd_t *uvd, unsigned short x)
  1116. {
  1117. ibmcam_send_x_00(uvd, x);
  1118. ibmcam_veio(uvd, 0, 0x0005, 0x0124);
  1119. }
  1120. static void ibmcam_send_x_00_05_02(uvd_t *uvd, unsigned short x)
  1121. {
  1122. ibmcam_veio(uvd, 0, x,      0x0127);
  1123. ibmcam_veio(uvd, 0, 0x0000, 0x0124);
  1124. ibmcam_veio(uvd, 0, 0x0005, 0x0124);
  1125. ibmcam_veio(uvd, 0, 0x0002, 0x0124);
  1126. }
  1127. static void ibmcam_send_x_01_00_05(uvd_t *uvd, unsigned short x)
  1128. {
  1129. ibmcam_veio(uvd, 0, x,      0x0127);
  1130. ibmcam_veio(uvd, 0, 0x0001, 0x0124);
  1131. ibmcam_veio(uvd, 0, 0x0000, 0x0124);
  1132. ibmcam_veio(uvd, 0, 0x0005, 0x0124);
  1133. }
  1134. static void ibmcam_send_x_00_05_02_01(uvd_t *uvd, unsigned short x)
  1135. {
  1136. ibmcam_veio(uvd, 0, x,      0x0127);
  1137. ibmcam_veio(uvd, 0, 0x0000, 0x0124);
  1138. ibmcam_veio(uvd, 0, 0x0005, 0x0124);
  1139. ibmcam_veio(uvd, 0, 0x0002, 0x0124);
  1140. ibmcam_veio(uvd, 0, 0x0001, 0x0124);
  1141. }
  1142. static void ibmcam_send_x_00_05_02_08_01(uvd_t *uvd, unsigned short x)
  1143. {
  1144. ibmcam_veio(uvd, 0, x,      0x0127);
  1145. ibmcam_veio(uvd, 0, 0x0000, 0x0124);
  1146. ibmcam_veio(uvd, 0, 0x0005, 0x0124);
  1147. ibmcam_veio(uvd, 0, 0x0002, 0x0124);
  1148. ibmcam_veio(uvd, 0, 0x0008, 0x0124);
  1149. ibmcam_veio(uvd, 0, 0x0001, 0x0124);
  1150. }
  1151. static void ibmcam_Packet_Format1(uvd_t *uvd, unsigned char fkey, unsigned char val)
  1152. {
  1153. ibmcam_send_x_01_00_05(uvd, unknown_88);
  1154. ibmcam_send_x_00_05(uvd, fkey);
  1155. ibmcam_send_x_00_05_02_08_01(uvd, val);
  1156. ibmcam_send_x_00_05(uvd, unknown_88);
  1157. ibmcam_send_x_00_05_02_01(uvd, fkey);
  1158. ibmcam_send_x_00_05(uvd, unknown_89);
  1159. ibmcam_send_x_00(uvd, fkey);
  1160. ibmcam_send_00_04_06(uvd);
  1161. ibmcam_veio(uvd, 1, 0x0000, 0x0126);
  1162. ibmcam_send_FF_04_02(uvd);
  1163. }
  1164. static void ibmcam_PacketFormat2(uvd_t *uvd, unsigned char fkey, unsigned char val)
  1165. {
  1166. ibmcam_send_x_01_00_05 (uvd, unknown_88);
  1167. ibmcam_send_x_00_05 (uvd, fkey);
  1168. ibmcam_send_x_00_05_02 (uvd, val);
  1169. }
  1170. static void ibmcam_model2_Packet2(uvd_t *uvd)
  1171. {
  1172. ibmcam_veio(uvd, 0, 0x00ff, 0x012d);
  1173. ibmcam_veio(uvd, 0, 0xfea3, 0x0124);
  1174. }
  1175. static void ibmcam_model2_Packet1(uvd_t *uvd, unsigned short v1, unsigned short v2)
  1176. {
  1177. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  1178. ibmcam_veio(uvd, 0, 0x00ff, 0x012e);
  1179. ibmcam_veio(uvd, 0, v1,     0x012f);
  1180. ibmcam_veio(uvd, 0, 0x00ff, 0x0130);
  1181. ibmcam_veio(uvd, 0, 0xc719, 0x0124);
  1182. ibmcam_veio(uvd, 0, v2,     0x0127);
  1183. ibmcam_model2_Packet2(uvd);
  1184. }
  1185. /*
  1186.  * ibmcam_model3_Packet1()
  1187.  *
  1188.  * 00_0078_012d
  1189.  * 00_0097_012f
  1190.  * 00_d141_0124
  1191.  * 00_0096_0127
  1192.  * 00_fea8_0124
  1193. */
  1194. static void ibmcam_model3_Packet1(uvd_t *uvd, unsigned short v1, unsigned short v2)
  1195. {
  1196. ibmcam_veio(uvd, 0, 0x0078, 0x012d);
  1197. ibmcam_veio(uvd, 0, v1,     0x012f);
  1198. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  1199. ibmcam_veio(uvd, 0, v2,     0x0127);
  1200. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  1201. }
  1202. static void ibmcam_model4_BrightnessPacket(uvd_t *uvd, int i)
  1203. {
  1204. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  1205. ibmcam_veio(uvd, 0, 0x0026, 0x012f);
  1206. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  1207. ibmcam_veio(uvd, 0, i,      0x0127);
  1208. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  1209. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  1210. ibmcam_veio(uvd, 0, 0x0038, 0x012d);
  1211. ibmcam_veio(uvd, 0, 0x0004, 0x012f);
  1212. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  1213. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  1214. }
  1215. /*
  1216.  * ibmcam_adjust_contrast()
  1217.  *
  1218.  * The contrast value changes from 0 (high contrast) to 15 (low contrast).
  1219.  * This is in reverse to usual order of things (such as TV controls), so
  1220.  * we reverse it again here.
  1221.  *
  1222.  * TODO: we probably don't need to send the setup 5 times...
  1223.  *
  1224.  * History:
  1225.  * 1/2/00   Created.
  1226.  */
  1227. static void ibmcam_adjust_contrast(uvd_t *uvd)
  1228. {
  1229. unsigned char a_contrast = uvd->vpic.contrast >> 12;
  1230. unsigned char new_contrast;
  1231. if (a_contrast >= 16)
  1232. a_contrast = 15;
  1233. new_contrast = 15 - a_contrast;
  1234. if (new_contrast == uvd->vpic_old.contrast)
  1235. return;
  1236. uvd->vpic_old.contrast = new_contrast;
  1237. switch (IBMCAM_T(uvd)->camera_model) {
  1238. case IBMCAM_MODEL_1:
  1239. {
  1240. const int ntries = 5;
  1241. int i;
  1242. for (i=0; i < ntries; i++) {
  1243. ibmcam_Packet_Format1(uvd, contrast_14, new_contrast);
  1244. ibmcam_send_FF_04_02(uvd);
  1245. }
  1246. break;
  1247. }
  1248. case IBMCAM_MODEL_2:
  1249. case IBMCAM_MODEL_4:
  1250. /* Models 2, 4 do not have this control; implemented in software. */
  1251. break;
  1252. case IBMCAM_MODEL_3:
  1253. { /* Preset hardware values */
  1254. static const struct {
  1255. unsigned short cv1;
  1256. unsigned short cv2;
  1257. unsigned short cv3;
  1258. } cv[7] = {
  1259. { 0x05, 0x05, 0x0f }, /* Minimum */
  1260. { 0x04, 0x04, 0x16 },
  1261. { 0x02, 0x03, 0x16 },
  1262. { 0x02, 0x08, 0x16 },
  1263. { 0x01, 0x0c, 0x16 },
  1264. { 0x01, 0x0e, 0x16 },
  1265. { 0x01, 0x10, 0x16 } /* Maximum */
  1266. };
  1267. int i = a_contrast / 2;
  1268. RESTRICT_TO_RANGE(i, 0, 6);
  1269. ibmcam_veio(uvd, 0, 0x0000, 0x010c); /* Stop */
  1270. ibmcam_model3_Packet1(uvd, 0x0067, cv[i].cv1);
  1271. ibmcam_model3_Packet1(uvd, 0x005b, cv[i].cv2);
  1272. ibmcam_model3_Packet1(uvd, 0x005c, cv[i].cv3);
  1273. ibmcam_veio(uvd, 0, 0x0001, 0x0114);
  1274. ibmcam_veio(uvd, 0, 0x00c0, 0x010c); /* Go! */
  1275. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  1276. break;
  1277. }
  1278. default:
  1279. break;
  1280. }
  1281. }
  1282. /*
  1283.  * ibmcam_change_lighting_conditions()
  1284.  *
  1285.  * Camera model 1:
  1286.  * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low.
  1287.  *
  1288.  * Camera model 2:
  1289.  * We have 16 levels of lighting, 0 for bright light and up to 15 for
  1290.  * low light. But values above 5 or so are useless because camera is
  1291.  * not really capable to produce anything worth viewing at such light.
  1292.  * This setting may be altered only in certain camera state.
  1293.  *
  1294.  * Low lighting forces slower FPS. Lighting is set as a module parameter.
  1295.  *
  1296.  * History:
  1297.  * 1/5/00   Created.
  1298.  * 2/20/00  Added support for Model 2 cameras.
  1299.  */
  1300. static void ibmcam_change_lighting_conditions(uvd_t *uvd)
  1301. {
  1302. static const char proc[] = "ibmcam_change_lighting_conditions";
  1303. if (debug > 0)
  1304. info("%s: Set lighting to %hu.", proc, lighting);
  1305. switch (IBMCAM_T(uvd)->camera_model) {
  1306. case IBMCAM_MODEL_1:
  1307. {
  1308. const int ntries = 5;
  1309. int i;
  1310. for (i=0; i < ntries; i++)
  1311. ibmcam_Packet_Format1(uvd, light_27, (unsigned short) lighting);
  1312. break;
  1313. }
  1314. case IBMCAM_MODEL_2:
  1315. #if 0
  1316. /*
  1317.  * This command apparently requires camera to be stopped. My
  1318.  * experiments showed that it -is- possible to alter the lighting
  1319.  * conditions setting "on the fly", but why bother? This setting does
  1320.  * not work reliably in all cases, so I decided simply to leave the
  1321.  * setting where Xirlink put it - in the camera setup phase. This code
  1322.  * is commented out because it does not work at -any- moment, so its
  1323.  * presence makes no sense. You may use it for experiments.
  1324.  */
  1325. ibmcam_veio(uvd, 0, 0x0000, 0x010c); /* Stop camera */
  1326. ibmcam_model2_Packet1(uvd, mod2_sensitivity, lighting);
  1327. ibmcam_veio(uvd, 0, 0x00c0, 0x010c); /* Start camera */
  1328. #endif
  1329. break;
  1330. case IBMCAM_MODEL_3:
  1331. case IBMCAM_MODEL_4:
  1332. default:
  1333. break;
  1334. }
  1335. }
  1336. /*
  1337.  * ibmcam_set_sharpness()
  1338.  *
  1339.  * Cameras model 1 have internal smoothing feature. It is controlled by value in
  1340.  * range [0..6], where 0 is most smooth and 6 is most sharp (raw image, I guess).
  1341.  * Recommended value is 4. Cameras model 2 do not have this feature at all.
  1342.  */
  1343. static void ibmcam_set_sharpness(uvd_t *uvd)
  1344. {
  1345. static const char proc[] = "ibmcam_set_sharpness";
  1346. switch (IBMCAM_T(uvd)->camera_model) {
  1347. case IBMCAM_MODEL_1:
  1348. {
  1349. static const unsigned short sa[] = { 0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a };
  1350. unsigned short i, sv;
  1351. RESTRICT_TO_RANGE(sharpness, SHARPNESS_MIN, SHARPNESS_MAX);
  1352. if (debug > 0)
  1353. info("%s: Set sharpness to %hu.", proc, sharpness);
  1354. sv = sa[sharpness - SHARPNESS_MIN];
  1355. for (i=0; i < 2; i++) {
  1356. ibmcam_send_x_01_00_05 (uvd, unknown_88);
  1357. ibmcam_send_x_00_05 (uvd, sharp_13);
  1358. ibmcam_send_x_00_05_02 (uvd, sv);
  1359. }
  1360. break;
  1361. }
  1362. case IBMCAM_MODEL_2:
  1363. case IBMCAM_MODEL_4:
  1364. /* Models 2, 4 do not have this control */
  1365. break;
  1366. case IBMCAM_MODEL_3:
  1367. { /*
  1368.  * "Use a table of magic numbers.
  1369.  *  This setting doesn't really change much.
  1370.  *  But that's how Windows does it."
  1371.  */
  1372. static const struct {
  1373. unsigned short sv1;
  1374. unsigned short sv2;
  1375. unsigned short sv3;
  1376. unsigned short sv4;
  1377. } sv[7] = {
  1378. { 0x00, 0x00, 0x05, 0x14 }, /* Smoothest */
  1379. { 0x01, 0x04, 0x05, 0x14 },
  1380. { 0x02, 0x04, 0x05, 0x14 },
  1381. { 0x03, 0x04, 0x05, 0x14 },
  1382. { 0x03, 0x05, 0x05, 0x14 },
  1383. { 0x03, 0x06, 0x05, 0x14 },
  1384. { 0x03, 0x07, 0x05, 0x14 } /* Sharpest */
  1385. };
  1386. RESTRICT_TO_RANGE(sharpness, SHARPNESS_MIN, SHARPNESS_MAX);
  1387. RESTRICT_TO_RANGE(sharpness, 0, 6);
  1388. ibmcam_veio(uvd, 0, 0x0000, 0x010c); /* Stop */
  1389. ibmcam_model3_Packet1(uvd, 0x0060, sv[sharpness].sv1);
  1390. ibmcam_model3_Packet1(uvd, 0x0061, sv[sharpness].sv2);
  1391. ibmcam_model3_Packet1(uvd, 0x0062, sv[sharpness].sv3);
  1392. ibmcam_model3_Packet1(uvd, 0x0063, sv[sharpness].sv4);
  1393. ibmcam_veio(uvd, 0, 0x0001, 0x0114);
  1394. ibmcam_veio(uvd, 0, 0x00c0, 0x010c); /* Go! */
  1395. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  1396. ibmcam_veio(uvd, 0, 0x0001, 0x0113);
  1397. break;
  1398. }
  1399. default:
  1400. break;
  1401. }
  1402. }
  1403. /*
  1404.  * ibmcam_set_brightness()
  1405.  *
  1406.  * This procedure changes brightness of the picture.
  1407.  */
  1408. static void ibmcam_set_brightness(uvd_t *uvd)
  1409. {
  1410. static const char proc[] = "ibmcam_set_brightness";
  1411. static const unsigned short n = 1;
  1412. if (debug > 0)
  1413. info("%s: Set brightness to %hu.", proc, uvd->vpic.brightness);
  1414. switch (IBMCAM_T(uvd)->camera_model) {
  1415. case IBMCAM_MODEL_1:
  1416. {
  1417. unsigned short i, j, bv[3];
  1418. bv[0] = bv[1] = bv[2] = uvd->vpic.brightness >> 10;
  1419. if (bv[0] == (uvd->vpic_old.brightness >> 10))
  1420. return;
  1421. uvd->vpic_old.brightness = bv[0];
  1422. for (j=0; j < 3; j++)
  1423. for (i=0; i < n; i++)
  1424. ibmcam_Packet_Format1(uvd, bright_3x[j], bv[j]);
  1425. break;
  1426. }
  1427. case IBMCAM_MODEL_2:
  1428. {
  1429. unsigned short i, j;
  1430. i = uvd->vpic.brightness >> 12; /* 0 .. 15 */
  1431. j = 0x60 + i * ((0xee - 0x60) / 16); /* 0x60 .. 0xee or so */
  1432. if (uvd->vpic_old.brightness == j)
  1433. break;
  1434. uvd->vpic_old.brightness = j;
  1435. ibmcam_model2_Packet1(uvd, mod2_brightness, j);
  1436. break;
  1437. }
  1438. case IBMCAM_MODEL_3:
  1439. {
  1440. /* Model 3: Brightness range 'i' in [0x0C..0x3F] */
  1441. unsigned short i =
  1442. 0x0C + (uvd->vpic.brightness / (0xFFFF / (0x3F - 0x0C + 1)));
  1443. RESTRICT_TO_RANGE(i, 0x0C, 0x3F);
  1444. if (uvd->vpic_old.brightness == i)
  1445. break;
  1446. uvd->vpic_old.brightness = i;
  1447. ibmcam_veio(uvd, 0, 0x0000, 0x010c); /* Stop */
  1448. ibmcam_model3_Packet1(uvd, 0x0036, i);
  1449. ibmcam_veio(uvd, 0, 0x0001, 0x0114);
  1450. ibmcam_veio(uvd, 0, 0x00c0, 0x010c); /* Go! */
  1451. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  1452. ibmcam_veio(uvd, 0, 0x0001, 0x0113);
  1453. break;
  1454. }
  1455. case IBMCAM_MODEL_4:
  1456. {
  1457. /* Model 4: Brightness range 'i' in [0x04..0xb4] */
  1458. unsigned short i = 0x04 + (uvd->vpic.brightness / (0xFFFF / (0xb4 - 0x04 + 1)));
  1459. RESTRICT_TO_RANGE(i, 0x04, 0xb4);
  1460. if (uvd->vpic_old.brightness == i)
  1461. break;
  1462. uvd->vpic_old.brightness = i;
  1463. ibmcam_model4_BrightnessPacket(uvd, i);
  1464. break;
  1465. }
  1466. default:
  1467. break;
  1468. }
  1469. }
  1470. static void ibmcam_set_hue(uvd_t *uvd)
  1471. {
  1472. switch (IBMCAM_T(uvd)->camera_model) {
  1473. case IBMCAM_MODEL_2:
  1474. {
  1475. unsigned short hue = uvd->vpic.hue >> 9; /* 0 .. 7F */
  1476. if (uvd->vpic_old.hue == hue)
  1477. return;
  1478. uvd->vpic_old.hue = hue;
  1479. ibmcam_model2_Packet1(uvd, mod2_hue, hue);
  1480. /* ibmcam_model2_Packet1(uvd, mod2_saturation, sat); */
  1481. break;
  1482. }
  1483. case IBMCAM_MODEL_3:
  1484. {
  1485. #if 0 /* This seems not to work. No problem, will fix programmatically */
  1486. unsigned short hue = 0x05 + (uvd->vpic.hue / (0xFFFF / (0x37 - 0x05 + 1)));
  1487. RESTRICT_TO_RANGE(hue, 0x05, 0x37);
  1488. if (uvd->vpic_old.hue == hue)
  1489. return;
  1490. uvd->vpic_old.hue = hue;
  1491. ibmcam_veio(uvd, 0, 0x0000, 0x010c); /* Stop */
  1492. ibmcam_model3_Packet1(uvd, 0x007e, hue);
  1493. ibmcam_veio(uvd, 0, 0x0001, 0x0114);
  1494. ibmcam_veio(uvd, 0, 0x00c0, 0x010c); /* Go! */
  1495. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  1496. ibmcam_veio(uvd, 0, 0x0001, 0x0113);
  1497. #endif
  1498. break;
  1499. }
  1500. case IBMCAM_MODEL_4:
  1501. {
  1502. unsigned short r_gain, g_gain, b_gain, hue;
  1503. /*
  1504.  * I am not sure r/g/b_gain variables exactly control gain
  1505.  * of those channels. Most likely they subtly change some
  1506.  * very internal image processing settings in the camera.
  1507.  * In any case, here is what they do, and feel free to tweak:
  1508.  *
  1509.  * r_gain: seriously affects red gain
  1510.  * g_gain: seriously affects green gain
  1511.  * b_gain: seriously affects blue gain
  1512.  * hue: changes average color from violet (0) to red (0xFF)
  1513.  *
  1514.  * These settings are preset for a decent white balance in
  1515.  * 320x240, 352x288 modes. Low-res modes exhibit higher contrast
  1516.  * and therefore may need different values here.
  1517.  */
  1518. hue = 20 + (uvd->vpic.hue >> 9);
  1519. switch (uvd->videosize) {
  1520. case VIDEOSIZE_128x96:
  1521. r_gain = 90;
  1522. g_gain = 166;
  1523. b_gain = 175;
  1524. break;
  1525. case VIDEOSIZE_160x120:
  1526. r_gain = 70;
  1527. g_gain = 166;
  1528. b_gain = 185;
  1529. break;
  1530. case VIDEOSIZE_176x144:
  1531. r_gain = 160;
  1532. g_gain = 175;
  1533. b_gain = 185;
  1534. break;
  1535. default:
  1536. r_gain = 120;
  1537. g_gain = 166;
  1538. b_gain = 175;
  1539. break;
  1540. }
  1541. RESTRICT_TO_RANGE(hue, 1, 0x7f);
  1542. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  1543. ibmcam_veio(uvd, 0, 0x001e, 0x012f);
  1544. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  1545. ibmcam_veio(uvd, 0, g_gain, 0x0127); /* Green gain */
  1546. ibmcam_veio(uvd, 0, r_gain, 0x012e); /* Red gain */
  1547. ibmcam_veio(uvd, 0, b_gain, 0x0130); /* Blue gain */
  1548. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  1549. ibmcam_veio(uvd, 0, hue,    0x012d); /* Hue */
  1550. ibmcam_veio(uvd, 0, 0xf545, 0x0124);
  1551. break;
  1552. }
  1553. default:
  1554. break;
  1555. }
  1556. }
  1557. /*
  1558.  * ibmcam_adjust_picture()
  1559.  *
  1560.  * This procedure gets called from V4L interface to update picture settings.
  1561.  * Here we change brightness and contrast.
  1562.  */
  1563. static void ibmcam_adjust_picture(uvd_t *uvd)
  1564. {
  1565. ibmcam_adjust_contrast(uvd);
  1566. ibmcam_set_brightness(uvd);
  1567. ibmcam_set_hue(uvd);
  1568. }
  1569. static int ibmcam_model1_setup(uvd_t *uvd)
  1570. {
  1571. const int ntries = 5;
  1572. int i;
  1573. ibmcam_veio(uvd, 1, 0x00, 0x0128);
  1574. ibmcam_veio(uvd, 1, 0x00, 0x0100);
  1575. ibmcam_veio(uvd, 0, 0x01, 0x0100); /* LED On  */
  1576. ibmcam_veio(uvd, 1, 0x00, 0x0100);
  1577. ibmcam_veio(uvd, 0, 0x81, 0x0100); /* LED Off */
  1578. ibmcam_veio(uvd, 1, 0x00, 0x0100);
  1579. ibmcam_veio(uvd, 0, 0x01, 0x0100); /* LED On  */
  1580. ibmcam_veio(uvd, 0, 0x01, 0x0108);
  1581. ibmcam_veio(uvd, 0, 0x03, 0x0112);
  1582. ibmcam_veio(uvd, 1, 0x00, 0x0115);
  1583. ibmcam_veio(uvd, 0, 0x06, 0x0115);
  1584. ibmcam_veio(uvd, 1, 0x00, 0x0116);
  1585. ibmcam_veio(uvd, 0, 0x44, 0x0116);
  1586. ibmcam_veio(uvd, 1, 0x00, 0x0116);
  1587. ibmcam_veio(uvd, 0, 0x40, 0x0116);
  1588. ibmcam_veio(uvd, 1, 0x00, 0x0115);
  1589. ibmcam_veio(uvd, 0, 0x0e, 0x0115);
  1590. ibmcam_veio(uvd, 0, 0x19, 0x012c);
  1591. ibmcam_Packet_Format1(uvd, 0x00, 0x1e);
  1592. ibmcam_Packet_Format1(uvd, 0x39, 0x0d);
  1593. ibmcam_Packet_Format1(uvd, 0x39, 0x09);
  1594. ibmcam_Packet_Format1(uvd, 0x3b, 0x00);
  1595. ibmcam_Packet_Format1(uvd, 0x28, 0x22);
  1596. ibmcam_Packet_Format1(uvd, light_27, 0);
  1597. ibmcam_Packet_Format1(uvd, 0x2b, 0x1f);
  1598. ibmcam_Packet_Format1(uvd, 0x39, 0x08);
  1599. for (i=0; i < ntries; i++)
  1600. ibmcam_Packet_Format1(uvd, 0x2c, 0x00);
  1601. for (i=0; i < ntries; i++)
  1602. ibmcam_Packet_Format1(uvd, 0x30, 0x14);
  1603. ibmcam_PacketFormat2(uvd, 0x39, 0x02);
  1604. ibmcam_PacketFormat2(uvd, 0x01, 0xe1);
  1605. ibmcam_PacketFormat2(uvd, 0x02, 0xcd);
  1606. ibmcam_PacketFormat2(uvd, 0x03, 0xcd);
  1607. ibmcam_PacketFormat2(uvd, 0x04, 0xfa);
  1608. ibmcam_PacketFormat2(uvd, 0x3f, 0xff);
  1609. ibmcam_PacketFormat2(uvd, 0x39, 0x00);
  1610. ibmcam_PacketFormat2(uvd, 0x39, 0x02);
  1611. ibmcam_PacketFormat2(uvd, 0x0a, 0x37);
  1612. ibmcam_PacketFormat2(uvd, 0x0b, 0xb8);
  1613. ibmcam_PacketFormat2(uvd, 0x0c, 0xf3);
  1614. ibmcam_PacketFormat2(uvd, 0x0d, 0xe3);
  1615. ibmcam_PacketFormat2(uvd, 0x0e, 0x0d);
  1616. ibmcam_PacketFormat2(uvd, 0x0f, 0xf2);
  1617. ibmcam_PacketFormat2(uvd, 0x10, 0xd5);
  1618. ibmcam_PacketFormat2(uvd, 0x11, 0xba);
  1619. ibmcam_PacketFormat2(uvd, 0x12, 0x53);
  1620. ibmcam_PacketFormat2(uvd, 0x3f, 0xff);
  1621. ibmcam_PacketFormat2(uvd, 0x39, 0x00);
  1622. ibmcam_PacketFormat2(uvd, 0x39, 0x02);
  1623. ibmcam_PacketFormat2(uvd, 0x16, 0x00);
  1624. ibmcam_PacketFormat2(uvd, 0x17, 0x28);
  1625. ibmcam_PacketFormat2(uvd, 0x18, 0x7d);
  1626. ibmcam_PacketFormat2(uvd, 0x19, 0xbe);
  1627. ibmcam_PacketFormat2(uvd, 0x3f, 0xff);
  1628. ibmcam_PacketFormat2(uvd, 0x39, 0x00);
  1629. for (i=0; i < ntries; i++)
  1630. ibmcam_Packet_Format1(uvd, 0x00, 0x18);
  1631. for (i=0; i < ntries; i++)
  1632. ibmcam_Packet_Format1(uvd, 0x13, 0x18);
  1633. for (i=0; i < ntries; i++)
  1634. ibmcam_Packet_Format1(uvd, 0x14, 0x06);
  1635. /* This is default brightness */
  1636. for (i=0; i < ntries; i++)
  1637. ibmcam_Packet_Format1(uvd, 0x31, 0x37);
  1638. for (i=0; i < ntries; i++)
  1639. ibmcam_Packet_Format1(uvd, 0x32, 0x46);
  1640. for (i=0; i < ntries; i++)
  1641. ibmcam_Packet_Format1(uvd, 0x33, 0x55);
  1642. ibmcam_Packet_Format1(uvd, 0x2e, 0x04);
  1643. for (i=0; i < ntries; i++)
  1644. ibmcam_Packet_Format1(uvd, 0x2d, 0x04);
  1645. for (i=0; i < ntries; i++)
  1646. ibmcam_Packet_Format1(uvd, 0x29, 0x80);
  1647. ibmcam_Packet_Format1(uvd, 0x2c, 0x01);
  1648. ibmcam_Packet_Format1(uvd, 0x30, 0x17);
  1649. ibmcam_Packet_Format1(uvd, 0x39, 0x08);
  1650. for (i=0; i < ntries; i++)
  1651. ibmcam_Packet_Format1(uvd, 0x34, 0x00);
  1652. ibmcam_veio(uvd, 0, 0x00, 0x0101);
  1653. ibmcam_veio(uvd, 0, 0x00, 0x010a);
  1654. switch (uvd->videosize) {
  1655. case VIDEOSIZE_128x96:
  1656. ibmcam_veio(uvd, 0, 0x80, 0x0103);
  1657. ibmcam_veio(uvd, 0, 0x60, 0x0105);
  1658. ibmcam_veio(uvd, 0, 0x0c, 0x010b);
  1659. ibmcam_veio(uvd, 0, 0x04, 0x011b); /* Same everywhere */
  1660. ibmcam_veio(uvd, 0, 0x0b, 0x011d);
  1661. ibmcam_veio(uvd, 0, 0x00, 0x011e); /* Same everywhere */
  1662. ibmcam_veio(uvd, 0, 0x00, 0x0129);
  1663. break;
  1664. case VIDEOSIZE_176x144:
  1665. ibmcam_veio(uvd, 0, 0xb0, 0x0103);
  1666. ibmcam_veio(uvd, 0, 0x8f, 0x0105);
  1667. ibmcam_veio(uvd, 0, 0x06, 0x010b);
  1668. ibmcam_veio(uvd, 0, 0x04, 0x011b); /* Same everywhere */
  1669. ibmcam_veio(uvd, 0, 0x0d, 0x011d);
  1670. ibmcam_veio(uvd, 0, 0x00, 0x011e); /* Same everywhere */
  1671. ibmcam_veio(uvd, 0, 0x03, 0x0129);
  1672. break;
  1673. case VIDEOSIZE_352x288:
  1674. ibmcam_veio(uvd, 0, 0xb0, 0x0103);
  1675. ibmcam_veio(uvd, 0, 0x90, 0x0105);
  1676. ibmcam_veio(uvd, 0, 0x02, 0x010b);
  1677. ibmcam_veio(uvd, 0, 0x04, 0x011b); /* Same everywhere */
  1678. ibmcam_veio(uvd, 0, 0x05, 0x011d);
  1679. ibmcam_veio(uvd, 0, 0x00, 0x011e); /* Same everywhere */
  1680. ibmcam_veio(uvd, 0, 0x00, 0x0129);
  1681. break;
  1682. }
  1683. ibmcam_veio(uvd, 0, 0xff, 0x012b);
  1684. /* This is another brightness - don't know why */
  1685. for (i=0; i < ntries; i++)
  1686. ibmcam_Packet_Format1(uvd, 0x31, 0xc3);
  1687. for (i=0; i < ntries; i++)
  1688. ibmcam_Packet_Format1(uvd, 0x32, 0xd2);
  1689. for (i=0; i < ntries; i++)
  1690. ibmcam_Packet_Format1(uvd, 0x33, 0xe1);
  1691. /* Default contrast */
  1692. for (i=0; i < ntries; i++)
  1693. ibmcam_Packet_Format1(uvd, contrast_14, 0x0a);
  1694. /* Default sharpness */
  1695. for (i=0; i < 2; i++)
  1696. ibmcam_PacketFormat2(uvd, sharp_13, 0x1a); /* Level 4 FIXME */
  1697. /* Default lighting conditions */
  1698. ibmcam_Packet_Format1(uvd, light_27, lighting); /* 0=Bright 2=Low */
  1699. /* Assorted init */
  1700. switch (uvd->videosize) {
  1701. case VIDEOSIZE_128x96:
  1702. ibmcam_Packet_Format1(uvd, 0x2b, 0x1e);
  1703. ibmcam_veio(uvd, 0, 0xc9, 0x0119); /* Same everywhere */
  1704. ibmcam_veio(uvd, 0, 0x80, 0x0109); /* Same everywhere */
  1705. ibmcam_veio(uvd, 0, 0x36, 0x0102);
  1706. ibmcam_veio(uvd, 0, 0x1a, 0x0104);
  1707. ibmcam_veio(uvd, 0, 0x04, 0x011a); /* Same everywhere */
  1708. ibmcam_veio(uvd, 0, 0x2b, 0x011c);
  1709. ibmcam_veio(uvd, 0, 0x23, 0x012a); /* Same everywhere */
  1710. #if 0
  1711. ibmcam_veio(uvd, 0, 0x00, 0x0106);
  1712. ibmcam_veio(uvd, 0, 0x38, 0x0107);
  1713. #else
  1714. ibmcam_veio(uvd, 0, 0x02, 0x0106);
  1715. ibmcam_veio(uvd, 0, 0x2a, 0x0107);
  1716. #endif
  1717. break;
  1718. case VIDEOSIZE_176x144:
  1719. ibmcam_Packet_Format1(uvd, 0x2b, 0x1e);
  1720. ibmcam_veio(uvd, 0, 0xc9, 0x0119); /* Same everywhere */
  1721. ibmcam_veio(uvd, 0, 0x80, 0x0109); /* Same everywhere */
  1722. ibmcam_veio(uvd, 0, 0x04, 0x0102);
  1723. ibmcam_veio(uvd, 0, 0x02, 0x0104);
  1724. ibmcam_veio(uvd, 0, 0x04, 0x011a); /* Same everywhere */
  1725. ibmcam_veio(uvd, 0, 0x2b, 0x011c);
  1726. ibmcam_veio(uvd, 0, 0x23, 0x012a); /* Same everywhere */
  1727. ibmcam_veio(uvd, 0, 0x01, 0x0106);
  1728. ibmcam_veio(uvd, 0, 0xca, 0x0107);
  1729. break;
  1730. case VIDEOSIZE_352x288:
  1731. ibmcam_Packet_Format1(uvd, 0x2b, 0x1f);
  1732. ibmcam_veio(uvd, 0, 0xc9, 0x0119); /* Same everywhere */
  1733. ibmcam_veio(uvd, 0, 0x80, 0x0109); /* Same everywhere */
  1734. ibmcam_veio(uvd, 0, 0x08, 0x0102);
  1735. ibmcam_veio(uvd, 0, 0x01, 0x0104);
  1736. ibmcam_veio(uvd, 0, 0x04, 0x011a); /* Same everywhere */
  1737. ibmcam_veio(uvd, 0, 0x2f, 0x011c);
  1738. ibmcam_veio(uvd, 0, 0x23, 0x012a); /* Same everywhere */
  1739. ibmcam_veio(uvd, 0, 0x03, 0x0106);
  1740. ibmcam_veio(uvd, 0, 0xf6, 0x0107);
  1741. break;
  1742. }
  1743. return (CAMERA_IS_OPERATIONAL(uvd) ? 0 : -EFAULT);
  1744. }
  1745. static int ibmcam_model2_setup(uvd_t *uvd)
  1746. {
  1747. ibmcam_veio(uvd, 0, 0x0000, 0x0100); /* LED on */
  1748. ibmcam_veio(uvd, 1, 0x0000, 0x0116);
  1749. ibmcam_veio(uvd, 0, 0x0060, 0x0116);
  1750. ibmcam_veio(uvd, 0, 0x0002, 0x0112);
  1751. ibmcam_veio(uvd, 0, 0x00bc, 0x012c);
  1752. ibmcam_veio(uvd, 0, 0x0008, 0x012b);
  1753. ibmcam_veio(uvd, 0, 0x0000, 0x0108);
  1754. ibmcam_veio(uvd, 0, 0x0001, 0x0133);
  1755. ibmcam_veio(uvd, 0, 0x0001, 0x0102);
  1756. switch (uvd->videosize) {
  1757. case VIDEOSIZE_176x144:
  1758. ibmcam_veio(uvd, 0, 0x002c, 0x0103); /* All except 320x240 */
  1759. ibmcam_veio(uvd, 0, 0x0000, 0x0104); /* Same */
  1760. ibmcam_veio(uvd, 0, 0x0024, 0x0105); /* 176x144, 352x288 */
  1761. ibmcam_veio(uvd, 0, 0x00b9, 0x010a); /* Unique to this mode */
  1762. ibmcam_veio(uvd, 0, 0x0038, 0x0119); /* Unique to this mode */
  1763. ibmcam_veio(uvd, 0, 0x0003, 0x0106); /* Same */
  1764. ibmcam_veio(uvd, 0, 0x0090, 0x0107); /* Unique to every mode*/
  1765. break;
  1766. case VIDEOSIZE_320x240:
  1767. ibmcam_veio(uvd, 0, 0x0028, 0x0103); /* Unique to this mode */
  1768. ibmcam_veio(uvd, 0, 0x0000, 0x0104); /* Same */
  1769. ibmcam_veio(uvd, 0, 0x001e, 0x0105); /* 320x240, 352x240 */
  1770. ibmcam_veio(uvd, 0, 0x0039, 0x010a); /* All except 176x144 */
  1771. ibmcam_veio(uvd, 0, 0x0070, 0x0119); /* All except 176x144 */
  1772. ibmcam_veio(uvd, 0, 0x0003, 0x0106); /* Same */
  1773. ibmcam_veio(uvd, 0, 0x0098, 0x0107); /* Unique to every mode*/
  1774. break;
  1775. case VIDEOSIZE_352x240:
  1776. ibmcam_veio(uvd, 0, 0x002c, 0x0103); /* All except 320x240 */
  1777. ibmcam_veio(uvd, 0, 0x0000, 0x0104); /* Same */
  1778. ibmcam_veio(uvd, 0, 0x001e, 0x0105); /* 320x240, 352x240 */
  1779. ibmcam_veio(uvd, 0, 0x0039, 0x010a); /* All except 176x144 */
  1780. ibmcam_veio(uvd, 0, 0x0070, 0x0119); /* All except 176x144 */
  1781. ibmcam_veio(uvd, 0, 0x0003, 0x0106); /* Same */
  1782. ibmcam_veio(uvd, 0, 0x00da, 0x0107); /* Unique to every mode*/
  1783. break;
  1784. case VIDEOSIZE_352x288:
  1785. ibmcam_veio(uvd, 0, 0x002c, 0x0103); /* All except 320x240 */
  1786. ibmcam_veio(uvd, 0, 0x0000, 0x0104); /* Same */
  1787. ibmcam_veio(uvd, 0, 0x0024, 0x0105); /* 176x144, 352x288 */
  1788. ibmcam_veio(uvd, 0, 0x0039, 0x010a); /* All except 176x144 */
  1789. ibmcam_veio(uvd, 0, 0x0070, 0x0119); /* All except 176x144 */
  1790. ibmcam_veio(uvd, 0, 0x0003, 0x0106); /* Same */
  1791. ibmcam_veio(uvd, 0, 0x00fe, 0x0107); /* Unique to every mode*/
  1792. break;
  1793. }
  1794. return (CAMERA_IS_OPERATIONAL(uvd) ? 0 : -EFAULT);
  1795. }
  1796. /*
  1797.  * ibmcam_model1_setup_after_video_if()
  1798.  *
  1799.  * This code adds finishing touches to the video data interface.
  1800.  * Here we configure the frame rate and turn on the LED.
  1801.  */
  1802. static void ibmcam_model1_setup_after_video_if(uvd_t *uvd)
  1803. {
  1804. unsigned short internal_frame_rate;
  1805. RESTRICT_TO_RANGE(framerate, FRAMERATE_MIN, FRAMERATE_MAX);
  1806. internal_frame_rate = FRAMERATE_MAX - framerate; /* 0=Fast 6=Slow */
  1807. ibmcam_veio(uvd, 0, 0x01, 0x0100); /* LED On  */
  1808. ibmcam_veio(uvd, 0, internal_frame_rate, 0x0111);
  1809. ibmcam_veio(uvd, 0, 0x01, 0x0114);
  1810. ibmcam_veio(uvd, 0, 0xc0, 0x010c);
  1811. }
  1812. static void ibmcam_model2_setup_after_video_if(uvd_t *uvd)
  1813. {
  1814. unsigned short setup_model2_rg2, setup_model2_sat, setup_model2_yb;
  1815. ibmcam_veio(uvd, 0, 0x0000, 0x0100); /* LED on */
  1816. switch (uvd->videosize) {
  1817. case VIDEOSIZE_176x144:
  1818. ibmcam_veio(uvd, 0, 0x0050, 0x0111);
  1819. ibmcam_veio(uvd, 0, 0x00d0, 0x0111);
  1820. break;
  1821. case VIDEOSIZE_320x240:
  1822. case VIDEOSIZE_352x240:
  1823. case VIDEOSIZE_352x288:
  1824. ibmcam_veio(uvd, 0, 0x0040, 0x0111);
  1825. ibmcam_veio(uvd, 0, 0x00c0, 0x0111);
  1826. break;
  1827. }
  1828. ibmcam_veio(uvd, 0, 0x009b, 0x010f);
  1829. ibmcam_veio(uvd, 0, 0x00bb, 0x010f);
  1830. /*
  1831.  * Hardware settings, may affect CMOS sensor; not user controls!
  1832.  * -------------------------------------------------------------
  1833.  * 0x0004: no effect
  1834.  * 0x0006: hardware effect
  1835.  * 0x0008: no effect
  1836.  * 0x000a: stops video stream, probably important h/w setting
  1837.  * 0x000c: changes color in hardware manner (not user setting)
  1838.  * 0x0012: changes number of colors (does not affect speed)
  1839.  * 0x002a: no effect
  1840.  * 0x002c: hardware setting (related to scan lines)
  1841.  * 0x002e: stops video stream, probably important h/w setting
  1842.  */
  1843. ibmcam_model2_Packet1(uvd, 0x000a, 0x005c);
  1844. ibmcam_model2_Packet1(uvd, 0x0004, 0x0000);
  1845. ibmcam_model2_Packet1(uvd, 0x0006, 0x00fb);
  1846. ibmcam_model2_Packet1(uvd, 0x0008, 0x0000);
  1847. ibmcam_model2_Packet1(uvd, 0x000c, 0x0009);
  1848. ibmcam_model2_Packet1(uvd, 0x0012, 0x000a);
  1849. ibmcam_model2_Packet1(uvd, 0x002a, 0x0000);
  1850. ibmcam_model2_Packet1(uvd, 0x002c, 0x0000);
  1851. ibmcam_model2_Packet1(uvd, 0x002e, 0x0008);
  1852. /*
  1853.  * Function 0x0030 pops up all over the place. Apparently
  1854.  * it is a hardware control register, with every bit assigned to
  1855.  * do something.
  1856.  */
  1857. ibmcam_model2_Packet1(uvd, 0x0030, 0x0000);
  1858. /*
  1859.  * Magic control of CMOS sensor. Only lower values like
  1860.  * 0-3 work, and picture shifts left or right. Don't change.
  1861.  */
  1862. switch (uvd->videosize) {
  1863. case VIDEOSIZE_176x144:
  1864. ibmcam_model2_Packet1(uvd, 0x0014, 0x0002);
  1865. ibmcam_model2_Packet1(uvd, 0x0016, 0x0002); /* Horizontal shift */
  1866. ibmcam_model2_Packet1(uvd, 0x0018, 0x004a); /* Another hardware setting */
  1867. break;
  1868. case VIDEOSIZE_320x240:
  1869. ibmcam_model2_Packet1(uvd, 0x0014, 0x0009);
  1870. ibmcam_model2_Packet1(uvd, 0x0016, 0x0005); /* Horizontal shift */
  1871. ibmcam_model2_Packet1(uvd, 0x0018, 0x0044); /* Another hardware setting */
  1872. break;
  1873. case VIDEOSIZE_352x240:
  1874. /* This mode doesn't work as Windows programs it; changed to work */
  1875. ibmcam_model2_Packet1(uvd, 0x0014, 0x0009); /* Windows sets this to 8 */
  1876. ibmcam_model2_Packet1(uvd, 0x0016, 0x0003); /* Horizontal shift */
  1877. ibmcam_model2_Packet1(uvd, 0x0018, 0x0044); /* Windows sets this to 0x0045 */
  1878. break;
  1879. case VIDEOSIZE_352x288:
  1880. ibmcam_model2_Packet1(uvd, 0x0014, 0x0003);
  1881. ibmcam_model2_Packet1(uvd, 0x0016, 0x0002); /* Horizontal shift */
  1882. ibmcam_model2_Packet1(uvd, 0x0018, 0x004a); /* Another hardware setting */
  1883. break;
  1884. }
  1885. ibmcam_model2_Packet1(uvd, mod2_brightness, 0x005a);
  1886. /*
  1887.  * We have our own frame rate setting varying from 0 (slowest) to 6 (fastest).
  1888.  * The camera model 2 allows frame rate in range [0..0x1F] where 0 is also the
  1889.  * slowest setting. However for all practical reasons high settings make no
  1890.  * sense because USB is not fast enough to support high FPS. Be aware that
  1891.  * the picture datastream will be severely disrupted if you ask for
  1892.  * frame rate faster than allowed for the video size - see below:
  1893.  *
  1894.  * Allowable ranges (obtained experimentally on OHCI, K6-3, 450 MHz):
  1895.  * -----------------------------------------------------------------
  1896.  * 176x144: [6..31]
  1897.  * 320x240: [8..31]
  1898.  * 352x240: [10..31]
  1899.  * 352x288: [16..31] I have to raise lower threshold for stability...
  1900.  *
  1901.  * As usual, slower FPS provides better sensitivity.
  1902.  */
  1903. {
  1904. short hw_fps=31, i_framerate;
  1905. RESTRICT_TO_RANGE(framerate, FRAMERATE_MIN, FRAMERATE_MAX);
  1906. i_framerate = FRAMERATE_MAX - framerate + FRAMERATE_MIN;
  1907. switch (uvd->videosize) {
  1908. case VIDEOSIZE_176x144:
  1909. hw_fps = 6 + i_framerate*4;
  1910. break;
  1911. case VIDEOSIZE_320x240:
  1912. hw_fps = 8 + i_framerate*3;
  1913. break;
  1914. case VIDEOSIZE_352x240:
  1915. hw_fps = 10 + i_framerate*2;
  1916. break;
  1917. case VIDEOSIZE_352x288:
  1918. hw_fps = 28 + i_framerate/2;
  1919. break;
  1920. }
  1921. if (uvd->debug > 0)
  1922. info("Framerate (hardware): %hd.", hw_fps);
  1923. RESTRICT_TO_RANGE(hw_fps, 0, 31);
  1924. ibmcam_model2_Packet1(uvd, mod2_set_framerate, hw_fps);
  1925. }
  1926. /*
  1927.  * This setting does not visibly affect pictures; left it here
  1928.  * because it was present in Windows USB data stream. This function
  1929.  * does not allow arbitrary values and apparently is a bit mask, to
  1930.  * be activated only at appropriate time. Don't change it randomly!
  1931.  */
  1932. switch (uvd->videosize) {
  1933. case VIDEOSIZE_176x144:
  1934. ibmcam_model2_Packet1(uvd, 0x0026, 0x00c2);
  1935. break;
  1936. case VIDEOSIZE_320x240:
  1937. ibmcam_model2_Packet1(uvd, 0x0026, 0x0044);
  1938. break;
  1939. case VIDEOSIZE_352x240:
  1940. ibmcam_model2_Packet1(uvd, 0x0026, 0x0046);
  1941. break;
  1942. case VIDEOSIZE_352x288:
  1943. ibmcam_model2_Packet1(uvd, 0x0026, 0x0048);
  1944. break;
  1945. }
  1946. ibmcam_model2_Packet1(uvd, mod2_sensitivity, lighting);
  1947. if (init_model2_rg2 >= 0) {
  1948. RESTRICT_TO_RANGE(init_model2_rg2, 0, 255);
  1949. setup_model2_rg2 = init_model2_rg2;
  1950. } else
  1951. setup_model2_rg2 = 0x002f;
  1952. if (init_model2_sat >= 0) {
  1953. RESTRICT_TO_RANGE(init_model2_sat, 0, 255);
  1954. setup_model2_sat = init_model2_sat;
  1955. } else
  1956. setup_model2_sat = 0x0034;
  1957. if (init_model2_yb >= 0) {
  1958. RESTRICT_TO_RANGE(init_model2_yb, 0, 255);
  1959. setup_model2_yb = init_model2_yb;
  1960. } else
  1961. setup_model2_yb = 0x00a0;
  1962. ibmcam_model2_Packet1(uvd, mod2_color_balance_rg2, setup_model2_rg2);
  1963. ibmcam_model2_Packet1(uvd, mod2_saturation, setup_model2_sat);
  1964. ibmcam_model2_Packet1(uvd, mod2_color_balance_yb, setup_model2_yb);
  1965. ibmcam_model2_Packet1(uvd, mod2_hue, uvd->vpic.hue >> 9); /* 0 .. 7F */;
  1966. /* Hardware control command */
  1967. ibmcam_model2_Packet1(uvd, 0x0030, 0x0004);
  1968. ibmcam_veio(uvd, 0, 0x00c0, 0x010c); /* Go camera, go! */
  1969. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  1970. }
  1971. static void ibmcam_model4_setup_after_video_if(uvd_t *uvd)
  1972. {
  1973. switch (uvd->videosize) {
  1974. case VIDEOSIZE_128x96:
  1975. ibmcam_veio(uvd, 0, 0x0000, 0x0100);
  1976. ibmcam_veio(uvd, 0, 0x00c0, 0x0111);
  1977. ibmcam_veio(uvd, 0, 0x00bc, 0x012c);
  1978. ibmcam_veio(uvd, 0, 0x0080, 0x012b);
  1979. ibmcam_veio(uvd, 0, 0x0000, 0x0108);
  1980. ibmcam_veio(uvd, 0, 0x0001, 0x0133);
  1981. ibmcam_veio(uvd, 0, 0x009b, 0x010f);
  1982. ibmcam_veio(uvd, 0, 0x00bb, 0x010f);
  1983. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  1984. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  1985. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  1986. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  1987. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  1988. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  1989. ibmcam_veio(uvd, 0, 0x000a, 0x012f);
  1990. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  1991. ibmcam_veio(uvd, 0, 0x005c, 0x0127);
  1992. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  1993. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  1994. ibmcam_veio(uvd, 0, 0x0004, 0x012f);
  1995. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  1996. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  1997. ibmcam_veio(uvd, 0, 0x00fb, 0x012e);
  1998. ibmcam_veio(uvd, 0, 0x0000, 0x0130);
  1999. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2000. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2001. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2002. ibmcam_veio(uvd, 0, 0x000c, 0x0127);
  2003. ibmcam_veio(uvd, 0, 0x0009, 0x012e);
  2004. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2005. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2006. ibmcam_veio(uvd, 0, 0x0012, 0x012f);
  2007. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2008. ibmcam_veio(uvd, 0, 0x0008, 0x0127);
  2009. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2010. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2011. ibmcam_veio(uvd, 0, 0x002a, 0x012d);
  2012. ibmcam_veio(uvd, 0, 0x0000, 0x012f);
  2013. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2014. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2015. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2016. ibmcam_veio(uvd, 0, 0x0034, 0x012f);
  2017. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2018. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2019. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2020. ibmcam_veio(uvd, 0, 0x0070, 0x0119);
  2021. ibmcam_veio(uvd, 0, 0x00d2, 0x0107);
  2022. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2023. ibmcam_veio(uvd, 0, 0x005e, 0x0107);
  2024. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2025. ibmcam_veio(uvd, 0, 0x00d0, 0x0111);
  2026. ibmcam_veio(uvd, 0, 0x0039, 0x010a);
  2027. ibmcam_veio(uvd, 0, 0x0001, 0x0102);
  2028. ibmcam_veio(uvd, 0, 0x0028, 0x0103);
  2029. ibmcam_veio(uvd, 0, 0x0000, 0x0104);
  2030. ibmcam_veio(uvd, 0, 0x001e, 0x0105);
  2031. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2032. ibmcam_veio(uvd, 0, 0x0016, 0x012f);
  2033. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2034. ibmcam_veio(uvd, 0, 0x000a, 0x0127);
  2035. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2036. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2037. ibmcam_veio(uvd, 0, 0x0014, 0x012d);
  2038. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2039. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2040. ibmcam_veio(uvd, 0, 0x00aa, 0x012e);
  2041. ibmcam_veio(uvd, 0, 0x001a, 0x0130);
  2042. ibmcam_veio(uvd, 0, 0x8a0a, 0x0124);
  2043. ibmcam_veio(uvd, 0, 0x005a, 0x012d);
  2044. ibmcam_veio(uvd, 0, 0x9545, 0x0124);
  2045. ibmcam_veio(uvd, 0, 0x00aa, 0x0127);
  2046. ibmcam_veio(uvd, 0, 0x0018, 0x012e);
  2047. ibmcam_veio(uvd, 0, 0x0043, 0x0130);
  2048. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2049. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2050. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2051. ibmcam_veio(uvd, 0, 0x001c, 0x0127);
  2052. ibmcam_veio(uvd, 0, 0x00eb, 0x012e);
  2053. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2054. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2055. ibmcam_veio(uvd, 0, 0x0032, 0x012f);
  2056. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2057. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2058. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2059. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2060. ibmcam_veio(uvd, 0, 0x0036, 0x012d);
  2061. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2062. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2063. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2064. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2065. ibmcam_veio(uvd, 0, 0x001e, 0x012f);
  2066. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2067. ibmcam_veio(uvd, 0, 0x0017, 0x0127);
  2068. ibmcam_veio(uvd, 0, 0x0013, 0x012e);
  2069. ibmcam_veio(uvd, 0, 0x0031, 0x0130);
  2070. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2071. ibmcam_veio(uvd, 0, 0x0017, 0x012d);
  2072. ibmcam_veio(uvd, 0, 0x0078, 0x012f);
  2073. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2074. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2075. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2076. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2077. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2078. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2079. ibmcam_veio(uvd, 0, 0x0004, 0x0127);
  2080. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2081. ibmcam_veio(uvd, 0, 0x00c0, 0x010c);
  2082. break;
  2083. case VIDEOSIZE_160x120:
  2084. ibmcam_veio(uvd, 0, 0x0000, 0x0100);
  2085. ibmcam_veio(uvd, 0, 0x00c0, 0x0111);
  2086. ibmcam_veio(uvd, 0, 0x00bc, 0x012c);
  2087. ibmcam_veio(uvd, 0, 0x0080, 0x012b);
  2088. ibmcam_veio(uvd, 0, 0x0000, 0x0108);
  2089. ibmcam_veio(uvd, 0, 0x0001, 0x0133);
  2090. ibmcam_veio(uvd, 0, 0x009b, 0x010f);
  2091. ibmcam_veio(uvd, 0, 0x00bb, 0x010f);
  2092. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2093. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2094. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2095. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2096. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2097. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2098. ibmcam_veio(uvd, 0, 0x000a, 0x012f);
  2099. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2100. ibmcam_veio(uvd, 0, 0x005c, 0x0127);
  2101. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2102. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2103. ibmcam_veio(uvd, 0, 0x0004, 0x012f);
  2104. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2105. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2106. ibmcam_veio(uvd, 0, 0x00fb, 0x012e);
  2107. ibmcam_veio(uvd, 0, 0x0000, 0x0130);
  2108. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2109. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2110. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2111. ibmcam_veio(uvd, 0, 0x000c, 0x0127);
  2112. ibmcam_veio(uvd, 0, 0x0009, 0x012e);
  2113. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2114. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2115. ibmcam_veio(uvd, 0, 0x0012, 0x012f);
  2116. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2117. ibmcam_veio(uvd, 0, 0x0008, 0x0127);
  2118. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2119. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2120. ibmcam_veio(uvd, 0, 0x002a, 0x012d);
  2121. ibmcam_veio(uvd, 0, 0x0000, 0x012f);
  2122. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2123. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2124. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2125. ibmcam_veio(uvd, 0, 0x0034, 0x012f);
  2126. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2127. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2128. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2129. ibmcam_veio(uvd, 0, 0x0038, 0x0119);
  2130. ibmcam_veio(uvd, 0, 0x00d8, 0x0107);
  2131. ibmcam_veio(uvd, 0, 0x0002, 0x0106);
  2132. ibmcam_veio(uvd, 0, 0x00d0, 0x0111);
  2133. ibmcam_veio(uvd, 0, 0x00b9, 0x010a);
  2134. ibmcam_veio(uvd, 0, 0x0001, 0x0102);
  2135. ibmcam_veio(uvd, 0, 0x0028, 0x0103);
  2136. ibmcam_veio(uvd, 0, 0x0000, 0x0104);
  2137. ibmcam_veio(uvd, 0, 0x001e, 0x0105);
  2138. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2139. ibmcam_veio(uvd, 0, 0x0016, 0x012f);
  2140. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2141. ibmcam_veio(uvd, 0, 0x000b, 0x0127);
  2142. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2143. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2144. ibmcam_veio(uvd, 0, 0x0014, 0x012d);
  2145. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2146. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2147. ibmcam_veio(uvd, 0, 0x00aa, 0x012e);
  2148. ibmcam_veio(uvd, 0, 0x001a, 0x0130);
  2149. ibmcam_veio(uvd, 0, 0x8a0a, 0x0124);
  2150. ibmcam_veio(uvd, 0, 0x005a, 0x012d);
  2151. ibmcam_veio(uvd, 0, 0x9545, 0x0124);
  2152. ibmcam_veio(uvd, 0, 0x00aa, 0x0127);
  2153. ibmcam_veio(uvd, 0, 0x0018, 0x012e);
  2154. ibmcam_veio(uvd, 0, 0x0043, 0x0130);
  2155. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2156. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2157. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2158. ibmcam_veio(uvd, 0, 0x001c, 0x0127);
  2159. ibmcam_veio(uvd, 0, 0x00c7, 0x012e);
  2160. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2161. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2162. ibmcam_veio(uvd, 0, 0x0032, 0x012f);
  2163. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2164. ibmcam_veio(uvd, 0, 0x0025, 0x0127);
  2165. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2166. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2167. ibmcam_veio(uvd, 0, 0x0036, 0x012d);
  2168. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2169. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2170. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2171. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2172. ibmcam_veio(uvd, 0, 0x001e, 0x012f);
  2173. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2174. ibmcam_veio(uvd, 0, 0x0048, 0x0127);
  2175. ibmcam_veio(uvd, 0, 0x0035, 0x012e);
  2176. ibmcam_veio(uvd, 0, 0x00d0, 0x0130);
  2177. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2178. ibmcam_veio(uvd, 0, 0x0048, 0x012d);
  2179. ibmcam_veio(uvd, 0, 0x0090, 0x012f);
  2180. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2181. ibmcam_veio(uvd, 0, 0x0001, 0x0127);
  2182. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2183. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2184. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2185. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2186. ibmcam_veio(uvd, 0, 0x0004, 0x0127);
  2187. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2188. ibmcam_veio(uvd, 0, 0x00c0, 0x010c);
  2189. break;
  2190. case VIDEOSIZE_176x144:
  2191. ibmcam_veio(uvd, 0, 0x0000, 0x0100);
  2192. ibmcam_veio(uvd, 0, 0x00c0, 0x0111);
  2193. ibmcam_veio(uvd, 0, 0x00bc, 0x012c);
  2194. ibmcam_veio(uvd, 0, 0x0080, 0x012b);
  2195. ibmcam_veio(uvd, 0, 0x0000, 0x0108);
  2196. ibmcam_veio(uvd, 0, 0x0001, 0x0133);
  2197. ibmcam_veio(uvd, 0, 0x009b, 0x010f);
  2198. ibmcam_veio(uvd, 0, 0x00bb, 0x010f);
  2199. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2200. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2201. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2202. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2203. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2204. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2205. ibmcam_veio(uvd, 0, 0x000a, 0x012f);
  2206. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2207. ibmcam_veio(uvd, 0, 0x005c, 0x0127);
  2208. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2209. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2210. ibmcam_veio(uvd, 0, 0x0004, 0x012f);
  2211. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2212. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2213. ibmcam_veio(uvd, 0, 0x00fb, 0x012e);
  2214. ibmcam_veio(uvd, 0, 0x0000, 0x0130);
  2215. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2216. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2217. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2218. ibmcam_veio(uvd, 0, 0x000c, 0x0127);
  2219. ibmcam_veio(uvd, 0, 0x0009, 0x012e);
  2220. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2221. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2222. ibmcam_veio(uvd, 0, 0x0012, 0x012f);
  2223. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2224. ibmcam_veio(uvd, 0, 0x0008, 0x0127);
  2225. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2226. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2227. ibmcam_veio(uvd, 0, 0x002a, 0x012d);
  2228. ibmcam_veio(uvd, 0, 0x0000, 0x012f);
  2229. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2230. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2231. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2232. ibmcam_veio(uvd, 0, 0x0034, 0x012f);
  2233. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2234. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2235. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2236. ibmcam_veio(uvd, 0, 0x0038, 0x0119);
  2237. ibmcam_veio(uvd, 0, 0x00d6, 0x0107);
  2238. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2239. ibmcam_veio(uvd, 0, 0x0018, 0x0107);
  2240. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2241. ibmcam_veio(uvd, 0, 0x00d0, 0x0111);
  2242. ibmcam_veio(uvd, 0, 0x00b9, 0x010a);
  2243. ibmcam_veio(uvd, 0, 0x0001, 0x0102);
  2244. ibmcam_veio(uvd, 0, 0x002c, 0x0103);
  2245. ibmcam_veio(uvd, 0, 0x0000, 0x0104);
  2246. ibmcam_veio(uvd, 0, 0x0024, 0x0105);
  2247. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2248. ibmcam_veio(uvd, 0, 0x0016, 0x012f);
  2249. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2250. ibmcam_veio(uvd, 0, 0x0007, 0x0127);
  2251. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2252. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2253. ibmcam_veio(uvd, 0, 0x0014, 0x012d);
  2254. ibmcam_veio(uvd, 0, 0x0001, 0x012f);
  2255. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2256. ibmcam_veio(uvd, 0, 0x00aa, 0x012e);
  2257. ibmcam_veio(uvd, 0, 0x001a, 0x0130);
  2258. ibmcam_veio(uvd, 0, 0x8a0a, 0x0124);
  2259. ibmcam_veio(uvd, 0, 0x005e, 0x012d);
  2260. ibmcam_veio(uvd, 0, 0x9545, 0x0124);
  2261. ibmcam_veio(uvd, 0, 0x00aa, 0x0127);
  2262. ibmcam_veio(uvd, 0, 0x0018, 0x012e);
  2263. ibmcam_veio(uvd, 0, 0x0049, 0x0130);
  2264. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2265. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2266. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2267. ibmcam_veio(uvd, 0, 0x001c, 0x0127);
  2268. ibmcam_veio(uvd, 0, 0x00c7, 0x012e);
  2269. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2270. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2271. ibmcam_veio(uvd, 0, 0x0032, 0x012f);
  2272. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2273. ibmcam_veio(uvd, 0, 0x0028, 0x0127);
  2274. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2275. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2276. ibmcam_veio(uvd, 0, 0x0036, 0x012d);
  2277. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2278. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2279. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2280. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2281. ibmcam_veio(uvd, 0, 0x001e, 0x012f);
  2282. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2283. ibmcam_veio(uvd, 0, 0x0010, 0x0127);
  2284. ibmcam_veio(uvd, 0, 0x0013, 0x012e);
  2285. ibmcam_veio(uvd, 0, 0x002a, 0x0130);
  2286. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2287. ibmcam_veio(uvd, 0, 0x0010, 0x012d);
  2288. ibmcam_veio(uvd, 0, 0x006d, 0x012f);
  2289. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2290. ibmcam_veio(uvd, 0, 0x0001, 0x0127);
  2291. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2292. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2293. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2294. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2295. ibmcam_veio(uvd, 0, 0x0004, 0x0127);
  2296. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2297. ibmcam_veio(uvd, 0, 0x00c0, 0x010c);
  2298. break;
  2299. case VIDEOSIZE_320x240:
  2300. ibmcam_veio(uvd, 0, 0x0000, 0x0100);
  2301. ibmcam_veio(uvd, 0, 0x00c0, 0x0111);
  2302. ibmcam_veio(uvd, 0, 0x00bc, 0x012c);
  2303. ibmcam_veio(uvd, 0, 0x0080, 0x012b);
  2304. ibmcam_veio(uvd, 0, 0x0000, 0x0108);
  2305. ibmcam_veio(uvd, 0, 0x0001, 0x0133);
  2306. ibmcam_veio(uvd, 0, 0x009b, 0x010f);
  2307. ibmcam_veio(uvd, 0, 0x00bb, 0x010f);
  2308. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2309. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2310. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2311. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2312. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2313. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2314. ibmcam_veio(uvd, 0, 0x000a, 0x012f);
  2315. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2316. ibmcam_veio(uvd, 0, 0x005c, 0x0127);
  2317. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2318. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2319. ibmcam_veio(uvd, 0, 0x0004, 0x012f);
  2320. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2321. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2322. ibmcam_veio(uvd, 0, 0x00fb, 0x012e);
  2323. ibmcam_veio(uvd, 0, 0x0000, 0x0130);
  2324. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2325. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2326. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2327. ibmcam_veio(uvd, 0, 0x000c, 0x0127);
  2328. ibmcam_veio(uvd, 0, 0x0009, 0x012e);
  2329. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2330. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2331. ibmcam_veio(uvd, 0, 0x0012, 0x012f);
  2332. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2333. ibmcam_veio(uvd, 0, 0x0008, 0x0127);
  2334. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2335. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2336. ibmcam_veio(uvd, 0, 0x002a, 0x012d);
  2337. ibmcam_veio(uvd, 0, 0x0000, 0x012f);
  2338. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2339. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2340. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2341. ibmcam_veio(uvd, 0, 0x0034, 0x012f);
  2342. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2343. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2344. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2345. ibmcam_veio(uvd, 0, 0x0070, 0x0119);
  2346. ibmcam_veio(uvd, 0, 0x00d2, 0x0107);
  2347. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2348. ibmcam_veio(uvd, 0, 0x005e, 0x0107);
  2349. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2350. ibmcam_veio(uvd, 0, 0x00d0, 0x0111);
  2351. ibmcam_veio(uvd, 0, 0x0039, 0x010a);
  2352. ibmcam_veio(uvd, 0, 0x0001, 0x0102);
  2353. ibmcam_veio(uvd, 0, 0x0028, 0x0103);
  2354. ibmcam_veio(uvd, 0, 0x0000, 0x0104);
  2355. ibmcam_veio(uvd, 0, 0x001e, 0x0105);
  2356. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2357. ibmcam_veio(uvd, 0, 0x0016, 0x012f);
  2358. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2359. ibmcam_veio(uvd, 0, 0x000a, 0x0127);
  2360. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2361. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2362. ibmcam_veio(uvd, 0, 0x0014, 0x012d);
  2363. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2364. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2365. ibmcam_veio(uvd, 0, 0x00aa, 0x012e);
  2366. ibmcam_veio(uvd, 0, 0x001a, 0x0130);
  2367. ibmcam_veio(uvd, 0, 0x8a0a, 0x0124);
  2368. ibmcam_veio(uvd, 0, 0x005a, 0x012d);
  2369. ibmcam_veio(uvd, 0, 0x9545, 0x0124);
  2370. ibmcam_veio(uvd, 0, 0x00aa, 0x0127);
  2371. ibmcam_veio(uvd, 0, 0x0018, 0x012e);
  2372. ibmcam_veio(uvd, 0, 0x0043, 0x0130);
  2373. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2374. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2375. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2376. ibmcam_veio(uvd, 0, 0x001c, 0x0127);
  2377. ibmcam_veio(uvd, 0, 0x00eb, 0x012e);
  2378. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2379. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2380. ibmcam_veio(uvd, 0, 0x0032, 0x012f);
  2381. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2382. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2383. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2384. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2385. ibmcam_veio(uvd, 0, 0x0036, 0x012d);
  2386. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2387. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2388. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2389. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2390. ibmcam_veio(uvd, 0, 0x001e, 0x012f);
  2391. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2392. ibmcam_veio(uvd, 0, 0x0017, 0x0127);
  2393. ibmcam_veio(uvd, 0, 0x0013, 0x012e);
  2394. ibmcam_veio(uvd, 0, 0x0031, 0x0130);
  2395. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2396. ibmcam_veio(uvd, 0, 0x0017, 0x012d);
  2397. ibmcam_veio(uvd, 0, 0x0078, 0x012f);
  2398. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2399. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2400. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2401. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2402. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2403. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2404. ibmcam_veio(uvd, 0, 0x0004, 0x0127);
  2405. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2406. ibmcam_veio(uvd, 0, 0x00c0, 0x010c);
  2407. break;
  2408. case VIDEOSIZE_352x288:
  2409. ibmcam_veio(uvd, 0, 0x0000, 0x0100);
  2410. ibmcam_veio(uvd, 0, 0x00c0, 0x0111);
  2411. ibmcam_veio(uvd, 0, 0x00bc, 0x012c);
  2412. ibmcam_veio(uvd, 0, 0x0080, 0x012b);
  2413. ibmcam_veio(uvd, 0, 0x0000, 0x0108);
  2414. ibmcam_veio(uvd, 0, 0x0001, 0x0133);
  2415. ibmcam_veio(uvd, 0, 0x009b, 0x010f);
  2416. ibmcam_veio(uvd, 0, 0x00bb, 0x010f);
  2417. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2418. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2419. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2420. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2421. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2422. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2423. ibmcam_veio(uvd, 0, 0x000a, 0x012f);
  2424. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2425. ibmcam_veio(uvd, 0, 0x005c, 0x0127);
  2426. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2427. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2428. ibmcam_veio(uvd, 0, 0x0004, 0x012f);
  2429. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2430. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2431. ibmcam_veio(uvd, 0, 0x00fb, 0x012e);
  2432. ibmcam_veio(uvd, 0, 0x0000, 0x0130);
  2433. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2434. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2435. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2436. ibmcam_veio(uvd, 0, 0x000c, 0x0127);
  2437. ibmcam_veio(uvd, 0, 0x0009, 0x012e);
  2438. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2439. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2440. ibmcam_veio(uvd, 0, 0x0012, 0x012f);
  2441. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2442. ibmcam_veio(uvd, 0, 0x0008, 0x0127);
  2443. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2444. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2445. ibmcam_veio(uvd, 0, 0x002a, 0x012d);
  2446. ibmcam_veio(uvd, 0, 0x0000, 0x012f);
  2447. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2448. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2449. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2450. ibmcam_veio(uvd, 0, 0x0034, 0x012f);
  2451. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2452. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2453. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2454. ibmcam_veio(uvd, 0, 0x0070, 0x0119);
  2455. ibmcam_veio(uvd, 0, 0x00f2, 0x0107);
  2456. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2457. ibmcam_veio(uvd, 0, 0x008c, 0x0107);
  2458. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  2459. ibmcam_veio(uvd, 0, 0x00c0, 0x0111);
  2460. ibmcam_veio(uvd, 0, 0x0039, 0x010a);
  2461. ibmcam_veio(uvd, 0, 0x0001, 0x0102);
  2462. ibmcam_veio(uvd, 0, 0x002c, 0x0103);
  2463. ibmcam_veio(uvd, 0, 0x0000, 0x0104);
  2464. ibmcam_veio(uvd, 0, 0x0024, 0x0105);
  2465. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2466. ibmcam_veio(uvd, 0, 0x0016, 0x012f);
  2467. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2468. ibmcam_veio(uvd, 0, 0x0006, 0x0127);
  2469. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2470. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2471. ibmcam_veio(uvd, 0, 0x0014, 0x012d);
  2472. ibmcam_veio(uvd, 0, 0x0002, 0x012f);
  2473. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2474. ibmcam_veio(uvd, 0, 0x00aa, 0x012e);
  2475. ibmcam_veio(uvd, 0, 0x001a, 0x0130);
  2476. ibmcam_veio(uvd, 0, 0x8a0a, 0x0124);
  2477. ibmcam_veio(uvd, 0, 0x005e, 0x012d);
  2478. ibmcam_veio(uvd, 0, 0x9545, 0x0124);
  2479. ibmcam_veio(uvd, 0, 0x00aa, 0x0127);
  2480. ibmcam_veio(uvd, 0, 0x0018, 0x012e);
  2481. ibmcam_veio(uvd, 0, 0x0049, 0x0130);
  2482. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2483. ibmcam_veio(uvd, 0, 0x00aa, 0x012f);
  2484. ibmcam_veio(uvd, 0, 0xd055, 0x0124);
  2485. ibmcam_veio(uvd, 0, 0x001c, 0x0127);
  2486. ibmcam_veio(uvd, 0, 0x00cf, 0x012e);
  2487. ibmcam_veio(uvd, 0, 0xaa28, 0x0124);
  2488. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2489. ibmcam_veio(uvd, 0, 0x0032, 0x012f);
  2490. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2491. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2492. ibmcam_veio(uvd, 0, 0x00aa, 0x0130);
  2493. ibmcam_veio(uvd, 0, 0x82a8, 0x0124);
  2494. ibmcam_veio(uvd, 0, 0x0036, 0x012d);
  2495. ibmcam_veio(uvd, 0, 0x0008, 0x012f);
  2496. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2497. ibmcam_veio(uvd, 0, 0xfffa, 0x0124);
  2498. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2499. ibmcam_veio(uvd, 0, 0x001e, 0x012f);
  2500. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2501. ibmcam_veio(uvd, 0, 0x0010, 0x0127);
  2502. ibmcam_veio(uvd, 0, 0x0013, 0x012e);
  2503. ibmcam_veio(uvd, 0, 0x0025, 0x0130);
  2504. ibmcam_veio(uvd, 0, 0x8a28, 0x0124);
  2505. ibmcam_veio(uvd, 0, 0x0010, 0x012d);
  2506. ibmcam_veio(uvd, 0, 0x0048, 0x012f);
  2507. ibmcam_veio(uvd, 0, 0xd145, 0x0124);
  2508. ibmcam_veio(uvd, 0, 0x0000, 0x0127);
  2509. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2510. ibmcam_veio(uvd, 0, 0x00aa, 0x012d);
  2511. ibmcam_veio(uvd, 0, 0x0038, 0x012f);
  2512. ibmcam_veio(uvd, 0, 0xd141, 0x0124);
  2513. ibmcam_veio(uvd, 0, 0x0004, 0x0127);
  2514. ibmcam_veio(uvd, 0, 0xfea8, 0x0124);
  2515. ibmcam_veio(uvd, 0, 0x00c0, 0x010c);
  2516. break; 
  2517. }
  2518. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  2519. }
  2520. static void ibmcam_model3_setup_after_video_if(uvd_t *uvd)
  2521. {
  2522. int i;
  2523. /*
  2524.  * 01.01.08 - Added for RCA video in support -LO
  2525.  * This struct is used to init the Model3 cam to use the RCA video in port
  2526.  * instead of the CCD sensor.
  2527.  */
  2528. static const struct struct_initData initData[] = {
  2529. {0, 0x0000, 0x010c},
  2530. {0, 0x0006, 0x012c},
  2531. {0, 0x0078, 0x012d},
  2532. {0, 0x0046, 0x012f},
  2533. {0, 0xd141, 0x0124},
  2534. {0, 0x0000, 0x0127},
  2535. {0, 0xfea8, 0x0124},
  2536. {1, 0x0000, 0x0116},
  2537. {0, 0x0064, 0x0116},
  2538. {1, 0x0000, 0x0115},
  2539. {0, 0x0003, 0x0115},
  2540. {0, 0x0008, 0x0123},
  2541. {0, 0x0000, 0x0117},
  2542. {0, 0x0000, 0x0112},
  2543. {0, 0x0080, 0x0100},
  2544. {0, 0x0000, 0x0100},
  2545. {1, 0x0000, 0x0116},
  2546. {0, 0x0060, 0x0116},
  2547. {0, 0x0002, 0x0112},
  2548. {0, 0x0000, 0x0123},
  2549. {0, 0x0001, 0x0117},
  2550. {0, 0x0040, 0x0108},
  2551. {0, 0x0019, 0x012c},
  2552. {0, 0x0040, 0x0116},
  2553. {0, 0x000a, 0x0115},
  2554. {0, 0x000b, 0x0115},
  2555. {0, 0x0078, 0x012d},
  2556. {0, 0x0046, 0x012f},
  2557. {0, 0xd141, 0x0124},
  2558. {0, 0x0000, 0x0127},
  2559. {0, 0xfea8, 0x0124},
  2560. {0, 0x0064, 0x0116},
  2561. {0, 0x0000, 0x0115},
  2562. {0, 0x0001, 0x0115},
  2563. {0, 0xffff, 0x0124},
  2564. {0, 0xfff9, 0x0124},
  2565. {0, 0x0086, 0x0127},
  2566. {0, 0xfff8, 0x0124},
  2567. {0, 0xfffd, 0x0124},
  2568. {0, 0x00aa, 0x0127},
  2569. {0, 0xfff8, 0x0124},
  2570. {0, 0xfffd, 0x0124},
  2571. {0, 0x0000, 0x0127},
  2572. {0, 0xfff8, 0x0124},
  2573. {0, 0xfffd, 0x0124},
  2574. {0, 0xfffa, 0x0124},
  2575. {0, 0xffff, 0x0124},
  2576. {0, 0xfff9, 0x0124},
  2577. {0, 0x0086, 0x0127},
  2578. {0, 0xfff8, 0x0124},
  2579. {0, 0xfffd, 0x0124},
  2580. {0, 0x00f2, 0x0127},
  2581. {0, 0xfff8, 0x0124},
  2582. {0, 0xfffd, 0x0124},
  2583. {0, 0x000f, 0x0127},
  2584. {0, 0xfff8, 0x0124},
  2585. {0, 0xfffd, 0x0124},
  2586. {0, 0xfffa, 0x0124},
  2587. {0, 0xffff, 0x0124},
  2588. {0, 0xfff9, 0x0124},
  2589. {0, 0x0086, 0x0127},
  2590. {0, 0xfff8, 0x0124},
  2591. {0, 0xfffd, 0x0124},
  2592. {0, 0x00f8, 0x0127},
  2593. {0, 0xfff8, 0x0124},
  2594. {0, 0xfffd, 0x0124},
  2595. {0, 0x00fc, 0x0127},
  2596. {0, 0xfff8, 0x0124},
  2597. {0, 0xfffd, 0x0124},
  2598. {0, 0xfffa, 0x0124},
  2599. {0, 0xffff, 0x0124},
  2600. {0, 0xfff9, 0x0124},
  2601. {0, 0x0086, 0x0127},
  2602. {0, 0xfff8, 0x0124},
  2603. {0, 0xfffd, 0x0124},
  2604. {0, 0x00f9, 0x0127},
  2605. {0, 0xfff8, 0x0124},
  2606. {0, 0xfffd, 0x0124},
  2607. {0, 0x003c, 0x0127},
  2608. {0, 0xfff8, 0x0124},
  2609. {0, 0xfffd, 0x0124},
  2610. {0, 0xfffa, 0x0124},
  2611. {0, 0xffff, 0x0124},
  2612. {0, 0xfff9, 0x0124},
  2613. {0, 0x0086, 0x0127},
  2614. {0, 0xfff8, 0x0124},
  2615. {0, 0xfffd, 0x0124},
  2616. {0, 0x0027, 0x0127},
  2617. {0, 0xfff8, 0x0124},
  2618. {0, 0xfffd, 0x0124},
  2619. {0, 0x0019, 0x0127},
  2620. {0, 0xfff8, 0x0124},
  2621. {0, 0xfffd, 0x0124},
  2622. {0, 0xfffa, 0x0124},
  2623. {0, 0xfff9, 0x0124},
  2624. {0, 0x0086, 0x0127},
  2625. {0, 0xfff8, 0x0124},
  2626. {0, 0xfffd, 0x0124},
  2627. {0, 0x0037, 0x0127},
  2628. {0, 0xfff8, 0x0124},
  2629. {0, 0xfffd, 0x0124},
  2630. {0, 0x0000, 0x0127},
  2631. {0, 0xfff8, 0x0124},
  2632. {0, 0xfffd, 0x0124},
  2633. {0, 0x0021, 0x0127},
  2634. {0, 0xfff8, 0x0124},
  2635. {0, 0xfffd, 0x0124},
  2636. {0, 0xfffa, 0x0124},
  2637. {0, 0xfff9, 0x0124},
  2638. {0, 0x0086, 0x0127},
  2639. {0, 0xfff8, 0x0124},
  2640. {0, 0xfffd, 0x0124},
  2641. {0, 0x0038, 0x0127},
  2642. {0, 0xfff8, 0x0124},
  2643. {0, 0xfffd, 0x0124},
  2644. {0, 0x0006, 0x0127},
  2645. {0, 0xfff8, 0x0124},
  2646. {0, 0xfffd, 0x0124},
  2647. {0, 0x0045, 0x0127},
  2648. {0, 0xfff8, 0x0124},
  2649. {0, 0xfffd, 0x0124},
  2650. {0, 0xfffa, 0x0124},
  2651. {0, 0xfff9, 0x0124},
  2652. {0, 0x0086, 0x0127},
  2653. {0, 0xfff8, 0x0124},
  2654. {0, 0xfffd, 0x0124},
  2655. {0, 0x0037, 0x0127},
  2656. {0, 0xfff8, 0x0124},
  2657. {0, 0xfffd, 0x0124},
  2658. {0, 0x0001, 0x0127},
  2659. {0, 0xfff8, 0x0124},
  2660. {0, 0xfffd, 0x0124},
  2661. {0, 0x002a, 0x0127},
  2662. {0, 0xfff8, 0x0124},
  2663. {0, 0xfffd, 0x0124},
  2664. {0, 0xfffa, 0x0124},
  2665. {0, 0xfff9, 0x0124},
  2666. {0, 0x0086, 0x0127},
  2667. {0, 0xfff8, 0x0124},
  2668. {0, 0xfffd, 0x0124},
  2669. {0, 0x0038, 0x0127},
  2670. {0, 0xfff8, 0x0124},
  2671. {0, 0xfffd, 0x0124},
  2672. {0, 0x0000, 0x0127},
  2673. {0, 0xfff8, 0x0124},
  2674. {0, 0xfffd, 0x0124},
  2675. {0, 0x000e, 0x0127},
  2676. {0, 0xfff8, 0x0124},
  2677. {0, 0xfffd, 0x0124},
  2678. {0, 0xfffa, 0x0124},
  2679. {0, 0xfff9, 0x0124},
  2680. {0, 0x0086, 0x0127},
  2681. {0, 0xfff8, 0x0124},
  2682. {0, 0xfffd, 0x0124},
  2683. {0, 0x0037, 0x0127},
  2684. {0, 0xfff8, 0x0124},
  2685. {0, 0xfffd, 0x0124},
  2686. {0, 0x0001, 0x0127},
  2687. {0, 0xfff8, 0x0124},
  2688. {0, 0xfffd, 0x0124},
  2689. {0, 0x002b, 0x0127},
  2690. {0, 0xfff8, 0x0124},
  2691. {0, 0xfffd, 0x0124},
  2692. {0, 0xfffa, 0x0124},
  2693. {0, 0xfff9, 0x0124},
  2694. {0, 0x0086, 0x0127},
  2695. {0, 0xfff8, 0x0124},
  2696. {0, 0xfffd, 0x0124},
  2697. {0, 0x0038, 0x0127},
  2698. {0, 0xfff8, 0x0124},
  2699. {0, 0xfffd, 0x0124},
  2700. {0, 0x0001, 0x0127},
  2701. {0, 0xfff8, 0x0124},
  2702. {0, 0xfffd, 0x0124},
  2703. {0, 0x00f4, 0x0127},
  2704. {0, 0xfff8, 0x0124},
  2705. {0, 0xfffd, 0x0124},
  2706. {0, 0xfffa, 0x0124},
  2707. {0, 0xfff9, 0x0124},
  2708. {0, 0x0086, 0x0127},
  2709. {0, 0xfff8, 0x0124},
  2710. {0, 0xfffd, 0x0124},
  2711. {0, 0x0037, 0x0127},
  2712. {0, 0xfff8, 0x0124},
  2713. {0, 0xfffd, 0x0124},
  2714. {0, 0x0001, 0x0127},
  2715. {0, 0xfff8, 0x0124},
  2716. {0, 0xfffd, 0x0124},
  2717. {0, 0x002c, 0x0127},
  2718. {0, 0xfff8, 0x0124},
  2719. {0, 0xfffd, 0x0124},
  2720. {0, 0xfffa, 0x0124},
  2721. {0, 0xfff9, 0x0124},
  2722. {0, 0x0086, 0x0127},
  2723. {0, 0xfff8, 0x0124},
  2724. {0, 0xfffd, 0x0124},
  2725. {0, 0x0038, 0x0127},
  2726. {0, 0xfff8, 0x0124},
  2727. {0, 0xfffd, 0x0124},
  2728. {0, 0x0001, 0x0127},
  2729. {0, 0xfff8, 0x0124},
  2730. {0, 0xfffd, 0x0124},
  2731. {0, 0x0004, 0x0127},
  2732. {0, 0xfff8, 0x0124},
  2733. {0, 0xfffd, 0x0124},
  2734. {0, 0xfffa, 0x0124},
  2735. {0, 0xfff9, 0x0124},
  2736. {0, 0x0086, 0x0127},
  2737. {0, 0xfff8, 0x0124},
  2738. {0, 0xfffd, 0x0124},
  2739. {0, 0x0037, 0x0127},
  2740. {0, 0xfff8, 0x0124},
  2741. {0, 0xfffd, 0x0124},
  2742. {0, 0x0001, 0x0127},
  2743. {0, 0xfff8, 0x0124},
  2744. {0, 0xfffd, 0x0124},
  2745. {0, 0x002d, 0x0127},
  2746. {0, 0xfff8, 0x0124},
  2747. {0, 0xfffd, 0x0124},
  2748. {0, 0xfffa, 0x0124},
  2749. {0, 0xfff9, 0x0124},
  2750. {0, 0x0086, 0x0127},
  2751. {0, 0xfff8, 0x0124},
  2752. {0, 0xfffd, 0x0124},
  2753. {0, 0x0038, 0x0127},
  2754. {0, 0xfff8, 0x0124},
  2755. {0, 0xfffd, 0x0124},
  2756. {0, 0x0000, 0x0127},
  2757. {0, 0xfff8, 0x0124},
  2758. {0, 0xfffd, 0x0124},
  2759. {0, 0x0014, 0x0127},
  2760. {0, 0xfff8, 0x0124},
  2761. {0, 0xfffd, 0x0124},
  2762. {0, 0xfffa, 0x0124},
  2763. {0, 0xfff9, 0x0124},
  2764. {0, 0x0086, 0x0127},
  2765. {0, 0xfff8, 0x0124},
  2766. {0, 0xfffd, 0x0124},
  2767. {0, 0x0037, 0x0127},
  2768. {0, 0xfff8, 0x0124},
  2769. {0, 0xfffd, 0x0124},
  2770. {0, 0x0001, 0x0127},
  2771. {0, 0xfff8, 0x0124},
  2772. {0, 0xfffd, 0x0124},
  2773. {0, 0x002e, 0x0127},
  2774. {0, 0xfff8, 0x0124},
  2775. {0, 0xfffd, 0x0124},
  2776. {0, 0xfffa, 0x0124},
  2777. {0, 0xfff9, 0x0124},
  2778. {0, 0x0086, 0x0127},
  2779. {0, 0xfff8, 0x0124},
  2780. {0, 0xfffd, 0x0124},
  2781. {0, 0x0038, 0x0127},
  2782. {0, 0xfff8, 0x0124},
  2783. {0, 0xfffd, 0x0124},
  2784. {0, 0x0003, 0x0127},
  2785. {0, 0xfff8, 0x0124},
  2786. {0, 0xfffd, 0x0124},
  2787. {0, 0x0000, 0x0127},
  2788. {0, 0xfff8, 0x0124},
  2789. {0, 0xfffd, 0x0124},
  2790. {0, 0xfffa, 0x0124},
  2791. {0, 0xfff9, 0x0124},
  2792. {0, 0x0086, 0x0127},
  2793. {0, 0xfff8, 0x0124},
  2794. {0, 0xfffd, 0x0124},
  2795. {0, 0x0037, 0x0127},
  2796. {0, 0xfff8, 0x0124},
  2797. {0, 0xfffd, 0x0124},
  2798. {0, 0x0001, 0x0127},
  2799. {0, 0xfff8, 0x0124},
  2800. {0, 0xfffd, 0x0124},
  2801. {0, 0x002f, 0x0127},
  2802. {0, 0xfff8, 0x0124},
  2803. {0, 0xfffd, 0x0124},
  2804. {0, 0xfffa, 0x0124},
  2805. {0, 0xfff9, 0x0124},
  2806. {0, 0x0086, 0x0127},
  2807. {0, 0xfff8, 0x0124},
  2808. {0, 0xfffd, 0x0124},
  2809. {0, 0x0038, 0x0127},
  2810. {0, 0xfff8, 0x0124},
  2811. {0, 0xfffd, 0x0124},
  2812. {0, 0x0003, 0x0127},
  2813. {0, 0xfff8, 0x0124},
  2814. {0, 0xfffd, 0x0124},
  2815. {0, 0x0014, 0x0127},
  2816. {0, 0xfff8, 0x0124},
  2817. {0, 0xfffd, 0x0124},
  2818. {0, 0xfffa, 0x0124},
  2819. {0, 0xfff9, 0x0124},
  2820. {0, 0x0086, 0x0127},
  2821. {0, 0xfff8, 0x0124},
  2822. {0, 0xfffd, 0x0124},
  2823. {0, 0x0037, 0x0127},
  2824. {0, 0xfff8, 0x0124},
  2825. {0, 0xfffd, 0x0124},
  2826. {0, 0x0001, 0x0127},
  2827. {0, 0xfff8, 0x0124},
  2828. {0, 0xfffd, 0x0124},
  2829. {0, 0x0040, 0x0127},
  2830. {0, 0xfff8, 0x0124},
  2831. {0, 0xfffd, 0x0124},
  2832. {0, 0xfffa, 0x0124},
  2833. {0, 0xfff9, 0x0124},
  2834. {0, 0x0086, 0x0127},
  2835. {0, 0xfff8, 0x0124},
  2836. {0, 0xfffd, 0x0124},
  2837. {0, 0x0038, 0x0127},
  2838. {0, 0xfff8, 0x0124},
  2839. {0, 0xfffd, 0x0124},
  2840. {0, 0x0000, 0x0127},
  2841. {0, 0xfff8, 0x0124},
  2842. {0, 0xfffd, 0x0124},
  2843. {0, 0x0040, 0x0127},
  2844. {0, 0xfff8, 0x0124},
  2845. {0, 0xfffd, 0x0124},
  2846. {0, 0xfffa, 0x0124},
  2847. {0, 0xfff9, 0x0124},
  2848. {0, 0x0086, 0x0127},
  2849. {0, 0xfff8, 0x0124},
  2850. {0, 0xfffd, 0x0124},
  2851. {0, 0x0037, 0x0127},
  2852. {0, 0xfff8, 0x0124},
  2853. {0, 0xfffd, 0x0124},
  2854. {0, 0x0001, 0x0127},
  2855. {0, 0xfff8, 0x0124},
  2856. {0, 0xfffd, 0x0124},
  2857. {0, 0x0053, 0x0127},
  2858. {0, 0xfff8, 0x0124},
  2859. {0, 0xfffd, 0x0124},
  2860. {0, 0xfffa, 0x0124},
  2861. {0, 0xfff9, 0x0124},
  2862. {0, 0x0086, 0x0127},
  2863. {0, 0xfff8, 0x0124},
  2864. {0, 0xfffd, 0x0124},
  2865. {0, 0x0038, 0x0127},
  2866. {0, 0xfff8, 0x0124},
  2867. {0, 0xfffd, 0x0124},
  2868. {0, 0x0000, 0x0127},
  2869. {0, 0xfff8, 0x0124},
  2870. {0, 0xfffd, 0x0124},
  2871. {0, 0x0038, 0x0127},
  2872. {0, 0xfff8, 0x0124},
  2873. {0, 0xfffd, 0x0124},
  2874. {0, 0xfffa, 0x0124},
  2875. {0, 0x0000, 0x0101},
  2876. {0, 0x00a0, 0x0103},
  2877. {0, 0x0078, 0x0105},
  2878. {0, 0x0000, 0x010a},
  2879. {0, 0x0024, 0x010b},
  2880. {0, 0x0028, 0x0119},
  2881. {0, 0x0088, 0x011b},
  2882. {0, 0x0002, 0x011d},
  2883. {0, 0x0003, 0x011e},
  2884. {0, 0x0000, 0x0129},
  2885. {0, 0x00fc, 0x012b},
  2886. {0, 0x0008, 0x0102},
  2887. {0, 0x0000, 0x0104},
  2888. {0, 0x0008, 0x011a},
  2889. {0, 0x0028, 0x011c},
  2890. {0, 0x0021, 0x012a},
  2891. {0, 0x0000, 0x0118},
  2892. {0, 0x0000, 0x0132},
  2893. {0, 0x0000, 0x0109},
  2894. {0, 0xfff9, 0x0124},
  2895. {0, 0x0086, 0x0127},
  2896. {0, 0xfff8, 0x0124},
  2897. {0, 0xfffd, 0x0124},
  2898. {0, 0x0037, 0x0127},
  2899. {0, 0xfff8, 0x0124},
  2900. {0, 0xfffd, 0x0124},
  2901. {0, 0x0001, 0x0127},
  2902. {0, 0xfff8, 0x0124},
  2903. {0, 0xfffd, 0x0124},
  2904. {0, 0x0031, 0x0127},
  2905. {0, 0xfff8, 0x0124},
  2906. {0, 0xfffd, 0x0124},
  2907. {0, 0xfffa, 0x0124},
  2908. {0, 0xfff9, 0x0124},
  2909. {0, 0x0086, 0x0127},
  2910. {0, 0xfff8, 0x0124},
  2911. {0, 0xfffd, 0x0124},
  2912. {0, 0x0038, 0x0127},
  2913. {0, 0xfff8, 0x0124},
  2914. {0, 0xfffd, 0x0124},
  2915. {0, 0x0000, 0x0127},
  2916. {0, 0xfff8, 0x0124},
  2917. {0, 0xfffd, 0x0124},
  2918. {0, 0x0000, 0x0127},
  2919. {0, 0xfff8, 0x0124},
  2920. {0, 0xfffd, 0x0124},
  2921. {0, 0xfffa, 0x0124},
  2922. {0, 0xfff9, 0x0124},
  2923. {0, 0x0086, 0x0127},
  2924. {0, 0xfff8, 0x0124},
  2925. {0, 0xfffd, 0x0124},
  2926. {0, 0x0037, 0x0127},
  2927. {0, 0xfff8, 0x0124},
  2928. {0, 0xfffd, 0x0124},
  2929. {0, 0x0001, 0x0127},
  2930. {0, 0xfff8, 0x0124},
  2931. {0, 0xfffd, 0x0124},
  2932. {0, 0x0040, 0x0127},
  2933. {0, 0xfff8, 0x0124},
  2934. {0, 0xfffd, 0x0124},
  2935. {0, 0xfffa, 0x0124},
  2936. {0, 0xfff9, 0x0124},
  2937. {0, 0x0086, 0x0127},
  2938. {0, 0xfff8, 0x0124},
  2939. {0, 0xfffd, 0x0124},
  2940. {0, 0x0038, 0x0127},
  2941. {0, 0xfff8, 0x0124},
  2942. {0, 0xfffd, 0x0124},
  2943. {0, 0x0000, 0x0127},
  2944. {0, 0xfff8, 0x0124},
  2945. {0, 0xfffd, 0x0124},
  2946. {0, 0x0040, 0x0127},
  2947. {0, 0xfff8, 0x0124},
  2948. {0, 0xfffd, 0x0124},
  2949. {0, 0xfffa, 0x0124},
  2950. {0, 0xfff9, 0x0124},
  2951. {0, 0x0086, 0x0127},
  2952. {0, 0xfff8, 0x0124},
  2953. {0, 0xfffd, 0x0124},
  2954. {0, 0x0037, 0x0127},
  2955. {0, 0xfff8, 0x0124},
  2956. {0, 0xfffd, 0x0124},
  2957. {0, 0x0000, 0x0127},
  2958. {0, 0xfff8, 0x0124},
  2959. {0, 0xfffd, 0x0124},
  2960. {0, 0x00dc, 0x0127},
  2961. {0, 0xfff8, 0x0124},
  2962. {0, 0xfffd, 0x0124},
  2963. {0, 0xfffa, 0x0124},
  2964. {0, 0xfff9, 0x0124},
  2965. {0, 0x0086, 0x0127},
  2966. {0, 0xfff8, 0x0124},
  2967. {0, 0xfffd, 0x0124},
  2968. {0, 0x0038, 0x0127},
  2969. {0, 0xfff8, 0x0124},
  2970. {0, 0xfffd, 0x0124},
  2971. {0, 0x0000, 0x0127},
  2972. {0, 0xfff8, 0x0124},
  2973. {0, 0xfffd, 0x0124},
  2974. {0, 0x0000, 0x0127},
  2975. {0, 0xfff8, 0x0124},
  2976. {0, 0xfffd, 0x0124},
  2977. {0, 0xfffa, 0x0124},
  2978. {0, 0xfff9, 0x0124},
  2979. {0, 0x0086, 0x0127},
  2980. {0, 0xfff8, 0x0124},
  2981. {0, 0xfffd, 0x0124},
  2982. {0, 0x0037, 0x0127},
  2983. {0, 0xfff8, 0x0124},
  2984. {0, 0xfffd, 0x0124},
  2985. {0, 0x0001, 0x0127},
  2986. {0, 0xfff8, 0x0124},
  2987. {0, 0xfffd, 0x0124},
  2988. {0, 0x0032, 0x0127},
  2989. {0, 0xfff8, 0x0124},
  2990. {0, 0xfffd, 0x0124},
  2991. {0, 0xfffa, 0x0124},
  2992. {0, 0xfff9, 0x0124},
  2993. {0, 0x0086, 0x0127},
  2994. {0, 0xfff8, 0x0124},
  2995. {0, 0xfffd, 0x0124},
  2996. {0, 0x0038, 0x0127},
  2997. {0, 0xfff8, 0x0124},
  2998. {0, 0xfffd, 0x0124},
  2999. {0, 0x0001, 0x0127},
  3000. {0, 0xfff8, 0x0124},
  3001. {0, 0xfffd, 0x0124},
  3002. {0, 0x0020, 0x0127},
  3003. {0, 0xfff8, 0x0124},
  3004. {0, 0xfffd, 0x0124},
  3005. {0, 0xfffa, 0x0124},
  3006. {0, 0xfff9, 0x0124},
  3007. {0, 0x0086, 0x0127},
  3008. {0, 0xfff8, 0x0124},
  3009. {0, 0xfffd, 0x0124},
  3010. {0, 0x0037, 0x0127},
  3011. {0, 0xfff8, 0x0124},
  3012. {0, 0xfffd, 0x0124},
  3013. {0, 0x0001, 0x0127},
  3014. {0, 0xfff8, 0x0124},
  3015. {0, 0xfffd, 0x0124},
  3016. {0, 0x0040, 0x0127},
  3017. {0, 0xfff8, 0x0124},
  3018. {0, 0xfffd, 0x0124},
  3019. {0, 0xfffa, 0x0124},
  3020. {0, 0xfff9, 0x0124},
  3021. {0, 0x0086, 0x0127},
  3022. {0, 0xfff8, 0x0124},
  3023. {0, 0xfffd, 0x0124},
  3024. {0, 0x0038, 0x0127},
  3025. {0, 0xfff8, 0x0124},
  3026. {0, 0xfffd, 0x0124},
  3027. {0, 0x0000, 0x0127},
  3028. {0, 0xfff8, 0x0124},
  3029. {0, 0xfffd, 0x0124},
  3030. {0, 0x0040, 0x0127},
  3031. {0, 0xfff8, 0x0124},
  3032. {0, 0xfffd, 0x0124},
  3033. {0, 0xfffa, 0x0124},
  3034. {0, 0xfff9, 0x0124},
  3035. {0, 0x0086, 0x0127},
  3036. {0, 0xfff8, 0x0124},
  3037. {0, 0xfffd, 0x0124},
  3038. {0, 0x0037, 0x0127},
  3039. {0, 0xfff8, 0x0124},
  3040. {0, 0xfffd, 0x0124},
  3041. {0, 0x0000, 0x0127},
  3042. {0, 0xfff8, 0x0124},
  3043. {0, 0xfffd, 0x0124},
  3044. {0, 0x0030, 0x0127},
  3045. {0, 0xfff8, 0x0124},
  3046. {0, 0xfffd, 0x0124},
  3047. {0, 0xfffa, 0x0124},
  3048. {0, 0xfff9, 0x0124},
  3049. {0, 0x0086, 0x0127},
  3050. {0, 0xfff8, 0x0124},
  3051. {0, 0xfffd, 0x0124},
  3052. {0, 0x0038, 0x0127},
  3053. {0, 0xfff8, 0x0124},
  3054. {0, 0xfffd, 0x0124},
  3055. {0, 0x0008, 0x0127},
  3056. {0, 0xfff8, 0x0124},
  3057. {0, 0xfffd, 0x0124},
  3058. {0, 0x0000, 0x0127},
  3059. {0, 0xfff8, 0x0124},
  3060. {0, 0xfffd, 0x0124},
  3061. {0, 0xfffa, 0x0124},
  3062. {0, 0x0003, 0x0106},
  3063. {0, 0x0062, 0x0107},
  3064. {0, 0x0003, 0x0111},
  3065. };
  3066. #define NUM_INIT_DATA 
  3067. unsigned short compression = 0; /* 0=none, 7=best frame rate  */
  3068. int f_rate; /* 0=Fastest 7=slowest */
  3069. if (IBMCAM_T(uvd)->initialized)
  3070. return;
  3071. /* Internal frame rate is controlled by f_rate value */
  3072. f_rate = 7 - framerate;
  3073. RESTRICT_TO_RANGE(f_rate, 0, 7);
  3074. ibmcam_veio(uvd, 0, 0x0000, 0x0100);
  3075. ibmcam_veio(uvd, 1, 0x0000, 0x0116);
  3076. ibmcam_veio(uvd, 0, 0x0060, 0x0116);
  3077. ibmcam_veio(uvd, 0, 0x0002, 0x0112);
  3078. ibmcam_veio(uvd, 0, 0x0000, 0x0123);
  3079. ibmcam_veio(uvd, 0, 0x0001, 0x0117);
  3080. ibmcam_veio(uvd, 0, 0x0040, 0x0108);
  3081. ibmcam_veio(uvd, 0, 0x0019, 0x012c);
  3082. ibmcam_veio(uvd, 0, 0x0060, 0x0116);
  3083. ibmcam_veio(uvd, 0, 0x0002, 0x0115);
  3084. ibmcam_veio(uvd, 0, 0x0003, 0x0115);
  3085. ibmcam_veio(uvd, 1, 0x0000, 0x0115);
  3086. ibmcam_veio(uvd, 0, 0x000b, 0x0115);
  3087. ibmcam_model3_Packet1(uvd, 0x000a, 0x0040);
  3088. ibmcam_model3_Packet1(uvd, 0x000b, 0x00f6);
  3089. ibmcam_model3_Packet1(uvd, 0x000c, 0x0002);
  3090. ibmcam_model3_Packet1(uvd, 0x000d, 0x0020);
  3091. ibmcam_model3_Packet1(uvd, 0x000e, 0x0033);
  3092. ibmcam_model3_Packet1(uvd, 0x000f, 0x0007);
  3093. ibmcam_model3_Packet1(uvd, 0x0010, 0x0000);
  3094. ibmcam_model3_Packet1(uvd, 0x0011, 0x0070);
  3095. ibmcam_model3_Packet1(uvd, 0x0012, 0x0030);
  3096. ibmcam_model3_Packet1(uvd, 0x0013, 0x0000);
  3097. ibmcam_model3_Packet1(uvd, 0x0014, 0x0001);
  3098. ibmcam_model3_Packet1(uvd, 0x0015, 0x0001);
  3099. ibmcam_model3_Packet1(uvd, 0x0016, 0x0001);
  3100. ibmcam_model3_Packet1(uvd, 0x0017, 0x0001);
  3101. ibmcam_model3_Packet1(uvd, 0x0018, 0x0000);
  3102. ibmcam_model3_Packet1(uvd, 0x001e, 0x00c3);
  3103. ibmcam_model3_Packet1(uvd, 0x0020, 0x0000);
  3104. ibmcam_model3_Packet1(uvd, 0x0028, 0x0010);
  3105. ibmcam_model3_Packet1(uvd, 0x0029, 0x0054);
  3106. ibmcam_model3_Packet1(uvd, 0x002a, 0x0013);
  3107. ibmcam_model3_Packet1(uvd, 0x002b, 0x0007);
  3108. ibmcam_model3_Packet1(uvd, 0x002d, 0x0028);
  3109. ibmcam_model3_Packet1(uvd, 0x002e, 0x0000);
  3110. ibmcam_model3_Packet1(uvd, 0x0031, 0x0000);
  3111. ibmcam_model3_Packet1(uvd, 0x0032, 0x0000);
  3112. ibmcam_model3_Packet1(uvd, 0x0033, 0x0000);
  3113. ibmcam_model3_Packet1(uvd, 0x0034, 0x0000);
  3114. ibmcam_model3_Packet1(uvd, 0x0035, 0x0038);
  3115. ibmcam_model3_Packet1(uvd, 0x003a, 0x0001);
  3116. ibmcam_model3_Packet1(uvd, 0x003c, 0x001e);
  3117. ibmcam_model3_Packet1(uvd, 0x003f, 0x000a);
  3118. ibmcam_model3_Packet1(uvd, 0x0041, 0x0000);
  3119. ibmcam_model3_Packet1(uvd, 0x0046, 0x003f);
  3120. ibmcam_model3_Packet1(uvd, 0x0047, 0x0000);
  3121. ibmcam_model3_Packet1(uvd, 0x0050, 0x0005);
  3122. ibmcam_model3_Packet1(uvd, 0x0052, 0x001a);
  3123. ibmcam_model3_Packet1(uvd, 0x0053, 0x0003);
  3124. ibmcam_model3_Packet1(uvd, 0x005a, 0x006b);
  3125. ibmcam_model3_Packet1(uvd, 0x005d, 0x001e);
  3126. ibmcam_model3_Packet1(uvd, 0x005e, 0x0030);
  3127. ibmcam_model3_Packet1(uvd, 0x005f, 0x0041);
  3128. ibmcam_model3_Packet1(uvd, 0x0064, 0x0008);
  3129. ibmcam_model3_Packet1(uvd, 0x0065, 0x0015);
  3130. ibmcam_model3_Packet1(uvd, 0x0068, 0x000f);
  3131. ibmcam_model3_Packet1(uvd, 0x0079, 0x0000);
  3132. ibmcam_model3_Packet1(uvd, 0x007a, 0x0000);
  3133. ibmcam_model3_Packet1(uvd, 0x007c, 0x003f);
  3134. ibmcam_model3_Packet1(uvd, 0x0082, 0x000f);
  3135. ibmcam_model3_Packet1(uvd, 0x0085, 0x0000);
  3136. ibmcam_model3_Packet1(uvd, 0x0099, 0x0000);
  3137. ibmcam_model3_Packet1(uvd, 0x009b, 0x0023);
  3138. ibmcam_model3_Packet1(uvd, 0x009c, 0x0022);
  3139. ibmcam_model3_Packet1(uvd, 0x009d, 0x0096);
  3140. ibmcam_model3_Packet1(uvd, 0x009e, 0x0096);
  3141. ibmcam_model3_Packet1(uvd, 0x009f, 0x000a);
  3142. switch (uvd->videosize) {
  3143. case VIDEOSIZE_160x120:
  3144. ibmcam_veio(uvd, 0, 0x0000, 0x0101); /* Same on 176x144, 320x240 */
  3145. ibmcam_veio(uvd, 0, 0x00a0, 0x0103); /* Same on 176x144, 320x240 */
  3146. ibmcam_veio(uvd, 0, 0x0078, 0x0105); /* Same on 176x144, 320x240 */
  3147. ibmcam_veio(uvd, 0, 0x0000, 0x010a); /* Same */
  3148. ibmcam_veio(uvd, 0, 0x0024, 0x010b); /* Differs everywhere */
  3149. ibmcam_veio(uvd, 0, 0x00a9, 0x0119);
  3150. ibmcam_veio(uvd, 0, 0x0016, 0x011b);
  3151. ibmcam_veio(uvd, 0, 0x0002, 0x011d); /* Same on 176x144, 320x240 */
  3152. ibmcam_veio(uvd, 0, 0x0003, 0x011e); /* Same on 176x144, 640x480 */
  3153. ibmcam_veio(uvd, 0, 0x0000, 0x0129); /* Same */
  3154. ibmcam_veio(uvd, 0, 0x00fc, 0x012b); /* Same */
  3155. ibmcam_veio(uvd, 0, 0x0018, 0x0102);
  3156. ibmcam_veio(uvd, 0, 0x0004, 0x0104);
  3157. ibmcam_veio(uvd, 0, 0x0004, 0x011a);
  3158. ibmcam_veio(uvd, 0, 0x0028, 0x011c);
  3159. ibmcam_veio(uvd, 0, 0x0022, 0x012a); /* Same */
  3160. ibmcam_veio(uvd, 0, 0x0000, 0x0118);
  3161. ibmcam_veio(uvd, 0, 0x0000, 0x0132);
  3162. ibmcam_model3_Packet1(uvd, 0x0021, 0x0001); /* Same */
  3163. ibmcam_veio(uvd, 0, compression, 0x0109);
  3164. break;
  3165. case VIDEOSIZE_320x240:
  3166. ibmcam_veio(uvd, 0, 0x0000, 0x0101); /* Same on 176x144, 320x240 */
  3167. ibmcam_veio(uvd, 0, 0x00a0, 0x0103); /* Same on 176x144, 320x240 */
  3168. ibmcam_veio(uvd, 0, 0x0078, 0x0105); /* Same on 176x144, 320x240 */
  3169. ibmcam_veio(uvd, 0, 0x0000, 0x010a); /* Same */
  3170. ibmcam_veio(uvd, 0, 0x0028, 0x010b); /* Differs everywhere */
  3171. ibmcam_veio(uvd, 0, 0x0002, 0x011d); /* Same */
  3172. ibmcam_veio(uvd, 0, 0x0000, 0x011e);
  3173. ibmcam_veio(uvd, 0, 0x0000, 0x0129); /* Same */
  3174. ibmcam_veio(uvd, 0, 0x00fc, 0x012b); /* Same */
  3175. /* 4 commands from 160x120 skipped */
  3176. ibmcam_veio(uvd, 0, 0x0022, 0x012a); /* Same */
  3177. ibmcam_model3_Packet1(uvd, 0x0021, 0x0001); /* Same */
  3178. ibmcam_veio(uvd, 0, compression, 0x0109);
  3179. ibmcam_veio(uvd, 0, 0x00d9, 0x0119);
  3180. ibmcam_veio(uvd, 0, 0x0006, 0x011b);
  3181. ibmcam_veio(uvd, 0, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
  3182. ibmcam_veio(uvd, 0, 0x0010, 0x0104);
  3183. ibmcam_veio(uvd, 0, 0x0004, 0x011a);
  3184. ibmcam_veio(uvd, 0, 0x003f, 0x011c);
  3185. ibmcam_veio(uvd, 0, 0x001c, 0x0118);
  3186. ibmcam_veio(uvd, 0, 0x0000, 0x0132);
  3187. break;
  3188. case VIDEOSIZE_640x480:
  3189. ibmcam_veio(uvd, 0, 0x00f0, 0x0105);
  3190. ibmcam_veio(uvd, 0, 0x0000, 0x010a); /* Same */
  3191. ibmcam_veio(uvd, 0, 0x0038, 0x010b); /* Differs everywhere */
  3192. ibmcam_veio(uvd, 0, 0x00d9, 0x0119); /* Same on 320x240, 640x480 */
  3193. ibmcam_veio(uvd, 0, 0x0006, 0x011b); /* Same on 320x240, 640x480 */
  3194. ibmcam_veio(uvd, 0, 0x0004, 0x011d); /* NC */
  3195. ibmcam_veio(uvd, 0, 0x0003, 0x011e); /* Same on 176x144, 640x480 */
  3196. ibmcam_veio(uvd, 0, 0x0000, 0x0129); /* Same */
  3197. ibmcam_veio(uvd, 0, 0x00fc, 0x012b); /* Same */
  3198. ibmcam_veio(uvd, 0, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
  3199. ibmcam_veio(uvd, 0, 0x0016, 0x0104); /* NC */
  3200. ibmcam_veio(uvd, 0, 0x0004, 0x011a); /* Same on 320x240, 640x480 */
  3201. ibmcam_veio(uvd, 0, 0x003f, 0x011c); /* Same on 320x240, 640x480 */
  3202. ibmcam_veio(uvd, 0, 0x0022, 0x012a); /* Same */
  3203. ibmcam_veio(uvd, 0, 0x001c, 0x0118); /* Same on 320x240, 640x480 */
  3204. ibmcam_model3_Packet1(uvd, 0x0021, 0x0001); /* Same */
  3205. ibmcam_veio(uvd, 0, compression, 0x0109);
  3206. ibmcam_veio(uvd, 0, 0x0040, 0x0101);
  3207. ibmcam_veio(uvd, 0, 0x0040, 0x0103);
  3208. ibmcam_veio(uvd, 0, 0x0000, 0x0132); /* Same on 320x240, 640x480 */
  3209. break;
  3210. }
  3211. ibmcam_model3_Packet1(uvd, 0x007e, 0x000e); /* Hue */
  3212. ibmcam_model3_Packet1(uvd, 0x0036, 0x0011); /* Brightness */
  3213. ibmcam_model3_Packet1(uvd, 0x0060, 0x0002); /* Sharpness */
  3214. ibmcam_model3_Packet1(uvd, 0x0061, 0x0004); /* Sharpness */
  3215. ibmcam_model3_Packet1(uvd, 0x0062, 0x0005); /* Sharpness */
  3216. ibmcam_model3_Packet1(uvd, 0x0063, 0x0014); /* Sharpness */
  3217. ibmcam_model3_Packet1(uvd, 0x0096, 0x00a0); /* Red gain */
  3218. ibmcam_model3_Packet1(uvd, 0x0097, 0x0096); /* Blue gain */
  3219. ibmcam_model3_Packet1(uvd, 0x0067, 0x0001); /* Contrast */
  3220. ibmcam_model3_Packet1(uvd, 0x005b, 0x000c); /* Contrast */
  3221. ibmcam_model3_Packet1(uvd, 0x005c, 0x0016); /* Contrast */
  3222. ibmcam_model3_Packet1(uvd, 0x0098, 0x000b);
  3223. ibmcam_model3_Packet1(uvd, 0x002c, 0x0003); /* Was 1, broke 640x480 */
  3224. ibmcam_model3_Packet1(uvd, 0x002f, 0x002a);
  3225. ibmcam_model3_Packet1(uvd, 0x0030, 0x0029);
  3226. ibmcam_model3_Packet1(uvd, 0x0037, 0x0002);
  3227. ibmcam_model3_Packet1(uvd, 0x0038, 0x0059);
  3228. ibmcam_model3_Packet1(uvd, 0x003d, 0x002e);
  3229. ibmcam_model3_Packet1(uvd, 0x003e, 0x0028);
  3230. ibmcam_model3_Packet1(uvd, 0x0078, 0x0005);
  3231. ibmcam_model3_Packet1(uvd, 0x007b, 0x0011);
  3232. ibmcam_model3_Packet1(uvd, 0x007d, 0x004b);
  3233. ibmcam_model3_Packet1(uvd, 0x007f, 0x0022);
  3234. ibmcam_model3_Packet1(uvd, 0x0080, 0x000c);
  3235. ibmcam_model3_Packet1(uvd, 0x0081, 0x000b);
  3236. ibmcam_model3_Packet1(uvd, 0x0083, 0x00fd);
  3237. ibmcam_model3_Packet1(uvd, 0x0086, 0x000b);
  3238. ibmcam_model3_Packet1(uvd, 0x0087, 0x000b);
  3239. ibmcam_model3_Packet1(uvd, 0x007e, 0x000e);
  3240. ibmcam_model3_Packet1(uvd, 0x0096, 0x00a0); /* Red gain */
  3241. ibmcam_model3_Packet1(uvd, 0x0097, 0x0096); /* Blue gain */
  3242. ibmcam_model3_Packet1(uvd, 0x0098, 0x000b);
  3243. switch (uvd->videosize) {
  3244. case VIDEOSIZE_160x120:
  3245. ibmcam_veio(uvd, 0, 0x0002, 0x0106);
  3246. ibmcam_veio(uvd, 0, 0x0008, 0x0107);
  3247. ibmcam_veio(uvd, 0, f_rate, 0x0111); /* Frame rate */
  3248. ibmcam_model3_Packet1(uvd, 0x001f, 0x0000); /* Same */
  3249. ibmcam_model3_Packet1(uvd, 0x0039, 0x001f); /* Same */
  3250. ibmcam_model3_Packet1(uvd, 0x003b, 0x003c); /* Same */
  3251. ibmcam_model3_Packet1(uvd, 0x0040, 0x000a);
  3252. ibmcam_model3_Packet1(uvd, 0x0051, 0x000a);
  3253. break;
  3254. case VIDEOSIZE_320x240:
  3255. ibmcam_veio(uvd, 0, 0x0003, 0x0106);
  3256. ibmcam_veio(uvd, 0, 0x0062, 0x0107);
  3257. ibmcam_veio(uvd, 0, f_rate, 0x0111); /* Frame rate */
  3258. ibmcam_model3_Packet1(uvd, 0x001f, 0x0000); /* Same */
  3259. ibmcam_model3_Packet1(uvd, 0x0039, 0x001f); /* Same */
  3260. ibmcam_model3_Packet1(uvd, 0x003b, 0x003c); /* Same */
  3261. ibmcam_model3_Packet1(uvd, 0x0040, 0x0008);
  3262. ibmcam_model3_Packet1(uvd, 0x0051, 0x000b);
  3263. break;
  3264. case VIDEOSIZE_640x480:
  3265. ibmcam_veio(uvd, 0, 0x0002, 0x0106); /* Adjustments */
  3266. ibmcam_veio(uvd, 0, 0x00b4, 0x0107); /* Adjustments */
  3267. ibmcam_veio(uvd, 0, f_rate, 0x0111); /* Frame rate */
  3268. ibmcam_model3_Packet1(uvd, 0x001f, 0x0002); /* !Same */
  3269. ibmcam_model3_Packet1(uvd, 0x0039, 0x003e); /* !Same */
  3270. ibmcam_model3_Packet1(uvd, 0x0040, 0x0008);
  3271. ibmcam_model3_Packet1(uvd, 0x0051, 0x000a);
  3272. break;
  3273. }
  3274. /* 01.01.08 - Added for RCA video in support -LO */
  3275. if(init_model3_input) {
  3276. if (debug > 0)
  3277. info("Setting input to RCA.");
  3278. for (i=0; i < (sizeof(initData)/sizeof(initData[0])); i++) {
  3279. ibmcam_veio(uvd, initData[i].req, initData[i].value, initData[i].index);
  3280. }
  3281. }
  3282. ibmcam_veio(uvd, 0, 0x0001, 0x0114);
  3283. ibmcam_veio(uvd, 0, 0x00c0, 0x010c);
  3284. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  3285. }
  3286. /*
  3287.  * ibmcam_video_stop()
  3288.  *
  3289.  * This code tells camera to stop streaming. The interface remains
  3290.  * configured and bandwidth - claimed.
  3291.  */
  3292. static void ibmcam_video_stop(uvd_t *uvd)
  3293. {
  3294. switch (IBMCAM_T(uvd)->camera_model) {
  3295. case IBMCAM_MODEL_1:
  3296. ibmcam_veio(uvd, 0, 0x00, 0x010c);
  3297. ibmcam_veio(uvd, 0, 0x00, 0x010c);
  3298. ibmcam_veio(uvd, 0, 0x01, 0x0114);
  3299. ibmcam_veio(uvd, 0, 0xc0, 0x010c);
  3300. ibmcam_veio(uvd, 0, 0x00, 0x010c);
  3301. ibmcam_send_FF_04_02(uvd);
  3302. ibmcam_veio(uvd, 1, 0x00, 0x0100);
  3303. ibmcam_veio(uvd, 0, 0x81, 0x0100); /* LED Off */
  3304. break;
  3305. case IBMCAM_MODEL_2:
  3306. case IBMCAM_MODEL_4:
  3307. ibmcam_veio(uvd, 0, 0x0000, 0x010c); /* Stop the camera */
  3308. ibmcam_model2_Packet1(uvd, 0x0030, 0x0004);
  3309. ibmcam_veio(uvd, 0, 0x0080, 0x0100); /* LED Off */
  3310. ibmcam_veio(uvd, 0, 0x0020, 0x0111);
  3311. ibmcam_veio(uvd, 0, 0x00a0, 0x0111);
  3312. ibmcam_model2_Packet1(uvd, 0x0030, 0x0002);
  3313. ibmcam_veio(uvd, 0, 0x0020, 0x0111);
  3314. ibmcam_veio(uvd, 0, 0x0000, 0x0112);
  3315. break;
  3316. case IBMCAM_MODEL_3:
  3317. #if 1
  3318. ibmcam_veio(uvd, 0, 0x0000, 0x010c);
  3319. /* Here we are supposed to select video interface alt. setting 0 */
  3320. ibmcam_veio(uvd, 0, 0x0006, 0x012c);
  3321. ibmcam_model3_Packet1(uvd, 0x0046, 0x0000);
  3322. ibmcam_veio(uvd, 1, 0x0000, 0x0116);
  3323. ibmcam_veio(uvd, 0, 0x0064, 0x0116);
  3324. ibmcam_veio(uvd, 1, 0x0000, 0x0115);
  3325. ibmcam_veio(uvd, 0, 0x0003, 0x0115);
  3326. ibmcam_veio(uvd, 0, 0x0008, 0x0123);
  3327. ibmcam_veio(uvd, 0, 0x0000, 0x0117);
  3328. ibmcam_veio(uvd, 0, 0x0000, 0x0112);
  3329. ibmcam_veio(uvd, 0, 0x0080, 0x0100);
  3330. IBMCAM_T(uvd)->initialized = 0;
  3331. #endif
  3332. break;
  3333. } /* switch */
  3334. }
  3335. /*
  3336.  * ibmcam_reinit_iso()
  3337.  *
  3338.  * This procedure sends couple of commands to the camera and then
  3339.  * resets the video pipe. This sequence was observed to reinit the
  3340.  * camera or, at least, to initiate ISO data stream.
  3341.  *
  3342.  * History:
  3343.  * 1/2/00   Created.
  3344.  */
  3345. static void ibmcam_reinit_iso(uvd_t *uvd, int do_stop)
  3346. {
  3347. switch (IBMCAM_T(uvd)->camera_model) {
  3348. case IBMCAM_MODEL_1:
  3349. if (do_stop)
  3350. ibmcam_video_stop(uvd);
  3351. ibmcam_veio(uvd, 0, 0x0001, 0x0114);
  3352. ibmcam_veio(uvd, 0, 0x00c0, 0x010c);
  3353. usb_clear_halt(uvd->dev, usb_rcvisocpipe(uvd->dev, uvd->video_endp));
  3354. ibmcam_model1_setup_after_video_if(uvd);
  3355. break;
  3356. case IBMCAM_MODEL_2:
  3357. ibmcam_model2_setup_after_video_if(uvd);
  3358. break;
  3359. case IBMCAM_MODEL_3:
  3360. ibmcam_video_stop(uvd);
  3361. ibmcam_model3_setup_after_video_if(uvd);
  3362. break;
  3363. case IBMCAM_MODEL_4:
  3364. ibmcam_model4_setup_after_video_if(uvd);
  3365. break;
  3366. }
  3367. }
  3368. static void ibmcam_video_start(uvd_t *uvd)
  3369. {
  3370. ibmcam_change_lighting_conditions(uvd);
  3371. ibmcam_set_sharpness(uvd);
  3372. ibmcam_reinit_iso(uvd, 0);
  3373. }
  3374. /*
  3375.  * Return negative code on failure, 0 on success.
  3376.  */
  3377. static int ibmcam_setup_on_open(uvd_t *uvd)
  3378. {
  3379. int setup_ok = 0; /* Success by default */
  3380. /* Send init sequence only once, it's large! */
  3381. if (!IBMCAM_T(uvd)->initialized) { /* FIXME rename */
  3382. switch (IBMCAM_T(uvd)->camera_model) {
  3383. case IBMCAM_MODEL_1:
  3384. setup_ok = ibmcam_model1_setup(uvd);
  3385. break;
  3386. case IBMCAM_MODEL_2:
  3387. setup_ok = ibmcam_model2_setup(uvd);
  3388. break;
  3389. case IBMCAM_MODEL_3:
  3390. case IBMCAM_MODEL_4:
  3391. /* We do all setup when Isoc stream is requested */
  3392. break;
  3393. }
  3394. IBMCAM_T(uvd)->initialized = (setup_ok != 0);
  3395. }
  3396. return setup_ok;
  3397. }
  3398. static void ibmcam_configure_video(uvd_t *uvd)
  3399. {
  3400. if (uvd == NULL)
  3401. return;
  3402. RESTRICT_TO_RANGE(init_brightness, 0, 255);
  3403. RESTRICT_TO_RANGE(init_contrast, 0, 255);
  3404. RESTRICT_TO_RANGE(init_color, 0, 255);
  3405. RESTRICT_TO_RANGE(init_hue, 0, 255);
  3406. RESTRICT_TO_RANGE(hue_correction, 0, 255);
  3407. memset(&uvd->vpic, 0, sizeof(uvd->vpic));
  3408. memset(&uvd->vpic_old, 0x55, sizeof(uvd->vpic_old));
  3409. uvd->vpic.colour = init_color << 8;
  3410. uvd->vpic.hue = init_hue << 8;
  3411. uvd->vpic.brightness = init_brightness << 8;
  3412. uvd->vpic.contrast = init_contrast << 8;
  3413. uvd->vpic.whiteness = 105 << 8; /* This one isn't used */
  3414. uvd->vpic.depth = 24;
  3415. uvd->vpic.palette = VIDEO_PALETTE_RGB24;
  3416. memset(&uvd->vcap, 0, sizeof(uvd->vcap));
  3417. strcpy(uvd->vcap.name, "IBM USB Camera");
  3418. uvd->vcap.type = VID_TYPE_CAPTURE;
  3419. uvd->vcap.channels = 1;
  3420. uvd->vcap.audios = 0;
  3421. uvd->vcap.maxwidth = VIDEOSIZE_X(uvd->canvas);
  3422. uvd->vcap.maxheight = VIDEOSIZE_Y(uvd->canvas);
  3423. uvd->vcap.minwidth = min_canvasWidth;
  3424. uvd->vcap.minheight = min_canvasHeight;
  3425. memset(&uvd->vchan, 0, sizeof(uvd->vchan));
  3426. uvd->vchan.flags = 0;
  3427. uvd->vchan.tuners = 0;
  3428. uvd->vchan.channel = 0;
  3429. uvd->vchan.type = VIDEO_TYPE_CAMERA;
  3430. strcpy(uvd->vchan.name, "Camera");
  3431. }
  3432. /*
  3433.  * ibmcam_probe()
  3434.  *
  3435.  * This procedure queries device descriptor and accepts the interface
  3436.  * if it looks like IBM C-it camera.
  3437.  *
  3438.  * History:
  3439.  * 22-Jan-2000 Moved camera init code to ibmcam_open()
  3440.  * 27=Jan-2000 Changed to use static structures, added locking.
  3441.  * 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT).
  3442.  * 03-Jul-2000 Fixed endianness bug.
  3443.  * 12-Nov-2000 Reworked to comply with new probe() signature.
  3444.  * 23-Jan-2001 Added compatibility with 2.2.x kernels.
  3445.  */
  3446. static void *ibmcam_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *devid)
  3447. {
  3448. uvd_t *uvd = NULL;
  3449. int i, nas, model=0, canvasX=0, canvasY=0;
  3450. int actInterface=-1, inactInterface=-1, maxPS=0;
  3451. unsigned char video_ep = 0;
  3452. if (debug >= 1)
  3453. info("ibmcam_probe(%p,%u.)", dev, ifnum);
  3454. /* We don't handle multi-config cameras */
  3455. if (dev->descriptor.bNumConfigurations != 1)
  3456. return NULL;
  3457. /* Is it an IBM camera? */
  3458. if (dev->descriptor.idVendor != IBMCAM_VENDOR_ID)
  3459. return NULL;
  3460. if ((dev->descriptor.idProduct != IBMCAM_PRODUCT_ID) &&
  3461.     (dev->descriptor.idProduct != NETCAM_PRODUCT_ID))
  3462. return NULL;
  3463. /* Check the version/revision */
  3464. switch (dev->descriptor.bcdDevice) {
  3465. case 0x0002:
  3466. if (ifnum != 2)
  3467. return NULL;
  3468. model = IBMCAM_MODEL_1;
  3469. break;
  3470. case 0x030A:
  3471. if (ifnum != 0)
  3472. return NULL;
  3473. if (dev->descriptor.idProduct == NETCAM_PRODUCT_ID)
  3474. model = IBMCAM_MODEL_4;
  3475. else
  3476. model = IBMCAM_MODEL_2;
  3477. break;
  3478. case 0x0301:
  3479. if (ifnum != 0)
  3480. return NULL;
  3481. model = IBMCAM_MODEL_3;
  3482. break;
  3483. default:
  3484. err("IBM camera with revision 0x%04x is not supported.",
  3485. dev->descriptor.bcdDevice);
  3486. return NULL;
  3487. }
  3488. info("IBM USB camera found (model %d, rev. 0x%04x)",
  3489. model, dev->descriptor.bcdDevice);
  3490. /* Validate found interface: must have one ISO endpoint */
  3491. nas = dev->actconfig->interface[ifnum].num_altsetting;
  3492. if (debug > 0)
  3493. info("Number of alternate settings=%d.", nas);
  3494. if (nas < 2) {
  3495. err("Too few alternate settings for this camera!");
  3496. return NULL;
  3497. }
  3498. /* Validate all alternate settings */
  3499. for (i=0; i < nas; i++) {
  3500. const struct usb_interface_descriptor *interface;
  3501. const struct usb_endpoint_descriptor *endpoint;
  3502. interface = &dev->actconfig->interface[ifnum].altsetting[i];
  3503. if (interface->bNumEndpoints != 1) {
  3504. err("Interface %d. has %u. endpoints!",
  3505.     ifnum, (unsigned)(interface->bNumEndpoints));
  3506. return NULL;
  3507. }
  3508. endpoint = &interface->endpoint[0];
  3509. if (video_ep == 0)
  3510. video_ep = endpoint->bEndpointAddress;
  3511. else if (video_ep != endpoint->bEndpointAddress) {
  3512. err("Alternate settings have different endpoint addresses!");
  3513. return NULL;
  3514. }
  3515. if ((endpoint->bmAttributes & 0x03) != 0x01) {
  3516. err("Interface %d. has non-ISO endpoint!", ifnum);
  3517. return NULL;
  3518. }
  3519. if ((endpoint->bEndpointAddress & 0x80) == 0) {
  3520. err("Interface %d. has ISO OUT endpoint!", ifnum);
  3521. return NULL;
  3522. }
  3523. if (endpoint->wMaxPacketSize == 0) {
  3524. if (inactInterface < 0)
  3525. inactInterface = i;
  3526. else {
  3527. err("More than one inactive alt. setting!");
  3528. return NULL;
  3529. }
  3530. } else {
  3531. if (actInterface < 0) {
  3532. actInterface = i;
  3533. maxPS = endpoint->wMaxPacketSize;
  3534. if (debug > 0)
  3535. info("Active setting=%d. maxPS=%d.", i, maxPS);
  3536. } else
  3537. err("More than one active alt. setting! Ignoring #%d.", i);
  3538. }
  3539. }
  3540. if ((maxPS <= 0) || (actInterface < 0) || (inactInterface < 0)) {
  3541. err("Failed to recognize the camera!");
  3542. return NULL;
  3543. }
  3544. /* Validate options */
  3545. switch (model) {
  3546. case IBMCAM_MODEL_1:
  3547. RESTRICT_TO_RANGE(lighting, 0, 2);
  3548. RESTRICT_TO_RANGE(size, SIZE_128x96, SIZE_352x288);
  3549. if (framerate < 0)
  3550. framerate = 2;
  3551. canvasX = 352;
  3552. canvasY = 288;
  3553. break;
  3554. case IBMCAM_MODEL_2:
  3555. RESTRICT_TO_RANGE(lighting, 0, 15);
  3556. RESTRICT_TO_RANGE(size, SIZE_176x144, SIZE_352x240);
  3557. if (framerate < 0)
  3558. framerate = 2;
  3559. canvasX = 352;
  3560. canvasY = 240;
  3561. break;
  3562. case IBMCAM_MODEL_3:
  3563. RESTRICT_TO_RANGE(lighting, 0, 15); /* FIXME */
  3564. switch (size) {
  3565. case SIZE_160x120:
  3566. canvasX = 160;
  3567. canvasY = 120;
  3568. if (framerate < 0)
  3569. framerate = 2;
  3570. RESTRICT_TO_RANGE(framerate, 0, 5);
  3571. break;
  3572. default:
  3573. info("IBM camera: using 320x240");
  3574. size = SIZE_320x240;
  3575. /* No break here */
  3576. case SIZE_320x240:
  3577. canvasX = 320;
  3578. canvasY = 240;
  3579. if (framerate < 0)
  3580. framerate = 3;
  3581. RESTRICT_TO_RANGE(framerate, 0, 5);
  3582. break;
  3583. case SIZE_640x480:
  3584. canvasX = 640;
  3585. canvasY = 480;
  3586. framerate = 0; /* Slowest, and maybe even that is too fast */
  3587. break;
  3588. }
  3589. break;
  3590. case IBMCAM_MODEL_4:
  3591. RESTRICT_TO_RANGE(lighting, 0, 2);
  3592. switch (size) {
  3593. case SIZE_128x96:
  3594. canvasX = 128;
  3595. canvasY = 96;
  3596. break;
  3597. case SIZE_160x120:
  3598. canvasX = 160;
  3599. canvasY = 120;
  3600. break;
  3601. default:
  3602. info("IBM NetCamera: using 176x144");
  3603. size = SIZE_176x144;
  3604. /* No break here */
  3605. case SIZE_176x144:
  3606. canvasX = 176;
  3607. canvasY = 144;
  3608. break;
  3609. case SIZE_320x240:
  3610. canvasX = 320;
  3611. canvasY = 240;
  3612. break;
  3613. case SIZE_352x288:
  3614. canvasX = 352;
  3615. canvasY = 288;
  3616. break;
  3617. }
  3618. break;
  3619. default:
  3620. err("IBM camera: Model %d. not supported!", model);
  3621. return NULL;
  3622. }
  3623. /* Code below may sleep, need to lock module while we are here */
  3624. MOD_INC_USE_COUNT;
  3625. uvd = usbvideo_AllocateDevice(cams);
  3626. if (uvd != NULL) {
  3627. /* Here uvd is a fully allocated uvd_t object */
  3628. uvd->flags = flags;
  3629. uvd->debug = debug;
  3630. uvd->dev = dev;
  3631. uvd->iface = ifnum;
  3632. uvd->ifaceAltInactive = inactInterface;
  3633. uvd->ifaceAltActive = actInterface;
  3634. uvd->video_endp = video_ep;
  3635. uvd->iso_packet_len = maxPS;
  3636. uvd->paletteBits = 1L << VIDEO_PALETTE_RGB24;
  3637. uvd->defaultPalette = VIDEO_PALETTE_RGB24;
  3638. uvd->canvas = VIDEOSIZE(canvasX, canvasY);
  3639. uvd->videosize = ibmcam_size_to_videosize(size);
  3640. /* Initialize ibmcam-specific data */
  3641. assert(IBMCAM_T(uvd) != NULL);
  3642. IBMCAM_T(uvd)->camera_model = model;
  3643. IBMCAM_T(uvd)->initialized = 0;
  3644. ibmcam_configure_video(uvd);
  3645. i = usbvideo_RegisterVideoDevice(uvd);
  3646. if (i != 0) {
  3647. err("usbvideo_RegisterVideoDevice() failed.");
  3648. uvd = NULL;
  3649. }
  3650. }
  3651. MOD_DEC_USE_COUNT;
  3652. return uvd;
  3653. }
  3654. /*
  3655.  * ibmcam_init()
  3656.  *
  3657.  * This code is run to initialize the driver.
  3658.  *
  3659.  * History:
  3660.  * 1/27/00  Reworked to use statically allocated ibmcam structures.
  3661.  * 21/10/00 Completely redesigned to use usbvideo services.
  3662.  */
  3663. static int __init ibmcam_init(void)
  3664. {
  3665. usbvideo_cb_t cbTbl;
  3666. memset(&cbTbl, 0, sizeof(cbTbl));
  3667. cbTbl.probe = ibmcam_probe;
  3668. cbTbl.setupOnOpen = ibmcam_setup_on_open;
  3669. cbTbl.videoStart = ibmcam_video_start;
  3670. cbTbl.videoStop = ibmcam_video_stop;
  3671. cbTbl.processData = ibmcam_ProcessIsocData;
  3672. cbTbl.postProcess = usbvideo_DeinterlaceFrame;
  3673. cbTbl.adjustPicture = ibmcam_adjust_picture;
  3674. cbTbl.getFPS = ibmcam_calculate_fps;
  3675. return usbvideo_register(
  3676. &cams,
  3677. MAX_IBMCAM,
  3678. sizeof(ibmcam_t),
  3679. "ibmcam",
  3680. &cbTbl,
  3681. THIS_MODULE);
  3682. }
  3683. static void __exit ibmcam_cleanup(void)
  3684. {
  3685. usbvideo_Deregister(&cams);
  3686. }
  3687. #if defined(usb_device_id_ver)
  3688. static __devinitdata struct usb_device_id id_table[] = {
  3689. { USB_DEVICE_VER(IBMCAM_VENDOR_ID, IBMCAM_PRODUCT_ID, 0x0002, 0x0002) }, /* Model 1 */
  3690. { USB_DEVICE_VER(IBMCAM_VENDOR_ID, IBMCAM_PRODUCT_ID, 0x030a, 0x030a) }, /* Model 2 */
  3691. { USB_DEVICE_VER(IBMCAM_VENDOR_ID, IBMCAM_PRODUCT_ID, 0x0301, 0x0301) }, /* Model 3 */
  3692. { USB_DEVICE_VER(IBMCAM_VENDOR_ID, NETCAM_PRODUCT_ID, 0x030a, 0x030a) }, /* Model 4 */
  3693. { }  /* Terminating entry */
  3694. };
  3695. MODULE_DEVICE_TABLE(usb, id_table);
  3696. #endif /* defined(usb_device_id_ver) */
  3697. module_init(ibmcam_init);
  3698. module_exit(ibmcam_cleanup);