smsusb.c 18.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/****************************************************************

Siano Mobile Silicon, Inc.
MDTV receiver kernel modules.
Copyright (C) 2005-2009, Uri Shkolnik, Anatoly Greenblat

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.

 This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

****************************************************************/
21

22 23 24 25
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/usb.h>
#include <linux/firmware.h>
26
#include <linux/slab.h>
27
#include <linux/module.h>
28 29

#include "smscoreapi.h"
30
#include "sms-cards.h"
31
#include "smsendian.h"
32

33 34 35 36
static int sms_dbg;
module_param_named(debug, sms_dbg, int, 0644);
MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");

37
#define USB1_BUFFER_SIZE		0x1000
38
#define USB2_BUFFER_SIZE		0x2000
39 40 41 42

#define MAX_BUFFERS		50
#define MAX_URBS		10

43
struct smsusb_device_t;
44

45 46 47 48 49 50
enum smsusb_state {
	SMSUSB_DISCONNECTED,
	SMSUSB_SUSPENDED,
	SMSUSB_ACTIVE
};

51
struct smsusb_urb_t {
52
	struct list_head entry;
53
	struct smscore_buffer_t *cb;
54
	struct smsusb_device_t *dev;
55

56 57
	struct urb urb;
};
58

59
struct smsusb_device_t {
60
	struct usb_device *udev;
61
	struct smscore_device_t *coredev;
62

63
	struct smsusb_urb_t 	surbs[MAX_URBS];
64

65 66
	int		response_alignment;
	int		buffer_size;
67 68 69 70

	unsigned char in_ep;
	unsigned char out_ep;
	enum smsusb_state state;
71
};
72

73 74
static int smsusb_submit_urb(struct smsusb_device_t *dev,
			     struct smsusb_urb_t *surb);
75

76 77 78 79 80 81 82 83
/**
 * Completing URB's callback handler - top half (interrupt context)
 * adds completing sms urb to the global surbs list and activtes the worker
 * thread the surb
 * IMPORTANT - blocking functions must not be called from here !!!

 * @param urb pointer to a completing urb object
 */
84
static void smsusb_onresponse(struct urb *urb)
85
{
86 87
	struct smsusb_urb_t *surb = (struct smsusb_urb_t *) urb->context;
	struct smsusb_device_t *dev = surb->dev;
88

89 90
	if (urb->status == -ESHUTDOWN) {
		sms_err("error, urb status %d (-ESHUTDOWN), %d bytes",
91
			urb->status, urb->actual_length);
92 93 94
		return;
	}

95
	if ((urb->actual_length > 0) && (urb->status == 0)) {
96
		struct sms_msg_hdr *phdr = (struct sms_msg_hdr *)surb->cb->p;
97

98
		smsendian_handle_message_header(phdr);
99 100
		if (urb->actual_length >= phdr->msg_length) {
			surb->cb->size = phdr->msg_length;
101

102
			if (dev->response_alignment &&
103
			    (phdr->msg_flags & MSG_HDR_FLAG_SPLIT_MSG)) {
104 105 106

				surb->cb->offset =
					dev->response_alignment +
107
					((phdr->msg_flags >> 8) & 3);
108 109

				/* sanity check */
110
				if (((int) phdr->msg_length +
111
				     surb->cb->offset) > urb->actual_length) {
112 113 114
					sms_err("invalid response "
						"msglen %d offset %d "
						"size %d",
115
						phdr->msg_length,
116 117
						surb->cb->offset,
						urb->actual_length);
118 119 120
					goto exit_and_resubmit;
				}

121 122
				/* move buffer pointer and
				 * copy header to its new location */
123
				memcpy((char *) phdr + surb->cb->offset,
124
				       phdr, sizeof(struct sms_msg_hdr));
125
			} else
126 127
				surb->cb->offset = 0;

128
			sms_debug("received %s(%d) size: %d",
129 130
				  smscore_translate_msg(phdr->msg_type),
				  phdr->msg_type, phdr->msg_length);
131

132
			smsendian_handle_rx_message((struct sms_msg_data *) phdr);
133

134 135
			smscore_onresponse(dev->coredev, surb->cb);
			surb->cb = NULL;
136
		} else {
137 138
			sms_err("invalid response "
				"msglen %d actual %d",
139
				phdr->msg_length, urb->actual_length);
140
		}
141 142 143 144
	} else
		sms_err("error, urb status %d, %d bytes",
			urb->status, urb->actual_length);

145 146 147 148 149

exit_and_resubmit:
	smsusb_submit_urb(dev, surb);
}

150 151
static int smsusb_submit_urb(struct smsusb_device_t *dev,
			     struct smsusb_urb_t *surb)
152
{
153
	if (!surb->cb) {
154
		surb->cb = smscore_getbuffer(dev->coredev);
155
		if (!surb->cb) {
156
			sms_err("smscore_getbuffer(...) returned NULL");
157 158 159 160 161 162 163
			return -ENOMEM;
		}
	}

	usb_fill_bulk_urb(
		&surb->urb,
		dev->udev,
164
		usb_rcvbulkpipe(dev->udev, dev->in_ep),
165 166 167 168 169 170 171 172 173 174 175
		surb->cb->p,
		dev->buffer_size,
		smsusb_onresponse,
		surb
	);
	surb->urb.transfer_dma = surb->cb->phys;
	surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	return usb_submit_urb(&surb->urb, GFP_ATOMIC);
}

176
static void smsusb_stop_streaming(struct smsusb_device_t *dev)
177 178 179
{
	int i;

180
	for (i = 0; i < MAX_URBS; i++) {
181 182
		usb_kill_urb(&dev->surbs[i].urb);

183
		if (dev->surbs[i].cb) {
184 185 186 187 188 189
			smscore_putbuffer(dev->coredev, dev->surbs[i].cb);
			dev->surbs[i].cb = NULL;
		}
	}
}

190
static int smsusb_start_streaming(struct smsusb_device_t *dev)
191 192 193
{
	int i, rc;

194
	for (i = 0; i < MAX_URBS; i++) {
195
		rc = smsusb_submit_urb(dev, &dev->surbs[i]);
196
		if (rc < 0) {
197
			sms_err("smsusb_submit_urb(...) failed");
198 199 200 201 202 203 204 205
			smsusb_stop_streaming(dev);
			break;
		}
	}

	return rc;
}

206
static int smsusb_sendrequest(void *context, void *buffer, size_t size)
207
{
208
	struct smsusb_device_t *dev = (struct smsusb_device_t *) context;
209
	struct sms_msg_hdr *phdr = (struct sms_msg_hdr *) buffer;
210 211
	int dummy;

212 213
	if (dev->state != SMSUSB_ACTIVE) {
		sms_debug("Device not active yet");
214
		return -ENOENT;
215
	}
216

217
	sms_debug("sending %s(%d) size: %d",
218 219
		  smscore_translate_msg(phdr->msg_type), phdr->msg_type,
		  phdr->msg_length);
220

221 222
	smsendian_handle_tx_message((struct sms_msg_data *) phdr);
	smsendian_handle_message_header((struct sms_msg_hdr *)buffer);
223 224
	return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),
			    buffer, size, &dummy, 1000);
225 226
}

227
static char *smsusb1_fw_lkup[] = {
228 229 230 231 232 233 234
	"dvbt_stellar_usb.inp",
	"dvbh_stellar_usb.inp",
	"tdmb_stellar_usb.inp",
	"none",
	"dvbt_bda_stellar_usb.inp",
};

235 236 237 238 239 240 241
static inline char *sms_get_fw_name(int mode, int board_id)
{
	char **fw = sms_get_board(board_id)->fw;
	return (fw && fw[mode]) ? fw[mode] : smsusb1_fw_lkup[mode];
}

static int smsusb1_load_firmware(struct usb_device *udev, int id, int board_id)
242 243
{
	const struct firmware *fw;
244
	u8 *fw_buffer;
245
	int rc, dummy;
246
	char *fw_filename;
247

248
	if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) {
249
		sms_err("invalid firmware id specified %d", id);
250 251 252
		return -EINVAL;
	}

253 254 255
	fw_filename = sms_get_fw_name(id, board_id);

	rc = request_firmware(&fw, fw_filename, &udev->dev);
256
	if (rc < 0) {
257 258 259 260 261 262 263 264 265 266 267
		sms_warn("failed to open \"%s\" mode %d, "
			 "trying again with default firmware", fw_filename, id);

		fw_filename = smsusb1_fw_lkup[id];
		rc = request_firmware(&fw, fw_filename, &udev->dev);
		if (rc < 0) {
			sms_warn("failed to open \"%s\" mode %d",
				 fw_filename, id);

			return rc;
		}
268 269 270
	}

	fw_buffer = kmalloc(fw->size, GFP_KERNEL);
271
	if (fw_buffer) {
272 273
		memcpy(fw_buffer, fw->data, fw->size);

274 275
		rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2),
				  fw_buffer, fw->size, &dummy, 1000);
276

277
		sms_info("sent %zd(%d) bytes, rc %d", fw->size, dummy, rc);
278 279

		kfree(fw_buffer);
280
	} else {
281
		sms_err("failed to allocate firmware buffer");
282 283
		rc = -ENOMEM;
	}
284
	sms_info("read FW %s, size=%zd", fw_filename, fw->size);
285 286 287 288 289 290

	release_firmware(fw);

	return rc;
}

291
static void smsusb1_detectmode(void *context, int *mode)
292
{
293 294
	char *product_string =
		((struct smsusb_device_t *) context)->udev->product;
295 296 297

	*mode = DEVICE_MODE_NONE;

298
	if (!product_string) {
299
		product_string = "none";
300
		sms_err("product string not found");
301 302 303 304 305 306 307 308
	} else if (strstr(product_string, "DVBH"))
		*mode = 1;
	else if (strstr(product_string, "BDA"))
		*mode = 4;
	else if (strstr(product_string, "DVBT"))
		*mode = 0;
	else if (strstr(product_string, "TDMB"))
		*mode = 2;
309

310
	sms_info("%d \"%s\"", *mode, product_string);
311 312
}

313
static int smsusb1_setmode(void *context, int mode)
314
{
315
	struct sms_msg_hdr msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,
316
			     sizeof(struct sms_msg_hdr), 0 };
317

318
	if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
319
		sms_err("invalid firmware id specified %d", mode);
320 321 322
		return -EINVAL;
	}

323
	return smsusb_sendrequest(context, &msg, sizeof(msg));
324 325
}

326
static void smsusb_term_device(struct usb_interface *intf)
327
{
328
	struct smsusb_device_t *dev = usb_get_intfdata(intf);
329

330
	if (dev) {
331 332
		dev->state = SMSUSB_DISCONNECTED;

333 334
		smsusb_stop_streaming(dev);

335
		/* unregister from smscore */
336 337 338
		if (dev->coredev)
			smscore_unregister_device(dev->coredev);

339
		sms_info("device 0x%p destroyed", dev);
340
		kfree(dev);
341 342 343 344 345
	}

	usb_set_intfdata(intf, NULL);
}

346
static int smsusb_init_device(struct usb_interface *intf, int board_id)
347
{
348 349
	struct smsdevice_params_t params;
	struct smsusb_device_t *dev;
350 351
	int i, rc;

352
	/* create device object */
353
	dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL);
354
	if (!dev) {
355
		sms_err("kzalloc(sizeof(struct smsusb_device_t) failed");
356 357 358 359 360 361
		return -ENOMEM;
	}

	memset(&params, 0, sizeof(params));
	usb_set_intfdata(intf, dev);
	dev->udev = interface_to_usbdev(intf);
362
	dev->state = SMSUSB_DISCONNECTED;
363

364
	params.device_type = sms_get_board(board_id)->type;
365

366
	switch (params.device_type) {
367
	case SMS_STELLAR:
368 369 370 371 372
		dev->buffer_size = USB1_BUFFER_SIZE;

		params.setmode_handler = smsusb1_setmode;
		params.detectmode_handler = smsusb1_detectmode;
		break;
373
	case SMS_UNKNOWN_TYPE:
374 375
		sms_err("Unspecified sms device type!");
		/* fall-thru */
376
	default:
377
		dev->buffer_size = USB2_BUFFER_SIZE;
378
		dev->response_alignment =
379
		    le16_to_cpu(dev->udev->ep_in[1]->desc.wMaxPacketSize) -
380
		    sizeof(struct sms_msg_hdr);
381

382 383
		params.flags |= SMS_DEVICE_FAMILY2;
		break;
384 385
	}

386 387 388 389 390 391 392 393 394 395
	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
		if (intf->cur_altsetting->endpoint[i].desc. bEndpointAddress & USB_DIR_IN)
			dev->in_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
		else
			dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
	}

	sms_info("in_ep = %02x, out_ep = %02x",
		dev->in_ep, dev->out_ep);

396 397 398 399 400
	params.device = &dev->udev->dev;
	params.buffer_size = dev->buffer_size;
	params.num_buffers = MAX_BUFFERS;
	params.sendrequest_handler = smsusb_sendrequest;
	params.context = dev;
401
	usb_make_path(dev->udev, params.devpath, sizeof(params.devpath));
402

403
	/* register in smscore */
404
	rc = smscore_register_device(&params, &dev->coredev);
405
	if (rc < 0) {
406
		sms_err("smscore_register_device(...) failed, rc %d", rc);
407 408 409 410
		smsusb_term_device(intf);
		return rc;
	}

411 412
	smscore_set_board_id(dev->coredev, board_id);

413 414
	dev->coredev->is_usb_device = true;

415
	/* initialize urbs */
416
	for (i = 0; i < MAX_URBS; i++) {
417 418 419 420
		dev->surbs[i].dev = dev;
		usb_init_urb(&dev->surbs[i].urb);
	}

421
	sms_info("smsusb_start_streaming(...).");
422
	rc = smsusb_start_streaming(dev);
423
	if (rc < 0) {
424
		sms_err("smsusb_start_streaming(...) failed");
425 426 427 428
		smsusb_term_device(intf);
		return rc;
	}

429 430
	dev->state = SMSUSB_ACTIVE;

431
	rc = smscore_start_device(dev->coredev);
432
	if (rc < 0) {
433
		sms_err("smscore_start_device(...) failed");
434 435 436 437
		smsusb_term_device(intf);
		return rc;
	}

438
	sms_info("device 0x%p created", dev);
439 440 441 442

	return rc;
}

443
static int smsusb_probe(struct usb_interface *intf,
444
			const struct usb_device_id *id)
445 446
{
	struct usb_device *udev = interface_to_usbdev(intf);
447
	char devpath[32];
448 449
	int i, rc;

450 451
	sms_info("board id=%lu, interface number %d",
		 id->driver_info,
452
		 intf->cur_altsetting->desc.bInterfaceNumber);
453

454 455
	if (sms_get_board(id->driver_info)->intf_num !=
	    intf->cur_altsetting->desc.bInterfaceNumber) {
456 457 458
		sms_debug("interface %d won't be used. Expecting interface %d to popup",
			intf->cur_altsetting->desc.bInterfaceNumber,
			sms_get_board(id->driver_info)->intf_num);
459 460 461 462 463 464 465
		return -ENODEV;
	}

	if (intf->num_altsetting > 1) {
		rc = usb_set_interface(udev,
				       intf->cur_altsetting->desc.bInterfaceNumber,
				       0);
466
		if (rc < 0) {
467
			sms_err("usb_set_interface failed, rc %d", rc);
468 469 470 471
			return rc;
		}
	}

472
	sms_info("smsusb_probe %d",
473
	       intf->cur_altsetting->desc.bInterfaceNumber);
474
	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
475
		sms_info("endpoint %d %02x %02x %d", i,
476 477 478
		       intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
		       intf->cur_altsetting->endpoint[i].desc.bmAttributes,
		       intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
479 480 481 482 483 484 485 486
		if (intf->cur_altsetting->endpoint[i].desc.bEndpointAddress &
		    USB_DIR_IN)
			rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev,
				intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
		else
			rc = usb_clear_halt(udev, usb_sndbulkpipe(udev,
				intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
	}
487 488
	if ((udev->actconfig->desc.bNumInterfaces == 2) &&
	    (intf->cur_altsetting->desc.bInterfaceNumber == 0)) {
489
		sms_debug("rom interface 0 is not used");
490 491 492
		return -ENODEV;
	}

493 494 495 496 497 498 499 500 501
	if (id->driver_info == SMS1XXX_BOARD_SIANO_STELLAR_ROM) {
		snprintf(devpath, sizeof(devpath), "usb\\%d-%s",
			 udev->bus->busnum, udev->devpath);
		sms_info("stellar device was found.");
		return smsusb1_load_firmware(
				udev, smscore_registry_getmode(devpath),
				id->driver_info);
	}

502
	rc = smsusb_init_device(intf, id->driver_info);
503
	sms_info("Device initialized with return code %d", rc);
504
	sms_board_load_modules(id->driver_info);
505
	return rc;
506 507
}

508
static void smsusb_disconnect(struct usb_interface *intf)
509 510 511 512
{
	smsusb_term_device(intf);
}

513 514
static int smsusb_suspend(struct usb_interface *intf, pm_message_t msg)
{
515
	struct smsusb_device_t *dev = usb_get_intfdata(intf);
516 517 518
	printk(KERN_INFO "%s  Entering status %d.\n", __func__, msg.event);
	dev->state = SMSUSB_SUSPENDED;
	/*smscore_set_power_mode(dev, SMS_POWER_MODE_SUSPENDED);*/
519 520 521 522 523 524 525
	smsusb_stop_streaming(dev);
	return 0;
}

static int smsusb_resume(struct usb_interface *intf)
{
	int rc, i;
526
	struct smsusb_device_t *dev = usb_get_intfdata(intf);
527 528
	struct usb_device *udev = interface_to_usbdev(intf);

529 530 531
	printk(KERN_INFO "%s  Entering.\n", __func__);
	usb_clear_halt(udev, usb_rcvbulkpipe(udev, dev->in_ep));
	usb_clear_halt(udev, usb_sndbulkpipe(udev, dev->out_ep));
532 533 534 535 536 537 538 539 540 541 542 543

	for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
		printk(KERN_INFO "endpoint %d %02x %02x %d\n", i,
		       intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
		       intf->cur_altsetting->endpoint[i].desc.bmAttributes,
		       intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);

	if (intf->num_altsetting > 0) {
		rc = usb_set_interface(udev,
				       intf->cur_altsetting->desc.
				       bInterfaceNumber, 0);
		if (rc < 0) {
544 545
			printk(KERN_INFO "%s usb_set_interface failed, "
			       "rc %d\n", __func__, rc);
546 547 548 549 550 551 552 553
			return rc;
		}
	}

	smsusb_start_streaming(dev);
	return 0;
}

554
static const struct usb_device_id smsusb_id_table[] = {
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594
	{ USB_DEVICE(0x187f, 0x0010),
		.driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
	{ USB_DEVICE(0x187f, 0x0100),
		.driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
	{ USB_DEVICE(0x187f, 0x0200),
		.driver_info = SMS1XXX_BOARD_SIANO_NOVA_A },
	{ USB_DEVICE(0x187f, 0x0201),
		.driver_info = SMS1XXX_BOARD_SIANO_NOVA_B },
	{ USB_DEVICE(0x187f, 0x0300),
		.driver_info = SMS1XXX_BOARD_SIANO_VEGA },
	{ USB_DEVICE(0x2040, 0x1700),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT },
	{ USB_DEVICE(0x2040, 0x1800),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A },
	{ USB_DEVICE(0x2040, 0x1801),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B },
	{ USB_DEVICE(0x2040, 0x2000),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
	{ USB_DEVICE(0x2040, 0x2009),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD_R2 },
	{ USB_DEVICE(0x2040, 0x200a),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
	{ USB_DEVICE(0x2040, 0x2010),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
	{ USB_DEVICE(0x2040, 0x2011),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
	{ USB_DEVICE(0x2040, 0x2019),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
	{ USB_DEVICE(0x2040, 0x5500),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0x5510),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0x5520),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0x5530),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0x5580),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0x5590),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
595 596 597 598
	{ USB_DEVICE(0x187f, 0x0202),
		.driver_info = SMS1XXX_BOARD_SIANO_NICE },
	{ USB_DEVICE(0x187f, 0x0301),
		.driver_info = SMS1XXX_BOARD_SIANO_VENICE },
599 600 601 602
	{ USB_DEVICE(0x2040, 0xb900),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0xb910),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
603 604 605 606
	{ USB_DEVICE(0x2040, 0xb980),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0xb990),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
607 608
	{ USB_DEVICE(0x2040, 0xc000),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
609 610 611 612 613 614
	{ USB_DEVICE(0x2040, 0xc010),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0xc080),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
	{ USB_DEVICE(0x2040, 0xc090),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
615 616
	{ USB_DEVICE(0x2040, 0xc0a0),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
617 618
	{ USB_DEVICE(0x2040, 0xf5a0),
		.driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
	{ USB_DEVICE(0x187f, 0x0202),
		.driver_info = SMS1XXX_BOARD_SIANO_NICE },
	{ USB_DEVICE(0x187f, 0x0301),
		.driver_info = SMS1XXX_BOARD_SIANO_VENICE },
	{ USB_DEVICE(0x187f, 0x0302),
		.driver_info = SMS1XXX_BOARD_SIANO_VENICE },
	{ USB_DEVICE(0x187f, 0x0310),
		.driver_info = SMS1XXX_BOARD_SIANO_MING },
	{ USB_DEVICE(0x187f, 0x0500),
		.driver_info = SMS1XXX_BOARD_SIANO_PELE },
	{ USB_DEVICE(0x187f, 0x0600),
		.driver_info = SMS1XXX_BOARD_SIANO_RIO },
	{ USB_DEVICE(0x187f, 0x0700),
		.driver_info = SMS1XXX_BOARD_SIANO_DENVER_2160 },
	{ USB_DEVICE(0x187f, 0x0800),
		.driver_info = SMS1XXX_BOARD_SIANO_DENVER_1530 },
	{ USB_DEVICE(0x19D2, 0x0086),
		.driver_info = SMS1XXX_BOARD_ZTE_DVB_DATA_CARD },
	{ USB_DEVICE(0x19D2, 0x0078),
		.driver_info = SMS1XXX_BOARD_ONDA_MDTV_DATA_CARD },
639 640 641
	{ } /* Terminating entry */
	};

642 643
MODULE_DEVICE_TABLE(usb, smsusb_id_table);

644
static struct usb_driver smsusb_driver = {
645
	.name			= "smsusb",
646
	.probe			= smsusb_probe,
647
	.disconnect		= smsusb_disconnect,
648
	.id_table		= smsusb_id_table,
649 650 651

	.suspend		= smsusb_suspend,
	.resume			= smsusb_resume,
652 653
};

654
module_usb_driver(smsusb_driver);
655

656
MODULE_DESCRIPTION("Driver for the Siano SMS1xxx USB dongle");
657 658
MODULE_AUTHOR("Siano Mobile Silicon, INC. (uris@siano-ms.com)");
MODULE_LICENSE("GPL");