2 * Copyright (C) 2008 Sensoray Company Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License (Version 2) as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/usb.h>
21 #include <linux/i2c.h>
22 #include <linux/videodev2.h>
23 #include <media/v4l2-common.h>
24 #include "go7007-priv.h"
27 extern int s2250loader_init(void);
28 extern void s2250loader_cleanup(void);
30 #define TLV320_ADDRESS 0x34
31 #define S2250_VIDDEC 0x86
32 #define VPX322_ADDR_ANALOGCONTROL1 0x02
33 #define VPX322_ADDR_BRIGHTNESS0 0x0127
34 #define VPX322_ADDR_BRIGHTNESS1 0x0131
35 #define VPX322_ADDR_CONTRAST0 0x0128
36 #define VPX322_ADDR_CONTRAST1 0x0132
37 #define VPX322_ADDR_HUE 0x00dc
38 #define VPX322_ADDR_SAT 0x0030
40 struct go7007_usb_board
{
42 struct go7007_board_info main_info
;
46 struct go7007_usb_board
*board
;
47 struct semaphore i2c_lock
;
48 struct usb_device
*usbdev
;
49 struct urb
*video_urbs
[8];
50 struct urb
*audio_urbs
[8];
54 static unsigned char aud_regs
[] = {
72 static unsigned char vid_regs
[] = {
79 static u16 vid_regs_fp
[] = {
104 /* PAL specific values */
105 static u16 vid_regs_fp_pal
[] =
128 /* from go7007-usb.c which is Copyright (C) 2005-2006 Micronas USA Inc.*/
129 static int go7007_usb_vendor_request(struct go7007
*go
, u16 request
,
130 u16 value
, u16 index
, void *transfer_buffer
, int length
, int in
)
132 struct go7007_usb
*usb
= go
->hpi_context
;
136 return usb_control_msg(usb
->usbdev
,
137 usb_rcvctrlpipe(usb
->usbdev
, 0), request
,
138 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
| USB_DIR_IN
,
139 value
, index
, transfer_buffer
, length
, timeout
);
141 return usb_control_msg(usb
->usbdev
,
142 usb_sndctrlpipe(usb
->usbdev
, 0), request
,
143 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
144 value
, index
, transfer_buffer
, length
, timeout
);
147 /* end from go7007-usb.c which is Copyright (C) 2005-2006 Micronas USA Inc.*/
149 static int write_reg(struct i2c_client
*client
, u8 reg
, u8 value
)
151 struct go7007
*go
= i2c_get_adapdata(client
->adapter
);
152 struct go7007_usb
*usb
= go
->hpi_context
;
154 int dev_addr
= client
->addr
;
160 if (go
->status
== STATUS_SHUTDOWN
)
163 buf
= kzalloc(16, GFP_KERNEL
);
167 if (down_interruptible(&usb
->i2c_lock
) != 0) {
168 printk(KERN_INFO
"i2c lock failed\n");
171 rc
= go7007_usb_vendor_request(go
, 0x55, dev_addr
,
181 static int write_reg_fp(struct i2c_client
*client
, u16 addr
, u16 val
)
183 struct go7007
*go
= i2c_get_adapdata(client
->adapter
);
184 struct go7007_usb
*usb
= go
->hpi_context
;
186 struct s2250
*dec
= i2c_get_clientdata(client
);
191 if (go
->status
== STATUS_SHUTDOWN
)
194 buf
= kzalloc(16, GFP_KERNEL
);
201 memset(buf
, 0xcd, 6);
203 if (down_interruptible(&usb
->i2c_lock
) != 0) {
204 printk(KERN_INFO
"i2c lock failed\n");
207 if (go7007_usb_vendor_request(go
, 0x57, addr
, val
, buf
, 16, 1) < 0)
212 unsigned int subaddr
, val_read
;
214 subaddr
= (buf
[4] << 8) + buf
[5];
215 val_read
= (buf
[2] << 8) + buf
[3];
216 if (val_read
!= val
) {
217 printk(KERN_INFO
"invalid fp write %x %x\n",
221 if (subaddr
!= addr
) {
222 printk(KERN_INFO
"invalid fp write addr %x %x\n",
229 /* save last 12b value */
231 dec
->reg12b_val
= val
;
236 static int write_regs(struct i2c_client
*client
, u8
*regs
)
240 for (i
= 0; !((regs
[i
] == 0x00) && (regs
[i
+1] == 0x00)); i
+= 2) {
241 if (write_reg(client
, regs
[i
], regs
[i
+1]) < 0) {
242 printk(KERN_INFO
"s2250: failed\n");
249 static int write_regs_fp(struct i2c_client
*client
, u16
*regs
)
253 for (i
= 0; !((regs
[i
] == 0x00) && (regs
[i
+1] == 0x00)); i
+= 2) {
254 if (write_reg_fp(client
, regs
[i
], regs
[i
+1]) < 0) {
255 printk(KERN_INFO
"s2250: failed fp\n");
263 static int s2250_command(struct i2c_client
*client
,
264 unsigned int cmd
, void *arg
)
266 struct s2250
*dec
= i2c_get_clientdata(client
);
274 vidsys
= (dec
->std
== V4L2_STD_NTSC
) ? 0x01 : 0x00;
277 write_reg_fp(client
, 0x20, 0x020 | vidsys
);
278 write_reg_fp(client
, 0x21, 0x662);
279 write_reg_fp(client
, 0x140, 0x060);
282 write_reg_fp(client
, 0x20, 0x040 | vidsys
);
283 write_reg_fp(client
, 0x21, 0x666);
284 write_reg_fp(client
, 0x140, 0x060);
291 v4l2_std_id
*std
= arg
;
294 vidsource
= (dec
->input
== 1) ? 0x040 : 0x020;
298 write_regs_fp(client
, vid_regs_fp
);
299 write_reg_fp(client
, 0x20, vidsource
| 1);
302 write_regs_fp(client
, vid_regs_fp
);
303 write_regs_fp(client
, vid_regs_fp_pal
);
304 write_reg_fp(client
, 0x20, vidsource
);
311 case VIDIOC_QUERYCTRL
:
313 struct v4l2_queryctrl
*ctrl
= arg
;
314 static const u32 user_ctrls
[] = {
321 static const u32
*ctrl_classes
[] = {
326 ctrl
->id
= v4l2_ctrl_next(ctrl_classes
, ctrl
->id
);
328 case V4L2_CID_BRIGHTNESS
:
329 v4l2_ctrl_query_fill(ctrl
, 0, 100, 1, 50);
331 case V4L2_CID_CONTRAST
:
332 v4l2_ctrl_query_fill(ctrl
, 0, 100, 1, 50);
334 case V4L2_CID_SATURATION
:
335 v4l2_ctrl_query_fill(ctrl
, 0, 100, 1, 50);
338 v4l2_ctrl_query_fill(ctrl
, -50, 50, 1, 0);
341 ctrl
->name
[0] = '\0';
348 struct v4l2_control
*ctrl
= arg
;
352 case V4L2_CID_BRIGHTNESS
:
353 printk(KERN_INFO
"s2250: future setting\n");
355 case V4L2_CID_CONTRAST
:
356 printk(KERN_INFO
"s2250: future setting\n");
359 case V4L2_CID_SATURATION
:
360 if (ctrl
->value
> 127)
361 dec
->saturation
= 127;
362 else if (ctrl
->value
< 0)
365 dec
->saturation
= ctrl
->value
;
367 value1
= dec
->saturation
* 4140 / 100;
370 write_reg_fp(client
, VPX322_ADDR_SAT
, value1
);
373 if (ctrl
->value
> 50)
375 else if (ctrl
->value
< -50)
378 dec
->hue
= ctrl
->value
;
379 /* clamp the hue range */
380 value1
= dec
->hue
* 280 / 50;
381 write_reg_fp(client
, VPX322_ADDR_HUE
, value1
);
388 struct v4l2_control
*ctrl
= arg
;
391 case V4L2_CID_BRIGHTNESS
:
392 ctrl
->value
= dec
->brightness
;
394 case V4L2_CID_CONTRAST
:
395 ctrl
->value
= dec
->contrast
;
397 case V4L2_CID_SATURATION
:
398 ctrl
->value
= dec
->saturation
;
401 ctrl
->value
= dec
->hue
;
408 struct v4l2_format
*fmt
= arg
;
409 if (fmt
->fmt
.pix
.height
< 640) {
410 write_reg_fp(client
, 0x12b, dec
->reg12b_val
| 0x400);
411 write_reg_fp(client
, 0x140, 0x060);
413 write_reg_fp(client
, 0x12b, dec
->reg12b_val
& ~0x400);
414 write_reg_fp(client
, 0x140, 0x060);
420 struct v4l2_audio
*audio
= arg
;
422 memset(audio
, 0, sizeof(*audio
));
423 audio
->index
= dec
->audio_input
;
426 case VIDIOC_ENUMAUDIO
:
428 struct v4l2_audio
*audio
= arg
;
430 switch (audio
->index
) {
432 strcpy(audio
->name
, "Line In");
435 strcpy(audio
->name
, "Mic");
438 strcpy(audio
->name
, "Mic Boost");
441 audio
->name
[0] = '\0';
444 audio
->capability
= V4L2_AUDCAP_STEREO
;
450 struct v4l2_audio
*audio
= arg
;
452 client
->addr
= TLV320_ADDRESS
;
453 switch (audio
->index
) {
455 write_reg(client
, 0x08, 0x02); /* Line In */
458 write_reg(client
, 0x08, 0x04); /* Mic */
461 write_reg(client
, 0x08, 0x05); /* Mic Boost */
466 dec
->audio_input
= audio
->index
;
471 printk(KERN_INFO
"s2250: unknown command 0x%x\n", cmd
);
477 static struct i2c_driver s2250_driver
;
479 static struct i2c_client s2250_client_templ
= {
480 .name
= "Sensoray 2250",
481 .driver
= &s2250_driver
,
484 static int s2250_detect(struct i2c_adapter
*adapter
, int addr
, int kind
)
486 struct i2c_client
*client
;
489 struct go7007
*go
= i2c_get_adapdata(adapter
);
490 struct go7007_usb
*usb
= go
->hpi_context
;
492 client
= kmalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
495 memcpy(client
, &s2250_client_templ
,
496 sizeof(s2250_client_templ
));
497 client
->adapter
= adapter
;
499 dec
= kmalloc(sizeof(struct s2250
), GFP_KERNEL
);
505 dec
->std
= V4L2_STD_NTSC
;
506 dec
->brightness
= 50;
508 dec
->saturation
= 50;
510 client
->addr
= TLV320_ADDRESS
;
511 i2c_set_clientdata(client
, dec
);
514 "s2250: initializing video decoder on %s\n",
517 /* initialize the audio */
518 client
->addr
= TLV320_ADDRESS
;
519 if (write_regs(client
, aud_regs
) < 0) {
521 "s2250: error initializing audio\n");
526 client
->addr
= S2250_VIDDEC
;
527 i2c_set_clientdata(client
, dec
);
529 if (write_regs(client
, vid_regs
) < 0) {
531 "s2250: error initializing decoder\n");
536 if (write_regs_fp(client
, vid_regs_fp
) < 0) {
538 "s2250: error initializing decoder\n");
543 /* set default channel */
545 write_reg_fp(client
, 0x20, 0x020 | 1);
546 write_reg_fp(client
, 0x21, 0x662);
547 write_reg_fp(client
, 0x140, 0x060);
549 /* set default audio input */
550 dec
->audio_input
= 0;
551 write_reg(client
, 0x08, 0x02); /* Line In */
553 if (down_interruptible(&usb
->i2c_lock
) == 0) {
554 data
= kzalloc(16, GFP_KERNEL
);
557 rc
= go7007_usb_vendor_request(go
, 0x41, 0, 0,
565 go7007_usb_vendor_request(go
, 0x40, 0,
575 i2c_attach_client(client
);
576 printk("s2250: initialized successfully\n");
580 static int s2250_detach(struct i2c_client
*client
)
582 struct s2250
*dec
= i2c_get_clientdata(client
);
585 r
= i2c_detach_client(client
);
594 static struct i2c_driver s2250_driver
= {
596 .name
= "Sensoray 2250 board driver",
598 .id
= I2C_DRIVERID_S2250
,
599 .detach_client
= s2250_detach
,
600 .command
= s2250_command
,
603 static int __init
s2250_init(void)
607 r
= s2250loader_init();
611 r
= i2c_add_driver(&s2250_driver
);
614 return wis_i2c_add_driver(s2250_driver
.id
, s2250_detect
);
617 static void __exit
s2250_cleanup(void)
619 wis_i2c_del_driver(s2250_detect
);
620 i2c_del_driver(&s2250_driver
);
622 s2250loader_cleanup();
625 module_init(s2250_init
);
626 module_exit(s2250_cleanup
);
629 MODULE_DESCRIPTION("Board driver for Sensoryray 2250");
630 MODULE_LICENSE("GPL v2");