PageRenderTime 52ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/media/usb/gspca/dtcs033.c

https://gitlab.com/Skylake/Staging
C | 439 lines | 344 code | 50 blank | 45 comment | 14 complexity | 796a69f3548eb11a1b162212061ca659 MD5 | raw file
    

  1. /*
    2. 

  2.  * Subdriver for Scopium astro-camera (DTCS033, 0547:7303)
    3. 

  3.  *
    4. 

  4.  * Copyright (C) 2014 Robert Butora (robert.butora.fi@gmail.com)
    5. 

  5.  *
    6. 

  6.  * This program is free software; you can redistribute it and/or modify
    7. 

  7.  * it under the terms of the GNU General Public License as published by
    8. 

  8.  * the Free Software Foundation; either version 2 of the License, or
    9. 

  9.  * any later version.
    10. 

  10.  *
    11. 

  11.  * This program is distributed in the hope that it will be useful,
    12. 

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    14. 

  14.  * GNU General Public License for more details.
    15. 

  15.  */
    16. 

  16. 

  17. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
    18. 

  18. #define MODULE_NAME "dtcs033"
    19. 

  19. #include "gspca.h"
    20. 

  20. 

  21. MODULE_AUTHOR("Robert Butora <robert.butora.fi@gmail.com>");
    22. 

  22. MODULE_DESCRIPTION("Scopium DTCS033 astro-cam USB Camera Driver");
    23. 

  23. MODULE_LICENSE("GPL");
    24. 

  24. 

  25. struct dtcs033_usb_requests {
    26. 

  26. 	u8 bRequestType;
    27. 

  27. 	u8 bRequest;
    28. 

  28. 	u16 wValue;
    29. 

  29. 	u16 wIndex;
    30. 

  30. 	u16 wLength;
    31. 

  31. };
    32. 

  32. 

  33. /* send a usb request */
    34. 

  34. static void reg_rw(struct gspca_dev *gspca_dev,
    35. 

  35. 		u8 bRequestType, u8 bRequest,
    36. 

  36. 		u16 wValue, u16 wIndex, u16 wLength)
    37. 

  37. {
    38. 

  38. 	struct usb_device *udev = gspca_dev->dev;
    39. 

  39. 	int ret;
    40. 

  40. 

  41. 	if (gspca_dev->usb_err < 0)
    42. 

  42. 		return;
    43. 

  43. 

  44. 	ret = usb_control_msg(udev,
    45. 

  45. 		usb_rcvctrlpipe(udev, 0),
    46. 

  46. 		bRequest,
    47. 

  47. 		bRequestType,
    48. 

  48. 		wValue, wIndex,
    49. 

  49. 		gspca_dev->usb_buf, wLength, 500);
    50. 

  50. 

  51. 	if (ret < 0) {
    52. 

  52. 		gspca_dev->usb_err = ret;
    53. 

  53. 		pr_err("usb_control_msg error %d\n", ret);
    54. 

  54. 	}
    55. 

  55. 

  56. 	return;
    57. 

  57. }
    58. 

  58. /* send several usb in/out requests */
    59. 

  59. static int reg_reqs(struct gspca_dev *gspca_dev,
    60. 

  60. 		    const struct dtcs033_usb_requests *preqs, int n_reqs)
    61. 

  61. {
    62. 

  62. 	int i = 0;
    63. 

  63. 	const struct dtcs033_usb_requests *preq;
    64. 

  64. 

  65. 	while ((i < n_reqs) && (gspca_dev->usb_err >= 0)) {
    66. 

  66. 

  67. 		preq = &preqs[i];
    68. 

  68. 

  69. 		reg_rw(gspca_dev, preq->bRequestType, preq->bRequest,
    70. 

  70. 			preq->wValue, preq->wIndex, preq->wLength);
    71. 

  71. 

  72. 		if (gspca_dev->usb_err < 0) {
    73. 

  73. 

  74. 			gspca_err(gspca_dev, "usb error request no: %d / %d\n",
    75. 

  75. 				  i, n_reqs);
    76. 

  76. 		} else if (preq->bRequestType & USB_DIR_IN) {
    77. 

  77. 

  78. 			gspca_dbg(gspca_dev, D_STREAM,
    79. 

  79. 				  "USB IN (%d) returned[%d] %3ph %s",
    80. 

  80. 				  i,
    81. 

  81. 				  preq->wLength,
    82. 

  82. 				  gspca_dev->usb_buf,
    83. 

  83. 				  preq->wLength > 3 ? "...\n" : "\n");
    84. 

  84. 		}
    85. 

  85. 

  86. 		i++;
    87. 

  87. 	}
    88. 

  88. 	return gspca_dev->usb_err;
    89. 

  89. }
    90. 

  90. 

  91. /* -- subdriver interface implementation -- */
    92. 

  92. 

  93. #define DT_COLS (640)
    94. 

  94. static const struct v4l2_pix_format dtcs033_mode[] = {
    95. 

  95. 	/* raw Bayer patterned output */
    96. 

  96. 	{DT_COLS, 480, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
    97. 

  97. 		.bytesperline = DT_COLS,
    98. 

  98. 		.sizeimage = DT_COLS*480,
    99. 

  99. 		.colorspace = V4L2_COLORSPACE_SRGB,
    100. 

  100. 	},
    101. 

  101. 	/* this mode will demosaic the Bayer pattern */
    102. 

  102. 	{DT_COLS, 480, V4L2_PIX_FMT_SRGGB8, V4L2_FIELD_NONE,
    103. 

  103. 		.bytesperline = DT_COLS,
    104. 

  104. 		.sizeimage = DT_COLS*480,
    105. 

  105. 		.colorspace = V4L2_COLORSPACE_SRGB,
    106. 

  106. 	}
    107. 

  107. };
    108. 

  108. 

  109. /* config called at probe time */
    110. 

  110. static int sd_config(struct gspca_dev *gspca_dev,
    111. 

  111. 		const struct usb_device_id *id)
    112. 

  112. {
    113. 

  113. 	gspca_dev->cam.cam_mode = dtcs033_mode;
    114. 

  114. 	gspca_dev->cam.nmodes = ARRAY_SIZE(dtcs033_mode);
    115. 

  115. 

  116. 	gspca_dev->cam.bulk = 1;
    117. 

  117. 	gspca_dev->cam.bulk_nurbs = 1;
    118. 

  118. 	gspca_dev->cam.bulk_size = DT_COLS*512;
    119. 

  119. 

  120. 	return 0;
    121. 

  121. }
    122. 

  122. 

  123. /* init called at probe and resume time */
    124. 

  124. static int sd_init(struct gspca_dev *gspca_dev)
    125. 

  125. {
    126. 

  126. 	return 0;
    127. 

  127. }
    128. 

  128. 

  129. /* start stop the camera */
    130. 

  130. static int  dtcs033_start(struct gspca_dev *gspca_dev);
    131. 

  131. static void dtcs033_stopN(struct gspca_dev *gspca_dev);
    132. 

  132. 

  133. /* intercept camera image data */
    134. 

  134. static void dtcs033_pkt_scan(struct gspca_dev *gspca_dev,
    135. 

  135. 			u8 *data,  /* packet data */
    136. 

  136. 			int len)   /* packet data length */
    137. 

  137. {
    138. 

  138. 	/* drop incomplete frames */
    139. 

  139. 	if (len != DT_COLS*512) {
    140. 

  140. 		gspca_dev->last_packet_type = DISCARD_PACKET;
    141. 

  141. 		/* gspca.c: discard invalidates the whole frame. */
    142. 

  142. 		return;
    143. 

  143. 	}
    144. 

  144. 

  145. 	/* forward complete frames */
    146. 

  146. 	gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
    147. 

  147. 	gspca_frame_add(gspca_dev, INTER_PACKET,
    148. 

  148. 		data + 16*DT_COLS,
    149. 

  149. 		len  - 32*DT_COLS); /* skip first & last 16 lines */
    150. 

  150. 	gspca_frame_add(gspca_dev, LAST_PACKET,  NULL, 0);
    151. 

  151. 

  152. 	return;
    153. 

  153. }
    154. 

  154. 

  155. /* -- controls: exposure and gain -- */
    156. 

  156. 

  157. static void dtcs033_setexposure(struct gspca_dev *gspca_dev,
    158. 

  158. 			s32 expo, s32 gain)
    159. 

  159. {
    160. 

  160. 	/* gain [dB] encoding */
    161. 

  161. 	u16 sGain   = (u16)gain;
    162. 

  162. 	u16 gainVal = 224+(sGain-14)*(768-224)/(33-14);
    163. 

  163. 	u16 wIndex =  0x0100|(0x00FF&gainVal);
    164. 

  164. 	u16 wValue = (0xFF00&gainVal)>>8;
    165. 

  165. 

  166. 	/* exposure time [msec] encoding */
    167. 

  167. 	u16 sXTime   = (u16)expo;
    168. 

  168. 	u16 xtimeVal = (524*(150-(sXTime-1)))/150;
    169. 

  169. 

  170. 	const u8 bRequestType =
    171. 

  171. 		USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
    172. 

  172. 	const u8 bRequest = 0x18;
    173. 

  173. 

  174. 	reg_rw(gspca_dev,
    175. 

  175. 		bRequestType, bRequest, wValue, wIndex, 0);
    176. 

  176. 	if (gspca_dev->usb_err < 0)
    177. 

  177. 		gspca_err(gspca_dev, "usb error in setexposure(gain) sequence\n");
    178. 

  178. 

  179. 	reg_rw(gspca_dev,
    180. 

  180. 		bRequestType, bRequest, (xtimeVal<<4), 0x6300, 0);
    181. 

  181. 	if (gspca_dev->usb_err < 0)
    182. 

  182. 		gspca_err(gspca_dev, "usb error in setexposure(time) sequence\n");
    183. 

  183. }
    184. 

  184. 

  185. /* specific webcam descriptor */
    186. 

  186. struct sd {
    187. 

  187. 	struct gspca_dev gspca_dev;/* !! must be the first item */
    188. 

  188. 

  189. 	/* exposure & gain controls */
    190. 

  190. 	struct {
    191. 

  191. 		struct v4l2_ctrl *exposure;
    192. 

  192. 		struct v4l2_ctrl *gain;
    193. 

  193. 	};
    194. 

  194. };
    195. 

  195. 

  196. static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
    197. 

  197. {
    198. 

  198. 	struct gspca_dev *gspca_dev =
    199. 

  199. 	container_of(ctrl->handler,
    200. 

  200. 		struct gspca_dev, ctrl_handler);
    201. 

  201. 	struct sd *sd = (struct sd *) gspca_dev;
    202. 

  202. 

  203. 	gspca_dev->usb_err = 0;
    204. 

  204. 

  205. 	if (!gspca_dev->streaming)
    206. 

  206. 		return 0;
    207. 

  207. 

  208. 	switch (ctrl->id) {
    209. 

  209. 	case V4L2_CID_EXPOSURE:
    210. 

  210. 		dtcs033_setexposure(gspca_dev,
    211. 

  211. 				ctrl->val, sd->gain->val);
    212. 

  212. 		break;
    213. 

  213. 	case V4L2_CID_GAIN:
    214. 

  214. 		dtcs033_setexposure(gspca_dev,
    215. 

  215. 				sd->exposure->val, ctrl->val);
    216. 

  216. 		break;
    217. 

  217. 	}
    218. 

  218. 	return gspca_dev->usb_err;
    219. 

  219. }
    220. 

  220. 

  221. static const struct v4l2_ctrl_ops sd_ctrl_ops = {
    222. 

  222. 	.s_ctrl = sd_s_ctrl,
    223. 

  223. };
    224. 

  224. 

  225. static int dtcs033_init_controls(struct gspca_dev *gspca_dev)
    226. 

  226. {
    227. 

  227. 	struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
    228. 

  228. 	struct sd *sd = (struct sd *) gspca_dev;
    229. 

  229. 

  230. 	gspca_dev->vdev.ctrl_handler = hdl;
    231. 

  231. 	v4l2_ctrl_handler_init(hdl, 2);
    232. 

  232. 	/*                               min max step default */
    233. 

  233. 	sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
    234. 

  234. 				V4L2_CID_EXPOSURE,
    235. 

  235. 				1,  150,  1,  75);/* [msec] */
    236. 

  236. 	sd->gain     = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
    237. 

  237. 				V4L2_CID_GAIN,
    238. 

  238. 				14,  33,  1,  24);/* [dB] */
    239. 

  239. 	if (hdl->error) {
    240. 

  240. 		gspca_err(gspca_dev, "Could not initialize controls: %d\n",
    241. 

  241. 			  hdl->error);
    242. 

  242. 		return hdl->error;
    243. 

  243. 	}
    244. 

  244. 

  245. 	v4l2_ctrl_cluster(2, &sd->exposure);
    246. 

  246. 	return 0;
    247. 

  247. }
    248. 

  248. 

  249. /* sub-driver description */
    250. 

  250. static const struct sd_desc sd_desc = {
    251. 

  251. 	.name     = MODULE_NAME,
    252. 

  252. 	.config   = sd_config,
    253. 

  253. 	.init     = sd_init,
    254. 

  254. 	.start    = dtcs033_start,
    255. 

  255. 	.stopN    = dtcs033_stopN,
    256. 

  256. 	.pkt_scan = dtcs033_pkt_scan,
    257. 

  257. 	.init_controls = dtcs033_init_controls,
    258. 

  258. };
    259. 

  259. 

  260. /* -- module initialisation -- */
    261. 

  261. 

  262. static const struct usb_device_id device_table[] = {
    263. 

  263. 	{USB_DEVICE(0x0547, 0x7303)},
    264. 

  264. 	{}
    265. 

  265. };
    266. 

  266. MODULE_DEVICE_TABLE(usb, device_table);
    267. 

  267. 

  268. /* device connect */
    269. 

  269. static int sd_probe(struct usb_interface *intf,
    270. 

  270. 			const struct usb_device_id *id)
    271. 

  271. {
    272. 

  272. 	return gspca_dev_probe(intf, id,
    273. 

  273. 			&sd_desc, sizeof(struct sd),
    274. 

  274. 			THIS_MODULE);
    275. 

  275. }
    276. 

  276. 

  277. static struct usb_driver sd_driver = {
    278. 

  278. 	.name       = MODULE_NAME,
    279. 

  279. 	.id_table   = device_table,
    280. 

  280. 	.probe      = sd_probe,
    281. 

  281. 	.disconnect   = gspca_disconnect,
    282. 

  282. #ifdef CONFIG_PM
    283. 

  283. 	.suspend      = gspca_suspend,
    284. 

  284. 	.resume       = gspca_resume,
    285. 

  285. 	.reset_resume = gspca_resume,
    286. 

  286. #endif
    287. 

  287. };
    288. 

  288. module_usb_driver(sd_driver);
    289. 

  289. 

  290. 

  291. /* ---------------------------------------------------------
    292. 

  292.  USB requests to start/stop the camera [USB 2.0 spec Ch.9].
    293. 

    294. 

  294.  bRequestType :
    295. 

  295.  0x40 =  USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
    296. 

  296.  0xC0 =  USB_DIR_IN  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
    297. 

  297. */
    298. 

  298. static const struct dtcs033_usb_requests dtcs033_start_reqs[] = {
    299. 

  299. /* -- bRequest,wValue,wIndex,wLength */
    300. 

  300. { 0x40, 0x01, 0x0001, 0x000F, 0x0000 },
    301. 

  301. { 0x40, 0x01, 0x0000, 0x000F, 0x0000 },
    302. 

  302. { 0x40, 0x01, 0x0001, 0x000F, 0x0000 },
    303. 

  303. { 0x40, 0x18, 0x0000, 0x7F00, 0x0000 },
    304. 

  304. { 0x40, 0x18, 0x0000, 0x1001, 0x0000 },
    305. 

  305. { 0x40, 0x18, 0x0000, 0x0004, 0x0000 },
    306. 

  306. { 0x40, 0x18, 0x0000, 0x7F01, 0x0000 },
    307. 

  307. { 0x40, 0x18, 0x30E0, 0x0009, 0x0000 },
    308. 

  308. { 0x40, 0x18, 0x0500, 0x012C, 0x0000 },
    309. 

  309. { 0x40, 0x18, 0x0380, 0x0200, 0x0000 },
    310. 

  310. { 0x40, 0x18, 0x0000, 0x035C, 0x0000 },
    311. 

  311. { 0x40, 0x18, 0x05C0, 0x0438, 0x0000 },
    312. 

  312. { 0x40, 0x18, 0x0440, 0x0500, 0x0000 },
    313. 

  313. { 0x40, 0x18, 0x0000, 0x0668, 0x0000 },
    314. 

  314. { 0x40, 0x18, 0x0000, 0x0700, 0x0000 },
    315. 

  315. { 0x40, 0x18, 0x0000, 0x0800, 0x0000 },
    316. 

  316. { 0x40, 0x18, 0x0000, 0x0900, 0x0000 },
    317. 

  317. { 0x40, 0x18, 0x0000, 0x0A00, 0x0000 },
    318. 

  318. { 0x40, 0x18, 0x0000, 0x0B00, 0x0000 },
    319. 

  319. { 0x40, 0x18, 0x30E0, 0x6009, 0x0000 },
    320. 

  320. { 0x40, 0x18, 0x0500, 0x612C, 0x0000 },
    321. 

  321. { 0x40, 0x18, 0x2090, 0x6274, 0x0000 },
    322. 

  322. { 0x40, 0x18, 0x05C0, 0x6338, 0x0000 },
    323. 

  323. { 0x40, 0x18, 0x0000, 0x6400, 0x0000 },
    324. 

  324. { 0x40, 0x18, 0x05C0, 0x6538, 0x0000 },
    325. 

  325. { 0x40, 0x18, 0x0000, 0x6600, 0x0000 },
    326. 

  326. { 0x40, 0x18, 0x0680, 0x6744, 0x0000 },
    327. 

  327. { 0x40, 0x18, 0x0000, 0x6800, 0x0000 },
    328. 

  328. { 0x40, 0x18, 0x0000, 0x6900, 0x0000 },
    329. 

  329. { 0x40, 0x18, 0x0000, 0x6A00, 0x0000 },
    330. 

  330. { 0x40, 0x18, 0x0000, 0x6B00, 0x0000 },
    331. 

  331. { 0x40, 0x18, 0x0000, 0x6C00, 0x0000 },
    332. 

  332. { 0x40, 0x18, 0x0000, 0x6D00, 0x0000 },
    333. 

  333. { 0x40, 0x18, 0x0000, 0x6E00, 0x0000 },
    334. 

  334. { 0x40, 0x18, 0x0000, 0x808C, 0x0000 },
    335. 

  335. { 0x40, 0x18, 0x0010, 0x8101, 0x0000 },
    336. 

  336. { 0x40, 0x18, 0x30E0, 0x8200, 0x0000 },
    337. 

  337. { 0x40, 0x18, 0x0810, 0x832C, 0x0000 },
    338. 

  338. { 0x40, 0x18, 0x0680, 0x842B, 0x0000 },
    339. 

  339. { 0x40, 0x18, 0x0000, 0x8500, 0x0000 },
    340. 

  340. { 0x40, 0x18, 0x0000, 0x8600, 0x0000 },
    341. 

  341. { 0x40, 0x18, 0x0280, 0x8715, 0x0000 },
    342. 

  342. { 0x40, 0x18, 0x0000, 0x880C, 0x0000 },
    343. 

  343. { 0x40, 0x18, 0x0010, 0x8901, 0x0000 },
    344. 

  344. { 0x40, 0x18, 0x30E0, 0x8A00, 0x0000 },
    345. 

  345. { 0x40, 0x18, 0x0810, 0x8B2C, 0x0000 },
    346. 

  346. { 0x40, 0x18, 0x0680, 0x8C2B, 0x0000 },
    347. 

  347. { 0x40, 0x18, 0x0000, 0x8D00, 0x0000 },
    348. 

  348. { 0x40, 0x18, 0x0000, 0x8E00, 0x0000 },
    349. 

  349. { 0x40, 0x18, 0x0280, 0x8F15, 0x0000 },
    350. 

  350. { 0x40, 0x18, 0x0010, 0xD040, 0x0000 },
    351. 

  351. { 0x40, 0x18, 0x0000, 0xD100, 0x0000 },
    352. 

  352. { 0x40, 0x18, 0x00B0, 0xD20A, 0x0000 },
    353. 

  353. { 0x40, 0x18, 0x0000, 0xD300, 0x0000 },
    354. 

  354. { 0x40, 0x18, 0x30E2, 0xD40D, 0x0000 },
    355. 

  355. { 0x40, 0x18, 0x0001, 0xD5C0, 0x0000 },
    356. 

  356. { 0x40, 0x18, 0x00A0, 0xD60A, 0x0000 },
    357. 

  357. { 0x40, 0x18, 0x0000, 0xD700, 0x0000 },
    358. 

  358. { 0x40, 0x18, 0x0000, 0x7F00, 0x0000 },
    359. 

  359. { 0x40, 0x18, 0x0000, 0x1501, 0x0000 },
    360. 

  360. { 0x40, 0x18, 0x0001, 0x01FF, 0x0000 },
    361. 

  361. { 0x40, 0x18, 0x0000, 0x0200, 0x0000 },
    362. 

  362. { 0x40, 0x18, 0x0000, 0x0304, 0x0000 },
    363. 

  363. { 0x40, 0x18, 0x0000, 0x1101, 0x0000 },
    364. 

  364. { 0x40, 0x18, 0x0000, 0x1201, 0x0000 },
    365. 

  365. { 0x40, 0x18, 0x0000, 0x1300, 0x0000 },
    366. 

  366. { 0x40, 0x18, 0x0000, 0x1400, 0x0000 },
    367. 

  367. { 0x40, 0x18, 0x0000, 0x1601, 0x0000 },
    368. 

  368. { 0x40, 0x18, 0x0000, 0x1800, 0x0000 },
    369. 

  369. { 0x40, 0x18, 0x0000, 0x1900, 0x0000 },
    370. 

  370. { 0x40, 0x18, 0x0000, 0x1A00, 0x0000 },
    371. 

  371. { 0x40, 0x18, 0x2000, 0x1B00, 0x0000 },
    372. 

  372. { 0x40, 0x18, 0x0000, 0x1C00, 0x0000 },
    373. 

  373. { 0x40, 0x18, 0x0000, 0x2100, 0x0000 },
    374. 

  374. { 0x40, 0x18, 0x00C0, 0x228E, 0x0000 },
    375. 

  375. { 0x40, 0x18, 0x0000, 0x3001, 0x0000 },
    376. 

  376. { 0x40, 0x18, 0x0010, 0x3101, 0x0000 },
    377. 

  377. { 0x40, 0x18, 0x0008, 0x3301, 0x0000 },
    378. 

  378. { 0x40, 0x18, 0x0000, 0x3400, 0x0000 },
    379. 

  379. { 0x40, 0x18, 0x0012, 0x3549, 0x0000 },
    380. 

  380. { 0x40, 0x18, 0x0000, 0x3620, 0x0000 },
    381. 

  381. { 0x40, 0x18, 0x0001, 0x3700, 0x0000 },
    382. 

  382. { 0x40, 0x18, 0x0000, 0x4000, 0x0000 },
    383. 

  383. { 0x40, 0x18, 0xFFFF, 0x41FF, 0x0000 },
    384. 

  384. { 0x40, 0x18, 0xFFFF, 0x42FF, 0x0000 },
    385. 

  385. { 0x40, 0x18, 0x0000, 0x500F, 0x0000 },
    386. 

  386. { 0x40, 0x18, 0x2272, 0x5108, 0x0000 },
    387. 

  387. { 0x40, 0x18, 0x2272, 0x5208, 0x0000 },
    388. 

  388. { 0x40, 0x18, 0xFFFF, 0x53FF, 0x0000 },
    389. 

  389. { 0x40, 0x18, 0xFFFF, 0x54FF, 0x0000 },
    390. 

  390. { 0x40, 0x18, 0x0000, 0x6000, 0x0000 },
    391. 

  391. { 0x40, 0x18, 0x0000, 0x6102, 0x0000 },
    392. 

  392. { 0x40, 0x18, 0x0010, 0x6214, 0x0000 },
    393. 

  393. { 0x40, 0x18, 0x0C80, 0x6300, 0x0000 },
    394. 

  394. { 0x40, 0x18, 0x0000, 0x6401, 0x0000 },
    395. 

  395. { 0x40, 0x18, 0x0680, 0x6551, 0x0000 },
    396. 

  396. { 0x40, 0x18, 0xFFFF, 0x66FF, 0x0000 },
    397. 

  397. { 0x40, 0x18, 0x0000, 0x6702, 0x0000 },
    398. 

  398. { 0x40, 0x18, 0x0010, 0x6800, 0x0000 },
    399. 

  399. { 0x40, 0x18, 0x0000, 0x6900, 0x0000 },
    400. 

  400. { 0x40, 0x18, 0x0000, 0x6A00, 0x0000 },
    401. 

  401. { 0x40, 0x18, 0x0000, 0x6B00, 0x0000 },
    402. 

  402. { 0x40, 0x18, 0x0000, 0x6C00, 0x0000 },
    403. 

  403. { 0x40, 0x18, 0x0000, 0x6D01, 0x0000 },
    404. 

  404. { 0x40, 0x18, 0x0000, 0x6E00, 0x0000 },
    405. 

  405. { 0x40, 0x18, 0x0000, 0x6F00, 0x0000 },
    406. 

  406. { 0x40, 0x18, 0x0000, 0x7000, 0x0000 },
    407. 

  407. { 0x40, 0x18, 0x0001, 0x7118, 0x0000 },
    408. 

  408. { 0x40, 0x18, 0x0000, 0x2001, 0x0000 },
    409. 

  409. { 0x40, 0x18, 0x0000, 0x1101, 0x0000 },
    410. 

  410. { 0x40, 0x18, 0x0000, 0x1301, 0x0000 },
    411. 

  411. { 0x40, 0x18, 0x0000, 0x1300, 0x0000 },
    412. 

  412. { 0x40, 0x18, 0x0000, 0x1501, 0x0000 },
    413. 

  413. { 0xC0, 0x11, 0x0000, 0x24C0, 0x0003 },
    414. 

  414. { 0x40, 0x18, 0x0000, 0x3000, 0x0000 },
    415. 

  415. { 0x40, 0x18, 0x0000, 0x3620, 0x0000 },
    416. 

  416. { 0x40, 0x18, 0x0000, 0x1501, 0x0000 },
    417. 

  417. { 0x40, 0x18, 0x0010, 0x6300, 0x0000 },
    418. 

  418. { 0x40, 0x18, 0x0002, 0x01F0, 0x0000 },
    419. 

  419. { 0x40, 0x01, 0x0003, 0x000F, 0x0000 }
    420. 

  420. };
    421. 

  421. 

  422. static const struct dtcs033_usb_requests dtcs033_stop_reqs[] = {
    423. 

  423. /* -- bRequest,wValue,wIndex,wLength */
    424. 

  424. { 0x40, 0x01, 0x0001, 0x000F, 0x0000 },
    425. 

  425. { 0x40, 0x01, 0x0000, 0x000F, 0x0000 },
    426. 

  426. { 0x40, 0x18, 0x0000, 0x0003, 0x0000 }
    427. 

  427. };
    428. 

  428. static int dtcs033_start(struct gspca_dev *gspca_dev)
    429. 

  429. {
    430. 

  430. 	return reg_reqs(gspca_dev, dtcs033_start_reqs,
    431. 

  431. 		ARRAY_SIZE(dtcs033_start_reqs));
    432. 

  432. }
    433. 

  433. 

  434. static void dtcs033_stopN(struct gspca_dev *gspca_dev)
    435. 

  435. {
    436. 

  436. 	reg_reqs(gspca_dev, dtcs033_stop_reqs,
    437. 

  437. 		ARRAY_SIZE(dtcs033_stop_reqs));
    438. 

  438. 	return;
    439. 

  439. }
    440. 

  440.