em28xx-video.c 57 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371
  1. /*
  2. em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB
  3. video capture devices
  4. Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
  5. Markus Rechberger <mrechberger@gmail.com>
  6. Mauro Carvalho Chehab <mchehab@infradead.org>
  7. Sascha Sommer <saschasommer@freenet.de>
  8. Some parts based on SN9C10x PC Camera Controllers GPL driver made
  9. by Luca Risolia <luca.risolia@studio.unibo.it>
  10. This program is free software; you can redistribute it and/or modify
  11. it under the terms of the GNU General Public License as published by
  12. the Free Software Foundation; either version 2 of the License, or
  13. (at your option) any later version.
  14. This program is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. GNU General Public License for more details.
  18. You should have received a copy of the GNU General Public License
  19. along with this program; if not, write to the Free Software
  20. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21. */
  22. #include <linux/init.h>
  23. #include <linux/list.h>
  24. #include <linux/module.h>
  25. #include <linux/kernel.h>
  26. #include <linux/bitmap.h>
  27. #include <linux/usb.h>
  28. #include <linux/i2c.h>
  29. #include <linux/version.h>
  30. #include <linux/mm.h>
  31. #include <linux/mutex.h>
  32. #include "em28xx.h"
  33. #include <media/v4l2-common.h>
  34. #include <media/v4l2-ioctl.h>
  35. #include <media/msp3400.h>
  36. #include <media/tuner.h>
  37. #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
  38. "Markus Rechberger <mrechberger@gmail.com>, " \
  39. "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
  40. "Sascha Sommer <saschasommer@freenet.de>"
  41. #define DRIVER_NAME "em28xx"
  42. #define DRIVER_DESC "Empia em28xx based USB video device driver"
  43. #define EM28XX_VERSION_CODE KERNEL_VERSION(0, 1, 0)
  44. #define em28xx_videodbg(fmt, arg...) do {\
  45. if (video_debug) \
  46. printk(KERN_INFO "%s %s :"fmt, \
  47. dev->name, __func__ , ##arg); } while (0)
  48. static unsigned int isoc_debug;
  49. module_param(isoc_debug, int, 0644);
  50. MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
  51. #define em28xx_isocdbg(fmt, arg...) \
  52. do {\
  53. if (isoc_debug) { \
  54. printk(KERN_INFO "%s %s :"fmt, \
  55. dev->name, __func__ , ##arg); \
  56. } \
  57. } while (0)
  58. MODULE_AUTHOR(DRIVER_AUTHOR);
  59. MODULE_DESCRIPTION(DRIVER_DESC);
  60. MODULE_LICENSE("GPL");
  61. static LIST_HEAD(em28xx_devlist);
  62. static DEFINE_MUTEX(em28xx_devlist_mutex);
  63. static unsigned int card[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
  64. static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
  65. static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
  66. static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
  67. module_param_array(card, int, NULL, 0444);
  68. module_param_array(video_nr, int, NULL, 0444);
  69. module_param_array(vbi_nr, int, NULL, 0444);
  70. module_param_array(radio_nr, int, NULL, 0444);
  71. MODULE_PARM_DESC(card, "card type");
  72. MODULE_PARM_DESC(video_nr, "video device numbers");
  73. MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
  74. MODULE_PARM_DESC(radio_nr, "radio device numbers");
  75. static unsigned int video_debug;
  76. module_param(video_debug, int, 0644);
  77. MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
  78. /* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
  79. static unsigned long em28xx_devused;
  80. /* supported controls */
  81. /* Common to all boards */
  82. static struct v4l2_queryctrl em28xx_qctrl[] = {
  83. {
  84. .id = V4L2_CID_AUDIO_VOLUME,
  85. .type = V4L2_CTRL_TYPE_INTEGER,
  86. .name = "Volume",
  87. .minimum = 0x0,
  88. .maximum = 0x1f,
  89. .step = 0x1,
  90. .default_value = 0x1f,
  91. .flags = 0,
  92. }, {
  93. .id = V4L2_CID_AUDIO_MUTE,
  94. .type = V4L2_CTRL_TYPE_BOOLEAN,
  95. .name = "Mute",
  96. .minimum = 0,
  97. .maximum = 1,
  98. .step = 1,
  99. .default_value = 1,
  100. .flags = 0,
  101. }
  102. };
  103. static struct usb_driver em28xx_usb_driver;
  104. /* ------------------------------------------------------------------
  105. DMA and thread functions
  106. ------------------------------------------------------------------*/
  107. /*
  108. * Announces that a buffer were filled and request the next
  109. */
  110. static inline void buffer_filled(struct em28xx *dev,
  111. struct em28xx_dmaqueue *dma_q,
  112. struct em28xx_buffer *buf)
  113. {
  114. /* Advice that buffer was filled */
  115. em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
  116. buf->vb.state = VIDEOBUF_DONE;
  117. buf->vb.field_count++;
  118. do_gettimeofday(&buf->vb.ts);
  119. dev->isoc_ctl.buf = NULL;
  120. list_del(&buf->vb.queue);
  121. wake_up(&buf->vb.done);
  122. }
  123. /*
  124. * Identify the buffer header type and properly handles
  125. */
  126. static void em28xx_copy_video(struct em28xx *dev,
  127. struct em28xx_dmaqueue *dma_q,
  128. struct em28xx_buffer *buf,
  129. unsigned char *p,
  130. unsigned char *outp, unsigned long len)
  131. {
  132. void *fieldstart, *startwrite, *startread;
  133. int linesdone, currlinedone, offset, lencopy, remain;
  134. int bytesperline = dev->width << 1;
  135. if (dma_q->pos + len > buf->vb.size)
  136. len = buf->vb.size - dma_q->pos;
  137. if (p[0] != 0x88 && p[0] != 0x22) {
  138. em28xx_isocdbg("frame is not complete\n");
  139. len += 4;
  140. } else
  141. p += 4;
  142. startread = p;
  143. remain = len;
  144. /* Interlaces frame */
  145. if (buf->top_field)
  146. fieldstart = outp;
  147. else
  148. fieldstart = outp + bytesperline;
  149. linesdone = dma_q->pos / bytesperline;
  150. currlinedone = dma_q->pos % bytesperline;
  151. offset = linesdone * bytesperline * 2 + currlinedone;
  152. startwrite = fieldstart + offset;
  153. lencopy = bytesperline - currlinedone;
  154. lencopy = lencopy > remain ? remain : lencopy;
  155. if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
  156. em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
  157. ((char *)startwrite + lencopy) -
  158. ((char *)outp + buf->vb.size));
  159. lencopy = remain = (char *)outp + buf->vb.size - (char *)startwrite;
  160. }
  161. if (lencopy <= 0)
  162. return;
  163. memcpy(startwrite, startread, lencopy);
  164. remain -= lencopy;
  165. while (remain > 0) {
  166. startwrite += lencopy + bytesperline;
  167. startread += lencopy;
  168. if (bytesperline > remain)
  169. lencopy = remain;
  170. else
  171. lencopy = bytesperline;
  172. if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
  173. em28xx_isocdbg("Overflow of %zi bytes past buffer end (2)\n",
  174. ((char *)startwrite + lencopy) -
  175. ((char *)outp + buf->vb.size));
  176. lencopy = remain = (char *)outp + buf->vb.size -
  177. (char *)startwrite;
  178. }
  179. if (lencopy <= 0)
  180. break;
  181. memcpy(startwrite, startread, lencopy);
  182. remain -= lencopy;
  183. }
  184. dma_q->pos += len;
  185. }
  186. static inline void print_err_status(struct em28xx *dev,
  187. int packet, int status)
  188. {
  189. char *errmsg = "Unknown";
  190. switch (status) {
  191. case -ENOENT:
  192. errmsg = "unlinked synchronuously";
  193. break;
  194. case -ECONNRESET:
  195. errmsg = "unlinked asynchronuously";
  196. break;
  197. case -ENOSR:
  198. errmsg = "Buffer error (overrun)";
  199. break;
  200. case -EPIPE:
  201. errmsg = "Stalled (device not responding)";
  202. break;
  203. case -EOVERFLOW:
  204. errmsg = "Babble (bad cable?)";
  205. break;
  206. case -EPROTO:
  207. errmsg = "Bit-stuff error (bad cable?)";
  208. break;
  209. case -EILSEQ:
  210. errmsg = "CRC/Timeout (could be anything)";
  211. break;
  212. case -ETIME:
  213. errmsg = "Device does not respond";
  214. break;
  215. }
  216. if (packet < 0) {
  217. em28xx_isocdbg("URB status %d [%s].\n", status, errmsg);
  218. } else {
  219. em28xx_isocdbg("URB packet %d, status %d [%s].\n",
  220. packet, status, errmsg);
  221. }
  222. }
  223. /*
  224. * video-buf generic routine to get the next available buffer
  225. */
  226. static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,
  227. struct em28xx_buffer **buf)
  228. {
  229. struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
  230. char *outp;
  231. if (list_empty(&dma_q->active)) {
  232. em28xx_isocdbg("No active queue to serve\n");
  233. dev->isoc_ctl.buf = NULL;
  234. *buf = NULL;
  235. return;
  236. }
  237. /* Get the next buffer */
  238. *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
  239. /* Cleans up buffer - Usefull for testing for frame/URB loss */
  240. outp = videobuf_to_vmalloc(&(*buf)->vb);
  241. memset(outp, 0, (*buf)->vb.size);
  242. dev->isoc_ctl.buf = *buf;
  243. return;
  244. }
  245. /*
  246. * Controls the isoc copy of each urb packet
  247. */
  248. static inline int em28xx_isoc_copy(struct em28xx *dev, struct urb *urb)
  249. {
  250. struct em28xx_buffer *buf;
  251. struct em28xx_dmaqueue *dma_q = urb->context;
  252. unsigned char *outp = NULL;
  253. int i, len = 0, rc = 1;
  254. unsigned char *p;
  255. if (!dev)
  256. return 0;
  257. if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
  258. return 0;
  259. if (urb->status < 0) {
  260. print_err_status(dev, -1, urb->status);
  261. if (urb->status == -ENOENT)
  262. return 0;
  263. }
  264. buf = dev->isoc_ctl.buf;
  265. if (buf != NULL)
  266. outp = videobuf_to_vmalloc(&buf->vb);
  267. for (i = 0; i < urb->number_of_packets; i++) {
  268. int status = urb->iso_frame_desc[i].status;
  269. if (status < 0) {
  270. print_err_status(dev, i, status);
  271. if (urb->iso_frame_desc[i].status != -EPROTO)
  272. continue;
  273. }
  274. len = urb->iso_frame_desc[i].actual_length - 4;
  275. if (urb->iso_frame_desc[i].actual_length <= 0) {
  276. /* em28xx_isocdbg("packet %d is empty",i); - spammy */
  277. continue;
  278. }
  279. if (urb->iso_frame_desc[i].actual_length >
  280. dev->max_pkt_size) {
  281. em28xx_isocdbg("packet bigger than packet size");
  282. continue;
  283. }
  284. p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
  285. /* FIXME: incomplete buffer checks where removed to make
  286. logic simpler. Impacts of those changes should be evaluated
  287. */
  288. if (p[0] == 0x33 && p[1] == 0x95 && p[2] == 0x00) {
  289. em28xx_isocdbg("VBI HEADER!!!\n");
  290. /* FIXME: Should add vbi copy */
  291. continue;
  292. }
  293. if (p[0] == 0x22 && p[1] == 0x5a) {
  294. em28xx_isocdbg("Video frame %d, length=%i, %s\n", p[2],
  295. len, (p[2] & 1)? "odd" : "even");
  296. if (!(p[2] & 1)) {
  297. if (buf != NULL)
  298. buffer_filled(dev, dma_q, buf);
  299. get_next_buf(dma_q, &buf);
  300. if (buf == NULL)
  301. outp = NULL;
  302. else
  303. outp = videobuf_to_vmalloc(&buf->vb);
  304. }
  305. if (buf != NULL) {
  306. if (p[2] & 1)
  307. buf->top_field = 0;
  308. else
  309. buf->top_field = 1;
  310. }
  311. dma_q->pos = 0;
  312. }
  313. if (buf != NULL)
  314. em28xx_copy_video(dev, dma_q, buf, p, outp, len);
  315. }
  316. return rc;
  317. }
  318. /* ------------------------------------------------------------------
  319. Videobuf operations
  320. ------------------------------------------------------------------*/
  321. static int
  322. buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
  323. {
  324. struct em28xx_fh *fh = vq->priv_data;
  325. struct em28xx *dev = fh->dev;
  326. struct v4l2_frequency f;
  327. *size = 16 * fh->dev->width * fh->dev->height >> 3;
  328. if (0 == *count)
  329. *count = EM28XX_DEF_BUF;
  330. if (*count < EM28XX_MIN_BUF)
  331. *count = EM28XX_MIN_BUF;
  332. /* Ask tuner to go to analog mode */
  333. memset(&f, 0, sizeof(f));
  334. f.frequency = dev->ctl_freq;
  335. em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, &f);
  336. return 0;
  337. }
  338. /* This is called *without* dev->slock held; please keep it that way */
  339. static void free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
  340. {
  341. struct em28xx_fh *fh = vq->priv_data;
  342. struct em28xx *dev = fh->dev;
  343. unsigned long flags = 0;
  344. if (in_interrupt())
  345. BUG();
  346. /* We used to wait for the buffer to finish here, but this didn't work
  347. because, as we were keeping the state as VIDEOBUF_QUEUED,
  348. videobuf_queue_cancel marked it as finished for us.
  349. (Also, it could wedge forever if the hardware was misconfigured.)
  350. This should be safe; by the time we get here, the buffer isn't
  351. queued anymore. If we ever start marking the buffers as
  352. VIDEOBUF_ACTIVE, it won't be, though.
  353. */
  354. spin_lock_irqsave(&dev->slock, flags);
  355. if (dev->isoc_ctl.buf == buf)
  356. dev->isoc_ctl.buf = NULL;
  357. spin_unlock_irqrestore(&dev->slock, flags);
  358. videobuf_vmalloc_free(&buf->vb);
  359. buf->vb.state = VIDEOBUF_NEEDS_INIT;
  360. }
  361. static int
  362. buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
  363. enum v4l2_field field)
  364. {
  365. struct em28xx_fh *fh = vq->priv_data;
  366. struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
  367. struct em28xx *dev = fh->dev;
  368. int rc = 0, urb_init = 0;
  369. /* FIXME: It assumes depth = 16 */
  370. /* The only currently supported format is 16 bits/pixel */
  371. buf->vb.size = 16 * dev->width * dev->height >> 3;
  372. if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
  373. return -EINVAL;
  374. buf->vb.width = dev->width;
  375. buf->vb.height = dev->height;
  376. buf->vb.field = field;
  377. if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
  378. rc = videobuf_iolock(vq, &buf->vb, NULL);
  379. if (rc < 0)
  380. goto fail;
  381. }
  382. if (!dev->isoc_ctl.num_bufs)
  383. urb_init = 1;
  384. if (urb_init) {
  385. rc = em28xx_init_isoc(dev, EM28XX_NUM_PACKETS,
  386. EM28XX_NUM_BUFS, dev->max_pkt_size,
  387. em28xx_isoc_copy);
  388. if (rc < 0)
  389. goto fail;
  390. }
  391. buf->vb.state = VIDEOBUF_PREPARED;
  392. return 0;
  393. fail:
  394. free_buffer(vq, buf);
  395. return rc;
  396. }
  397. static void
  398. buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
  399. {
  400. struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
  401. struct em28xx_fh *fh = vq->priv_data;
  402. struct em28xx *dev = fh->dev;
  403. struct em28xx_dmaqueue *vidq = &dev->vidq;
  404. buf->vb.state = VIDEOBUF_QUEUED;
  405. list_add_tail(&buf->vb.queue, &vidq->active);
  406. }
  407. static void buffer_release(struct videobuf_queue *vq,
  408. struct videobuf_buffer *vb)
  409. {
  410. struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
  411. struct em28xx_fh *fh = vq->priv_data;
  412. struct em28xx *dev = (struct em28xx *)fh->dev;
  413. em28xx_isocdbg("em28xx: called buffer_release\n");
  414. free_buffer(vq, buf);
  415. }
  416. static struct videobuf_queue_ops em28xx_video_qops = {
  417. .buf_setup = buffer_setup,
  418. .buf_prepare = buffer_prepare,
  419. .buf_queue = buffer_queue,
  420. .buf_release = buffer_release,
  421. };
  422. /********************* v4l2 interface **************************************/
  423. /*
  424. * em28xx_config()
  425. * inits registers with sane defaults
  426. */
  427. static int em28xx_config(struct em28xx *dev)
  428. {
  429. int retval;
  430. /* Sets I2C speed to 100 KHz */
  431. if (!dev->is_em2800) {
  432. retval = em28xx_write_regs_req(dev, 0x00, 0x06, "\x40", 1);
  433. if (retval < 0) {
  434. em28xx_errdev("%s: em28xx_write_regs_req failed! retval [%d]\n",
  435. __func__, retval);
  436. return retval;
  437. }
  438. }
  439. /* enable vbi capturing */
  440. /* em28xx_write_regs_req(dev, 0x00, 0x0e, "\xC0", 1); audio register */
  441. /* em28xx_write_regs_req(dev, 0x00, 0x0f, "\x80", 1); clk register */
  442. em28xx_write_regs_req(dev, 0x00, 0x11, "\x51", 1);
  443. dev->mute = 1; /* maybe not the right place... */
  444. dev->volume = 0x1f;
  445. em28xx_outfmt_set_yuv422(dev);
  446. em28xx_colorlevels_set_default(dev);
  447. em28xx_compression_disable(dev);
  448. return 0;
  449. }
  450. /*
  451. * em28xx_config_i2c()
  452. * configure i2c attached devices
  453. */
  454. static void em28xx_config_i2c(struct em28xx *dev)
  455. {
  456. struct v4l2_routing route;
  457. int zero = 0;
  458. route.input = INPUT(dev->ctl_input)->vmux;
  459. route.output = 0;
  460. em28xx_i2c_call_clients(dev, VIDIOC_INT_RESET, &zero);
  461. em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
  462. em28xx_i2c_call_clients(dev, VIDIOC_STREAMON, NULL);
  463. }
  464. static void video_mux(struct em28xx *dev, int index)
  465. {
  466. struct v4l2_routing route;
  467. route.input = INPUT(index)->vmux;
  468. route.output = 0;
  469. dev->ctl_input = index;
  470. dev->ctl_ainput = INPUT(index)->amux;
  471. em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
  472. if (dev->has_msp34xx) {
  473. if (dev->i2s_speed) {
  474. em28xx_i2c_call_clients(dev, VIDIOC_INT_I2S_CLOCK_FREQ,
  475. &dev->i2s_speed);
  476. }
  477. route.input = dev->ctl_ainput;
  478. route.output = MSP_OUTPUT(MSP_SC_IN_DSP_SCART1);
  479. /* Note: this is msp3400 specific */
  480. em28xx_i2c_call_clients(dev, VIDIOC_INT_S_AUDIO_ROUTING,
  481. &route);
  482. }
  483. em28xx_audio_analog_set(dev);
  484. }
  485. /* Usage lock check functions */
  486. static int res_get(struct em28xx_fh *fh)
  487. {
  488. struct em28xx *dev = fh->dev;
  489. int rc = 0;
  490. /* This instance already has stream_on */
  491. if (fh->stream_on)
  492. return rc;
  493. if (dev->stream_on)
  494. return -EINVAL;
  495. mutex_lock(&dev->lock);
  496. dev->stream_on = 1;
  497. fh->stream_on = 1;
  498. mutex_unlock(&dev->lock);
  499. return rc;
  500. }
  501. static int res_check(struct em28xx_fh *fh)
  502. {
  503. return (fh->stream_on);
  504. }
  505. static void res_free(struct em28xx_fh *fh)
  506. {
  507. struct em28xx *dev = fh->dev;
  508. mutex_lock(&dev->lock);
  509. fh->stream_on = 0;
  510. dev->stream_on = 0;
  511. mutex_unlock(&dev->lock);
  512. }
  513. /*
  514. * em28xx_get_ctrl()
  515. * return the current saturation, brightness or contrast, mute state
  516. */
  517. static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
  518. {
  519. switch (ctrl->id) {
  520. case V4L2_CID_AUDIO_MUTE:
  521. ctrl->value = dev->mute;
  522. return 0;
  523. case V4L2_CID_AUDIO_VOLUME:
  524. ctrl->value = dev->volume;
  525. return 0;
  526. default:
  527. return -EINVAL;
  528. }
  529. }
  530. /*
  531. * em28xx_set_ctrl()
  532. * mute or set new saturation, brightness or contrast
  533. */
  534. static int em28xx_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
  535. {
  536. switch (ctrl->id) {
  537. case V4L2_CID_AUDIO_MUTE:
  538. if (ctrl->value != dev->mute) {
  539. dev->mute = ctrl->value;
  540. return em28xx_audio_analog_set(dev);
  541. }
  542. return 0;
  543. case V4L2_CID_AUDIO_VOLUME:
  544. dev->volume = ctrl->value;
  545. return em28xx_audio_analog_set(dev);
  546. default:
  547. return -EINVAL;
  548. }
  549. }
  550. static int check_dev(struct em28xx *dev)
  551. {
  552. if (dev->state & DEV_DISCONNECTED) {
  553. em28xx_errdev("v4l2 ioctl: device not present\n");
  554. return -ENODEV;
  555. }
  556. if (dev->state & DEV_MISCONFIGURED) {
  557. em28xx_errdev("v4l2 ioctl: device is misconfigured; "
  558. "close and open it again\n");
  559. return -EIO;
  560. }
  561. return 0;
  562. }
  563. static void get_scale(struct em28xx *dev,
  564. unsigned int width, unsigned int height,
  565. unsigned int *hscale, unsigned int *vscale)
  566. {
  567. unsigned int maxw = norm_maxw(dev);
  568. unsigned int maxh = norm_maxh(dev);
  569. *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
  570. if (*hscale >= 0x4000)
  571. *hscale = 0x3fff;
  572. *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
  573. if (*vscale >= 0x4000)
  574. *vscale = 0x3fff;
  575. }
  576. /* ------------------------------------------------------------------
  577. IOCTL vidioc handling
  578. ------------------------------------------------------------------*/
  579. static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
  580. struct v4l2_format *f)
  581. {
  582. struct em28xx_fh *fh = priv;
  583. struct em28xx *dev = fh->dev;
  584. mutex_lock(&dev->lock);
  585. f->fmt.pix.width = dev->width;
  586. f->fmt.pix.height = dev->height;
  587. f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  588. f->fmt.pix.bytesperline = dev->width * 2;
  589. f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height;
  590. f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
  591. /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
  592. f->fmt.pix.field = dev->interlaced ?
  593. V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
  594. mutex_unlock(&dev->lock);
  595. return 0;
  596. }
  597. static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
  598. struct v4l2_format *f)
  599. {
  600. struct em28xx_fh *fh = priv;
  601. struct em28xx *dev = fh->dev;
  602. int width = f->fmt.pix.width;
  603. int height = f->fmt.pix.height;
  604. unsigned int maxw = norm_maxw(dev);
  605. unsigned int maxh = norm_maxh(dev);
  606. unsigned int hscale, vscale;
  607. /* width must even because of the YUYV format
  608. height must be even because of interlacing */
  609. height &= 0xfffe;
  610. width &= 0xfffe;
  611. if (height < 32)
  612. height = 32;
  613. if (height > maxh)
  614. height = maxh;
  615. if (width < 48)
  616. width = 48;
  617. if (width > maxw)
  618. width = maxw;
  619. mutex_lock(&dev->lock);
  620. if (dev->is_em2800) {
  621. /* the em2800 can only scale down to 50% */
  622. if (height % (maxh / 2))
  623. height = maxh;
  624. if (width % (maxw / 2))
  625. width = maxw;
  626. /* according to empiatech support */
  627. /* the MaxPacketSize is to small to support */
  628. /* framesizes larger than 640x480 @ 30 fps */
  629. /* or 640x576 @ 25 fps. As this would cut */
  630. /* of a part of the image we prefer */
  631. /* 360x576 or 360x480 for now */
  632. if (width == maxw && height == maxh)
  633. width /= 2;
  634. }
  635. get_scale(dev, width, height, &hscale, &vscale);
  636. width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
  637. height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
  638. f->fmt.pix.width = width;
  639. f->fmt.pix.height = height;
  640. f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  641. f->fmt.pix.bytesperline = width * 2;
  642. f->fmt.pix.sizeimage = width * 2 * height;
  643. f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
  644. f->fmt.pix.field = V4L2_FIELD_INTERLACED;
  645. mutex_unlock(&dev->lock);
  646. return 0;
  647. }
  648. static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
  649. struct v4l2_format *f)
  650. {
  651. struct em28xx_fh *fh = priv;
  652. struct em28xx *dev = fh->dev;
  653. int rc;
  654. rc = check_dev(dev);
  655. if (rc < 0)
  656. return rc;
  657. vidioc_try_fmt_vid_cap(file, priv, f);
  658. mutex_lock(&dev->lock);
  659. if (videobuf_queue_is_busy(&fh->vb_vidq)) {
  660. em28xx_errdev("%s queue busy\n", __func__);
  661. rc = -EBUSY;
  662. goto out;
  663. }
  664. if (dev->stream_on && !fh->stream_on) {
  665. em28xx_errdev("%s device in use by another fh\n", __func__);
  666. rc = -EBUSY;
  667. goto out;
  668. }
  669. /* set new image size */
  670. dev->width = f->fmt.pix.width;
  671. dev->height = f->fmt.pix.height;
  672. get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
  673. em28xx_set_alternate(dev);
  674. em28xx_resolution_set(dev);
  675. rc = 0;
  676. out:
  677. mutex_unlock(&dev->lock);
  678. return rc;
  679. }
  680. static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id * norm)
  681. {
  682. struct em28xx_fh *fh = priv;
  683. struct em28xx *dev = fh->dev;
  684. struct v4l2_format f;
  685. int rc;
  686. rc = check_dev(dev);
  687. if (rc < 0)
  688. return rc;
  689. mutex_lock(&dev->lock);
  690. dev->norm = *norm;
  691. mutex_unlock(&dev->lock);
  692. /* Adjusts width/height, if needed */
  693. f.fmt.pix.width = dev->width;
  694. f.fmt.pix.height = dev->height;
  695. vidioc_try_fmt_vid_cap(file, priv, &f);
  696. mutex_lock(&dev->lock);
  697. /* set new image size */
  698. dev->width = f.fmt.pix.width;
  699. dev->height = f.fmt.pix.height;
  700. get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
  701. em28xx_resolution_set(dev);
  702. em28xx_i2c_call_clients(dev, VIDIOC_S_STD, &dev->norm);
  703. mutex_unlock(&dev->lock);
  704. return 0;
  705. }
  706. static const char *iname[] = {
  707. [EM28XX_VMUX_COMPOSITE1] = "Composite1",
  708. [EM28XX_VMUX_COMPOSITE2] = "Composite2",
  709. [EM28XX_VMUX_COMPOSITE3] = "Composite3",
  710. [EM28XX_VMUX_COMPOSITE4] = "Composite4",
  711. [EM28XX_VMUX_SVIDEO] = "S-Video",
  712. [EM28XX_VMUX_TELEVISION] = "Television",
  713. [EM28XX_VMUX_CABLE] = "Cable TV",
  714. [EM28XX_VMUX_DVB] = "DVB",
  715. [EM28XX_VMUX_DEBUG] = "for debug only",
  716. };
  717. static int vidioc_enum_input(struct file *file, void *priv,
  718. struct v4l2_input *i)
  719. {
  720. struct em28xx_fh *fh = priv;
  721. struct em28xx *dev = fh->dev;
  722. unsigned int n;
  723. n = i->index;
  724. if (n >= MAX_EM28XX_INPUT)
  725. return -EINVAL;
  726. if (0 == INPUT(n)->type)
  727. return -EINVAL;
  728. i->index = n;
  729. i->type = V4L2_INPUT_TYPE_CAMERA;
  730. strcpy(i->name, iname[INPUT(n)->type]);
  731. if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
  732. (EM28XX_VMUX_CABLE == INPUT(n)->type))
  733. i->type = V4L2_INPUT_TYPE_TUNER;
  734. i->std = dev->vdev->tvnorms;
  735. return 0;
  736. }
  737. static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
  738. {
  739. struct em28xx_fh *fh = priv;
  740. struct em28xx *dev = fh->dev;
  741. *i = dev->ctl_input;
  742. return 0;
  743. }
  744. static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
  745. {
  746. struct em28xx_fh *fh = priv;
  747. struct em28xx *dev = fh->dev;
  748. int rc;
  749. rc = check_dev(dev);
  750. if (rc < 0)
  751. return rc;
  752. if (i >= MAX_EM28XX_INPUT)
  753. return -EINVAL;
  754. if (0 == INPUT(i)->type)
  755. return -EINVAL;
  756. mutex_lock(&dev->lock);
  757. video_mux(dev, i);
  758. mutex_unlock(&dev->lock);
  759. return 0;
  760. }
  761. static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
  762. {
  763. struct em28xx_fh *fh = priv;
  764. struct em28xx *dev = fh->dev;
  765. unsigned int index = a->index;
  766. if (a->index > 1)
  767. return -EINVAL;
  768. index = dev->ctl_ainput;
  769. if (index == 0)
  770. strcpy(a->name, "Television");
  771. else
  772. strcpy(a->name, "Line In");
  773. a->capability = V4L2_AUDCAP_STEREO;
  774. a->index = index;
  775. return 0;
  776. }
  777. static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
  778. {
  779. struct em28xx_fh *fh = priv;
  780. struct em28xx *dev = fh->dev;
  781. if (a->index != dev->ctl_ainput)
  782. return -EINVAL;
  783. return 0;
  784. }
  785. static int vidioc_queryctrl(struct file *file, void *priv,
  786. struct v4l2_queryctrl *qc)
  787. {
  788. struct em28xx_fh *fh = priv;
  789. struct em28xx *dev = fh->dev;
  790. int id = qc->id;
  791. int i;
  792. int rc;
  793. rc = check_dev(dev);
  794. if (rc < 0)
  795. return rc;
  796. memset(qc, 0, sizeof(*qc));
  797. qc->id = id;
  798. if (!dev->has_msp34xx) {
  799. for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
  800. if (qc->id && qc->id == em28xx_qctrl[i].id) {
  801. memcpy(qc, &(em28xx_qctrl[i]), sizeof(*qc));
  802. return 0;
  803. }
  804. }
  805. }
  806. mutex_lock(&dev->lock);
  807. em28xx_i2c_call_clients(dev, VIDIOC_QUERYCTRL, qc);
  808. mutex_unlock(&dev->lock);
  809. if (qc->type)
  810. return 0;
  811. else
  812. return -EINVAL;
  813. }
  814. static int vidioc_g_ctrl(struct file *file, void *priv,
  815. struct v4l2_control *ctrl)
  816. {
  817. struct em28xx_fh *fh = priv;
  818. struct em28xx *dev = fh->dev;
  819. int rc;
  820. rc = check_dev(dev);
  821. if (rc < 0)
  822. return rc;
  823. mutex_lock(&dev->lock);
  824. if (!dev->has_msp34xx)
  825. rc = em28xx_get_ctrl(dev, ctrl);
  826. else
  827. rc = -EINVAL;
  828. if (rc == -EINVAL) {
  829. em28xx_i2c_call_clients(dev, VIDIOC_G_CTRL, ctrl);
  830. rc = 0;
  831. }
  832. mutex_unlock(&dev->lock);
  833. return rc;
  834. }
  835. static int vidioc_s_ctrl(struct file *file, void *priv,
  836. struct v4l2_control *ctrl)
  837. {
  838. struct em28xx_fh *fh = priv;
  839. struct em28xx *dev = fh->dev;
  840. u8 i;
  841. int rc;
  842. rc = check_dev(dev);
  843. if (rc < 0)
  844. return rc;
  845. mutex_lock(&dev->lock);
  846. if (dev->has_msp34xx)
  847. em28xx_i2c_call_clients(dev, VIDIOC_S_CTRL, ctrl);
  848. else {
  849. rc = 1;
  850. for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
  851. if (ctrl->id == em28xx_qctrl[i].id) {
  852. if (ctrl->value < em28xx_qctrl[i].minimum ||
  853. ctrl->value > em28xx_qctrl[i].maximum) {
  854. rc = -ERANGE;
  855. break;
  856. }
  857. rc = em28xx_set_ctrl(dev, ctrl);
  858. break;
  859. }
  860. }
  861. }
  862. /* Control not found - try to send it to the attached devices */
  863. if (rc == 1) {
  864. em28xx_i2c_call_clients(dev, VIDIOC_S_CTRL, ctrl);
  865. rc = 0;
  866. }
  867. mutex_unlock(&dev->lock);
  868. return rc;
  869. }
  870. static int vidioc_g_tuner(struct file *file, void *priv,
  871. struct v4l2_tuner *t)
  872. {
  873. struct em28xx_fh *fh = priv;
  874. struct em28xx *dev = fh->dev;
  875. int rc;
  876. rc = check_dev(dev);
  877. if (rc < 0)
  878. return rc;
  879. if (0 != t->index)
  880. return -EINVAL;
  881. strcpy(t->name, "Tuner");
  882. mutex_lock(&dev->lock);
  883. em28xx_i2c_call_clients(dev, VIDIOC_G_TUNER, t);
  884. mutex_unlock(&dev->lock);
  885. return 0;
  886. }
  887. static int vidioc_s_tuner(struct file *file, void *priv,
  888. struct v4l2_tuner *t)
  889. {
  890. struct em28xx_fh *fh = priv;
  891. struct em28xx *dev = fh->dev;
  892. int rc;
  893. rc = check_dev(dev);
  894. if (rc < 0)
  895. return rc;
  896. if (0 != t->index)
  897. return -EINVAL;
  898. mutex_lock(&dev->lock);
  899. em28xx_i2c_call_clients(dev, VIDIOC_S_TUNER, t);
  900. mutex_unlock(&dev->lock);
  901. return 0;
  902. }
  903. static int vidioc_g_frequency(struct file *file, void *priv,
  904. struct v4l2_frequency *f)
  905. {
  906. struct em28xx_fh *fh = priv;
  907. struct em28xx *dev = fh->dev;
  908. f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
  909. f->frequency = dev->ctl_freq;
  910. return 0;
  911. }
  912. static int vidioc_s_frequency(struct file *file, void *priv,
  913. struct v4l2_frequency *f)
  914. {
  915. struct em28xx_fh *fh = priv;
  916. struct em28xx *dev = fh->dev;
  917. int rc;
  918. rc = check_dev(dev);
  919. if (rc < 0)
  920. return rc;
  921. if (0 != f->tuner)
  922. return -EINVAL;
  923. if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV))
  924. return -EINVAL;
  925. if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO))
  926. return -EINVAL;
  927. mutex_lock(&dev->lock);
  928. dev->ctl_freq = f->frequency;
  929. em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, f);
  930. mutex_unlock(&dev->lock);
  931. return 0;
  932. }
  933. #ifdef CONFIG_VIDEO_ADV_DEBUG
  934. static int em28xx_reg_len(int reg)
  935. {
  936. switch (reg) {
  937. case EM28XX_R40_AC97LSB:
  938. case EM28XX_R30_HSCALELOW:
  939. case EM28XX_R32_VSCALELOW:
  940. return 2;
  941. default:
  942. return 1;
  943. }
  944. }
  945. static int vidioc_g_register(struct file *file, void *priv,
  946. struct v4l2_register *reg)
  947. {
  948. struct em28xx_fh *fh = priv;
  949. struct em28xx *dev = fh->dev;
  950. int ret;
  951. if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
  952. return -EINVAL;
  953. if (em28xx_reg_len(reg->reg) == 1) {
  954. ret = em28xx_read_reg(dev, reg->reg);
  955. if (ret < 0)
  956. return ret;
  957. reg->val = ret;
  958. } else {
  959. __le64 val = 0;
  960. ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
  961. reg->reg, (char *)&val, 2);
  962. if (ret < 0)
  963. return ret;
  964. reg->val = le64_to_cpu(val);
  965. }
  966. return 0;
  967. }
  968. static int vidioc_s_register(struct file *file, void *priv,
  969. struct v4l2_register *reg)
  970. {
  971. struct em28xx_fh *fh = priv;
  972. struct em28xx *dev = fh->dev;
  973. __le64 buf;
  974. buf = cpu_to_le64(reg->val);
  975. return em28xx_write_regs(dev, reg->reg, (char *)&buf,
  976. em28xx_reg_len(reg->reg));
  977. }
  978. #endif
  979. static int vidioc_cropcap(struct file *file, void *priv,
  980. struct v4l2_cropcap *cc)
  981. {
  982. struct em28xx_fh *fh = priv;
  983. struct em28xx *dev = fh->dev;
  984. if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  985. return -EINVAL;
  986. cc->bounds.left = 0;
  987. cc->bounds.top = 0;
  988. cc->bounds.width = dev->width;
  989. cc->bounds.height = dev->height;
  990. cc->defrect = cc->bounds;
  991. cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */
  992. cc->pixelaspect.denominator = 59;
  993. return 0;
  994. }
  995. static int vidioc_streamon(struct file *file, void *priv,
  996. enum v4l2_buf_type type)
  997. {
  998. struct em28xx_fh *fh = priv;
  999. struct em28xx *dev = fh->dev;
  1000. int rc;
  1001. rc = check_dev(dev);
  1002. if (rc < 0)
  1003. return rc;
  1004. if (unlikely(res_get(fh) < 0))
  1005. return -EBUSY;
  1006. return (videobuf_streamon(&fh->vb_vidq));
  1007. }
  1008. static int vidioc_streamoff(struct file *file, void *priv,
  1009. enum v4l2_buf_type type)
  1010. {
  1011. struct em28xx_fh *fh = priv;
  1012. struct em28xx *dev = fh->dev;
  1013. int rc;
  1014. rc = check_dev(dev);
  1015. if (rc < 0)
  1016. return rc;
  1017. if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  1018. return -EINVAL;
  1019. if (type != fh->type)
  1020. return -EINVAL;
  1021. videobuf_streamoff(&fh->vb_vidq);
  1022. res_free(fh);
  1023. return 0;
  1024. }
  1025. static int vidioc_querycap(struct file *file, void *priv,
  1026. struct v4l2_capability *cap)
  1027. {
  1028. struct em28xx_fh *fh = priv;
  1029. struct em28xx *dev = fh->dev;
  1030. strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
  1031. strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
  1032. strlcpy(cap->bus_info, dev_name(&dev->udev->dev), sizeof(cap->bus_info));
  1033. cap->version = EM28XX_VERSION_CODE;
  1034. cap->capabilities =
  1035. V4L2_CAP_SLICED_VBI_CAPTURE |
  1036. V4L2_CAP_VIDEO_CAPTURE |
  1037. V4L2_CAP_AUDIO |
  1038. V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
  1039. if (dev->tuner_type != TUNER_ABSENT)
  1040. cap->capabilities |= V4L2_CAP_TUNER;
  1041. return 0;
  1042. }
  1043. static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
  1044. struct v4l2_fmtdesc *fmtd)
  1045. {
  1046. if (fmtd->index != 0)
  1047. return -EINVAL;
  1048. fmtd->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1049. strcpy(fmtd->description, "Packed YUY2");
  1050. fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
  1051. memset(fmtd->reserved, 0, sizeof(fmtd->reserved));
  1052. return 0;
  1053. }
  1054. /* Sliced VBI ioctls */
  1055. static int vidioc_g_fmt_sliced_vbi_cap(struct file *file, void *priv,
  1056. struct v4l2_format *f)
  1057. {
  1058. struct em28xx_fh *fh = priv;
  1059. struct em28xx *dev = fh->dev;
  1060. int rc;
  1061. rc = check_dev(dev);
  1062. if (rc < 0)
  1063. return rc;
  1064. mutex_lock(&dev->lock);
  1065. f->fmt.sliced.service_set = 0;
  1066. em28xx_i2c_call_clients(dev, VIDIOC_G_FMT, f);
  1067. if (f->fmt.sliced.service_set == 0)
  1068. rc = -EINVAL;
  1069. mutex_unlock(&dev->lock);
  1070. return rc;
  1071. }
  1072. static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv,
  1073. struct v4l2_format *f)
  1074. {
  1075. struct em28xx_fh *fh = priv;
  1076. struct em28xx *dev = fh->dev;
  1077. int rc;
  1078. rc = check_dev(dev);
  1079. if (rc < 0)
  1080. return rc;
  1081. mutex_lock(&dev->lock);
  1082. em28xx_i2c_call_clients(dev, VIDIOC_G_FMT, f);
  1083. mutex_unlock(&dev->lock);
  1084. if (f->fmt.sliced.service_set == 0)
  1085. return -EINVAL;
  1086. return 0;
  1087. }
  1088. static int vidioc_reqbufs(struct file *file, void *priv,
  1089. struct v4l2_requestbuffers *rb)
  1090. {
  1091. struct em28xx_fh *fh = priv;
  1092. struct em28xx *dev = fh->dev;
  1093. int rc;
  1094. rc = check_dev(dev);
  1095. if (rc < 0)
  1096. return rc;
  1097. return (videobuf_reqbufs(&fh->vb_vidq, rb));
  1098. }
  1099. static int vidioc_querybuf(struct file *file, void *priv,
  1100. struct v4l2_buffer *b)
  1101. {
  1102. struct em28xx_fh *fh = priv;
  1103. struct em28xx *dev = fh->dev;
  1104. int rc;
  1105. rc = check_dev(dev);
  1106. if (rc < 0)
  1107. return rc;
  1108. return (videobuf_querybuf(&fh->vb_vidq, b));
  1109. }
  1110. static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
  1111. {
  1112. struct em28xx_fh *fh = priv;
  1113. struct em28xx *dev = fh->dev;
  1114. int rc;
  1115. rc = check_dev(dev);
  1116. if (rc < 0)
  1117. return rc;
  1118. return (videobuf_qbuf(&fh->vb_vidq, b));
  1119. }
  1120. static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
  1121. {
  1122. struct em28xx_fh *fh = priv;
  1123. struct em28xx *dev = fh->dev;
  1124. int rc;
  1125. rc = check_dev(dev);
  1126. if (rc < 0)
  1127. return rc;
  1128. return (videobuf_dqbuf(&fh->vb_vidq, b,
  1129. file->f_flags & O_NONBLOCK));
  1130. }
  1131. #ifdef CONFIG_VIDEO_V4L1_COMPAT
  1132. static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
  1133. {
  1134. struct em28xx_fh *fh = priv;
  1135. return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
  1136. }
  1137. #endif
  1138. /* ----------------------------------------------------------- */
  1139. /* RADIO ESPECIFIC IOCTLS */
  1140. /* ----------------------------------------------------------- */
  1141. static int radio_querycap(struct file *file, void *priv,
  1142. struct v4l2_capability *cap)
  1143. {
  1144. struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
  1145. strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
  1146. strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
  1147. strlcpy(cap->bus_info, dev_name(&dev->udev->dev), sizeof(cap->bus_info));
  1148. cap->version = EM28XX_VERSION_CODE;
  1149. cap->capabilities = V4L2_CAP_TUNER;
  1150. return 0;
  1151. }
  1152. static int radio_g_tuner(struct file *file, void *priv,
  1153. struct v4l2_tuner *t)
  1154. {
  1155. struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
  1156. if (unlikely(t->index > 0))
  1157. return -EINVAL;
  1158. strcpy(t->name, "Radio");
  1159. t->type = V4L2_TUNER_RADIO;
  1160. em28xx_i2c_call_clients(dev, VIDIOC_G_TUNER, t);
  1161. return 0;
  1162. }
  1163. static int radio_enum_input(struct file *file, void *priv,
  1164. struct v4l2_input *i)
  1165. {
  1166. if (i->index != 0)
  1167. return -EINVAL;
  1168. strcpy(i->name, "Radio");
  1169. i->type = V4L2_INPUT_TYPE_TUNER;
  1170. return 0;
  1171. }
  1172. static int radio_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
  1173. {
  1174. if (unlikely(a->index))
  1175. return -EINVAL;
  1176. strcpy(a->name, "Radio");
  1177. return 0;
  1178. }
  1179. static int radio_s_tuner(struct file *file, void *priv,
  1180. struct v4l2_tuner *t)
  1181. {
  1182. struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
  1183. if (0 != t->index)
  1184. return -EINVAL;
  1185. em28xx_i2c_call_clients(dev, VIDIOC_S_TUNER, t);
  1186. return 0;
  1187. }
  1188. static int radio_s_audio(struct file *file, void *fh,
  1189. struct v4l2_audio *a)
  1190. {
  1191. return 0;
  1192. }
  1193. static int radio_s_input(struct file *file, void *fh, unsigned int i)
  1194. {
  1195. return 0;
  1196. }
  1197. static int radio_queryctrl(struct file *file, void *priv,
  1198. struct v4l2_queryctrl *qc)
  1199. {
  1200. int i;
  1201. if (qc->id < V4L2_CID_BASE ||
  1202. qc->id >= V4L2_CID_LASTP1)
  1203. return -EINVAL;
  1204. for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
  1205. if (qc->id && qc->id == em28xx_qctrl[i].id) {
  1206. memcpy(qc, &(em28xx_qctrl[i]), sizeof(*qc));
  1207. return 0;
  1208. }
  1209. }
  1210. return -EINVAL;
  1211. }
  1212. /*
  1213. * em28xx_v4l2_open()
  1214. * inits the device and starts isoc transfer
  1215. */
  1216. static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
  1217. {
  1218. int minor = iminor(inode);
  1219. int errCode = 0, radio = 0;
  1220. struct em28xx *h, *dev = NULL;
  1221. struct em28xx_fh *fh;
  1222. enum v4l2_buf_type fh_type = 0;
  1223. mutex_lock(&em28xx_devlist_mutex);
  1224. list_for_each_entry(h, &em28xx_devlist, devlist) {
  1225. if (h->vdev->minor == minor) {
  1226. dev = h;
  1227. fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  1228. }
  1229. if (h->vbi_dev->minor == minor) {
  1230. dev = h;
  1231. fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
  1232. }
  1233. if (h->radio_dev &&
  1234. h->radio_dev->minor == minor) {
  1235. radio = 1;
  1236. dev = h;
  1237. }
  1238. }
  1239. mutex_unlock(&em28xx_devlist_mutex);
  1240. if (NULL == dev)
  1241. return -ENODEV;
  1242. mutex_lock(&dev->lock);
  1243. em28xx_videodbg("open minor=%d type=%s users=%d\n",
  1244. minor, v4l2_type_names[fh_type], dev->users);
  1245. fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL);
  1246. if (!fh) {
  1247. em28xx_errdev("em28xx-video.c: Out of memory?!\n");
  1248. mutex_unlock(&dev->lock);
  1249. return -ENOMEM;
  1250. }
  1251. fh->dev = dev;
  1252. fh->radio = radio;
  1253. fh->type = fh_type;
  1254. filp->private_data = fh;
  1255. if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
  1256. dev->width = norm_maxw(dev);
  1257. dev->height = norm_maxh(dev);
  1258. dev->hscale = 0;
  1259. dev->vscale = 0;
  1260. em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
  1261. em28xx_set_alternate(dev);
  1262. em28xx_resolution_set(dev);
  1263. /* Needed, since GPIO might have disabled power of
  1264. some i2c device
  1265. */
  1266. em28xx_config_i2c(dev);
  1267. }
  1268. if (fh->radio) {
  1269. em28xx_videodbg("video_open: setting radio device\n");
  1270. em28xx_i2c_call_clients(dev, AUDC_SET_RADIO, NULL);
  1271. }
  1272. dev->users++;
  1273. videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops,
  1274. NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
  1275. sizeof(struct em28xx_buffer), fh);
  1276. mutex_unlock(&dev->lock);
  1277. return errCode;
  1278. }
  1279. /*
  1280. * em28xx_realease_resources()
  1281. * unregisters the v4l2,i2c and usb devices
  1282. * called when the device gets disconected or at module unload
  1283. */
  1284. static void em28xx_release_resources(struct em28xx *dev)
  1285. {
  1286. /*FIXME: I2C IR should be disconnected */
  1287. list_del(&dev->devlist);
  1288. if (dev->sbutton_input_dev)
  1289. em28xx_deregister_snapshot_button(dev);
  1290. if (dev->ir)
  1291. em28xx_ir_fini(dev);
  1292. if (dev->radio_dev) {
  1293. if (-1 != dev->radio_dev->minor)
  1294. video_unregister_device(dev->radio_dev);
  1295. else
  1296. video_device_release(dev->radio_dev);
  1297. dev->radio_dev = NULL;
  1298. }
  1299. if (dev->vbi_dev) {
  1300. em28xx_info("V4L2 device /dev/vbi%d deregistered\n",
  1301. dev->vbi_dev->num);
  1302. if (-1 != dev->vbi_dev->minor)
  1303. video_unregister_device(dev->vbi_dev);
  1304. else
  1305. video_device_release(dev->vbi_dev);
  1306. dev->vbi_dev = NULL;
  1307. }
  1308. if (dev->vdev) {
  1309. em28xx_info("V4L2 device /dev/video%d deregistered\n",
  1310. dev->vdev->num);
  1311. if (-1 != dev->vdev->minor)
  1312. video_unregister_device(dev->vdev);
  1313. else
  1314. video_device_release(dev->vdev);
  1315. dev->vdev = NULL;
  1316. }
  1317. em28xx_i2c_unregister(dev);
  1318. usb_put_dev(dev->udev);
  1319. /* Mark device as unused */
  1320. em28xx_devused &= ~(1<<dev->devno);
  1321. }
  1322. /*
  1323. * em28xx_v4l2_close()
  1324. * stops streaming and deallocates all resources allocated by the v4l2
  1325. * calls and ioctls
  1326. */
  1327. static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
  1328. {
  1329. struct em28xx_fh *fh = filp->private_data;
  1330. struct em28xx *dev = fh->dev;
  1331. int errCode;
  1332. em28xx_videodbg("users=%d\n", dev->users);
  1333. if (res_check(fh))
  1334. res_free(fh);
  1335. mutex_lock(&dev->lock);
  1336. if (dev->users == 1) {
  1337. videobuf_stop(&fh->vb_vidq);
  1338. videobuf_mmap_free(&fh->vb_vidq);
  1339. /* the device is already disconnect,
  1340. free the remaining resources */
  1341. if (dev->state & DEV_DISCONNECTED) {
  1342. em28xx_release_resources(dev);
  1343. mutex_unlock(&dev->lock);
  1344. kfree(dev);
  1345. return 0;
  1346. }
  1347. /* do this before setting alternate! */
  1348. em28xx_uninit_isoc(dev);
  1349. em28xx_set_mode(dev, EM28XX_MODE_UNDEFINED);
  1350. /* set alternate 0 */
  1351. dev->alt = 0;
  1352. em28xx_videodbg("setting alternate 0\n");
  1353. errCode = usb_set_interface(dev->udev, 0, 0);
  1354. if (errCode < 0) {
  1355. em28xx_errdev("cannot change alternate number to "
  1356. "0 (error=%i)\n", errCode);
  1357. }
  1358. }
  1359. kfree(fh);
  1360. dev->users--;
  1361. wake_up_interruptible_nr(&dev->open, 1);
  1362. mutex_unlock(&dev->lock);
  1363. return 0;
  1364. }
  1365. /*
  1366. * em28xx_v4l2_read()
  1367. * will allocate buffers when called for the first time
  1368. */
  1369. static ssize_t
  1370. em28xx_v4l2_read(struct file *filp, char __user *buf, size_t count,
  1371. loff_t *pos)
  1372. {
  1373. struct em28xx_fh *fh = filp->private_data;
  1374. struct em28xx *dev = fh->dev;
  1375. int rc;
  1376. rc = check_dev(dev);
  1377. if (rc < 0)
  1378. return rc;
  1379. /* FIXME: read() is not prepared to allow changing the video
  1380. resolution while streaming. Seems a bug at em28xx_set_fmt
  1381. */
  1382. if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
  1383. if (unlikely(res_get(fh)))
  1384. return -EBUSY;
  1385. return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
  1386. filp->f_flags & O_NONBLOCK);
  1387. }
  1388. return 0;
  1389. }
  1390. /*
  1391. * em28xx_v4l2_poll()
  1392. * will allocate buffers when called for the first time
  1393. */
  1394. static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
  1395. {
  1396. struct em28xx_fh *fh = filp->private_data;
  1397. struct em28xx *dev = fh->dev;
  1398. int rc;
  1399. rc = check_dev(dev);
  1400. if (rc < 0)
  1401. return rc;
  1402. if (unlikely(res_get(fh) < 0))
  1403. return POLLERR;
  1404. if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
  1405. return POLLERR;
  1406. return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
  1407. }
  1408. /*
  1409. * em28xx_v4l2_mmap()
  1410. */
  1411. static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
  1412. {
  1413. struct em28xx_fh *fh = filp->private_data;
  1414. struct em28xx *dev = fh->dev;
  1415. int rc;
  1416. if (unlikely(res_get(fh) < 0))
  1417. return -EBUSY;
  1418. rc = check_dev(dev);
  1419. if (rc < 0)
  1420. return rc;
  1421. rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
  1422. em28xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n",
  1423. (unsigned long)vma->vm_start,
  1424. (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
  1425. rc);
  1426. return rc;
  1427. }
  1428. static const struct file_operations em28xx_v4l_fops = {
  1429. .owner = THIS_MODULE,
  1430. .open = em28xx_v4l2_open,
  1431. .release = em28xx_v4l2_close,
  1432. .read = em28xx_v4l2_read,
  1433. .poll = em28xx_v4l2_poll,
  1434. .mmap = em28xx_v4l2_mmap,
  1435. .ioctl = video_ioctl2,
  1436. .llseek = no_llseek,
  1437. .compat_ioctl = v4l_compat_ioctl32,
  1438. };
  1439. static const struct v4l2_ioctl_ops video_ioctl_ops = {
  1440. .vidioc_querycap = vidioc_querycap,
  1441. .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
  1442. .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
  1443. .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
  1444. .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
  1445. .vidioc_g_audio = vidioc_g_audio,
  1446. .vidioc_s_audio = vidioc_s_audio,
  1447. .vidioc_cropcap = vidioc_cropcap,
  1448. .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
  1449. .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
  1450. .vidioc_s_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
  1451. .vidioc_reqbufs = vidioc_reqbufs,
  1452. .vidioc_querybuf = vidioc_querybuf,
  1453. .vidioc_qbuf = vidioc_qbuf,
  1454. .vidioc_dqbuf = vidioc_dqbuf,
  1455. .vidioc_s_std = vidioc_s_std,
  1456. .vidioc_enum_input = vidioc_enum_input,
  1457. .vidioc_g_input = vidioc_g_input,
  1458. .vidioc_s_input = vidioc_s_input,
  1459. .vidioc_queryctrl = vidioc_queryctrl,
  1460. .vidioc_g_ctrl = vidioc_g_ctrl,
  1461. .vidioc_s_ctrl = vidioc_s_ctrl,
  1462. .vidioc_streamon = vidioc_streamon,
  1463. .vidioc_streamoff = vidioc_streamoff,
  1464. .vidioc_g_tuner = vidioc_g_tuner,
  1465. .vidioc_s_tuner = vidioc_s_tuner,
  1466. .vidioc_g_frequency = vidioc_g_frequency,
  1467. .vidioc_s_frequency = vidioc_s_frequency,
  1468. #ifdef CONFIG_VIDEO_ADV_DEBUG
  1469. .vidioc_g_register = vidioc_g_register,
  1470. .vidioc_s_register = vidioc_s_register,
  1471. #endif
  1472. #ifdef CONFIG_VIDEO_V4L1_COMPAT
  1473. .vidiocgmbuf = vidiocgmbuf,
  1474. #endif
  1475. };
  1476. static const struct video_device em28xx_video_template = {
  1477. .fops = &em28xx_v4l_fops,
  1478. .release = video_device_release,
  1479. .ioctl_ops = &video_ioctl_ops,
  1480. .minor = -1,
  1481. .tvnorms = V4L2_STD_ALL,
  1482. .current_norm = V4L2_STD_PAL,
  1483. };
  1484. static const struct file_operations radio_fops = {
  1485. .owner = THIS_MODULE,
  1486. .open = em28xx_v4l2_open,
  1487. .release = em28xx_v4l2_close,
  1488. .ioctl = video_ioctl2,
  1489. .compat_ioctl = v4l_compat_ioctl32,
  1490. .llseek = no_llseek,
  1491. };
  1492. static const struct v4l2_ioctl_ops radio_ioctl_ops = {
  1493. .vidioc_querycap = radio_querycap,
  1494. .vidioc_g_tuner = radio_g_tuner,
  1495. .vidioc_enum_input = radio_enum_input,
  1496. .vidioc_g_audio = radio_g_audio,
  1497. .vidioc_s_tuner = radio_s_tuner,
  1498. .vidioc_s_audio = radio_s_audio,
  1499. .vidioc_s_input = radio_s_input,
  1500. .vidioc_queryctrl = radio_queryctrl,
  1501. .vidioc_g_ctrl = vidioc_g_ctrl,
  1502. .vidioc_s_ctrl = vidioc_s_ctrl,
  1503. .vidioc_g_frequency = vidioc_g_frequency,
  1504. .vidioc_s_frequency = vidioc_s_frequency,
  1505. #ifdef CONFIG_VIDEO_ADV_DEBUG
  1506. .vidioc_g_register = vidioc_g_register,
  1507. .vidioc_s_register = vidioc_s_register,
  1508. #endif
  1509. };
  1510. static struct video_device em28xx_radio_template = {
  1511. .name = "em28xx-radio",
  1512. .fops = &radio_fops,
  1513. .ioctl_ops = &radio_ioctl_ops,
  1514. .minor = -1,
  1515. };
  1516. /******************************** usb interface ******************************/
  1517. static LIST_HEAD(em28xx_extension_devlist);
  1518. static DEFINE_MUTEX(em28xx_extension_devlist_lock);
  1519. int em28xx_register_extension(struct em28xx_ops *ops)
  1520. {
  1521. struct em28xx *dev = NULL;
  1522. mutex_lock(&em28xx_devlist_mutex);
  1523. mutex_lock(&em28xx_extension_devlist_lock);
  1524. list_add_tail(&ops->next, &em28xx_extension_devlist);
  1525. list_for_each_entry(dev, &em28xx_devlist, devlist) {
  1526. if (dev)
  1527. ops->init(dev);
  1528. }
  1529. printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
  1530. mutex_unlock(&em28xx_extension_devlist_lock);
  1531. mutex_unlock(&em28xx_devlist_mutex);
  1532. return 0;
  1533. }
  1534. EXPORT_SYMBOL(em28xx_register_extension);
  1535. void em28xx_unregister_extension(struct em28xx_ops *ops)
  1536. {
  1537. struct em28xx *dev = NULL;
  1538. mutex_lock(&em28xx_devlist_mutex);
  1539. list_for_each_entry(dev, &em28xx_devlist, devlist) {
  1540. if (dev)
  1541. ops->fini(dev);
  1542. }
  1543. mutex_lock(&em28xx_extension_devlist_lock);
  1544. printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
  1545. list_del(&ops->next);
  1546. mutex_unlock(&em28xx_extension_devlist_lock);
  1547. mutex_unlock(&em28xx_devlist_mutex);
  1548. }
  1549. EXPORT_SYMBOL(em28xx_unregister_extension);
  1550. static struct video_device *em28xx_vdev_init(struct em28xx *dev,
  1551. const struct video_device *template,
  1552. const char *type_name)
  1553. {
  1554. struct video_device *vfd;
  1555. vfd = video_device_alloc();
  1556. if (NULL == vfd)
  1557. return NULL;
  1558. *vfd = *template;
  1559. vfd->minor = -1;
  1560. vfd->parent = &dev->udev->dev;
  1561. vfd->release = video_device_release;
  1562. vfd->debug = video_debug;
  1563. snprintf(vfd->name, sizeof(vfd->name), "%s %s",
  1564. dev->name, type_name);
  1565. return vfd;
  1566. }
  1567. static int register_analog_devices(struct em28xx *dev)
  1568. {
  1569. int ret;
  1570. /* allocate and fill video video_device struct */
  1571. dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video");
  1572. if (!dev->vdev) {
  1573. em28xx_errdev("cannot allocate video_device.\n");
  1574. return -ENODEV;
  1575. }
  1576. /* register v4l2 video video_device */
  1577. ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
  1578. video_nr[dev->devno]);
  1579. if (ret) {
  1580. em28xx_errdev("unable to register video device (error=%i).\n",
  1581. ret);
  1582. return ret;
  1583. }
  1584. /* Allocate and fill vbi video_device struct */
  1585. dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template, "vbi");
  1586. /* register v4l2 vbi video_device */
  1587. ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
  1588. vbi_nr[dev->devno]);
  1589. if (ret < 0) {
  1590. em28xx_errdev("unable to register vbi device\n");
  1591. return ret;
  1592. }
  1593. if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
  1594. dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template, "radio");
  1595. if (!dev->radio_dev) {
  1596. em28xx_errdev("cannot allocate video_device.\n");
  1597. return -ENODEV;
  1598. }
  1599. ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
  1600. radio_nr[dev->devno]);
  1601. if (ret < 0) {
  1602. em28xx_errdev("can't register radio device\n");
  1603. return ret;
  1604. }
  1605. em28xx_info("Registered radio device as /dev/radio%d\n",
  1606. dev->radio_dev->num);
  1607. }
  1608. em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n",
  1609. dev->vdev->num, dev->vbi_dev->num);
  1610. return 0;
  1611. }
  1612. /*
  1613. * em28xx_init_dev()
  1614. * allocates and inits the device structs, registers i2c bus and v4l device
  1615. */
  1616. static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
  1617. int minor)
  1618. {
  1619. struct em28xx_ops *ops = NULL;
  1620. struct em28xx *dev = *devhandle;
  1621. int retval = -ENOMEM;
  1622. int errCode;
  1623. unsigned int maxh, maxw;
  1624. dev->udev = udev;
  1625. mutex_init(&dev->lock);
  1626. mutex_init(&dev->ctrl_urb_lock);
  1627. spin_lock_init(&dev->slock);
  1628. init_waitqueue_head(&dev->open);
  1629. init_waitqueue_head(&dev->wait_frame);
  1630. init_waitqueue_head(&dev->wait_stream);
  1631. dev->em28xx_write_regs = em28xx_write_regs;
  1632. dev->em28xx_read_reg = em28xx_read_reg;
  1633. dev->em28xx_read_reg_req_len = em28xx_read_reg_req_len;
  1634. dev->em28xx_write_regs_req = em28xx_write_regs_req;
  1635. dev->em28xx_read_reg_req = em28xx_read_reg_req;
  1636. dev->is_em2800 = em28xx_boards[dev->model].is_em2800;
  1637. em28xx_pre_card_setup(dev);
  1638. errCode = em28xx_config(dev);
  1639. if (errCode) {
  1640. em28xx_errdev("error configuring device\n");
  1641. return -ENOMEM;
  1642. }
  1643. /* register i2c bus */
  1644. errCode = em28xx_i2c_register(dev);
  1645. if (errCode < 0) {
  1646. em28xx_errdev("%s: em28xx_i2c_register - errCode [%d]!\n",
  1647. __func__, errCode);
  1648. return errCode;
  1649. }
  1650. /* Do board specific init and eeprom reading */
  1651. em28xx_card_setup(dev);
  1652. /* Configure audio */
  1653. errCode = em28xx_audio_setup(dev);
  1654. if (errCode < 0) {
  1655. em28xx_errdev("%s: Error while setting audio - errCode [%d]!\n",
  1656. __func__, errCode);
  1657. }
  1658. /* configure the device */
  1659. em28xx_config_i2c(dev);
  1660. /* set default norm */
  1661. dev->norm = em28xx_video_template.current_norm;
  1662. maxw = norm_maxw(dev);
  1663. maxh = norm_maxh(dev);
  1664. /* set default image size */
  1665. dev->width = maxw;
  1666. dev->height = maxh;
  1667. dev->interlaced = EM28XX_INTERLACED_DEFAULT;
  1668. dev->hscale = 0;
  1669. dev->vscale = 0;
  1670. dev->ctl_input = 2;
  1671. errCode = em28xx_config(dev);
  1672. if (errCode < 0) {
  1673. em28xx_errdev("%s: em28xx_config - errCode [%d]!\n",
  1674. __func__, errCode);
  1675. return errCode;
  1676. }
  1677. /* init video dma queues */
  1678. INIT_LIST_HEAD(&dev->vidq.active);
  1679. INIT_LIST_HEAD(&dev->vidq.queued);
  1680. if (dev->has_msp34xx) {
  1681. /* Send a reset to other chips via gpio */
  1682. errCode = em28xx_write_regs_req(dev, 0x00, 0x08, "\xf7", 1);
  1683. if (errCode < 0) {
  1684. em28xx_errdev("%s: em28xx_write_regs_req - msp34xx(1) failed! errCode [%d]\n",
  1685. __func__, errCode);
  1686. return errCode;
  1687. }
  1688. msleep(3);
  1689. errCode = em28xx_write_regs_req(dev, 0x00, 0x08, "\xff", 1);
  1690. if (errCode < 0) {
  1691. em28xx_errdev("%s: em28xx_write_regs_req - msp34xx(2) failed! errCode [%d]\n",
  1692. __func__, errCode);
  1693. return errCode;
  1694. }
  1695. msleep(3);
  1696. }
  1697. video_mux(dev, 0);
  1698. mutex_lock(&em28xx_devlist_mutex);
  1699. list_add_tail(&dev->devlist, &em28xx_devlist);
  1700. retval = register_analog_devices(dev);
  1701. if (retval < 0) {
  1702. em28xx_release_resources(dev);
  1703. mutex_unlock(&em28xx_devlist_mutex);
  1704. goto fail_reg_devices;
  1705. }
  1706. mutex_lock(&em28xx_extension_devlist_lock);
  1707. if (!list_empty(&em28xx_extension_devlist)) {
  1708. list_for_each_entry(ops, &em28xx_extension_devlist, next) {
  1709. if (ops->id)
  1710. ops->init(dev);
  1711. }
  1712. }
  1713. mutex_unlock(&em28xx_extension_devlist_lock);
  1714. mutex_unlock(&em28xx_devlist_mutex);
  1715. return 0;
  1716. fail_reg_devices:
  1717. mutex_unlock(&dev->lock);
  1718. return retval;
  1719. }
  1720. #if defined(CONFIG_MODULES) && defined(MODULE)
  1721. static void request_module_async(struct work_struct *work)
  1722. {
  1723. struct em28xx *dev = container_of(work,
  1724. struct em28xx, request_module_wk);
  1725. if (dev->has_audio_class)
  1726. request_module("snd-usb-audio");
  1727. else if (dev->has_alsa_audio)
  1728. request_module("em28xx-alsa");
  1729. if (dev->has_dvb)
  1730. request_module("em28xx-dvb");
  1731. }
  1732. static void request_modules(struct em28xx *dev)
  1733. {
  1734. INIT_WORK(&dev->request_module_wk, request_module_async);
  1735. schedule_work(&dev->request_module_wk);
  1736. }
  1737. #else
  1738. #define request_modules(dev)
  1739. #endif /* CONFIG_MODULES */
  1740. /*
  1741. * em28xx_usb_probe()
  1742. * checks for supported devices
  1743. */
  1744. static int em28xx_usb_probe(struct usb_interface *interface,
  1745. const struct usb_device_id *id)
  1746. {
  1747. const struct usb_endpoint_descriptor *endpoint;
  1748. struct usb_device *udev;
  1749. struct usb_interface *uif;
  1750. struct em28xx *dev = NULL;
  1751. int retval = -ENODEV;
  1752. int i, nr, ifnum, isoc_pipe;
  1753. udev = usb_get_dev(interface_to_usbdev(interface));
  1754. ifnum = interface->altsetting[0].desc.bInterfaceNumber;
  1755. /* Check to see next free device and mark as used */
  1756. nr = find_first_zero_bit(&em28xx_devused, EM28XX_MAXBOARDS);
  1757. em28xx_devused |= 1<<nr;
  1758. /* Don't register audio interfaces */
  1759. if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
  1760. em28xx_err(DRIVER_NAME " audio device (%04x:%04x): interface %i, class %i\n",
  1761. udev->descriptor.idVendor,
  1762. udev->descriptor.idProduct,
  1763. ifnum,
  1764. interface->altsetting[0].desc.bInterfaceClass);
  1765. em28xx_devused &= ~(1<<nr);
  1766. return -ENODEV;
  1767. }
  1768. em28xx_err(DRIVER_NAME " new video device (%04x:%04x): interface %i, class %i\n",
  1769. udev->descriptor.idVendor,
  1770. udev->descriptor.idProduct,
  1771. ifnum,
  1772. interface->altsetting[0].desc.bInterfaceClass);
  1773. endpoint = &interface->cur_altsetting->endpoint[0].desc;
  1774. /* check if the device has the iso in endpoint at the correct place */
  1775. if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
  1776. USB_ENDPOINT_XFER_ISOC &&
  1777. (interface->altsetting[1].endpoint[0].desc.wMaxPacketSize == 940))
  1778. {
  1779. /* It's a newer em2874/em2875 device */
  1780. isoc_pipe = 0;
  1781. } else {
  1782. isoc_pipe = 1;
  1783. endpoint = &interface->cur_altsetting->endpoint[1].desc;
  1784. if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
  1785. USB_ENDPOINT_XFER_ISOC) {
  1786. em28xx_err(DRIVER_NAME " probing error: endpoint is non-ISO endpoint!\n");
  1787. em28xx_devused &= ~(1<<nr);
  1788. return -ENODEV;
  1789. }
  1790. if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) {
  1791. em28xx_err(DRIVER_NAME " probing error: endpoint is ISO OUT endpoint!\n");
  1792. em28xx_devused &= ~(1<<nr);
  1793. return -ENODEV;
  1794. }
  1795. }
  1796. if (nr >= EM28XX_MAXBOARDS) {
  1797. printk(DRIVER_NAME ": Supports only %i em28xx boards.\n",
  1798. EM28XX_MAXBOARDS);
  1799. em28xx_devused &= ~(1<<nr);
  1800. return -ENOMEM;
  1801. }
  1802. /* allocate memory for our device state and initialize it */
  1803. dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  1804. if (dev == NULL) {
  1805. em28xx_err(DRIVER_NAME ": out of memory!\n");
  1806. em28xx_devused &= ~(1<<nr);
  1807. return -ENOMEM;
  1808. }
  1809. snprintf(dev->name, 29, "em28xx #%d", nr);
  1810. dev->devno = nr;
  1811. dev->model = id->driver_info;
  1812. dev->alt = -1;
  1813. /* Checks if audio is provided by some interface */
  1814. for (i = 0; i < udev->config->desc.bNumInterfaces; i++) {
  1815. uif = udev->config->interface[i];
  1816. if (uif->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
  1817. dev->has_audio_class = 1;
  1818. break;
  1819. }
  1820. }
  1821. /* compute alternate max packet sizes */
  1822. uif = udev->actconfig->interface[0];
  1823. dev->num_alt = uif->num_altsetting;
  1824. em28xx_info("Alternate settings: %i\n", dev->num_alt);
  1825. /* dev->alt_max_pkt_size = kmalloc(sizeof(*dev->alt_max_pkt_size)* */
  1826. dev->alt_max_pkt_size = kmalloc(32 * dev->num_alt, GFP_KERNEL);
  1827. if (dev->alt_max_pkt_size == NULL) {
  1828. em28xx_errdev("out of memory!\n");
  1829. em28xx_devused &= ~(1<<nr);
  1830. kfree(dev);
  1831. return -ENOMEM;
  1832. }
  1833. for (i = 0; i < dev->num_alt ; i++) {
  1834. u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[isoc_pipe].desc.
  1835. wMaxPacketSize);
  1836. dev->alt_max_pkt_size[i] =
  1837. (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
  1838. em28xx_info("Alternate setting %i, max size= %i\n", i,
  1839. dev->alt_max_pkt_size[i]);
  1840. }
  1841. if ((card[nr] >= 0) && (card[nr] < em28xx_bcount))
  1842. dev->model = card[nr];
  1843. /* allocate device struct */
  1844. retval = em28xx_init_dev(&dev, udev, nr);
  1845. if (retval) {
  1846. em28xx_devused &= ~(1<<dev->devno);
  1847. kfree(dev);
  1848. return retval;
  1849. }
  1850. em28xx_info("Found %s\n", em28xx_boards[dev->model].name);
  1851. /* save our data pointer in this interface device */
  1852. usb_set_intfdata(interface, dev);
  1853. request_modules(dev);
  1854. return 0;
  1855. }
  1856. /*
  1857. * em28xx_usb_disconnect()
  1858. * called when the device gets diconencted
  1859. * video device will be unregistered on v4l2_close in case it is still open
  1860. */
  1861. static void em28xx_usb_disconnect(struct usb_interface *interface)
  1862. {
  1863. struct em28xx *dev;
  1864. struct em28xx_ops *ops = NULL;
  1865. dev = usb_get_intfdata(interface);
  1866. usb_set_intfdata(interface, NULL);
  1867. if (!dev)
  1868. return;
  1869. em28xx_info("disconnecting %s\n", dev->vdev->name);
  1870. /* wait until all current v4l2 io is finished then deallocate
  1871. resources */
  1872. mutex_lock(&dev->lock);
  1873. wake_up_interruptible_all(&dev->open);
  1874. if (dev->users) {
  1875. em28xx_warn
  1876. ("device /dev/video%d is open! Deregistration and memory "
  1877. "deallocation are deferred on close.\n",
  1878. dev->vdev->num);
  1879. dev->state |= DEV_MISCONFIGURED;
  1880. em28xx_uninit_isoc(dev);
  1881. dev->state |= DEV_DISCONNECTED;
  1882. wake_up_interruptible(&dev->wait_frame);
  1883. wake_up_interruptible(&dev->wait_stream);
  1884. } else {
  1885. dev->state |= DEV_DISCONNECTED;
  1886. em28xx_release_resources(dev);
  1887. }
  1888. mutex_unlock(&dev->lock);
  1889. mutex_lock(&em28xx_extension_devlist_lock);
  1890. if (!list_empty(&em28xx_extension_devlist)) {
  1891. list_for_each_entry(ops, &em28xx_extension_devlist, next) {
  1892. ops->fini(dev);
  1893. }
  1894. }
  1895. mutex_unlock(&em28xx_extension_devlist_lock);
  1896. if (!dev->users) {
  1897. kfree(dev->alt_max_pkt_size);
  1898. kfree(dev);
  1899. }
  1900. }
  1901. static struct usb_driver em28xx_usb_driver = {
  1902. .name = "em28xx",
  1903. .probe = em28xx_usb_probe,
  1904. .disconnect = em28xx_usb_disconnect,
  1905. .id_table = em28xx_id_table,
  1906. };
  1907. static int __init em28xx_module_init(void)
  1908. {
  1909. int result;
  1910. printk(KERN_INFO DRIVER_NAME " v4l2 driver version %d.%d.%d loaded\n",
  1911. (EM28XX_VERSION_CODE >> 16) & 0xff,
  1912. (EM28XX_VERSION_CODE >> 8) & 0xff, EM28XX_VERSION_CODE & 0xff);
  1913. #ifdef SNAPSHOT
  1914. printk(KERN_INFO DRIVER_NAME " snapshot date %04d-%02d-%02d\n",
  1915. SNAPSHOT / 10000, (SNAPSHOT / 100) % 100, SNAPSHOT % 100);
  1916. #endif
  1917. /* register this driver with the USB subsystem */
  1918. result = usb_register(&em28xx_usb_driver);
  1919. if (result)
  1920. em28xx_err(DRIVER_NAME
  1921. " usb_register failed. Error number %d.\n", result);
  1922. return result;
  1923. }
  1924. static void __exit em28xx_module_exit(void)
  1925. {
  1926. /* deregister this driver with the USB subsystem */
  1927. usb_deregister(&em28xx_usb_driver);
  1928. }
  1929. module_init(em28xx_module_init);
  1930. module_exit(em28xx_module_exit);