2 * device driver for Telegent tlg2300 based TV cards
5 * Kang Yong <kangyong@telegent.com>
6 * Zhang Xiaobing <xbzhang@telegent.com>
7 * Huang Shijie <zyziii@telegent.com> or <shijie8@gmail.com>
9 * (c) 2009 Telegent Systems
10 * (c) 2010 Telegent Systems
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
15 * (at your option) any later version.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/version.h>
28 #include <linux/kernel.h>
29 #include <linux/errno.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/module.h>
33 #include <linux/kref.h>
34 #include <linux/suspend.h>
35 #include <linux/usb/quirks.h>
36 #include <linux/ctype.h>
37 #include <linux/string.h>
38 #include <linux/types.h>
39 #include <linux/firmware.h>
40 #include <linux/smp_lock.h>
42 #include "vendorcmds.h"
43 #include "pd-common.h"
45 #define VENDOR_ID 0x1B24
46 #define PRODUCT_ID 0x4001
47 static struct usb_device_id id_table
[] = {
48 { USB_DEVICE_AND_INTERFACE_INFO(VENDOR_ID
, PRODUCT_ID
, 255, 1, 0) },
49 { USB_DEVICE_AND_INTERFACE_INFO(VENDOR_ID
, PRODUCT_ID
, 255, 1, 1) },
52 MODULE_DEVICE_TABLE(usb
, id_table
);
55 module_param(debug_mode
, int, 0644);
56 MODULE_PARM_DESC(debug_mode
, "0 = disable, 1 = enable, 2 = verbose");
58 const char *firmware_name
= "tlg2300_firmware.bin";
59 struct usb_driver poseidon_driver
;
60 static LIST_HEAD(pd_device_list
);
63 * send set request to USB firmware.
65 s32
send_set_req(struct poseidon
*pd
, u8 cmdid
, s32 param
, s32
*cmd_status
)
69 u16 lower_16
, upper_16
;
71 if (pd
->state
& POSEIDON_STATE_DISCONNECT
)
77 upper_16
= lower_16
= 0;
79 /* send 32 bit param as two 16 bit param,little endian */
80 lower_16
= (unsigned short)(param
& 0xffff);
81 upper_16
= (unsigned short)((param
>> 16) & 0xffff);
83 ret
= usb_control_msg(pd
->udev
,
84 usb_rcvctrlpipe(pd
->udev
, 0),
86 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
91 USB_CTRL_GET_TIMEOUT
);
96 /* 1st 4 bytes into cmd_status */
97 memcpy((char *)cmd_status
, &(data
[0]), sizeof(*cmd_status
));
103 * send get request to Poseidon firmware.
105 s32
send_get_req(struct poseidon
*pd
, u8 cmdid
, s32 param
,
106 void *buf
, s32
*cmd_status
, s32 datalen
)
110 u16 lower_16
, upper_16
;
112 if (pd
->state
& POSEIDON_STATE_DISCONNECT
)
117 upper_16
= lower_16
= 0;
119 /*send 32 bit param as two 16 bit param, little endian */
120 lower_16
= (unsigned short)(param
& 0xffff);
121 upper_16
= (unsigned short)((param
>> 16) & 0xffff);
123 ret
= usb_control_msg(pd
->udev
,
124 usb_rcvctrlpipe(pd
->udev
, 0),
126 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
130 (datalen
+ sizeof(*cmd_status
)),
131 USB_CTRL_GET_TIMEOUT
);
136 /* 1st 4 bytes into cmd_status, remaining data into cmd_data */
137 memcpy((char *)cmd_status
, &data
[0], sizeof(*cmd_status
));
138 memcpy((char *)buf
, &data
[sizeof(*cmd_status
)], datalen
);
143 static int pm_notifier_block(struct notifier_block
*nb
,
144 unsigned long event
, void *dummy
)
146 struct poseidon
*pd
= NULL
;
147 struct list_head
*node
, *next
;
150 case PM_POST_HIBERNATION
:
151 list_for_each_safe(node
, next
, &pd_device_list
) {
152 struct usb_device
*udev
;
153 struct usb_interface
*iface
;
156 pd
= container_of(node
, struct poseidon
, device_list
);
158 iface
= pd
->interface
;
160 /* It will cause the system to reload the firmware */
161 rc
= usb_lock_device_for_reset(udev
, iface
);
163 usb_reset_device(udev
);
164 usb_unlock_device(udev
);
171 log("event :%ld\n", event
);
175 static struct notifier_block pm_notifer
= {
176 .notifier_call
= pm_notifier_block
,
179 int set_tuner_mode(struct poseidon
*pd
, unsigned char mode
)
183 if (pd
->state
& POSEIDON_STATE_DISCONNECT
)
186 ret
= send_set_req(pd
, TUNE_MODE_SELECT
, mode
, &cmd_status
);
187 if (ret
|| cmd_status
)
192 enum tlg__analog_audio_standard
get_audio_std(s32 mode
, s32 country_code
)
194 s32 nicam
[] = {27, 32, 33, 34, 36, 44, 45, 46, 47, 48, 64,
195 65, 86, 351, 352, 353, 354, 358, 372, 852, 972};
196 s32 btsc
[] = {1, 52, 54, 55, 886};
200 if (mode
== TLG_MODE_FM_RADIO
) {
201 if (country_code
== 1)
202 return TLG_TUNE_ASTD_FM_US
;
204 return TLG_TUNE_ASTD_FM_EUR
;
205 } else if (mode
== TLG_MODE_ANALOG_TV_UNCOMP
) {
206 for (i
= 0; i
< sizeof(nicam
) / sizeof(s32
); i
++) {
207 if (country_code
== nicam
[i
])
208 return TLG_TUNE_ASTD_NICAM
;
211 for (i
= 0; i
< sizeof(btsc
) / sizeof(s32
); i
++) {
212 if (country_code
== btsc
[i
])
213 return TLG_TUNE_ASTD_BTSC
;
216 for (i
= 0; i
< sizeof(eiaj
) / sizeof(s32
); i
++) {
217 if (country_code
== eiaj
[i
])
218 return TLG_TUNE_ASTD_EIAJ
;
221 return TLG_TUNE_ASTD_A2
;
223 return TLG_TUNE_ASTD_NONE
;
227 void poseidon_delete(struct kref
*kref
)
229 struct poseidon
*pd
= container_of(kref
, struct poseidon
, kref
);
233 list_del_init(&pd
->device_list
);
235 pd_dvb_usb_device_cleanup(pd
);
236 /* clean_audio_data(&pd->audio_data);*/
239 usb_put_dev(pd
->udev
);
243 usb_put_intf(pd
->interface
);
244 pd
->interface
= NULL
;
250 static int firmware_download(struct usb_device
*udev
)
252 int ret
= 0, actual_length
;
253 const struct firmware
*fw
= NULL
;
255 size_t fwlength
= 0, offset
;
256 size_t max_packet_size
;
258 ret
= request_firmware(&fw
, firmware_name
, &udev
->dev
);
260 log("download err : %d", ret
);
266 fwbuf
= kzalloc(fwlength
, GFP_KERNEL
);
271 memcpy(fwbuf
, fw
->data
, fwlength
);
273 max_packet_size
= udev
->ep_out
[0x1]->desc
.wMaxPacketSize
;
274 log("\t\t download size : %d", (int)max_packet_size
);
276 for (offset
= 0; offset
< fwlength
; offset
+= max_packet_size
) {
278 ret
= usb_bulk_msg(udev
,
279 usb_sndbulkpipe(udev
, 0x01), /* ep 1 */
281 min(max_packet_size
, fwlength
- offset
),
289 release_firmware(fw
);
294 /* one-to-one map : poseidon{} <----> usb_device{}'s port */
295 static inline void set_map_flags(struct poseidon
*pd
, struct usb_device
*udev
)
297 pd
->portnum
= udev
->portnum
;
300 static inline int get_autopm_ref(struct poseidon
*pd
)
302 return pd
->video_data
.users
+ pd
->vbi_data
.users
+ pd
->audio
.users
303 + atomic_read(&pd
->dvb_data
.users
) + pd
->radio_data
.users
;
306 /* fixup something for poseidon */
307 static inline struct poseidon
*fixup(struct poseidon
*pd
)
311 /* old udev and interface have gone, so put back reference . */
312 count
= get_autopm_ref(pd
);
313 log("count : %d, ref count : %d", count
, get_pm_count(pd
));
315 usb_autopm_put_interface(pd
->interface
);
316 /*usb_autopm_set_interface(pd->interface); */
318 usb_put_dev(pd
->udev
);
319 usb_put_intf(pd
->interface
);
320 log("event : %d\n", pd
->msg
.event
);
324 static struct poseidon
*find_old_poseidon(struct usb_device
*udev
)
328 list_for_each_entry(pd
, &pd_device_list
, device_list
) {
329 if (pd
->portnum
== udev
->portnum
&& in_hibernation(pd
))
335 /* Is the card working now ? */
336 static inline int is_working(struct poseidon
*pd
)
338 return get_pm_count(pd
) > 0;
341 static inline struct poseidon
*get_pd(struct usb_interface
*intf
)
343 return usb_get_intfdata(intf
);
346 static int poseidon_suspend(struct usb_interface
*intf
, pm_message_t msg
)
348 struct poseidon
*pd
= get_pd(intf
);
352 if (!is_working(pd
)) {
353 if (get_pm_count(pd
) <= 0 && !in_hibernation(pd
)) {
354 pd
->msg
.event
= PM_EVENT_AUTO_SUSPEND
;
355 pd
->pm_resume
= NULL
; /* a good guard */
356 printk(KERN_DEBUG
"\n\t+ TLG2300 auto suspend +\n\n");
360 pd
->msg
= msg
; /* save it here */
362 return pd
->pm_suspend
? pd
->pm_suspend(pd
) : 0;
365 static int poseidon_resume(struct usb_interface
*intf
)
367 struct poseidon
*pd
= get_pd(intf
);
371 printk(KERN_DEBUG
"\n\t ++ TLG2300 resume ++\n\n");
373 if (!is_working(pd
)) {
374 if (PM_EVENT_AUTO_SUSPEND
== pd
->msg
.event
)
378 if (in_hibernation(pd
)) {
383 return pd
->pm_resume
? pd
->pm_resume(pd
) : 0;
386 static void hibernation_resume(struct work_struct
*w
)
388 struct poseidon
*pd
= container_of(w
, struct poseidon
, pm_work
);
391 pd
->msg
.event
= 0; /* clear it here */
392 pd
->state
&= ~POSEIDON_STATE_DISCONNECT
;
394 /* set the new interface's reference */
395 count
= get_autopm_ref(pd
);
397 usb_autopm_get_interface(pd
->interface
);
399 /* resume the context */
406 static bool check_firmware(struct usb_device
*udev
, int *down_firmware
)
410 struct cmd_firmware_vers_s
*cmd_firm
;
412 buf
= kzalloc(sizeof(*cmd_firm
) + sizeof(u32
), GFP_KERNEL
);
415 ret
= usb_control_msg(udev
,
416 usb_rcvctrlpipe(udev
, 0),
417 REQ_GET_CMD
| GET_FW_ID
,
418 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
422 sizeof(*cmd_firm
) + sizeof(u32
),
423 USB_CTRL_GET_TIMEOUT
);
428 return firmware_download(udev
);
433 static int poseidon_probe(struct usb_interface
*interface
,
434 const struct usb_device_id
*id
)
436 struct usb_device
*udev
= interface_to_usbdev(interface
);
437 struct poseidon
*pd
= NULL
;
441 /* download firmware */
442 check_firmware(udev
, &ret
);
446 /* Do I recovery from the hibernate ? */
447 pd
= find_old_poseidon(udev
);
449 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
452 kref_init(&pd
->kref
);
453 set_map_flags(pd
, udev
);
457 pd
->udev
= usb_get_dev(udev
);
458 pd
->interface
= usb_get_intf(interface
);
459 usb_set_intfdata(interface
, pd
);
462 struct device
*dev
= &interface
->dev
;
465 pd
->country_code
= 86;
466 mutex_init(&pd
->lock
);
468 /* register v4l2 device */
469 snprintf(pd
->v4l2_dev
.name
, sizeof(pd
->v4l2_dev
.name
), "%s %s",
470 dev
->driver
->name
, dev_name(dev
));
471 ret
= v4l2_device_register(NULL
, &pd
->v4l2_dev
);
473 /* register devices in directory /dev */
474 ret
= pd_video_init(pd
);
475 poseidon_audio_init(pd
);
476 poseidon_fm_init(pd
);
477 pd_dvb_usb_device_init(pd
);
479 INIT_LIST_HEAD(&pd
->device_list
);
480 list_add_tail(&pd
->device_list
, &pd_device_list
);
483 device_init_wakeup(&udev
->dev
, 1);
485 pd
->udev
->autosuspend_disabled
= 0;
486 pd
->udev
->autosuspend_delay
= HZ
* PM_SUSPEND_DELAY
;
488 if (in_hibernation(pd
)) {
489 INIT_WORK(&pd
->pm_work
, hibernation_resume
);
490 schedule_work(&pd
->pm_work
);
496 static void poseidon_disconnect(struct usb_interface
*interface
)
498 struct poseidon
*pd
= get_pd(interface
);
503 if (in_hibernation(pd
))
506 mutex_lock(&pd
->lock
);
507 pd
->state
|= POSEIDON_STATE_DISCONNECT
;
508 mutex_unlock(&pd
->lock
);
510 /* stop urb transferring */
511 stop_all_video_stream(pd
);
512 dvb_stop_streaming(&pd
->dvb_data
);
514 /*unregister v4l2 device */
515 v4l2_device_unregister(&pd
->v4l2_dev
);
519 pd_dvb_usb_device_exit(pd
);
520 poseidon_fm_exit(pd
);
522 poseidon_audio_free(pd
);
527 usb_set_intfdata(interface
, NULL
);
528 kref_put(&pd
->kref
, poseidon_delete
);
531 struct usb_driver poseidon_driver
= {
533 .probe
= poseidon_probe
,
534 .disconnect
= poseidon_disconnect
,
535 .id_table
= id_table
,
537 .suspend
= poseidon_suspend
,
538 .resume
= poseidon_resume
,
540 .supports_autosuspend
= 1,
543 static int __init
poseidon_init(void)
547 ret
= usb_register(&poseidon_driver
);
550 register_pm_notifier(&pm_notifer
);
554 static void __exit
poseidon_exit(void)
557 unregister_pm_notifier(&pm_notifer
);
558 usb_deregister(&poseidon_driver
);
561 module_init(poseidon_init
);
562 module_exit(poseidon_exit
);
564 MODULE_AUTHOR("Telegent Systems");
565 MODULE_DESCRIPTION("For tlg2300-based USB device ");
566 MODULE_LICENSE("GPL");