gspca.c 60 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501
  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. * You should have received a copy of the GNU General Public License
  20. * along with this program; if not, write to the Free Software Foundation,
  21. * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. */
  23. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24. #define MODULE_NAME "gspca"
  25. #include <linux/init.h>
  26. #include <linux/fs.h>
  27. #include <linux/vmalloc.h>
  28. #include <linux/sched.h>
  29. #include <linux/slab.h>
  30. #include <linux/mm.h>
  31. #include <linux/string.h>
  32. #include <linux/pagemap.h>
  33. #include <linux/io.h>
  34. #include <asm/page.h>
  35. #include <linux/uaccess.h>
  36. #include <linux/ktime.h>
  37. #include <media/v4l2-ioctl.h>
  38. #include "gspca.h"
  39. #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
  40. #include <linux/input.h>
  41. #include <linux/usb/input.h>
  42. #endif
  43. /* global values */
  44. #define DEF_NURBS 3 /* default number of URBs */
  45. #if DEF_NURBS > MAX_NURBS
  46. #error "DEF_NURBS too big"
  47. #endif
  48. #define DRIVER_VERSION_NUMBER "2.13.0"
  49. MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
  50. MODULE_DESCRIPTION("GSPCA USB Camera Driver");
  51. MODULE_LICENSE("GPL");
  52. MODULE_VERSION(DRIVER_VERSION_NUMBER);
  53. #ifdef GSPCA_DEBUG
  54. int gspca_debug = D_ERR | D_PROBE;
  55. EXPORT_SYMBOL(gspca_debug);
  56. static void PDEBUG_MODE(char *txt, __u32 pixfmt, int w, int h)
  57. {
  58. if ((pixfmt >> 24) >= '0' && (pixfmt >> 24) <= 'z') {
  59. PDEBUG(D_CONF|D_STREAM, "%s %c%c%c%c %dx%d",
  60. txt,
  61. pixfmt & 0xff,
  62. (pixfmt >> 8) & 0xff,
  63. (pixfmt >> 16) & 0xff,
  64. pixfmt >> 24,
  65. w, h);
  66. } else {
  67. PDEBUG(D_CONF|D_STREAM, "%s 0x%08x %dx%d",
  68. txt,
  69. pixfmt,
  70. w, h);
  71. }
  72. }
  73. #else
  74. #define PDEBUG_MODE(txt, pixfmt, w, h)
  75. #endif
  76. /* specific memory types - !! should be different from V4L2_MEMORY_xxx */
  77. #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */
  78. #define GSPCA_MEMORY_READ 7
  79. #define BUF_ALL_FLAGS (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE)
  80. /*
  81. * VMA operations.
  82. */
  83. static void gspca_vm_open(struct vm_area_struct *vma)
  84. {
  85. struct gspca_frame *frame = vma->vm_private_data;
  86. frame->vma_use_count++;
  87. frame->v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED;
  88. }
  89. static void gspca_vm_close(struct vm_area_struct *vma)
  90. {
  91. struct gspca_frame *frame = vma->vm_private_data;
  92. if (--frame->vma_use_count <= 0)
  93. frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_MAPPED;
  94. }
  95. static const struct vm_operations_struct gspca_vm_ops = {
  96. .open = gspca_vm_open,
  97. .close = gspca_vm_close,
  98. };
  99. /*
  100. * Input and interrupt endpoint handling functions
  101. */
  102. #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
  103. static void int_irq(struct urb *urb)
  104. {
  105. struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
  106. int ret;
  107. ret = urb->status;
  108. switch (ret) {
  109. case 0:
  110. if (gspca_dev->sd_desc->int_pkt_scan(gspca_dev,
  111. urb->transfer_buffer, urb->actual_length) < 0) {
  112. PDEBUG(D_ERR, "Unknown packet received");
  113. }
  114. break;
  115. case -ENOENT:
  116. case -ECONNRESET:
  117. case -ENODEV:
  118. case -ESHUTDOWN:
  119. /* Stop is requested either by software or hardware is gone,
  120. * keep the ret value non-zero and don't resubmit later.
  121. */
  122. break;
  123. default:
  124. PDEBUG(D_ERR, "URB error %i, resubmitting", urb->status);
  125. urb->status = 0;
  126. ret = 0;
  127. }
  128. if (ret == 0) {
  129. ret = usb_submit_urb(urb, GFP_ATOMIC);
  130. if (ret < 0)
  131. pr_err("Resubmit URB failed with error %i\n", ret);
  132. }
  133. }
  134. static int gspca_input_connect(struct gspca_dev *dev)
  135. {
  136. struct input_dev *input_dev;
  137. int err = 0;
  138. dev->input_dev = NULL;
  139. if (dev->sd_desc->int_pkt_scan || dev->sd_desc->other_input) {
  140. input_dev = input_allocate_device();
  141. if (!input_dev)
  142. return -ENOMEM;
  143. usb_make_path(dev->dev, dev->phys, sizeof(dev->phys));
  144. strlcat(dev->phys, "/input0", sizeof(dev->phys));
  145. input_dev->name = dev->sd_desc->name;
  146. input_dev->phys = dev->phys;
  147. usb_to_input_id(dev->dev, &input_dev->id);
  148. input_dev->evbit[0] = BIT_MASK(EV_KEY);
  149. input_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
  150. input_dev->dev.parent = &dev->dev->dev;
  151. err = input_register_device(input_dev);
  152. if (err) {
  153. pr_err("Input device registration failed with error %i\n",
  154. err);
  155. input_dev->dev.parent = NULL;
  156. input_free_device(input_dev);
  157. } else {
  158. dev->input_dev = input_dev;
  159. }
  160. }
  161. return err;
  162. }
  163. static int alloc_and_submit_int_urb(struct gspca_dev *gspca_dev,
  164. struct usb_endpoint_descriptor *ep)
  165. {
  166. unsigned int buffer_len;
  167. int interval;
  168. struct urb *urb;
  169. struct usb_device *dev;
  170. void *buffer = NULL;
  171. int ret = -EINVAL;
  172. buffer_len = le16_to_cpu(ep->wMaxPacketSize);
  173. interval = ep->bInterval;
  174. PDEBUG(D_CONF, "found int in endpoint: 0x%x, "
  175. "buffer_len=%u, interval=%u",
  176. ep->bEndpointAddress, buffer_len, interval);
  177. dev = gspca_dev->dev;
  178. urb = usb_alloc_urb(0, GFP_KERNEL);
  179. if (!urb) {
  180. ret = -ENOMEM;
  181. goto error;
  182. }
  183. buffer = usb_alloc_coherent(dev, buffer_len,
  184. GFP_KERNEL, &urb->transfer_dma);
  185. if (!buffer) {
  186. ret = -ENOMEM;
  187. goto error_buffer;
  188. }
  189. usb_fill_int_urb(urb, dev,
  190. usb_rcvintpipe(dev, ep->bEndpointAddress),
  191. buffer, buffer_len,
  192. int_irq, (void *)gspca_dev, interval);
  193. urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  194. ret = usb_submit_urb(urb, GFP_KERNEL);
  195. if (ret < 0) {
  196. PDEBUG(D_ERR, "submit int URB failed with error %i", ret);
  197. goto error_submit;
  198. }
  199. gspca_dev->int_urb = urb;
  200. return ret;
  201. error_submit:
  202. usb_free_coherent(dev,
  203. urb->transfer_buffer_length,
  204. urb->transfer_buffer,
  205. urb->transfer_dma);
  206. error_buffer:
  207. usb_free_urb(urb);
  208. error:
  209. return ret;
  210. }
  211. static void gspca_input_create_urb(struct gspca_dev *gspca_dev)
  212. {
  213. struct usb_interface *intf;
  214. struct usb_host_interface *intf_desc;
  215. struct usb_endpoint_descriptor *ep;
  216. int i;
  217. if (gspca_dev->sd_desc->int_pkt_scan) {
  218. intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
  219. intf_desc = intf->cur_altsetting;
  220. for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
  221. ep = &intf_desc->endpoint[i].desc;
  222. if (usb_endpoint_dir_in(ep) &&
  223. usb_endpoint_xfer_int(ep)) {
  224. alloc_and_submit_int_urb(gspca_dev, ep);
  225. break;
  226. }
  227. }
  228. }
  229. }
  230. static void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
  231. {
  232. struct urb *urb;
  233. urb = gspca_dev->int_urb;
  234. if (urb) {
  235. gspca_dev->int_urb = NULL;
  236. usb_kill_urb(urb);
  237. usb_free_coherent(gspca_dev->dev,
  238. urb->transfer_buffer_length,
  239. urb->transfer_buffer,
  240. urb->transfer_dma);
  241. usb_free_urb(urb);
  242. }
  243. }
  244. #else
  245. static inline void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
  246. {
  247. }
  248. static inline void gspca_input_create_urb(struct gspca_dev *gspca_dev)
  249. {
  250. }
  251. static inline int gspca_input_connect(struct gspca_dev *dev)
  252. {
  253. return 0;
  254. }
  255. #endif
  256. /*
  257. * fill a video frame from an URB and resubmit
  258. */
  259. static void fill_frame(struct gspca_dev *gspca_dev,
  260. struct urb *urb)
  261. {
  262. u8 *data; /* address of data in the iso message */
  263. int i, len, st;
  264. cam_pkt_op pkt_scan;
  265. if (urb->status != 0) {
  266. if (urb->status == -ESHUTDOWN)
  267. return; /* disconnection */
  268. #ifdef CONFIG_PM
  269. if (gspca_dev->frozen)
  270. return;
  271. #endif
  272. PDEBUG(D_ERR|D_PACK, "urb status: %d", urb->status);
  273. urb->status = 0;
  274. goto resubmit;
  275. }
  276. pkt_scan = gspca_dev->sd_desc->pkt_scan;
  277. for (i = 0; i < urb->number_of_packets; i++) {
  278. len = urb->iso_frame_desc[i].actual_length;
  279. /* check the packet status and length */
  280. st = urb->iso_frame_desc[i].status;
  281. if (st) {
  282. pr_err("ISOC data error: [%d] len=%d, status=%d\n",
  283. i, len, st);
  284. gspca_dev->last_packet_type = DISCARD_PACKET;
  285. continue;
  286. }
  287. if (len == 0) {
  288. if (gspca_dev->empty_packet == 0)
  289. gspca_dev->empty_packet = 1;
  290. continue;
  291. }
  292. /* let the packet be analyzed by the subdriver */
  293. PDEBUG(D_PACK, "packet [%d] o:%d l:%d",
  294. i, urb->iso_frame_desc[i].offset, len);
  295. data = (u8 *) urb->transfer_buffer
  296. + urb->iso_frame_desc[i].offset;
  297. pkt_scan(gspca_dev, data, len);
  298. }
  299. resubmit:
  300. /* resubmit the URB */
  301. st = usb_submit_urb(urb, GFP_ATOMIC);
  302. if (st < 0)
  303. pr_err("usb_submit_urb() ret %d\n", st);
  304. }
  305. /*
  306. * ISOC message interrupt from the USB device
  307. *
  308. * Analyse each packet and call the subdriver for copy to the frame buffer.
  309. */
  310. static void isoc_irq(struct urb *urb)
  311. {
  312. struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
  313. PDEBUG(D_PACK, "isoc irq");
  314. if (!gspca_dev->streaming)
  315. return;
  316. fill_frame(gspca_dev, urb);
  317. }
  318. /*
  319. * bulk message interrupt from the USB device
  320. */
  321. static void bulk_irq(struct urb *urb)
  322. {
  323. struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
  324. int st;
  325. PDEBUG(D_PACK, "bulk irq");
  326. if (!gspca_dev->streaming)
  327. return;
  328. switch (urb->status) {
  329. case 0:
  330. break;
  331. case -ESHUTDOWN:
  332. return; /* disconnection */
  333. default:
  334. #ifdef CONFIG_PM
  335. if (gspca_dev->frozen)
  336. return;
  337. #endif
  338. PDEBUG(D_ERR|D_PACK, "urb status: %d", urb->status);
  339. urb->status = 0;
  340. goto resubmit;
  341. }
  342. PDEBUG(D_PACK, "packet l:%d", urb->actual_length);
  343. gspca_dev->sd_desc->pkt_scan(gspca_dev,
  344. urb->transfer_buffer,
  345. urb->actual_length);
  346. resubmit:
  347. /* resubmit the URB */
  348. if (gspca_dev->cam.bulk_nurbs != 0) {
  349. st = usb_submit_urb(urb, GFP_ATOMIC);
  350. if (st < 0)
  351. pr_err("usb_submit_urb() ret %d\n", st);
  352. }
  353. }
  354. /*
  355. * add data to the current frame
  356. *
  357. * This function is called by the subdrivers at interrupt level.
  358. *
  359. * To build a frame, these ones must add
  360. * - one FIRST_PACKET
  361. * - 0 or many INTER_PACKETs
  362. * - one LAST_PACKET
  363. * DISCARD_PACKET invalidates the whole frame.
  364. */
  365. void gspca_frame_add(struct gspca_dev *gspca_dev,
  366. enum gspca_packet_type packet_type,
  367. const u8 *data,
  368. int len)
  369. {
  370. struct gspca_frame *frame;
  371. int i, j;
  372. PDEBUG(D_PACK, "add t:%d l:%d", packet_type, len);
  373. if (packet_type == FIRST_PACKET) {
  374. i = atomic_read(&gspca_dev->fr_i);
  375. /* if there are no queued buffer, discard the whole frame */
  376. if (i == atomic_read(&gspca_dev->fr_q)) {
  377. gspca_dev->last_packet_type = DISCARD_PACKET;
  378. gspca_dev->sequence++;
  379. return;
  380. }
  381. j = gspca_dev->fr_queue[i];
  382. frame = &gspca_dev->frame[j];
  383. frame->v4l2_buf.timestamp = ktime_to_timeval(ktime_get());
  384. frame->v4l2_buf.sequence = gspca_dev->sequence++;
  385. gspca_dev->image = frame->data;
  386. gspca_dev->image_len = 0;
  387. } else {
  388. switch (gspca_dev->last_packet_type) {
  389. case DISCARD_PACKET:
  390. if (packet_type == LAST_PACKET) {
  391. gspca_dev->last_packet_type = packet_type;
  392. gspca_dev->image = NULL;
  393. gspca_dev->image_len = 0;
  394. }
  395. return;
  396. case LAST_PACKET:
  397. return;
  398. }
  399. }
  400. /* append the packet to the frame buffer */
  401. if (len > 0) {
  402. if (gspca_dev->image_len + len > gspca_dev->frsz) {
  403. PDEBUG(D_ERR|D_PACK, "frame overflow %d > %d",
  404. gspca_dev->image_len + len,
  405. gspca_dev->frsz);
  406. packet_type = DISCARD_PACKET;
  407. } else {
  408. /* !! image is NULL only when last pkt is LAST or DISCARD
  409. if (gspca_dev->image == NULL) {
  410. pr_err("gspca_frame_add() image == NULL\n");
  411. return;
  412. }
  413. */
  414. memcpy(gspca_dev->image + gspca_dev->image_len,
  415. data, len);
  416. gspca_dev->image_len += len;
  417. }
  418. }
  419. gspca_dev->last_packet_type = packet_type;
  420. /* if last packet, invalidate packet concatenation until
  421. * next first packet, wake up the application and advance
  422. * in the queue */
  423. if (packet_type == LAST_PACKET) {
  424. i = atomic_read(&gspca_dev->fr_i);
  425. j = gspca_dev->fr_queue[i];
  426. frame = &gspca_dev->frame[j];
  427. frame->v4l2_buf.bytesused = gspca_dev->image_len;
  428. frame->v4l2_buf.flags = (frame->v4l2_buf.flags
  429. | V4L2_BUF_FLAG_DONE)
  430. & ~V4L2_BUF_FLAG_QUEUED;
  431. i = (i + 1) % GSPCA_MAX_FRAMES;
  432. atomic_set(&gspca_dev->fr_i, i);
  433. wake_up_interruptible(&gspca_dev->wq); /* event = new frame */
  434. PDEBUG(D_FRAM, "frame complete len:%d",
  435. frame->v4l2_buf.bytesused);
  436. gspca_dev->image = NULL;
  437. gspca_dev->image_len = 0;
  438. }
  439. }
  440. EXPORT_SYMBOL(gspca_frame_add);
  441. static int gspca_is_compressed(__u32 format)
  442. {
  443. switch (format) {
  444. case V4L2_PIX_FMT_MJPEG:
  445. case V4L2_PIX_FMT_JPEG:
  446. case V4L2_PIX_FMT_SPCA561:
  447. case V4L2_PIX_FMT_PAC207:
  448. case V4L2_PIX_FMT_MR97310A:
  449. return 1;
  450. }
  451. return 0;
  452. }
  453. static int frame_alloc(struct gspca_dev *gspca_dev, struct file *file,
  454. enum v4l2_memory memory, unsigned int count)
  455. {
  456. struct gspca_frame *frame;
  457. unsigned int frsz;
  458. int i;
  459. i = gspca_dev->curr_mode;
  460. frsz = gspca_dev->cam.cam_mode[i].sizeimage;
  461. PDEBUG(D_STREAM, "frame alloc frsz: %d", frsz);
  462. frsz = PAGE_ALIGN(frsz);
  463. if (count >= GSPCA_MAX_FRAMES)
  464. count = GSPCA_MAX_FRAMES - 1;
  465. gspca_dev->frbuf = vmalloc_32(frsz * count);
  466. if (!gspca_dev->frbuf) {
  467. pr_err("frame alloc failed\n");
  468. return -ENOMEM;
  469. }
  470. gspca_dev->capt_file = file;
  471. gspca_dev->memory = memory;
  472. gspca_dev->frsz = frsz;
  473. gspca_dev->nframes = count;
  474. for (i = 0; i < count; i++) {
  475. frame = &gspca_dev->frame[i];
  476. frame->v4l2_buf.index = i;
  477. frame->v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  478. frame->v4l2_buf.flags = 0;
  479. frame->v4l2_buf.field = V4L2_FIELD_NONE;
  480. frame->v4l2_buf.length = frsz;
  481. frame->v4l2_buf.memory = memory;
  482. frame->v4l2_buf.sequence = 0;
  483. frame->data = gspca_dev->frbuf + i * frsz;
  484. frame->v4l2_buf.m.offset = i * frsz;
  485. }
  486. atomic_set(&gspca_dev->fr_q, 0);
  487. atomic_set(&gspca_dev->fr_i, 0);
  488. gspca_dev->fr_o = 0;
  489. return 0;
  490. }
  491. static void frame_free(struct gspca_dev *gspca_dev)
  492. {
  493. int i;
  494. PDEBUG(D_STREAM, "frame free");
  495. if (gspca_dev->frbuf != NULL) {
  496. vfree(gspca_dev->frbuf);
  497. gspca_dev->frbuf = NULL;
  498. for (i = 0; i < gspca_dev->nframes; i++)
  499. gspca_dev->frame[i].data = NULL;
  500. }
  501. gspca_dev->nframes = 0;
  502. gspca_dev->frsz = 0;
  503. gspca_dev->capt_file = NULL;
  504. gspca_dev->memory = GSPCA_MEMORY_NO;
  505. }
  506. static void destroy_urbs(struct gspca_dev *gspca_dev)
  507. {
  508. struct urb *urb;
  509. unsigned int i;
  510. PDEBUG(D_STREAM, "kill transfer");
  511. for (i = 0; i < MAX_NURBS; i++) {
  512. urb = gspca_dev->urb[i];
  513. if (urb == NULL)
  514. break;
  515. gspca_dev->urb[i] = NULL;
  516. usb_kill_urb(urb);
  517. if (urb->transfer_buffer != NULL)
  518. usb_free_coherent(gspca_dev->dev,
  519. urb->transfer_buffer_length,
  520. urb->transfer_buffer,
  521. urb->transfer_dma);
  522. usb_free_urb(urb);
  523. }
  524. }
  525. static int gspca_set_alt0(struct gspca_dev *gspca_dev)
  526. {
  527. int ret;
  528. if (gspca_dev->alt == 0)
  529. return 0;
  530. ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0);
  531. if (ret < 0)
  532. pr_err("set alt 0 err %d\n", ret);
  533. return ret;
  534. }
  535. /* Note: both the queue and the usb locks should be held when calling this */
  536. static void gspca_stream_off(struct gspca_dev *gspca_dev)
  537. {
  538. gspca_dev->streaming = 0;
  539. if (gspca_dev->present) {
  540. if (gspca_dev->sd_desc->stopN)
  541. gspca_dev->sd_desc->stopN(gspca_dev);
  542. destroy_urbs(gspca_dev);
  543. gspca_input_destroy_urb(gspca_dev);
  544. gspca_set_alt0(gspca_dev);
  545. gspca_input_create_urb(gspca_dev);
  546. }
  547. /* always call stop0 to free the subdriver's resources */
  548. if (gspca_dev->sd_desc->stop0)
  549. gspca_dev->sd_desc->stop0(gspca_dev);
  550. PDEBUG(D_STREAM, "stream off OK");
  551. }
  552. /*
  553. * look for an input transfer endpoint in an alternate setting
  554. */
  555. static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt,
  556. int xfer)
  557. {
  558. struct usb_host_endpoint *ep;
  559. int i, attr;
  560. for (i = 0; i < alt->desc.bNumEndpoints; i++) {
  561. ep = &alt->endpoint[i];
  562. attr = ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
  563. if (attr == xfer
  564. && ep->desc.wMaxPacketSize != 0
  565. && usb_endpoint_dir_in(&ep->desc))
  566. return ep;
  567. }
  568. return NULL;
  569. }
  570. /*
  571. * look for an input (isoc or bulk) endpoint
  572. *
  573. * The endpoint is defined by the subdriver.
  574. * Use only the first isoc (some Zoran - 0x0572:0x0001 - have two such ep).
  575. * This routine may be called many times when the bandwidth is too small
  576. * (the bandwidth is checked on urb submit).
  577. */
  578. static struct usb_host_endpoint *get_ep(struct gspca_dev *gspca_dev)
  579. {
  580. struct usb_interface *intf;
  581. struct usb_host_endpoint *ep;
  582. int xfer, i, ret;
  583. intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
  584. ep = NULL;
  585. xfer = gspca_dev->cam.bulk ? USB_ENDPOINT_XFER_BULK
  586. : USB_ENDPOINT_XFER_ISOC;
  587. i = gspca_dev->alt; /* previous alt setting */
  588. if (gspca_dev->cam.reverse_alts) {
  589. while (++i < gspca_dev->nbalt) {
  590. ep = alt_xfer(&intf->altsetting[i], xfer);
  591. if (ep)
  592. break;
  593. }
  594. } else {
  595. while (--i >= 0) {
  596. ep = alt_xfer(&intf->altsetting[i], xfer);
  597. if (ep)
  598. break;
  599. }
  600. }
  601. if (ep == NULL) {
  602. pr_err("no transfer endpoint found\n");
  603. return NULL;
  604. }
  605. PDEBUG(D_STREAM, "use alt %d ep 0x%02x",
  606. i, ep->desc.bEndpointAddress);
  607. gspca_dev->alt = i; /* memorize the current alt setting */
  608. if (gspca_dev->nbalt > 1) {
  609. ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, i);
  610. if (ret < 0) {
  611. pr_err("set alt %d err %d\n", i, ret);
  612. ep = NULL;
  613. }
  614. }
  615. return ep;
  616. }
  617. /*
  618. * create the URBs for image transfer
  619. */
  620. static int create_urbs(struct gspca_dev *gspca_dev,
  621. struct usb_host_endpoint *ep)
  622. {
  623. struct urb *urb;
  624. int n, nurbs, i, psize, npkt, bsize;
  625. /* calculate the packet size and the number of packets */
  626. psize = le16_to_cpu(ep->desc.wMaxPacketSize);
  627. if (!gspca_dev->cam.bulk) { /* isoc */
  628. /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
  629. if (gspca_dev->pkt_size == 0)
  630. psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
  631. else
  632. psize = gspca_dev->pkt_size;
  633. npkt = gspca_dev->cam.npkt;
  634. if (npkt == 0)
  635. npkt = 32; /* default value */
  636. bsize = psize * npkt;
  637. PDEBUG(D_STREAM,
  638. "isoc %d pkts size %d = bsize:%d",
  639. npkt, psize, bsize);
  640. nurbs = DEF_NURBS;
  641. } else { /* bulk */
  642. npkt = 0;
  643. bsize = gspca_dev->cam.bulk_size;
  644. if (bsize == 0)
  645. bsize = psize;
  646. PDEBUG(D_STREAM, "bulk bsize:%d", bsize);
  647. if (gspca_dev->cam.bulk_nurbs != 0)
  648. nurbs = gspca_dev->cam.bulk_nurbs;
  649. else
  650. nurbs = 1;
  651. }
  652. for (n = 0; n < nurbs; n++) {
  653. urb = usb_alloc_urb(npkt, GFP_KERNEL);
  654. if (!urb) {
  655. pr_err("usb_alloc_urb failed\n");
  656. return -ENOMEM;
  657. }
  658. gspca_dev->urb[n] = urb;
  659. urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev,
  660. bsize,
  661. GFP_KERNEL,
  662. &urb->transfer_dma);
  663. if (urb->transfer_buffer == NULL) {
  664. pr_err("usb_alloc_coherent failed\n");
  665. return -ENOMEM;
  666. }
  667. urb->dev = gspca_dev->dev;
  668. urb->context = gspca_dev;
  669. urb->transfer_buffer_length = bsize;
  670. if (npkt != 0) { /* ISOC */
  671. urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
  672. ep->desc.bEndpointAddress);
  673. urb->transfer_flags = URB_ISO_ASAP
  674. | URB_NO_TRANSFER_DMA_MAP;
  675. urb->interval = ep->desc.bInterval;
  676. urb->complete = isoc_irq;
  677. urb->number_of_packets = npkt;
  678. for (i = 0; i < npkt; i++) {
  679. urb->iso_frame_desc[i].length = psize;
  680. urb->iso_frame_desc[i].offset = psize * i;
  681. }
  682. } else { /* bulk */
  683. urb->pipe = usb_rcvbulkpipe(gspca_dev->dev,
  684. ep->desc.bEndpointAddress);
  685. urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
  686. urb->complete = bulk_irq;
  687. }
  688. }
  689. return 0;
  690. }
  691. /*
  692. * start the USB transfer
  693. */
  694. static int gspca_init_transfer(struct gspca_dev *gspca_dev)
  695. {
  696. struct usb_host_endpoint *ep;
  697. struct urb *urb;
  698. int n, ret;
  699. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  700. return -ERESTARTSYS;
  701. if (!gspca_dev->present) {
  702. ret = -ENODEV;
  703. goto unlock;
  704. }
  705. /* reset the streaming variables */
  706. gspca_dev->image = NULL;
  707. gspca_dev->image_len = 0;
  708. gspca_dev->last_packet_type = DISCARD_PACKET;
  709. gspca_dev->sequence = 0;
  710. gspca_dev->usb_err = 0;
  711. /* set the higher alternate setting and
  712. * loop until urb submit succeeds */
  713. if (gspca_dev->cam.reverse_alts)
  714. gspca_dev->alt = 0;
  715. else
  716. gspca_dev->alt = gspca_dev->nbalt;
  717. if (gspca_dev->sd_desc->isoc_init) {
  718. ret = gspca_dev->sd_desc->isoc_init(gspca_dev);
  719. if (ret < 0)
  720. goto unlock;
  721. }
  722. gspca_input_destroy_urb(gspca_dev);
  723. ep = get_ep(gspca_dev);
  724. if (ep == NULL) {
  725. ret = -EIO;
  726. goto out;
  727. }
  728. for (;;) {
  729. if (!gspca_dev->cam.no_urb_create) {
  730. PDEBUG(D_STREAM, "init transfer alt %d",
  731. gspca_dev->alt);
  732. ret = create_urbs(gspca_dev, ep);
  733. if (ret < 0) {
  734. destroy_urbs(gspca_dev);
  735. goto out;
  736. }
  737. }
  738. /* clear the bulk endpoint */
  739. if (gspca_dev->cam.bulk)
  740. usb_clear_halt(gspca_dev->dev,
  741. gspca_dev->urb[0]->pipe);
  742. /* start the cam */
  743. ret = gspca_dev->sd_desc->start(gspca_dev);
  744. if (ret < 0) {
  745. destroy_urbs(gspca_dev);
  746. goto out;
  747. }
  748. gspca_dev->streaming = 1;
  749. /* some bulk transfers are started by the subdriver */
  750. if (gspca_dev->cam.bulk && gspca_dev->cam.bulk_nurbs == 0)
  751. break;
  752. /* submit the URBs */
  753. for (n = 0; n < MAX_NURBS; n++) {
  754. urb = gspca_dev->urb[n];
  755. if (urb == NULL)
  756. break;
  757. ret = usb_submit_urb(urb, GFP_KERNEL);
  758. if (ret < 0)
  759. break;
  760. }
  761. if (ret >= 0)
  762. break;
  763. gspca_stream_off(gspca_dev);
  764. if (ret != -ENOSPC) {
  765. pr_err("usb_submit_urb alt %d err %d\n",
  766. gspca_dev->alt, ret);
  767. goto out;
  768. }
  769. /* the bandwidth is not wide enough
  770. * negotiate or try a lower alternate setting */
  771. PDEBUG(D_ERR|D_STREAM,
  772. "bandwidth not wide enough - trying again");
  773. msleep(20); /* wait for kill complete */
  774. if (gspca_dev->sd_desc->isoc_nego) {
  775. ret = gspca_dev->sd_desc->isoc_nego(gspca_dev);
  776. if (ret < 0)
  777. goto out;
  778. } else {
  779. ep = get_ep(gspca_dev);
  780. if (ep == NULL) {
  781. ret = -EIO;
  782. goto out;
  783. }
  784. }
  785. }
  786. out:
  787. gspca_input_create_urb(gspca_dev);
  788. unlock:
  789. mutex_unlock(&gspca_dev->usb_lock);
  790. return ret;
  791. }
  792. static void gspca_set_default_mode(struct gspca_dev *gspca_dev)
  793. {
  794. struct gspca_ctrl *ctrl;
  795. int i;
  796. i = gspca_dev->cam.nmodes - 1; /* take the highest mode */
  797. gspca_dev->curr_mode = i;
  798. gspca_dev->width = gspca_dev->cam.cam_mode[i].width;
  799. gspca_dev->height = gspca_dev->cam.cam_mode[i].height;
  800. gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i].pixelformat;
  801. /* set the current control values to their default values
  802. * which may have changed in sd_init() */
  803. ctrl = gspca_dev->cam.ctrls;
  804. if (ctrl != NULL) {
  805. for (i = 0;
  806. i < gspca_dev->sd_desc->nctrls;
  807. i++, ctrl++)
  808. ctrl->val = ctrl->def;
  809. }
  810. }
  811. static int wxh_to_mode(struct gspca_dev *gspca_dev,
  812. int width, int height)
  813. {
  814. int i;
  815. for (i = gspca_dev->cam.nmodes; --i > 0; ) {
  816. if (width >= gspca_dev->cam.cam_mode[i].width
  817. && height >= gspca_dev->cam.cam_mode[i].height)
  818. break;
  819. }
  820. return i;
  821. }
  822. /*
  823. * search a mode with the right pixel format
  824. */
  825. static int gspca_get_mode(struct gspca_dev *gspca_dev,
  826. int mode,
  827. int pixfmt)
  828. {
  829. int modeU, modeD;
  830. modeU = modeD = mode;
  831. while ((modeU < gspca_dev->cam.nmodes) || modeD >= 0) {
  832. if (--modeD >= 0) {
  833. if (gspca_dev->cam.cam_mode[modeD].pixelformat
  834. == pixfmt)
  835. return modeD;
  836. }
  837. if (++modeU < gspca_dev->cam.nmodes) {
  838. if (gspca_dev->cam.cam_mode[modeU].pixelformat
  839. == pixfmt)
  840. return modeU;
  841. }
  842. }
  843. return -EINVAL;
  844. }
  845. #ifdef CONFIG_VIDEO_ADV_DEBUG
  846. static int vidioc_g_register(struct file *file, void *priv,
  847. struct v4l2_dbg_register *reg)
  848. {
  849. int ret;
  850. struct gspca_dev *gspca_dev = priv;
  851. if (!gspca_dev->sd_desc->get_chip_ident)
  852. return -EINVAL;
  853. if (!gspca_dev->sd_desc->get_register)
  854. return -EINVAL;
  855. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  856. return -ERESTARTSYS;
  857. gspca_dev->usb_err = 0;
  858. if (gspca_dev->present)
  859. ret = gspca_dev->sd_desc->get_register(gspca_dev, reg);
  860. else
  861. ret = -ENODEV;
  862. mutex_unlock(&gspca_dev->usb_lock);
  863. return ret;
  864. }
  865. static int vidioc_s_register(struct file *file, void *priv,
  866. struct v4l2_dbg_register *reg)
  867. {
  868. int ret;
  869. struct gspca_dev *gspca_dev = priv;
  870. if (!gspca_dev->sd_desc->get_chip_ident)
  871. return -EINVAL;
  872. if (!gspca_dev->sd_desc->set_register)
  873. return -EINVAL;
  874. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  875. return -ERESTARTSYS;
  876. gspca_dev->usb_err = 0;
  877. if (gspca_dev->present)
  878. ret = gspca_dev->sd_desc->set_register(gspca_dev, reg);
  879. else
  880. ret = -ENODEV;
  881. mutex_unlock(&gspca_dev->usb_lock);
  882. return ret;
  883. }
  884. #endif
  885. static int vidioc_g_chip_ident(struct file *file, void *priv,
  886. struct v4l2_dbg_chip_ident *chip)
  887. {
  888. int ret;
  889. struct gspca_dev *gspca_dev = priv;
  890. if (!gspca_dev->sd_desc->get_chip_ident)
  891. return -EINVAL;
  892. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  893. return -ERESTARTSYS;
  894. gspca_dev->usb_err = 0;
  895. if (gspca_dev->present)
  896. ret = gspca_dev->sd_desc->get_chip_ident(gspca_dev, chip);
  897. else
  898. ret = -ENODEV;
  899. mutex_unlock(&gspca_dev->usb_lock);
  900. return ret;
  901. }
  902. static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
  903. struct v4l2_fmtdesc *fmtdesc)
  904. {
  905. struct gspca_dev *gspca_dev = priv;
  906. int i, j, index;
  907. __u32 fmt_tb[8];
  908. /* give an index to each format */
  909. index = 0;
  910. j = 0;
  911. for (i = gspca_dev->cam.nmodes; --i >= 0; ) {
  912. fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixelformat;
  913. j = 0;
  914. for (;;) {
  915. if (fmt_tb[j] == fmt_tb[index])
  916. break;
  917. j++;
  918. }
  919. if (j == index) {
  920. if (fmtdesc->index == index)
  921. break; /* new format */
  922. index++;
  923. if (index >= ARRAY_SIZE(fmt_tb))
  924. return -EINVAL;
  925. }
  926. }
  927. if (i < 0)
  928. return -EINVAL; /* no more format */
  929. fmtdesc->pixelformat = fmt_tb[index];
  930. if (gspca_is_compressed(fmt_tb[index]))
  931. fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED;
  932. fmtdesc->description[0] = fmtdesc->pixelformat & 0xff;
  933. fmtdesc->description[1] = (fmtdesc->pixelformat >> 8) & 0xff;
  934. fmtdesc->description[2] = (fmtdesc->pixelformat >> 16) & 0xff;
  935. fmtdesc->description[3] = fmtdesc->pixelformat >> 24;
  936. fmtdesc->description[4] = '\0';
  937. return 0;
  938. }
  939. static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
  940. struct v4l2_format *fmt)
  941. {
  942. struct gspca_dev *gspca_dev = priv;
  943. int mode;
  944. mode = gspca_dev->curr_mode;
  945. memcpy(&fmt->fmt.pix, &gspca_dev->cam.cam_mode[mode],
  946. sizeof fmt->fmt.pix);
  947. return 0;
  948. }
  949. static int try_fmt_vid_cap(struct gspca_dev *gspca_dev,
  950. struct v4l2_format *fmt)
  951. {
  952. int w, h, mode, mode2;
  953. w = fmt->fmt.pix.width;
  954. h = fmt->fmt.pix.height;
  955. #ifdef GSPCA_DEBUG
  956. if (gspca_debug & D_CONF)
  957. PDEBUG_MODE("try fmt cap", fmt->fmt.pix.pixelformat, w, h);
  958. #endif
  959. /* search the closest mode for width and height */
  960. mode = wxh_to_mode(gspca_dev, w, h);
  961. /* OK if right palette */
  962. if (gspca_dev->cam.cam_mode[mode].pixelformat
  963. != fmt->fmt.pix.pixelformat) {
  964. /* else, search the closest mode with the same pixel format */
  965. mode2 = gspca_get_mode(gspca_dev, mode,
  966. fmt->fmt.pix.pixelformat);
  967. if (mode2 >= 0)
  968. mode = mode2;
  969. /* else
  970. ; * no chance, return this mode */
  971. }
  972. memcpy(&fmt->fmt.pix, &gspca_dev->cam.cam_mode[mode],
  973. sizeof fmt->fmt.pix);
  974. return mode; /* used when s_fmt */
  975. }
  976. static int vidioc_try_fmt_vid_cap(struct file *file,
  977. void *priv,
  978. struct v4l2_format *fmt)
  979. {
  980. struct gspca_dev *gspca_dev = priv;
  981. int ret;
  982. ret = try_fmt_vid_cap(gspca_dev, fmt);
  983. if (ret < 0)
  984. return ret;
  985. return 0;
  986. }
  987. static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
  988. struct v4l2_format *fmt)
  989. {
  990. struct gspca_dev *gspca_dev = priv;
  991. int ret;
  992. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  993. return -ERESTARTSYS;
  994. ret = try_fmt_vid_cap(gspca_dev, fmt);
  995. if (ret < 0)
  996. goto out;
  997. if (gspca_dev->nframes != 0
  998. && fmt->fmt.pix.sizeimage > gspca_dev->frsz) {
  999. ret = -EINVAL;
  1000. goto out;
  1001. }
  1002. if (ret == gspca_dev->curr_mode) {
  1003. ret = 0;
  1004. goto out; /* same mode */
  1005. }
  1006. if (gspca_dev->streaming) {
  1007. ret = -EBUSY;
  1008. goto out;
  1009. }
  1010. gspca_dev->width = fmt->fmt.pix.width;
  1011. gspca_dev->height = fmt->fmt.pix.height;
  1012. gspca_dev->pixfmt = fmt->fmt.pix.pixelformat;
  1013. gspca_dev->curr_mode = ret;
  1014. ret = 0;
  1015. out:
  1016. mutex_unlock(&gspca_dev->queue_lock);
  1017. return ret;
  1018. }
  1019. static int vidioc_enum_framesizes(struct file *file, void *priv,
  1020. struct v4l2_frmsizeenum *fsize)
  1021. {
  1022. struct gspca_dev *gspca_dev = priv;
  1023. int i;
  1024. __u32 index = 0;
  1025. for (i = 0; i < gspca_dev->cam.nmodes; i++) {
  1026. if (fsize->pixel_format !=
  1027. gspca_dev->cam.cam_mode[i].pixelformat)
  1028. continue;
  1029. if (fsize->index == index) {
  1030. fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
  1031. fsize->discrete.width =
  1032. gspca_dev->cam.cam_mode[i].width;
  1033. fsize->discrete.height =
  1034. gspca_dev->cam.cam_mode[i].height;
  1035. return 0;
  1036. }
  1037. index++;
  1038. }
  1039. return -EINVAL;
  1040. }
  1041. static int vidioc_enum_frameintervals(struct file *filp, void *priv,
  1042. struct v4l2_frmivalenum *fival)
  1043. {
  1044. struct gspca_dev *gspca_dev = priv;
  1045. int mode = wxh_to_mode(gspca_dev, fival->width, fival->height);
  1046. __u32 i;
  1047. if (gspca_dev->cam.mode_framerates == NULL ||
  1048. gspca_dev->cam.mode_framerates[mode].nrates == 0)
  1049. return -EINVAL;
  1050. if (fival->pixel_format !=
  1051. gspca_dev->cam.cam_mode[mode].pixelformat)
  1052. return -EINVAL;
  1053. for (i = 0; i < gspca_dev->cam.mode_framerates[mode].nrates; i++) {
  1054. if (fival->index == i) {
  1055. fival->type = V4L2_FRMSIZE_TYPE_DISCRETE;
  1056. fival->discrete.numerator = 1;
  1057. fival->discrete.denominator =
  1058. gspca_dev->cam.mode_framerates[mode].rates[i];
  1059. return 0;
  1060. }
  1061. }
  1062. return -EINVAL;
  1063. }
  1064. static void gspca_release(struct video_device *vfd)
  1065. {
  1066. struct gspca_dev *gspca_dev = container_of(vfd, struct gspca_dev, vdev);
  1067. PDEBUG(D_PROBE, "%s released",
  1068. video_device_node_name(&gspca_dev->vdev));
  1069. kfree(gspca_dev->usb_buf);
  1070. kfree(gspca_dev);
  1071. }
  1072. static int dev_open(struct file *file)
  1073. {
  1074. struct gspca_dev *gspca_dev;
  1075. PDEBUG(D_STREAM, "[%s] open", current->comm);
  1076. gspca_dev = (struct gspca_dev *) video_devdata(file);
  1077. if (!gspca_dev->present)
  1078. return -ENODEV;
  1079. /* protect the subdriver against rmmod */
  1080. if (!try_module_get(gspca_dev->module))
  1081. return -ENODEV;
  1082. file->private_data = gspca_dev;
  1083. #ifdef GSPCA_DEBUG
  1084. /* activate the v4l2 debug */
  1085. if (gspca_debug & D_V4L2)
  1086. gspca_dev->vdev.debug |= V4L2_DEBUG_IOCTL
  1087. | V4L2_DEBUG_IOCTL_ARG;
  1088. else
  1089. gspca_dev->vdev.debug &= ~(V4L2_DEBUG_IOCTL
  1090. | V4L2_DEBUG_IOCTL_ARG);
  1091. #endif
  1092. return 0;
  1093. }
  1094. static int dev_close(struct file *file)
  1095. {
  1096. struct gspca_dev *gspca_dev = file->private_data;
  1097. PDEBUG(D_STREAM, "[%s] close", current->comm);
  1098. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1099. return -ERESTARTSYS;
  1100. /* if the file did the capture, free the streaming resources */
  1101. if (gspca_dev->capt_file == file) {
  1102. if (gspca_dev->streaming) {
  1103. mutex_lock(&gspca_dev->usb_lock);
  1104. gspca_dev->usb_err = 0;
  1105. gspca_stream_off(gspca_dev);
  1106. mutex_unlock(&gspca_dev->usb_lock);
  1107. }
  1108. frame_free(gspca_dev);
  1109. }
  1110. file->private_data = NULL;
  1111. module_put(gspca_dev->module);
  1112. mutex_unlock(&gspca_dev->queue_lock);
  1113. PDEBUG(D_STREAM, "close done");
  1114. return 0;
  1115. }
  1116. static int vidioc_querycap(struct file *file, void *priv,
  1117. struct v4l2_capability *cap)
  1118. {
  1119. struct gspca_dev *gspca_dev = priv;
  1120. int ret;
  1121. /* protect the access to the usb device */
  1122. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  1123. return -ERESTARTSYS;
  1124. if (!gspca_dev->present) {
  1125. ret = -ENODEV;
  1126. goto out;
  1127. }
  1128. strlcpy((char *) cap->driver, gspca_dev->sd_desc->name,
  1129. sizeof cap->driver);
  1130. if (gspca_dev->dev->product != NULL) {
  1131. strlcpy((char *) cap->card, gspca_dev->dev->product,
  1132. sizeof cap->card);
  1133. } else {
  1134. snprintf((char *) cap->card, sizeof cap->card,
  1135. "USB Camera (%04x:%04x)",
  1136. le16_to_cpu(gspca_dev->dev->descriptor.idVendor),
  1137. le16_to_cpu(gspca_dev->dev->descriptor.idProduct));
  1138. }
  1139. usb_make_path(gspca_dev->dev, (char *) cap->bus_info,
  1140. sizeof(cap->bus_info));
  1141. cap->capabilities = V4L2_CAP_VIDEO_CAPTURE
  1142. | V4L2_CAP_STREAMING
  1143. | V4L2_CAP_READWRITE;
  1144. ret = 0;
  1145. out:
  1146. mutex_unlock(&gspca_dev->usb_lock);
  1147. return ret;
  1148. }
  1149. static int get_ctrl(struct gspca_dev *gspca_dev,
  1150. int id)
  1151. {
  1152. const struct ctrl *ctrls;
  1153. int i;
  1154. for (i = 0, ctrls = gspca_dev->sd_desc->ctrls;
  1155. i < gspca_dev->sd_desc->nctrls;
  1156. i++, ctrls++) {
  1157. if (gspca_dev->ctrl_dis & (1 << i))
  1158. continue;
  1159. if (id == ctrls->qctrl.id)
  1160. return i;
  1161. }
  1162. return -1;
  1163. }
  1164. static int vidioc_queryctrl(struct file *file, void *priv,
  1165. struct v4l2_queryctrl *q_ctrl)
  1166. {
  1167. struct gspca_dev *gspca_dev = priv;
  1168. const struct ctrl *ctrls;
  1169. struct gspca_ctrl *gspca_ctrl;
  1170. int i, idx;
  1171. u32 id;
  1172. id = q_ctrl->id;
  1173. if (id & V4L2_CTRL_FLAG_NEXT_CTRL) {
  1174. id &= V4L2_CTRL_ID_MASK;
  1175. id++;
  1176. idx = -1;
  1177. for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
  1178. if (gspca_dev->ctrl_dis & (1 << i))
  1179. continue;
  1180. if (gspca_dev->sd_desc->ctrls[i].qctrl.id < id)
  1181. continue;
  1182. if (idx >= 0
  1183. && gspca_dev->sd_desc->ctrls[i].qctrl.id
  1184. > gspca_dev->sd_desc->ctrls[idx].qctrl.id)
  1185. continue;
  1186. idx = i;
  1187. }
  1188. } else {
  1189. idx = get_ctrl(gspca_dev, id);
  1190. }
  1191. if (idx < 0)
  1192. return -EINVAL;
  1193. ctrls = &gspca_dev->sd_desc->ctrls[idx];
  1194. memcpy(q_ctrl, &ctrls->qctrl, sizeof *q_ctrl);
  1195. if (gspca_dev->cam.ctrls != NULL) {
  1196. gspca_ctrl = &gspca_dev->cam.ctrls[idx];
  1197. q_ctrl->default_value = gspca_ctrl->def;
  1198. q_ctrl->minimum = gspca_ctrl->min;
  1199. q_ctrl->maximum = gspca_ctrl->max;
  1200. }
  1201. if (gspca_dev->ctrl_inac & (1 << idx))
  1202. q_ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
  1203. return 0;
  1204. }
  1205. static int vidioc_s_ctrl(struct file *file, void *priv,
  1206. struct v4l2_control *ctrl)
  1207. {
  1208. struct gspca_dev *gspca_dev = priv;
  1209. const struct ctrl *ctrls;
  1210. struct gspca_ctrl *gspca_ctrl;
  1211. int idx, ret;
  1212. idx = get_ctrl(gspca_dev, ctrl->id);
  1213. if (idx < 0)
  1214. return -EINVAL;
  1215. if (gspca_dev->ctrl_inac & (1 << idx))
  1216. return -EINVAL;
  1217. ctrls = &gspca_dev->sd_desc->ctrls[idx];
  1218. if (gspca_dev->cam.ctrls != NULL) {
  1219. gspca_ctrl = &gspca_dev->cam.ctrls[idx];
  1220. if (ctrl->value < gspca_ctrl->min
  1221. || ctrl->value > gspca_ctrl->max)
  1222. return -ERANGE;
  1223. } else {
  1224. gspca_ctrl = NULL;
  1225. if (ctrl->value < ctrls->qctrl.minimum
  1226. || ctrl->value > ctrls->qctrl.maximum)
  1227. return -ERANGE;
  1228. }
  1229. PDEBUG(D_CONF, "set ctrl [%08x] = %d", ctrl->id, ctrl->value);
  1230. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  1231. return -ERESTARTSYS;
  1232. if (!gspca_dev->present) {
  1233. ret = -ENODEV;
  1234. goto out;
  1235. }
  1236. gspca_dev->usb_err = 0;
  1237. if (ctrls->set != NULL) {
  1238. ret = ctrls->set(gspca_dev, ctrl->value);
  1239. goto out;
  1240. }
  1241. if (gspca_ctrl != NULL) {
  1242. gspca_ctrl->val = ctrl->value;
  1243. if (ctrls->set_control != NULL
  1244. && gspca_dev->streaming)
  1245. ctrls->set_control(gspca_dev);
  1246. }
  1247. ret = gspca_dev->usb_err;
  1248. out:
  1249. mutex_unlock(&gspca_dev->usb_lock);
  1250. return ret;
  1251. }
  1252. static int vidioc_g_ctrl(struct file *file, void *priv,
  1253. struct v4l2_control *ctrl)
  1254. {
  1255. struct gspca_dev *gspca_dev = priv;
  1256. const struct ctrl *ctrls;
  1257. int idx, ret;
  1258. idx = get_ctrl(gspca_dev, ctrl->id);
  1259. if (idx < 0)
  1260. return -EINVAL;
  1261. ctrls = &gspca_dev->sd_desc->ctrls[idx];
  1262. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  1263. return -ERESTARTSYS;
  1264. if (!gspca_dev->present) {
  1265. ret = -ENODEV;
  1266. goto out;
  1267. }
  1268. gspca_dev->usb_err = 0;
  1269. if (ctrls->get != NULL) {
  1270. ret = ctrls->get(gspca_dev, &ctrl->value);
  1271. goto out;
  1272. }
  1273. if (gspca_dev->cam.ctrls != NULL)
  1274. ctrl->value = gspca_dev->cam.ctrls[idx].val;
  1275. ret = 0;
  1276. out:
  1277. mutex_unlock(&gspca_dev->usb_lock);
  1278. return ret;
  1279. }
  1280. static int vidioc_querymenu(struct file *file, void *priv,
  1281. struct v4l2_querymenu *qmenu)
  1282. {
  1283. struct gspca_dev *gspca_dev = priv;
  1284. if (!gspca_dev->sd_desc->querymenu)
  1285. return -EINVAL;
  1286. return gspca_dev->sd_desc->querymenu(gspca_dev, qmenu);
  1287. }
  1288. static int vidioc_enum_input(struct file *file, void *priv,
  1289. struct v4l2_input *input)
  1290. {
  1291. struct gspca_dev *gspca_dev = priv;
  1292. if (input->index != 0)
  1293. return -EINVAL;
  1294. input->type = V4L2_INPUT_TYPE_CAMERA;
  1295. input->status = gspca_dev->cam.input_flags;
  1296. strlcpy(input->name, gspca_dev->sd_desc->name,
  1297. sizeof input->name);
  1298. return 0;
  1299. }
  1300. static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
  1301. {
  1302. *i = 0;
  1303. return 0;
  1304. }
  1305. static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
  1306. {
  1307. if (i > 0)
  1308. return -EINVAL;
  1309. return (0);
  1310. }
  1311. static int vidioc_reqbufs(struct file *file, void *priv,
  1312. struct v4l2_requestbuffers *rb)
  1313. {
  1314. struct gspca_dev *gspca_dev = priv;
  1315. int i, ret = 0, streaming;
  1316. i = rb->memory; /* (avoid compilation warning) */
  1317. switch (i) {
  1318. case GSPCA_MEMORY_READ: /* (internal call) */
  1319. case V4L2_MEMORY_MMAP:
  1320. case V4L2_MEMORY_USERPTR:
  1321. break;
  1322. default:
  1323. return -EINVAL;
  1324. }
  1325. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1326. return -ERESTARTSYS;
  1327. if (gspca_dev->memory != GSPCA_MEMORY_NO
  1328. && gspca_dev->memory != GSPCA_MEMORY_READ
  1329. && gspca_dev->memory != rb->memory) {
  1330. ret = -EBUSY;
  1331. goto out;
  1332. }
  1333. /* only one file may do the capture */
  1334. if (gspca_dev->capt_file != NULL
  1335. && gspca_dev->capt_file != file) {
  1336. ret = -EBUSY;
  1337. goto out;
  1338. }
  1339. /* if allocated, the buffers must not be mapped */
  1340. for (i = 0; i < gspca_dev->nframes; i++) {
  1341. if (gspca_dev->frame[i].vma_use_count) {
  1342. ret = -EBUSY;
  1343. goto out;
  1344. }
  1345. }
  1346. /* stop streaming */
  1347. streaming = gspca_dev->streaming;
  1348. if (streaming) {
  1349. mutex_lock(&gspca_dev->usb_lock);
  1350. gspca_dev->usb_err = 0;
  1351. gspca_stream_off(gspca_dev);
  1352. mutex_unlock(&gspca_dev->usb_lock);
  1353. /* Don't restart the stream when switching from read
  1354. * to mmap mode */
  1355. if (gspca_dev->memory == GSPCA_MEMORY_READ)
  1356. streaming = 0;
  1357. }
  1358. /* free the previous allocated buffers, if any */
  1359. if (gspca_dev->nframes != 0)
  1360. frame_free(gspca_dev);
  1361. if (rb->count == 0) /* unrequest */
  1362. goto out;
  1363. ret = frame_alloc(gspca_dev, file, rb->memory, rb->count);
  1364. if (ret == 0) {
  1365. rb->count = gspca_dev->nframes;
  1366. if (streaming)
  1367. ret = gspca_init_transfer(gspca_dev);
  1368. }
  1369. out:
  1370. mutex_unlock(&gspca_dev->queue_lock);
  1371. PDEBUG(D_STREAM, "reqbufs st:%d c:%d", ret, rb->count);
  1372. return ret;
  1373. }
  1374. static int vidioc_querybuf(struct file *file, void *priv,
  1375. struct v4l2_buffer *v4l2_buf)
  1376. {
  1377. struct gspca_dev *gspca_dev = priv;
  1378. struct gspca_frame *frame;
  1379. if (v4l2_buf->index < 0
  1380. || v4l2_buf->index >= gspca_dev->nframes)
  1381. return -EINVAL;
  1382. frame = &gspca_dev->frame[v4l2_buf->index];
  1383. memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
  1384. return 0;
  1385. }
  1386. static int vidioc_streamon(struct file *file, void *priv,
  1387. enum v4l2_buf_type buf_type)
  1388. {
  1389. struct gspca_dev *gspca_dev = priv;
  1390. int ret;
  1391. if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  1392. return -EINVAL;
  1393. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1394. return -ERESTARTSYS;
  1395. /* check the capture file */
  1396. if (gspca_dev->capt_file != file) {
  1397. ret = -EBUSY;
  1398. goto out;
  1399. }
  1400. if (gspca_dev->nframes == 0
  1401. || !(gspca_dev->frame[0].v4l2_buf.flags & V4L2_BUF_FLAG_QUEUED)) {
  1402. ret = -EINVAL;
  1403. goto out;
  1404. }
  1405. if (!gspca_dev->streaming) {
  1406. ret = gspca_init_transfer(gspca_dev);
  1407. if (ret < 0)
  1408. goto out;
  1409. }
  1410. #ifdef GSPCA_DEBUG
  1411. if (gspca_debug & D_STREAM) {
  1412. PDEBUG_MODE("stream on OK",
  1413. gspca_dev->pixfmt,
  1414. gspca_dev->width,
  1415. gspca_dev->height);
  1416. }
  1417. #endif
  1418. ret = 0;
  1419. out:
  1420. mutex_unlock(&gspca_dev->queue_lock);
  1421. return ret;
  1422. }
  1423. static int vidioc_streamoff(struct file *file, void *priv,
  1424. enum v4l2_buf_type buf_type)
  1425. {
  1426. struct gspca_dev *gspca_dev = priv;
  1427. int ret;
  1428. if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  1429. return -EINVAL;
  1430. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1431. return -ERESTARTSYS;
  1432. if (!gspca_dev->streaming) {
  1433. ret = 0;
  1434. goto out;
  1435. }
  1436. /* check the capture file */
  1437. if (gspca_dev->capt_file != file) {
  1438. ret = -EBUSY;
  1439. goto out;
  1440. }
  1441. /* stop streaming */
  1442. if (mutex_lock_interruptible(&gspca_dev->usb_lock)) {
  1443. ret = -ERESTARTSYS;
  1444. goto out;
  1445. }
  1446. gspca_dev->usb_err = 0;
  1447. gspca_stream_off(gspca_dev);
  1448. mutex_unlock(&gspca_dev->usb_lock);
  1449. /* In case another thread is waiting in dqbuf */
  1450. wake_up_interruptible(&gspca_dev->wq);
  1451. /* empty the transfer queues */
  1452. atomic_set(&gspca_dev->fr_q, 0);
  1453. atomic_set(&gspca_dev->fr_i, 0);
  1454. gspca_dev->fr_o = 0;
  1455. ret = 0;
  1456. out:
  1457. mutex_unlock(&gspca_dev->queue_lock);
  1458. return ret;
  1459. }
  1460. static int vidioc_g_jpegcomp(struct file *file, void *priv,
  1461. struct v4l2_jpegcompression *jpegcomp)
  1462. {
  1463. struct gspca_dev *gspca_dev = priv;
  1464. int ret;
  1465. if (!gspca_dev->sd_desc->get_jcomp)
  1466. return -EINVAL;
  1467. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  1468. return -ERESTARTSYS;
  1469. gspca_dev->usb_err = 0;
  1470. if (gspca_dev->present)
  1471. ret = gspca_dev->sd_desc->get_jcomp(gspca_dev, jpegcomp);
  1472. else
  1473. ret = -ENODEV;
  1474. mutex_unlock(&gspca_dev->usb_lock);
  1475. return ret;
  1476. }
  1477. static int vidioc_s_jpegcomp(struct file *file, void *priv,
  1478. struct v4l2_jpegcompression *jpegcomp)
  1479. {
  1480. struct gspca_dev *gspca_dev = priv;
  1481. int ret;
  1482. if (!gspca_dev->sd_desc->set_jcomp)
  1483. return -EINVAL;
  1484. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  1485. return -ERESTARTSYS;
  1486. gspca_dev->usb_err = 0;
  1487. if (gspca_dev->present)
  1488. ret = gspca_dev->sd_desc->set_jcomp(gspca_dev, jpegcomp);
  1489. else
  1490. ret = -ENODEV;
  1491. mutex_unlock(&gspca_dev->usb_lock);
  1492. return ret;
  1493. }
  1494. static int vidioc_g_parm(struct file *filp, void *priv,
  1495. struct v4l2_streamparm *parm)
  1496. {
  1497. struct gspca_dev *gspca_dev = priv;
  1498. parm->parm.capture.readbuffers = gspca_dev->nbufread;
  1499. if (gspca_dev->sd_desc->get_streamparm) {
  1500. int ret;
  1501. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  1502. return -ERESTARTSYS;
  1503. if (gspca_dev->present) {
  1504. gspca_dev->usb_err = 0;
  1505. gspca_dev->sd_desc->get_streamparm(gspca_dev, parm);
  1506. ret = gspca_dev->usb_err;
  1507. } else {
  1508. ret = -ENODEV;
  1509. }
  1510. mutex_unlock(&gspca_dev->usb_lock);
  1511. return ret;
  1512. }
  1513. return 0;
  1514. }
  1515. static int vidioc_s_parm(struct file *filp, void *priv,
  1516. struct v4l2_streamparm *parm)
  1517. {
  1518. struct gspca_dev *gspca_dev = priv;
  1519. int n;
  1520. n = parm->parm.capture.readbuffers;
  1521. if (n == 0 || n >= GSPCA_MAX_FRAMES)
  1522. parm->parm.capture.readbuffers = gspca_dev->nbufread;
  1523. else
  1524. gspca_dev->nbufread = n;
  1525. if (gspca_dev->sd_desc->set_streamparm) {
  1526. int ret;
  1527. if (mutex_lock_interruptible(&gspca_dev->usb_lock))
  1528. return -ERESTARTSYS;
  1529. if (gspca_dev->present) {
  1530. gspca_dev->usb_err = 0;
  1531. gspca_dev->sd_desc->set_streamparm(gspca_dev, parm);
  1532. ret = gspca_dev->usb_err;
  1533. } else {
  1534. ret = -ENODEV;
  1535. }
  1536. mutex_unlock(&gspca_dev->usb_lock);
  1537. return ret;
  1538. }
  1539. return 0;
  1540. }
  1541. static int dev_mmap(struct file *file, struct vm_area_struct *vma)
  1542. {
  1543. struct gspca_dev *gspca_dev = file->private_data;
  1544. struct gspca_frame *frame;
  1545. struct page *page;
  1546. unsigned long addr, start, size;
  1547. int i, ret;
  1548. start = vma->vm_start;
  1549. size = vma->vm_end - vma->vm_start;
  1550. PDEBUG(D_STREAM, "mmap start:%08x size:%d", (int) start, (int) size);
  1551. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1552. return -ERESTARTSYS;
  1553. if (!gspca_dev->present) {
  1554. ret = -ENODEV;
  1555. goto out;
  1556. }
  1557. if (gspca_dev->capt_file != file) {
  1558. ret = -EINVAL;
  1559. goto out;
  1560. }
  1561. frame = NULL;
  1562. for (i = 0; i < gspca_dev->nframes; ++i) {
  1563. if (gspca_dev->frame[i].v4l2_buf.memory != V4L2_MEMORY_MMAP) {
  1564. PDEBUG(D_STREAM, "mmap bad memory type");
  1565. break;
  1566. }
  1567. if ((gspca_dev->frame[i].v4l2_buf.m.offset >> PAGE_SHIFT)
  1568. == vma->vm_pgoff) {
  1569. frame = &gspca_dev->frame[i];
  1570. break;
  1571. }
  1572. }
  1573. if (frame == NULL) {
  1574. PDEBUG(D_STREAM, "mmap no frame buffer found");
  1575. ret = -EINVAL;
  1576. goto out;
  1577. }
  1578. if (size != frame->v4l2_buf.length) {
  1579. PDEBUG(D_STREAM, "mmap bad size");
  1580. ret = -EINVAL;
  1581. goto out;
  1582. }
  1583. /*
  1584. * - VM_IO marks the area as being a mmaped region for I/O to a
  1585. * device. It also prevents the region from being core dumped.
  1586. */
  1587. vma->vm_flags |= VM_IO;
  1588. addr = (unsigned long) frame->data;
  1589. while (size > 0) {
  1590. page = vmalloc_to_page((void *) addr);
  1591. ret = vm_insert_page(vma, start, page);
  1592. if (ret < 0)
  1593. goto out;
  1594. start += PAGE_SIZE;
  1595. addr += PAGE_SIZE;
  1596. size -= PAGE_SIZE;
  1597. }
  1598. vma->vm_ops = &gspca_vm_ops;
  1599. vma->vm_private_data = frame;
  1600. gspca_vm_open(vma);
  1601. ret = 0;
  1602. out:
  1603. mutex_unlock(&gspca_dev->queue_lock);
  1604. return ret;
  1605. }
  1606. static int frame_ready_nolock(struct gspca_dev *gspca_dev, struct file *file,
  1607. enum v4l2_memory memory)
  1608. {
  1609. if (!gspca_dev->present)
  1610. return -ENODEV;
  1611. if (gspca_dev->capt_file != file || gspca_dev->memory != memory ||
  1612. !gspca_dev->streaming)
  1613. return -EINVAL;
  1614. /* check if a frame is ready */
  1615. return gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i);
  1616. }
  1617. static int frame_ready(struct gspca_dev *gspca_dev, struct file *file,
  1618. enum v4l2_memory memory)
  1619. {
  1620. int ret;
  1621. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1622. return -ERESTARTSYS;
  1623. ret = frame_ready_nolock(gspca_dev, file, memory);
  1624. mutex_unlock(&gspca_dev->queue_lock);
  1625. return ret;
  1626. }
  1627. /*
  1628. * dequeue a video buffer
  1629. *
  1630. * If nonblock_ing is false, block until a buffer is available.
  1631. */
  1632. static int vidioc_dqbuf(struct file *file, void *priv,
  1633. struct v4l2_buffer *v4l2_buf)
  1634. {
  1635. struct gspca_dev *gspca_dev = priv;
  1636. struct gspca_frame *frame;
  1637. int i, j, ret;
  1638. PDEBUG(D_FRAM, "dqbuf");
  1639. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1640. return -ERESTARTSYS;
  1641. for (;;) {
  1642. ret = frame_ready_nolock(gspca_dev, file, v4l2_buf->memory);
  1643. if (ret < 0)
  1644. goto out;
  1645. if (ret > 0)
  1646. break;
  1647. mutex_unlock(&gspca_dev->queue_lock);
  1648. if (file->f_flags & O_NONBLOCK)
  1649. return -EAGAIN;
  1650. /* wait till a frame is ready */
  1651. ret = wait_event_interruptible_timeout(gspca_dev->wq,
  1652. frame_ready(gspca_dev, file, v4l2_buf->memory),
  1653. msecs_to_jiffies(3000));
  1654. if (ret < 0)
  1655. return ret;
  1656. if (ret == 0)
  1657. return -EIO;
  1658. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1659. return -ERESTARTSYS;
  1660. }
  1661. i = gspca_dev->fr_o;
  1662. j = gspca_dev->fr_queue[i];
  1663. frame = &gspca_dev->frame[j];
  1664. gspca_dev->fr_o = (i + 1) % GSPCA_MAX_FRAMES;
  1665. if (gspca_dev->sd_desc->dq_callback) {
  1666. mutex_lock(&gspca_dev->usb_lock);
  1667. gspca_dev->usb_err = 0;
  1668. if (gspca_dev->present)
  1669. gspca_dev->sd_desc->dq_callback(gspca_dev);
  1670. mutex_unlock(&gspca_dev->usb_lock);
  1671. }
  1672. frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE;
  1673. memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
  1674. PDEBUG(D_FRAM, "dqbuf %d", j);
  1675. ret = 0;
  1676. if (gspca_dev->memory == V4L2_MEMORY_USERPTR) {
  1677. if (copy_to_user((__u8 __user *) frame->v4l2_buf.m.userptr,
  1678. frame->data,
  1679. frame->v4l2_buf.bytesused)) {
  1680. PDEBUG(D_ERR|D_STREAM,
  1681. "dqbuf cp to user failed");
  1682. ret = -EFAULT;
  1683. }
  1684. }
  1685. out:
  1686. mutex_unlock(&gspca_dev->queue_lock);
  1687. return ret;
  1688. }
  1689. /*
  1690. * queue a video buffer
  1691. *
  1692. * Attempting to queue a buffer that has already been
  1693. * queued will return -EINVAL.
  1694. */
  1695. static int vidioc_qbuf(struct file *file, void *priv,
  1696. struct v4l2_buffer *v4l2_buf)
  1697. {
  1698. struct gspca_dev *gspca_dev = priv;
  1699. struct gspca_frame *frame;
  1700. int i, index, ret;
  1701. PDEBUG(D_FRAM, "qbuf %d", v4l2_buf->index);
  1702. if (mutex_lock_interruptible(&gspca_dev->queue_lock))
  1703. return -ERESTARTSYS;
  1704. index = v4l2_buf->index;
  1705. if ((unsigned) index >= gspca_dev->nframes) {
  1706. PDEBUG(D_FRAM,
  1707. "qbuf idx %d >= %d", index, gspca_dev->nframes);
  1708. ret = -EINVAL;
  1709. goto out;
  1710. }
  1711. if (v4l2_buf->memory != gspca_dev->memory) {
  1712. PDEBUG(D_FRAM, "qbuf bad memory type");
  1713. ret = -EINVAL;
  1714. goto out;
  1715. }
  1716. frame = &gspca_dev->frame[index];
  1717. if (frame->v4l2_buf.flags & BUF_ALL_FLAGS) {
  1718. PDEBUG(D_FRAM, "qbuf bad state");
  1719. ret = -EINVAL;
  1720. goto out;
  1721. }
  1722. frame->v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED;
  1723. if (frame->v4l2_buf.memory == V4L2_MEMORY_USERPTR) {
  1724. frame->v4l2_buf.m.userptr = v4l2_buf->m.userptr;
  1725. frame->v4l2_buf.length = v4l2_buf->length;
  1726. }
  1727. /* put the buffer in the 'queued' queue */
  1728. i = atomic_read(&gspca_dev->fr_q);
  1729. gspca_dev->fr_queue[i] = index;
  1730. atomic_set(&gspca_dev->fr_q, (i + 1) % GSPCA_MAX_FRAMES);
  1731. v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED;
  1732. v4l2_buf->flags &= ~V4L2_BUF_FLAG_DONE;
  1733. ret = 0;
  1734. out:
  1735. mutex_unlock(&gspca_dev->queue_lock);
  1736. return ret;
  1737. }
  1738. /*
  1739. * allocate the resources for read()
  1740. */
  1741. static int read_alloc(struct gspca_dev *gspca_dev,
  1742. struct file *file)
  1743. {
  1744. struct v4l2_buffer v4l2_buf;
  1745. int i, ret;
  1746. PDEBUG(D_STREAM, "read alloc");
  1747. if (gspca_dev->nframes == 0) {
  1748. struct v4l2_requestbuffers rb;
  1749. memset(&rb, 0, sizeof rb);
  1750. rb.count = gspca_dev->nbufread;
  1751. rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1752. rb.memory = GSPCA_MEMORY_READ;
  1753. ret = vidioc_reqbufs(file, gspca_dev, &rb);
  1754. if (ret != 0) {
  1755. PDEBUG(D_STREAM, "read reqbuf err %d", ret);
  1756. return ret;
  1757. }
  1758. memset(&v4l2_buf, 0, sizeof v4l2_buf);
  1759. v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1760. v4l2_buf.memory = GSPCA_MEMORY_READ;
  1761. for (i = 0; i < gspca_dev->nbufread; i++) {
  1762. v4l2_buf.index = i;
  1763. ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
  1764. if (ret != 0) {
  1765. PDEBUG(D_STREAM, "read qbuf err: %d", ret);
  1766. return ret;
  1767. }
  1768. }
  1769. gspca_dev->memory = GSPCA_MEMORY_READ;
  1770. }
  1771. /* start streaming */
  1772. ret = vidioc_streamon(file, gspca_dev, V4L2_BUF_TYPE_VIDEO_CAPTURE);
  1773. if (ret != 0)
  1774. PDEBUG(D_STREAM, "read streamon err %d", ret);
  1775. return ret;
  1776. }
  1777. static unsigned int dev_poll(struct file *file, poll_table *wait)
  1778. {
  1779. struct gspca_dev *gspca_dev = file->private_data;
  1780. int ret;
  1781. PDEBUG(D_FRAM, "poll");
  1782. poll_wait(file, &gspca_dev->wq, wait);
  1783. /* if reqbufs is not done, the user would use read() */
  1784. if (gspca_dev->memory == GSPCA_MEMORY_NO) {
  1785. ret = read_alloc(gspca_dev, file);
  1786. if (ret != 0)
  1787. return POLLERR;
  1788. }
  1789. if (mutex_lock_interruptible(&gspca_dev->queue_lock) != 0)
  1790. return POLLERR;
  1791. /* check if an image has been received */
  1792. if (gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i))
  1793. ret = POLLIN | POLLRDNORM; /* yes */
  1794. else
  1795. ret = 0;
  1796. mutex_unlock(&gspca_dev->queue_lock);
  1797. if (!gspca_dev->present)
  1798. return POLLHUP;
  1799. return ret;
  1800. }
  1801. static ssize_t dev_read(struct file *file, char __user *data,
  1802. size_t count, loff_t *ppos)
  1803. {
  1804. struct gspca_dev *gspca_dev = file->private_data;
  1805. struct gspca_frame *frame;
  1806. struct v4l2_buffer v4l2_buf;
  1807. struct timeval timestamp;
  1808. int n, ret, ret2;
  1809. PDEBUG(D_FRAM, "read (%zd)", count);
  1810. if (!gspca_dev->present)
  1811. return -ENODEV;
  1812. if (gspca_dev->memory == GSPCA_MEMORY_NO) { /* first time ? */
  1813. ret = read_alloc(gspca_dev, file);
  1814. if (ret != 0)
  1815. return ret;
  1816. }
  1817. /* get a frame */
  1818. timestamp = ktime_to_timeval(ktime_get());
  1819. timestamp.tv_sec--;
  1820. n = 2;
  1821. for (;;) {
  1822. memset(&v4l2_buf, 0, sizeof v4l2_buf);
  1823. v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1824. v4l2_buf.memory = GSPCA_MEMORY_READ;
  1825. ret = vidioc_dqbuf(file, gspca_dev, &v4l2_buf);
  1826. if (ret != 0) {
  1827. PDEBUG(D_STREAM, "read dqbuf err %d", ret);
  1828. return ret;
  1829. }
  1830. /* if the process slept for more than 1 second,
  1831. * get a newer frame */
  1832. frame = &gspca_dev->frame[v4l2_buf.index];
  1833. if (--n < 0)
  1834. break; /* avoid infinite loop */
  1835. if (frame->v4l2_buf.timestamp.tv_sec >= timestamp.tv_sec)
  1836. break;
  1837. ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
  1838. if (ret != 0) {
  1839. PDEBUG(D_STREAM, "read qbuf err %d", ret);
  1840. return ret;
  1841. }
  1842. }
  1843. /* copy the frame */
  1844. if (count > frame->v4l2_buf.bytesused)
  1845. count = frame->v4l2_buf.bytesused;
  1846. ret = copy_to_user(data, frame->data, count);
  1847. if (ret != 0) {
  1848. PDEBUG(D_ERR|D_STREAM,
  1849. "read cp to user lack %d / %zd", ret, count);
  1850. ret = -EFAULT;
  1851. goto out;
  1852. }
  1853. ret = count;
  1854. out:
  1855. /* in each case, requeue the buffer */
  1856. ret2 = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
  1857. if (ret2 != 0)
  1858. return ret2;
  1859. return ret;
  1860. }
  1861. static struct v4l2_file_operations dev_fops = {
  1862. .owner = THIS_MODULE,
  1863. .open = dev_open,
  1864. .release = dev_close,
  1865. .read = dev_read,
  1866. .mmap = dev_mmap,
  1867. .unlocked_ioctl = video_ioctl2,
  1868. .poll = dev_poll,
  1869. };
  1870. static const struct v4l2_ioctl_ops dev_ioctl_ops = {
  1871. .vidioc_querycap = vidioc_querycap,
  1872. .vidioc_dqbuf = vidioc_dqbuf,
  1873. .vidioc_qbuf = vidioc_qbuf,
  1874. .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
  1875. .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
  1876. .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
  1877. .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
  1878. .vidioc_streamon = vidioc_streamon,
  1879. .vidioc_queryctrl = vidioc_queryctrl,
  1880. .vidioc_g_ctrl = vidioc_g_ctrl,
  1881. .vidioc_s_ctrl = vidioc_s_ctrl,
  1882. .vidioc_querymenu = vidioc_querymenu,
  1883. .vidioc_enum_input = vidioc_enum_input,
  1884. .vidioc_g_input = vidioc_g_input,
  1885. .vidioc_s_input = vidioc_s_input,
  1886. .vidioc_reqbufs = vidioc_reqbufs,
  1887. .vidioc_querybuf = vidioc_querybuf,
  1888. .vidioc_streamoff = vidioc_streamoff,
  1889. .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
  1890. .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
  1891. .vidioc_g_parm = vidioc_g_parm,
  1892. .vidioc_s_parm = vidioc_s_parm,
  1893. .vidioc_enum_framesizes = vidioc_enum_framesizes,
  1894. .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
  1895. #ifdef CONFIG_VIDEO_ADV_DEBUG
  1896. .vidioc_g_register = vidioc_g_register,
  1897. .vidioc_s_register = vidioc_s_register,
  1898. #endif
  1899. .vidioc_g_chip_ident = vidioc_g_chip_ident,
  1900. };
  1901. static const struct video_device gspca_template = {
  1902. .name = "gspca main driver",
  1903. .fops = &dev_fops,
  1904. .ioctl_ops = &dev_ioctl_ops,
  1905. .release = gspca_release,
  1906. };
  1907. /* initialize the controls */
  1908. static void ctrls_init(struct gspca_dev *gspca_dev)
  1909. {
  1910. struct gspca_ctrl *ctrl;
  1911. int i;
  1912. for (i = 0, ctrl = gspca_dev->cam.ctrls;
  1913. i < gspca_dev->sd_desc->nctrls;
  1914. i++, ctrl++) {
  1915. ctrl->def = gspca_dev->sd_desc->ctrls[i].qctrl.default_value;
  1916. ctrl->val = ctrl->def;
  1917. ctrl->min = gspca_dev->sd_desc->ctrls[i].qctrl.minimum;
  1918. ctrl->max = gspca_dev->sd_desc->ctrls[i].qctrl.maximum;
  1919. }
  1920. }
  1921. /*
  1922. * probe and create a new gspca device
  1923. *
  1924. * This function must be called by the sub-driver when it is
  1925. * called for probing a new device.
  1926. */
  1927. int gspca_dev_probe2(struct usb_interface *intf,
  1928. const struct usb_device_id *id,
  1929. const struct sd_desc *sd_desc,
  1930. int dev_size,
  1931. struct module *module)
  1932. {
  1933. struct gspca_dev *gspca_dev;
  1934. struct usb_device *dev = interface_to_usbdev(intf);
  1935. int ret;
  1936. PDEBUG(D_PROBE, "probing %04x:%04x", id->idVendor, id->idProduct);
  1937. /* create the device */
  1938. if (dev_size < sizeof *gspca_dev)
  1939. dev_size = sizeof *gspca_dev;
  1940. gspca_dev = kzalloc(dev_size, GFP_KERNEL);
  1941. if (!gspca_dev) {
  1942. pr_err("couldn't kzalloc gspca struct\n");
  1943. return -ENOMEM;
  1944. }
  1945. gspca_dev->usb_buf = kmalloc(USB_BUF_SZ, GFP_KERNEL);
  1946. if (!gspca_dev->usb_buf) {
  1947. pr_err("out of memory\n");
  1948. ret = -ENOMEM;
  1949. goto out;
  1950. }
  1951. gspca_dev->dev = dev;
  1952. gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber;
  1953. gspca_dev->nbalt = intf->num_altsetting;
  1954. /* check if any audio device */
  1955. if (dev->config->desc.bNumInterfaces != 1) {
  1956. int i;
  1957. struct usb_interface *intf2;
  1958. for (i = 0; i < dev->config->desc.bNumInterfaces; i++) {
  1959. intf2 = dev->config->interface[i];
  1960. if (intf2 != NULL
  1961. && intf2->altsetting != NULL
  1962. && intf2->altsetting->desc.bInterfaceClass ==
  1963. USB_CLASS_AUDIO) {
  1964. gspca_dev->audio = 1;
  1965. break;
  1966. }
  1967. }
  1968. }
  1969. gspca_dev->sd_desc = sd_desc;
  1970. gspca_dev->nbufread = 2;
  1971. gspca_dev->empty_packet = -1; /* don't check the empty packets */
  1972. /* configure the subdriver and initialize the USB device */
  1973. ret = sd_desc->config(gspca_dev, id);
  1974. if (ret < 0)
  1975. goto out;
  1976. if (gspca_dev->cam.ctrls != NULL)
  1977. ctrls_init(gspca_dev);
  1978. ret = sd_desc->init(gspca_dev);
  1979. if (ret < 0)
  1980. goto out;
  1981. gspca_set_default_mode(gspca_dev);
  1982. ret = gspca_input_connect(gspca_dev);
  1983. if (ret)
  1984. goto out;
  1985. mutex_init(&gspca_dev->usb_lock);
  1986. mutex_init(&gspca_dev->queue_lock);
  1987. init_waitqueue_head(&gspca_dev->wq);
  1988. /* init video stuff */
  1989. memcpy(&gspca_dev->vdev, &gspca_template, sizeof gspca_template);
  1990. gspca_dev->vdev.parent = &intf->dev;
  1991. gspca_dev->module = module;
  1992. gspca_dev->present = 1;
  1993. ret = video_register_device(&gspca_dev->vdev,
  1994. VFL_TYPE_GRABBER,
  1995. -1);
  1996. if (ret < 0) {
  1997. pr_err("video_register_device err %d\n", ret);
  1998. goto out;
  1999. }
  2000. usb_set_intfdata(intf, gspca_dev);
  2001. PDEBUG(D_PROBE, "%s created", video_device_node_name(&gspca_dev->vdev));
  2002. gspca_input_create_urb(gspca_dev);
  2003. return 0;
  2004. out:
  2005. #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
  2006. if (gspca_dev->input_dev)
  2007. input_unregister_device(gspca_dev->input_dev);
  2008. #endif
  2009. kfree(gspca_dev->usb_buf);
  2010. kfree(gspca_dev);
  2011. return ret;
  2012. }
  2013. EXPORT_SYMBOL(gspca_dev_probe2);
  2014. /* same function as the previous one, but check the interface */
  2015. int gspca_dev_probe(struct usb_interface *intf,
  2016. const struct usb_device_id *id,
  2017. const struct sd_desc *sd_desc,
  2018. int dev_size,
  2019. struct module *module)
  2020. {
  2021. struct usb_device *dev = interface_to_usbdev(intf);
  2022. /* we don't handle multi-config cameras */
  2023. if (dev->descriptor.bNumConfigurations != 1) {
  2024. pr_err("%04x:%04x too many config\n",
  2025. id->idVendor, id->idProduct);
  2026. return -ENODEV;
  2027. }
  2028. /* the USB video interface must be the first one */
  2029. if (dev->config->desc.bNumInterfaces != 1
  2030. && intf->cur_altsetting->desc.bInterfaceNumber != 0)
  2031. return -ENODEV;
  2032. return gspca_dev_probe2(intf, id, sd_desc, dev_size, module);
  2033. }
  2034. EXPORT_SYMBOL(gspca_dev_probe);
  2035. /*
  2036. * USB disconnection
  2037. *
  2038. * This function must be called by the sub-driver
  2039. * when the device disconnects, after the specific resources are freed.
  2040. */
  2041. void gspca_disconnect(struct usb_interface *intf)
  2042. {
  2043. struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
  2044. #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
  2045. struct input_dev *input_dev;
  2046. #endif
  2047. PDEBUG(D_PROBE, "%s disconnect",
  2048. video_device_node_name(&gspca_dev->vdev));
  2049. mutex_lock(&gspca_dev->usb_lock);
  2050. gspca_dev->present = 0;
  2051. wake_up_interruptible(&gspca_dev->wq);
  2052. destroy_urbs(gspca_dev);
  2053. #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
  2054. gspca_input_destroy_urb(gspca_dev);
  2055. input_dev = gspca_dev->input_dev;
  2056. if (input_dev) {
  2057. gspca_dev->input_dev = NULL;
  2058. input_unregister_device(input_dev);
  2059. }
  2060. #endif
  2061. /* the device is freed at exit of this function */
  2062. gspca_dev->dev = NULL;
  2063. mutex_unlock(&gspca_dev->usb_lock);
  2064. usb_set_intfdata(intf, NULL);
  2065. /* release the device */
  2066. /* (this will call gspca_release() immediately or on last close) */
  2067. video_unregister_device(&gspca_dev->vdev);
  2068. /* PDEBUG(D_PROBE, "disconnect complete"); */
  2069. }
  2070. EXPORT_SYMBOL(gspca_disconnect);
  2071. #ifdef CONFIG_PM
  2072. int gspca_suspend(struct usb_interface *intf, pm_message_t message)
  2073. {
  2074. struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
  2075. if (!gspca_dev->streaming)
  2076. return 0;
  2077. gspca_dev->frozen = 1; /* avoid urb error messages */
  2078. if (gspca_dev->sd_desc->stopN)
  2079. gspca_dev->sd_desc->stopN(gspca_dev);
  2080. destroy_urbs(gspca_dev);
  2081. gspca_input_destroy_urb(gspca_dev);
  2082. gspca_set_alt0(gspca_dev);
  2083. if (gspca_dev->sd_desc->stop0)
  2084. gspca_dev->sd_desc->stop0(gspca_dev);
  2085. return 0;
  2086. }
  2087. EXPORT_SYMBOL(gspca_suspend);
  2088. int gspca_resume(struct usb_interface *intf)
  2089. {
  2090. struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
  2091. gspca_dev->frozen = 0;
  2092. gspca_dev->sd_desc->init(gspca_dev);
  2093. gspca_input_create_urb(gspca_dev);
  2094. if (gspca_dev->streaming)
  2095. return gspca_init_transfer(gspca_dev);
  2096. return 0;
  2097. }
  2098. EXPORT_SYMBOL(gspca_resume);
  2099. #endif
  2100. /* -- cam driver utility functions -- */
  2101. /* auto gain and exposure algorithm based on the knee algorithm described here:
  2102. http://ytse.tricolour.net/docs/LowLightOptimization.html
  2103. Returns 0 if no changes were made, 1 if the gain and or exposure settings
  2104. where changed. */
  2105. int gspca_auto_gain_n_exposure(struct gspca_dev *gspca_dev, int avg_lum,
  2106. int desired_avg_lum, int deadzone, int gain_knee, int exposure_knee)
  2107. {
  2108. int i, steps, gain, orig_gain, exposure, orig_exposure, autogain;
  2109. const struct ctrl *gain_ctrl = NULL;
  2110. const struct ctrl *exposure_ctrl = NULL;
  2111. const struct ctrl *autogain_ctrl = NULL;
  2112. int retval = 0;
  2113. for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
  2114. if (gspca_dev->ctrl_dis & (1 << i))
  2115. continue;
  2116. if (gspca_dev->sd_desc->ctrls[i].qctrl.id == V4L2_CID_GAIN)
  2117. gain_ctrl = &gspca_dev->sd_desc->ctrls[i];
  2118. if (gspca_dev->sd_desc->ctrls[i].qctrl.id == V4L2_CID_EXPOSURE)
  2119. exposure_ctrl = &gspca_dev->sd_desc->ctrls[i];
  2120. if (gspca_dev->sd_desc->ctrls[i].qctrl.id == V4L2_CID_AUTOGAIN)
  2121. autogain_ctrl = &gspca_dev->sd_desc->ctrls[i];
  2122. }
  2123. if (!gain_ctrl || !exposure_ctrl || !autogain_ctrl) {
  2124. PDEBUG(D_ERR, "Error: gspca_auto_gain_n_exposure called "
  2125. "on cam without (auto)gain/exposure");
  2126. return 0;
  2127. }
  2128. if (gain_ctrl->get(gspca_dev, &gain) ||
  2129. exposure_ctrl->get(gspca_dev, &exposure) ||
  2130. autogain_ctrl->get(gspca_dev, &autogain) || !autogain)
  2131. return 0;
  2132. orig_gain = gain;
  2133. orig_exposure = exposure;
  2134. /* If we are of a multiple of deadzone, do multiple steps to reach the
  2135. desired lumination fast (with the risc of a slight overshoot) */
  2136. steps = abs(desired_avg_lum - avg_lum) / deadzone;
  2137. PDEBUG(D_FRAM, "autogain: lum: %d, desired: %d, steps: %d",
  2138. avg_lum, desired_avg_lum, steps);
  2139. for (i = 0; i < steps; i++) {
  2140. if (avg_lum > desired_avg_lum) {
  2141. if (gain > gain_knee)
  2142. gain--;
  2143. else if (exposure > exposure_knee)
  2144. exposure--;
  2145. else if (gain > gain_ctrl->qctrl.default_value)
  2146. gain--;
  2147. else if (exposure > exposure_ctrl->qctrl.minimum)
  2148. exposure--;
  2149. else if (gain > gain_ctrl->qctrl.minimum)
  2150. gain--;
  2151. else
  2152. break;
  2153. } else {
  2154. if (gain < gain_ctrl->qctrl.default_value)
  2155. gain++;
  2156. else if (exposure < exposure_knee)
  2157. exposure++;
  2158. else if (gain < gain_knee)
  2159. gain++;
  2160. else if (exposure < exposure_ctrl->qctrl.maximum)
  2161. exposure++;
  2162. else if (gain < gain_ctrl->qctrl.maximum)
  2163. gain++;
  2164. else
  2165. break;
  2166. }
  2167. }
  2168. if (gain != orig_gain) {
  2169. gain_ctrl->set(gspca_dev, gain);
  2170. retval = 1;
  2171. }
  2172. if (exposure != orig_exposure) {
  2173. exposure_ctrl->set(gspca_dev, exposure);
  2174. retval = 1;
  2175. }
  2176. return retval;
  2177. }
  2178. EXPORT_SYMBOL(gspca_auto_gain_n_exposure);
  2179. /* -- module insert / remove -- */
  2180. static int __init gspca_init(void)
  2181. {
  2182. pr_info("v" DRIVER_VERSION_NUMBER " registered\n");
  2183. return 0;
  2184. }
  2185. static void __exit gspca_exit(void)
  2186. {
  2187. }
  2188. module_init(gspca_init);
  2189. module_exit(gspca_exit);
  2190. #ifdef GSPCA_DEBUG
  2191. module_param_named(debug, gspca_debug, int, 0644);
  2192. MODULE_PARM_DESC(debug,
  2193. "Debug (bit) 0x01:error 0x02:probe 0x04:config"
  2194. " 0x08:stream 0x10:frame 0x20:packet"
  2195. " 0x0100: v4l2");
  2196. #endif