1 /****************************************************************
3 Siano Mobile Silicon, Inc.
4 MDTV receiver kernel modules.
5 Copyright (C) 2005-2009, Uri Shkolnik, Anatoly Greenblat
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 ****************************************************************/
22 #include "smscoreapi.h"
24 #include <linux/kernel.h>
25 #include <linux/init.h>
26 #include <linux/usb.h>
27 #include <linux/firmware.h>
28 #include <linux/slab.h>
29 #include <linux/module.h>
31 #include "sms-cards.h"
32 #include "smsendian.h"
35 module_param_named(debug
, sms_dbg
, int, 0644);
36 MODULE_PARM_DESC(debug
, "set debug level (info=1, adv=2 (or-able))");
38 #define USB1_BUFFER_SIZE 0x1000
39 #define USB2_BUFFER_SIZE 0x2000
41 #define MAX_BUFFERS 50
44 struct smsusb_device_t
;
53 struct list_head entry
;
54 struct smscore_buffer_t
*cb
;
55 struct smsusb_device_t
*dev
;
60 struct smsusb_device_t
{
61 struct usb_device
*udev
;
62 struct smscore_device_t
*coredev
;
64 struct smsusb_urb_t surbs
[MAX_URBS
];
66 int response_alignment
;
71 enum smsusb_state state
;
74 static int smsusb_submit_urb(struct smsusb_device_t
*dev
,
75 struct smsusb_urb_t
*surb
);
78 * Completing URB's callback handler - top half (interrupt context)
79 * adds completing sms urb to the global surbs list and activtes the worker
81 * IMPORTANT - blocking functions must not be called from here !!!
83 * @param urb pointer to a completing urb object
85 static void smsusb_onresponse(struct urb
*urb
)
87 struct smsusb_urb_t
*surb
= (struct smsusb_urb_t
*) urb
->context
;
88 struct smsusb_device_t
*dev
= surb
->dev
;
90 if (urb
->status
== -ESHUTDOWN
) {
91 pr_err("error, urb status %d (-ESHUTDOWN), %d bytes\n",
92 urb
->status
, urb
->actual_length
);
96 if ((urb
->actual_length
> 0) && (urb
->status
== 0)) {
97 struct sms_msg_hdr
*phdr
= (struct sms_msg_hdr
*)surb
->cb
->p
;
99 smsendian_handle_message_header(phdr
);
100 if (urb
->actual_length
>= phdr
->msg_length
) {
101 surb
->cb
->size
= phdr
->msg_length
;
103 if (dev
->response_alignment
&&
104 (phdr
->msg_flags
& MSG_HDR_FLAG_SPLIT_MSG
)) {
107 dev
->response_alignment
+
108 ((phdr
->msg_flags
>> 8) & 3);
111 if (((int) phdr
->msg_length
+
112 surb
->cb
->offset
) > urb
->actual_length
) {
113 pr_err("invalid response msglen %d offset %d size %d\n",
117 goto exit_and_resubmit
;
120 /* move buffer pointer and
121 * copy header to its new location */
122 memcpy((char *) phdr
+ surb
->cb
->offset
,
123 phdr
, sizeof(struct sms_msg_hdr
));
125 surb
->cb
->offset
= 0;
127 pr_debug("received %s(%d) size: %d\n",
128 smscore_translate_msg(phdr
->msg_type
),
129 phdr
->msg_type
, phdr
->msg_length
);
131 smsendian_handle_rx_message((struct sms_msg_data
*) phdr
);
133 smscore_onresponse(dev
->coredev
, surb
->cb
);
136 pr_err("invalid response msglen %d actual %d\n",
137 phdr
->msg_length
, urb
->actual_length
);
140 pr_err("error, urb status %d, %d bytes\n",
141 urb
->status
, urb
->actual_length
);
145 smsusb_submit_urb(dev
, surb
);
148 static int smsusb_submit_urb(struct smsusb_device_t
*dev
,
149 struct smsusb_urb_t
*surb
)
152 surb
->cb
= smscore_getbuffer(dev
->coredev
);
154 pr_err("smscore_getbuffer(...) returned NULL\n");
162 usb_rcvbulkpipe(dev
->udev
, dev
->in_ep
),
168 surb
->urb
.transfer_dma
= surb
->cb
->phys
;
169 surb
->urb
.transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
171 return usb_submit_urb(&surb
->urb
, GFP_ATOMIC
);
174 static void smsusb_stop_streaming(struct smsusb_device_t
*dev
)
178 for (i
= 0; i
< MAX_URBS
; i
++) {
179 usb_kill_urb(&dev
->surbs
[i
].urb
);
181 if (dev
->surbs
[i
].cb
) {
182 smscore_putbuffer(dev
->coredev
, dev
->surbs
[i
].cb
);
183 dev
->surbs
[i
].cb
= NULL
;
188 static int smsusb_start_streaming(struct smsusb_device_t
*dev
)
192 for (i
= 0; i
< MAX_URBS
; i
++) {
193 rc
= smsusb_submit_urb(dev
, &dev
->surbs
[i
]);
195 pr_err("smsusb_submit_urb(...) failed\n");
196 smsusb_stop_streaming(dev
);
204 static int smsusb_sendrequest(void *context
, void *buffer
, size_t size
)
206 struct smsusb_device_t
*dev
= (struct smsusb_device_t
*) context
;
207 struct sms_msg_hdr
*phdr
= (struct sms_msg_hdr
*) buffer
;
210 if (dev
->state
!= SMSUSB_ACTIVE
) {
211 pr_debug("Device not active yet\n");
215 pr_debug("sending %s(%d) size: %d\n",
216 smscore_translate_msg(phdr
->msg_type
), phdr
->msg_type
,
219 smsendian_handle_tx_message((struct sms_msg_data
*) phdr
);
220 smsendian_handle_message_header((struct sms_msg_hdr
*)buffer
);
221 return usb_bulk_msg(dev
->udev
, usb_sndbulkpipe(dev
->udev
, 2),
222 buffer
, size
, &dummy
, 1000);
225 static char *smsusb1_fw_lkup
[] = {
226 "dvbt_stellar_usb.inp",
227 "dvbh_stellar_usb.inp",
228 "tdmb_stellar_usb.inp",
230 "dvbt_bda_stellar_usb.inp",
233 static inline char *sms_get_fw_name(int mode
, int board_id
)
235 char **fw
= sms_get_board(board_id
)->fw
;
236 return (fw
&& fw
[mode
]) ? fw
[mode
] : smsusb1_fw_lkup
[mode
];
239 static int smsusb1_load_firmware(struct usb_device
*udev
, int id
, int board_id
)
241 const struct firmware
*fw
;
247 id
= sms_get_board(board_id
)->default_mode
;
249 if (id
< DEVICE_MODE_DVBT
|| id
> DEVICE_MODE_DVBT_BDA
) {
250 pr_err("invalid firmware id specified %d\n", id
);
254 fw_filename
= sms_get_fw_name(id
, board_id
);
256 rc
= request_firmware(&fw
, fw_filename
, &udev
->dev
);
258 pr_warn("failed to open '%s' mode %d, trying again with default firmware\n",
261 fw_filename
= smsusb1_fw_lkup
[id
];
262 rc
= request_firmware(&fw
, fw_filename
, &udev
->dev
);
264 pr_warn("failed to open '%s' mode %d\n",
271 fw_buffer
= kmalloc(fw
->size
, GFP_KERNEL
);
273 memcpy(fw_buffer
, fw
->data
, fw
->size
);
275 rc
= usb_bulk_msg(udev
, usb_sndbulkpipe(udev
, 2),
276 fw_buffer
, fw
->size
, &dummy
, 1000);
278 sms_info("sent %zu(%d) bytes, rc %d", fw
->size
, dummy
, rc
);
282 pr_err("failed to allocate firmware buffer\n");
285 sms_info("read FW %s, size=%zu", fw_filename
, fw
->size
);
287 release_firmware(fw
);
292 static void smsusb1_detectmode(void *context
, int *mode
)
294 char *product_string
=
295 ((struct smsusb_device_t
*) context
)->udev
->product
;
297 *mode
= DEVICE_MODE_NONE
;
299 if (!product_string
) {
300 product_string
= "none";
301 pr_err("product string not found\n");
302 } else if (strstr(product_string
, "DVBH"))
304 else if (strstr(product_string
, "BDA"))
306 else if (strstr(product_string
, "DVBT"))
308 else if (strstr(product_string
, "TDMB"))
311 sms_info("%d \"%s\"", *mode
, product_string
);
314 static int smsusb1_setmode(void *context
, int mode
)
316 struct sms_msg_hdr msg
= { MSG_SW_RELOAD_REQ
, 0, HIF_TASK
,
317 sizeof(struct sms_msg_hdr
), 0 };
319 if (mode
< DEVICE_MODE_DVBT
|| mode
> DEVICE_MODE_DVBT_BDA
) {
320 pr_err("invalid firmware id specified %d\n", mode
);
324 return smsusb_sendrequest(context
, &msg
, sizeof(msg
));
327 static void smsusb_term_device(struct usb_interface
*intf
)
329 struct smsusb_device_t
*dev
= usb_get_intfdata(intf
);
332 dev
->state
= SMSUSB_DISCONNECTED
;
334 smsusb_stop_streaming(dev
);
336 /* unregister from smscore */
338 smscore_unregister_device(dev
->coredev
);
340 sms_info("device 0x%p destroyed", dev
);
344 usb_set_intfdata(intf
, NULL
);
347 static void siano_media_device_register(struct smsusb_device_t
*dev
)
349 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
350 struct media_device
*mdev
;
351 struct usb_device
*udev
= dev
->udev
;
352 int board_id
= smscore_get_board_id(dev
->coredev
);
353 struct sms_board
*board
= sms_get_board(board_id
);
356 mdev
= kzalloc(sizeof(*mdev
), GFP_KERNEL
);
360 mdev
->dev
= &udev
->dev
;
361 strlcpy(mdev
->model
, board
->name
, sizeof(mdev
->model
));
363 strlcpy(mdev
->serial
, udev
->serial
, sizeof(mdev
->serial
));
364 strcpy(mdev
->bus_info
, udev
->devpath
);
365 mdev
->hw_revision
= le16_to_cpu(udev
->descriptor
.bcdDevice
);
366 mdev
->driver_version
= LINUX_VERSION_CODE
;
368 ret
= media_device_register(mdev
);
370 pr_err("Couldn't create a media device. Error: %d\n",
376 dev
->coredev
->media_dev
= mdev
;
378 sms_info("media controller created");
383 static int smsusb_init_device(struct usb_interface
*intf
, int board_id
)
385 struct smsdevice_params_t params
;
386 struct smsusb_device_t
*dev
;
389 /* create device object */
390 dev
= kzalloc(sizeof(struct smsusb_device_t
), GFP_KERNEL
);
394 memset(¶ms
, 0, sizeof(params
));
395 usb_set_intfdata(intf
, dev
);
396 dev
->udev
= interface_to_usbdev(intf
);
397 dev
->state
= SMSUSB_DISCONNECTED
;
399 params
.device_type
= sms_get_board(board_id
)->type
;
401 switch (params
.device_type
) {
403 dev
->buffer_size
= USB1_BUFFER_SIZE
;
405 params
.setmode_handler
= smsusb1_setmode
;
406 params
.detectmode_handler
= smsusb1_detectmode
;
408 case SMS_UNKNOWN_TYPE
:
409 pr_err("Unspecified sms device type!\n");
412 dev
->buffer_size
= USB2_BUFFER_SIZE
;
413 dev
->response_alignment
=
414 le16_to_cpu(dev
->udev
->ep_in
[1]->desc
.wMaxPacketSize
) -
415 sizeof(struct sms_msg_hdr
);
417 params
.flags
|= SMS_DEVICE_FAMILY2
;
421 for (i
= 0; i
< intf
->cur_altsetting
->desc
.bNumEndpoints
; i
++) {
422 if (intf
->cur_altsetting
->endpoint
[i
].desc
. bEndpointAddress
& USB_DIR_IN
)
423 dev
->in_ep
= intf
->cur_altsetting
->endpoint
[i
].desc
.bEndpointAddress
;
425 dev
->out_ep
= intf
->cur_altsetting
->endpoint
[i
].desc
.bEndpointAddress
;
428 sms_info("in_ep = %02x, out_ep = %02x",
429 dev
->in_ep
, dev
->out_ep
);
431 params
.device
= &dev
->udev
->dev
;
432 params
.buffer_size
= dev
->buffer_size
;
433 params
.num_buffers
= MAX_BUFFERS
;
434 params
.sendrequest_handler
= smsusb_sendrequest
;
435 params
.context
= dev
;
436 usb_make_path(dev
->udev
, params
.devpath
, sizeof(params
.devpath
));
438 /* register in smscore */
439 rc
= smscore_register_device(¶ms
, &dev
->coredev
);
441 pr_err("smscore_register_device(...) failed, rc %d\n", rc
);
442 smsusb_term_device(intf
);
446 smscore_set_board_id(dev
->coredev
, board_id
);
448 dev
->coredev
->is_usb_device
= true;
450 /* initialize urbs */
451 for (i
= 0; i
< MAX_URBS
; i
++) {
452 dev
->surbs
[i
].dev
= dev
;
453 usb_init_urb(&dev
->surbs
[i
].urb
);
456 sms_info("smsusb_start_streaming(...).");
457 rc
= smsusb_start_streaming(dev
);
459 pr_err("smsusb_start_streaming(...) failed\n");
460 smsusb_term_device(intf
);
464 dev
->state
= SMSUSB_ACTIVE
;
466 rc
= smscore_start_device(dev
->coredev
);
468 pr_err("smscore_start_device(...) failed\n");
469 smsusb_term_device(intf
);
473 sms_info("device 0x%p created", dev
);
474 siano_media_device_register(dev
);
479 static int smsusb_probe(struct usb_interface
*intf
,
480 const struct usb_device_id
*id
)
482 struct usb_device
*udev
= interface_to_usbdev(intf
);
486 sms_info("board id=%lu, interface number %d",
488 intf
->cur_altsetting
->desc
.bInterfaceNumber
);
490 if (sms_get_board(id
->driver_info
)->intf_num
!=
491 intf
->cur_altsetting
->desc
.bInterfaceNumber
) {
492 pr_debug("interface %d won't be used. Expecting interface %d to popup\n",
493 intf
->cur_altsetting
->desc
.bInterfaceNumber
,
494 sms_get_board(id
->driver_info
)->intf_num
);
498 if (intf
->num_altsetting
> 1) {
499 rc
= usb_set_interface(udev
,
500 intf
->cur_altsetting
->desc
.bInterfaceNumber
,
503 pr_err("usb_set_interface failed, rc %d\n", rc
);
508 sms_info("smsusb_probe %d",
509 intf
->cur_altsetting
->desc
.bInterfaceNumber
);
510 for (i
= 0; i
< intf
->cur_altsetting
->desc
.bNumEndpoints
; i
++) {
511 sms_info("endpoint %d %02x %02x %d", i
,
512 intf
->cur_altsetting
->endpoint
[i
].desc
.bEndpointAddress
,
513 intf
->cur_altsetting
->endpoint
[i
].desc
.bmAttributes
,
514 intf
->cur_altsetting
->endpoint
[i
].desc
.wMaxPacketSize
);
515 if (intf
->cur_altsetting
->endpoint
[i
].desc
.bEndpointAddress
&
517 rc
= usb_clear_halt(udev
, usb_rcvbulkpipe(udev
,
518 intf
->cur_altsetting
->endpoint
[i
].desc
.bEndpointAddress
));
520 rc
= usb_clear_halt(udev
, usb_sndbulkpipe(udev
,
521 intf
->cur_altsetting
->endpoint
[i
].desc
.bEndpointAddress
));
523 if ((udev
->actconfig
->desc
.bNumInterfaces
== 2) &&
524 (intf
->cur_altsetting
->desc
.bInterfaceNumber
== 0)) {
525 pr_debug("rom interface 0 is not used\n");
529 if (id
->driver_info
== SMS1XXX_BOARD_SIANO_STELLAR_ROM
) {
530 /* Detected a Siano Stellar uninitialized */
532 snprintf(devpath
, sizeof(devpath
), "usb\\%d-%s",
533 udev
->bus
->busnum
, udev
->devpath
);
534 sms_info("stellar device in cold state was found at %s.", devpath
);
535 rc
= smsusb1_load_firmware(
536 udev
, smscore_registry_getmode(devpath
),
539 /* This device will reset and gain another USB ID */
541 sms_info("stellar device now in warm state");
543 pr_err("Failed to put stellar in warm state. Error: %d\n",
548 rc
= smsusb_init_device(intf
, id
->driver_info
);
551 sms_info("Device initialized with return code %d", rc
);
552 sms_board_load_modules(id
->driver_info
);
556 static void smsusb_disconnect(struct usb_interface
*intf
)
558 smsusb_term_device(intf
);
561 static int smsusb_suspend(struct usb_interface
*intf
, pm_message_t msg
)
563 struct smsusb_device_t
*dev
= usb_get_intfdata(intf
);
564 printk(KERN_INFO
"%s Entering status %d.\n", __func__
, msg
.event
);
565 dev
->state
= SMSUSB_SUSPENDED
;
566 /*smscore_set_power_mode(dev, SMS_POWER_MODE_SUSPENDED);*/
567 smsusb_stop_streaming(dev
);
571 static int smsusb_resume(struct usb_interface
*intf
)
574 struct smsusb_device_t
*dev
= usb_get_intfdata(intf
);
575 struct usb_device
*udev
= interface_to_usbdev(intf
);
577 printk(KERN_INFO
"%s Entering.\n", __func__
);
578 usb_clear_halt(udev
, usb_rcvbulkpipe(udev
, dev
->in_ep
));
579 usb_clear_halt(udev
, usb_sndbulkpipe(udev
, dev
->out_ep
));
581 for (i
= 0; i
< intf
->cur_altsetting
->desc
.bNumEndpoints
; i
++)
582 printk(KERN_INFO
"endpoint %d %02x %02x %d\n", i
,
583 intf
->cur_altsetting
->endpoint
[i
].desc
.bEndpointAddress
,
584 intf
->cur_altsetting
->endpoint
[i
].desc
.bmAttributes
,
585 intf
->cur_altsetting
->endpoint
[i
].desc
.wMaxPacketSize
);
587 if (intf
->num_altsetting
> 0) {
588 rc
= usb_set_interface(udev
,
589 intf
->cur_altsetting
->desc
.
590 bInterfaceNumber
, 0);
592 printk(KERN_INFO
"%s usb_set_interface failed, "
593 "rc %d\n", __func__
, rc
);
598 smsusb_start_streaming(dev
);
602 static const struct usb_device_id smsusb_id_table
[] = {
603 /* This device is only present before firmware load */
604 { USB_DEVICE(0x187f, 0x0010),
605 .driver_info
= SMS1XXX_BOARD_SIANO_STELLAR_ROM
},
606 /* This device pops up after firmware load */
607 { USB_DEVICE(0x187f, 0x0100),
608 .driver_info
= SMS1XXX_BOARD_SIANO_STELLAR
},
610 { USB_DEVICE(0x187f, 0x0200),
611 .driver_info
= SMS1XXX_BOARD_SIANO_NOVA_A
},
612 { USB_DEVICE(0x187f, 0x0201),
613 .driver_info
= SMS1XXX_BOARD_SIANO_NOVA_B
},
614 { USB_DEVICE(0x187f, 0x0300),
615 .driver_info
= SMS1XXX_BOARD_SIANO_VEGA
},
616 { USB_DEVICE(0x2040, 0x1700),
617 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT
},
618 { USB_DEVICE(0x2040, 0x1800),
619 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A
},
620 { USB_DEVICE(0x2040, 0x1801),
621 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B
},
622 { USB_DEVICE(0x2040, 0x2000),
623 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD
},
624 { USB_DEVICE(0x2040, 0x2009),
625 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD_R2
},
626 { USB_DEVICE(0x2040, 0x200a),
627 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD
},
628 { USB_DEVICE(0x2040, 0x2010),
629 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD
},
630 { USB_DEVICE(0x2040, 0x2011),
631 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD
},
632 { USB_DEVICE(0x2040, 0x2019),
633 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD
},
634 { USB_DEVICE(0x2040, 0x5500),
635 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
636 { USB_DEVICE(0x2040, 0x5510),
637 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
638 { USB_DEVICE(0x2040, 0x5520),
639 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
640 { USB_DEVICE(0x2040, 0x5530),
641 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
642 { USB_DEVICE(0x2040, 0x5580),
643 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
644 { USB_DEVICE(0x2040, 0x5590),
645 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
646 { USB_DEVICE(0x187f, 0x0202),
647 .driver_info
= SMS1XXX_BOARD_SIANO_NICE
},
648 { USB_DEVICE(0x187f, 0x0301),
649 .driver_info
= SMS1XXX_BOARD_SIANO_VENICE
},
650 { USB_DEVICE(0x2040, 0xb900),
651 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
652 { USB_DEVICE(0x2040, 0xb910),
653 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
654 { USB_DEVICE(0x2040, 0xb980),
655 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
656 { USB_DEVICE(0x2040, 0xb990),
657 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
658 { USB_DEVICE(0x2040, 0xc000),
659 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
660 { USB_DEVICE(0x2040, 0xc010),
661 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
662 { USB_DEVICE(0x2040, 0xc080),
663 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
664 { USB_DEVICE(0x2040, 0xc090),
665 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
666 { USB_DEVICE(0x2040, 0xc0a0),
667 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
668 { USB_DEVICE(0x2040, 0xf5a0),
669 .driver_info
= SMS1XXX_BOARD_HAUPPAUGE_WINDHAM
},
670 { USB_DEVICE(0x187f, 0x0202),
671 .driver_info
= SMS1XXX_BOARD_SIANO_NICE
},
672 { USB_DEVICE(0x187f, 0x0301),
673 .driver_info
= SMS1XXX_BOARD_SIANO_VENICE
},
674 { USB_DEVICE(0x187f, 0x0302),
675 .driver_info
= SMS1XXX_BOARD_SIANO_VENICE
},
676 { USB_DEVICE(0x187f, 0x0310),
677 .driver_info
= SMS1XXX_BOARD_SIANO_MING
},
678 { USB_DEVICE(0x187f, 0x0500),
679 .driver_info
= SMS1XXX_BOARD_SIANO_PELE
},
680 { USB_DEVICE(0x187f, 0x0600),
681 .driver_info
= SMS1XXX_BOARD_SIANO_RIO
},
682 { USB_DEVICE(0x187f, 0x0700),
683 .driver_info
= SMS1XXX_BOARD_SIANO_DENVER_2160
},
684 { USB_DEVICE(0x187f, 0x0800),
685 .driver_info
= SMS1XXX_BOARD_SIANO_DENVER_1530
},
686 { USB_DEVICE(0x19D2, 0x0086),
687 .driver_info
= SMS1XXX_BOARD_ZTE_DVB_DATA_CARD
},
688 { USB_DEVICE(0x19D2, 0x0078),
689 .driver_info
= SMS1XXX_BOARD_ONDA_MDTV_DATA_CARD
},
690 { USB_DEVICE(0x3275, 0x0080),
691 .driver_info
= SMS1XXX_BOARD_SIANO_RIO
},
692 { USB_DEVICE(0x2013, 0x0257),
693 .driver_info
= SMS1XXX_BOARD_PCTV_77E
},
694 { } /* Terminating entry */
697 MODULE_DEVICE_TABLE(usb
, smsusb_id_table
);
699 static struct usb_driver smsusb_driver
= {
701 .probe
= smsusb_probe
,
702 .disconnect
= smsusb_disconnect
,
703 .id_table
= smsusb_id_table
,
705 .suspend
= smsusb_suspend
,
706 .resume
= smsusb_resume
,
709 module_usb_driver(smsusb_driver
);
711 MODULE_DESCRIPTION("Driver for the Siano SMS1xxx USB dongle");
712 MODULE_AUTHOR("Siano Mobile Silicon, INC. (uris@siano-ms.com)");
713 MODULE_LICENSE("GPL");