2 * USB Driver for ALi m5602 based webcams
4 * Copyright (C) 2008 Erik Andrén
5 * Copyright (C) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
6 * Copyright (C) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
8 * Portions of code to USB interface and ALi driver software,
9 * Copyright (c) 2006 Willem Duinker
10 * v4l2 interface modeled after the V4L2 driver
11 * for SN9C10x PC Camera Controllers
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License as
15 * published by the Free Software Foundation, version 2.
19 #include "m5602_ov9650.h"
20 #include "m5602_mt9m111.h"
21 #include "m5602_po1030.h"
22 #include "m5602_s5k83a.h"
23 #include "m5602_s5k4aa.h"
25 /* Kernel module parameters */
27 static int dump_bridge
;
30 static const __devinitdata
struct usb_device_id m5602_table
[] = {
31 {USB_DEVICE(0x0402, 0x5602)},
35 MODULE_DEVICE_TABLE(usb
, m5602_table
);
37 /* Reads a byte from the m5602 */
38 int m5602_read_bridge(struct sd
*sd
, u8 address
, u8
*i2c_data
)
41 struct usb_device
*udev
= sd
->gspca_dev
.dev
;
42 __u8
*buf
= sd
->gspca_dev
.usb_buf
;
44 err
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
46 0x8100 + address
, buf
,
47 1, M5602_URB_MSG_TIMEOUT
);
50 PDEBUG(D_CONF
, "Reading bridge register 0x%x containing 0x%x",
53 /* usb_control_msg(...) returns the number of bytes sent upon success,
54 mask that and return zero instead*/
55 return (err
< 0) ? err
: 0;
58 /* Writes a byte to to the m5602 */
59 int m5602_write_bridge(struct sd
*sd
, u8 address
, u8 i2c_data
)
62 struct usb_device
*udev
= sd
->gspca_dev
.dev
;
63 __u8
*buf
= sd
->gspca_dev
.usb_buf
;
65 PDEBUG(D_CONF
, "Writing bridge register 0x%x with 0x%x",
68 memcpy(buf
, bridge_urb_skeleton
,
69 sizeof(bridge_urb_skeleton
));
73 err
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
76 4, M5602_URB_MSG_TIMEOUT
);
78 /* usb_control_msg(...) returns the number of bytes sent upon success,
79 mask that and return zero instead */
80 return (err
< 0) ? err
: 0;
83 int m5602_wait_for_i2c(struct sd
*sd
)
89 err
= m5602_read_bridge(sd
, M5602_XB_I2C_STATUS
, &data
);
90 } while ((data
& I2C_BUSY
) && !err
);
94 int m5602_read_sensor(struct sd
*sd
, const u8 address
,
95 u8
*i2c_data
, const u8 len
)
99 if (!len
|| len
> sd
->sensor
->i2c_regW
)
102 err
= m5602_wait_for_i2c(sd
);
106 err
= m5602_write_bridge(sd
, M5602_XB_I2C_DEV_ADDR
,
107 sd
->sensor
->i2c_slave_id
);
111 err
= m5602_write_bridge(sd
, M5602_XB_I2C_REG_ADDR
, address
);
115 if (sd
->sensor
->i2c_regW
== 1) {
116 err
= m5602_write_bridge(sd
, M5602_XB_I2C_CTRL
, len
);
120 err
= m5602_write_bridge(sd
, M5602_XB_I2C_CTRL
, 0x08);
124 err
= m5602_write_bridge(sd
, M5602_XB_I2C_CTRL
, 0x18 + len
);
129 for (i
= 0; (i
< len
) && !err
; i
++) {
130 err
= m5602_wait_for_i2c(sd
);
134 err
= m5602_read_bridge(sd
, M5602_XB_I2C_DATA
, &(i2c_data
[i
]));
136 PDEBUG(D_CONF
, "Reading sensor register "
137 "0x%x containing 0x%x ", address
, *i2c_data
);
142 int m5602_write_sensor(struct sd
*sd
, const u8 address
,
143 u8
*i2c_data
, const u8 len
)
147 struct usb_device
*udev
= sd
->gspca_dev
.dev
;
148 __u8
*buf
= sd
->gspca_dev
.usb_buf
;
150 /* No sensor with a data width larger than 16 bits has yet been seen */
151 if (len
> sd
->sensor
->i2c_regW
|| !len
)
154 memcpy(buf
, sensor_urb_skeleton
,
155 sizeof(sensor_urb_skeleton
));
157 buf
[11] = sd
->sensor
->i2c_slave_id
;
160 /* Special case larger sensor writes */
163 /* Copy a four byte write sequence for each byte to be written to */
164 for (i
= 0; i
< len
; i
++) {
165 memcpy(p
, sensor_urb_skeleton
+ 16, 4);
168 PDEBUG(D_CONF
, "Writing sensor register 0x%x with 0x%x",
169 address
, i2c_data
[i
]);
172 /* Copy the tailer */
173 memcpy(p
, sensor_urb_skeleton
+ 20, 4);
175 /* Set the total length */
178 err
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
181 20 + len
* 4, M5602_URB_MSG_TIMEOUT
);
183 return (err
< 0) ? err
: 0;
186 /* Dump all the registers of the m5602 bridge,
187 unfortunately this breaks the camera until it's power cycled */
188 static void m5602_dump_bridge(struct sd
*sd
)
191 for (i
= 0; i
< 0x80; i
++) {
192 unsigned char val
= 0;
193 m5602_read_bridge(sd
, i
, &val
);
194 info("ALi m5602 address 0x%x contains 0x%x", i
, val
);
196 info("Warning: The ALi m5602 webcam probably won't work "
197 "until it's power cycled");
200 static int m5602_probe_sensor(struct sd
*sd
)
203 sd
->sensor
= &po1030
;
204 if (!sd
->sensor
->probe(sd
))
207 /* Try the mt9m111 sensor */
208 sd
->sensor
= &mt9m111
;
209 if (!sd
->sensor
->probe(sd
))
213 sd
->sensor
= &s5k4aa
;
214 if (!sd
->sensor
->probe(sd
))
218 sd
->sensor
= &ov9650
;
219 if (!sd
->sensor
->probe(sd
))
223 sd
->sensor
= &s5k83a
;
224 if (!sd
->sensor
->probe(sd
))
227 /* More sensor probe function goes here */
228 info("Failed to find a sensor");
233 static int m5602_configure(struct gspca_dev
*gspca_dev
,
234 const struct usb_device_id
*id
);
236 static int m5602_init(struct gspca_dev
*gspca_dev
)
238 struct sd
*sd
= (struct sd
*) gspca_dev
;
241 PDEBUG(D_CONF
, "Initializing ALi m5602 webcam");
242 /* Run the init sequence */
243 err
= sd
->sensor
->init(sd
);
248 static int m5602_start_transfer(struct gspca_dev
*gspca_dev
)
250 struct sd
*sd
= (struct sd
*) gspca_dev
;
251 __u8
*buf
= sd
->gspca_dev
.usb_buf
;
254 /* Send start command to the camera */
255 const u8 buffer
[4] = {0x13, 0xf9, 0x0f, 0x01};
257 if (sd
->sensor
->start
)
258 sd
->sensor
->start(sd
);
260 memcpy(buf
, buffer
, sizeof(buffer
));
261 err
= usb_control_msg(gspca_dev
->dev
,
262 usb_sndctrlpipe(gspca_dev
->dev
, 0),
263 0x04, 0x40, 0x19, 0x0000, buf
,
264 sizeof(buffer
), M5602_URB_MSG_TIMEOUT
);
266 PDEBUG(D_STREAM
, "Transfer started");
267 return (err
< 0) ? err
: 0;
270 static void m5602_urb_complete(struct gspca_dev
*gspca_dev
,
271 struct gspca_frame
*frame
,
274 struct sd
*sd
= (struct sd
*) gspca_dev
;
277 PDEBUG(D_PACK
, "Packet is less than 6 bytes");
281 /* Frame delimiter: ff xx xx xx ff ff */
282 if (data
[0] == 0xff && data
[4] == 0xff && data
[5] == 0xff &&
283 data
[2] != sd
->frame_id
) {
284 PDEBUG(D_FRAM
, "Frame delimiter detected");
285 sd
->frame_id
= data
[2];
287 /* Remove the extra fluff appended on each header */
291 /* Complete the last frame (if any) */
292 frame
= gspca_frame_add(gspca_dev
, LAST_PACKET
,
296 /* Create a new frame */
297 gspca_frame_add(gspca_dev
, FIRST_PACKET
, frame
, data
, len
);
299 PDEBUG(D_FRAM
, "Starting new frame %d",
303 int cur_frame_len
= frame
->data_end
- frame
->data
;
305 /* Remove urb header */
309 if (cur_frame_len
+ len
<= frame
->v4l2_buf
.length
) {
310 PDEBUG(D_FRAM
, "Continuing frame %d copying %d bytes",
311 sd
->frame_count
, len
);
313 gspca_frame_add(gspca_dev
, INTER_PACKET
, frame
,
315 } else if (frame
->v4l2_buf
.length
- cur_frame_len
> 0) {
316 /* Add the remaining data up to frame size */
317 gspca_frame_add(gspca_dev
, INTER_PACKET
, frame
, data
,
318 frame
->v4l2_buf
.length
- cur_frame_len
);
323 static void m5602_stop_transfer(struct gspca_dev
*gspca_dev
)
325 struct sd
*sd
= (struct sd
*) gspca_dev
;
327 /* Run the sensor specific end transfer sequence */
328 if (sd
->sensor
->stop
)
329 sd
->sensor
->stop(sd
);
332 /* sub-driver description, the ctrl and nctrl is filled at probe time */
333 static struct sd_desc sd_desc
= {
335 .config
= m5602_configure
,
337 .start
= m5602_start_transfer
,
338 .stopN
= m5602_stop_transfer
,
339 .pkt_scan
= m5602_urb_complete
342 /* this function is called at probe time */
343 static int m5602_configure(struct gspca_dev
*gspca_dev
,
344 const struct usb_device_id
*id
)
346 struct sd
*sd
= (struct sd
*) gspca_dev
;
350 cam
= &gspca_dev
->cam
;
354 m5602_dump_bridge(sd
);
357 err
= m5602_probe_sensor(sd
);
364 PDEBUG(D_ERR
, "ALi m5602 webcam failed");
365 cam
->cam_mode
= NULL
;
371 static int m5602_probe(struct usb_interface
*intf
,
372 const struct usb_device_id
*id
)
374 return gspca_dev_probe(intf
, id
, &sd_desc
, sizeof(struct sd
),
378 void m5602_disconnect(struct usb_interface
*intf
)
380 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
381 struct sd
*sd
= (struct sd
*) gspca_dev
;
383 if (sd
->sensor
->disconnect
)
384 sd
->sensor
->disconnect(sd
);
386 gspca_disconnect(intf
);
389 static struct usb_driver sd_driver
= {
391 .id_table
= m5602_table
,
392 .probe
= m5602_probe
,
394 .suspend
= gspca_suspend
,
395 .resume
= gspca_resume
,
397 .disconnect
= m5602_disconnect
400 /* -- module insert / remove -- */
401 static int __init
mod_m5602_init(void)
404 ret
= usb_register(&sd_driver
);
407 PDEBUG(D_PROBE
, "registered");
411 static void __exit
mod_m5602_exit(void)
413 usb_deregister(&sd_driver
);
414 PDEBUG(D_PROBE
, "deregistered");
417 module_init(mod_m5602_init
);
418 module_exit(mod_m5602_exit
);
420 MODULE_AUTHOR(DRIVER_AUTHOR
);
421 MODULE_DESCRIPTION(DRIVER_DESC
);
422 MODULE_LICENSE("GPL");
423 module_param(force_sensor
, int, S_IRUGO
| S_IWUSR
);
424 MODULE_PARM_DESC(force_sensor
,
425 "forces detection of a sensor, "
426 "1 = OV9650, 2 = S5K83A, 3 = S5K4AA, "
427 "4 = MT9M111, 5 = PO1030, 6 = OV7660");
429 module_param(dump_bridge
, bool, S_IRUGO
| S_IWUSR
);
430 MODULE_PARM_DESC(dump_bridge
, "Dumps all usb bridge registers at startup");
432 module_param(dump_sensor
, bool, S_IRUGO
| S_IWUSR
);
433 MODULE_PARM_DESC(dump_sensor
, "Dumps all usb sensor registers "
434 "at startup providing a sensor is found");