projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'v3.10.107' into update
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / usb / siano / smsusb.c
CommitLineData
6d4e6972
US		 1/****************************************************************
2
3Siano Mobile Silicon, Inc.
4MDTV receiver kernel modules.
5Copyright (C) 2005-2009, Uri Shkolnik, Anatoly Greenblat
6
7This program is free software: you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation, either version 2 of the License, or
10(at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20****************************************************************/
8d4f9d0e 21
2e5c1ec8
MK		 22#include <linux/kernel.h>
23#include <linux/init.h>
2e5c1ec8
MK		 24#include <linux/usb.h>
25#include <linux/firmware.h>
5a0e3ad6 26#include <linux/slab.h>
7a707b89 27#include <linux/module.h>
2e5c1ec8 28
2e5c1ec8 29#include "smscoreapi.h"
1c11d546 30#include "sms-cards.h"
c7ce8d37 31#include "smsendian.h"
2e5c1ec8 32
0d02efe4
MK		 33static int sms_dbg;
34module_param_named(debug, sms_dbg, int, 0644);
35MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
36
2e5c1ec8 37#define USB1_BUFFER_SIZE 0x1000
05f0ffbc 38#define USB2_BUFFER_SIZE 0x2000
2e5c1ec8
MK		 39
40#define MAX_BUFFERS 50
41#define MAX_URBS 10
42
18245e18 43struct smsusb_device_t;
2e5c1ec8 44
05f0ffbc
MCC		 45enum smsusb_state {
46 SMSUSB_DISCONNECTED,
47 SMSUSB_SUSPENDED,
48 SMSUSB_ACTIVE
49};
50
18245e18 51struct smsusb_urb_t {
05f0ffbc 52 struct list_head entry;
18245e18 53 struct smscore_buffer_t *cb;
05f0ffbc 54 struct smsusb_device_t *dev;
2e5c1ec8 55
18245e18
MK		 56 struct urb urb;
57};
2e5c1ec8 58
18245e18 59struct smsusb_device_t {
a83ccdd6 60 struct usb_device *udev;
18245e18 61 struct smscore_device_t *coredev;
2e5c1ec8 62
18245e18 63 struct smsusb_urb_t surbs[MAX_URBS];
2e5c1ec8 64
82237416
MK		 65 int response_alignment;
66 int buffer_size;
05f0ffbc
MCC		 67
68 unsigned char in_ep;
69 unsigned char out_ep;
70 enum smsusb_state state;
18245e18 71};
2e5c1ec8 72
0c071f37
MK		 73static int smsusb_submit_urb(struct smsusb_device_t *dev,
74 struct smsusb_urb_t *surb);
2e5c1ec8 75
05f0ffbc
MCC		 76/**
77 * Completing URB's callback handler - top half (interrupt context)
78 * adds completing sms urb to the global surbs list and activtes the worker
79 * thread the surb
80 * IMPORTANT - blocking functions must not be called from here !!!
81
82 * @param urb pointer to a completing urb object
83 */
0c071f37 84static void smsusb_onresponse(struct urb *urb)
2e5c1ec8 85{
18245e18
MK		 86 struct smsusb_urb_t *surb = (struct smsusb_urb_t *) urb->context;
87 struct smsusb_device_t *dev = surb->dev;
2e5c1ec8 88
8f12d0a4
US		 89 if (urb->status == -ESHUTDOWN) {
90 sms_err("error, urb status %d (-ESHUTDOWN), %d bytes",
eb250942 91 urb->status, urb->actual_length);
2e5c1ec8
MK		 92 return;
93 }
94
8f12d0a4 95 if ((urb->actual_length > 0) && (urb->status == 0)) {
dfef84fc 96 struct sms_msg_hdr *phdr = (struct sms_msg_hdr *)surb->cb->p;
2e5c1ec8 97
9c9c68a8 98 smsendian_handle_message_header(phdr);
dfef84fc
MCC		 99 if (urb->actual_length >= phdr->msg_length) {
100 surb->cb->size = phdr->msg_length;
2e5c1ec8 101
82237416 102 if (dev->response_alignment &&
dfef84fc 103 (phdr->msg_flags & MSG_HDR_FLAG_SPLIT_MSG)) {
82237416
MK		 104
105 surb->cb->offset =
106 dev->response_alignment +
dfef84fc 107 ((phdr->msg_flags >> 8) & 3);
82237416
MK		 108
109 /* sanity check */
dfef84fc 110 if (((int) phdr->msg_length +
82237416 111 surb->cb->offset) > urb->actual_length) {
eb250942
MK		 112 sms_err("invalid response "
113 "msglen %d offset %d "
114 "size %d",
dfef84fc 115 phdr->msg_length,
eb250942
MK		 116 surb->cb->offset,
117 urb->actual_length);
2e5c1ec8
MK		 118 goto exit_and_resubmit;
119 }
120
82237416
MK		 121 /* move buffer pointer and
122 * copy header to its new location */
55ad310c 123 memcpy((char *) phdr + surb->cb->offset,
dfef84fc 124 phdr, sizeof(struct sms_msg_hdr));
82237416 125 } else
2e5c1ec8
MK		 126 surb->cb->offset = 0;
127
4c3bdb5e 128 sms_debug("received %s(%d) size: %d",
dfef84fc
MCC		 129 smscore_translate_msg(phdr->msg_type),
130 phdr->msg_type, phdr->msg_length);
4c3bdb5e 131
dfef84fc 132 smsendian_handle_rx_message((struct sms_msg_data *) phdr);
80ccb51a 133
2e5c1ec8
MK		 134 smscore_onresponse(dev->coredev, surb->cb);
135 surb->cb = NULL;
82237416 136 } else {
eb250942
MK		 137 sms_err("invalid response "
138 "msglen %d actual %d",
dfef84fc 139 phdr->msg_length, urb->actual_length);
2e5c1ec8 140 }
8f12d0a4
US		 141 } else
142 sms_err("error, urb status %d, %d bytes",
143 urb->status, urb->actual_length);
144
2e5c1ec8
MK		 145
146exit_and_resubmit:
147 smsusb_submit_urb(dev, surb);
148}
149
0c071f37
MK		 150static int smsusb_submit_urb(struct smsusb_device_t *dev,
151 struct smsusb_urb_t *surb)
2e5c1ec8 152{
82237416 153 if (!surb->cb) {
2e5c1ec8 154 surb->cb = smscore_getbuffer(dev->coredev);
82237416 155 if (!surb->cb) {
eb250942 156 sms_err("smscore_getbuffer(...) returned NULL");
2e5c1ec8
MK		 157 return -ENOMEM;
158 }
159 }
160
161 usb_fill_bulk_urb(
162 &surb->urb,
163 dev->udev,
05f0ffbc 164 usb_rcvbulkpipe(dev->udev, dev->in_ep),
2e5c1ec8
MK		 165 surb->cb->p,
166 dev->buffer_size,
167 smsusb_onresponse,
168 surb
169 );
170 surb->urb.transfer_dma = surb->cb->phys;
171 surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
172
173 return usb_submit_urb(&surb->urb, GFP_ATOMIC);
174}
175
0c071f37 176static void smsusb_stop_streaming(struct smsusb_device_t *dev)
2e5c1ec8
MK		 177{
178 int i;
179
fa830e8a 180 for (i = 0; i < MAX_URBS; i++) {
2e5c1ec8
MK		 181 usb_kill_urb(&dev->surbs[i].urb);
182
82237416 183 if (dev->surbs[i].cb) {
2e5c1ec8
MK		 184 smscore_putbuffer(dev->coredev, dev->surbs[i].cb);
185 dev->surbs[i].cb = NULL;
186 }
187 }
188}
189
0c071f37 190static int smsusb_start_streaming(struct smsusb_device_t *dev)
2e5c1ec8
MK		 191{
192 int i, rc;
193
fa830e8a 194 for (i = 0; i < MAX_URBS; i++) {
2e5c1ec8 195 rc = smsusb_submit_urb(dev, &dev->surbs[i]);
82237416 196 if (rc < 0) {
eb250942 197 sms_err("smsusb_submit_urb(...) failed");
2e5c1ec8
MK		 198 smsusb_stop_streaming(dev);
199 break;
200 }
201 }
202
203 return rc;
204}
205
0c071f37 206static int smsusb_sendrequest(void *context, void *buffer, size_t size)
2e5c1ec8 207{
18245e18 208 struct smsusb_device_t *dev = (struct smsusb_device_t *) context;
7160035d
MCC		 209 struct sms_msg_hdr *phdr;
210 int dummy, ret;
2e5c1ec8 211
80ccb51a
MCC		 212 if (dev->state != SMSUSB_ACTIVE)
213 return -ENOENT;
214
7160035d
MCC		 215 phdr = kmalloc(size, GFP_KERNEL);
216 if (!phdr)
217 return -ENOMEM;
218 memcpy(phdr, buffer, size);
219
4c3bdb5e 220 sms_debug("sending %s(%d) size: %d",
dfef84fc
MCC		 221 smscore_translate_msg(phdr->msg_type), phdr->msg_type,
222 phdr->msg_length);
4c3bdb5e 223
dfef84fc 224 smsendian_handle_tx_message((struct sms_msg_data *) phdr);
7160035d
MCC		 225 smsendian_handle_message_header((struct sms_msg_hdr *)phdr);
226 ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),
227 phdr, size, &dummy, 1000);
228
229 kfree(phdr);
230 return ret;
2e5c1ec8
MK		 231}
232
0c071f37 233static char *smsusb1_fw_lkup[] = {
2e5c1ec8
MK		 234 "dvbt_stellar_usb.inp",
235 "dvbh_stellar_usb.inp",
236 "tdmb_stellar_usb.inp",
237 "none",
238 "dvbt_bda_stellar_usb.inp",
239};
240
1fbc3caf
MK		 241static inline char *sms_get_fw_name(int mode, int board_id)
242{
243 char **fw = sms_get_board(board_id)->fw;
244 return (fw && fw[mode]) ? fw[mode] : smsusb1_fw_lkup[mode];
245}
246
247static int smsusb1_load_firmware(struct usb_device *udev, int id, int board_id)
2e5c1ec8
MK		 248{
249 const struct firmware *fw;
a83ccdd6 250 u8 *fw_buffer;
2e5c1ec8 251 int rc, dummy;
1fbc3caf 252 char *fw_filename;
2e5c1ec8 253
82237416 254 if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) {
eb250942 255 sms_err("invalid firmware id specified %d", id);
2e5c1ec8
MK		 256 return -EINVAL;
257 }
258
1fbc3caf
MK		 259 fw_filename = sms_get_fw_name(id, board_id);
260
261 rc = request_firmware(&fw, fw_filename, &udev->dev);
82237416 262 if (rc < 0) {
1fbc3caf
MK		 263 sms_warn("failed to open \"%s\" mode %d, "
264 "trying again with default firmware", fw_filename, id);
265
266 fw_filename = smsusb1_fw_lkup[id];
267 rc = request_firmware(&fw, fw_filename, &udev->dev);
268 if (rc < 0) {
269 sms_warn("failed to open \"%s\" mode %d",
270 fw_filename, id);
271
272 return rc;
273 }
2e5c1ec8
MK		 274 }
275
276 fw_buffer = kmalloc(fw->size, GFP_KERNEL);
82237416 277 if (fw_buffer) {
2e5c1ec8
MK		 278 memcpy(fw_buffer, fw->data, fw->size);
279
82237416
MK		 280 rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2),
281 fw_buffer, fw->size, &dummy, 1000);
2e5c1ec8 282
0f2a1ee1 283 sms_info("sent %zd(%d) bytes, rc %d", fw->size, dummy, rc);
2e5c1ec8
MK		 284
285 kfree(fw_buffer);
82237416 286 } else {
eb250942 287 sms_err("failed to allocate firmware buffer");
2e5c1ec8
MK		 288 rc = -ENOMEM;
289 }
1fbc3caf 290 sms_info("read FW %s, size=%zd", fw_filename, fw->size);
2e5c1ec8
MK		 291
292 release_firmware(fw);
293
294 return rc;
295}
296
0c071f37 297static void smsusb1_detectmode(void *context, int *mode)
2e5c1ec8 298{
18245e18
MK		 299 char *product_string =
300 ((struct smsusb_device_t *) context)->udev->product;
2e5c1ec8
MK		 301
302 *mode = DEVICE_MODE_NONE;
303
82237416 304 if (!product_string) {
2e5c1ec8 305 product_string = "none";
a0c0abcb 306 sms_err("product string not found");
82237416
MK		 307 } else if (strstr(product_string, "DVBH"))
308 *mode = 1;
309 else if (strstr(product_string, "BDA"))
310 *mode = 4;
311 else if (strstr(product_string, "DVBT"))
312 *mode = 0;
313 else if (strstr(product_string, "TDMB"))
314 *mode = 2;
2e5c1ec8 315
a0c0abcb 316 sms_info("%d \"%s\"", *mode, product_string);
2e5c1ec8
MK		 317}
318
0c071f37 319static int smsusb1_setmode(void *context, int mode)
2e5c1ec8 320{
28a59df4 321 struct sms_msg_hdr msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,
dfef84fc 322 sizeof(struct sms_msg_hdr), 0 };
2e5c1ec8 323
82237416 324 if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
eb250942 325 sms_err("invalid firmware id specified %d", mode);
2e5c1ec8
MK		 326 return -EINVAL;
327 }
328
28a59df4 329 return smsusb_sendrequest(context, &msg, sizeof(msg));
2e5c1ec8
MK		 330}
331
0c071f37 332static void smsusb_term_device(struct usb_interface *intf)
2e5c1ec8 333{
8350e155 334 struct smsusb_device_t *dev = usb_get_intfdata(intf);
2e5c1ec8 335
82237416 336 if (dev) {
05f0ffbc
MCC		 337 dev->state = SMSUSB_DISCONNECTED;
338
2e5c1ec8
MK		 339 smsusb_stop_streaming(dev);
340
fa830e8a 341 /* unregister from smscore */
2e5c1ec8
MK		 342 if (dev->coredev)
343 smscore_unregister_device(dev->coredev);
344
05f0ffbc 345 sms_info("device 0x%p destroyed", dev);
08921ac9 346 kfree(dev);
2e5c1ec8
MK		 347 }
348
349 usb_set_intfdata(intf, NULL);
350}
351
0c071f37 352static int smsusb_init_device(struct usb_interface *intf, int board_id)
2e5c1ec8 353{
18245e18
MK		 354 struct smsdevice_params_t params;
355 struct smsusb_device_t *dev;
2e5c1ec8
MK		 356 int i, rc;
357
fa830e8a 358 /* create device object */
18245e18 359 dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL);
82237416 360 if (!dev) {
eb250942 361 sms_err("kzalloc(sizeof(struct smsusb_device_t) failed");
2e5c1ec8
MK		 362 return -ENOMEM;
363 }
364
365 memset(&params, 0, sizeof(params));
366 usb_set_intfdata(intf, dev);
367 dev->udev = interface_to_usbdev(intf);
05f0ffbc 368 dev->state = SMSUSB_DISCONNECTED;
2e5c1ec8 369
2708e888 370 params.device_type = sms_get_board(board_id)->type;
73104fb3 371
2708e888 372 switch (params.device_type) {
1c11d546 373 case SMS_STELLAR:
f17407a8
MK		 374 dev->buffer_size = USB1_BUFFER_SIZE;
375
376 params.setmode_handler = smsusb1_setmode;
377 params.detectmode_handler = smsusb1_detectmode;
f17407a8 378 break;
07bb6bdd 379 case SMS_UNKNOWN_TYPE:
2708e888
MK		 380 sms_err("Unspecified sms device type!");
381 /* fall-thru */
07bb6bdd 382 default:
f17407a8 383 dev->buffer_size = USB2_BUFFER_SIZE;
82237416 384 dev->response_alignment =
c7ce8d37 385 le16_to_cpu(dev->udev->ep_in[1]->desc.wMaxPacketSize) -
dfef84fc 386 sizeof(struct sms_msg_hdr);
2e5c1ec8 387
f17407a8
MK		 388 params.flags |= SMS_DEVICE_FAMILY2;
389 break;
2e5c1ec8
MK		 390 }
391
05f0ffbc
MCC		 392 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
393 if (intf->cur_altsetting->endpoint[i].desc. bEndpointAddress & USB_DIR_IN)
394 dev->in_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
395 else
396 dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
397 }
398
399 sms_info("in_ep = %02x, out_ep = %02x",
400 dev->in_ep, dev->out_ep);
401
2e5c1ec8
MK		 402 params.device = &dev->udev->dev;
403 params.buffer_size = dev->buffer_size;
404 params.num_buffers = MAX_BUFFERS;
405 params.sendrequest_handler = smsusb_sendrequest;
406 params.context = dev;
1722f3b3 407 usb_make_path(dev->udev, params.devpath, sizeof(params.devpath));
2e5c1ec8 408
82237416 409 /* register in smscore */
2e5c1ec8 410 rc = smscore_register_device(&params, &dev->coredev);
82237416 411 if (rc < 0) {
eb250942 412 sms_err("smscore_register_device(...) failed, rc %d", rc);
2e5c1ec8
MK		 413 smsusb_term_device(intf);
414 return rc;
415 }
416
1c11d546
MK		 417 smscore_set_board_id(dev->coredev, board_id);
418
503efe5c
MCC		 419 dev->coredev->is_usb_device = true;
420
fa830e8a 421 /* initialize urbs */
82237416 422 for (i = 0; i < MAX_URBS; i++) {
2e5c1ec8
MK		 423 dev->surbs[i].dev = dev;
424 usb_init_urb(&dev->surbs[i].urb);
425 }
426
a0c0abcb 427 sms_info("smsusb_start_streaming(...).");
2e5c1ec8 428 rc = smsusb_start_streaming(dev);
82237416 429 if (rc < 0) {
eb250942 430 sms_err("smsusb_start_streaming(...) failed");
2e5c1ec8
MK		 431 smsusb_term_device(intf);
432 return rc;
433 }
434
05f0ffbc
MCC		 435 dev->state = SMSUSB_ACTIVE;
436
2e5c1ec8 437 rc = smscore_start_device(dev->coredev);
82237416 438 if (rc < 0) {
eb250942 439 sms_err("smscore_start_device(...) failed");
2e5c1ec8
MK		 440 smsusb_term_device(intf);
441 return rc;
442 }
443
05f0ffbc 444 sms_info("device 0x%p created", dev);
2e5c1ec8
MK		 445
446 return rc;
447}
448
4c62e976 449static int smsusb_probe(struct usb_interface *intf,
0c071f37 450 const struct usb_device_id *id)
2e5c1ec8
MK		 451{
452 struct usb_device *udev = interface_to_usbdev(intf);
347d8f1f 453 char devpath[32];
2e5c1ec8
MK		 454 int i, rc;
455
05f0ffbc
MCC		 456 sms_info("interface number %d",
457 intf->cur_altsetting->desc.bInterfaceNumber);
f17407a8 458
05f0ffbc
MCC		 459 if (sms_get_board(id->driver_info)->intf_num !=
460 intf->cur_altsetting->desc.bInterfaceNumber) {
461 sms_err("interface number is %d expecting %d",
462 sms_get_board(id->driver_info)->intf_num,
463 intf->cur_altsetting->desc.bInterfaceNumber);
464 return -ENODEV;
465 }
466
467 if (intf->num_altsetting > 1) {
468 rc = usb_set_interface(udev,
469 intf->cur_altsetting->desc.bInterfaceNumber,
470 0);
82237416 471 if (rc < 0) {
eb250942 472 sms_err("usb_set_interface failed, rc %d", rc);
2e5c1ec8
MK		 473 return rc;
474 }
475 }
476
a0c0abcb 477 sms_info("smsusb_probe %d",
82237416 478 intf->cur_altsetting->desc.bInterfaceNumber);
05f0ffbc 479 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
a0c0abcb 480 sms_info("endpoint %d %02x %02x %d", i,
82237416
MK		 481 intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
482 intf->cur_altsetting->endpoint[i].desc.bmAttributes,
483 intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
05f0ffbc
MCC		 484 if (intf->cur_altsetting->endpoint[i].desc.bEndpointAddress &
485 USB_DIR_IN)
486 rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev,
487 intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
488 else
489 rc = usb_clear_halt(udev, usb_sndbulkpipe(udev,
490 intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
491 }
82237416
MK		 492 if ((udev->actconfig->desc.bNumInterfaces == 2) &&
493 (intf->cur_altsetting->desc.bInterfaceNumber == 0)) {
eb250942 494 sms_err("rom interface 0 is not used");
2e5c1ec8
MK		 495 return -ENODEV;
496 }
497
347d8f1f
MCC		 498 if (id->driver_info == SMS1XXX_BOARD_SIANO_STELLAR_ROM) {
499 sms_info("stellar device was found.");
500 snprintf(devpath, sizeof(devpath), "usb\\%d-%s",
501 udev->bus->busnum, udev->devpath);
502 sms_info("stellar device was found.");
503 return smsusb1_load_firmware(
504 udev, smscore_registry_getmode(devpath),
505 id->driver_info);
506 }
507
1c11d546 508 rc = smsusb_init_device(intf, id->driver_info);
a0c0abcb 509 sms_info("rc %d", rc);
05860f2d 510 sms_board_load_modules(id->driver_info);
f17407a8 511 return rc;
2e5c1ec8
MK		 512}
513
0c071f37 514static void smsusb_disconnect(struct usb_interface *intf)
2e5c1ec8
MK		 515{
516 smsusb_term_device(intf);
517}
518
2f56c34b
US		 519static int smsusb_suspend(struct usb_interface *intf, pm_message_t msg)
520{
8350e155 521 struct smsusb_device_t *dev = usb_get_intfdata(intf);
05f0ffbc
MCC		 522 printk(KERN_INFO "%s Entering status %d.\n", __func__, msg.event);
523 dev->state = SMSUSB_SUSPENDED;
524 /*smscore_set_power_mode(dev, SMS_POWER_MODE_SUSPENDED);*/
2f56c34b
US		 525 smsusb_stop_streaming(dev);
526 return 0;
527}
528
529static int smsusb_resume(struct usb_interface *intf)
530{
531 int rc, i;
8350e155 532 struct smsusb_device_t *dev = usb_get_intfdata(intf);
2f56c34b
US		 533 struct usb_device *udev = interface_to_usbdev(intf);
534
05f0ffbc
MCC		 535 printk(KERN_INFO "%s Entering.\n", __func__);
536 usb_clear_halt(udev, usb_rcvbulkpipe(udev, dev->in_ep));
537 usb_clear_halt(udev, usb_sndbulkpipe(udev, dev->out_ep));
2f56c34b
US		 538
539 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
540 printk(KERN_INFO "endpoint %d %02x %02x %d\n", i,
541 intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
542 intf->cur_altsetting->endpoint[i].desc.bmAttributes,
543 intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
544
545 if (intf->num_altsetting > 0) {
546 rc = usb_set_interface(udev,
547 intf->cur_altsetting->desc.
548 bInterfaceNumber, 0);
549 if (rc < 0) {
b9391f41
MK		 550 printk(KERN_INFO "%s usb_set_interface failed, "
551 "rc %d\n", __func__, rc);
2f56c34b
US		 552 return rc;
553 }
554 }
555
556 smsusb_start_streaming(dev);
557 return 0;
558}
559
d04dbd1c 560static const struct usb_device_id smsusb_id_table[] = {
841a3f0d
MK		 561 { USB_DEVICE(0x187f, 0x0010),
562 .driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
563 { USB_DEVICE(0x187f, 0x0100),
564 .driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
565 { USB_DEVICE(0x187f, 0x0200),
566 .driver_info = SMS1XXX_BOARD_SIANO_NOVA_A },
567 { USB_DEVICE(0x187f, 0x0201),
568 .driver_info = SMS1XXX_BOARD_SIANO_NOVA_B },
569 { USB_DEVICE(0x187f, 0x0300),
570 .driver_info = SMS1XXX_BOARD_SIANO_VEGA },
841a3f0d
MK		 571 { USB_DEVICE(0x2040, 0x1700),
572 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT },
573 { USB_DEVICE(0x2040, 0x1800),
574 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A },
575 { USB_DEVICE(0x2040, 0x1801),
576 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B },
577 { USB_DEVICE(0x2040, 0x2000),
578 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
579 { USB_DEVICE(0x2040, 0x2009),
580 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD_R2 },
581 { USB_DEVICE(0x2040, 0x200a),
582 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
583 { USB_DEVICE(0x2040, 0x2010),
584 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
585 { USB_DEVICE(0x2040, 0x2011),
586 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
587 { USB_DEVICE(0x2040, 0x2019),
588 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
589 { USB_DEVICE(0x2040, 0x5500),
590 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
591 { USB_DEVICE(0x2040, 0x5510),
592 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
593 { USB_DEVICE(0x2040, 0x5520),
594 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
595 { USB_DEVICE(0x2040, 0x5530),
596 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
597 { USB_DEVICE(0x2040, 0x5580),
598 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
599 { USB_DEVICE(0x2040, 0x5590),
600 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
d0b66180
US		 601 { USB_DEVICE(0x187f, 0x0202),
602 .driver_info = SMS1XXX_BOARD_SIANO_NICE },
603 { USB_DEVICE(0x187f, 0x0301),
604 .driver_info = SMS1XXX_BOARD_SIANO_VENICE },
78c948ab
MK		 605 { USB_DEVICE(0x2040, 0xb900),
606 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
607 { USB_DEVICE(0x2040, 0xb910),
608 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
20d15a20
MK		 609 { USB_DEVICE(0x2040, 0xb980),
610 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
611 { USB_DEVICE(0x2040, 0xb990),
612 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
78c948ab
MK		 613 { USB_DEVICE(0x2040, 0xc000),
614 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
20d15a20
MK		 615 { USB_DEVICE(0x2040, 0xc010),
616 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
617 { USB_DEVICE(0x2040, 0xc080),
618 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
619 { USB_DEVICE(0x2040, 0xc090),
620 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
4d1b58b8
MK		 621 { USB_DEVICE(0x2040, 0xc0a0),
622 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
3e1141e2
MK		 623 { USB_DEVICE(0x2040, 0xf5a0),
624 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
347d8f1f
MCC		 625 { USB_DEVICE(0x187f, 0x0202),
626 .driver_info = SMS1XXX_BOARD_SIANO_NICE },
627 { USB_DEVICE(0x187f, 0x0301),
628 .driver_info = SMS1XXX_BOARD_SIANO_VENICE },
629 { USB_DEVICE(0x187f, 0x0302),
630 .driver_info = SMS1XXX_BOARD_SIANO_VENICE },
631 { USB_DEVICE(0x187f, 0x0310),
632 .driver_info = SMS1XXX_BOARD_SIANO_MING },
633 { USB_DEVICE(0x187f, 0x0500),
634 .driver_info = SMS1XXX_BOARD_SIANO_PELE },
635 { USB_DEVICE(0x187f, 0x0600),
636 .driver_info = SMS1XXX_BOARD_SIANO_RIO },
637 { USB_DEVICE(0x187f, 0x0700),
638 .driver_info = SMS1XXX_BOARD_SIANO_DENVER_2160 },
639 { USB_DEVICE(0x187f, 0x0800),
640 .driver_info = SMS1XXX_BOARD_SIANO_DENVER_1530 },
641 { USB_DEVICE(0x19D2, 0x0086),
642 .driver_info = SMS1XXX_BOARD_ZTE_DVB_DATA_CARD },
643 { USB_DEVICE(0x19D2, 0x0078),
644 .driver_info = SMS1XXX_BOARD_ONDA_MDTV_DATA_CARD },
d0b66180
US		 645 { } /* Terminating entry */
646 };
647
841a3f0d
MK		 648MODULE_DEVICE_TABLE(usb, smsusb_id_table);
649
2e5c1ec8 650static struct usb_driver smsusb_driver = {
dba843af 651 .name = "smsusb",
2e5c1ec8 652 .probe = smsusb_probe,
82237416 653 .disconnect = smsusb_disconnect,
2e5c1ec8 654 .id_table = smsusb_id_table,
2f56c34b
US		 655
656 .suspend = smsusb_suspend,
657 .resume = smsusb_resume,
2e5c1ec8
MK		 658};
659
ecb3b2b3 660module_usb_driver(smsusb_driver);
e0f14c25 661
05a07376 662MODULE_DESCRIPTION("Driver for the Siano SMS1xxx USB dongle");
e0f14c25
US		 663MODULE_AUTHOR("Siano Mobile Silicon, INC. (uris@siano-ms.com)");
664MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)