1 /*
2 * USB Driver for ALi m5602 based webcams
3 *
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>
7 *
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
12 *
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.
16 *
17 */
18
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"
24
25 /* Kernel module parameters */
26 int force_sensor;
27 static int dump_bridge;
28 int dump_sensor;
29
30 static const __devinitdata struct usb_device_id m5602_table[] = {
31 {USB_DEVICE(0x0402, 0x5602)},
32 {}
33 };
34
35 MODULE_DEVICE_TABLE(usb, m5602_table);
36
37 /* Reads a byte from the m5602 */
m5602_read_bridge(struct sd * sd,u8 address,u8 * i2c_data)38 int m5602_read_bridge(struct sd *sd, u8 address, u8 *i2c_data)
39 {
40 int err;
41 struct usb_device *udev = sd->gspca_dev.dev;
42 __u8 *buf = sd->gspca_dev.usb_buf;
43
44 err = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
45 0x04, 0xc0, 0x14,
46 0x8100 + address, buf,
47 1, M5602_URB_MSG_TIMEOUT);
48 *i2c_data = buf[0];
49
50 PDEBUG(D_CONF, "Reading bridge register 0x%x containing 0x%x",
51 address, *i2c_data);
52
53 /* usb_control_msg(...) returns the number of bytes sent upon success,
54 mask that and return zero upon success instead*/
55 return (err < 0) ? err : 0;
56 }
57
58 /* Writes a byte to to the m5602 */
m5602_write_bridge(struct sd * sd,u8 address,u8 i2c_data)59 int m5602_write_bridge(struct sd *sd, u8 address, u8 i2c_data)
60 {
61 int err;
62 struct usb_device *udev = sd->gspca_dev.dev;
63 __u8 *buf = sd->gspca_dev.usb_buf;
64
65 PDEBUG(D_CONF, "Writing bridge register 0x%x with 0x%x",
66 address, i2c_data);
67
68 memcpy(buf, bridge_urb_skeleton,
69 sizeof(bridge_urb_skeleton));
70 buf[1] = address;
71 buf[3] = i2c_data;
72
73 err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
74 0x04, 0x40, 0x19,
75 0x0000, buf,
76 4, M5602_URB_MSG_TIMEOUT);
77
78 /* usb_control_msg(...) returns the number of bytes sent upon success,
79 mask that and return zero upon success instead */
80 return (err < 0) ? err : 0;
81 }
82
m5602_read_sensor(struct sd * sd,const u8 address,u8 * i2c_data,const u8 len)83 int m5602_read_sensor(struct sd *sd, const u8 address,
84 u8 *i2c_data, const u8 len)
85 {
86 int err, i;
87
88 if (!len || len > sd->sensor->i2c_regW)
89 return -EINVAL;
90
91 do {
92 err = m5602_read_bridge(sd, M5602_XB_I2C_STATUS, i2c_data);
93 } while ((*i2c_data & I2C_BUSY) && !err);
94 if (err < 0)
95 goto out;
96
97 err = m5602_write_bridge(sd, M5602_XB_I2C_DEV_ADDR,
98 sd->sensor->i2c_slave_id);
99 if (err < 0)
100 goto out;
101
102 err = m5602_write_bridge(sd, M5602_XB_I2C_REG_ADDR, address);
103 if (err < 0)
104 goto out;
105
106 if (sd->sensor->i2c_regW == 1) {
107 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, len);
108 if (err < 0)
109 goto out;
110
111 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x08);
112 if (err < 0)
113 goto out;
114 } else {
115 err = m5602_write_bridge(sd, M5602_XB_I2C_CTRL, 0x18 + len);
116 if (err < 0)
117 goto out;
118 }
119
120 for (i = 0; (i < len) && !err; i++) {
121 err = m5602_read_bridge(sd, M5602_XB_I2C_DATA, &(i2c_data[i]));
122
123 PDEBUG(D_CONF, "Reading sensor register "
124 "0x%x containing 0x%x ", address, *i2c_data);
125 }
126 out:
127 return err;
128 }
129
m5602_write_sensor(struct sd * sd,const u8 address,u8 * i2c_data,const u8 len)130 int m5602_write_sensor(struct sd *sd, const u8 address,
131 u8 *i2c_data, const u8 len)
132 {
133 int err, i;
134 u8 *p;
135 struct usb_device *udev = sd->gspca_dev.dev;
136 __u8 *buf = sd->gspca_dev.usb_buf;
137
138 /* No sensor with a data width larger than 16 bits has yet been seen */
139 if (len > sd->sensor->i2c_regW || !len)
140 return -EINVAL;
141
142 memcpy(buf, sensor_urb_skeleton,
143 sizeof(sensor_urb_skeleton));
144
145 buf[11] = sd->sensor->i2c_slave_id;
146 buf[15] = address;
147
148 /* Special case larger sensor writes */
149 p = buf + 16;
150
151 /* Copy a four byte write sequence for each byte to be written to */
152 for (i = 0; i < len; i++) {
153 memcpy(p, sensor_urb_skeleton + 16, 4);
154 p[3] = i2c_data[i];
155 p += 4;
156 PDEBUG(D_CONF, "Writing sensor register 0x%x with 0x%x",
157 address, i2c_data[i]);
158 }
159
160 /* Copy the tailer */
161 memcpy(p, sensor_urb_skeleton + 20, 4);
162
163 /* Set the total length */
164 p[3] = 0x10 + len;
165
166 err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
167 0x04, 0x40, 0x19,
168 0x0000, buf,
169 20 + len * 4, M5602_URB_MSG_TIMEOUT);
170
171 return (err < 0) ? err : 0;
172 }
173
174 /* Dump all the registers of the m5602 bridge,
175 unfortunately this breaks the camera until it's power cycled */
m5602_dump_bridge(struct sd * sd)176 static void m5602_dump_bridge(struct sd *sd)
177 {
178 int i;
179 for (i = 0; i < 0x80; i++) {
180 unsigned char val = 0;
181 m5602_read_bridge(sd, i, &val);
182 info("ALi m5602 address 0x%x contains 0x%x", i, val);
183 }
184 info("Warning: The ALi m5602 webcam probably won't work "
185 "until it's power cycled");
186 }
187
m5602_probe_sensor(struct sd * sd)188 static int m5602_probe_sensor(struct sd *sd)
189 {
190 /* Try the po1030 */
191 sd->sensor = &po1030;
192 if (!sd->sensor->probe(sd))
193 return 0;
194
195 /* Try the mt9m111 sensor */
196 sd->sensor = &mt9m111;
197 if (!sd->sensor->probe(sd))
198 return 0;
199
200 /* Try the s5k4aa */
201 sd->sensor = &s5k4aa;
202 if (!sd->sensor->probe(sd))
203 return 0;
204
205 /* Try the ov9650 */
206 sd->sensor = &ov9650;
207 if (!sd->sensor->probe(sd))
208 return 0;
209
210 /* Try the s5k83a */
211 sd->sensor = &s5k83a;
212 if (!sd->sensor->probe(sd))
213 return 0;
214
215 /* More sensor probe function goes here */
216 info("Failed to find a sensor");
217 sd->sensor = NULL;
218 return -ENODEV;
219 }
220
221 static int m5602_configure(struct gspca_dev *gspca_dev,
222 const struct usb_device_id *id);
223
m5602_init(struct gspca_dev * gspca_dev)224 static int m5602_init(struct gspca_dev *gspca_dev)
225 {
226 struct sd *sd = (struct sd *) gspca_dev;
227 int err;
228
229 PDEBUG(D_CONF, "Initializing ALi m5602 webcam");
230 /* Run the init sequence */
231 err = sd->sensor->init(sd);
232
233 return err;
234 }
235
m5602_start_transfer(struct gspca_dev * gspca_dev)236 static int m5602_start_transfer(struct gspca_dev *gspca_dev)
237 {
238 struct sd *sd = (struct sd *) gspca_dev;
239 __u8 *buf = sd->gspca_dev.usb_buf;
240 int err;
241
242 /* Send start command to the camera */
243 const u8 buffer[4] = {0x13, 0xf9, 0x0f, 0x01};
244
245 if (sd->sensor->start)
246 sd->sensor->start(sd);
247
248 memcpy(buf, buffer, sizeof(buffer));
249 err = usb_control_msg(gspca_dev->dev,
250 usb_sndctrlpipe(gspca_dev->dev, 0),
251 0x04, 0x40, 0x19, 0x0000, buf,
252 sizeof(buffer), M5602_URB_MSG_TIMEOUT);
253
254 PDEBUG(D_STREAM, "Transfer started");
255 return (err < 0) ? err : 0;
256 }
257
m5602_urb_complete(struct gspca_dev * gspca_dev,struct gspca_frame * frame,__u8 * data,int len)258 static void m5602_urb_complete(struct gspca_dev *gspca_dev,
259 struct gspca_frame *frame,
260 __u8 *data, int len)
261 {
262 struct sd *sd = (struct sd *) gspca_dev;
263
264 if (len < 6) {
265 PDEBUG(D_PACK, "Packet is less than 6 bytes");
266 return;
267 }
268
269 /* Frame delimiter: ff xx xx xx ff ff */
270 if (data[0] == 0xff && data[4] == 0xff && data[5] == 0xff &&
271 data[2] != sd->frame_id) {
272 PDEBUG(D_FRAM, "Frame delimiter detected");
273 sd->frame_id = data[2];
274
275 /* Remove the extra fluff appended on each header */
276 data += 6;
277 len -= 6;
278
279 /* Complete the last frame (if any) */
280 frame = gspca_frame_add(gspca_dev, LAST_PACKET,
281 frame, data, 0);
282 sd->frame_count++;
283
284 /* Create a new frame */
285 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
286
287 PDEBUG(D_FRAM, "Starting new frame %d",
288 sd->frame_count);
289
290 } else {
291 int cur_frame_len = frame->data_end - frame->data;
292
293 /* Remove urb header */
294 data += 4;
295 len -= 4;
296
297 if (cur_frame_len + len <= frame->v4l2_buf.length) {
298 PDEBUG(D_FRAM, "Continuing frame %d copying %d bytes",
299 sd->frame_count, len);
300
301 gspca_frame_add(gspca_dev, INTER_PACKET, frame,
302 data, len);
303 } else if (frame->v4l2_buf.length - cur_frame_len > 0) {
304 /* Add the remaining data up to frame size */
305 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data,
306 frame->v4l2_buf.length - cur_frame_len);
307 }
308 }
309 }
310
m5602_stop_transfer(struct gspca_dev * gspca_dev)311 static void m5602_stop_transfer(struct gspca_dev *gspca_dev)
312 {
313 /* Is there are a command to stop a data transfer? */
314 }
315
316 /* sub-driver description, the ctrl and nctrl is filled at probe time */
317 static struct sd_desc sd_desc = {
318 .name = MODULE_NAME,
319 .config = m5602_configure,
320 .init = m5602_init,
321 .start = m5602_start_transfer,
322 .stopN = m5602_stop_transfer,
323 .pkt_scan = m5602_urb_complete
324 };
325
326 /* this function is called at probe time */
m5602_configure(struct gspca_dev * gspca_dev,const struct usb_device_id * id)327 static int m5602_configure(struct gspca_dev *gspca_dev,
328 const struct usb_device_id *id)
329 {
330 struct sd *sd = (struct sd *) gspca_dev;
331 struct cam *cam;
332 int err;
333
334 cam = &gspca_dev->cam;
335 cam->epaddr = M5602_ISOC_ENDPOINT_ADDR;
336 sd->desc = &sd_desc;
337
338 if (dump_bridge)
339 m5602_dump_bridge(sd);
340
341 /* Probe sensor */
342 err = m5602_probe_sensor(sd);
343 if (err)
344 goto fail;
345
346 return 0;
347
348 fail:
349 PDEBUG(D_ERR, "ALi m5602 webcam failed");
350 cam->cam_mode = NULL;
351 cam->nmodes = 0;
352
353 return err;
354 }
355
m5602_probe(struct usb_interface * intf,const struct usb_device_id * id)356 static int m5602_probe(struct usb_interface *intf,
357 const struct usb_device_id *id)
358 {
359 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
360 THIS_MODULE);
361 }
362
363 static struct usb_driver sd_driver = {
364 .name = MODULE_NAME,
365 .id_table = m5602_table,
366 .probe = m5602_probe,
367 #ifdef CONFIG_PM
368 .suspend = gspca_suspend,
369 .resume = gspca_resume,
370 #endif
371 .disconnect = gspca_disconnect
372 };
373
374 /* -- module insert / remove -- */
mod_m5602_init(void)375 static int __init mod_m5602_init(void)
376 {
377 if (usb_register(&sd_driver) < 0)
378 return -1;
379 PDEBUG(D_PROBE, "registered");
380 return 0;
381 }
382
mod_m5602_exit(void)383 static void __exit mod_m5602_exit(void)
384 {
385 usb_deregister(&sd_driver);
386 PDEBUG(D_PROBE, "deregistered");
387 }
388
389 module_init(mod_m5602_init);
390 module_exit(mod_m5602_exit);
391
392 MODULE_AUTHOR(DRIVER_AUTHOR);
393 MODULE_DESCRIPTION(DRIVER_DESC);
394 MODULE_LICENSE("GPL");
395 module_param(force_sensor, int, S_IRUGO | S_IWUSR);
396 MODULE_PARM_DESC(force_sensor,
397 "force detection of sensor, "
398 "1 = OV9650, 2 = S5K83A, 3 = S5K4AA, 4 = MT9M111, 5 = PO1030");
399
400 module_param(dump_bridge, bool, S_IRUGO | S_IWUSR);
401 MODULE_PARM_DESC(dump_bridge, "Dumps all usb bridge registers at startup");
402
403 module_param(dump_sensor, bool, S_IRUGO | S_IWUSR);
404 MODULE_PARM_DESC(dump_sensor, "Dumps all usb sensor registers "
405 "at startup providing a sensor is found");
406