2 * kinect sensor device camera, gspca driver
4 * Copyright (C) 2011 Antonio Ospite <ospite@studenti.unina.it>
6 * Based on the OpenKinect project and libfreenect
7 * http://openkinect.org/wiki/Init_Analysis
9 * Special thanks to Steven Toth and kernellabs.com for sponsoring a Kinect
10 * sensor device which I tested the driver on.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29 #define MODULE_NAME "kinect"
33 #define CTRL_TIMEOUT 500
35 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
36 MODULE_DESCRIPTION("GSPCA/Kinect Sensor Device USB Camera Driver");
37 MODULE_LICENSE("GPL");
40 int gspca_debug
= D_ERR
| D_PROBE
| D_CONF
| D_STREAM
| D_FRAM
| D_PACK
|
41 D_USBI
| D_USBO
| D_V4L2
;
62 /* specific webcam descriptor */
64 struct gspca_dev gspca_dev
; /* !! must be the first item */
65 uint16_t cam_tag
; /* a sequence number for packets */
66 uint8_t stream_flag
; /* to identify different stream types */
67 uint8_t obuf
[0x400]; /* output buffer for control commands */
68 uint8_t ibuf
[0x200]; /* input buffer for control commands */
71 /* V4L2 controls supported by the driver */
72 /* controls prototypes here */
74 static const struct ctrl sd_ctrls
[] = {
77 #define MODE_640x480 0x0001
78 #define MODE_640x488 0x0002
79 #define MODE_1280x1024 0x0004
81 #define FORMAT_BAYER 0x0010
82 #define FORMAT_UYVY 0x0020
83 #define FORMAT_Y10B 0x0040
85 #define FPS_HIGH 0x0100
87 static const struct v4l2_pix_format video_camera_mode
[] = {
88 {640, 480, V4L2_PIX_FMT_SGRBG8
, V4L2_FIELD_NONE
,
90 .sizeimage
= 640 * 480,
91 .colorspace
= V4L2_COLORSPACE_SRGB
,
92 .priv
= MODE_640x480
| FORMAT_BAYER
| FPS_HIGH
},
93 {640, 480, V4L2_PIX_FMT_UYVY
, V4L2_FIELD_NONE
,
94 .bytesperline
= 640 * 2,
95 .sizeimage
= 640 * 480 * 2,
96 .colorspace
= V4L2_COLORSPACE_SRGB
,
97 .priv
= MODE_640x480
| FORMAT_UYVY
},
98 {1280, 1024, V4L2_PIX_FMT_SGRBG8
, V4L2_FIELD_NONE
,
100 .sizeimage
= 1280 * 1024,
101 .colorspace
= V4L2_COLORSPACE_SRGB
,
102 .priv
= MODE_1280x1024
| FORMAT_BAYER
},
103 {640, 488, V4L2_PIX_FMT_Y10BPACK
, V4L2_FIELD_NONE
,
104 .bytesperline
= 640 * 10 / 8,
105 .sizeimage
= 640 * 488 * 10 / 8,
106 .colorspace
= V4L2_COLORSPACE_SRGB
,
107 .priv
= MODE_640x488
| FORMAT_Y10B
| FPS_HIGH
},
108 {1280, 1024, V4L2_PIX_FMT_Y10BPACK
, V4L2_FIELD_NONE
,
109 .bytesperline
= 1280 * 10 / 8,
110 .sizeimage
= 1280 * 1024 * 10 / 8,
111 .colorspace
= V4L2_COLORSPACE_SRGB
,
112 .priv
= MODE_1280x1024
| FORMAT_Y10B
},
115 static int kinect_write(struct usb_device
*udev
, uint8_t *data
,
118 return usb_control_msg(udev
,
119 usb_sndctrlpipe(udev
, 0),
121 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
122 0, 0, data
, wLength
, CTRL_TIMEOUT
);
125 static int kinect_read(struct usb_device
*udev
, uint8_t *data
, uint16_t wLength
)
127 return usb_control_msg(udev
,
128 usb_rcvctrlpipe(udev
, 0),
130 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
131 0, 0, data
, wLength
, CTRL_TIMEOUT
);
134 static int send_cmd(struct gspca_dev
*gspca_dev
, uint16_t cmd
, void *cmdbuf
,
135 unsigned int cmd_len
, void *replybuf
, unsigned int reply_len
)
137 struct sd
*sd
= (struct sd
*) gspca_dev
;
138 struct usb_device
*udev
= gspca_dev
->dev
;
140 uint8_t *obuf
= sd
->obuf
;
141 uint8_t *ibuf
= sd
->ibuf
;
142 struct cam_hdr
*chdr
= (void *)obuf
;
143 struct cam_hdr
*rhdr
= (void *)ibuf
;
145 if (cmd_len
& 1 || cmd_len
> (0x400 - sizeof(*chdr
))) {
146 pr_err("send_cmd: Invalid command length (0x%x)\n", cmd_len
);
150 chdr
->magic
[0] = 0x47;
151 chdr
->magic
[1] = 0x4d;
152 chdr
->cmd
= cpu_to_le16(cmd
);
153 chdr
->tag
= cpu_to_le16(sd
->cam_tag
);
154 chdr
->len
= cpu_to_le16(cmd_len
/ 2);
156 memcpy(obuf
+sizeof(*chdr
), cmdbuf
, cmd_len
);
158 res
= kinect_write(udev
, obuf
, cmd_len
+ sizeof(*chdr
));
159 PDEBUG(D_USBO
, "Control cmd=%04x tag=%04x len=%04x: %d", cmd
,
160 sd
->cam_tag
, cmd_len
, res
);
162 pr_err("send_cmd: Output control transfer failed (%d)\n", res
);
167 actual_len
= kinect_read(udev
, ibuf
, 0x200);
168 } while (actual_len
== 0);
169 PDEBUG(D_USBO
, "Control reply: %d", res
);
170 if (actual_len
< sizeof(*rhdr
)) {
171 pr_err("send_cmd: Input control transfer failed (%d)\n", res
);
174 actual_len
-= sizeof(*rhdr
);
176 if (rhdr
->magic
[0] != 0x52 || rhdr
->magic
[1] != 0x42) {
177 pr_err("send_cmd: Bad magic %02x %02x\n",
178 rhdr
->magic
[0], rhdr
->magic
[1]);
181 if (rhdr
->cmd
!= chdr
->cmd
) {
182 pr_err("send_cmd: Bad cmd %02x != %02x\n",
183 rhdr
->cmd
, chdr
->cmd
);
186 if (rhdr
->tag
!= chdr
->tag
) {
187 pr_err("send_cmd: Bad tag %04x != %04x\n",
188 rhdr
->tag
, chdr
->tag
);
191 if (cpu_to_le16(rhdr
->len
) != (actual_len
/2)) {
192 pr_err("send_cmd: Bad len %04x != %04x\n",
193 cpu_to_le16(rhdr
->len
), (int)(actual_len
/2));
197 if (actual_len
> reply_len
) {
198 pr_warn("send_cmd: Data buffer is %d bytes long, but got %d bytes\n",
199 reply_len
, actual_len
);
200 memcpy(replybuf
, ibuf
+sizeof(*rhdr
), reply_len
);
202 memcpy(replybuf
, ibuf
+sizeof(*rhdr
), actual_len
);
210 static int write_register(struct gspca_dev
*gspca_dev
, uint16_t reg
,
217 cmd
[0] = cpu_to_le16(reg
);
218 cmd
[1] = cpu_to_le16(data
);
220 PDEBUG(D_USBO
, "Write Reg 0x%04x <= 0x%02x", reg
, data
);
221 res
= send_cmd(gspca_dev
, 0x03, cmd
, 4, reply
, 4);
225 pr_warn("send_cmd returned %d [%04x %04x], 0000 expected\n",
226 res
, reply
[0], reply
[1]);
231 /* this function is called at probe time */
232 static int sd_config(struct gspca_dev
*gspca_dev
,
233 const struct usb_device_id
*id
)
235 struct sd
*sd
= (struct sd
*) gspca_dev
;
240 /* Only video stream is supported for now,
241 * which has stream flag = 0x80 */
242 sd
->stream_flag
= 0x80;
244 cam
= &gspca_dev
->cam
;
246 cam
->cam_mode
= video_camera_mode
;
247 cam
->nmodes
= ARRAY_SIZE(video_camera_mode
);
250 /* Setting those values is not needed for video stream */
252 gspca_dev
->pkt_size
= 960 * 2;
258 /* this function is called at probe and resume time */
259 static int sd_init(struct gspca_dev
*gspca_dev
)
261 PDEBUG(D_PROBE
, "Kinect Camera device.");
266 static int sd_start(struct gspca_dev
*gspca_dev
)
269 uint8_t fmt_reg
, fmt_val
;
270 uint8_t res_reg
, res_val
;
271 uint8_t fps_reg
, fps_val
;
274 mode
= gspca_dev
->cam
.cam_mode
[gspca_dev
->curr_mode
].priv
;
276 if (mode
& FORMAT_Y10B
) {
289 if (mode
& FORMAT_UYVY
)
294 if (mode
& MODE_1280x1024
)
305 /* turn off IR-reset function */
306 write_register(gspca_dev
, 0x105, 0x00);
308 /* Reset video stream */
309 write_register(gspca_dev
, 0x05, 0x00);
311 /* Due to some ridiculous condition in the firmware, we have to start
312 * and stop the depth stream before the camera will hand us 1280x1024
313 * IR. This is a stupid workaround, but we've yet to find a better
316 * Thanks to Drew Fisher for figuring this out.
318 if (mode
& (FORMAT_Y10B
| MODE_1280x1024
)) {
319 write_register(gspca_dev
, 0x13, 0x01);
320 write_register(gspca_dev
, 0x14, 0x1e);
321 write_register(gspca_dev
, 0x06, 0x02);
322 write_register(gspca_dev
, 0x06, 0x00);
325 write_register(gspca_dev
, fmt_reg
, fmt_val
);
326 write_register(gspca_dev
, res_reg
, res_val
);
327 write_register(gspca_dev
, fps_reg
, fps_val
);
329 /* Start video stream */
330 write_register(gspca_dev
, 0x05, mode_val
);
333 write_register(gspca_dev
, 0x47, 0x00);
338 static void sd_stopN(struct gspca_dev
*gspca_dev
)
340 /* reset video stream */
341 write_register(gspca_dev
, 0x05, 0x00);
344 static void sd_pkt_scan(struct gspca_dev
*gspca_dev
, u8
*__data
, int len
)
346 struct sd
*sd
= (struct sd
*) gspca_dev
;
348 struct pkt_hdr
*hdr
= (void *)__data
;
349 uint8_t *data
= __data
+ sizeof(*hdr
);
350 int datalen
= len
- sizeof(*hdr
);
352 uint8_t sof
= sd
->stream_flag
| 1;
353 uint8_t mof
= sd
->stream_flag
| 2;
354 uint8_t eof
= sd
->stream_flag
| 5;
359 if (hdr
->magic
[0] != 'R' || hdr
->magic
[1] != 'B') {
360 pr_warn("[Stream %02x] Invalid magic %02x%02x\n",
361 sd
->stream_flag
, hdr
->magic
[0], hdr
->magic
[1]);
365 if (hdr
->flag
== sof
)
366 gspca_frame_add(gspca_dev
, FIRST_PACKET
, data
, datalen
);
368 else if (hdr
->flag
== mof
)
369 gspca_frame_add(gspca_dev
, INTER_PACKET
, data
, datalen
);
371 else if (hdr
->flag
== eof
)
372 gspca_frame_add(gspca_dev
, LAST_PACKET
, data
, datalen
);
375 pr_warn("Packet type not recognized...\n");
378 /* sub-driver description */
379 static const struct sd_desc sd_desc
= {
382 .nctrls
= ARRAY_SIZE(sd_ctrls
),
387 .pkt_scan
= sd_pkt_scan
,
389 .querymenu = sd_querymenu,
390 .get_streamparm = sd_get_streamparm,
391 .set_streamparm = sd_set_streamparm,
395 /* -- module initialisation -- */
396 static const struct usb_device_id device_table
[] = {
397 {USB_DEVICE(0x045e, 0x02ae)},
401 MODULE_DEVICE_TABLE(usb
, device_table
);
403 /* -- device connect -- */
404 static int sd_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
406 return gspca_dev_probe(intf
, id
, &sd_desc
, sizeof(struct sd
),
410 static struct usb_driver sd_driver
= {
412 .id_table
= device_table
,
414 .disconnect
= gspca_disconnect
,
416 .suspend
= gspca_suspend
,
417 .resume
= gspca_resume
,
421 /* -- module insert / remove -- */
422 static int __init
sd_mod_init(void)
424 return usb_register(&sd_driver
);
427 static void __exit
sd_mod_exit(void)
429 usb_deregister(&sd_driver
);
432 module_init(sd_mod_init
);
433 module_exit(sd_mod_exit
);