gspca.c 44 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729
  1. /*
  2. * Main USB camera driver
  3. *
  4. * Copyright (C) 2008-2011 Jean-François Moine <http://moinejf.free.fr>
  5. *
  6. * Camera button input handling by Márton Németh
  7. * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
  8. *
  9. * This program is free software; you can redistribute it and/or modify it
  10. * under the terms of the GNU General Public License as published by the
  11. * Free Software Foundation; either version 2 of the License, or (at your
  12. * option) any later version.
  13. *
  14. * This program is distributed in the hope that it will be useful, but
  15. * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16. * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  17. * for more details.
  18. */
  19. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  20. #define GSPCA_VERSION "2.14.0"
  21. #include <linux/init.h>
  22. #include <linux/fs.h>
  23. #include <linux/vmalloc.h>
  24. #include <linux/sched.h>
  25. #include <linux/slab.h>
  26. #include <linux/mm.h>
  27. #include <linux/string.h>
  28. #include <linux/pagemap.h>
  29. #include <linux/io.h>
  30. #include <asm/page.h>
  31. #include <linux/uaccess.h>
  32. #include <linux/ktime.h>
  33. #include <media/v4l2-ioctl.h>
  34. #include <media/v4l2-ctrls.h>
  35. #include <media/v4l2-fh.h>
  36. #include <media/v4l2-event.h>
  37. #include "gspca.h"
  38. #if IS_ENABLED(CONFIG_INPUT)
  39. #include <linux/input.h>
  40. #include <linux/usb/input.h>
  41. #endif
  42. /* global values */
  43. #define DEF_NURBS 3 /* default number of URBs */
  44. #if DEF_NURBS > MAX_NURBS
  45. #error "DEF_NURBS too big"
  46. #endif
  47. MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
  48. MODULE_DESCRIPTION("GSPCA USB Camera Driver");
  49. MODULE_LICENSE("GPL");
  50. MODULE_VERSION(GSPCA_VERSION);
  51. int gspca_debug;
  52. EXPORT_SYMBOL(gspca_debug);
  53. static void PDEBUG_MODE(struct gspca_dev *gspca_dev, int debug, char *txt,
  54. __u32 pixfmt, int w, int h)
  55. {
  56. if ((pixfmt >> 24) >= '0' && (pixfmt >> 24) <= 'z') {
  57. gspca_dbg(gspca_dev, debug, "%s %c%c%c%c %dx%d\n",
  58. txt,
  59. pixfmt & 0xff,
  60. (pixfmt >> 8) & 0xff,
  61. (pixfmt >> 16) & 0xff,
  62. pixfmt >> 24,
  63. w, h);
  64. } else {
  65. gspca_dbg(gspca_dev, debug, "%s 0x%08x %dx%d\n",
  66. txt,
  67. pixfmt,
  68. w, h);
  69. }
  70. }
  71. /* specific memory types - !! should be different from V4L2_MEMORY_xxx */
  72. #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */
  73. #define GSPCA_MEMORY_READ 7
  74. /*
  75. * Input and interrupt endpoint handling functions
  76. */
  77. #if IS_ENABLED(CONFIG_INPUT)
  78. static void int_irq(struct urb *urb)
  79. {
  80. struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
  81. int ret;
  82. ret = urb->status;
  83. switch (ret) {
  84. case 0:
  85. if (gspca_dev->sd_desc->int_pkt_scan(gspca_dev,
  86. urb->transfer_buffer, urb->actual_length) < 0) {
  87. gspca_err(gspca_dev, "Unknown packet received\n");
  88. }
  89. break;
  90. case -ENOENT:
  91. case -ECONNRESET:
  92. case -ENODEV:
  93. case -ESHUTDOWN:
  94. /* Stop is requested either by software or hardware is gone,
  95. * keep the ret value non-zero and don't resubmit later.
  96. */
  97. break;
  98. default:
  99. gspca_err(gspca_dev, "URB error %i, resubmitting\n",
  100. urb->status);
  101. urb->status = 0;
  102. ret = 0;
  103. }
  104. if (ret == 0) {
  105. ret = usb_submit_urb(urb, GFP_ATOMIC);
  106. if (ret < 0)
  107. pr_err("Resubmit URB failed with error %i\n", ret);
  108. }
  109. }
  110. static int gspca_input_connect(struct gspca_dev *dev)
  111. {
  112. struct input_dev *input_dev;
  113. int err = 0;
  114. dev->input_dev = NULL;
  115. if (dev->sd_desc->int_pkt_scan || dev->sd_desc->other_input) {
  116. input_dev = input_allocate_device();
  117. if (!input_dev)
  118. return -ENOMEM;
  119. usb_make_path(dev->dev, dev->phys, sizeof(dev->phys));
  120. strlcat(dev->phys, "/input0", sizeof(dev->phys));
  121. input_dev->name = dev->sd_desc->name;
  122. input_dev->phys = dev->phys;
  123. usb_to_input_id(dev->dev, &input_dev->id);
  124. input_dev->evbit[0] = BIT_MASK(EV_KEY);
  125. input_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
  126. input_dev->dev.parent = &dev->dev->dev;
  127. err = input_register_device(input_dev);
  128. if (err) {
  129. pr_err("Input device registration failed with error %i\n",
  130. err);
  131. input_dev->dev.parent = NULL;
  132. input_free_device(input_dev);
  133. } else {
  134. dev->input_dev = input_dev;
  135. }
  136. }
  137. return err;
  138. }
  139. static int alloc_and_submit_int_urb(struct gspca_dev *gspca_dev,
  140. struct usb_endpoint_descriptor *ep)
  141. {
  142. unsigned int buffer_len;
  143. int interval;
  144. struct urb *urb;
  145. struct usb_device *dev;
  146. void *buffer = NULL;
  147. int ret = -EINVAL;
  148. buffer_len = le16_to_cpu(ep->wMaxPacketSize);
  149. interval = ep->bInterval;
  150. gspca_dbg(gspca_dev, D_CONF, "found int in endpoint: 0x%x, buffer_len=%u, interval=%u\n",
  151. ep->bEndpointAddress, buffer_len, interval);
  152. dev = gspca_dev->dev;
  153. urb = usb_alloc_urb(0, GFP_KERNEL);
  154. if (!urb) {
  155. ret = -ENOMEM;
  156. goto error;
  157. }
  158. buffer = usb_alloc_coherent(dev, buffer_len,
  159. GFP_KERNEL, &urb->transfer_dma);
  160. if (!buffer) {
  161. ret = -ENOMEM;
  162. goto error_buffer;
  163. }
  164. usb_fill_int_urb(urb, dev,
  165. usb_rcvintpipe(dev, ep->bEndpointAddress),
  166. buffer, buffer_len,
  167. int_irq, (void *)gspca_dev, interval);
  168. urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  169. ret = usb_submit_urb(urb, GFP_KERNEL);
  170. if (ret < 0) {
  171. gspca_err(gspca_dev, "submit int URB failed with error %i\n",
  172. ret);
  173. goto error_submit;
  174. }
  175. gspca_dev->int_urb = urb;
  176. return ret;
  177. error_submit:
  178. usb_free_coherent(dev,
  179. urb->transfer_buffer_length,
  180. urb->transfer_buffer,
  181. urb->transfer_dma);
  182. error_buffer:
  183. usb_free_urb(urb);
  184. error:
  185. return ret;
  186. }
  187. static void gspca_input_create_urb(struct gspca_dev *gspca_dev)
  188. {
  189. struct usb_interface *intf;
  190. struct usb_host_interface *intf_desc;
  191. struct usb_endpoint_descriptor *ep;
  192. int i;
  193. if (gspca_dev->sd_desc->int_pkt_scan) {
  194. intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
  195. intf_desc = intf->cur_altsetting;
  196. for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
  197. ep = &intf_desc->endpoint[i].desc;
  198. if (usb_endpoint_dir_in(ep) &&
  199. usb_endpoint_xfer_int(ep)) {
  200. alloc_and_submit_int_urb(gspca_dev, ep);
  201. break;
  202. }
  203. }
  204. }
  205. }
  206. static void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
  207. {
  208. struct urb *urb;
  209. urb = gspca_dev->int_urb;
  210. if (urb) {
  211. gspca_dev->int_urb = NULL;
  212. usb_kill_urb(urb);
  213. usb_free_coherent(gspca_dev->dev,
  214. urb->transfer_buffer_length,
  215. urb->transfer_buffer,
  216. urb->transfer_dma);
  217. usb_free_urb(urb);
  218. }
  219. }
  220. #else
  221. static inline void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
  222. {
  223. }
  224. static inline void gspca_input_create_urb(struct gspca_dev *gspca_dev)
  225. {
  226. }
  227. static inline int gspca_input_connect(struct gspca_dev *dev)
  228. {
  229. return 0;
  230. }
  231. #endif
  232. /*
  233. * fill a video frame from an URB and resubmit
  234. */
  235. static void fill_frame(struct gspca_dev *gspca_dev,
  236. struct urb *urb)
  237. {
  238. u8 *data; /* address of data in the iso message */
  239. int i, len, st;
  240. cam_pkt_op pkt_scan;
  241. if (urb->status != 0) {
  242. if (urb->status == -ESHUTDOWN)
  243. return; /* disconnection */
  244. #ifdef CONFIG_PM
  245. if (gspca_dev->frozen)
  246. return;
  247. #endif
  248. gspca_err(gspca_dev, "urb status: %d\n", urb->status);
  249. urb->status = 0;
  250. goto resubmit;
  251. }
  252. pkt_scan = gspca_dev->sd_desc->pkt_scan;
  253. for (i = 0; i < urb->number_of_packets; i++) {
  254. len = urb->iso_frame_desc[i].actual_length;
  255. /* check the packet status and length */
  256. st = urb->iso_frame_desc[i].status;
  257. if (st) {
  258. gspca_dbg(gspca_dev, D_PACK, "ISOC data error: [%d] len=%d, status=%d\n",
  259. i, len, st);
  260. gspca_dev->last_packet_type = DISCARD_PACKET;
  261. continue;
  262. }
  263. if (len == 0) {
  264. if (gspca_dev->empty_packet == 0)
  265. gspca_dev->empty_packet = 1;
  266. continue;
  267. }
  268. /* let the packet be analyzed by the subdriver */
  269. gspca_dbg(gspca_dev, D_PACK, "packet [%d] o:%d l:%d\n",
  270. i, urb->iso_frame_desc[i].offset, len);
  271. data = (u8 *) urb->transfer_buffer
  272. + urb->iso_frame_desc[i].offset;
  273. pkt_scan(gspca_dev, data, len);
  274. }
  275. resubmit:
  276. if (!gspca_dev->streaming)
  277. return;
  278. /* resubmit the URB */
  279. st = usb_submit_urb(urb, GFP_ATOMIC);
  280. if (st < 0)
  281. pr_err("usb_submit_urb() ret %d\n", st);
  282. }
  283. /*
  284. * ISOC message interrupt from the USB device
  285. *
  286. * Analyse each packet and call the subdriver for copy to the frame buffer.
  287. */
  288. static void isoc_irq(struct urb *urb)
  289. {
  290. struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
  291. gspca_dbg(gspca_dev, D_PACK, "isoc irq\n");
  292. if (!gspca_dev->streaming)
  293. return;
  294. fill_frame(gspca_dev, urb);
  295. }
  296. /*
  297. * bulk message interrupt from the USB device
  298. */
  299. static void bulk_irq(struct urb *urb)
  300. {
  301. struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
  302. int st;
  303. gspca_dbg(gspca_dev, D_PACK, "bulk irq\n");
  304. if (!gspca_dev->streaming)
  305. return;
  306. switch (urb->status) {
  307. case 0:
  308. break;
  309. case -ESHUTDOWN:
  310. return; /* disconnection */
  311. default:
  312. #ifdef CONFIG_PM
  313. if (gspca_dev->frozen)
  314. return;
  315. #endif
  316. gspca_err(gspca_dev, "urb status: %d\n", urb->status);
  317. urb->status = 0;
  318. goto resubmit;
  319. }
  320. gspca_dbg(gspca_dev, D_PACK, "packet l:%d\n", urb->actual_length);
  321. gspca_dev->sd_desc->pkt_scan(gspca_dev,
  322. urb->transfer_buffer,
  323. urb->actual_length);
  324. resubmit:
  325. if (!gspca_dev->streaming)
  326. return;
  327. /* resubmit the URB */
  328. if (gspca_dev->cam.bulk_nurbs != 0) {
  329. st = usb_submit_urb(urb, GFP_ATOMIC);
  330. if (st < 0)
  331. pr_err("usb_submit_urb() ret %d\n", st);
  332. }
  333. }
  334. /*
  335. * add data to the current frame
  336. *
  337. * This function is called by the subdrivers at interrupt level.
  338. *
  339. * To build a frame, these ones must add
  340. * - one FIRST_PACKET
  341. * - 0 or many INTER_PACKETs
  342. * - one LAST_PACKET
  343. * DISCARD_PACKET invalidates the whole frame.
  344. */
  345. void gspca_frame_add(struct gspca_dev *gspca_dev,
  346. enum gspca_packet_type packet_type,
  347. const u8 *data,
  348. int len)
  349. {
  350. struct gspca_buffer *buf;
  351. unsigned long flags;
  352. gspca_dbg(gspca_dev, D_PACK, "add t:%d l:%d\n", packet_type, len);
  353. spin_lock_irqsave(&gspca_dev->qlock, flags);
  354. buf = list_first_entry_or_null(&gspca_dev->buf_list,
  355. typeof(*buf), list);
  356. spin_unlock_irqrestore(&gspca_dev->qlock, flags);
  357. if (packet_type == FIRST_PACKET) {
  358. /* if there is no queued buffer, discard the whole frame */
  359. if (!buf) {
  360. gspca_dev->last_packet_type = DISCARD_PACKET;
  361. gspca_dev->sequence++;
  362. return;
  363. }
  364. gspca_dev->image = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
  365. gspca_dev->image_len = 0;
  366. } else {
  367. switch (gspca_dev->last_packet_type) {
  368. case DISCARD_PACKET:
  369. if (packet_type == LAST_PACKET) {
  370. gspca_dev->last_packet_type = packet_type;
  371. gspca_dev->image = NULL;
  372. gspca_dev->image_len = 0;
  373. }
  374. return;
  375. case LAST_PACKET:
  376. return;
  377. }
  378. }
  379. /* append the packet to the frame buffer */
  380. if (len > 0) {
  381. if (gspca_dev->image_len + len > PAGE_ALIGN(gspca_dev->pixfmt.sizeimage)) {
  382. gspca_err(gspca_dev, "frame overflow %d > %d\n",
  383. gspca_dev->image_len + len,
  384. PAGE_ALIGN(gspca_dev->pixfmt.sizeimage));
  385. packet_type = DISCARD_PACKET;
  386. } else {
  387. /* !! image is NULL only when last pkt is LAST or DISCARD
  388. if (gspca_dev->image == NULL) {
  389. pr_err("gspca_frame_add() image == NULL\n");
  390. return;
  391. }
  392. */
  393. memcpy(gspca_dev->image + gspca_dev->image_len,
  394. data, len);
  395. gspca_dev->image_len += len;
  396. }
  397. }
  398. gspca_dev->last_packet_type = packet_type;
  399. /* if last packet, invalidate packet concatenation until
  400. * next first packet, wake up the application and advance
  401. * in the queue */
  402. if (packet_type == LAST_PACKET) {
  403. spin_lock_irqsave(&gspca_dev->qlock, flags);
  404. list_del(&buf->list);
  405. spin_unlock_irqrestore(&gspca_dev->qlock, flags);
  406. buf->vb.vb2_buf.timestamp = ktime_get_ns();
  407. vb2_set_plane_payload(&buf->vb.vb2_buf, 0,
  408. gspca_dev->image_len);
  409. buf->vb.sequence = gspca_dev->sequence++;
  410. buf->vb.field = V4L2_FIELD_NONE;
  411. gspca_dbg(gspca_dev, D_FRAM, "frame complete len:%d\n",
  412. gspca_dev->image_len);
  413. vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
  414. gspca_dev->image = NULL;
  415. gspca_dev->image_len = 0;
  416. }
  417. }
  418. EXPORT_SYMBOL(gspca_frame_add);
  419. static void destroy_urbs(struct gspca_dev *gspca_dev)
  420. {
  421. struct urb *urb;
  422. unsigned int i;
  423. gspca_dbg(gspca_dev, D_STREAM, "kill transfer\n");
  424. /* Killing all URBs guarantee that no URB completion
  425. * handler is running. Therefore, there shouldn't
  426. * be anyone trying to access gspca_dev->urb[i]
  427. */
  428. for (i = 0; i < MAX_NURBS; i++)
  429. usb_kill_urb(gspca_dev->urb[i]);
  430. gspca_dbg(gspca_dev, D_STREAM, "releasing urbs\n");
  431. for (i = 0; i < MAX_NURBS; i++) {
  432. urb = gspca_dev->urb[i];
  433. if (!urb)
  434. continue;
  435. gspca_dev->urb[i] = NULL;
  436. usb_free_coherent(gspca_dev->dev,
  437. urb->transfer_buffer_length,
  438. urb->transfer_buffer,
  439. urb->transfer_dma);
  440. usb_free_urb(urb);
  441. }
  442. }
  443. static int gspca_set_alt0(struct gspca_dev *gspca_dev)
  444. {
  445. int ret;
  446. if (gspca_dev->alt == 0)
  447. return 0;
  448. ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0);
  449. if (ret < 0)
  450. pr_err("set alt 0 err %d\n", ret);
  451. return ret;
  452. }
  453. /*
  454. * look for an input transfer endpoint in an alternate setting.
  455. *
  456. * If xfer_ep is invalid, return the first valid ep found, otherwise
  457. * look for exactly the ep with address equal to xfer_ep.
  458. */
  459. static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt,
  460. int xfer, int xfer_ep)
  461. {
  462. struct usb_host_endpoint *ep;
  463. int i, attr;
  464. for (i = 0; i < alt->desc.bNumEndpoints; i++) {
  465. ep = &alt->endpoint[i];
  466. attr = ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
  467. if (attr == xfer
  468. && ep->desc.wMaxPacketSize != 0
  469. && usb_endpoint_dir_in(&ep->desc)
  470. && (xfer_ep < 0 || ep->desc.bEndpointAddress == xfer_ep))
  471. return ep;
  472. }
  473. return NULL;
  474. }
  475. /* compute the minimum bandwidth for the current transfer */
  476. static u32 which_bandwidth(struct gspca_dev *gspca_dev)
  477. {
  478. u32 bandwidth;
  479. /* get the (max) image size */
  480. bandwidth = gspca_dev->pixfmt.sizeimage;
  481. /* if the image is compressed, estimate its mean size */
  482. if (!gspca_dev->cam.needs_full_bandwidth &&
  483. bandwidth < gspca_dev->pixfmt.width *
  484. gspca_dev->pixfmt.height)
  485. bandwidth = bandwidth * 3 / 8; /* 0.375 */
  486. /* estimate the frame rate */
  487. if (gspca_dev->sd_desc->get_streamparm) {
  488. struct v4l2_streamparm parm;
  489. gspca_dev->sd_desc->get_streamparm(gspca_dev, &parm);
  490. bandwidth *= parm.parm.capture.timeperframe.denominator;
  491. bandwidth /= parm.parm.capture.timeperframe.numerator;
  492. } else {
  493. /* don't hope more than 15 fps with USB 1.1 and
  494. * image resolution >= 640x480 */
  495. if (gspca_dev->pixfmt.width >= 640
  496. && gspca_dev->dev->speed == USB_SPEED_FULL)
  497. bandwidth *= 15; /* 15 fps */
  498. else
  499. bandwidth *= 30; /* 30 fps */
  500. }
  501. gspca_dbg(gspca_dev, D_STREAM, "min bandwidth: %d\n", bandwidth);
  502. return bandwidth;
  503. }
  504. /* endpoint table */
  505. #define MAX_ALT 16
  506. struct ep_tb_s {
  507. u32 alt;
  508. u32 bandwidth;
  509. };
  510. /*
  511. * build the table of the endpoints
  512. * and compute the minimum bandwidth for the image transfer
  513. */
  514. static int build_isoc_ep_tb(struct gspca_dev *gspca_dev,
  515. struct usb_interface *intf,
  516. struct ep_tb_s *ep_tb)
  517. {
  518. struct usb_host_endpoint *ep;
  519. int i, j, nbalt, psize, found;
  520. u32 bandwidth, last_bw;
  521. nbalt = intf->num_altsetting;
  522. if (nbalt > MAX_ALT)
  523. nbalt = MAX_ALT; /* fixme: should warn */
  524. /* build the endpoint table */
  525. i = 0;
  526. last_bw = 0;
  527. for (;;) {
  528. ep_tb->bandwidth = 2000 * 2000 * 120;
  529. found = 0;
  530. for (j = 0; j < nbalt; j++) {
  531. ep = alt_xfer(&intf->altsetting[j],
  532. USB_ENDPOINT_XFER_ISOC,
  533. gspca_dev->xfer_ep);
  534. if (ep == NULL)
  535. continue;
  536. if (ep->desc.bInterval == 0) {
  537. pr_err("alt %d iso endp with 0 interval\n", j);
  538. continue;
  539. }
  540. psize = le16_to_cpu(ep->desc.wMaxPacketSize);
  541. psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
  542. bandwidth = psize * 1000;
  543. if (gspca_dev->dev->speed == USB_SPEED_HIGH
  544. || gspca_dev->dev->speed >= USB_SPEED_SUPER)
  545. bandwidth *= 8;
  546. bandwidth /= 1 << (ep->desc.bInterval - 1);
  547. if (bandwidth <= last_bw)
  548. continue;
  549. if (bandwidth < ep_tb->bandwidth) {
  550. ep_tb->bandwidth = bandwidth;
  551. ep_tb->alt = j;
  552. found = 1;
  553. }
  554. }
  555. if (!found)
  556. break;
  557. gspca_dbg(gspca_dev, D_STREAM, "alt %d bandwidth %d\n",
  558. ep_tb->alt, ep_tb->bandwidth);
  559. last_bw = ep_tb->bandwidth;
  560. i++;
  561. ep_tb++;
  562. }
  563. /*
  564. * If the camera:
  565. * has a usb audio class interface (a built in usb mic); and
  566. * is a usb 1 full speed device; and
  567. * uses the max full speed iso bandwidth; and
  568. * and has more than 1 alt setting
  569. * then skip the highest alt setting to spare bandwidth for the mic
  570. */
  571. if (gspca_dev->audio &&
  572. gspca_dev->dev->speed == USB_SPEED_FULL &&
  573. last_bw >= 1000000 &&
  574. i > 1) {
  575. gspca_dbg(gspca_dev, D_STREAM, "dev has usb audio, skipping highest alt\n");
  576. i--;
  577. ep_tb--;
  578. }
  579. /* get the requested bandwidth and start at the highest atlsetting */
  580. bandwidth = which_bandwidth(gspca_dev);
  581. ep_tb--;
  582. while (i > 1) {
  583. ep_tb--;
  584. if (ep_tb->bandwidth < bandwidth)
  585. break;
  586. i--;
  587. }
  588. return i;
  589. }
  590. /*
  591. * create the URBs for image transfer
  592. */
  593. static int create_urbs(struct gspca_dev *gspca_dev,
  594. struct usb_host_endpoint *ep)
  595. {
  596. struct urb *urb;
  597. int n, nurbs, i, psize, npkt, bsize;
  598. /* calculate the packet size and the number of packets */
  599. psize = le16_to_cpu(ep->desc.wMaxPacketSize);
  600. if (!gspca_dev->cam.bulk) { /* isoc */
  601. /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
  602. if (gspca_dev->pkt_size == 0)
  603. psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
  604. else
  605. psize = gspca_dev->pkt_size;
  606. npkt = gspca_dev->cam.npkt;
  607. if (npkt == 0)
  608. npkt = 32; /* default value */
  609. bsize = psize * npkt;
  610. gspca_dbg(gspca_dev, D_STREAM,
  611. "isoc %d pkts size %d = bsize:%d\n",
  612. npkt, psize, bsize);
  613. nurbs = DEF_NURBS;
  614. } else { /* bulk */
  615. npkt = 0;
  616. bsize = gspca_dev->cam.bulk_size;
  617. if (bsize == 0)
  618. bsize = psize;
  619. gspca_dbg(gspca_dev, D_STREAM, "bulk bsize:%d\n", bsize);
  620. if (gspca_dev->cam.bulk_nurbs != 0)
  621. nurbs = gspca_dev->cam.bulk_nurbs;
  622. else
  623. nurbs = 1;
  624. }
  625. for (n = 0; n < nurbs; n++) {
  626. urb = usb_alloc_urb(npkt, GFP_KERNEL);
  627. if (!urb)
  628. return -ENOMEM;
  629. gspca_dev->urb[n] = urb;
  630. urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev,
  631. bsize,
  632. GFP_KERNEL,
  633. &urb->transfer_dma);
  634. if (urb->transfer_buffer == NULL) {
  635. pr_err("usb_alloc_coherent failed\n");
  636. return -ENOMEM;
  637. }
  638. urb->dev = gspca_dev->dev;
  639. urb->context = gspca_dev;
  640. urb->transfer_buffer_length = bsize;
  641. if (npkt != 0) { /* ISOC */
  642. urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
  643. ep->desc.bEndpointAddress);
  644. urb->transfer_flags = URB_ISO_ASAP
  645. | URB_NO_TRANSFER_DMA_MAP;
  646. urb->interval = 1 << (ep->desc.bInterval - 1);
  647. urb->complete = isoc_irq;
  648. urb->number_of_packets = npkt;
  649. for (i = 0; i < npkt; i++) {
  650. urb->iso_frame_desc[i].length = psize;
  651. urb->iso_frame_desc[i].offset = psize * i;
  652. }
  653. } else { /* bulk */
  654. urb->pipe = usb_rcvbulkpipe(gspca_dev->dev,
  655. ep->desc.bEndpointAddress);
  656. urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
  657. urb->complete = bulk_irq;
  658. }
  659. }
  660. return 0;
  661. }
  662. /* Note: both the queue and the usb locks should be held when calling this */
  663. static void gspca_stream_off(struct gspca_dev *gspca_dev)
  664. {
  665. gspca_dev->streaming = false;
  666. gspca_dev->usb_err = 0;
  667. if (gspca_dev->sd_desc->stopN)
  668. gspca_dev->sd_desc->stopN(gspca_dev);
  669. destroy_urbs(gspca_dev);
  670. gspca_input_destroy_urb(gspca_dev);
  671. gspca_set_alt0(gspca_dev);
  672. if (gspca_dev->present)
  673. gspca_input_create_urb(gspca_dev);
  674. if (gspca_dev->sd_desc->stop0)
  675. gspca_dev->sd_desc->stop0(gspca_dev);
  676. gspca_dbg(gspca_dev, D_STREAM, "stream off OK\n");
  677. }
  678. /*
  679. * start the USB transfer
  680. */
  681. static int gspca_init_transfer(struct gspca_dev *gspca_dev)
  682. {
  683. struct usb_interface *intf;
  684. struct usb_host_endpoint *ep;
  685. struct urb *urb;
  686. struct ep_tb_s ep_tb[MAX_ALT];
  687. int n, ret, xfer, alt, alt_idx;
  688. /* reset the streaming variables */
  689. gspca_dev->image = NULL;
  690. gspca_dev->image_len = 0;
  691. gspca_dev->last_packet_type = DISCARD_PACKET;
  692. gspca_dev->usb_err = 0;
  693. /* do the specific subdriver stuff before endpoint selection */
  694. intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
  695. gspca_dev->alt = gspca_dev->cam.bulk ? intf->num_altsetting : 0;
  696. if (gspca_dev->sd_desc->isoc_init) {
  697. ret = gspca_dev->sd_desc->isoc_init(gspca_dev);
  698. if (ret < 0)
  699. return ret;
  700. }
  701. xfer = gspca_dev->cam.bulk ? USB_ENDPOINT_XFER_BULK
  702. : USB_ENDPOINT_XFER_ISOC;
  703. /* if bulk or the subdriver forced an altsetting, get the endpoint */
  704. if (gspca_dev->alt != 0) {
  705. gspca_dev->alt--; /* (previous version compatibility) */
  706. ep = alt_xfer(&intf->altsetting[gspca_dev->alt], xfer,
  707. gspca_dev->xfer_ep);
  708. if (ep == NULL) {
  709. pr_err("bad altsetting %d\n", gspca_dev->alt);
  710. return -EIO;
  711. }
  712. ep_tb[0].alt = gspca_dev->alt;
  713. alt_idx = 1;
  714. } else {
  715. /* else, compute the minimum bandwidth
  716. * and build the endpoint table */
  717. alt_idx = build_isoc_ep_tb(gspca_dev, intf, ep_tb);
  718. if (alt_idx <= 0) {
  719. pr_err("no transfer endpoint found\n");
  720. return -EIO;
  721. }
  722. }
  723. /* set the highest alternate setting and
  724. * loop until urb submit succeeds */
  725. gspca_input_destroy_urb(gspca_dev);
  726. gspca_dev->alt = ep_tb[--alt_idx].alt;
  727. alt = -1;
  728. for (;;) {
  729. if (alt != gspca_dev->alt) {
  730. alt = gspca_dev->alt;
  731. if (intf->num_altsetting > 1) {
  732. ret = usb_set_interface(gspca_dev->dev,
  733. gspca_dev->iface,
  734. alt);
  735. if (ret < 0) {
  736. if (ret == -ENOSPC)
  737. goto retry; /*fixme: ugly*/
  738. pr_err("set alt %d err %d\n", alt, ret);
  739. goto out;
  740. }
  741. }
  742. }
  743. if (!gspca_dev->cam.no_urb_create) {
  744. gspca_dbg(gspca_dev, D_STREAM, "init transfer alt %d\n",
  745. alt);
  746. ret = create_urbs(gspca_dev,
  747. alt_xfer(&intf->altsetting[alt], xfer,
  748. gspca_dev->xfer_ep));
  749. if (ret < 0) {
  750. destroy_urbs(gspca_dev);
  751. goto out;
  752. }
  753. }
  754. /* clear the bulk endpoint */
  755. if (gspca_dev->cam.bulk)
  756. usb_clear_halt(gspca_dev->dev,
  757. gspca_dev->urb[0]->pipe);
  758. /* start the cam */
  759. ret = gspca_dev->sd_desc->start(gspca_dev);
  760. if (ret < 0) {
  761. destroy_urbs(gspca_dev);
  762. goto out;
  763. }
  764. v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler);
  765. gspca_dev->streaming = true;
  766. /* some bulk transfers are started by the subdriver */
  767. if (gspca_dev->cam.bulk && gspca_dev->cam.bulk_nurbs == 0)
  768. break;
  769. /* submit the URBs */
  770. for (n = 0; n < MAX_NURBS; n++) {
  771. urb = gspca_dev->urb[n];
  772. if (urb == NULL)
  773. break;
  774. ret = usb_submit_urb(urb, GFP_KERNEL);
  775. if (ret < 0)
  776. break;
  777. }
  778. if (ret >= 0)
  779. break; /* transfer is started */
  780. /* something when wrong
  781. * stop the webcam and free the transfer resources */
  782. gspca_stream_off(gspca_dev);
  783. if (ret != -ENOSPC) {
  784. pr_err("usb_submit_urb alt %d err %d\n",
  785. gspca_dev->alt, ret);
  786. goto out;
  787. }
  788. /* the bandwidth is not wide enough
  789. * negotiate or try a lower alternate setting */
  790. retry:
  791. gspca_err(gspca_dev, "alt %d - bandwidth not wide enough, trying again\n",
  792. alt);
  793. msleep(20); /* wait for kill complete */
  794. if (gspca_dev->sd_desc->isoc_nego) {
  795. ret = gspca_dev->sd_desc->isoc_nego(gspca_dev);
  796. if (ret < 0)
  797. goto out;
  798. } else {
  799. if (alt_idx <= 0) {
  800. pr_err("no transfer endpoint found\n");
  801. ret = -EIO;
  802. goto out;
  803. }
  804. gspca_dev->alt = ep_tb[--alt_idx].alt;
  805. }
  806. }
  807. out:
  808. gspca_input_create_urb(gspca_dev);
  809. return ret;
  810. }
  811. static void gspca_set_default_mode(struct gspca_dev *gspca_dev)
  812. {
  813. int i;
  814. i = gspca_dev->cam.nmodes - 1; /* take the highest mode */
  815. gspca_dev->curr_mode = i;
  816. gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i];
  817. /* does nothing if ctrl_handler == NULL */
  818. v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler);
  819. }
  820. static int wxh_to_mode(struct gspca_dev *gspca_dev,
  821. int width, int height)
  822. {
  823. int i;
  824. for (i = 0; i < gspca_dev->cam.nmodes; i++) {
  825. if (width == gspca_dev->cam.cam_mode[i].width
  826. && height == gspca_dev->cam.cam_mode[i].height)
  827. return i;
  828. }
  829. return -EINVAL;
  830. }
  831. static int wxh_to_nearest_mode(struct gspca_dev *gspca_dev,
  832. int width, int height)
  833. {
  834. int i;
  835. for (i = gspca_dev->cam.nmodes; --i > 0; ) {
  836. if (width >= gspca_dev->cam.cam_mode[i].width
  837. && height >= gspca_dev->cam.cam_mode[i].height)
  838. break;
  839. }
  840. return i;
  841. }
  842. /*
  843. * search a mode with the right pixel format
  844. */
  845. static int gspca_get_mode(struct gspca_dev *gspca_dev,
  846. int mode,
  847. int pixfmt)
  848. {
  849. int modeU, modeD;
  850. modeU = modeD = mode;
  851. while ((modeU < gspca_dev->cam.nmodes) || modeD >= 0) {
  852. if (--modeD >= 0) {
  853. if (gspca_dev->cam.cam_mode[modeD].pixelformat
  854. == pixfmt)
  855. return modeD;
  856. }
  857. if (++modeU < gspca_dev->cam.nmodes) {
  858. if (gspca_dev->cam.cam_mode[modeU].pixelformat
  859. == pixfmt)
  860. return modeU;
  861. }
  862. }
  863. return -EINVAL;
  864. }
  865. #ifdef CONFIG_VIDEO_ADV_DEBUG
  866. static int vidioc_g_chip_info(struct file *file, void *priv,
  867. struct v4l2_dbg_chip_info *chip)
  868. {
  869. struct gspca_dev *gspca_dev = video_drvdata(file);
  870. gspca_dev->usb_err = 0;
  871. if (gspca_dev->sd_desc->get_chip_info)
  872. return gspca_dev->sd_desc->get_chip_info(gspca_dev, chip);
  873. return chip->match.addr ? -EINVAL : 0;
  874. }
  875. static int vidioc_g_register(struct file *file, void *priv,
  876. struct v4l2_dbg_register *reg)
  877. {
  878. struct gspca_dev *gspca_dev = video_drvdata(file);
  879. gspca_dev->usb_err = 0;
  880. return gspca_dev->sd_desc->get_register(gspca_dev, reg);
  881. }
  882. static int vidioc_s_register(struct file *file, void *priv,
  883. const struct v4l2_dbg_register *reg)
  884. {
  885. struct gspca_dev *gspca_dev = video_drvdata(file);
  886. gspca_dev->usb_err = 0;
  887. return gspca_dev->sd_desc->set_register(gspca_dev, reg);
  888. }
  889. #endif
  890. static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
  891. struct v4l2_fmtdesc *fmtdesc)
  892. {
  893. struct gspca_dev *gspca_dev = video_drvdata(file);
  894. int i, j, index;
  895. __u32 fmt_tb[8];
  896. /* give an index to each format */
  897. index = 0;
  898. for (i = gspca_dev->cam.nmodes; --i >= 0; ) {
  899. fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixelformat;
  900. j = 0;
  901. for (;;) {
  902. if (fmt_tb[j] == fmt_tb[index])
  903. break;
  904. j++;
  905. }
  906. if (j == index) {
  907. if (fmtdesc->index == index)
  908. break; /* new format */
  909. index++;
  910. if (index >= ARRAY_SIZE(fmt_tb))
  911. return -EINVAL;
  912. }
  913. }
  914. if (i < 0)
  915. return -EINVAL; /* no more format */
  916. fmtdesc->pixelformat = fmt_tb[index];
  917. if (gspca_dev->cam.cam_mode[i].sizeimage <
  918. gspca_dev->cam.cam_mode[i].width *
  919. gspca_dev->cam.cam_mode[i].height)
  920. fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED;
  921. fmtdesc->description[0] = fmtdesc->pixelformat & 0xff;
  922. fmtdesc->description[1] = (fmtdesc->pixelformat >> 8) & 0xff;
  923. fmtdesc->description[2] = (fmtdesc->pixelformat >> 16) & 0xff;
  924. fmtdesc->description[3] = fmtdesc->pixelformat >> 24;
  925. fmtdesc->description[4] = '\0';
  926. return 0;
  927. }
  928. static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
  929. struct v4l2_format *fmt)
  930. {
  931. struct gspca_dev *gspca_dev = video_drvdata(file);
  932. fmt->fmt.pix = gspca_dev->pixfmt;
  933. /* some drivers use priv internally, zero it before giving it back to
  934. the core */
  935. fmt->fmt.pix.priv = 0;
  936. return 0;
  937. }
  938. static int try_fmt_vid_cap(struct gspca_dev *gspca_dev,
  939. struct v4l2_format *fmt)
  940. {
  941. int w, h, mode, mode2;
  942. w = fmt->fmt.pix.width;
  943. h = fmt->fmt.pix.height;
  944. PDEBUG_MODE(gspca_dev, D_CONF, "try fmt cap",
  945. fmt->fmt.pix.pixelformat, w, h);
  946. /* search the nearest mode for width and height */
  947. mode = wxh_to_nearest_mode(gspca_dev, w, h);
  948. /* OK if right palette */
  949. if (gspca_dev->cam.cam_mode[mode].pixelformat
  950. != fmt->fmt.pix.pixelformat) {
  951. /* else, search the closest mode with the same pixel format */
  952. mode2 = gspca_get_mode(gspca_dev, mode,
  953. fmt->fmt.pix.pixelformat);
  954. if (mode2 >= 0)
  955. mode = mode2;
  956. }
  957. fmt->fmt.pix = gspca_dev->cam.cam_mode[mode];
  958. if (gspca_dev->sd_desc->try_fmt) {
  959. /* pass original resolution to subdriver try_fmt */
  960. fmt->fmt.pix.width = w;
  961. fmt->fmt.pix.height = h;
  962. gspca_dev->sd_desc->try_fmt(gspca_dev, fmt);
  963. }
  964. /* some drivers use priv internally, zero it before giving it back to
  965. the core */
  966. fmt->fmt.pix.priv = 0;
  967. return mode; /* used when s_fmt */
  968. }
  969. static int vidioc_try_fmt_vid_cap(struct file *file,
  970. void *priv,
  971. struct v4l2_format *fmt)
  972. {
  973. struct gspca_dev *gspca_dev = video_drvdata(file);
  974. if (try_fmt_vid_cap(gspca_dev, fmt) < 0)
  975. return -EINVAL;
  976. return 0;
  977. }
  978. static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
  979. struct v4l2_format *fmt)
  980. {
  981. struct gspca_dev *gspca_dev = video_drvdata(file);
  982. int mode;
  983. if (vb2_is_busy(&gspca_dev->queue))
  984. return -EBUSY;
  985. mode = try_fmt_vid_cap(gspca_dev, fmt);
  986. if (mode < 0)
  987. return -EINVAL;
  988. gspca_dev->curr_mode = mode;
  989. if (gspca_dev->sd_desc->try_fmt)
  990. /* subdriver try_fmt can modify format parameters */
  991. gspca_dev->pixfmt = fmt->fmt.pix;
  992. else
  993. gspca_dev->pixfmt = gspca_dev->cam.cam_mode[mode];
  994. return 0;
  995. }
  996. static int vidioc_enum_framesizes(struct file *file, void *priv,
  997. struct v4l2_frmsizeenum *fsize)
  998. {
  999. struct gspca_dev *gspca_dev = video_drvdata(file);
  1000. int i;
  1001. __u32 index = 0;
  1002. if (gspca_dev->sd_desc->enum_framesizes)
  1003. return gspca_dev->sd_desc->enum_framesizes(gspca_dev, fsize);
  1004. for (i = 0; i < gspca_dev->cam.nmodes; i++) {
  1005. if (fsize->pixel_format !=
  1006. gspca_dev->cam.cam_mode[i].pixelformat)
  1007. continue;
  1008. if (fsize->index == index) {
  1009. fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
  1010. fsize->discrete.width =
  1011. gspca_dev->cam.cam_mode[i].width;
  1012. fsize->discrete.height =
  1013. gspca_dev->cam.cam_mode[i].height;
  1014. return 0;
  1015. }
  1016. index++;
  1017. }
  1018. return -EINVAL;
  1019. }
  1020. static int vidioc_enum_frameintervals(struct file *filp, void *priv,
  1021. struct v4l2_frmivalenum *fival)
  1022. {
  1023. struct gspca_dev *gspca_dev = video_drvdata(filp);
  1024. int mode;
  1025. __u32 i;
  1026. mode = wxh_to_mode(gspca_dev, fival->width, fival->height);
  1027. if (mode < 0)
  1028. return -EINVAL;
  1029. if (gspca_dev->cam.mode_framerates == NULL ||
  1030. gspca_dev->cam.mode_framerates[mode].nrates == 0)
  1031. return -EINVAL;
  1032. if (fival->pixel_format !=
  1033. gspca_dev->cam.cam_mode[mode].pixelformat)
  1034. return -EINVAL;
  1035. for (i = 0; i < gspca_dev->cam.mode_framerates[mode].nrates; i++) {
  1036. if (fival->index == i) {
  1037. fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
  1038. fival->discrete.numerator = 1;
  1039. fival->discrete.denominator =
  1040. gspca_dev->cam.mode_framerates[mode].rates[i];
  1041. return 0;
  1042. }
  1043. }
  1044. return -EINVAL;
  1045. }
  1046. static void gspca_release(struct v4l2_device *v4l2_device)
  1047. {
  1048. struct gspca_dev *gspca_dev =
  1049. container_of(v4l2_device, struct gspca_dev, v4l2_dev);
  1050. v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler);
  1051. v4l2_device_unregister(&gspca_dev->v4l2_dev);
  1052. kfree(gspca_dev->usb_buf);
  1053. kfree(gspca_dev);
  1054. }
  1055. static int vidioc_querycap(struct file *file, void *priv,
  1056. struct v4l2_capability *cap)
  1057. {
  1058. struct gspca_dev *gspca_dev = video_drvdata(file);
  1059. strlcpy((char *) cap->driver, gspca_dev->sd_desc->name,
  1060. sizeof cap->driver);
  1061. if (gspca_dev->dev->product != NULL) {
  1062. strlcpy((char *) cap->card, gspca_dev->dev->product,
  1063. sizeof cap->card);
  1064. } else {
  1065. snprintf((char *) cap->card, sizeof cap->card,
  1066. "USB Camera (%04x:%04x)",
  1067. le16_to_cpu(gspca_dev->dev->descriptor.idVendor),
  1068. le16_to_cpu(gspca_dev->dev->descriptor.idProduct));
  1069. }
  1070. usb_make_path(gspca_dev->dev, (char *) cap->bus_info,
  1071. sizeof(cap->bus_info));
  1072. cap->device_caps = V4L2_CAP_VIDEO_CAPTURE
  1073. | V4L2_CAP_STREAMING
  1074. | V4L2_CAP_READWRITE;
  1075. cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
  1076. return 0;
  1077. }
  1078. static int vidioc_enum_input(struct file *file, void *priv,
  1079. struct v4l2_input *input)
  1080. {
  1081. struct gspca_dev *gspca_dev = video_drvdata(file);
  1082. if (input->index != 0)
  1083. return -EINVAL;
  1084. input->type = V4L2_INPUT_TYPE_CAMERA;
  1085. input->status = gspca_dev->cam.input_flags;
  1086. strlcpy(input->name, gspca_dev->sd_desc->name,
  1087. sizeof input->name);
  1088. return 0;
  1089. }
  1090. static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
  1091. {
  1092. *i = 0;
  1093. return 0;
  1094. }
  1095. static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
  1096. {
  1097. if (i > 0)
  1098. return -EINVAL;
  1099. return 0;
  1100. }
  1101. static int vidioc_g_jpegcomp(struct file *file, void *priv,
  1102. struct v4l2_jpegcompression *jpegcomp)
  1103. {
  1104. struct gspca_dev *gspca_dev = video_drvdata(file);
  1105. gspca_dev->usb_err = 0;
  1106. return gspca_dev->sd_desc->get_jcomp(gspca_dev, jpegcomp);
  1107. }
  1108. static int vidioc_s_jpegcomp(struct file *file, void *priv,
  1109. const struct v4l2_jpegcompression *jpegcomp)
  1110. {
  1111. struct gspca_dev *gspca_dev = video_drvdata(file);
  1112. gspca_dev->usb_err = 0;
  1113. return gspca_dev->sd_desc->set_jcomp(gspca_dev, jpegcomp);
  1114. }
  1115. static int vidioc_g_parm(struct file *filp, void *priv,
  1116. struct v4l2_streamparm *parm)
  1117. {
  1118. struct gspca_dev *gspca_dev = video_drvdata(filp);
  1119. parm->parm.capture.readbuffers = gspca_dev->queue.min_buffers_needed;
  1120. if (!gspca_dev->sd_desc->get_streamparm)
  1121. return 0;
  1122. parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
  1123. gspca_dev->usb_err = 0;
  1124. gspca_dev->sd_desc->get_streamparm(gspca_dev, parm);
  1125. return gspca_dev->usb_err;
  1126. }
  1127. static int vidioc_s_parm(struct file *filp, void *priv,
  1128. struct v4l2_streamparm *parm)
  1129. {
  1130. struct gspca_dev *gspca_dev = video_drvdata(filp);
  1131. parm->parm.capture.readbuffers = gspca_dev->queue.min_buffers_needed;
  1132. if (!gspca_dev->sd_desc->set_streamparm) {
  1133. parm->parm.capture.capability = 0;
  1134. return 0;
  1135. }
  1136. parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
  1137. gspca_dev->usb_err = 0;
  1138. gspca_dev->sd_desc->set_streamparm(gspca_dev, parm);
  1139. return gspca_dev->usb_err;
  1140. }
  1141. static int gspca_queue_setup(struct vb2_queue *vq,
  1142. unsigned int *nbuffers, unsigned int *nplanes,
  1143. unsigned int sizes[], struct device *alloc_devs[])
  1144. {
  1145. struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq);
  1146. unsigned int size = PAGE_ALIGN(gspca_dev->pixfmt.sizeimage);
  1147. if (*nplanes)
  1148. return sizes[0] < size ? -EINVAL : 0;
  1149. *nplanes = 1;
  1150. sizes[0] = size;
  1151. return 0;
  1152. }
  1153. static int gspca_buffer_prepare(struct vb2_buffer *vb)
  1154. {
  1155. struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue);
  1156. unsigned long size = PAGE_ALIGN(gspca_dev->pixfmt.sizeimage);
  1157. if (vb2_plane_size(vb, 0) < size) {
  1158. gspca_err(gspca_dev, "buffer too small (%lu < %lu)\n",
  1159. vb2_plane_size(vb, 0), size);
  1160. return -EINVAL;
  1161. }
  1162. return 0;
  1163. }
  1164. static void gspca_buffer_finish(struct vb2_buffer *vb)
  1165. {
  1166. struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue);
  1167. if (!gspca_dev->sd_desc->dq_callback)
  1168. return;
  1169. gspca_dev->usb_err = 0;
  1170. if (gspca_dev->present)
  1171. gspca_dev->sd_desc->dq_callback(gspca_dev);
  1172. }
  1173. static void gspca_buffer_queue(struct vb2_buffer *vb)
  1174. {
  1175. struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue);
  1176. struct gspca_buffer *buf = to_gspca_buffer(vb);
  1177. unsigned long flags;
  1178. spin_lock_irqsave(&gspca_dev->qlock, flags);
  1179. list_add_tail(&buf->list, &gspca_dev->buf_list);
  1180. spin_unlock_irqrestore(&gspca_dev->qlock, flags);
  1181. }
  1182. static void gspca_return_all_buffers(struct gspca_dev *gspca_dev,
  1183. enum vb2_buffer_state state)
  1184. {
  1185. struct gspca_buffer *buf, *node;
  1186. unsigned long flags;
  1187. spin_lock_irqsave(&gspca_dev->qlock, flags);
  1188. list_for_each_entry_safe(buf, node, &gspca_dev->buf_list, list) {
  1189. vb2_buffer_done(&buf->vb.vb2_buf, state);
  1190. list_del(&buf->list);
  1191. }
  1192. spin_unlock_irqrestore(&gspca_dev->qlock, flags);
  1193. }
  1194. static int gspca_start_streaming(struct vb2_queue *vq, unsigned int count)
  1195. {
  1196. struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq);
  1197. int ret;
  1198. gspca_dev->sequence = 0;
  1199. ret = gspca_init_transfer(gspca_dev);
  1200. if (ret)
  1201. gspca_return_all_buffers(gspca_dev, VB2_BUF_STATE_QUEUED);
  1202. return ret;
  1203. }
  1204. static void gspca_stop_streaming(struct vb2_queue *vq)
  1205. {
  1206. struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq);
  1207. gspca_stream_off(gspca_dev);
  1208. /* Release all active buffers */
  1209. gspca_return_all_buffers(gspca_dev, VB2_BUF_STATE_ERROR);
  1210. }
  1211. static const struct vb2_ops gspca_qops = {
  1212. .queue_setup = gspca_queue_setup,
  1213. .buf_prepare = gspca_buffer_prepare,
  1214. .buf_finish = gspca_buffer_finish,
  1215. .buf_queue = gspca_buffer_queue,
  1216. .start_streaming = gspca_start_streaming,
  1217. .stop_streaming = gspca_stop_streaming,
  1218. .wait_prepare = vb2_ops_wait_prepare,
  1219. .wait_finish = vb2_ops_wait_finish,
  1220. };
  1221. static const struct v4l2_file_operations dev_fops = {
  1222. .owner = THIS_MODULE,
  1223. .open = v4l2_fh_open,
  1224. .release = vb2_fop_release,
  1225. .unlocked_ioctl = video_ioctl2,
  1226. .read = vb2_fop_read,
  1227. .mmap = vb2_fop_mmap,
  1228. .poll = vb2_fop_poll,
  1229. };
  1230. static const struct v4l2_ioctl_ops dev_ioctl_ops = {
  1231. .vidioc_querycap = vidioc_querycap,
  1232. .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
  1233. .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
  1234. .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
  1235. .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
  1236. .vidioc_enum_input = vidioc_enum_input,
  1237. .vidioc_g_input = vidioc_g_input,
  1238. .vidioc_s_input = vidioc_s_input,
  1239. .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
  1240. .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
  1241. .vidioc_g_parm = vidioc_g_parm,
  1242. .vidioc_s_parm = vidioc_s_parm,
  1243. .vidioc_enum_framesizes = vidioc_enum_framesizes,
  1244. .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
  1245. .vidioc_reqbufs = vb2_ioctl_reqbufs,
  1246. .vidioc_create_bufs = vb2_ioctl_create_bufs,
  1247. .vidioc_querybuf = vb2_ioctl_querybuf,
  1248. .vidioc_qbuf = vb2_ioctl_qbuf,
  1249. .vidioc_dqbuf = vb2_ioctl_dqbuf,
  1250. .vidioc_expbuf = vb2_ioctl_expbuf,
  1251. .vidioc_streamon = vb2_ioctl_streamon,
  1252. .vidioc_streamoff = vb2_ioctl_streamoff,
  1253. #ifdef CONFIG_VIDEO_ADV_DEBUG
  1254. .vidioc_g_chip_info = vidioc_g_chip_info,
  1255. .vidioc_g_register = vidioc_g_register,
  1256. .vidioc_s_register = vidioc_s_register,
  1257. #endif
  1258. .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
  1259. .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
  1260. };
  1261. static const struct video_device gspca_template = {
  1262. .name = "gspca main driver",
  1263. .fops = &dev_fops,
  1264. .ioctl_ops = &dev_ioctl_ops,
  1265. .release = video_device_release_empty, /* We use v4l2_dev.release */
  1266. };
  1267. /*
  1268. * probe and create a new gspca device
  1269. *
  1270. * This function must be called by the sub-driver when it is
  1271. * called for probing a new device.
  1272. */
  1273. int gspca_dev_probe2(struct usb_interface *intf,
  1274. const struct usb_device_id *id,
  1275. const struct sd_desc *sd_desc,
  1276. int dev_size,
  1277. struct module *module)
  1278. {
  1279. struct gspca_dev *gspca_dev;
  1280. struct usb_device *dev = interface_to_usbdev(intf);
  1281. struct vb2_queue *q;
  1282. int ret;
  1283. pr_info("%s-" GSPCA_VERSION " probing %04x:%04x\n",
  1284. sd_desc->name, id->idVendor, id->idProduct);
  1285. /* create the device */
  1286. if (dev_size < sizeof *gspca_dev)
  1287. dev_size = sizeof *gspca_dev;
  1288. gspca_dev = kzalloc(dev_size, GFP_KERNEL);
  1289. if (!gspca_dev) {
  1290. pr_err("couldn't kzalloc gspca struct\n");
  1291. return -ENOMEM;
  1292. }
  1293. gspca_dev->usb_buf = kzalloc(USB_BUF_SZ, GFP_KERNEL);
  1294. if (!gspca_dev->usb_buf) {
  1295. pr_err("out of memory\n");
  1296. ret = -ENOMEM;
  1297. goto out;
  1298. }
  1299. gspca_dev->dev = dev;
  1300. gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber;
  1301. gspca_dev->xfer_ep = -1;
  1302. /* check if any audio device */
  1303. if (dev->actconfig->desc.bNumInterfaces != 1) {
  1304. int i;
  1305. struct usb_interface *intf2;
  1306. for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
  1307. intf2 = dev->actconfig->interface[i];
  1308. if (intf2 != NULL
  1309. && intf2->altsetting != NULL
  1310. && intf2->altsetting->desc.bInterfaceClass ==
  1311. USB_CLASS_AUDIO) {
  1312. gspca_dev->audio = 1;
  1313. break;
  1314. }
  1315. }
  1316. }
  1317. gspca_dev->v4l2_dev.release = gspca_release;
  1318. ret = v4l2_device_register(&intf->dev, &gspca_dev->v4l2_dev);
  1319. if (ret)
  1320. goto out;
  1321. gspca_dev->present = true;
  1322. gspca_dev->sd_desc = sd_desc;
  1323. gspca_dev->empty_packet = -1; /* don't check the empty packets */
  1324. gspca_dev->vdev = gspca_template;
  1325. gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev;
  1326. video_set_drvdata(&gspca_dev->vdev, gspca_dev);
  1327. gspca_dev->module = module;
  1328. mutex_init(&gspca_dev->usb_lock);
  1329. gspca_dev->vdev.lock = &gspca_dev->usb_lock;
  1330. init_waitqueue_head(&gspca_dev->wq);
  1331. /* Initialize the vb2 queue */
  1332. q = &gspca_dev->queue;
  1333. q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1334. q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
  1335. q->drv_priv = gspca_dev;
  1336. q->buf_struct_size = sizeof(struct gspca_buffer);
  1337. q->ops = &gspca_qops;
  1338. q->mem_ops = &vb2_vmalloc_memops;
  1339. q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
  1340. q->min_buffers_needed = 2;
  1341. q->lock = &gspca_dev->usb_lock;
  1342. ret = vb2_queue_init(q);
  1343. if (ret)
  1344. goto out;
  1345. gspca_dev->vdev.queue = q;
  1346. INIT_LIST_HEAD(&gspca_dev->buf_list);
  1347. spin_lock_init(&gspca_dev->qlock);
  1348. /* configure the subdriver and initialize the USB device */
  1349. ret = sd_desc->config(gspca_dev, id);
  1350. if (ret < 0)
  1351. goto out;
  1352. ret = sd_desc->init(gspca_dev);
  1353. if (ret < 0)
  1354. goto out;
  1355. if (sd_desc->init_controls)
  1356. ret = sd_desc->init_controls(gspca_dev);
  1357. if (ret < 0)
  1358. goto out;
  1359. gspca_set_default_mode(gspca_dev);
  1360. ret = gspca_input_connect(gspca_dev);
  1361. if (ret)
  1362. goto out;
  1363. #ifdef CONFIG_VIDEO_ADV_DEBUG
  1364. if (!gspca_dev->sd_desc->get_register)
  1365. v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_G_REGISTER);
  1366. if (!gspca_dev->sd_desc->set_register)
  1367. v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_S_REGISTER);
  1368. #endif
  1369. if (!gspca_dev->sd_desc->get_jcomp)
  1370. v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_G_JPEGCOMP);
  1371. if (!gspca_dev->sd_desc->set_jcomp)
  1372. v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_S_JPEGCOMP);
  1373. /* init video stuff */
  1374. ret = video_register_device(&gspca_dev->vdev,
  1375. VFL_TYPE_GRABBER,
  1376. -1);
  1377. if (ret < 0) {
  1378. pr_err("video_register_device err %d\n", ret);
  1379. goto out;
  1380. }
  1381. usb_set_intfdata(intf, gspca_dev);
  1382. gspca_dbg(gspca_dev, D_PROBE, "%s created\n",
  1383. video_device_node_name(&gspca_dev->vdev));
  1384. gspca_input_create_urb(gspca_dev);
  1385. return 0;
  1386. out:
  1387. #if IS_ENABLED(CONFIG_INPUT)
  1388. if (gspca_dev->input_dev)
  1389. input_unregister_device(gspca_dev->input_dev);
  1390. #endif
  1391. v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler);
  1392. v4l2_device_unregister(&gspca_dev->v4l2_dev);
  1393. if (sd_desc->probe_error)
  1394. sd_desc->probe_error(gspca_dev);
  1395. kfree(gspca_dev->usb_buf);
  1396. kfree(gspca_dev);
  1397. return ret;
  1398. }
  1399. EXPORT_SYMBOL(gspca_dev_probe2);
  1400. /* same function as the previous one, but check the interface */
  1401. int gspca_dev_probe(struct usb_interface *intf,
  1402. const struct usb_device_id *id,
  1403. const struct sd_desc *sd_desc,
  1404. int dev_size,
  1405. struct module *module)
  1406. {
  1407. struct usb_device *dev = interface_to_usbdev(intf);
  1408. /* we don't handle multi-config cameras */
  1409. if (dev->descriptor.bNumConfigurations != 1) {
  1410. pr_err("%04x:%04x too many config\n",
  1411. id->idVendor, id->idProduct);
  1412. return -ENODEV;
  1413. }
  1414. /* the USB video interface must be the first one */
  1415. if (dev->actconfig->desc.bNumInterfaces != 1
  1416. && intf->cur_altsetting->desc.bInterfaceNumber != 0)
  1417. return -ENODEV;
  1418. return gspca_dev_probe2(intf, id, sd_desc, dev_size, module);
  1419. }
  1420. EXPORT_SYMBOL(gspca_dev_probe);
  1421. /*
  1422. * USB disconnection
  1423. *
  1424. * This function must be called by the sub-driver
  1425. * when the device disconnects, after the specific resources are freed.
  1426. */
  1427. void gspca_disconnect(struct usb_interface *intf)
  1428. {
  1429. struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
  1430. #if IS_ENABLED(CONFIG_INPUT)
  1431. struct input_dev *input_dev;
  1432. #endif
  1433. gspca_dbg(gspca_dev, D_PROBE, "%s disconnect\n",
  1434. video_device_node_name(&gspca_dev->vdev));
  1435. mutex_lock(&gspca_dev->usb_lock);
  1436. gspca_dev->present = false;
  1437. destroy_urbs(gspca_dev);
  1438. gspca_input_destroy_urb(gspca_dev);
  1439. vb2_queue_error(&gspca_dev->queue);
  1440. #if IS_ENABLED(CONFIG_INPUT)
  1441. input_dev = gspca_dev->input_dev;
  1442. if (input_dev) {
  1443. gspca_dev->input_dev = NULL;
  1444. input_unregister_device(input_dev);
  1445. }
  1446. #endif
  1447. v4l2_device_disconnect(&gspca_dev->v4l2_dev);
  1448. video_unregister_device(&gspca_dev->vdev);
  1449. mutex_unlock(&gspca_dev->usb_lock);
  1450. /* (this will call gspca_release() immediately or on last close) */
  1451. v4l2_device_put(&gspca_dev->v4l2_dev);
  1452. }
  1453. EXPORT_SYMBOL(gspca_disconnect);
  1454. #ifdef CONFIG_PM
  1455. int gspca_suspend(struct usb_interface *intf, pm_message_t message)
  1456. {
  1457. struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
  1458. gspca_input_destroy_urb(gspca_dev);
  1459. if (!vb2_start_streaming_called(&gspca_dev->queue))
  1460. return 0;
  1461. mutex_lock(&gspca_dev->usb_lock);
  1462. gspca_dev->frozen = 1; /* avoid urb error messages */
  1463. gspca_dev->usb_err = 0;
  1464. if (gspca_dev->sd_desc->stopN)
  1465. gspca_dev->sd_desc->stopN(gspca_dev);
  1466. destroy_urbs(gspca_dev);
  1467. gspca_set_alt0(gspca_dev);
  1468. if (gspca_dev->sd_desc->stop0)
  1469. gspca_dev->sd_desc->stop0(gspca_dev);
  1470. mutex_unlock(&gspca_dev->usb_lock);
  1471. return 0;
  1472. }
  1473. EXPORT_SYMBOL(gspca_suspend);
  1474. int gspca_resume(struct usb_interface *intf)
  1475. {
  1476. struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
  1477. int streaming, ret = 0;
  1478. mutex_lock(&gspca_dev->usb_lock);
  1479. gspca_dev->frozen = 0;
  1480. gspca_dev->usb_err = 0;
  1481. gspca_dev->sd_desc->init(gspca_dev);
  1482. /*
  1483. * Most subdrivers send all ctrl values on sd_start and thus
  1484. * only write to the device registers on s_ctrl when streaming ->
  1485. * Clear streaming to avoid setting all ctrls twice.
  1486. */
  1487. streaming = vb2_start_streaming_called(&gspca_dev->queue);
  1488. if (streaming)
  1489. ret = gspca_init_transfer(gspca_dev);
  1490. else
  1491. gspca_input_create_urb(gspca_dev);
  1492. mutex_unlock(&gspca_dev->usb_lock);
  1493. return ret;
  1494. }
  1495. EXPORT_SYMBOL(gspca_resume);
  1496. #endif
  1497. /* -- module insert / remove -- */
  1498. static int __init gspca_init(void)
  1499. {
  1500. pr_info("v" GSPCA_VERSION " registered\n");
  1501. return 0;
  1502. }
  1503. static void __exit gspca_exit(void)
  1504. {
  1505. }
  1506. module_init(gspca_init);
  1507. module_exit(gspca_exit);
  1508. module_param_named(debug, gspca_debug, int, 0644);
  1509. MODULE_PARM_DESC(debug,
  1510. "1:probe 2:config 3:stream 4:frame 5:packet 6:usbi 7:usbo");