File: | dev/usb/uvideo.c |
Warning: | line 3056, column 3 Value stored to 'p' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: uvideo.c,v 1.219 2022/10/21 18:29:37 kn Exp $ */ |
2 | |
3 | /* |
4 | * Copyright (c) 2008 Robert Nagy <robert@openbsd.org> |
5 | * Copyright (c) 2008 Marcus Glocker <mglocker@openbsd.org> |
6 | * |
7 | * Permission to use, copy, modify, and distribute this software for any |
8 | * purpose with or without fee is hereby granted, provided that the above |
9 | * copyright notice and this permission notice appear in all copies. |
10 | * |
11 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
12 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
13 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
14 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
15 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
16 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
17 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
18 | */ |
19 | |
20 | #include <sys/param.h> |
21 | #include <sys/systm.h> |
22 | #include <sys/kernel.h> |
23 | #include <sys/malloc.h> |
24 | #include <sys/device.h> |
25 | #include <sys/ioctl.h> |
26 | #include <sys/tty.h> |
27 | #include <sys/fcntl.h> |
28 | #include <sys/lock.h> |
29 | #include <sys/stat.h> |
30 | #include <sys/timeout.h> |
31 | #include <sys/kthread.h> |
32 | #include <sys/stdint.h> |
33 | |
34 | #include <uvm/uvm_extern.h> |
35 | |
36 | #include <machine/bus.h> |
37 | |
38 | #include <dev/usb/usb.h> |
39 | #include <dev/usb/usbdi.h> |
40 | #include <dev/usb/usbdivar.h> |
41 | #include <dev/usb/usbdi_util.h> |
42 | #include <dev/usb/usbdevs.h> |
43 | #include <dev/usb/uvideo.h> |
44 | |
45 | #include <dev/video_if.h> |
46 | |
47 | #ifdef UVIDEO_DEBUG |
48 | int uvideo_debug = 1; |
49 | #define DPRINTF(l, x...) do { if ((l) <= uvideo_debug) printf(x); } while (0) |
50 | #else |
51 | #define DPRINTF(l, x...) |
52 | #endif |
53 | |
54 | #define DEVNAME(_s)((_s)->sc_dev.dv_xname) ((_s)->sc_dev.dv_xname) |
55 | |
56 | #define byteof(x)((x) >> 3) ((x) >> 3) |
57 | #define bitof(x)(1L << ((x) & 0x7)) (1L << ((x) & 0x7)) |
58 | |
59 | struct uvideo_softc { |
60 | struct device sc_dev; |
61 | struct usbd_device *sc_udev; |
62 | int sc_iface; |
63 | int sc_nifaces; |
64 | |
65 | struct device *sc_videodev; |
66 | |
67 | int sc_max_ctrl_size; |
68 | int sc_max_fbuf_size; |
69 | int sc_negotiated_flag; |
70 | int sc_frame_rate; |
71 | |
72 | struct uvideo_frame_buffer sc_frame_buffer; |
73 | |
74 | struct uvideo_mmap sc_mmap[UVIDEO_MAX_BUFFERS8]; |
75 | uint8_t *sc_mmap_buffer; |
76 | size_t sc_mmap_buffer_size; |
77 | q_mmap sc_mmap_q; |
78 | int sc_mmap_count; |
79 | int sc_mmap_flag; |
80 | |
81 | struct vnode *sc_vp; |
82 | struct usb_task sc_task_write; |
83 | |
84 | int sc_nframes; |
85 | struct usb_video_probe_commit sc_desc_probe; |
86 | struct usb_video_header_desc_all sc_desc_vc_header; |
87 | struct usb_video_input_header_desc_all sc_desc_vs_input_header; |
88 | |
89 | #define UVIDEO_MAX_PU8 8 |
90 | int sc_desc_vc_pu_num; |
91 | struct usb_video_vc_processing_desc *sc_desc_vc_pu_cur; |
92 | struct usb_video_vc_processing_desc *sc_desc_vc_pu[UVIDEO_MAX_PU8]; |
93 | |
94 | #define UVIDEO_MAX_FORMAT8 8 |
95 | int sc_fmtgrp_idx; |
96 | int sc_fmtgrp_num; |
97 | struct uvideo_format_group *sc_fmtgrp_cur; |
98 | struct uvideo_format_group sc_fmtgrp[UVIDEO_MAX_FORMAT8]; |
99 | |
100 | #define UVIDEO_MAX_VS_NUM8 8 |
101 | struct uvideo_vs_iface *sc_vs_cur; |
102 | struct uvideo_vs_iface sc_vs_coll[UVIDEO_MAX_VS_NUM8]; |
103 | |
104 | void *sc_uplayer_arg; |
105 | int *sc_uplayer_fsize; |
106 | uint8_t *sc_uplayer_fbuffer; |
107 | void (*sc_uplayer_intr)(void *); |
108 | |
109 | const struct uvideo_devs *sc_quirk; |
110 | usbd_status (*sc_decode_stream_header) |
111 | (struct uvideo_softc *, |
112 | uint8_t *, int); |
113 | }; |
114 | |
115 | int uvideo_open(void *, int, int *, uint8_t *, void (*)(void *), |
116 | void *); |
117 | int uvideo_close(void *); |
118 | int uvideo_match(struct device *, void *, void *); |
119 | void uvideo_attach(struct device *, struct device *, void *); |
120 | void uvideo_attach_hook(struct device *); |
121 | int uvideo_detach(struct device *, int); |
122 | |
123 | usbd_status uvideo_vc_parse_desc(struct uvideo_softc *); |
124 | usbd_status uvideo_vc_parse_desc_header(struct uvideo_softc *, |
125 | const usb_descriptor_t *); |
126 | usbd_status uvideo_vc_parse_desc_pu(struct uvideo_softc *, |
127 | const usb_descriptor_t *); |
128 | usbd_status uvideo_vc_get_ctrl(struct uvideo_softc *, uint8_t *, uint8_t, |
129 | uint8_t, uint16_t, uint16_t); |
130 | usbd_status uvideo_vc_set_ctrl(struct uvideo_softc *, uint8_t *, uint8_t, |
131 | uint8_t, uint16_t, uint16_t); |
132 | int uvideo_find_ctrl(struct uvideo_softc *, int); |
133 | int uvideo_has_ctrl(struct usb_video_vc_processing_desc *, int); |
134 | |
135 | usbd_status uvideo_vs_parse_desc(struct uvideo_softc *, |
136 | usb_config_descriptor_t *); |
137 | usbd_status uvideo_vs_parse_desc_input_header(struct uvideo_softc *, |
138 | const usb_descriptor_t *); |
139 | usbd_status uvideo_vs_parse_desc_format(struct uvideo_softc *); |
140 | usbd_status uvideo_vs_parse_desc_format_mjpeg(struct uvideo_softc *, |
141 | const usb_descriptor_t *); |
142 | usbd_status uvideo_vs_parse_desc_format_uncompressed(struct uvideo_softc *, |
143 | const usb_descriptor_t *); |
144 | usbd_status uvideo_vs_parse_desc_frame(struct uvideo_softc *); |
145 | usbd_status uvideo_vs_parse_desc_frame_sub(struct uvideo_softc *, |
146 | const usb_descriptor_t *); |
147 | usbd_status uvideo_vs_parse_desc_alt(struct uvideo_softc *, int, int, int); |
148 | usbd_status uvideo_vs_set_alt(struct uvideo_softc *, |
149 | struct usbd_interface *, int); |
150 | int uvideo_desc_len(const usb_descriptor_t *, int, int, int, int); |
151 | void uvideo_find_res(struct uvideo_softc *, int, int, int, |
152 | struct uvideo_res *); |
153 | usbd_status uvideo_vs_negotiation(struct uvideo_softc *, int); |
154 | usbd_status uvideo_vs_set_probe(struct uvideo_softc *, uint8_t *); |
155 | usbd_status uvideo_vs_get_probe(struct uvideo_softc *, uint8_t *, uint8_t); |
156 | usbd_status uvideo_vs_set_commit(struct uvideo_softc *, uint8_t *); |
157 | usbd_status uvideo_vs_alloc_frame(struct uvideo_softc *); |
158 | void uvideo_vs_free_frame(struct uvideo_softc *); |
159 | usbd_status uvideo_vs_alloc_isoc(struct uvideo_softc *); |
160 | usbd_status uvideo_vs_alloc_bulk(struct uvideo_softc *); |
161 | void uvideo_vs_free_isoc(struct uvideo_softc *); |
162 | void uvideo_vs_free_bulk(struct uvideo_softc *); |
163 | usbd_status uvideo_vs_open(struct uvideo_softc *); |
164 | void uvideo_vs_close(struct uvideo_softc *); |
165 | usbd_status uvideo_vs_init(struct uvideo_softc *); |
166 | int uvideo_vs_start_bulk(struct uvideo_softc *); |
167 | void uvideo_vs_start_bulk_thread(void *); |
168 | void uvideo_vs_start_isoc(struct uvideo_softc *); |
169 | void uvideo_vs_start_isoc_ixfer(struct uvideo_softc *, |
170 | struct uvideo_isoc_xfer *); |
171 | void uvideo_vs_cb(struct usbd_xfer *, void *, |
172 | usbd_status); |
173 | usbd_status uvideo_vs_decode_stream_header(struct uvideo_softc *, |
174 | uint8_t *, int); |
175 | usbd_status uvideo_vs_decode_stream_header_isight(struct uvideo_softc *, |
176 | uint8_t *, int); |
177 | int uvideo_mmap_queue(struct uvideo_softc *, uint8_t *, int); |
178 | void uvideo_read(struct uvideo_softc *, uint8_t *, int); |
179 | usbd_status uvideo_usb_control(struct uvideo_softc *, uint8_t, uint8_t, |
180 | uint16_t, uint8_t *, size_t); |
181 | |
182 | #ifdef UVIDEO_DEBUG |
183 | #include <sys/namei.h> |
184 | #include <sys/proc.h> |
185 | #include <sys/vnode.h> |
186 | |
187 | void uvideo_dump_desc_all(struct uvideo_softc *); |
188 | void uvideo_dump_desc_vc_header(struct uvideo_softc *, |
189 | const usb_descriptor_t *); |
190 | void uvideo_dump_desc_input_header(struct uvideo_softc *, |
191 | const usb_descriptor_t *); |
192 | void uvideo_dump_desc_input(struct uvideo_softc *, |
193 | const usb_descriptor_t *); |
194 | void uvideo_dump_desc_output(struct uvideo_softc *, |
195 | const usb_descriptor_t *); |
196 | void uvideo_dump_desc_endpoint(struct uvideo_softc *, |
197 | const usb_descriptor_t *); |
198 | void uvideo_dump_desc_iface_assoc(struct uvideo_softc *, |
199 | const usb_descriptor_t *); |
200 | void uvideo_dump_desc_interface(struct uvideo_softc *, |
201 | const usb_descriptor_t *); |
202 | void uvideo_dump_desc_config(struct uvideo_softc *, |
203 | const usb_descriptor_t *); |
204 | void uvideo_dump_desc_cs_endpoint(struct uvideo_softc *, |
205 | const usb_descriptor_t *); |
206 | void uvideo_dump_desc_colorformat(struct uvideo_softc *, |
207 | const usb_descriptor_t *); |
208 | void uvideo_dump_desc_format_mjpeg(struct uvideo_softc *, |
209 | const usb_descriptor_t *); |
210 | void uvideo_dump_desc_format_uncompressed(struct uvideo_softc *, |
211 | const usb_descriptor_t *); |
212 | void uvideo_dump_desc_frame(struct uvideo_softc *, |
213 | const usb_descriptor_t *); |
214 | void uvideo_dump_desc_processing(struct uvideo_softc *, |
215 | const usb_descriptor_t *); |
216 | void uvideo_dump_desc_extension(struct uvideo_softc *, |
217 | const usb_descriptor_t *); |
218 | void uvideo_hexdump(void *, int, int); |
219 | int uvideo_debug_file_open(struct uvideo_softc *); |
220 | void uvideo_debug_file_write_frame(void *); |
221 | #endif |
222 | |
223 | /* |
224 | * IOCTL's |
225 | */ |
226 | int uvideo_querycap(void *, struct v4l2_capability *); |
227 | int uvideo_enum_fmt(void *, struct v4l2_fmtdesc *); |
228 | int uvideo_enum_fsizes(void *, struct v4l2_frmsizeenum *); |
229 | int uvideo_enum_fivals(void *, struct v4l2_frmivalenum *); |
230 | int uvideo_s_fmt(void *, struct v4l2_format *); |
231 | int uvideo_g_fmt(void *, struct v4l2_format *); |
232 | int uvideo_s_parm(void *, struct v4l2_streamparm *); |
233 | int uvideo_g_parm(void *, struct v4l2_streamparm *); |
234 | int uvideo_enum_input(void *, struct v4l2_input *); |
235 | int uvideo_s_input(void *, int); |
236 | int uvideo_g_input(void *, int *); |
237 | int uvideo_reqbufs(void *, struct v4l2_requestbuffers *); |
238 | int uvideo_querybuf(void *, struct v4l2_buffer *); |
239 | int uvideo_qbuf(void *, struct v4l2_buffer *); |
240 | int uvideo_dqbuf(void *, struct v4l2_buffer *); |
241 | int uvideo_streamon(void *, int); |
242 | int uvideo_streamoff(void *, int); |
243 | int uvideo_try_fmt(void *, struct v4l2_format *); |
244 | int uvideo_queryctrl(void *, struct v4l2_queryctrl *); |
245 | int uvideo_g_ctrl(void *, struct v4l2_control *); |
246 | int uvideo_s_ctrl(void *, struct v4l2_control *); |
247 | |
248 | /* |
249 | * Other hardware interface related functions |
250 | */ |
251 | caddr_t uvideo_mappage(void *, off_t, int); |
252 | int uvideo_get_bufsize(void *); |
253 | int uvideo_start_read(void *); |
254 | |
255 | /* |
256 | * Firmware |
257 | */ |
258 | usbd_status uvideo_ucode_loader_ricoh(struct uvideo_softc *); |
259 | usbd_status uvideo_ucode_loader_apple_isight(struct uvideo_softc *); |
260 | |
261 | struct cfdriver uvideo_cd = { |
262 | NULL((void *)0), "uvideo", DV_DULL |
263 | }; |
264 | |
265 | const struct cfattach uvideo_ca = { |
266 | sizeof(struct uvideo_softc), uvideo_match, uvideo_attach, uvideo_detach |
267 | }; |
268 | |
269 | const struct video_hw_if uvideo_hw_if = { |
270 | uvideo_open, /* open */ |
271 | uvideo_close, /* close */ |
272 | uvideo_querycap, /* VIDIOC_QUERYCAP */ |
273 | uvideo_enum_fmt, /* VIDIOC_ENUM_FMT */ |
274 | uvideo_enum_fsizes, /* VIDIOC_ENUM_FRAMESIZES */ |
275 | uvideo_enum_fivals, /* VIDIOC_ENUM_FRAMEINTERVALS */ |
276 | uvideo_s_fmt, /* VIDIOC_S_FMT */ |
277 | uvideo_g_fmt, /* VIDIOC_G_FMT */ |
278 | uvideo_s_parm, /* VIDIOC_S_PARM */ |
279 | uvideo_g_parm, /* VIDIOC_G_PARM */ |
280 | uvideo_enum_input, /* VIDIOC_ENUMINPUT */ |
281 | uvideo_s_input, /* VIDIOC_S_INPUT */ |
282 | uvideo_g_input, /* VIDIOC_G_INPUT */ |
283 | uvideo_reqbufs, /* VIDIOC_REQBUFS */ |
284 | uvideo_querybuf, /* VIDIOC_QUERYBUF */ |
285 | uvideo_qbuf, /* VIDIOC_QBUF */ |
286 | uvideo_dqbuf, /* VIDIOC_DQBUF */ |
287 | uvideo_streamon, /* VIDIOC_STREAMON */ |
288 | uvideo_streamoff, /* VIDIOC_STREAMOFF */ |
289 | uvideo_try_fmt, /* VIDIOC_TRY_FMT */ |
290 | uvideo_queryctrl, /* VIDIOC_QUERYCTRL */ |
291 | uvideo_g_ctrl, /* VIDIOC_G_CTRL */ |
292 | uvideo_s_ctrl, /* VIDIOC_S_CTRL */ |
293 | uvideo_mappage, /* mmap */ |
294 | uvideo_get_bufsize, /* read */ |
295 | uvideo_start_read /* start stream for read */ |
296 | }; |
297 | |
298 | /* |
299 | * Devices which either fail to declare themselves as UICLASS_VIDEO, |
300 | * or which need firmware uploads or other quirk handling later on. |
301 | */ |
302 | #define UVIDEO_FLAG_ISIGHT_STREAM_HEADER0x1 0x1 |
303 | #define UVIDEO_FLAG_REATTACH0x2 0x2 |
304 | #define UVIDEO_FLAG_VENDOR_CLASS0x4 0x4 |
305 | #define UVIDEO_FLAG_NOATTACH0x8 0x8 |
306 | const struct uvideo_devs { |
307 | struct usb_devno uv_dev; |
308 | char *ucode_name; |
309 | usbd_status (*ucode_loader)(struct uvideo_softc *); |
310 | int flags; |
311 | } uvideo_devs[] = { |
312 | { |
313 | /* Needs firmware */ |
314 | { USB_VENDOR_RICOH0x05ca, USB_PRODUCT_RICOH_VGPVCC50x1835 }, |
315 | "uvideo_r5u87x_05ca-1835", |
316 | uvideo_ucode_loader_ricoh, |
317 | 0 |
318 | }, |
319 | { |
320 | /* Needs firmware */ |
321 | { USB_VENDOR_RICOH0x05ca, USB_PRODUCT_RICOH_VGPVCC40x1836 }, |
322 | "uvideo_r5u87x_05ca-1836", |
323 | uvideo_ucode_loader_ricoh, |
324 | 0 |
325 | }, |
326 | { |
327 | /* Needs firmware */ |
328 | { USB_VENDOR_RICOH0x05ca, USB_PRODUCT_RICOH_VGPVCC4_20x1837 }, |
329 | "uvideo_r5u87x_05ca-1837", |
330 | uvideo_ucode_loader_ricoh, |
331 | 0 |
332 | }, |
333 | { |
334 | /* Needs firmware */ |
335 | { USB_VENDOR_RICOH0x05ca, USB_PRODUCT_RICOH_VGPVCC60x1839 }, |
336 | "uvideo_r5u87x_05ca-1839", |
337 | uvideo_ucode_loader_ricoh, |
338 | 0 |
339 | }, |
340 | { |
341 | /* Needs firmware */ |
342 | { USB_VENDOR_RICOH0x05ca, USB_PRODUCT_RICOH_VGPVCC70x183a }, |
343 | "uvideo_r5u87x_05ca-183a", |
344 | uvideo_ucode_loader_ricoh, |
345 | 0 |
346 | }, |
347 | { |
348 | /* Needs firmware */ |
349 | { USB_VENDOR_RICOH0x05ca, USB_PRODUCT_RICOH_VGPVCC80x183b }, |
350 | "uvideo_r5u87x_05ca-183b", |
351 | uvideo_ucode_loader_ricoh, |
352 | 0 |
353 | }, |
354 | { |
355 | /* Needs firmware */ |
356 | { USB_VENDOR_RICOH0x05ca, USB_PRODUCT_RICOH_VGPVCC90x183e }, |
357 | "uvideo_r5u87x_05ca-183e", |
358 | uvideo_ucode_loader_ricoh, |
359 | 0 |
360 | }, |
361 | { |
362 | /* Needs firmware */ |
363 | { USB_VENDOR_APPLE0x05ac, USB_PRODUCT_APPLE_BLUETOOTH0x8300 }, |
364 | "uvideo_isight_05ac-8300", |
365 | uvideo_ucode_loader_apple_isight, |
366 | UVIDEO_FLAG_REATTACH0x2 |
367 | }, |
368 | { |
369 | /* Has a non-standard streaming header protocol */ |
370 | { USB_VENDOR_APPLE0x05ac, USB_PRODUCT_APPLE_ISIGHT_10x8501 }, |
371 | NULL((void *)0), |
372 | NULL((void *)0), |
373 | UVIDEO_FLAG_ISIGHT_STREAM_HEADER0x1 |
374 | }, |
375 | { /* Incorrectly reports as bInterfaceClass=UICLASS_VENDOR */ |
376 | { USB_VENDOR_LOGITECH0x046d, USB_PRODUCT_LOGITECH_QUICKCAMOEM_10x08c6 }, |
377 | NULL((void *)0), |
378 | NULL((void *)0), |
379 | UVIDEO_FLAG_VENDOR_CLASS0x4 |
380 | }, |
381 | { /* Infrared camera not supported */ |
382 | { USB_VENDOR_CHICONY0x04f2, USB_PRODUCT_CHICONY_IRCAMERA0xb615 }, |
383 | NULL((void *)0), |
384 | NULL((void *)0), |
385 | UVIDEO_FLAG_NOATTACH0x8 |
386 | }, |
387 | }; |
388 | #define uvideo_lookup(v, p)((const struct uvideo_devs *)usbd_match_device((const struct usb_devno *)(uvideo_devs), sizeof (uvideo_devs) / sizeof ((uvideo_devs )[0]), sizeof ((uvideo_devs)[0]), (v), (p))) \ |
389 | ((const struct uvideo_devs *)usb_lookup(uvideo_devs, v, p)usbd_match_device((const struct usb_devno *)(uvideo_devs), sizeof (uvideo_devs) / sizeof ((uvideo_devs)[0]), sizeof ((uvideo_devs )[0]), (v), (p))) |
390 | |
391 | int |
392 | uvideo_open(void *addr, int flags, int *size, uint8_t *buffer, |
393 | void (*intr)(void *), void *arg) |
394 | { |
395 | struct uvideo_softc *sc = addr; |
396 | |
397 | DPRINTF(1, "%s: uvideo_open: sc=%p\n", DEVNAME(sc), sc); |
398 | |
399 | if (usbd_is_dying(sc->sc_udev)) |
400 | return (EIO5); |
401 | |
402 | /* pointers to upper video layer */ |
403 | sc->sc_uplayer_arg = arg; |
404 | sc->sc_uplayer_fsize = size; |
405 | sc->sc_uplayer_fbuffer = buffer; |
406 | sc->sc_uplayer_intr = intr; |
407 | |
408 | sc->sc_mmap_flag = 0; |
409 | sc->sc_negotiated_flag = 0; |
410 | |
411 | return (0); |
412 | } |
413 | |
414 | int |
415 | uvideo_close(void *addr) |
416 | { |
417 | struct uvideo_softc *sc = addr; |
418 | |
419 | DPRINTF(1, "%s: uvideo_close: sc=%p\n", DEVNAME(sc), sc); |
420 | |
421 | #ifdef UVIDEO_DUMP |
422 | usb_rem_task(sc->sc_udev, &sc->sc_task_write); |
423 | #endif |
424 | /* close video stream pipe */ |
425 | uvideo_vs_close(sc); |
426 | |
427 | /* free video stream xfer buffer */ |
428 | if (sc->sc_vs_cur->bulk_endpoint) |
429 | uvideo_vs_free_bulk(sc); |
430 | else |
431 | uvideo_vs_free_isoc(sc); |
432 | |
433 | /* free video stream frame buffer */ |
434 | uvideo_vs_free_frame(sc); |
435 | return (0); |
436 | } |
437 | |
438 | int |
439 | uvideo_match(struct device *parent, void *match, void *aux) |
440 | { |
441 | struct usb_attach_arg *uaa = aux; |
442 | usb_interface_descriptor_t *id; |
443 | const struct uvideo_devs *quirk; |
444 | |
445 | if (uaa->iface == NULL((void *)0)) |
446 | return (UMATCH_NONE0); |
447 | |
448 | id = usbd_get_interface_descriptor(uaa->iface); |
449 | if (id == NULL((void *)0)) |
450 | return (UMATCH_NONE0); |
451 | |
452 | /* quirk devices */ |
453 | quirk = uvideo_lookup(uaa->vendor, uaa->product)((const struct uvideo_devs *)usbd_match_device((const struct usb_devno *)(uvideo_devs), sizeof (uvideo_devs) / sizeof ((uvideo_devs )[0]), sizeof ((uvideo_devs)[0]), (uaa->vendor), (uaa-> product))); |
454 | if (quirk != NULL((void *)0)) { |
455 | if (quirk->flags & UVIDEO_FLAG_REATTACH0x2) |
456 | return (UMATCH_VENDOR_PRODUCT_CONF_IFACE8); |
457 | |
458 | if (quirk->flags & UVIDEO_FLAG_VENDOR_CLASS0x4 && |
459 | id->bInterfaceClass == UICLASS_VENDOR0xff && |
460 | id->bInterfaceSubClass == UISUBCLASS_VIDEOCONTROL1) |
461 | return (UMATCH_VENDOR_PRODUCT_CONF_IFACE8); |
462 | } |
463 | |
464 | if (id->bInterfaceClass == UICLASS_VIDEO0x0e && |
465 | id->bInterfaceSubClass == UISUBCLASS_VIDEOCONTROL1) |
466 | return (UMATCH_VENDOR_PRODUCT_CONF_IFACE8); |
467 | |
468 | return (UMATCH_NONE0); |
469 | } |
470 | |
471 | void |
472 | uvideo_attach(struct device *parent, struct device *self, void *aux) |
473 | { |
474 | struct uvideo_softc *sc = (struct uvideo_softc *)self; |
475 | struct usb_attach_arg *uaa = aux; |
476 | usb_interface_assoc_descriptor_t *iad; |
477 | usb_interface_descriptor_t *id; |
478 | const usb_descriptor_t *desc; |
479 | struct usbd_desc_iter iter; |
480 | int i; |
481 | |
482 | sc->sc_udev = uaa->device; |
483 | |
484 | /* Find the first unclaimed video interface. */ |
485 | for (i = 0; i < uaa->nifaces; i++) { |
486 | if (usbd_iface_claimed(sc->sc_udev, i)) |
487 | continue; |
488 | id = usbd_get_interface_descriptor(&sc->sc_udev->ifaces[i]); |
489 | if (id == NULL((void *)0)) |
490 | continue; |
491 | if (id->bInterfaceClass == UICLASS_VIDEO0x0e) |
492 | break; |
493 | } |
494 | if (i == uaa->nifaces) { |
495 | printf("%s: can't find video interface\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
496 | return; |
497 | } |
498 | |
499 | /* Find out which interface association we belong to. */ |
500 | usbd_desc_iter_init(sc->sc_udev, &iter); |
501 | desc = usbd_desc_iter_next(&iter); |
502 | while (desc) { |
503 | if (desc->bDescriptorType != UDESC_IFACE_ASSOC0x0B) { |
504 | desc = usbd_desc_iter_next(&iter); |
505 | continue; |
506 | } |
507 | iad = (usb_interface_assoc_descriptor_t *)desc; |
508 | if (i >= iad->bFirstInterface && |
509 | i < iad->bFirstInterface + iad->bInterfaceCount) |
510 | break; |
511 | desc = usbd_desc_iter_next(&iter); |
512 | } |
513 | if (desc == NULL((void *)0)) { |
514 | printf("%s: can't find interface assoc descriptor\n", |
515 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
516 | return; |
517 | } |
518 | |
519 | /* |
520 | * Claim all interfaces of our association. Interfaces must be |
521 | * claimed during attach, during attach hooks is too late. |
522 | */ |
523 | for (i = iad->bFirstInterface; |
524 | i < iad->bFirstInterface + iad->bInterfaceCount; i++) { |
525 | if (usbd_iface_claimed(sc->sc_udev, i)) { |
526 | printf("%s: interface already claimed\n", |
527 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
528 | return; |
529 | } |
530 | usbd_claim_iface(sc->sc_udev, i); |
531 | } |
532 | |
533 | /* Remember our association by saving the first interface. */ |
534 | sc->sc_iface = iad->bFirstInterface; |
535 | sc->sc_nifaces = iad->bInterfaceCount; |
536 | |
537 | /* maybe the device has quirks */ |
538 | sc->sc_quirk = uvideo_lookup(uaa->vendor, uaa->product)((const struct uvideo_devs *)usbd_match_device((const struct usb_devno *)(uvideo_devs), sizeof (uvideo_devs) / sizeof ((uvideo_devs )[0]), sizeof ((uvideo_devs)[0]), (uaa->vendor), (uaa-> product))); |
539 | |
540 | if (sc->sc_quirk && sc->sc_quirk->flags & UVIDEO_FLAG_NOATTACH0x8) { |
541 | printf("%s: device not supported\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
542 | return; |
543 | } |
544 | |
545 | if (sc->sc_quirk && sc->sc_quirk->ucode_name) |
546 | config_mountroot(self, uvideo_attach_hook); |
547 | else |
548 | uvideo_attach_hook(self); |
549 | } |
550 | |
551 | void |
552 | uvideo_attach_hook(struct device *self) |
553 | { |
554 | struct uvideo_softc *sc = (struct uvideo_softc *)self; |
555 | usb_config_descriptor_t *cdesc; |
556 | usbd_status error; |
557 | |
558 | /* maybe the device needs a firmware */ |
559 | if (sc->sc_quirk && sc->sc_quirk->ucode_name) { |
560 | error = (sc->sc_quirk->ucode_loader)(sc); |
561 | if (error != USBD_NORMAL_COMPLETION) |
562 | return; |
563 | } |
564 | |
565 | /* map stream header decode function */ |
566 | if (sc->sc_quirk && |
567 | sc->sc_quirk->flags & UVIDEO_FLAG_ISIGHT_STREAM_HEADER0x1) { |
568 | sc->sc_decode_stream_header = |
569 | uvideo_vs_decode_stream_header_isight; |
570 | } else { |
571 | sc->sc_decode_stream_header = |
572 | uvideo_vs_decode_stream_header; |
573 | } |
574 | |
575 | /* get the config descriptor */ |
576 | cdesc = usbd_get_config_descriptor(sc->sc_udev); |
577 | if (cdesc == NULL((void *)0)) { |
578 | printf("%s: failed to get configuration descriptor\n", |
579 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
580 | return; |
581 | } |
582 | #ifdef UVIDEO_DEBUG |
583 | uvideo_dump_desc_all(sc); |
584 | #endif |
585 | /* parse video control descriptors */ |
586 | error = uvideo_vc_parse_desc(sc); |
587 | if (error != USBD_NORMAL_COMPLETION) |
588 | return; |
589 | |
590 | /* parse video stream descriptors */ |
591 | error = uvideo_vs_parse_desc(sc, cdesc); |
592 | if (error != USBD_NORMAL_COMPLETION) |
593 | return; |
594 | |
595 | /* set default video stream interface */ |
596 | error = usbd_set_interface(sc->sc_vs_cur->ifaceh, 0); |
597 | if (error != USBD_NORMAL_COMPLETION) |
598 | return; |
599 | |
600 | /* do device negotiation without commit */ |
601 | error = uvideo_vs_negotiation(sc, 0); |
602 | if (error != USBD_NORMAL_COMPLETION) |
603 | return; |
604 | |
605 | /* init mmap queue */ |
606 | SIMPLEQ_INIT(&sc->sc_mmap_q)do { (&sc->sc_mmap_q)->sqh_first = ((void *)0); (& sc->sc_mmap_q)->sqh_last = &(&sc->sc_mmap_q) ->sqh_first; } while (0); |
607 | sc->sc_mmap_count = 0; |
608 | |
609 | DPRINTF(1, "uvideo_attach: doing video_attach_mi\n"); |
610 | sc->sc_videodev = video_attach_mi(&uvideo_hw_if, sc, &sc->sc_dev); |
611 | } |
612 | |
613 | int |
614 | uvideo_detach(struct device *self, int flags) |
615 | { |
616 | struct uvideo_softc *sc = (struct uvideo_softc *)self; |
617 | int rv = 0; |
618 | |
619 | /* Wait for outstanding requests to complete */ |
620 | usbd_delay_ms(sc->sc_udev, UVIDEO_NFRAMES_MAX40); |
621 | |
622 | if (sc->sc_videodev != NULL((void *)0)) |
623 | rv = config_detach(sc->sc_videodev, flags); |
624 | |
625 | uvideo_vs_free_frame(sc); |
626 | |
627 | return (rv); |
628 | } |
629 | |
630 | usbd_status |
631 | uvideo_vc_parse_desc(struct uvideo_softc *sc) |
632 | { |
633 | struct usbd_desc_iter iter; |
634 | const usb_descriptor_t *desc; |
635 | usb_interface_descriptor_t *id; |
636 | int vc_header_found; |
637 | usbd_status error; |
638 | |
639 | DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); |
640 | |
641 | vc_header_found = 0; |
642 | |
643 | usbd_desc_iter_init(sc->sc_udev, &iter); |
644 | desc = usbd_desc_iter_next(&iter); |
645 | while (desc) { |
646 | /* Skip all interfaces until we found our first. */ |
647 | if (desc->bDescriptorType == UDESC_INTERFACE0x04) { |
648 | id = (usb_interface_descriptor_t *)desc; |
649 | if (id->bInterfaceNumber == sc->sc_iface) |
650 | break; |
651 | } |
652 | desc = usbd_desc_iter_next(&iter); |
653 | } |
654 | while (desc) { |
655 | /* Crossed device function boundary. */ |
656 | if (desc->bDescriptorType == UDESC_IFACE_ASSOC0x0B) |
657 | break; |
658 | if (desc->bDescriptorType != UDESC_CS_INTERFACE0x24) { |
659 | desc = usbd_desc_iter_next(&iter); |
660 | continue; |
661 | } |
662 | |
663 | switch (desc->bDescriptorSubtype) { |
664 | case UDESCSUB_VC_HEADER0x01: |
665 | if (!uvideo_desc_len(desc, 12, 11, 1, 0)) |
666 | break; |
667 | if (vc_header_found) { |
668 | printf("%s: too many VC_HEADERs!\n", |
669 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
670 | return (USBD_INVAL); |
671 | } |
672 | error = uvideo_vc_parse_desc_header(sc, desc); |
673 | if (error != USBD_NORMAL_COMPLETION) |
674 | return (error); |
675 | vc_header_found = 1; |
676 | break; |
677 | case UDESCSUB_VC_PROCESSING_UNIT0x05: |
678 | /* XXX do correct length calculation */ |
679 | if (desc->bLength < |
680 | sizeof(struct usb_video_frame_desc)) { |
681 | (void)uvideo_vc_parse_desc_pu(sc, desc); |
682 | } |
683 | break; |
684 | |
685 | /* TODO: which VC descriptors do we need else? */ |
686 | } |
687 | |
688 | desc = usbd_desc_iter_next(&iter); |
689 | } |
690 | |
691 | if (vc_header_found == 0) { |
692 | printf("%s: no VC_HEADER found!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
693 | return (USBD_INVAL); |
694 | } |
695 | |
696 | return (USBD_NORMAL_COMPLETION); |
697 | } |
698 | |
699 | usbd_status |
700 | uvideo_vc_parse_desc_header(struct uvideo_softc *sc, |
701 | const usb_descriptor_t *desc) |
702 | { |
703 | struct usb_video_header_desc *d; |
704 | |
705 | d = (struct usb_video_header_desc *)(uint8_t *)desc; |
706 | |
707 | if (d->bInCollection == 0) { |
708 | printf("%s: no VS interface found!\n", |
709 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
710 | return (USBD_INVAL); |
711 | } |
712 | |
713 | sc->sc_desc_vc_header.fix = d; |
714 | sc->sc_desc_vc_header.baInterfaceNr = (uByte *)(d + 1); |
715 | if (UGETW(d->bcdUVC)(*(u_int16_t *)(d->bcdUVC)) < 0x0110) |
716 | sc->sc_max_ctrl_size = 26; |
717 | else if (UGETW(d->bcdUVC)(*(u_int16_t *)(d->bcdUVC)) < 0x0150) |
718 | sc->sc_max_ctrl_size = 34; |
719 | else |
720 | sc->sc_max_ctrl_size = 48; |
721 | |
722 | return (USBD_NORMAL_COMPLETION); |
723 | } |
724 | |
725 | usbd_status |
726 | uvideo_vc_parse_desc_pu(struct uvideo_softc *sc, |
727 | const usb_descriptor_t *desc) |
728 | { |
729 | struct usb_video_vc_processing_desc *d; |
730 | |
731 | /* PU descriptor is variable sized */ |
732 | d = (void *)desc; |
733 | |
734 | if (sc->sc_desc_vc_pu_num == UVIDEO_MAX_PU8) { |
735 | printf("%s: too many PU descriptors found!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
736 | return (USBD_INVAL); |
737 | } |
738 | |
739 | sc->sc_desc_vc_pu[sc->sc_desc_vc_pu_num] = d; |
740 | sc->sc_desc_vc_pu_num++; |
741 | |
742 | return (USBD_NORMAL_COMPLETION); |
743 | } |
744 | |
745 | usbd_status |
746 | uvideo_vc_get_ctrl(struct uvideo_softc *sc, uint8_t *ctrl_data, |
747 | uint8_t request, uint8_t unitid, uint16_t ctrl_selector, uint16_t ctrl_len) |
748 | { |
749 | usb_device_request_t req; |
750 | usbd_status error; |
751 | |
752 | req.bmRequestType = UVIDEO_GET_IF0xa1; |
753 | req.bRequest = request; |
754 | USETW(req.wValue, (ctrl_selector << 8))(*(u_int16_t *)(req.wValue) = ((ctrl_selector << 8))); |
755 | USETW(req.wIndex, (unitid << 8))(*(u_int16_t *)(req.wIndex) = ((unitid << 8))); |
756 | USETW(req.wLength, ctrl_len)(*(u_int16_t *)(req.wLength) = (ctrl_len)); |
757 | |
758 | error = usbd_do_request(sc->sc_udev, &req, ctrl_data); |
759 | if (error) { |
760 | DPRINTF(1, "%s: %s: could not GET ctrl request: %s\n", |
761 | DEVNAME(sc), __func__, usbd_errstr(error)); |
762 | return (USBD_INVAL); |
763 | } |
764 | |
765 | return (USBD_NORMAL_COMPLETION); |
766 | } |
767 | |
768 | usbd_status |
769 | uvideo_vc_set_ctrl(struct uvideo_softc *sc, uint8_t *ctrl_data, |
770 | uint8_t request, uint8_t unitid, uint16_t ctrl_selector, uint16_t ctrl_len) |
771 | { |
772 | usb_device_request_t req; |
773 | usbd_status error; |
774 | |
775 | req.bmRequestType = UVIDEO_SET_IF0x21; |
776 | req.bRequest = request; |
777 | USETW(req.wValue, (ctrl_selector << 8))(*(u_int16_t *)(req.wValue) = ((ctrl_selector << 8))); |
778 | USETW(req.wIndex, (unitid << 8))(*(u_int16_t *)(req.wIndex) = ((unitid << 8))); |
779 | USETW(req.wLength, ctrl_len)(*(u_int16_t *)(req.wLength) = (ctrl_len)); |
780 | |
781 | error = usbd_do_request(sc->sc_udev, &req, ctrl_data); |
782 | if (error) { |
783 | DPRINTF(1, "%s: %s: could not SET ctrl request: %s\n", |
784 | DEVNAME(sc), __func__, usbd_errstr(error)); |
785 | return (USBD_INVAL); |
786 | } |
787 | |
788 | return (USBD_NORMAL_COMPLETION); |
789 | } |
790 | |
791 | int |
792 | uvideo_find_ctrl(struct uvideo_softc *sc, int id) |
793 | { |
794 | int i, j, found; |
795 | |
796 | if (sc->sc_desc_vc_pu_num == 0) { |
797 | /* no processing unit descriptors found */ |
798 | DPRINTF(1, "%s: %s: no processing unit descriptors found!\n", |
799 | DEVNAME(sc), __func__); |
800 | return (EINVAL22); |
801 | } |
802 | |
803 | /* do we support this control? */ |
804 | for (found = 0, i = 0; uvideo_ctrls[i].cid != 0; i++) { |
805 | if (id == uvideo_ctrls[i].cid) { |
806 | found = 1; |
807 | break; |
808 | } |
809 | } |
810 | if (found == 0) { |
811 | DPRINTF(1, "%s: %s: control not supported by driver!\n", |
812 | DEVNAME(sc), __func__); |
813 | return (EINVAL22); |
814 | } |
815 | |
816 | /* does the device support this control? */ |
817 | for (found = 0, j = 0; j < sc->sc_desc_vc_pu_num; j++) { |
818 | if (uvideo_has_ctrl(sc->sc_desc_vc_pu[j], |
819 | uvideo_ctrls[i].ctrl_bit) != 0) { |
820 | found = 1; |
821 | break; |
822 | } |
823 | } |
824 | if (found == 0) { |
825 | DPRINTF(1, "%s: %s: control not supported by device!\n", |
826 | DEVNAME(sc), __func__); |
827 | return (EINVAL22); |
828 | } |
829 | sc->sc_desc_vc_pu_cur = sc->sc_desc_vc_pu[j]; |
830 | |
831 | return (i); |
832 | } |
833 | |
834 | int |
835 | uvideo_has_ctrl(struct usb_video_vc_processing_desc *desc, int ctrl_bit) |
836 | { |
837 | if (desc->bControlSize * 8 <= ctrl_bit) |
838 | return (0); |
839 | |
840 | return (desc->bmControls[byteof(ctrl_bit)((ctrl_bit) >> 3)] & bitof(ctrl_bit)(1L << ((ctrl_bit) & 0x7))); |
841 | } |
842 | |
843 | usbd_status |
844 | uvideo_vs_parse_desc(struct uvideo_softc *sc, usb_config_descriptor_t *cdesc) |
845 | { |
846 | struct usbd_desc_iter iter; |
847 | const usb_descriptor_t *desc; |
848 | usb_interface_descriptor_t *id; |
849 | int i, iface, numalts; |
850 | usbd_status error; |
851 | |
852 | DPRINTF(1, "%s: number of total interfaces=%d\n", |
853 | DEVNAME(sc), sc->sc_nifaces); |
854 | DPRINTF(1, "%s: number of VS interfaces=%d\n", |
855 | DEVNAME(sc), sc->sc_desc_vc_header.fix->bInCollection); |
856 | |
857 | usbd_desc_iter_init(sc->sc_udev, &iter); |
858 | desc = usbd_desc_iter_next(&iter); |
859 | while (desc) { |
860 | /* Skip all interfaces until we found our first. */ |
861 | if (desc->bDescriptorType == UDESC_INTERFACE0x04) { |
862 | id = (usb_interface_descriptor_t *)desc; |
863 | if (id->bInterfaceNumber == sc->sc_iface) |
864 | break; |
865 | } |
866 | desc = usbd_desc_iter_next(&iter); |
867 | } |
868 | while (desc) { |
869 | /* Crossed device function boundary. */ |
870 | if (desc->bDescriptorType == UDESC_IFACE_ASSOC0x0B) |
871 | break; |
872 | if (desc->bDescriptorType != UDESC_CS_INTERFACE0x24) { |
873 | desc = usbd_desc_iter_next(&iter); |
874 | continue; |
875 | } |
876 | |
877 | switch (desc->bDescriptorSubtype) { |
878 | case UDESCSUB_VS_INPUT_HEADER0x01: |
879 | if (!uvideo_desc_len(desc, 13, 3, 0, 12)) |
880 | break; |
881 | error = uvideo_vs_parse_desc_input_header(sc, desc); |
882 | if (error != USBD_NORMAL_COMPLETION) |
883 | return (error); |
884 | break; |
885 | |
886 | /* TODO: which VS descriptors do we need else? */ |
887 | } |
888 | |
889 | desc = usbd_desc_iter_next(&iter); |
890 | } |
891 | |
892 | /* parse video stream format descriptors */ |
893 | error = uvideo_vs_parse_desc_format(sc); |
894 | if (error != USBD_NORMAL_COMPLETION) |
895 | return (error); |
896 | |
897 | /* parse video stream frame descriptors */ |
898 | error = uvideo_vs_parse_desc_frame(sc); |
899 | if (error != USBD_NORMAL_COMPLETION) |
900 | return (error); |
901 | |
902 | /* parse interface collection */ |
903 | for (i = 0; i < sc->sc_desc_vc_header.fix->bInCollection; i++) { |
904 | iface = sc->sc_desc_vc_header.baInterfaceNr[i]; |
905 | |
906 | id = usbd_get_interface_descriptor(&sc->sc_udev->ifaces[iface]); |
907 | if (id == NULL((void *)0)) { |
908 | printf("%s: can't get VS interface %d!\n", |
909 | DEVNAME(sc)((sc)->sc_dev.dv_xname), iface); |
910 | return (USBD_INVAL); |
911 | } |
912 | usbd_claim_iface(sc->sc_udev, iface); |
913 | |
914 | numalts = usbd_get_no_alts(cdesc, id->bInterfaceNumber); |
915 | |
916 | DPRINTF(1, "%s: VS interface %d, ", DEVNAME(sc), i); |
917 | DPRINTF(1, "bInterfaceNumber=0x%02x, numalts=%d\n", |
918 | id->bInterfaceNumber, numalts); |
919 | |
920 | error = uvideo_vs_parse_desc_alt(sc, i, iface, numalts); |
921 | if (error != USBD_NORMAL_COMPLETION) |
922 | return (error); |
923 | } |
924 | |
925 | /* XXX for now always use the first video stream */ |
926 | sc->sc_vs_cur = &sc->sc_vs_coll[0]; |
927 | |
928 | return (USBD_NORMAL_COMPLETION); |
929 | } |
930 | |
931 | usbd_status |
932 | uvideo_vs_parse_desc_input_header(struct uvideo_softc *sc, |
933 | const usb_descriptor_t *desc) |
934 | { |
935 | struct usb_video_input_header_desc *d; |
936 | |
937 | d = (struct usb_video_input_header_desc *)(uint8_t *)desc; |
938 | |
939 | /* on some devices bNumFormats is larger than the truth */ |
940 | if (d->bNumFormats == 0) { |
941 | printf("%s: no INPUT FORMAT descriptors found!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
942 | return (USBD_INVAL); |
943 | } |
944 | |
945 | sc->sc_desc_vs_input_header.fix = d; |
946 | sc->sc_desc_vs_input_header.bmaControls = (uByte *)(d + 1); |
947 | |
948 | return (USBD_NORMAL_COMPLETION); |
949 | } |
950 | |
951 | usbd_status |
952 | uvideo_vs_parse_desc_format(struct uvideo_softc *sc) |
953 | { |
954 | struct usbd_desc_iter iter; |
955 | const usb_descriptor_t *desc; |
956 | usb_interface_descriptor_t *id; |
957 | |
958 | DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); |
959 | |
960 | usbd_desc_iter_init(sc->sc_udev, &iter); |
961 | desc = usbd_desc_iter_next(&iter); |
962 | while (desc) { |
963 | /* Skip all interfaces until we found our first. */ |
964 | if (desc->bDescriptorType == UDESC_INTERFACE0x04) { |
965 | id = (usb_interface_descriptor_t *)desc; |
966 | if (id->bInterfaceNumber == sc->sc_iface) |
967 | break; |
968 | } |
969 | desc = usbd_desc_iter_next(&iter); |
970 | } |
971 | while (desc) { |
972 | /* Crossed device function boundary. */ |
973 | if (desc->bDescriptorType == UDESC_IFACE_ASSOC0x0B) |
974 | break; |
975 | if (desc->bDescriptorType != UDESC_CS_INTERFACE0x24) { |
976 | desc = usbd_desc_iter_next(&iter); |
977 | continue; |
978 | } |
979 | |
980 | switch (desc->bDescriptorSubtype) { |
981 | case UDESCSUB_VS_FORMAT_MJPEG0x06: |
982 | if (desc->bLength == 11) { |
983 | (void)uvideo_vs_parse_desc_format_mjpeg( |
984 | sc, desc); |
985 | } |
986 | break; |
987 | case UDESCSUB_VS_FORMAT_UNCOMPRESSED0x04: |
988 | if (desc->bLength == 27) { |
989 | (void)uvideo_vs_parse_desc_format_uncompressed( |
990 | sc, desc); |
991 | } |
992 | break; |
993 | } |
994 | |
995 | desc = usbd_desc_iter_next(&iter); |
996 | } |
997 | |
998 | sc->sc_fmtgrp_idx = 0; |
999 | |
1000 | if (sc->sc_fmtgrp_num == 0) { |
1001 | printf("%s: no format descriptors found!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1002 | return (USBD_INVAL); |
1003 | } |
1004 | DPRINTF(1, "%s: number of total format descriptors=%d\n", |
1005 | DEVNAME(sc), sc->sc_fmtgrp_num); |
1006 | |
1007 | return (USBD_NORMAL_COMPLETION); |
1008 | } |
1009 | |
1010 | usbd_status |
1011 | uvideo_vs_parse_desc_format_mjpeg(struct uvideo_softc *sc, |
1012 | const usb_descriptor_t *desc) |
1013 | { |
1014 | struct usb_video_format_mjpeg_desc *d; |
1015 | |
1016 | d = (struct usb_video_format_mjpeg_desc *)(uint8_t *)desc; |
1017 | |
1018 | if (d->bNumFrameDescriptors == 0) { |
1019 | printf("%s: no MJPEG frame descriptors available!\n", |
1020 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1021 | return (USBD_INVAL); |
1022 | } |
1023 | |
1024 | if (sc->sc_fmtgrp_idx >= UVIDEO_MAX_FORMAT8) { |
1025 | printf("%s: too many format descriptors found!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1026 | return (USBD_INVAL); |
1027 | } |
1028 | |
1029 | sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format = |
1030 | (struct uvideo_format_desc *)d; |
1031 | if (d->bDefaultFrameIndex > d->bNumFrameDescriptors || |
1032 | d->bDefaultFrameIndex < 1) { |
1033 | /* sanitize wrong bDefaultFrameIndex value */ |
1034 | sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = 1; |
1035 | } else { |
1036 | sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = |
1037 | d->bDefaultFrameIndex; |
1038 | } |
1039 | sc->sc_fmtgrp[sc->sc_fmtgrp_idx].pixelformat = V4L2_PIX_FMT_MJPEG((u_int32_t)('M') | ((u_int32_t)('J') << 8) | ((u_int32_t )('P') << 16) | ((u_int32_t)('G') << 24)); |
1040 | |
1041 | if (sc->sc_fmtgrp_cur == NULL((void *)0)) |
1042 | /* set MJPEG format */ |
1043 | sc->sc_fmtgrp_cur = &sc->sc_fmtgrp[sc->sc_fmtgrp_idx]; |
1044 | |
1045 | sc->sc_fmtgrp_idx++; |
1046 | sc->sc_fmtgrp_num++; |
1047 | |
1048 | return (USBD_NORMAL_COMPLETION); |
1049 | } |
1050 | |
1051 | usbd_status |
1052 | uvideo_vs_parse_desc_format_uncompressed(struct uvideo_softc *sc, |
1053 | const usb_descriptor_t *desc) |
1054 | { |
1055 | struct usb_video_format_uncompressed_desc *d; |
1056 | uint8_t guid_8bit_ir[16] = UVIDEO_FORMAT_GUID_KSMEDIA_L8_IR{ 0x32, 0x00, 0x00, 0x00, 0x02, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }; |
1057 | int i; |
1058 | |
1059 | d = (struct usb_video_format_uncompressed_desc *)(uint8_t *)desc; |
1060 | |
1061 | if (d->bNumFrameDescriptors == 0) { |
1062 | printf("%s: no UNCOMPRESSED frame descriptors available!\n", |
1063 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1064 | return (USBD_INVAL); |
1065 | } |
1066 | |
1067 | if (sc->sc_fmtgrp_idx >= UVIDEO_MAX_FORMAT8) { |
1068 | printf("%s: too many format descriptors found!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1069 | return (USBD_INVAL); |
1070 | } |
1071 | |
1072 | sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format = |
1073 | (struct uvideo_format_desc *)d; |
1074 | if (d->bDefaultFrameIndex > d->bNumFrameDescriptors || |
1075 | d->bDefaultFrameIndex < 1) { |
1076 | /* sanitize wrong bDefaultFrameIndex value */ |
1077 | sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = 1; |
1078 | } else { |
1079 | sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = |
1080 | d->bDefaultFrameIndex; |
1081 | } |
1082 | i = sc->sc_fmtgrp_idx; |
1083 | if (!strcmp(sc->sc_fmtgrp[i].format->u.uc.guidFormat, "YUY2")) { |
1084 | sc->sc_fmtgrp[i].pixelformat = V4L2_PIX_FMT_YUYV((u_int32_t)('Y') | ((u_int32_t)('U') << 8) | ((u_int32_t )('Y') << 16) | ((u_int32_t)('V') << 24)); |
1085 | } else if (!strcmp(sc->sc_fmtgrp[i].format->u.uc.guidFormat, "NV12")) { |
1086 | sc->sc_fmtgrp[i].pixelformat = V4L2_PIX_FMT_NV12((u_int32_t)('N') | ((u_int32_t)('V') << 8) | ((u_int32_t )('1') << 16) | ((u_int32_t)('2') << 24)); |
1087 | } else if (!strcmp(sc->sc_fmtgrp[i].format->u.uc.guidFormat, "UYVY")) { |
1088 | sc->sc_fmtgrp[i].pixelformat = V4L2_PIX_FMT_UYVY((u_int32_t)('U') | ((u_int32_t)('Y') << 8) | ((u_int32_t )('V') << 16) | ((u_int32_t)('Y') << 24)); |
1089 | } else if (!memcmp(sc->sc_fmtgrp[i].format->u.uc.guidFormat,__builtin_memcmp((sc->sc_fmtgrp[i].format->u.uc.guidFormat ), (guid_8bit_ir), (16)) |
1090 | guid_8bit_ir, 16)__builtin_memcmp((sc->sc_fmtgrp[i].format->u.uc.guidFormat ), (guid_8bit_ir), (16))) { |
1091 | sc->sc_fmtgrp[i].pixelformat = V4L2_PIX_FMT_GREY((u_int32_t)('G') | ((u_int32_t)('R') << 8) | ((u_int32_t )('E') << 16) | ((u_int32_t)('Y') << 24)); |
1092 | } else { |
1093 | sc->sc_fmtgrp[i].pixelformat = 0; |
1094 | } |
1095 | |
1096 | if (sc->sc_fmtgrp_cur == NULL((void *)0)) |
1097 | /* set UNCOMPRESSED format */ |
1098 | sc->sc_fmtgrp_cur = &sc->sc_fmtgrp[sc->sc_fmtgrp_idx]; |
1099 | |
1100 | sc->sc_fmtgrp_idx++; |
1101 | sc->sc_fmtgrp_num++; |
1102 | |
1103 | return (USBD_NORMAL_COMPLETION); |
1104 | } |
1105 | |
1106 | usbd_status |
1107 | uvideo_vs_parse_desc_frame(struct uvideo_softc *sc) |
1108 | { |
1109 | struct usbd_desc_iter iter; |
1110 | const usb_descriptor_t *desc; |
1111 | usb_interface_descriptor_t *id; |
1112 | usbd_status error; |
1113 | |
1114 | DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); |
1115 | |
1116 | usbd_desc_iter_init(sc->sc_udev, &iter); |
1117 | desc = usbd_desc_iter_next(&iter); |
1118 | while (desc) { |
1119 | /* Skip all interfaces until we found our first. */ |
1120 | if (desc->bDescriptorType == UDESC_INTERFACE0x04) { |
1121 | id = (usb_interface_descriptor_t *)desc; |
1122 | if (id->bInterfaceNumber == sc->sc_iface) |
1123 | break; |
1124 | } |
1125 | desc = usbd_desc_iter_next(&iter); |
1126 | } |
1127 | while (desc) { |
1128 | /* Crossed device function boundary. */ |
1129 | if (desc->bDescriptorType == UDESC_IFACE_ASSOC0x0B) |
1130 | break; |
1131 | if (desc->bDescriptorType == UDESC_CS_INTERFACE0x24 && |
1132 | desc->bLength > sizeof(struct usb_video_frame_desc) && |
1133 | (desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_MJPEG0x07 || |
1134 | desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_UNCOMPRESSED0x05)) { |
1135 | error = uvideo_vs_parse_desc_frame_sub(sc, desc); |
1136 | if (error != USBD_NORMAL_COMPLETION) |
1137 | return (error); |
1138 | } |
1139 | desc = usbd_desc_iter_next(&iter); |
1140 | } |
1141 | |
1142 | return (USBD_NORMAL_COMPLETION); |
1143 | } |
1144 | |
1145 | usbd_status |
1146 | uvideo_vs_parse_desc_frame_sub(struct uvideo_softc *sc, |
1147 | const usb_descriptor_t *desc) |
1148 | { |
1149 | struct usb_video_frame_desc *fd = |
1150 | (struct usb_video_frame_desc *)(uint8_t *)desc; |
1151 | int fmtidx, frame_num; |
1152 | uint32_t fbuf_size; |
1153 | |
1154 | fmtidx = sc->sc_fmtgrp_idx; |
1155 | frame_num = sc->sc_fmtgrp[fmtidx].frame_num; |
1156 | if (frame_num >= UVIDEO_MAX_FRAME32) { |
1157 | printf("%s: too many %s frame descriptors found!\n", |
1158 | DEVNAME(sc)((sc)->sc_dev.dv_xname), |
1159 | desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_MJPEG0x07 ? |
1160 | "MJPEG" : "UNCOMPRESSED"); |
1161 | return (USBD_INVAL); |
1162 | } |
1163 | sc->sc_fmtgrp[fmtidx].frame[frame_num] = fd; |
1164 | |
1165 | if (sc->sc_fmtgrp[fmtidx].frame_cur == NULL((void *)0) || |
1166 | sc->sc_fmtgrp[fmtidx].format_dfidx == fd->bFrameIndex) |
1167 | sc->sc_fmtgrp[fmtidx].frame_cur = fd; |
1168 | |
1169 | /* |
1170 | * On some devices, dwMaxVideoFrameBufferSize is not correct. |
1171 | * Version 1.1 of the UVC spec says this field is deprecated. |
1172 | * For uncompressed pixel formats, the frame buffer size can |
1173 | * be determined by multiplying width, height, and bytes per pixel. |
1174 | * Uncompressed formats have a fixed number of bytes per pixel. |
1175 | * Bytes per pixel can vary with compressed formats. |
1176 | */ |
1177 | if (desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_UNCOMPRESSED0x05) { |
1178 | fbuf_size = UGETW(fd->wWidth)(*(u_int16_t *)(fd->wWidth)) * UGETW(fd->wHeight)(*(u_int16_t *)(fd->wHeight)) * |
1179 | sc->sc_fmtgrp[fmtidx].format->u.uc.bBitsPerPixel / NBBY8; |
1180 | DPRINTF(10, "%s: %s: frame buffer size=%d " |
1181 | "width=%d height=%d bpp=%d\n", DEVNAME(sc), __func__, |
1182 | fbuf_size, UGETW(fd->wWidth), UGETW(fd->wHeight), |
1183 | sc->sc_fmtgrp[fmtidx].format->u.uc.bBitsPerPixel); |
1184 | } else |
1185 | fbuf_size = UGETDW(fd->dwMaxVideoFrameBufferSize)(*(u_int32_t *)(fd->dwMaxVideoFrameBufferSize)); |
1186 | |
1187 | /* store max value */ |
1188 | if (fbuf_size > sc->sc_max_fbuf_size) |
1189 | sc->sc_max_fbuf_size = fbuf_size; |
1190 | |
1191 | /* |
1192 | * Increment frame count. If this is the last frame in the |
1193 | * format group, go on to next group. |
1194 | */ |
1195 | if (++sc->sc_fmtgrp[fmtidx].frame_num == |
1196 | sc->sc_fmtgrp[fmtidx].format->bNumFrameDescriptors) { |
1197 | sc->sc_fmtgrp_idx++; |
1198 | } |
1199 | |
1200 | return (USBD_NORMAL_COMPLETION); |
1201 | } |
1202 | |
1203 | usbd_status |
1204 | uvideo_vs_parse_desc_alt(struct uvideo_softc *sc, int vs_nr, int iface, int numalts) |
1205 | { |
1206 | struct uvideo_vs_iface *vs; |
1207 | struct usbd_desc_iter iter; |
1208 | const usb_descriptor_t *desc; |
1209 | usb_interface_descriptor_t *id; |
1210 | usb_endpoint_descriptor_t *ed; |
1211 | uint8_t ep_dir, ep_type; |
1212 | |
1213 | vs = &sc->sc_vs_coll[vs_nr]; |
1214 | |
1215 | usbd_desc_iter_init(sc->sc_udev, &iter); |
1216 | desc = usbd_desc_iter_next(&iter); |
1217 | while (desc) { |
1218 | /* Skip all interfaces until we found our first. */ |
1219 | if (desc->bDescriptorType == UDESC_INTERFACE0x04) { |
1220 | id = (usb_interface_descriptor_t *)desc; |
1221 | if (id->bInterfaceNumber == sc->sc_iface) |
1222 | break; |
1223 | } |
1224 | desc = usbd_desc_iter_next(&iter); |
1225 | } |
1226 | while (desc) { |
1227 | /* Crossed device function boundary. */ |
1228 | if (desc->bDescriptorType == UDESC_IFACE_ASSOC0x0B) |
1229 | break; |
1230 | /* find video stream interface */ |
1231 | if (desc->bDescriptorType != UDESC_INTERFACE0x04) |
1232 | goto next; |
1233 | id = (usb_interface_descriptor_t *)(uint8_t *)desc; |
1234 | if (id->bInterfaceNumber != iface) |
1235 | goto next; |
1236 | DPRINTF(1, "%s: bAlternateSetting=0x%02x, ", |
1237 | DEVNAME(sc), id->bAlternateSetting); |
1238 | if (id->bNumEndpoints == 0) { |
1239 | DPRINTF(1, "no endpoint descriptor\n"); |
1240 | goto next; |
1241 | } |
1242 | |
1243 | /* jump to corresponding endpoint descriptor */ |
1244 | while ((desc = usbd_desc_iter_next(&iter))) { |
1245 | if (desc->bDescriptorType == UDESC_ENDPOINT0x05) |
1246 | break; |
1247 | } |
1248 | ed = (usb_endpoint_descriptor_t *)(uint8_t *)desc; |
1249 | DPRINTF(1, "bEndpointAddress=0x%02x, ", ed->bEndpointAddress); |
1250 | DPRINTF(1, "wMaxPacketSize=%d\n", UGETW(ed->wMaxPacketSize)); |
1251 | |
1252 | /* locate endpoint type */ |
1253 | ep_dir = UE_GET_DIR(ed->bEndpointAddress)((ed->bEndpointAddress) & 0x80); |
1254 | ep_type = UE_GET_XFERTYPE(ed->bmAttributes)((ed->bmAttributes) & 0x03); |
1255 | if (ep_dir == UE_DIR_IN0x80 && ep_type == UE_ISOCHRONOUS0x01) |
1256 | vs->bulk_endpoint = 0; |
1257 | else if (ep_dir == UE_DIR_IN0x80 && ep_type == UE_BULK0x02) |
1258 | vs->bulk_endpoint = 1; |
1259 | else |
1260 | goto next; |
1261 | |
1262 | /* save endpoint with largest bandwidth */ |
1263 | if (UGETW(ed->wMaxPacketSize)(*(u_int16_t *)(ed->wMaxPacketSize)) > vs->psize) { |
1264 | vs->ifaceh = &sc->sc_udev->ifaces[iface]; |
1265 | vs->endpoint = ed->bEndpointAddress; |
1266 | vs->numalts = numalts; |
1267 | vs->curalt = id->bAlternateSetting; |
1268 | vs->psize = UGETW(ed->wMaxPacketSize)(*(u_int16_t *)(ed->wMaxPacketSize)); |
1269 | vs->iface = iface; |
1270 | } |
1271 | next: |
1272 | desc = usbd_desc_iter_next(&iter); |
1273 | } |
1274 | |
1275 | /* check if we have found a valid alternate interface */ |
1276 | if (vs->ifaceh == NULL((void *)0)) { |
1277 | printf("%s: no valid alternate interface found!\n", |
1278 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1279 | return (USBD_INVAL); |
1280 | } |
1281 | |
1282 | return (USBD_NORMAL_COMPLETION); |
1283 | } |
1284 | |
1285 | usbd_status |
1286 | uvideo_vs_set_alt(struct uvideo_softc *sc, struct usbd_interface *ifaceh, |
1287 | int max_packet_size) |
1288 | { |
1289 | struct usbd_desc_iter iter; |
1290 | const usb_descriptor_t *desc; |
1291 | usb_interface_descriptor_t *id; |
1292 | usb_endpoint_descriptor_t *ed; |
1293 | int diff, best_diff = INT_MAX0x7fffffff; |
1294 | usbd_status error; |
1295 | uint32_t psize; |
1296 | |
1297 | usbd_desc_iter_init(sc->sc_udev, &iter); |
1298 | desc = usbd_desc_iter_next(&iter); |
1299 | while (desc) { |
1300 | /* Skip all interfaces until we found our first. */ |
1301 | if (desc->bDescriptorType == UDESC_INTERFACE0x04) { |
1302 | id = (usb_interface_descriptor_t *)desc; |
1303 | if (id->bInterfaceNumber == sc->sc_iface) |
1304 | break; |
1305 | } |
1306 | desc = usbd_desc_iter_next(&iter); |
1307 | } |
1308 | while (desc) { |
1309 | /* Crossed device function boundary. */ |
1310 | if (desc->bDescriptorType == UDESC_IFACE_ASSOC0x0B) |
1311 | break; |
1312 | /* find video stream interface */ |
1313 | if (desc->bDescriptorType != UDESC_INTERFACE0x04) |
1314 | goto next; |
1315 | id = (usb_interface_descriptor_t *)(uint8_t *)desc; |
1316 | if (id->bInterfaceNumber != sc->sc_vs_cur->iface) |
1317 | goto next; |
1318 | if (id->bNumEndpoints == 0) |
1319 | goto next; |
1320 | |
1321 | /* jump to corresponding endpoint descriptor */ |
1322 | desc = usbd_desc_iter_next(&iter); |
1323 | if (desc->bDescriptorType != UDESC_ENDPOINT0x05) |
1324 | goto next; |
1325 | ed = (usb_endpoint_descriptor_t *)(uint8_t *)desc; |
1326 | |
1327 | /* save endpoint with requested bandwidth */ |
1328 | psize = UGETW(ed->wMaxPacketSize)(*(u_int16_t *)(ed->wMaxPacketSize)); |
1329 | psize = UE_GET_SIZE(psize)((psize) & 0x7ff) * (1 + UE_GET_TRANS(psize)(((psize) >> 11) & 0x3)); |
1330 | if (psize >= max_packet_size) |
1331 | diff = psize - max_packet_size; |
1332 | else |
1333 | goto next; |
1334 | if (diff < best_diff) { |
1335 | best_diff = diff; |
1336 | sc->sc_vs_cur->endpoint = ed->bEndpointAddress; |
1337 | sc->sc_vs_cur->curalt = id->bAlternateSetting; |
1338 | sc->sc_vs_cur->psize = psize; |
1339 | if (diff == 0) |
1340 | break; |
1341 | } |
1342 | next: |
1343 | desc = usbd_desc_iter_next(&iter); |
1344 | } |
1345 | |
1346 | DPRINTF(1, "%s: set alternate iface to ", DEVNAME(sc)); |
1347 | DPRINTF(1, "bAlternateSetting=0x%02x psize=%d max_packet_size=%d\n", |
1348 | sc->sc_vs_cur->curalt, sc->sc_vs_cur->psize, max_packet_size); |
1349 | |
1350 | /* set alternate video stream interface */ |
1351 | error = usbd_set_interface(ifaceh, sc->sc_vs_cur->curalt); |
1352 | if (error) { |
1353 | printf("%s: could not set alternate interface %d!\n", |
1354 | DEVNAME(sc)((sc)->sc_dev.dv_xname), sc->sc_vs_cur->curalt); |
1355 | return (USBD_INVAL); |
1356 | } |
1357 | |
1358 | return (USBD_NORMAL_COMPLETION); |
1359 | } |
1360 | |
1361 | /* |
1362 | * Thanks to the retarded USB Video Class specs there are different |
1363 | * descriptors types with the same bDescriptorSubtype which makes |
1364 | * it necessary to differ between those types by doing descriptor |
1365 | * size dances :-( |
1366 | * |
1367 | * size_fix: total size of the fixed structure part |
1368 | * off_num_elements: offset which tells the number of following elements |
1369 | * size_element: size of a single element |
1370 | * off_size_element: if size_element is 0 the element size is taken from |
1371 | * this offset in the descriptor |
1372 | */ |
1373 | int |
1374 | uvideo_desc_len(const usb_descriptor_t *desc, |
1375 | int size_fix, int off_num_elements, int size_element, int off_size_element) |
1376 | { |
1377 | uint8_t *buf; |
1378 | int size_elements, size_total; |
1379 | |
1380 | if (desc->bLength < size_fix) |
1381 | return (0); |
1382 | |
1383 | buf = (uint8_t *)desc; |
1384 | |
1385 | if (size_element == 0) |
1386 | size_element = buf[off_size_element]; |
1387 | |
1388 | size_elements = buf[off_num_elements] * size_element; |
1389 | size_total = size_fix + size_elements; |
1390 | |
1391 | if (desc->bLength == size_total && size_elements != 0) |
1392 | return (1); |
1393 | |
1394 | return (0); |
1395 | } |
1396 | |
1397 | /* |
1398 | * Find the next best matching resolution which we can offer and |
1399 | * return it. |
1400 | */ |
1401 | void |
1402 | uvideo_find_res(struct uvideo_softc *sc, int idx, int width, int height, |
1403 | struct uvideo_res *r) |
1404 | { |
1405 | int i, w, h, diff, diff_best, size_want, size_is; |
1406 | |
1407 | size_want = width * height; |
1408 | |
1409 | for (i = 0; i < sc->sc_fmtgrp[idx].frame_num; i++) { |
1410 | w = UGETW(sc->sc_fmtgrp[idx].frame[i]->wWidth)(*(u_int16_t *)(sc->sc_fmtgrp[idx].frame[i]->wWidth)); |
1411 | h = UGETW(sc->sc_fmtgrp[idx].frame[i]->wHeight)(*(u_int16_t *)(sc->sc_fmtgrp[idx].frame[i]->wHeight)); |
1412 | size_is = w * h; |
1413 | if (size_is > size_want) |
1414 | diff = size_is - size_want; |
1415 | else |
1416 | diff = size_want - size_is; |
1417 | if (i == 0) |
1418 | diff_best = diff; |
1419 | if (diff <= diff_best) { |
1420 | diff_best = diff; |
1421 | r->width = w; |
1422 | r->height = h; |
1423 | r->fidx = i; |
1424 | } |
1425 | DPRINTF(1, "%s: %s: frame index %d: width=%d, height=%d\n", |
1426 | DEVNAME(sc), __func__, i, w, h); |
1427 | } |
1428 | } |
1429 | |
1430 | usbd_status |
1431 | uvideo_vs_negotiation(struct uvideo_softc *sc, int commit) |
1432 | { |
1433 | struct usb_video_probe_commit *pc; |
1434 | struct uvideo_format_group *fmtgrp; |
1435 | struct usb_video_header_desc *hd; |
1436 | struct usb_video_frame_desc *frame; |
1437 | uint8_t *p, *cur; |
1438 | uint8_t probe_data[48]; |
1439 | uint32_t frame_ival, nivals, min, max, step, diff; |
1440 | usbd_status error; |
1441 | int i, ival_bytes, changed = 0; |
1442 | |
1443 | pc = (struct usb_video_probe_commit *)probe_data; |
1444 | |
1445 | fmtgrp = sc->sc_fmtgrp_cur; |
1446 | |
1447 | /* check if the format descriptor contains frame descriptors */ |
1448 | if (fmtgrp->frame_num == 0) { |
1449 | printf("%s: %s: no frame descriptors found!\n", |
1450 | __func__, DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1451 | return (USBD_INVAL); |
1452 | } |
1453 | |
1454 | /* set probe */ |
1455 | bzero(probe_data, sizeof(probe_data))__builtin_bzero((probe_data), (sizeof(probe_data))); |
1456 | /* hint that dwFrameInterval should be favored over other parameters */ |
1457 | USETW(pc->bmHint, 0x1)(*(u_int16_t *)(pc->bmHint) = (0x1)); |
1458 | pc->bFormatIndex = fmtgrp->format->bFormatIndex; |
1459 | pc->bFrameIndex = fmtgrp->frame_cur->bFrameIndex; |
1460 | /* dwFrameInterval: 30fps=333333, 15fps=666666, 10fps=1000000 */ |
1461 | frame_ival = UGETDW(fmtgrp->frame_cur->dwDefaultFrameInterval)(*(u_int32_t *)(fmtgrp->frame_cur->dwDefaultFrameInterval )); |
1462 | if (sc->sc_frame_rate != 0) { |
1463 | frame_ival = 10000000 / sc->sc_frame_rate; |
1464 | /* find closest matching interval the device supports */ |
1465 | p = (uint8_t *)fmtgrp->frame_cur; |
1466 | p += sizeof(struct usb_video_frame_desc); |
1467 | nivals = fmtgrp->frame_cur->bFrameIntervalType; |
1468 | ival_bytes = fmtgrp->frame_cur->bLength - |
1469 | sizeof(struct usb_video_frame_desc); |
1470 | if (!nivals && (ival_bytes >= sizeof(uDWord) * 3)) { |
1471 | /* continuous */ |
1472 | min = UGETDW(p)(*(u_int32_t *)(p)); |
1473 | p += sizeof(uDWord); |
1474 | max = UGETDW(p)(*(u_int32_t *)(p)); |
1475 | p += sizeof(uDWord); |
1476 | step = UGETDW(p)(*(u_int32_t *)(p)); |
1477 | p += sizeof(uDWord); |
1478 | if (frame_ival <= min) |
1479 | frame_ival = min; |
1480 | else if (frame_ival >= max) |
1481 | frame_ival = max; |
1482 | else { |
1483 | for (i = min; i + step/2 < frame_ival; i+= step) |
1484 | ; /* nothing */ |
1485 | frame_ival = i; |
1486 | } |
1487 | } else if (nivals > 0 && ival_bytes >= sizeof(uDWord)) { |
1488 | /* discrete */ |
1489 | cur = p; |
1490 | min = UINT_MAX0xffffffffU; |
1491 | for (i = 0; i < nivals; i++) { |
1492 | if (ival_bytes < sizeof(uDWord)) { |
1493 | /* short descriptor ? */ |
1494 | break; |
1495 | } |
1496 | diff = abs(UGETDW(p)(*(u_int32_t *)(p)) - frame_ival); |
1497 | if (diff < min) { |
1498 | min = diff; |
1499 | cur = p; |
1500 | if (diff == 0) |
1501 | break; |
1502 | } |
1503 | p += sizeof(uDWord); |
1504 | ival_bytes -= sizeof(uDWord); |
1505 | } |
1506 | frame_ival = UGETDW(cur)(*(u_int32_t *)(cur)); |
1507 | } else { |
1508 | DPRINTF(1, "%s: %s: bad frame ival descriptor\n", |
1509 | DEVNAME(sc), __func__); |
1510 | } |
1511 | } |
1512 | USETDW(pc->dwFrameInterval, frame_ival)(*(u_int32_t *)(pc->dwFrameInterval) = (frame_ival)); |
1513 | error = uvideo_vs_set_probe(sc, probe_data); |
1514 | if (error != USBD_NORMAL_COMPLETION) |
1515 | return (error); |
1516 | |
1517 | /* get probe */ |
1518 | bzero(probe_data, sizeof(probe_data))__builtin_bzero((probe_data), (sizeof(probe_data))); |
1519 | error = uvideo_vs_get_probe(sc, probe_data, GET_CUR0x81); |
1520 | if (error != USBD_NORMAL_COMPLETION) |
1521 | return (error); |
1522 | |
1523 | /* check that the format and frame indexes are what we wanted */ |
1524 | if (pc->bFormatIndex != fmtgrp->format->bFormatIndex) { |
1525 | changed++; |
1526 | DPRINTF(1, "%s: %s: wanted format 0x%x, got format 0x%x\n", |
1527 | DEVNAME(sc), __func__, fmtgrp->format->bFormatIndex, |
1528 | pc->bFormatIndex); |
1529 | for (i = 0; i < sc->sc_fmtgrp_num; i++) { |
1530 | if (sc->sc_fmtgrp[i].format->bFormatIndex == |
1531 | pc->bFormatIndex) { |
1532 | fmtgrp = &sc->sc_fmtgrp[i]; |
1533 | break; |
1534 | } |
1535 | } |
1536 | if (i == sc->sc_fmtgrp_num) { |
1537 | DPRINTF(1, "%s: %s: invalid format index 0x%x\n", |
1538 | DEVNAME(sc), __func__, pc->bFormatIndex); |
1539 | return (USBD_INVAL); |
1540 | } |
1541 | } |
1542 | if (pc->bFrameIndex != fmtgrp->frame_cur->bFrameIndex) { |
1543 | changed++; |
1544 | DPRINTF(1, "%s: %s: wanted frame 0x%x, got frame 0x%x\n", |
1545 | DEVNAME(sc), __func__, fmtgrp->frame_cur->bFrameIndex, |
1546 | pc->bFrameIndex); |
1547 | for (i = 0; i < fmtgrp->frame_num; i++) { |
1548 | if (fmtgrp->frame[i]->bFrameIndex == pc->bFrameIndex) { |
1549 | frame = fmtgrp->frame[i]; |
1550 | break; |
1551 | } |
1552 | } |
1553 | if (i == fmtgrp->frame_num) { |
1554 | DPRINTF(1, "%s: %s: invalid frame index 0x%x\n", |
1555 | DEVNAME(sc), __func__, pc->bFrameIndex); |
1556 | return (USBD_INVAL); |
1557 | } |
1558 | } else |
1559 | frame = fmtgrp->frame_cur; |
1560 | |
1561 | /* |
1562 | * Uncompressed formats have fixed bits per pixel, which means |
1563 | * the frame buffer size is fixed and can be calculated. Because |
1564 | * some devices return incorrect values, always override the |
1565 | * the frame size with a calculated value. |
1566 | */ |
1567 | if (frame->bDescriptorSubtype == UDESCSUB_VS_FRAME_UNCOMPRESSED0x05) { |
1568 | USETDW(pc->dwMaxVideoFrameSize,(*(u_int32_t *)(pc->dwMaxVideoFrameSize) = ((*(u_int16_t * )(frame->wWidth)) * (*(u_int16_t *)(frame->wHeight)) * fmtgrp ->format->u.uc.bBitsPerPixel / 8)) |
1569 | UGETW(frame->wWidth) * UGETW(frame->wHeight) *(*(u_int32_t *)(pc->dwMaxVideoFrameSize) = ((*(u_int16_t * )(frame->wWidth)) * (*(u_int16_t *)(frame->wHeight)) * fmtgrp ->format->u.uc.bBitsPerPixel / 8)) |
1570 | fmtgrp->format->u.uc.bBitsPerPixel / NBBY)(*(u_int32_t *)(pc->dwMaxVideoFrameSize) = ((*(u_int16_t * )(frame->wWidth)) * (*(u_int16_t *)(frame->wHeight)) * fmtgrp ->format->u.uc.bBitsPerPixel / 8)); |
1571 | DPRINTF(1, "fixed dwMaxVideoFrameSize=%d, " |
1572 | "width=%d height=%d bpp=%d\n", |
1573 | UGETDW(pc->dwMaxVideoFrameSize), |
1574 | UGETW(frame->wWidth), UGETW(frame->wHeight), |
1575 | fmtgrp->format->u.uc.bBitsPerPixel); |
1576 | } else { |
1577 | /* |
1578 | * Some UVC 1.00 devices return dwMaxVideoFrameSize = 0. |
1579 | * If so, fix it by format/frame descriptors. |
1580 | */ |
1581 | hd = sc->sc_desc_vc_header.fix; |
1582 | if (UGETDW(pc->dwMaxVideoFrameSize)(*(u_int32_t *)(pc->dwMaxVideoFrameSize)) == 0 && |
1583 | UGETW(hd->bcdUVC)(*(u_int16_t *)(hd->bcdUVC)) < 0x0110 ) { |
1584 | DPRINTF(1, "%s: dwMaxVideoFrameSize == 0, fixed\n", |
1585 | DEVNAME(sc)); |
1586 | USETDW(pc->dwMaxVideoFrameSize,(*(u_int32_t *)(pc->dwMaxVideoFrameSize) = ((*(u_int32_t * )(frame->dwMaxVideoFrameBufferSize)))) |
1587 | UGETDW(frame->dwMaxVideoFrameBufferSize))(*(u_int32_t *)(pc->dwMaxVideoFrameSize) = ((*(u_int32_t * )(frame->dwMaxVideoFrameBufferSize)))); |
1588 | } |
1589 | } |
1590 | |
1591 | /* commit */ |
1592 | if (commit) { |
1593 | if (changed > 0) { |
1594 | /* didn't get the frame format or size we wanted */ |
1595 | return (USBD_INVAL); |
1596 | } |
1597 | error = uvideo_vs_set_commit(sc, probe_data); |
1598 | if (error != USBD_NORMAL_COMPLETION) |
1599 | return (error); |
1600 | } |
1601 | |
1602 | /* save a copy of probe commit */ |
1603 | bcopy(pc, &sc->sc_desc_probe, sizeof(sc->sc_desc_probe)); |
1604 | |
1605 | return (USBD_NORMAL_COMPLETION); |
1606 | } |
1607 | |
1608 | usbd_status |
1609 | uvideo_vs_set_probe(struct uvideo_softc *sc, uint8_t *probe_data) |
1610 | { |
1611 | usb_device_request_t req; |
1612 | usbd_status error; |
1613 | uint16_t tmp; |
1614 | struct usb_video_probe_commit *pc; |
1615 | |
1616 | req.bmRequestType = UVIDEO_SET_IF0x21; |
1617 | req.bRequest = SET_CUR0x01; |
1618 | tmp = VS_PROBE_CONTROL0x01; |
1619 | tmp = tmp << 8; |
1620 | USETW(req.wValue, tmp)(*(u_int16_t *)(req.wValue) = (tmp)); |
1621 | USETW(req.wIndex, sc->sc_vs_cur->iface)(*(u_int16_t *)(req.wIndex) = (sc->sc_vs_cur->iface)); |
1622 | USETW(req.wLength, sc->sc_max_ctrl_size)(*(u_int16_t *)(req.wLength) = (sc->sc_max_ctrl_size)); |
1623 | |
1624 | pc = (struct usb_video_probe_commit *)probe_data; |
1625 | |
1626 | error = usbd_do_request(sc->sc_udev, &req, probe_data); |
1627 | if (error) { |
1628 | printf("%s: could not SET probe request: %s\n", |
1629 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
1630 | return (USBD_INVAL); |
1631 | } |
1632 | DPRINTF(1, "%s: SET probe request successfully\n", DEVNAME(sc)); |
1633 | |
1634 | DPRINTF(1, "bmHint=0x%02x\n", UGETW(pc->bmHint)); |
1635 | DPRINTF(1, "bFormatIndex=0x%02x\n", pc->bFormatIndex); |
1636 | DPRINTF(1, "bFrameIndex=0x%02x\n", pc->bFrameIndex); |
1637 | DPRINTF(1, "dwFrameInterval=%d (100ns units)\n", |
1638 | UGETDW(pc->dwFrameInterval)); |
1639 | DPRINTF(1, "wKeyFrameRate=%d\n", UGETW(pc->wKeyFrameRate)); |
1640 | DPRINTF(1, "wPFrameRate=%d\n", UGETW(pc->wPFrameRate)); |
1641 | DPRINTF(1, "wCompQuality=%d\n", UGETW(pc->wCompQuality)); |
1642 | DPRINTF(1, "wCompWindowSize=%d\n", UGETW(pc->wCompWindowSize)); |
1643 | DPRINTF(1, "wDelay=%d (ms)\n", UGETW(pc->wDelay)); |
1644 | DPRINTF(1, "dwMaxVideoFrameSize=%d (bytes)\n", |
1645 | UGETDW(pc->dwMaxVideoFrameSize)); |
1646 | DPRINTF(1, "dwMaxPayloadTransferSize=%d (bytes)\n", |
1647 | UGETDW(pc->dwMaxPayloadTransferSize)); |
1648 | |
1649 | return (USBD_NORMAL_COMPLETION); |
1650 | } |
1651 | |
1652 | usbd_status |
1653 | uvideo_vs_get_probe(struct uvideo_softc *sc, uint8_t *probe_data, |
1654 | uint8_t request) |
1655 | { |
1656 | usb_device_request_t req; |
1657 | usbd_status error; |
1658 | uint16_t tmp; |
1659 | struct usb_video_probe_commit *pc; |
1660 | |
1661 | req.bmRequestType = UVIDEO_GET_IF0xa1; |
1662 | req.bRequest = request; |
1663 | tmp = VS_PROBE_CONTROL0x01; |
1664 | tmp = tmp << 8; |
1665 | USETW(req.wValue, tmp)(*(u_int16_t *)(req.wValue) = (tmp)); |
1666 | USETW(req.wIndex, sc->sc_vs_cur->iface)(*(u_int16_t *)(req.wIndex) = (sc->sc_vs_cur->iface)); |
1667 | USETW(req.wLength, sc->sc_max_ctrl_size)(*(u_int16_t *)(req.wLength) = (sc->sc_max_ctrl_size)); |
1668 | |
1669 | pc = (struct usb_video_probe_commit *)probe_data; |
1670 | |
1671 | error = usbd_do_request(sc->sc_udev, &req, probe_data); |
1672 | if (error) { |
1673 | printf("%s: could not GET probe request: %s\n", |
1674 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
1675 | return (USBD_INVAL); |
1676 | } |
1677 | DPRINTF(1, "%s: GET probe request successfully\n", DEVNAME(sc)); |
1678 | |
1679 | DPRINTF(1, "bmHint=0x%02x\n", UGETW(pc->bmHint)); |
1680 | DPRINTF(1, "bFormatIndex=0x%02x\n", pc->bFormatIndex); |
1681 | DPRINTF(1, "bFrameIndex=0x%02x\n", pc->bFrameIndex); |
1682 | DPRINTF(1, "dwFrameInterval=%d (100ns units)\n", |
1683 | UGETDW(pc->dwFrameInterval)); |
1684 | DPRINTF(1, "wKeyFrameRate=%d\n", UGETW(pc->wKeyFrameRate)); |
1685 | DPRINTF(1, "wPFrameRate=%d\n", UGETW(pc->wPFrameRate)); |
1686 | DPRINTF(1, "wCompQuality=%d\n", UGETW(pc->wCompQuality)); |
1687 | DPRINTF(1, "wCompWindowSize=%d\n", UGETW(pc->wCompWindowSize)); |
1688 | DPRINTF(1, "wDelay=%d (ms)\n", UGETW(pc->wDelay)); |
1689 | DPRINTF(1, "dwMaxVideoFrameSize=%d (bytes)\n", |
1690 | UGETDW(pc->dwMaxVideoFrameSize)); |
1691 | DPRINTF(1, "dwMaxPayloadTransferSize=%d (bytes)\n", |
1692 | UGETDW(pc->dwMaxPayloadTransferSize)); |
1693 | |
1694 | return (USBD_NORMAL_COMPLETION); |
1695 | } |
1696 | |
1697 | usbd_status |
1698 | uvideo_vs_set_commit(struct uvideo_softc *sc, uint8_t *probe_data) |
1699 | { |
1700 | usb_device_request_t req; |
1701 | usbd_status error; |
1702 | uint16_t tmp; |
1703 | |
1704 | req.bmRequestType = UVIDEO_SET_IF0x21; |
1705 | req.bRequest = SET_CUR0x01; |
1706 | tmp = VS_COMMIT_CONTROL0x02; |
1707 | tmp = tmp << 8; |
1708 | USETW(req.wValue, tmp)(*(u_int16_t *)(req.wValue) = (tmp)); |
1709 | USETW(req.wIndex, sc->sc_vs_cur->iface)(*(u_int16_t *)(req.wIndex) = (sc->sc_vs_cur->iface)); |
1710 | USETW(req.wLength, sc->sc_max_ctrl_size)(*(u_int16_t *)(req.wLength) = (sc->sc_max_ctrl_size)); |
1711 | |
1712 | error = usbd_do_request(sc->sc_udev, &req, probe_data); |
1713 | if (error) { |
1714 | printf("%s: could not SET commit request: %s\n", |
1715 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
1716 | return (USBD_INVAL); |
1717 | } |
1718 | DPRINTF(1, "%s: SET commit request successfully\n", DEVNAME(sc)); |
1719 | |
1720 | return (USBD_NORMAL_COMPLETION); |
1721 | } |
1722 | |
1723 | usbd_status |
1724 | uvideo_vs_alloc_frame(struct uvideo_softc *sc) |
1725 | { |
1726 | struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; |
1727 | |
1728 | fb->buf_size = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxVideoFrameSize)); |
1729 | |
1730 | /* don't overflow the upper layer frame buffer */ |
1731 | if (sc->sc_max_fbuf_size < fb->buf_size && |
1732 | sc->sc_mmap_flag == 0) { |
1733 | printf("%s: software video buffer is too small!\n", |
1734 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1735 | return (USBD_NOMEM); |
1736 | } |
1737 | |
1738 | fb->buf = malloc(fb->buf_size, M_USBDEV102, M_NOWAIT0x0002); |
1739 | if (fb->buf == NULL((void *)0)) { |
1740 | printf("%s: can't allocate frame buffer!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1741 | return (USBD_NOMEM); |
1742 | } |
1743 | |
1744 | DPRINTF(1, "%s: %s: allocated %d bytes frame buffer\n", |
1745 | DEVNAME(sc), __func__, fb->buf_size); |
1746 | |
1747 | fb->sample = 0; |
1748 | fb->fid = 0; |
1749 | fb->offset = 0; |
1750 | fb->fmt_flags = sc->sc_fmtgrp_cur->frame_cur->bDescriptorSubtype == |
1751 | UDESCSUB_VS_FRAME_UNCOMPRESSED0x05 ? 0 : V4L2_FMT_FLAG_COMPRESSED0x0001; |
1752 | |
1753 | return (USBD_NORMAL_COMPLETION); |
1754 | } |
1755 | |
1756 | void |
1757 | uvideo_vs_free_frame(struct uvideo_softc *sc) |
1758 | { |
1759 | struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; |
1760 | |
1761 | if (fb->buf != NULL((void *)0)) { |
1762 | free(fb->buf, M_USBDEV102, fb->buf_size); |
1763 | fb->buf = NULL((void *)0); |
1764 | } |
1765 | |
1766 | if (sc->sc_mmap_buffer != NULL((void *)0)) { |
1767 | free(sc->sc_mmap_buffer, M_USBDEV102, sc->sc_mmap_buffer_size); |
1768 | sc->sc_mmap_buffer = NULL((void *)0); |
1769 | sc->sc_mmap_buffer_size = 0; |
1770 | } |
1771 | |
1772 | while (!SIMPLEQ_EMPTY(&sc->sc_mmap_q)(((&sc->sc_mmap_q)->sqh_first) == ((void *)0))) |
1773 | SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames)do { if (((&sc->sc_mmap_q)->sqh_first = (&sc-> sc_mmap_q)->sqh_first->q_frames.sqe_next) == ((void *)0 )) (&sc->sc_mmap_q)->sqh_last = &(&sc->sc_mmap_q )->sqh_first; } while (0); |
1774 | |
1775 | sc->sc_mmap_count = 0; |
1776 | } |
1777 | |
1778 | usbd_status |
1779 | uvideo_vs_alloc_isoc(struct uvideo_softc *sc) |
1780 | { |
1781 | int size, i; |
1782 | |
1783 | DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); |
1784 | |
1785 | for (i = 0; i < UVIDEO_IXFERS3; i++) { |
1786 | sc->sc_vs_cur->ixfer[i].sc = sc; |
1787 | |
1788 | sc->sc_vs_cur->ixfer[i].xfer = usbd_alloc_xfer(sc->sc_udev); |
1789 | if (sc->sc_vs_cur->ixfer[i].xfer == NULL((void *)0)) { |
1790 | printf("%s: could not allocate isoc VS xfer!\n", |
1791 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1792 | return (USBD_NOMEM); |
1793 | } |
1794 | |
1795 | size = sc->sc_vs_cur->psize * sc->sc_nframes; |
1796 | |
1797 | sc->sc_vs_cur->ixfer[i].buf = |
1798 | usbd_alloc_buffer(sc->sc_vs_cur->ixfer[i].xfer, size); |
1799 | if (sc->sc_vs_cur->ixfer[i].buf == NULL((void *)0)) { |
1800 | printf("%s: could not allocate isoc VS buffer!\n", |
1801 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1802 | return (USBD_NOMEM); |
1803 | } |
1804 | DPRINTF(1, "%s: allocated %d bytes isoc VS xfer buffer\n", |
1805 | DEVNAME(sc), size); |
1806 | } |
1807 | |
1808 | return (USBD_NORMAL_COMPLETION); |
1809 | } |
1810 | |
1811 | usbd_status |
1812 | uvideo_vs_alloc_bulk(struct uvideo_softc *sc) |
1813 | { |
1814 | int size; |
1815 | |
1816 | sc->sc_vs_cur->bxfer.sc = sc; |
1817 | |
1818 | sc->sc_vs_cur->bxfer.xfer = usbd_alloc_xfer(sc->sc_udev); |
1819 | if (sc->sc_vs_cur->bxfer.xfer == NULL((void *)0)) { |
1820 | printf("%s: could not allocate bulk VS xfer!\n", |
1821 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1822 | return (USBD_NOMEM); |
1823 | } |
1824 | |
1825 | size = UGETDW(sc->sc_desc_probe.dwMaxPayloadTransferSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxPayloadTransferSize )); |
1826 | |
1827 | sc->sc_vs_cur->bxfer.buf = |
1828 | usbd_alloc_buffer(sc->sc_vs_cur->bxfer.xfer, size); |
1829 | if (sc->sc_vs_cur->bxfer.buf == NULL((void *)0)) { |
1830 | printf("%s: could not allocate bulk VS buffer!\n", |
1831 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1832 | return (USBD_NOMEM); |
1833 | } |
1834 | DPRINTF(1, "%s: allocated %d bytes bulk VS xfer buffer\n", |
1835 | DEVNAME(sc), size); |
1836 | |
1837 | return (USBD_NORMAL_COMPLETION); |
1838 | } |
1839 | |
1840 | void |
1841 | uvideo_vs_free_isoc(struct uvideo_softc *sc) |
1842 | { |
1843 | int i; |
1844 | |
1845 | DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); |
1846 | |
1847 | for (i = 0; i < UVIDEO_IXFERS3; i++) { |
1848 | if (sc->sc_vs_cur->ixfer[i].buf != NULL((void *)0)) { |
1849 | usbd_free_buffer(sc->sc_vs_cur->ixfer[i].xfer); |
1850 | sc->sc_vs_cur->ixfer[i].buf = NULL((void *)0); |
1851 | } |
1852 | |
1853 | if (sc->sc_vs_cur->ixfer[i].xfer != NULL((void *)0)) { |
1854 | usbd_free_xfer(sc->sc_vs_cur->ixfer[i].xfer); |
1855 | sc->sc_vs_cur->ixfer[i].xfer = NULL((void *)0); |
1856 | } |
1857 | } |
1858 | } |
1859 | |
1860 | void |
1861 | uvideo_vs_free_bulk(struct uvideo_softc *sc) |
1862 | { |
1863 | if (sc->sc_vs_cur->bxfer.buf != NULL((void *)0)) { |
1864 | usbd_free_buffer(sc->sc_vs_cur->bxfer.xfer); |
1865 | sc->sc_vs_cur->bxfer.buf = NULL((void *)0); |
1866 | } |
1867 | |
1868 | if (sc->sc_vs_cur->bxfer.xfer != NULL((void *)0)) { |
1869 | usbd_free_xfer(sc->sc_vs_cur->bxfer.xfer); |
1870 | sc->sc_vs_cur->bxfer.xfer = NULL((void *)0); |
1871 | } |
1872 | } |
1873 | |
1874 | usbd_status |
1875 | uvideo_vs_open(struct uvideo_softc *sc) |
1876 | { |
1877 | usb_endpoint_descriptor_t *ed; |
1878 | usbd_status error; |
1879 | uint32_t dwMaxVideoFrameSize; |
1880 | |
1881 | DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); |
1882 | |
1883 | if (sc->sc_negotiated_flag == 0) { |
1884 | /* do device negotiation with commit */ |
1885 | error = uvideo_vs_negotiation(sc, 1); |
1886 | if (error != USBD_NORMAL_COMPLETION) |
1887 | return (error); |
1888 | } |
1889 | |
1890 | error = uvideo_vs_set_alt(sc, sc->sc_vs_cur->ifaceh, |
1891 | UGETDW(sc->sc_desc_probe.dwMaxPayloadTransferSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxPayloadTransferSize ))); |
1892 | if (error != USBD_NORMAL_COMPLETION) { |
1893 | printf("%s: could not set alternate interface!\n", |
1894 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1895 | return (error); |
1896 | } |
1897 | |
1898 | /* double check if we can access the selected endpoint descriptor */ |
1899 | ed = usbd_get_endpoint_descriptor(sc->sc_vs_cur->ifaceh, |
1900 | sc->sc_vs_cur->endpoint); |
1901 | if (ed == NULL((void *)0)) { |
1902 | printf("%s: no endpoint descriptor for VS iface\n", |
1903 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
1904 | return (USBD_INVAL); |
1905 | } |
1906 | |
1907 | DPRINTF(1, "%s: open pipe for bEndpointAddress=0x%02x\n", |
1908 | DEVNAME(sc), sc->sc_vs_cur->endpoint); |
1909 | error = usbd_open_pipe( |
1910 | sc->sc_vs_cur->ifaceh, |
1911 | sc->sc_vs_cur->endpoint, |
1912 | USBD_EXCLUSIVE_USE0x01, |
1913 | &sc->sc_vs_cur->pipeh); |
1914 | if (error != USBD_NORMAL_COMPLETION) { |
1915 | printf("%s: could not open VS pipe: %s\n", |
1916 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
1917 | return (error); |
1918 | } |
1919 | |
1920 | /* calculate optimal isoc xfer size */ |
1921 | if (strcmp(sc->sc_udev->bus->bdev.dv_cfdata->cf_driver->cd_name, |
1922 | "ohci") == 0) { |
1923 | /* ohci workaround */ |
1924 | sc->sc_nframes = 8; |
1925 | } else { |
1926 | dwMaxVideoFrameSize = |
1927 | UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxVideoFrameSize)); |
1928 | sc->sc_nframes = (dwMaxVideoFrameSize + sc->sc_vs_cur->psize - |
1929 | 1) / sc->sc_vs_cur->psize; |
1930 | } |
1931 | if (sc->sc_nframes > UVIDEO_NFRAMES_MAX40) |
1932 | sc->sc_nframes = UVIDEO_NFRAMES_MAX40; |
1933 | DPRINTF(1, "%s: nframes=%d\n", DEVNAME(sc), sc->sc_nframes); |
1934 | |
1935 | return (USBD_NORMAL_COMPLETION); |
1936 | } |
1937 | |
1938 | void |
1939 | uvideo_vs_close(struct uvideo_softc *sc) |
1940 | { |
1941 | if (sc->sc_vs_cur->bulk_running == 1) { |
1942 | sc->sc_vs_cur->bulk_running = 0; |
1943 | usbd_ref_wait(sc->sc_udev); |
1944 | } |
1945 | |
1946 | if (sc->sc_vs_cur->pipeh) { |
1947 | usbd_close_pipe(sc->sc_vs_cur->pipeh); |
1948 | sc->sc_vs_cur->pipeh = NULL((void *)0); |
1949 | } |
1950 | |
1951 | /* |
1952 | * Some devices need time to shutdown before we switch back to |
1953 | * the default interface (0). Not doing so can leave the device |
1954 | * back in a undefined condition. |
1955 | */ |
1956 | usbd_delay_ms(sc->sc_udev, 100); |
1957 | |
1958 | /* switch back to default interface (turns off cam LED) */ |
1959 | (void)usbd_set_interface(sc->sc_vs_cur->ifaceh, 0); |
1960 | } |
1961 | |
1962 | usbd_status |
1963 | uvideo_vs_init(struct uvideo_softc *sc) |
1964 | { |
1965 | usbd_status error; |
1966 | |
1967 | /* open video stream pipe */ |
1968 | error = uvideo_vs_open(sc); |
1969 | if (error != USBD_NORMAL_COMPLETION) |
1970 | return (USBD_INVAL); |
1971 | |
1972 | /* allocate video stream xfer buffer */ |
1973 | if (sc->sc_vs_cur->bulk_endpoint) |
1974 | error = uvideo_vs_alloc_bulk(sc); |
1975 | else |
1976 | error = uvideo_vs_alloc_isoc(sc); |
1977 | if (error != USBD_NORMAL_COMPLETION) |
1978 | return (USBD_INVAL); |
1979 | |
1980 | /* allocate video stream frame buffer */ |
1981 | error = uvideo_vs_alloc_frame(sc); |
1982 | if (error != USBD_NORMAL_COMPLETION) |
1983 | return (USBD_INVAL); |
1984 | #ifdef UVIDEO_DUMP |
1985 | if (uvideo_debug_file_open(sc) != 0) |
1986 | return (USBD_INVAL); |
1987 | usb_init_task(&sc->sc_task_write, uvideo_debug_file_write_frame, sc,((&sc->sc_task_write)->fun = (uvideo_debug_file_write_frame ), (&sc->sc_task_write)->arg = (sc), (&sc->sc_task_write )->type = (0), (&sc->sc_task_write)->state = 0x0 ) |
1988 | USB_TASK_TYPE_GENERIC)((&sc->sc_task_write)->fun = (uvideo_debug_file_write_frame ), (&sc->sc_task_write)->arg = (sc), (&sc->sc_task_write )->type = (0), (&sc->sc_task_write)->state = 0x0 ); |
1989 | #endif |
1990 | return (USBD_NORMAL_COMPLETION); |
1991 | } |
1992 | |
1993 | int |
1994 | uvideo_vs_start_bulk(struct uvideo_softc *sc) |
1995 | { |
1996 | int error; |
1997 | |
1998 | sc->sc_vs_cur->bulk_running = 1; |
1999 | |
2000 | error = kthread_create(uvideo_vs_start_bulk_thread, sc, NULL((void *)0), |
2001 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
2002 | if (error) { |
2003 | printf("%s: can't create kernel thread!", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
2004 | return (error); |
2005 | } |
2006 | |
2007 | return (0); |
2008 | } |
2009 | |
2010 | void |
2011 | uvideo_vs_start_bulk_thread(void *arg) |
2012 | { |
2013 | struct uvideo_softc *sc = arg; |
2014 | usbd_status error; |
2015 | int size; |
2016 | |
2017 | usbd_ref_incr(sc->sc_udev); |
2018 | while (sc->sc_vs_cur->bulk_running) { |
2019 | size = UGETDW(sc->sc_desc_probe.dwMaxPayloadTransferSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxPayloadTransferSize )); |
2020 | |
2021 | usbd_setup_xfer( |
2022 | sc->sc_vs_cur->bxfer.xfer, |
2023 | sc->sc_vs_cur->pipeh, |
2024 | 0, |
2025 | sc->sc_vs_cur->bxfer.buf, |
2026 | size, |
2027 | USBD_NO_COPY0x01 | USBD_SHORT_XFER_OK0x04 | USBD_SYNCHRONOUS0x02, |
2028 | 0, |
2029 | NULL((void *)0)); |
2030 | error = usbd_transfer(sc->sc_vs_cur->bxfer.xfer); |
2031 | if (error != USBD_NORMAL_COMPLETION) { |
2032 | DPRINTF(1, "%s: error in bulk xfer: %s!\n", |
2033 | DEVNAME(sc), usbd_errstr(error)); |
2034 | break; |
2035 | } |
2036 | |
2037 | DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), size); |
2038 | |
2039 | (void)sc->sc_decode_stream_header(sc, |
2040 | sc->sc_vs_cur->bxfer.buf, size); |
2041 | } |
2042 | usbd_ref_decr(sc->sc_udev); |
2043 | |
2044 | kthread_exit(0); |
2045 | } |
2046 | |
2047 | void |
2048 | uvideo_vs_start_isoc(struct uvideo_softc *sc) |
2049 | { |
2050 | int i; |
2051 | |
2052 | for (i = 0; i < UVIDEO_IXFERS3; i++) |
2053 | uvideo_vs_start_isoc_ixfer(sc, &sc->sc_vs_cur->ixfer[i]); |
2054 | } |
2055 | |
2056 | void |
2057 | uvideo_vs_start_isoc_ixfer(struct uvideo_softc *sc, |
2058 | struct uvideo_isoc_xfer *ixfer) |
2059 | { |
2060 | int i; |
2061 | usbd_status error; |
2062 | |
2063 | DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__); |
2064 | |
2065 | if (usbd_is_dying(sc->sc_udev)) |
2066 | return; |
2067 | |
2068 | for (i = 0; i < sc->sc_nframes; i++) |
2069 | ixfer->size[i] = sc->sc_vs_cur->psize; |
2070 | |
2071 | usbd_setup_isoc_xfer( |
2072 | ixfer->xfer, |
2073 | sc->sc_vs_cur->pipeh, |
2074 | ixfer, |
2075 | ixfer->size, |
2076 | sc->sc_nframes, |
2077 | USBD_NO_COPY0x01 | USBD_SHORT_XFER_OK0x04, |
2078 | uvideo_vs_cb); |
2079 | |
2080 | error = usbd_transfer(ixfer->xfer); |
2081 | if (error && error != USBD_IN_PROGRESS) { |
2082 | DPRINTF(1, "%s: usbd_transfer error=%s!\n", |
2083 | DEVNAME(sc), usbd_errstr(error)); |
2084 | } |
2085 | } |
2086 | |
2087 | void |
2088 | uvideo_vs_cb(struct usbd_xfer *xfer, void *priv, |
2089 | usbd_status status) |
2090 | { |
2091 | struct uvideo_isoc_xfer *ixfer = priv; |
2092 | struct uvideo_softc *sc = ixfer->sc; |
2093 | int len, i, frame_size; |
2094 | uint8_t *frame; |
2095 | usbd_status error; |
2096 | |
2097 | DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__); |
2098 | |
2099 | if (status != USBD_NORMAL_COMPLETION) { |
2100 | DPRINTF(1, "%s: %s: %s\n", DEVNAME(sc), __func__, |
2101 | usbd_errstr(status)); |
2102 | return; |
2103 | } |
2104 | usbd_get_xfer_status(xfer, NULL((void *)0), NULL((void *)0), &len, NULL((void *)0)); |
2105 | |
2106 | DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), len); |
2107 | if (len == 0) |
2108 | goto skip; |
2109 | |
2110 | for (i = 0; i < sc->sc_nframes; i++) { |
2111 | frame = ixfer->buf + (i * sc->sc_vs_cur->psize); |
2112 | frame_size = ixfer->size[i]; |
2113 | |
2114 | if (frame_size == 0) |
2115 | /* frame is empty */ |
2116 | continue; |
2117 | |
2118 | error = sc->sc_decode_stream_header(sc, frame, frame_size); |
2119 | if (error == USBD_CANCELLED) |
2120 | break; |
2121 | } |
2122 | |
2123 | skip: /* setup new transfer */ |
2124 | uvideo_vs_start_isoc_ixfer(sc, ixfer); |
2125 | } |
2126 | |
2127 | usbd_status |
2128 | uvideo_vs_decode_stream_header(struct uvideo_softc *sc, uint8_t *frame, |
2129 | int frame_size) |
2130 | { |
2131 | struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; |
2132 | struct usb_video_stream_header *sh; |
2133 | int sample_len; |
2134 | |
2135 | if (frame_size < UVIDEO_SH_MIN_LEN2) |
2136 | /* frame too small to contain a valid stream header */ |
2137 | return (USBD_INVAL); |
2138 | |
2139 | sh = (struct usb_video_stream_header *)frame; |
2140 | |
2141 | DPRINTF(2, "%s: stream header len = %d\n", DEVNAME(sc), sh->bLength); |
2142 | |
2143 | if (sh->bLength > UVIDEO_SH_MAX_LEN12 || sh->bLength < UVIDEO_SH_MIN_LEN2) |
2144 | /* invalid header size */ |
2145 | return (USBD_INVAL); |
2146 | if (sh->bLength == frame_size && !(sh->bFlags & UVIDEO_SH_FLAG_EOF(1 << 1))) { |
2147 | /* stream header without payload and no EOF */ |
2148 | return (USBD_INVAL); |
2149 | } |
2150 | if (sh->bFlags & UVIDEO_SH_FLAG_ERR(1 << 6)) { |
2151 | /* stream error, skip xfer */ |
2152 | DPRINTF(1, "%s: %s: stream error!\n", DEVNAME(sc), __func__); |
2153 | return (USBD_CANCELLED); |
2154 | } |
2155 | |
2156 | DPRINTF(2, "%s: frame_size = %d\n", DEVNAME(sc), frame_size); |
2157 | |
2158 | if (sh->bFlags & UVIDEO_SH_FLAG_FID(1 << 0)) { |
2159 | DPRINTF(2, "%s: %s: FID ON (0x%02x)\n", |
2160 | DEVNAME(sc), __func__, |
2161 | sh->bFlags & UVIDEO_SH_FLAG_FID); |
2162 | } else { |
2163 | DPRINTF(2, "%s: %s: FID OFF (0x%02x)\n", |
2164 | DEVNAME(sc), __func__, |
2165 | sh->bFlags & UVIDEO_SH_FLAG_FID); |
2166 | } |
2167 | |
2168 | if (fb->sample == 0) { |
2169 | /* first sample for a frame */ |
2170 | fb->sample = 1; |
2171 | fb->fid = sh->bFlags & UVIDEO_SH_FLAG_FID(1 << 0); |
2172 | fb->offset = 0; |
2173 | } else { |
2174 | /* continues sample for a frame, check consistency */ |
2175 | if (fb->fid != (sh->bFlags & UVIDEO_SH_FLAG_FID(1 << 0))) { |
2176 | DPRINTF(1, "%s: %s: wrong FID, ignore last frame!\n", |
2177 | DEVNAME(sc), __func__); |
2178 | fb->sample = 1; |
2179 | fb->fid = sh->bFlags & UVIDEO_SH_FLAG_FID(1 << 0); |
2180 | fb->offset = 0; |
2181 | } |
2182 | } |
2183 | |
2184 | /* save sample */ |
2185 | sample_len = frame_size - sh->bLength; |
2186 | if ((fb->offset + sample_len) <= fb->buf_size) { |
2187 | bcopy(frame + sh->bLength, fb->buf + fb->offset, sample_len); |
2188 | fb->offset += sample_len; |
2189 | } |
2190 | |
2191 | if (sh->bFlags & UVIDEO_SH_FLAG_EOF(1 << 1)) { |
2192 | /* got a full frame */ |
2193 | DPRINTF(2, "%s: %s: EOF (frame size = %d bytes)\n", |
2194 | DEVNAME(sc), __func__, fb->offset); |
2195 | |
2196 | if (fb->offset > fb->buf_size) { |
2197 | DPRINTF(1, "%s: %s: frame too large, skipped!\n", |
2198 | DEVNAME(sc), __func__); |
2199 | } else if (fb->offset < fb->buf_size && |
2200 | !(fb->fmt_flags & V4L2_FMT_FLAG_COMPRESSED0x0001)) { |
2201 | DPRINTF(1, "%s: %s: frame too small, skipped!\n", |
2202 | DEVNAME(sc), __func__); |
2203 | } else { |
2204 | #ifdef UVIDEO_DUMP |
2205 | /* do the file write in process context */ |
2206 | usb_rem_task(sc->sc_udev, &sc->sc_task_write); |
2207 | usb_add_task(sc->sc_udev, &sc->sc_task_write); |
2208 | #endif |
2209 | if (sc->sc_mmap_flag) { |
2210 | /* mmap */ |
2211 | if (uvideo_mmap_queue(sc, fb->buf, fb->offset)) |
2212 | return (USBD_NOMEM); |
2213 | } else { |
2214 | /* read */ |
2215 | uvideo_read(sc, fb->buf, fb->offset); |
2216 | } |
2217 | } |
2218 | |
2219 | fb->sample = 0; |
2220 | fb->fid = 0; |
2221 | } |
2222 | |
2223 | return (USBD_NORMAL_COMPLETION); |
2224 | } |
2225 | |
2226 | /* |
2227 | * XXX Doesn't work yet. Fix it! |
2228 | * |
2229 | * The iSight first generation device uses a own, non-standard streaming |
2230 | * protocol. The stream header is just sent once per image and looks |
2231 | * like following: |
2232 | * |
2233 | * uByte header length |
2234 | * uByte flags |
2235 | * uByte magic1[4] always "11223344" |
2236 | * uByte magic2[8] always "deadbeefdeadface" |
2237 | * uByte unknown[16] |
2238 | * |
2239 | * Sometimes the stream header is prefixed by a unknown byte. Therefore |
2240 | * we check for the magic value on two offsets. |
2241 | */ |
2242 | usbd_status |
2243 | uvideo_vs_decode_stream_header_isight(struct uvideo_softc *sc, uint8_t *frame, |
2244 | int frame_size) |
2245 | { |
2246 | struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; |
2247 | int sample_len, header = 0; |
2248 | uint8_t magic[] = { |
2249 | 0x11, 0x22, 0x33, 0x44, |
2250 | 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xfa, 0xce }; |
2251 | |
2252 | if (frame_size > 13 && !memcmp(&frame[2], magic, 12)__builtin_memcmp((&frame[2]), (magic), (12))) |
2253 | header = 1; |
2254 | if (frame_size > 14 && !memcmp(&frame[3], magic, 12)__builtin_memcmp((&frame[3]), (magic), (12))) |
2255 | header = 1; |
2256 | |
2257 | if (header && fb->fid == 0) { |
2258 | fb->fid = 1; |
2259 | return (USBD_NORMAL_COMPLETION); |
2260 | } |
2261 | |
2262 | if (header) { |
2263 | if (sc->sc_mmap_flag) { |
2264 | /* mmap */ |
2265 | if (uvideo_mmap_queue(sc, fb->buf, fb->offset)) |
2266 | return (USBD_NOMEM); |
2267 | } else { |
2268 | /* read */ |
2269 | uvideo_read(sc, fb->buf, fb->offset); |
2270 | } |
2271 | fb->offset = 0; |
2272 | } else { |
2273 | /* save sample */ |
2274 | sample_len = frame_size; |
2275 | if ((fb->offset + sample_len) <= fb->buf_size) { |
2276 | bcopy(frame, fb->buf + fb->offset, sample_len); |
2277 | fb->offset += sample_len; |
2278 | } |
2279 | } |
2280 | |
2281 | return (USBD_NORMAL_COMPLETION); |
2282 | } |
2283 | |
2284 | int |
2285 | uvideo_mmap_queue(struct uvideo_softc *sc, uint8_t *buf, int len) |
2286 | { |
2287 | int i; |
2288 | |
2289 | if (sc->sc_mmap_count == 0 || sc->sc_mmap_buffer == NULL((void *)0)) |
2290 | panic("%s: mmap buffers not allocated", __func__); |
2291 | |
2292 | /* find a buffer which is ready for queueing */ |
2293 | for (i = 0; i < sc->sc_mmap_count; i++) { |
2294 | if (sc->sc_mmap[i].v4l2_buf.flags & V4L2_BUF_FLAG_QUEUED0x00000002) |
2295 | break; |
2296 | } |
2297 | if (i == sc->sc_mmap_count) { |
2298 | DPRINTF(1, "%s: %s: mmap queue is full!", |
2299 | DEVNAME(sc), __func__); |
2300 | return ENOMEM12; |
2301 | } |
2302 | |
2303 | /* copy frame to mmap buffer and report length */ |
2304 | bcopy(buf, sc->sc_mmap[i].buf, len); |
2305 | sc->sc_mmap[i].v4l2_buf.bytesused = len; |
2306 | |
2307 | /* timestamp it */ |
2308 | getmicrotime(&sc->sc_mmap[i].v4l2_buf.timestamp); |
2309 | |
2310 | /* queue it */ |
2311 | sc->sc_mmap[i].v4l2_buf.flags |= V4L2_BUF_FLAG_DONE0x00000004; |
2312 | sc->sc_mmap[i].v4l2_buf.flags &= ~V4L2_BUF_FLAG_QUEUED0x00000002; |
2313 | SIMPLEQ_INSERT_TAIL(&sc->sc_mmap_q, &sc->sc_mmap[i], q_frames)do { (&sc->sc_mmap[i])->q_frames.sqe_next = ((void * )0); *(&sc->sc_mmap_q)->sqh_last = (&sc->sc_mmap [i]); (&sc->sc_mmap_q)->sqh_last = &(&sc-> sc_mmap[i])->q_frames.sqe_next; } while (0); |
2314 | DPRINTF(2, "%s: %s: frame queued on index %d\n", |
2315 | DEVNAME(sc), __func__, i); |
2316 | |
2317 | wakeup(sc); |
2318 | |
2319 | /* |
2320 | * In case userland uses poll(2), signal that we have a frame |
2321 | * ready to dequeue. |
2322 | */ |
2323 | sc->sc_uplayer_intr(sc->sc_uplayer_arg); |
2324 | |
2325 | return 0; |
2326 | } |
2327 | |
2328 | void |
2329 | uvideo_read(struct uvideo_softc *sc, uint8_t *buf, int len) |
2330 | { |
2331 | /* |
2332 | * Copy video frame to upper layer buffer and call |
2333 | * upper layer interrupt. |
2334 | */ |
2335 | *sc->sc_uplayer_fsize = len; |
2336 | bcopy(buf, sc->sc_uplayer_fbuffer, len); |
2337 | sc->sc_uplayer_intr(sc->sc_uplayer_arg); |
2338 | } |
2339 | |
2340 | #ifdef UVIDEO_DEBUG |
2341 | void |
2342 | uvideo_dump_desc_all(struct uvideo_softc *sc) |
2343 | { |
2344 | struct usbd_desc_iter iter; |
2345 | const usb_descriptor_t *desc; |
2346 | |
2347 | usbd_desc_iter_init(sc->sc_udev, &iter); |
2348 | desc = usbd_desc_iter_next(&iter); |
2349 | while (desc) { |
2350 | printf("bLength=%d\n", desc->bLength); |
2351 | printf("bDescriptorType=0x%02x", desc->bDescriptorType); |
2352 | |
2353 | switch (desc->bDescriptorType) { |
2354 | case UDESC_CS_INTERFACE0x24: |
2355 | printf(" (CS_INTERFACE)\n"); |
2356 | |
2357 | switch (desc->bDescriptorSubtype) { |
2358 | case UDESCSUB_VC_HEADER0x01: |
2359 | printf("bDescriptorSubtype=0x%02x", |
2360 | desc->bDescriptorSubtype); |
2361 | if (uvideo_desc_len(desc, 12, 11, 1, 0)) { |
2362 | printf(" (UDESCSUB_VC_HEADER)\n"); |
2363 | printf("|\n"); |
2364 | uvideo_dump_desc_vc_header(sc, desc); |
2365 | break; |
2366 | } |
2367 | if (uvideo_desc_len(desc, 13, 3, 0, 12)) { |
2368 | printf(" (UDESCSUB_VS_INPUT_HEADER)\n"); |
2369 | printf("|\n"); |
2370 | uvideo_dump_desc_input_header(sc, desc); |
2371 | break; |
2372 | } |
2373 | printf(" (unknown)\n"); |
2374 | break; |
2375 | case UDESCSUB_VC_INPUT_TERMINAL0x02: |
2376 | printf("bDescriptorSubtype=0x%02x", |
2377 | desc->bDescriptorSubtype); |
2378 | printf(" (UDESCSUB_VC_INPUT_TERMINAL)\n"); |
2379 | printf("|\n"); |
2380 | uvideo_dump_desc_input(sc, desc); |
2381 | break; |
2382 | case UDESCSUB_VC_OUTPUT_TERMINAL0x03: |
2383 | printf("bDescriptorSubtype=0x%02x", |
2384 | desc->bDescriptorSubtype); |
2385 | printf(" (UDESCSUB_VC_OUTPUT)\n"); |
2386 | printf("|\n"); |
2387 | uvideo_dump_desc_output(sc, desc); |
2388 | break; |
2389 | case UDESCSUB_VC_SELECTOR_UNIT0x04: |
2390 | printf("bDescriptorSubtype=0x%02x", |
2391 | desc->bDescriptorSubtype); |
2392 | if (desc->bLength == 27) { |
2393 | printf(" (UDESCSUB_VS_FORMAT_" |
2394 | "UNCOMPRESSED)\n"); |
2395 | uvideo_dump_desc_format_uncompressed( |
2396 | sc, desc); |
2397 | } else { |
2398 | printf(" (UDESCSUB_VC_SELECTOR_" |
2399 | "UNIT)\n"); |
2400 | /* TODO */ |
2401 | } |
2402 | break; |
2403 | case UDESCSUB_VC_PROCESSING_UNIT0x05: |
2404 | printf("bDescriptorSubtype=0x%02x", |
2405 | desc->bDescriptorSubtype); |
2406 | if (desc->bLength > |
2407 | sizeof(struct usb_video_frame_desc)) { |
2408 | printf(" (UDESCSUB_VS_FRAME_" |
2409 | "UNCOMPRESSED)\n"); |
2410 | uvideo_dump_desc_frame(sc, desc); |
2411 | } else { |
2412 | printf(" (UDESCSUB_VC_PROCESSING_" |
2413 | "UNIT)\n"); |
2414 | printf("|\n"); |
2415 | uvideo_dump_desc_processing(sc, desc); |
2416 | } |
2417 | break; |
2418 | case UDESCSUB_VC_EXTENSION_UNIT0x06: |
2419 | printf("bDescriptorSubtype=0x%02x", |
2420 | desc->bDescriptorSubtype); |
2421 | if (desc->bLength == 11) { |
2422 | printf(" (UDESCSUB_VS_FORMAT_MJPEG)\n"); |
2423 | printf("|\n"); |
2424 | uvideo_dump_desc_format_mjpeg(sc, desc); |
2425 | } else { |
2426 | printf(" (UDESCSUB_VC_EXTENSION_" |
2427 | "UNIT)\n"); |
2428 | printf("|\n"); |
2429 | uvideo_dump_desc_extension(sc, desc); |
2430 | } |
2431 | break; |
2432 | case UDESCSUB_VS_FRAME_MJPEG0x07: |
2433 | printf("bDescriptorSubtype=0x%02x", |
2434 | desc->bDescriptorSubtype); |
2435 | printf(" (UDESCSUB_VS_FRAME_MJPEG)\n"); |
2436 | if (desc->bLength > |
2437 | sizeof(struct usb_video_frame_desc)) { |
2438 | printf("|\n"); |
2439 | uvideo_dump_desc_frame(sc, desc); |
2440 | } |
2441 | break; |
2442 | case UDESCSUB_VS_COLORFORMAT0x0d: |
2443 | printf("bDescriptorSubtype=0x%02x", |
2444 | desc->bDescriptorSubtype); |
2445 | printf(" (UDESCSUB_VS_COLORFORMAT)\n"); |
2446 | printf("|\n"); |
2447 | uvideo_dump_desc_colorformat(sc, desc); |
2448 | break; |
2449 | } |
2450 | |
2451 | break; |
2452 | case UDESC_CS_ENDPOINT0x25: |
2453 | printf(" (UDESC_CS_ENDPOINT)\n"); |
2454 | |
2455 | switch (desc->bDescriptorSubtype) { |
2456 | case EP_INTERRUPT0x03: |
2457 | printf("bDescriptorSubtype=0x%02x", |
2458 | desc->bDescriptorSubtype); |
2459 | printf(" (EP_INTERRUPT)\n"); |
2460 | printf("|\n"); |
2461 | uvideo_dump_desc_cs_endpoint(sc, desc); |
2462 | break; |
2463 | case EP_GENERAL0x01: |
2464 | printf("bDescriptorSubtype=0x%02x", |
2465 | desc->bDescriptorSubtype); |
2466 | printf(" (EP_GENERAL)\n"); |
2467 | printf("|\n"); |
2468 | uvideo_dump_desc_cs_endpoint(sc, desc); |
2469 | break; |
2470 | } |
2471 | |
2472 | break; |
2473 | case UDESC_CONFIG0x02: |
2474 | printf(" (UDESC_CONFIG)\n"); |
2475 | printf("|\n"); |
2476 | uvideo_dump_desc_config(sc, desc); |
2477 | break; |
2478 | case UDESC_ENDPOINT0x05: |
2479 | printf(" (UDESC_ENDPOINT)\n"); |
2480 | printf("|\n"); |
2481 | uvideo_dump_desc_endpoint(sc, desc); |
2482 | break; |
2483 | case UDESC_INTERFACE0x04: |
2484 | printf(" (UDESC_INTERFACE)\n"); |
2485 | printf("|\n"); |
2486 | uvideo_dump_desc_interface(sc, desc); |
2487 | break; |
2488 | case UDESC_IFACE_ASSOC0x0B: |
2489 | printf(" (UDESC_IFACE_ASSOC)\n"); |
2490 | printf("|\n"); |
2491 | uvideo_dump_desc_iface_assoc(sc, desc); |
2492 | break; |
2493 | default: |
2494 | printf(" (unknown)\n"); |
2495 | break; |
2496 | } |
2497 | |
2498 | printf("\n"); |
2499 | |
2500 | desc = usbd_desc_iter_next(&iter); |
2501 | } |
2502 | |
2503 | } |
2504 | |
2505 | void |
2506 | uvideo_dump_desc_vc_header(struct uvideo_softc *sc, |
2507 | const usb_descriptor_t *desc) |
2508 | { |
2509 | struct usb_video_header_desc *d; |
2510 | |
2511 | d = (struct usb_video_header_desc *)(uint8_t *)desc; |
2512 | |
2513 | printf("bLength=%d\n", d->bLength); |
2514 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2515 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2516 | printf("bcdUVC=0x%04x\n", UGETW(d->bcdUVC)(*(u_int16_t *)(d->bcdUVC))); |
2517 | printf("wTotalLength=%d\n", UGETW(d->wTotalLength)(*(u_int16_t *)(d->wTotalLength))); |
2518 | printf("dwClockFrequency=%d\n", UGETDW(d->dwClockFrequency)(*(u_int32_t *)(d->dwClockFrequency))); |
2519 | printf("bInCollection=0x%02x\n", d->bInCollection); |
2520 | } |
2521 | |
2522 | void |
2523 | uvideo_dump_desc_input_header(struct uvideo_softc *sc, |
2524 | const usb_descriptor_t *desc) |
2525 | { |
2526 | struct usb_video_input_header_desc *d; |
2527 | |
2528 | d = (struct usb_video_input_header_desc *)(uint8_t *)desc; |
2529 | |
2530 | printf("bLength=%d\n", d->bLength); |
2531 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2532 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2533 | printf("bNumFormats=%d\n", d->bNumFormats); |
2534 | printf("wTotalLength=%d\n", UGETW(d->wTotalLength)(*(u_int16_t *)(d->wTotalLength))); |
2535 | printf("bEndpointAddress=0x%02x\n", d->bEndpointAddress); |
2536 | printf("bmInfo=0x%02x\n", d->bmInfo); |
2537 | printf("bTerminalLink=0x%02x\n", d->bTerminalLink); |
2538 | printf("bStillCaptureMethod=0x%02x\n", d->bStillCaptureMethod); |
2539 | printf("bTriggerSupport=0x%02x\n", d->bTriggerSupport); |
2540 | printf("bTriggerUsage=0x%02x\n", d->bTriggerUsage); |
2541 | printf("bControlSize=%d\n", d->bControlSize); |
2542 | } |
2543 | |
2544 | void |
2545 | uvideo_dump_desc_input(struct uvideo_softc *sc, |
2546 | const usb_descriptor_t *desc) |
2547 | { |
2548 | struct usb_video_input_terminal_desc *d; |
2549 | |
2550 | d = (struct usb_video_input_terminal_desc *)(uint8_t *)desc; |
2551 | |
2552 | printf("bLength=%d\n", d->bLength); |
2553 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2554 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2555 | printf("bTerminalID=0x%02x\n", d->bTerminalID); |
2556 | printf("wTerminalType=0x%04x\n", UGETW(d->wTerminalType)(*(u_int16_t *)(d->wTerminalType))); |
2557 | printf("bAssocTerminal=0x%02x\n", d->bAssocTerminal); |
2558 | printf("iTerminal=0x%02x\n", d->iTerminal); |
2559 | } |
2560 | |
2561 | void |
2562 | uvideo_dump_desc_output(struct uvideo_softc *sc, |
2563 | const usb_descriptor_t *desc) |
2564 | { |
2565 | struct usb_video_output_terminal_desc *d; |
2566 | |
2567 | d = (struct usb_video_output_terminal_desc *)(uint8_t *)desc; |
2568 | |
2569 | printf("bLength=%d\n", d->bLength); |
2570 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2571 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2572 | printf("bTerminalID=0x%02x\n", d->bTerminalID); |
2573 | printf("bAssocTerminal=0x%02x\n", d->bAssocTerminal); |
2574 | printf("bSourceID=0x%02x\n", d->bSourceID); |
2575 | printf("iTerminal=0x%02x\n", d->iTerminal); |
2576 | |
2577 | } |
2578 | |
2579 | void |
2580 | uvideo_dump_desc_endpoint(struct uvideo_softc *sc, |
2581 | const usb_descriptor_t *desc) |
2582 | { |
2583 | usb_endpoint_descriptor_t *d; |
2584 | |
2585 | d = (usb_endpoint_descriptor_t *)(uint8_t *)desc; |
2586 | |
2587 | printf("bLength=%d\n", d->bLength); |
2588 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2589 | printf("bEndpointAddress=0x%02x", d->bEndpointAddress); |
2590 | if (UE_GET_DIR(d->bEndpointAddress)((d->bEndpointAddress) & 0x80) == UE_DIR_IN0x80) |
2591 | printf(" (IN)\n"); |
2592 | if (UE_GET_DIR(d->bEndpointAddress)((d->bEndpointAddress) & 0x80) == UE_DIR_OUT0x00) |
2593 | printf(" (OUT)\n"); |
2594 | printf("bmAttributes=0x%02x", d->bmAttributes); |
2595 | if (UE_GET_XFERTYPE(d->bmAttributes)((d->bmAttributes) & 0x03) == UE_ISOCHRONOUS0x01) { |
2596 | printf(" (UE_ISOCHRONOUS,"); |
2597 | if (UE_GET_ISO_TYPE(d->bmAttributes)((d->bmAttributes) & 0x0c) == UE_ISO_ASYNC0x04) |
2598 | printf(" UE_ISO_ASYNC)\n"); |
2599 | if (UE_GET_ISO_TYPE(d->bmAttributes)((d->bmAttributes) & 0x0c) == UE_ISO_ADAPT0x08) |
2600 | printf(" UE_ISO_ADAPT)\n"); |
2601 | if (UE_GET_ISO_TYPE(d->bmAttributes)((d->bmAttributes) & 0x0c) == UE_ISO_SYNC0x0c) |
2602 | printf(" UE_ISO_SYNC)\n"); |
2603 | } |
2604 | if (UE_GET_XFERTYPE(d->bmAttributes)((d->bmAttributes) & 0x03) == UE_CONTROL0x00) |
2605 | printf(" (UE_CONTROL)\n"); |
2606 | if (UE_GET_XFERTYPE(d->bmAttributes)((d->bmAttributes) & 0x03) == UE_BULK0x02) |
2607 | printf(" (UE_BULK)\n"); |
2608 | if (UE_GET_XFERTYPE(d->bmAttributes)((d->bmAttributes) & 0x03) == UE_INTERRUPT0x03) |
2609 | printf(" (UE_INTERRUPT)\n"); |
2610 | printf("wMaxPacketSize=%d\n", UGETW(d->wMaxPacketSize)(*(u_int16_t *)(d->wMaxPacketSize))); |
2611 | printf("bInterval=0x%02x\n", d->bInterval); |
2612 | } |
2613 | |
2614 | void |
2615 | uvideo_dump_desc_iface_assoc(struct uvideo_softc *sc, |
2616 | const usb_descriptor_t *desc) |
2617 | { |
2618 | usb_interface_assoc_descriptor_t *d; |
2619 | |
2620 | d = (usb_interface_assoc_descriptor_t *)(uint8_t *)desc; |
2621 | |
2622 | printf("bLength=%d\n", d->bLength); |
2623 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2624 | printf("bFirstInterface=0x%02x\n", d->bFirstInterface); |
2625 | printf("bInterfaceCount=%d\n", d->bInterfaceCount); |
2626 | printf("bFunctionClass=0x%02x\n", d->bFunctionClass); |
2627 | printf("bFunctionSubClass=0x%02x\n", d->bFunctionSubClass); |
2628 | printf("bFunctionProtocol=0x%02x\n", d->bFunctionProtocol); |
2629 | printf("iFunction=0x%02x\n", d->iFunction); |
2630 | } |
2631 | |
2632 | void |
2633 | uvideo_dump_desc_interface(struct uvideo_softc *sc, |
2634 | const usb_descriptor_t *desc) |
2635 | { |
2636 | usb_interface_descriptor_t *d; |
2637 | |
2638 | d = (usb_interface_descriptor_t *)(uint8_t *)desc; |
2639 | |
2640 | printf("bLength=%d\n", d->bLength); |
2641 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2642 | printf("bInterfaceNumber=0x%02x\n", d->bInterfaceNumber); |
2643 | printf("bAlternateSetting=0x%02x\n", d->bAlternateSetting); |
2644 | printf("bNumEndpoints=%d\n", d->bNumEndpoints); |
2645 | printf("bInterfaceClass=0x%02x\n", d->bInterfaceClass); |
2646 | printf("bInterfaceSubClass=0x%02x\n", d->bInterfaceSubClass); |
2647 | printf("bInterfaceProtocol=0x%02x\n", d->bInterfaceProtocol); |
2648 | printf("iInterface=0x%02x\n", d->iInterface); |
2649 | } |
2650 | |
2651 | void |
2652 | uvideo_dump_desc_config(struct uvideo_softc *sc, |
2653 | const usb_descriptor_t *desc) |
2654 | { |
2655 | usb_config_descriptor_t *d; |
2656 | |
2657 | d = (usb_config_descriptor_t *)(uint8_t *)desc; |
2658 | |
2659 | printf("bLength=%d\n", d->bLength); |
2660 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2661 | printf("wTotalLength=%d\n", UGETW(d->wTotalLength)(*(u_int16_t *)(d->wTotalLength))); |
2662 | printf("bNumInterfaces=0x%02x\n", d->bNumInterfaces); |
2663 | printf("bConfigurationValue=0x%02x\n", d->bConfigurationValue); |
2664 | printf("iConfiguration=0x%02x\n", d->iConfiguration); |
2665 | printf("bmAttributes=0x%02x\n", d->bmAttributes); |
2666 | printf("bMaxPower=0x%02x\n", d->bMaxPower); |
2667 | } |
2668 | |
2669 | void |
2670 | uvideo_dump_desc_cs_endpoint(struct uvideo_softc *sc, |
2671 | const usb_descriptor_t *desc) |
2672 | { |
2673 | struct usb_video_vc_endpoint_desc *d; |
2674 | |
2675 | d = (struct usb_video_vc_endpoint_desc *)(uint8_t *)desc; |
2676 | |
2677 | printf("bLength=%d\n", d->bLength); |
2678 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2679 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2680 | printf("wMaxTransferSize=%d\n", UGETW(d->wMaxTransferSize)(*(u_int16_t *)(d->wMaxTransferSize))); |
2681 | } |
2682 | |
2683 | void |
2684 | uvideo_dump_desc_colorformat(struct uvideo_softc *sc, |
2685 | const usb_descriptor_t *desc) |
2686 | { |
2687 | struct usb_video_color_matching_descr *d; |
2688 | |
2689 | d = (struct usb_video_color_matching_descr *)(uint8_t *)desc; |
2690 | |
2691 | printf("bLength=%d\n", d->bLength); |
2692 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2693 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2694 | printf("bColorPrimaries=0x%02x\n", d->bColorPrimaries); |
2695 | printf("bTransferCharacteristics=0x%02x\n", |
2696 | d->bTransferCharacteristics); |
2697 | printf("bMatrixCoefficients=0x%02x\n", d->bMatrixCoefficients); |
2698 | } |
2699 | void |
2700 | uvideo_dump_desc_format_mjpeg(struct uvideo_softc *sc, |
2701 | const usb_descriptor_t *desc) |
2702 | { |
2703 | struct usb_video_format_mjpeg_desc *d; |
2704 | |
2705 | d = (struct usb_video_format_mjpeg_desc *)(uint8_t *)desc; |
2706 | |
2707 | printf("bLength=%d\n", d->bLength); |
2708 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2709 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2710 | printf("bFormatIndex=0x%02x\n", d->bFormatIndex); |
2711 | printf("bNumFrameDescriptors=0x%02x\n", d->bNumFrameDescriptors); |
2712 | printf("bmFlags=0x%02x\n", d->bmFlags); |
2713 | printf("bDefaultFrameIndex=0x%02x\n", d->bDefaultFrameIndex); |
2714 | printf("bAspectRatioX=0x%02x\n", d->bAspectRatioX); |
2715 | printf("bAspectRatioY=0x%02x\n", d->bAspectRatioY); |
2716 | printf("bmInterlaceFlags=0x%02x\n", d->bmInterlaceFlags); |
2717 | printf("bCopyProtect=0x%02x\n", d->bCopyProtect); |
2718 | } |
2719 | |
2720 | void |
2721 | uvideo_dump_desc_frame(struct uvideo_softc *sc, const usb_descriptor_t *desc) |
2722 | { |
2723 | struct usb_video_frame_desc *d; |
2724 | uint8_t *p; |
2725 | int length, i; |
2726 | |
2727 | d = (struct usb_video_frame_desc *)(uint8_t *)desc; |
2728 | |
2729 | printf("bLength=%d\n", d->bLength); |
2730 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2731 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2732 | printf("bFrameIndex=0x%02x\n", d->bFrameIndex); |
2733 | printf("bmCapabilities=0x%02x\n", d->bmCapabilities); |
2734 | printf("wWidth=%d\n", UGETW(d->wWidth)(*(u_int16_t *)(d->wWidth))); |
2735 | printf("wHeight=%d\n", UGETW(d->wHeight)(*(u_int16_t *)(d->wHeight))); |
2736 | printf("dwMinBitRate=%d\n", UGETDW(d->dwMinBitRate)(*(u_int32_t *)(d->dwMinBitRate))); |
2737 | printf("dwMaxBitRate=%d\n", UGETDW(d->dwMaxBitRate)(*(u_int32_t *)(d->dwMaxBitRate))); |
2738 | printf("dwMaxVideoFrameBufferSize=%d\n", |
2739 | UGETDW(d->dwMaxVideoFrameBufferSize)(*(u_int32_t *)(d->dwMaxVideoFrameBufferSize))); |
2740 | printf("dwDefaultFrameInterval=%d\n", |
2741 | UGETDW(d->dwDefaultFrameInterval)(*(u_int32_t *)(d->dwDefaultFrameInterval))); |
2742 | printf("bFrameIntervalType=0x%02x\n", d->bFrameIntervalType); |
2743 | |
2744 | p = (uint8_t *)d; |
2745 | p += sizeof(struct usb_video_frame_desc); |
2746 | |
2747 | if (!d->bFrameIntervalType) { |
2748 | /* continuous */ |
2749 | if (d->bLength < (sizeof(struct usb_video_frame_desc) + |
2750 | sizeof(uDWord) * 3)) { |
2751 | printf("invalid frame descriptor length\n"); |
2752 | } else { |
2753 | printf("dwMinFrameInterval = %d\n", UGETDW(p)(*(u_int32_t *)(p))); |
2754 | p += sizeof(uDWord); |
2755 | printf("dwMaxFrameInterval = %d\n", UGETDW(p)(*(u_int32_t *)(p))); |
2756 | p += sizeof(uDWord); |
2757 | printf("dwFrameIntervalStep = %d\n", UGETDW(p)(*(u_int32_t *)(p))); |
2758 | p += sizeof(uDWord); |
2759 | } |
2760 | } else { |
2761 | /* discrete */ |
2762 | length = d->bLength - sizeof(struct usb_video_frame_desc); |
2763 | for (i = 0; i < d->bFrameIntervalType; i++) { |
2764 | if (length <= 0) { |
2765 | printf("frame descriptor ended early\n"); |
2766 | break; |
2767 | } |
2768 | printf("dwFrameInterval = %d\n", UGETDW(p)(*(u_int32_t *)(p))); |
2769 | p += sizeof(uDWord); |
2770 | length -= sizeof(uDWord); |
2771 | } |
2772 | } |
2773 | } |
2774 | |
2775 | void |
2776 | uvideo_dump_desc_format_uncompressed(struct uvideo_softc *sc, |
2777 | const usb_descriptor_t *desc) |
2778 | { |
2779 | struct usb_video_format_uncompressed_desc *d; |
2780 | |
2781 | d = (struct usb_video_format_uncompressed_desc *)(uint8_t *)desc; |
2782 | |
2783 | printf("bLength=%d\n", d->bLength); |
2784 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2785 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2786 | printf("bFormatIndex=0x%02x\n", d->bFormatIndex); |
2787 | printf("bNumFrameDescriptors=0x%02x\n", d->bNumFrameDescriptors); |
2788 | printf("guidFormat=%s\n", d->guidFormat); |
2789 | printf("bBitsPerPixel=0x%02x\n", d->bBitsPerPixel); |
2790 | printf("bDefaultFrameIndex=0x%02x\n", d->bDefaultFrameIndex); |
2791 | printf("bAspectRatioX=0x%02x\n", d->bAspectRatioX); |
2792 | printf("bAspectRatioY=0x%02x\n", d->bAspectRatioY); |
2793 | printf("bmInterlaceFlags=0x%02x\n", d->bmInterlaceFlags); |
2794 | printf("bCopyProtect=0x%02x\n", d->bCopyProtect); |
2795 | } |
2796 | |
2797 | void |
2798 | uvideo_dump_desc_processing(struct uvideo_softc *sc, |
2799 | const usb_descriptor_t *desc) |
2800 | { |
2801 | struct usb_video_vc_processing_desc *d; |
2802 | |
2803 | /* PU descriptor is variable sized */ |
2804 | d = (void *)desc; |
2805 | |
2806 | printf("bLength=%d\n", d->bLength); |
2807 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2808 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2809 | printf("bUnitID=0x%02x\n", d->bUnitID); |
2810 | printf("bSourceID=0x%02x\n", d->bSourceID); |
2811 | printf("wMaxMultiplier=%d\n", UGETW(d->wMaxMultiplier)(*(u_int16_t *)(d->wMaxMultiplier))); |
2812 | printf("bControlSize=%d\n", d->bControlSize); |
2813 | printf("bmControls=0x"); |
2814 | uvideo_hexdump(d->bmControls, d->bControlSize, 1); |
2815 | printf("iProcessing=0x%02x\n", d->bmControls[d->bControlSize]); |
2816 | printf("bmVideoStandards=0x%02x\n", d->bmControls[d->bControlSize + 1]); |
2817 | } |
2818 | |
2819 | void |
2820 | uvideo_dump_desc_extension(struct uvideo_softc *sc, |
2821 | const usb_descriptor_t *desc) |
2822 | { |
2823 | struct usb_video_vc_extension_desc *d; |
2824 | |
2825 | d = (struct usb_video_vc_extension_desc *)(uint8_t *)desc; |
2826 | |
2827 | printf("bLength=%d\n", d->bLength); |
2828 | printf("bDescriptorType=0x%02x\n", d->bDescriptorType); |
2829 | printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); |
2830 | printf("bUnitID=0x%02x\n", d->bUnitID); |
2831 | printf("guidExtensionCode=0x"); |
2832 | uvideo_hexdump(d->guidExtensionCode, sizeof(d->guidExtensionCode), 1); |
2833 | printf("bNumControls=0x%02x\n", d->bNumControls); |
2834 | printf("bNrInPins=0x%02x\n", d->bNrInPins); |
2835 | } |
2836 | |
2837 | void |
2838 | uvideo_hexdump(void *buf, int len, int quiet) |
2839 | { |
2840 | int i; |
2841 | |
2842 | for (i = 0; i < len; i++) { |
2843 | if (quiet == 0) { |
2844 | if (i % 16 == 0) |
2845 | printf("%s%5i:", i ? "\n" : "", i); |
2846 | if (i % 4 == 0) |
2847 | printf(" "); |
2848 | } |
2849 | printf("%02x", (int)*((u_char *)buf + i)); |
2850 | } |
2851 | printf("\n"); |
2852 | } |
2853 | |
2854 | int |
2855 | uvideo_debug_file_open(struct uvideo_softc *sc) |
2856 | { |
2857 | struct proc *p = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc; |
2858 | struct nameidata nd; |
2859 | char name[] = "/tmp/uvideo.mjpeg"; |
2860 | int error; |
2861 | |
2862 | NDINIT(&nd, 0, 0, UIO_SYSSPACE, name, p); |
2863 | error = vn_open(&nd, O_CREAT0x0200 | FWRITE0x0002 | O_NOFOLLOW0x0100, S_IRUSR0000400 | S_IWUSR0000200); |
2864 | if (error) { |
2865 | DPRINTF(1, "%s: %s: can't create debug file %s!\n", |
2866 | DEVNAME(sc), __func__, name); |
2867 | return (error); |
2868 | } |
2869 | |
2870 | sc->sc_vp = nd.ni_vp; |
2871 | VOP_UNLOCK(sc->sc_vp); |
2872 | if (nd.ni_vp->v_type != VREG) { |
2873 | vn_close(nd.ni_vp, FWRITE0x0002, p->p_ucred, p); |
2874 | return (EIO5); |
2875 | } |
2876 | |
2877 | DPRINTF(1, "%s: %s: created debug file %s\n", |
2878 | DEVNAME(sc), __func__, name); |
2879 | |
2880 | return (0); |
2881 | } |
2882 | |
2883 | void |
2884 | uvideo_debug_file_write_frame(void *arg) |
2885 | { |
2886 | struct uvideo_softc *sc = arg; |
2887 | struct uvideo_frame_buffer *sb = &sc->sc_frame_buffer; |
2888 | struct proc *p = curproc({struct cpu_info *__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof(struct cpu_info, ci_self))); __ci;})->ci_curproc; |
2889 | int error; |
2890 | |
2891 | if (sc->sc_vp == NULL((void *)0)) { |
2892 | printf("%s: %s: no file open!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), __func__); |
2893 | return; |
2894 | } |
2895 | |
2896 | error = vn_rdwr(UIO_WRITE, sc->sc_vp, sb->buf, sb->offset, (off_t)0, |
2897 | UIO_SYSSPACE, IO_APPEND|IO_UNIT, p->p_ucred, NULL((void *)0), p); |
2898 | |
2899 | if (error) |
2900 | DPRINTF(1, "vn_rdwr error!\n"); |
2901 | } |
2902 | #endif |
2903 | |
2904 | /* |
2905 | * IOCTL's |
2906 | */ |
2907 | int |
2908 | uvideo_querycap(void *v, struct v4l2_capability *caps) |
2909 | { |
2910 | struct uvideo_softc *sc = v; |
2911 | |
2912 | bzero(caps, sizeof(*caps))__builtin_bzero((caps), (sizeof(*caps))); |
2913 | strlcpy(caps->driver, DEVNAME(sc)((sc)->sc_dev.dv_xname), sizeof(caps->driver)); |
2914 | strlcpy(caps->card, sc->sc_udev->product, sizeof(caps->card)); |
2915 | strlcpy(caps->bus_info, "usb", sizeof(caps->bus_info)); |
2916 | |
2917 | caps->version = 1; |
2918 | caps->device_caps = V4L2_CAP_VIDEO_CAPTURE0x00000001 |
2919 | | V4L2_CAP_STREAMING0x04000000 |
2920 | | V4L2_CAP_READWRITE0x01000000; |
2921 | caps->capabilities = caps->device_caps | V4L2_CAP_DEVICE_CAPS0x80000000; |
2922 | |
2923 | return (0); |
2924 | } |
2925 | |
2926 | int |
2927 | uvideo_enum_fmt(void *v, struct v4l2_fmtdesc *fmtdesc) |
2928 | { |
2929 | struct uvideo_softc *sc = v; |
2930 | int idx; |
2931 | |
2932 | if (fmtdesc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) |
2933 | /* type not supported */ |
2934 | return (EINVAL22); |
2935 | |
2936 | if (fmtdesc->index >= sc->sc_fmtgrp_num) |
2937 | /* no more formats left */ |
2938 | return (EINVAL22); |
2939 | idx = fmtdesc->index; |
2940 | |
2941 | switch (sc->sc_fmtgrp[idx].format->bDescriptorSubtype) { |
2942 | case UDESCSUB_VS_FORMAT_MJPEG0x06: |
2943 | fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED0x0001; |
2944 | (void)strlcpy(fmtdesc->description, "MJPEG", |
2945 | sizeof(fmtdesc->description)); |
2946 | fmtdesc->pixelformat = V4L2_PIX_FMT_MJPEG((u_int32_t)('M') | ((u_int32_t)('J') << 8) | ((u_int32_t )('P') << 16) | ((u_int32_t)('G') << 24)); |
2947 | bzero(fmtdesc->reserved, sizeof(fmtdesc->reserved))__builtin_bzero((fmtdesc->reserved), (sizeof(fmtdesc->reserved ))); |
2948 | break; |
2949 | case UDESCSUB_VS_FORMAT_UNCOMPRESSED0x04: |
2950 | fmtdesc->flags = 0; |
2951 | if (sc->sc_fmtgrp[idx].pixelformat == |
2952 | V4L2_PIX_FMT_YUYV((u_int32_t)('Y') | ((u_int32_t)('U') << 8) | ((u_int32_t )('Y') << 16) | ((u_int32_t)('V') << 24))) { |
2953 | (void)strlcpy(fmtdesc->description, "YUYV", |
2954 | sizeof(fmtdesc->description)); |
2955 | fmtdesc->pixelformat = V4L2_PIX_FMT_YUYV((u_int32_t)('Y') | ((u_int32_t)('U') << 8) | ((u_int32_t )('Y') << 16) | ((u_int32_t)('V') << 24)); |
2956 | } else if (sc->sc_fmtgrp[idx].pixelformat == |
2957 | V4L2_PIX_FMT_NV12((u_int32_t)('N') | ((u_int32_t)('V') << 8) | ((u_int32_t )('1') << 16) | ((u_int32_t)('2') << 24))) { |
2958 | (void)strlcpy(fmtdesc->description, "NV12", |
2959 | sizeof(fmtdesc->description)); |
2960 | fmtdesc->pixelformat = V4L2_PIX_FMT_NV12((u_int32_t)('N') | ((u_int32_t)('V') << 8) | ((u_int32_t )('1') << 16) | ((u_int32_t)('2') << 24)); |
2961 | } else if (sc->sc_fmtgrp[idx].pixelformat == |
2962 | V4L2_PIX_FMT_UYVY((u_int32_t)('U') | ((u_int32_t)('Y') << 8) | ((u_int32_t )('V') << 16) | ((u_int32_t)('Y') << 24))) { |
2963 | (void)strlcpy(fmtdesc->description, "UYVY", |
2964 | sizeof(fmtdesc->description)); |
2965 | fmtdesc->pixelformat = V4L2_PIX_FMT_UYVY((u_int32_t)('U') | ((u_int32_t)('Y') << 8) | ((u_int32_t )('V') << 16) | ((u_int32_t)('Y') << 24)); |
2966 | } else { |
2967 | (void)strlcpy(fmtdesc->description, "Unknown UC Format", |
2968 | sizeof(fmtdesc->description)); |
2969 | fmtdesc->pixelformat = 0; |
2970 | } |
2971 | bzero(fmtdesc->reserved, sizeof(fmtdesc->reserved))__builtin_bzero((fmtdesc->reserved), (sizeof(fmtdesc->reserved ))); |
2972 | break; |
2973 | default: |
2974 | fmtdesc->flags = 0; |
2975 | (void)strlcpy(fmtdesc->description, "Unknown Format", |
2976 | sizeof(fmtdesc->description)); |
2977 | fmtdesc->pixelformat = 0; |
2978 | bzero(fmtdesc->reserved, sizeof(fmtdesc->reserved))__builtin_bzero((fmtdesc->reserved), (sizeof(fmtdesc->reserved ))); |
2979 | break; |
2980 | } |
2981 | |
2982 | return (0); |
2983 | } |
2984 | |
2985 | int |
2986 | uvideo_enum_fsizes(void *v, struct v4l2_frmsizeenum *fsizes) |
2987 | { |
2988 | struct uvideo_softc *sc = v; |
2989 | int idx, found = 0; |
2990 | |
2991 | for (idx = 0; idx < sc->sc_fmtgrp_num; idx++) { |
2992 | if (sc->sc_fmtgrp[idx].pixelformat == fsizes->pixel_format) { |
2993 | found = 1; |
2994 | break; |
2995 | } |
2996 | } |
2997 | if (found == 0) |
2998 | return (EINVAL22); |
2999 | |
3000 | if (fsizes->index >= sc->sc_fmtgrp[idx].frame_num) |
3001 | return (EINVAL22); |
3002 | |
3003 | fsizes->type = V4L2_FRMSIZE_TYPE_DISCRETE; |
3004 | fsizes->discrete.width = |
3005 | UGETW(sc->sc_fmtgrp[idx].frame[fsizes->index]->wWidth)(*(u_int16_t *)(sc->sc_fmtgrp[idx].frame[fsizes->index] ->wWidth)); |
3006 | fsizes->discrete.height = |
3007 | UGETW(sc->sc_fmtgrp[idx].frame[fsizes->index]->wHeight)(*(u_int16_t *)(sc->sc_fmtgrp[idx].frame[fsizes->index] ->wHeight)); |
3008 | |
3009 | return (0); |
3010 | } |
3011 | |
3012 | int |
3013 | uvideo_enum_fivals(void *v, struct v4l2_frmivalenum *fivals) |
3014 | { |
3015 | struct uvideo_softc *sc = v; |
3016 | int idx; |
3017 | struct uvideo_format_group *fmtgrp = NULL((void *)0); |
3018 | struct usb_video_frame_desc *frame = NULL((void *)0); |
3019 | uint8_t *p; |
3020 | |
3021 | for (idx = 0; idx < sc->sc_fmtgrp_num; idx++) { |
3022 | if (sc->sc_fmtgrp[idx].pixelformat == fivals->pixel_format) { |
3023 | fmtgrp = &sc->sc_fmtgrp[idx]; |
3024 | break; |
3025 | } |
3026 | } |
3027 | if (fmtgrp == NULL((void *)0)) |
3028 | return (EINVAL22); |
3029 | |
3030 | for (idx = 0; idx < fmtgrp->frame_num; idx++) { |
3031 | if (UGETW(fmtgrp->frame[idx]->wWidth)(*(u_int16_t *)(fmtgrp->frame[idx]->wWidth)) == fivals->width && |
3032 | UGETW(fmtgrp->frame[idx]->wHeight)(*(u_int16_t *)(fmtgrp->frame[idx]->wHeight)) == fivals->height) { |
3033 | frame = fmtgrp->frame[idx]; |
3034 | break; |
3035 | } |
3036 | } |
3037 | if (frame == NULL((void *)0)) |
3038 | return (EINVAL22); |
3039 | |
3040 | /* byte-wise pointer to start of frame intervals */ |
3041 | p = (uint8_t *)frame; |
3042 | p += sizeof(struct usb_video_frame_desc); |
3043 | |
3044 | if (frame->bFrameIntervalType == 0) { |
3045 | if (fivals->index != 0) |
3046 | return (EINVAL22); |
3047 | fivals->type = V4L2_FRMIVAL_TYPE_STEPWISE; |
3048 | fivals->stepwise.min.numerator = UGETDW(p)(*(u_int32_t *)(p)); |
3049 | fivals->stepwise.min.denominator = 10000000; |
3050 | p += sizeof(uDWord); |
3051 | fivals->stepwise.max.numerator = UGETDW(p)(*(u_int32_t *)(p)); |
3052 | fivals->stepwise.max.denominator = 10000000; |
3053 | p += sizeof(uDWord); |
3054 | fivals->stepwise.step.numerator = UGETDW(p)(*(u_int32_t *)(p)); |
3055 | fivals->stepwise.step.denominator = 10000000; |
3056 | p += sizeof(uDWord); |
Value stored to 'p' is never read | |
3057 | } else { |
3058 | if (fivals->index >= frame->bFrameIntervalType) |
3059 | return (EINVAL22); |
3060 | p += sizeof(uDWord) * fivals->index; |
3061 | if (p > frame->bLength + (uint8_t *)frame) { |
3062 | printf("%s: frame desc too short?\n", __func__); |
3063 | return (EINVAL22); |
3064 | } |
3065 | fivals->type = V4L2_FRMIVAL_TYPE_DISCRETE; |
3066 | fivals->discrete.numerator = UGETDW(p)(*(u_int32_t *)(p)); |
3067 | fivals->discrete.denominator = 10000000; |
3068 | } |
3069 | |
3070 | return (0); |
3071 | } |
3072 | |
3073 | int |
3074 | uvideo_s_fmt(void *v, struct v4l2_format *fmt) |
3075 | { |
3076 | struct uvideo_softc *sc = v; |
3077 | struct uvideo_format_group *fmtgrp_save; |
3078 | struct usb_video_frame_desc *frame_save; |
3079 | struct uvideo_res r; |
3080 | int found, i; |
3081 | usbd_status error; |
3082 | |
3083 | if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) |
3084 | return (EINVAL22); |
3085 | |
3086 | DPRINTF(1, "%s: %s: requested width=%d, height=%d\n", |
3087 | DEVNAME(sc), __func__, fmt->fmt.pix.width, fmt->fmt.pix.height); |
3088 | |
3089 | /* search requested pixel format */ |
3090 | for (found = 0, i = 0; i < sc->sc_fmtgrp_num; i++) { |
3091 | if (fmt->fmt.pix.pixelformat == sc->sc_fmtgrp[i].pixelformat) { |
3092 | found = 1; |
3093 | break; |
3094 | } |
3095 | } |
3096 | if (found == 0) |
3097 | return (EINVAL22); |
3098 | |
3099 | /* check if the format descriptor contains frame descriptors */ |
3100 | if (sc->sc_fmtgrp[i].frame_num == 0) { |
3101 | printf("%s: %s: no frame descriptors found!\n", |
3102 | __func__, DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
3103 | return (EINVAL22); |
3104 | } |
3105 | |
3106 | /* search requested frame resolution */ |
3107 | uvideo_find_res(sc, i, fmt->fmt.pix.width, fmt->fmt.pix.height, &r); |
3108 | |
3109 | /* |
3110 | * Do negotiation. |
3111 | */ |
3112 | /* save a copy of current format group in case of negotiation fails */ |
3113 | fmtgrp_save = sc->sc_fmtgrp_cur; |
3114 | frame_save = sc->sc_fmtgrp_cur->frame_cur; |
3115 | /* set new format group */ |
3116 | sc->sc_fmtgrp_cur = &sc->sc_fmtgrp[i]; |
3117 | sc->sc_fmtgrp[i].frame_cur = sc->sc_fmtgrp[i].frame[r.fidx]; |
3118 | |
3119 | /* do device negotiation with commit */ |
3120 | error = uvideo_vs_negotiation(sc, 1); |
3121 | if (error != USBD_NORMAL_COMPLETION) { |
3122 | sc->sc_fmtgrp_cur = fmtgrp_save; |
3123 | sc->sc_fmtgrp_cur->frame_cur = frame_save; |
3124 | return (EINVAL22); |
3125 | } |
3126 | sc->sc_negotiated_flag = 1; |
3127 | |
3128 | /* offer closest resolution which we have found */ |
3129 | fmt->fmt.pix.width = r.width; |
3130 | fmt->fmt.pix.height = r.height; |
3131 | |
3132 | DPRINTF(1, "%s: %s: offered width=%d, height=%d\n", |
3133 | DEVNAME(sc), __func__, r.width, r.height); |
3134 | |
3135 | /* tell our frame buffer size */ |
3136 | fmt->fmt.pix.sizeimage = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxVideoFrameSize)); |
3137 | |
3138 | return (0); |
3139 | } |
3140 | |
3141 | int |
3142 | uvideo_g_fmt(void *v, struct v4l2_format *fmt) |
3143 | { |
3144 | struct uvideo_softc *sc = v; |
3145 | |
3146 | if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) |
3147 | return (EINVAL22); |
3148 | |
3149 | fmt->fmt.pix.pixelformat = sc->sc_fmtgrp_cur->pixelformat; |
3150 | fmt->fmt.pix.width = UGETW(sc->sc_fmtgrp_cur->frame_cur->wWidth)(*(u_int16_t *)(sc->sc_fmtgrp_cur->frame_cur->wWidth )); |
3151 | fmt->fmt.pix.height = UGETW(sc->sc_fmtgrp_cur->frame_cur->wHeight)(*(u_int16_t *)(sc->sc_fmtgrp_cur->frame_cur->wHeight )); |
3152 | fmt->fmt.pix.sizeimage = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxVideoFrameSize)); |
3153 | |
3154 | DPRINTF(1, "%s: %s: current width=%d, height=%d\n", |
3155 | DEVNAME(sc), __func__, fmt->fmt.pix.width, fmt->fmt.pix.height); |
3156 | |
3157 | return (0); |
3158 | } |
3159 | |
3160 | int |
3161 | uvideo_s_parm(void *v, struct v4l2_streamparm *parm) |
3162 | { |
3163 | struct uvideo_softc *sc = v; |
3164 | usbd_status error; |
3165 | |
3166 | if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { |
3167 | /* |
3168 | * XXX Only whole number frame rates for now. Frame |
3169 | * rate is the inverse of time per frame. |
3170 | */ |
3171 | if (parm->parm.capture.timeperframe.numerator == 0 || |
3172 | parm->parm.capture.timeperframe.denominator == 0) { |
3173 | sc->sc_frame_rate = 0; |
3174 | } else { |
3175 | sc->sc_frame_rate = |
3176 | parm->parm.capture.timeperframe.denominator / |
3177 | parm->parm.capture.timeperframe.numerator; |
3178 | } |
3179 | } else |
3180 | return (EINVAL22); |
3181 | |
3182 | /* renegotiate if necessary */ |
3183 | if (sc->sc_negotiated_flag) { |
3184 | error = uvideo_vs_negotiation(sc, 1); |
3185 | if (error != USBD_NORMAL_COMPLETION) |
3186 | return (error); |
3187 | } |
3188 | |
3189 | return (0); |
3190 | } |
3191 | |
3192 | int |
3193 | uvideo_g_parm(void *v, struct v4l2_streamparm *parm) |
3194 | { |
3195 | struct uvideo_softc *sc = v; |
3196 | |
3197 | if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { |
3198 | parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME0x1000; |
3199 | parm->parm.capture.capturemode = 0; |
3200 | parm->parm.capture.timeperframe.numerator = |
3201 | UGETDW(sc->sc_desc_probe.dwFrameInterval)(*(u_int32_t *)(sc->sc_desc_probe.dwFrameInterval)); |
3202 | parm->parm.capture.timeperframe.denominator = 10000000; |
3203 | } else |
3204 | return (EINVAL22); |
3205 | |
3206 | return (0); |
3207 | } |
3208 | |
3209 | int |
3210 | uvideo_enum_input(void *v, struct v4l2_input *input) |
3211 | { |
3212 | if (input->index != 0) |
3213 | /* XXX we just support one input for now */ |
3214 | return (EINVAL22); |
3215 | |
3216 | strlcpy(input->name, "Camera Terminal", sizeof(input->name)); |
3217 | input->type = V4L2_INPUT_TYPE_CAMERA2; |
3218 | |
3219 | return (0); |
3220 | } |
3221 | |
3222 | int |
3223 | uvideo_s_input(void *v, int input) |
3224 | { |
3225 | if (input != 0) |
3226 | /* XXX we just support one input for now */ |
3227 | return (EINVAL22); |
3228 | |
3229 | return (0); |
3230 | } |
3231 | |
3232 | int |
3233 | uvideo_g_input(void *v, int *input) |
3234 | { |
3235 | /* XXX we just support one input for now */ |
3236 | *input = 0; |
3237 | |
3238 | return (0); |
3239 | } |
3240 | |
3241 | int |
3242 | uvideo_reqbufs(void *v, struct v4l2_requestbuffers *rb) |
3243 | { |
3244 | struct uvideo_softc *sc = v; |
3245 | int i, buf_size, buf_size_total; |
3246 | |
3247 | DPRINTF(1, "%s: %s: count=%d\n", DEVNAME(sc), __func__, rb->count); |
3248 | |
3249 | /* We do not support freeing buffers via reqbufs(0) */ |
3250 | if (rb->count == 0) |
3251 | return (EINVAL22); |
3252 | |
3253 | if (sc->sc_mmap_count > 0 || sc->sc_mmap_buffer != NULL((void *)0)) { |
3254 | DPRINTF(1, "%s: %s: mmap buffers already allocated\n", |
3255 | DEVNAME(sc), __func__); |
3256 | return (EINVAL22); |
3257 | } |
3258 | |
3259 | /* limit the buffers */ |
3260 | if (rb->count > UVIDEO_MAX_BUFFERS8) |
3261 | sc->sc_mmap_count = UVIDEO_MAX_BUFFERS8; |
3262 | else |
3263 | sc->sc_mmap_count = rb->count; |
3264 | |
3265 | /* allocate the total mmap buffer */ |
3266 | buf_size = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize)(*(u_int32_t *)(sc->sc_desc_probe.dwMaxVideoFrameSize)); |
3267 | if (buf_size >= SIZE_MAX0xffffffffffffffffUL / UVIDEO_MAX_BUFFERS8) { |
3268 | printf("%s: video frame size too large!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
3269 | sc->sc_mmap_count = 0; |
3270 | return (EINVAL22); |
3271 | } |
3272 | buf_size_total = sc->sc_mmap_count * buf_size; |
3273 | buf_size_total = round_page(buf_size_total)(((buf_size_total) + ((1 << 12) - 1)) & ~((1 << 12) - 1)); /* page align buffer */ |
3274 | sc->sc_mmap_buffer = malloc(buf_size_total, M_USBDEV102, M_NOWAIT0x0002); |
3275 | if (sc->sc_mmap_buffer == NULL((void *)0)) { |
3276 | printf("%s: can't allocate mmap buffer!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
3277 | sc->sc_mmap_count = 0; |
3278 | return (EINVAL22); |
3279 | } |
3280 | sc->sc_mmap_buffer_size = buf_size_total; |
3281 | DPRINTF(1, "%s: allocated %d bytes mmap buffer\n", |
3282 | DEVNAME(sc), buf_size_total); |
3283 | |
3284 | /* fill the v4l2_buffer structure */ |
3285 | for (i = 0; i < sc->sc_mmap_count; i++) { |
3286 | sc->sc_mmap[i].buf = sc->sc_mmap_buffer + (i * buf_size); |
3287 | |
3288 | sc->sc_mmap[i].v4l2_buf.index = i; |
3289 | sc->sc_mmap[i].v4l2_buf.m.offset = i * buf_size; |
3290 | sc->sc_mmap[i].v4l2_buf.length = buf_size; |
3291 | sc->sc_mmap[i].v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
3292 | sc->sc_mmap[i].v4l2_buf.sequence = 0; |
3293 | sc->sc_mmap[i].v4l2_buf.field = V4L2_FIELD_NONE; |
3294 | sc->sc_mmap[i].v4l2_buf.memory = V4L2_MEMORY_MMAP; |
3295 | sc->sc_mmap[i].v4l2_buf.flags = V4L2_BUF_FLAG_MAPPED0x00000001; |
3296 | |
3297 | DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n", |
3298 | DEVNAME(sc), __func__, |
3299 | sc->sc_mmap[i].v4l2_buf.index, |
3300 | sc->sc_mmap[i].v4l2_buf.m.offset, |
3301 | sc->sc_mmap[i].v4l2_buf.length); |
3302 | } |
3303 | |
3304 | /* tell how many buffers we have really allocated */ |
3305 | rb->count = sc->sc_mmap_count; |
3306 | |
3307 | return (0); |
3308 | } |
3309 | |
3310 | int |
3311 | uvideo_querybuf(void *v, struct v4l2_buffer *qb) |
3312 | { |
3313 | struct uvideo_softc *sc = v; |
3314 | |
3315 | if (qb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || |
3316 | qb->memory != V4L2_MEMORY_MMAP || |
3317 | qb->index >= sc->sc_mmap_count) |
3318 | return (EINVAL22); |
3319 | |
3320 | bcopy(&sc->sc_mmap[qb->index].v4l2_buf, qb, |
3321 | sizeof(struct v4l2_buffer)); |
3322 | |
3323 | DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n", |
3324 | DEVNAME(sc), __func__, |
3325 | qb->index, |
3326 | qb->m.offset, |
3327 | qb->length); |
3328 | |
3329 | return (0); |
3330 | } |
3331 | |
3332 | int |
3333 | uvideo_qbuf(void *v, struct v4l2_buffer *qb) |
3334 | { |
3335 | struct uvideo_softc *sc = v; |
3336 | |
3337 | if (qb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || |
3338 | qb->memory != V4L2_MEMORY_MMAP || |
3339 | qb->index >= sc->sc_mmap_count) |
3340 | return (EINVAL22); |
3341 | |
3342 | sc->sc_mmap[qb->index].v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE0x00000004; |
3343 | sc->sc_mmap[qb->index].v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED0x00000002; |
3344 | |
3345 | DPRINTF(2, "%s: %s: buffer on index %d ready for queueing\n", |
3346 | DEVNAME(sc), __func__, qb->index); |
3347 | |
3348 | return (0); |
3349 | } |
3350 | |
3351 | int |
3352 | uvideo_dqbuf(void *v, struct v4l2_buffer *dqb) |
3353 | { |
3354 | struct uvideo_softc *sc = v; |
3355 | struct uvideo_mmap *mmap; |
3356 | int error; |
3357 | |
3358 | if (dqb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || |
3359 | dqb->memory != V4L2_MEMORY_MMAP) |
3360 | return (EINVAL22); |
3361 | |
3362 | if (SIMPLEQ_EMPTY(&sc->sc_mmap_q)(((&sc->sc_mmap_q)->sqh_first) == ((void *)0))) { |
3363 | /* mmap queue is empty, block until first frame is queued */ |
3364 | error = tsleep_nsec(sc, 0, "vid_mmap", SEC_TO_NSEC(10)); |
3365 | if (error) |
3366 | return (EINVAL22); |
3367 | } |
3368 | |
3369 | mmap = SIMPLEQ_FIRST(&sc->sc_mmap_q)((&sc->sc_mmap_q)->sqh_first); |
3370 | if (mmap == NULL((void *)0)) |
3371 | panic("uvideo_dqbuf: NULL pointer!"); |
3372 | |
3373 | bcopy(&mmap->v4l2_buf, dqb, sizeof(struct v4l2_buffer)); |
3374 | |
3375 | mmap->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE0x00000004; |
3376 | mmap->v4l2_buf.flags &= ~V4L2_BUF_FLAG_QUEUED0x00000002; |
3377 | |
3378 | DPRINTF(2, "%s: %s: frame dequeued from index %d\n", |
3379 | DEVNAME(sc), __func__, mmap->v4l2_buf.index); |
3380 | SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames)do { if (((&sc->sc_mmap_q)->sqh_first = (&sc-> sc_mmap_q)->sqh_first->q_frames.sqe_next) == ((void *)0 )) (&sc->sc_mmap_q)->sqh_last = &(&sc->sc_mmap_q )->sqh_first; } while (0); |
3381 | |
3382 | return (0); |
3383 | } |
3384 | |
3385 | int |
3386 | uvideo_streamon(void *v, int type) |
3387 | { |
3388 | struct uvideo_softc *sc = v; |
3389 | usbd_status error; |
3390 | |
3391 | error = uvideo_vs_init(sc); |
3392 | if (error != USBD_NORMAL_COMPLETION) |
3393 | return (EINVAL22); |
3394 | |
3395 | if (sc->sc_vs_cur->bulk_endpoint) |
3396 | uvideo_vs_start_bulk(sc); |
3397 | else |
3398 | uvideo_vs_start_isoc(sc); |
3399 | |
3400 | return (0); |
3401 | } |
3402 | |
3403 | int |
3404 | uvideo_streamoff(void *v, int type) |
3405 | { |
3406 | struct uvideo_softc *sc = v; |
3407 | |
3408 | uvideo_vs_close(sc); |
3409 | |
3410 | return (0); |
3411 | } |
3412 | |
3413 | int |
3414 | uvideo_queryctrl(void *v, struct v4l2_queryctrl *qctrl) |
3415 | { |
3416 | struct uvideo_softc *sc = v; |
3417 | int i, ret = 0; |
3418 | usbd_status error; |
3419 | uint8_t *ctrl_data; |
3420 | uint16_t ctrl_len; |
3421 | |
3422 | i = uvideo_find_ctrl(sc, qctrl->id); |
3423 | if (i == EINVAL22) |
3424 | return (i); |
3425 | |
3426 | ctrl_len = uvideo_ctrls[i].ctrl_len; |
3427 | if (ctrl_len < 1 || ctrl_len > 2) { |
3428 | printf("%s: invalid control length: %d\n", __func__, ctrl_len); |
3429 | return (EINVAL22); |
3430 | } |
3431 | |
3432 | ctrl_data = malloc(ctrl_len, M_USBDEV102, M_WAITOK0x0001 | M_CANFAIL0x0004); |
3433 | if (ctrl_data == NULL((void *)0)) { |
3434 | printf("%s: could not allocate control data\n", __func__); |
3435 | return (ENOMEM12); |
3436 | } |
3437 | |
3438 | /* set type */ |
3439 | qctrl->type = uvideo_ctrls[i].type; |
3440 | |
3441 | /* set description name */ |
3442 | strlcpy(qctrl->name, uvideo_ctrls[i].name, sizeof(qctrl->name)); |
3443 | |
3444 | /* set minimum */ |
3445 | error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_MIN0x82, |
3446 | sc->sc_desc_vc_pu_cur->bUnitID, |
3447 | uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); |
3448 | if (error != USBD_NORMAL_COMPLETION) { |
3449 | ret = EINVAL22; |
3450 | goto out; |
3451 | } |
3452 | switch (ctrl_len) { |
3453 | case 1: |
3454 | qctrl->minimum = uvideo_ctrls[i].sig ? |
3455 | *(int8_t *)ctrl_data : |
3456 | *ctrl_data; |
3457 | break; |
3458 | case 2: |
3459 | qctrl->minimum = uvideo_ctrls[i].sig ? |
3460 | (int16_t)UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)) : |
3461 | UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)); |
3462 | break; |
3463 | } |
3464 | |
3465 | /* set maximum */ |
3466 | error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_MAX0x83, |
3467 | sc->sc_desc_vc_pu_cur->bUnitID, |
3468 | uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); |
3469 | if (error != USBD_NORMAL_COMPLETION) { |
3470 | ret = EINVAL22; |
3471 | goto out; |
3472 | } |
3473 | switch(ctrl_len) { |
3474 | case 1: |
3475 | qctrl->maximum = uvideo_ctrls[i].sig ? |
3476 | *(int8_t *)ctrl_data : |
3477 | *ctrl_data; |
3478 | break; |
3479 | case 2: |
3480 | qctrl->maximum = uvideo_ctrls[i].sig ? |
3481 | (int16_t)UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)) : |
3482 | UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)); |
3483 | break; |
3484 | } |
3485 | |
3486 | /* set resolution */ |
3487 | error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_RES0x84, |
3488 | sc->sc_desc_vc_pu_cur->bUnitID, |
3489 | uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); |
3490 | if (error != USBD_NORMAL_COMPLETION) { |
3491 | ret = EINVAL22; |
3492 | goto out; |
3493 | } |
3494 | switch(ctrl_len) { |
3495 | case 1: |
3496 | qctrl->step = uvideo_ctrls[i].sig ? |
3497 | *(int8_t *)ctrl_data: |
3498 | *ctrl_data; |
3499 | break; |
3500 | case 2: |
3501 | qctrl->step = uvideo_ctrls[i].sig ? |
3502 | (int16_t)UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)) : |
3503 | UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)); |
3504 | break; |
3505 | } |
3506 | |
3507 | /* set default */ |
3508 | error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_DEF0x87, |
3509 | sc->sc_desc_vc_pu_cur->bUnitID, |
3510 | uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); |
3511 | if (error != USBD_NORMAL_COMPLETION) { |
3512 | ret = EINVAL22; |
3513 | goto out; |
3514 | } |
3515 | switch(ctrl_len) { |
3516 | case 1: |
3517 | qctrl->default_value = uvideo_ctrls[i].sig ? |
3518 | *(int8_t *)ctrl_data : |
3519 | *ctrl_data; |
3520 | break; |
3521 | case 2: |
3522 | qctrl->default_value = uvideo_ctrls[i].sig ? |
3523 | (int16_t)UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)) : |
3524 | UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)); |
3525 | break; |
3526 | } |
3527 | |
3528 | /* set flags */ |
3529 | qctrl->flags = 0; |
3530 | |
3531 | out: |
3532 | free(ctrl_data, M_USBDEV102, ctrl_len); |
3533 | |
3534 | return (ret); |
3535 | } |
3536 | |
3537 | int |
3538 | uvideo_g_ctrl(void *v, struct v4l2_control *gctrl) |
3539 | { |
3540 | struct uvideo_softc *sc = v; |
3541 | int i, ret = 0; |
3542 | usbd_status error; |
3543 | uint8_t *ctrl_data; |
3544 | uint16_t ctrl_len; |
3545 | |
3546 | i = uvideo_find_ctrl(sc, gctrl->id); |
3547 | if (i == EINVAL22) |
3548 | return (i); |
3549 | |
3550 | ctrl_len = uvideo_ctrls[i].ctrl_len; |
3551 | if (ctrl_len < 1 || ctrl_len > 2) { |
3552 | printf("%s: invalid control length: %d\n", __func__, ctrl_len); |
3553 | return (EINVAL22); |
3554 | } |
3555 | |
3556 | ctrl_data = malloc(ctrl_len, M_USBDEV102, M_WAITOK0x0001 | M_CANFAIL0x0004); |
3557 | if (ctrl_data == NULL((void *)0)) { |
3558 | printf("%s: could not allocate control data\n", __func__); |
3559 | return (ENOMEM12); |
3560 | } |
3561 | |
3562 | error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_CUR0x81, |
3563 | sc->sc_desc_vc_pu_cur->bUnitID, |
3564 | uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); |
3565 | if (error != USBD_NORMAL_COMPLETION) { |
3566 | ret = EINVAL22; |
3567 | goto out; |
3568 | } |
3569 | switch(ctrl_len) { |
3570 | case 1: |
3571 | gctrl->value = uvideo_ctrls[i].sig ? |
3572 | *(int8_t *)ctrl_data : |
3573 | *ctrl_data; |
3574 | break; |
3575 | case 2: |
3576 | gctrl->value = uvideo_ctrls[i].sig ? |
3577 | (int16_t)UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)) : |
3578 | UGETW(ctrl_data)(*(u_int16_t *)(ctrl_data)); |
3579 | break; |
3580 | } |
3581 | |
3582 | out: |
3583 | free(ctrl_data, M_USBDEV102, ctrl_len); |
3584 | |
3585 | return (0); |
3586 | } |
3587 | |
3588 | int |
3589 | uvideo_s_ctrl(void *v, struct v4l2_control *sctrl) |
3590 | { |
3591 | struct uvideo_softc *sc = v; |
3592 | int i, ret = 0; |
3593 | usbd_status error; |
3594 | uint8_t *ctrl_data; |
3595 | uint16_t ctrl_len; |
3596 | |
3597 | i = uvideo_find_ctrl(sc, sctrl->id); |
3598 | if (i == EINVAL22) |
3599 | return (i); |
3600 | |
3601 | ctrl_len = uvideo_ctrls[i].ctrl_len; |
3602 | if (ctrl_len < 1 || ctrl_len > 2) { |
3603 | printf("%s: invalid control length: %d\n", __func__, ctrl_len); |
3604 | return (EINVAL22); |
3605 | } |
3606 | |
3607 | ctrl_data = malloc(ctrl_len, M_USBDEV102, M_WAITOK0x0001 | M_CANFAIL0x0004); |
3608 | if (ctrl_data == NULL((void *)0)) { |
3609 | printf("%s: could not allocate control data\n", __func__); |
3610 | return (ENOMEM12); |
3611 | } |
3612 | |
3613 | switch(ctrl_len) { |
3614 | case 1: |
3615 | if (uvideo_ctrls[i].sig) |
3616 | *(int8_t *)ctrl_data = sctrl->value; |
3617 | else |
3618 | *ctrl_data = sctrl->value; |
3619 | break; |
3620 | case 2: |
3621 | USETW(ctrl_data, sctrl->value)(*(u_int16_t *)(ctrl_data) = (sctrl->value)); |
3622 | break; |
3623 | } |
3624 | error = uvideo_vc_set_ctrl(sc, ctrl_data, SET_CUR0x01, |
3625 | sc->sc_desc_vc_pu_cur->bUnitID, |
3626 | uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); |
3627 | if (error != USBD_NORMAL_COMPLETION) |
3628 | ret = EINVAL22; |
3629 | |
3630 | free(ctrl_data, M_USBDEV102, ctrl_len); |
3631 | |
3632 | return (ret); |
3633 | } |
3634 | |
3635 | int |
3636 | uvideo_try_fmt(void *v, struct v4l2_format *fmt) |
3637 | { |
3638 | struct uvideo_softc *sc = v; |
3639 | struct uvideo_res r; |
3640 | int found, i; |
3641 | |
3642 | if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) |
3643 | return (EINVAL22); |
3644 | |
3645 | DPRINTF(1, "%s: %s: requested width=%d, height=%d\n", |
3646 | DEVNAME(sc), __func__, fmt->fmt.pix.width, fmt->fmt.pix.height); |
3647 | |
3648 | /* search requested pixel format */ |
3649 | for (found = 0, i = 0; i < sc->sc_fmtgrp_num; i++) { |
3650 | if (fmt->fmt.pix.pixelformat == sc->sc_fmtgrp[i].pixelformat) { |
3651 | found = 1; |
3652 | break; |
3653 | } |
3654 | } |
3655 | if (found == 0) |
3656 | return (EINVAL22); |
3657 | |
3658 | /* search requested frame resolution */ |
3659 | uvideo_find_res(sc, i, fmt->fmt.pix.width, fmt->fmt.pix.height, &r); |
3660 | |
3661 | /* offer closest resolution which we have found */ |
3662 | fmt->fmt.pix.width = r.width; |
3663 | fmt->fmt.pix.height = r.height; |
3664 | |
3665 | DPRINTF(1, "%s: %s: offered width=%d, height=%d\n", |
3666 | DEVNAME(sc), __func__, r.width, r.height); |
3667 | |
3668 | /* tell our frame buffer size */ |
3669 | fmt->fmt.pix.sizeimage = sc->sc_frame_buffer.buf_size; |
3670 | |
3671 | return (0); |
3672 | } |
3673 | |
3674 | caddr_t |
3675 | uvideo_mappage(void *v, off_t off, int prot) |
3676 | { |
3677 | struct uvideo_softc *sc = v; |
3678 | caddr_t p; |
3679 | |
3680 | if (off >= sc->sc_mmap_buffer_size) |
3681 | return NULL((void *)0); |
3682 | |
3683 | if (!sc->sc_mmap_flag) |
3684 | sc->sc_mmap_flag = 1; |
3685 | |
3686 | p = sc->sc_mmap_buffer + off; |
3687 | |
3688 | return (p); |
3689 | } |
3690 | |
3691 | int |
3692 | uvideo_get_bufsize(void *v) |
3693 | { |
3694 | struct uvideo_softc *sc = v; |
3695 | |
3696 | return (sc->sc_max_fbuf_size); |
3697 | } |
3698 | |
3699 | int |
3700 | uvideo_start_read(void *v) |
3701 | { |
3702 | struct uvideo_softc *sc = v; |
3703 | usbd_status error; |
3704 | |
3705 | if (sc->sc_mmap_flag) |
3706 | sc->sc_mmap_flag = 0; |
3707 | |
3708 | error = uvideo_vs_init(sc); |
3709 | if (error != USBD_NORMAL_COMPLETION) |
3710 | return (EINVAL22); |
3711 | |
3712 | if (sc->sc_vs_cur->bulk_endpoint) |
3713 | uvideo_vs_start_bulk(sc); |
3714 | else |
3715 | uvideo_vs_start_isoc(sc); |
3716 | |
3717 | return (0); |
3718 | } |
3719 | |
3720 | usbd_status |
3721 | uvideo_usb_control(struct uvideo_softc *sc, uint8_t rt, uint8_t r, |
3722 | uint16_t value, uint8_t *data, size_t length) |
3723 | { |
3724 | usb_device_request_t req; |
3725 | usbd_status err; |
3726 | |
3727 | req.bmRequestType = rt; |
3728 | req.bRequest = r; |
3729 | USETW(req.wIndex, 0)(*(u_int16_t *)(req.wIndex) = (0)); |
3730 | USETW(req.wValue, value)(*(u_int16_t *)(req.wValue) = (value)); |
3731 | USETW(req.wLength, length)(*(u_int16_t *)(req.wLength) = (length)); |
3732 | |
3733 | err = usbd_do_request(sc->sc_udev, &req, data); |
3734 | if (err != USBD_NORMAL_COMPLETION) |
3735 | return (err); |
3736 | |
3737 | return (USBD_NORMAL_COMPLETION); |
3738 | } |
3739 | |
3740 | usbd_status |
3741 | uvideo_ucode_loader_ricoh(struct uvideo_softc *sc) |
3742 | { |
3743 | usbd_status error; |
3744 | uint8_t *ucode, len, cbuf; |
3745 | size_t ucode_size; |
3746 | uint16_t addr; |
3747 | int offset = 0, remain; |
3748 | |
3749 | /* get device microcode status */ |
3750 | cbuf = 0; |
3751 | error = uvideo_usb_control(sc, UT_READ_VENDOR_DEVICE(0x80 | 0x40 | 0x00), |
3752 | 0xa4, 0, &cbuf, sizeof cbuf); |
3753 | if (error != USBD_NORMAL_COMPLETION) { |
3754 | printf("%s: ucode status error=%s!\n", |
3755 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
3756 | return (USBD_INVAL); |
3757 | } |
3758 | if (cbuf) { |
3759 | DPRINTF(1, "%s: microcode already loaded\n", DEVNAME(sc)); |
3760 | return (USBD_NORMAL_COMPLETION); |
3761 | } else { |
3762 | DPRINTF(1, "%s: microcode not loaded\n", DEVNAME(sc)); |
3763 | } |
3764 | |
3765 | /* open microcode file */ |
3766 | error = loadfirmware(sc->sc_quirk->ucode_name, &ucode, &ucode_size); |
3767 | if (error != 0) { |
3768 | printf("%s: loadfirmware error=%d!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), error); |
3769 | return (USBD_INVAL); |
3770 | } |
3771 | |
3772 | /* upload microcode */ |
3773 | remain = ucode_size; |
3774 | while (remain > 0) { |
3775 | if (remain < 3) { |
3776 | printf("%s: ucode file incomplete!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
3777 | free(ucode, M_DEVBUF2, ucode_size); |
3778 | return (USBD_INVAL); |
3779 | } |
3780 | |
3781 | len = ucode[offset]; |
3782 | addr = ucode[offset + 1] | (ucode[offset + 2] << 8); |
3783 | offset += 3; |
3784 | remain -= 3; |
3785 | |
3786 | error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE(0x00 | 0x40 | 0x00), |
3787 | 0xa0, addr, &ucode[offset], len); |
3788 | if (error != USBD_NORMAL_COMPLETION) { |
3789 | printf("%s: ucode upload error=%s!\n", |
3790 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
3791 | free(ucode, M_DEVBUF2, ucode_size); |
3792 | return (USBD_INVAL); |
3793 | } |
3794 | DPRINTF(1, "%s: uploaded %d bytes ucode to addr 0x%x\n", |
3795 | DEVNAME(sc), len, addr); |
3796 | |
3797 | offset += len; |
3798 | remain -= len; |
3799 | } |
3800 | free(ucode, M_DEVBUF2, ucode_size); |
3801 | |
3802 | /* activate microcode */ |
3803 | cbuf = 0; |
3804 | error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE(0x00 | 0x40 | 0x00), |
3805 | 0xa1, 0, &cbuf, sizeof cbuf); |
3806 | if (error != USBD_NORMAL_COMPLETION) { |
3807 | printf("%s: ucode activate error=%s!\n", |
3808 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
3809 | return (USBD_INVAL); |
3810 | } |
3811 | DPRINTF(1, "%s: ucode activated\n", DEVNAME(sc)); |
3812 | |
3813 | return (USBD_NORMAL_COMPLETION); |
3814 | } |
3815 | |
3816 | /* |
3817 | * The iSight first generation device will first attach as |
3818 | * 0x8300 non-UVC. After the firmware gots uploaded, the device |
3819 | * will reset and come back as 0x8501 UVC compatible. |
3820 | */ |
3821 | usbd_status |
3822 | uvideo_ucode_loader_apple_isight(struct uvideo_softc *sc) |
3823 | { |
3824 | usbd_status error; |
3825 | uint8_t *ucode, *code, cbuf; |
3826 | size_t ucode_size; |
3827 | uint16_t len, req, off, llen; |
3828 | |
3829 | /* open microcode file */ |
3830 | error = loadfirmware(sc->sc_quirk->ucode_name, &ucode, &ucode_size); |
3831 | if (error != 0) { |
3832 | printf("%s: loadfirmware error=%d!\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), error); |
3833 | return (USBD_INVAL); |
3834 | } |
3835 | |
3836 | /* send init request */ |
3837 | cbuf = 1; |
3838 | error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE(0x00 | 0x40 | 0x00), 0xa0, 0xe600, |
3839 | &cbuf, sizeof(cbuf)); |
3840 | if (error) { |
3841 | printf("%s: failed to init firmware loading state: %s\n", |
3842 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
3843 | return (error); |
3844 | } |
3845 | |
3846 | code = ucode; |
3847 | while (code < ucode + ucode_size) { |
3848 | /* get header information */ |
3849 | len = (code[0] << 8) | code[1]; |
3850 | req = (code[2] << 8) | code[3]; |
3851 | DPRINTF(1, "%s: ucode data len=%d, request=0x%x\n", |
3852 | DEVNAME(sc), len, req); |
3853 | if (len < 1 || len > 1023) { |
3854 | printf("%s: ucode header contains wrong value!\n", |
3855 | DEVNAME(sc)((sc)->sc_dev.dv_xname)); |
3856 | free(ucode, M_DEVBUF2, ucode_size); |
3857 | return (USBD_INVAL); |
3858 | } |
3859 | code += 4; |
3860 | |
3861 | /* send data to device */ |
3862 | for (off = 0; len > 0; req += 50, off += 50) { |
3863 | llen = len > 50 ? 50 : len; |
3864 | len -= llen; |
3865 | |
3866 | DPRINTF(1, "%s: send %d bytes data to offset 0x%x\n", |
3867 | DEVNAME(sc), llen, req); |
3868 | error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE(0x00 | 0x40 | 0x00), |
3869 | 0xa0, req, code, llen); |
3870 | if (error) { |
3871 | printf("%s: ucode load failed: %s\n", |
3872 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
3873 | free(ucode, M_DEVBUF2, ucode_size); |
3874 | return (USBD_INVAL); |
3875 | } |
3876 | |
3877 | code += llen; |
3878 | } |
3879 | } |
3880 | free(ucode, M_DEVBUF2, ucode_size); |
3881 | |
3882 | /* send finished request */ |
3883 | cbuf = 0; |
3884 | error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE(0x00 | 0x40 | 0x00), 0xa0, 0xe600, |
3885 | &cbuf, sizeof(cbuf)); |
3886 | if (error != USBD_NORMAL_COMPLETION) { |
3887 | printf("%s: ucode activate error=%s!\n", |
3888 | DEVNAME(sc)((sc)->sc_dev.dv_xname), usbd_errstr(error)); |
3889 | return (USBD_INVAL); |
3890 | } |
3891 | DPRINTF(1, "%s: ucode activated\n", DEVNAME(sc)); |
3892 | |
3893 | /* |
3894 | * We will always return from the attach routine since the device |
3895 | * will reset and re-attach at this point. |
3896 | */ |
3897 | return (USBD_INVAL); |
3898 | } |