SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/siano/smsusb.c

   1 /****************************************************************
   2
   3 Siano Mobile Silicon, Inc.
   4 MDTV receiver kernel modules.
   5 Copyright (C) 2005-2009, Uri Shkolnik, Anatoly Greenblat
   6
   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.
  11
  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.
  16
  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/>.
  19
  20 ****************************************************************/
  21
  22 #include <linux/kernel.h>
  23 #include <linux/init.h>
  24 #include <linux/usb.h>
  25 #include <linux/firmware.h>
  26
  27 #include "smscoreapi.h"
  28 #include "sms-cards.h"
  29
  30 static int sms_dbg;
  31 module_param_named(debug, sms_dbg, int, 0644);
  32 MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
  33
  34 #define USB1_BUFFER_SIZE                0x1000
  35 #define USB2_BUFFER_SIZE                0x4000
  36
  37 #define MAX_BUFFERS             50
  38 #define MAX_URBS                10
  39
  40 struct smsusb_device_t;
  41
  42 struct smsusb_urb_t {
  43         struct smscore_buffer_t *cb;
  44         struct smsusb_device_t  *dev;
  45
  46         struct urb urb;
  47 };
  48
  49 struct smsusb_device_t {
  50         struct usb_device *udev;
  51         struct smscore_device_t *coredev;
  52
  53         struct smsusb_urb_t     surbs[MAX_URBS];
  54
  55         int             response_alignment;
  56         int             buffer_size;
  57 };
  58
  59 static int smsusb_submit_urb(struct smsusb_device_t *dev,
  60                              struct smsusb_urb_t *surb);
  61
  62 static void smsusb_onresponse(struct urb *urb)
  63 {
  64         struct smsusb_urb_t *surb = (struct smsusb_urb_t *) urb->context;
  65         struct smsusb_device_t *dev = surb->dev;
  66
  67         if (urb->status < 0) {
  68                 sms_err("error, urb status %d, %d bytes",
  69                         urb->status, urb->actual_length);
  70                 return;
  71         }
  72
  73         if (urb->actual_length > 0) {
  74                 struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *) surb->cb->p;
  75
  76                 smsendian_handle_message_header(phdr);
  77                 if (urb->actual_length >= phdr->msgLength) {
  78                         surb->cb->size = phdr->msgLength;
  79
  80                         if (dev->response_alignment &&
  81                             (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) {
  82
  83                                 surb->cb->offset =
  84                                         dev->response_alignment +
  85                                         ((phdr->msgFlags >> 8) & 3);
  86
  87                                 /* sanity check */
  88                                 if (((int) phdr->msgLength +
  89                                      surb->cb->offset) > urb->actual_length) {
  90                                         sms_err("invalid response "
  91                                                 "msglen %d offset %d "
  92                                                 "size %d",
  93                                                 phdr->msgLength,
  94                                                 surb->cb->offset,
  95                                                 urb->actual_length);
  96                                         goto exit_and_resubmit;
  97                                 }
  98
  99                                 /* move buffer pointer and
 100                                  * copy header to its new location */
 101                                 memcpy((char *) phdr + surb->cb->offset,
 102                                        phdr, sizeof(struct SmsMsgHdr_ST));
 103                         } else
 104                                 surb->cb->offset = 0;
 105
 106                         smscore_onresponse(dev->coredev, surb->cb);
 107                         surb->cb = NULL;
 108                 } else {
 109                         sms_err("invalid response "
 110                                 "msglen %d actual %d",
 111                                 phdr->msgLength, urb->actual_length);
 112                 }
 113         }
 114
 115 exit_and_resubmit:
 116         smsusb_submit_urb(dev, surb);
 117 }
 118
 119 static int smsusb_submit_urb(struct smsusb_device_t *dev,
 120                              struct smsusb_urb_t *surb)
 121 {
 122         if (!surb->cb) {
 123                 surb->cb = smscore_getbuffer(dev->coredev);
 124                 if (!surb->cb) {
 125                         sms_err("smscore_getbuffer(...) returned NULL");
 126                         return -ENOMEM;
 127                 }
 128         }
 129
 130         usb_fill_bulk_urb(
 131                 &surb->urb,
 132                 dev->udev,
 133                 usb_rcvbulkpipe(dev->udev, 0x81),
 134                 surb->cb->p,
 135                 dev->buffer_size,
 136                 smsusb_onresponse,
 137                 surb
 138         );
 139         surb->urb.transfer_dma = surb->cb->phys;
 140         surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 141
 142         return usb_submit_urb(&surb->urb, GFP_ATOMIC);
 143 }
 144
 145 static void smsusb_stop_streaming(struct smsusb_device_t *dev)
 146 {
 147         int i;
 148
 149         for (i = 0; i < MAX_URBS; i++) {
 150                 usb_kill_urb(&dev->surbs[i].urb);
 151
 152                 if (dev->surbs[i].cb) {
 153                         smscore_putbuffer(dev->coredev, dev->surbs[i].cb);
 154                         dev->surbs[i].cb = NULL;
 155                 }
 156         }
 157 }
 158
 159 static int smsusb_start_streaming(struct smsusb_device_t *dev)
 160 {
 161         int i, rc;
 162
 163         for (i = 0; i < MAX_URBS; i++) {
 164                 rc = smsusb_submit_urb(dev, &dev->surbs[i]);
 165                 if (rc < 0) {
 166                         sms_err("smsusb_submit_urb(...) failed");
 167                         smsusb_stop_streaming(dev);
 168                         break;
 169                 }
 170         }
 171
 172         return rc;
 173 }
 174
 175 static int smsusb_sendrequest(void *context, void *buffer, size_t size)
 176 {
 177         struct smsusb_device_t *dev = (struct smsusb_device_t *) context;
 178         int dummy;
 179
 180         return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),
 181                             buffer, size, &dummy, 1000);
 182 }
 183
 184 static char *smsusb1_fw_lkup[] = {
 185         "dvbt_stellar_usb.inp",
 186         "dvbh_stellar_usb.inp",
 187         "tdmb_stellar_usb.inp",
 188         "none",
 189         "dvbt_bda_stellar_usb.inp",
 190 };
 191
 192 static inline char *sms_get_fw_name(int mode, int board_id)
 193 {
 194         char **fw = sms_get_board(board_id)->fw;
 195         return (fw && fw[mode]) ? fw[mode] : smsusb1_fw_lkup[mode];
 196 }
 197
 198 static int smsusb1_load_firmware(struct usb_device *udev, int id, int board_id)
 199 {
 200         const struct firmware *fw;
 201         u8 *fw_buffer;
 202         int rc, dummy;
 203         char *fw_filename;
 204
 205         if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA) {
 206                 sms_err("invalid firmware id specified %d", id);
 207                 return -EINVAL;
 208         }
 209
 210         fw_filename = sms_get_fw_name(id, board_id);
 211
 212         rc = request_firmware(&fw, fw_filename, &udev->dev);
 213         if (rc < 0) {
 214                 sms_warn("failed to open \"%s\" mode %d, "
 215                          "trying again with default firmware", fw_filename, id);
 216
 217                 fw_filename = smsusb1_fw_lkup[id];
 218                 rc = request_firmware(&fw, fw_filename, &udev->dev);
 219                 if (rc < 0) {
 220                         sms_warn("failed to open \"%s\" mode %d",
 221                                  fw_filename, id);
 222
 223                         return rc;
 224                 }
 225         }
 226
 227         fw_buffer = kmalloc(fw->size, GFP_KERNEL);
 228         if (fw_buffer) {
 229                 memcpy(fw_buffer, fw->data, fw->size);
 230
 231                 rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2),
 232                                   fw_buffer, fw->size, &dummy, 1000);
 233
 234                 sms_info("sent %zd(%d) bytes, rc %d", fw->size, dummy, rc);
 235
 236                 kfree(fw_buffer);
 237         } else {
 238                 sms_err("failed to allocate firmware buffer");
 239                 rc = -ENOMEM;
 240         }
 241         sms_info("read FW %s, size=%zd", fw_filename, fw->size);
 242
 243         release_firmware(fw);
 244
 245         return rc;
 246 }
 247
 248 static void smsusb1_detectmode(void *context, int *mode)
 249 {
 250         char *product_string =
 251                 ((struct smsusb_device_t *) context)->udev->product;
 252
 253         *mode = DEVICE_MODE_NONE;
 254
 255         if (!product_string) {
 256                 product_string = "none";
 257                 sms_err("product string not found");
 258         } else if (strstr(product_string, "DVBH"))
 259                 *mode = 1;
 260         else if (strstr(product_string, "BDA"))
 261                 *mode = 4;
 262         else if (strstr(product_string, "DVBT"))
 263                 *mode = 0;
 264         else if (strstr(product_string, "TDMB"))
 265                 *mode = 2;
 266
 267         sms_info("%d \"%s\"", *mode, product_string);
 268 }
 269
 270 static int smsusb1_setmode(void *context, int mode)
 271 {
 272         struct SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,
 273                              sizeof(struct SmsMsgHdr_ST), 0 };
 274
 275         if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
 276                 sms_err("invalid firmware id specified %d", mode);
 277                 return -EINVAL;
 278         }
 279
 280         return smsusb_sendrequest(context, &Msg, sizeof(Msg));
 281 }
 282
 283 static void smsusb_term_device(struct usb_interface *intf)
 284 {
 285         struct smsusb_device_t *dev =
 286                 (struct smsusb_device_t *) usb_get_intfdata(intf);
 287
 288         if (dev) {
 289                 smsusb_stop_streaming(dev);
 290
 291                 /* unregister from smscore */
 292                 if (dev->coredev)
 293                         smscore_unregister_device(dev->coredev);
 294
 295                 kfree(dev);
 296
 297                 sms_info("device %p destroyed", dev);
 298         }
 299
 300         usb_set_intfdata(intf, NULL);
 301 }
 302
 303 static int smsusb_init_device(struct usb_interface *intf, int board_id)
 304 {
 305         struct smsdevice_params_t params;
 306         struct smsusb_device_t *dev;
 307         int i, rc;
 308
 309         /* create device object */
 310         dev = kzalloc(sizeof(struct smsusb_device_t), GFP_KERNEL);
 311         if (!dev) {
 312                 sms_err("kzalloc(sizeof(struct smsusb_device_t) failed");
 313                 return -ENOMEM;
 314         }
 315
 316         memset(&params, 0, sizeof(params));
 317         usb_set_intfdata(intf, dev);
 318         dev->udev = interface_to_usbdev(intf);
 319
 320         params.device_type = sms_get_board(board_id)->type;
 321
 322         switch (params.device_type) {
 323         case SMS_STELLAR:
 324                 dev->buffer_size = USB1_BUFFER_SIZE;
 325
 326                 params.setmode_handler = smsusb1_setmode;
 327                 params.detectmode_handler = smsusb1_detectmode;
 328                 break;
 329         default:
 330                 sms_err("Unspecified sms device type!");
 331                 /* fall-thru */
 332         case SMS_NOVA_A0:
 333         case SMS_NOVA_B0:
 334         case SMS_VEGA:
 335                 dev->buffer_size = USB2_BUFFER_SIZE;
 336                 dev->response_alignment =
 337                         dev->udev->ep_in[1]->desc.wMaxPacketSize -
 338                         sizeof(struct SmsMsgHdr_ST);
 339
 340                 params.flags |= SMS_DEVICE_FAMILY2;
 341                 break;
 342         }
 343
 344         params.device = &dev->udev->dev;
 345         params.buffer_size = dev->buffer_size;
 346         params.num_buffers = MAX_BUFFERS;
 347         params.sendrequest_handler = smsusb_sendrequest;
 348         params.context = dev;
 349         snprintf(params.devpath, sizeof(params.devpath),
 350                  "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath);
 351
 352         /* register in smscore */
 353         rc = smscore_register_device(&params, &dev->coredev);
 354         if (rc < 0) {
 355                 sms_err("smscore_register_device(...) failed, rc %d", rc);
 356                 smsusb_term_device(intf);
 357                 return rc;
 358         }
 359
 360         smscore_set_board_id(dev->coredev, board_id);
 361
 362         /* initialize urbs */
 363         for (i = 0; i < MAX_URBS; i++) {
 364                 dev->surbs[i].dev = dev;
 365                 usb_init_urb(&dev->surbs[i].urb);
 366         }
 367
 368         sms_info("smsusb_start_streaming(...).");
 369         rc = smsusb_start_streaming(dev);
 370         if (rc < 0) {
 371                 sms_err("smsusb_start_streaming(...) failed");
 372                 smsusb_term_device(intf);
 373                 return rc;
 374         }
 375
 376         rc = smscore_start_device(dev->coredev);
 377         if (rc < 0) {
 378                 sms_err("smscore_start_device(...) failed");
 379                 smsusb_term_device(intf);
 380                 return rc;
 381         }
 382
 383         sms_info("device %p created", dev);
 384
 385         return rc;
 386 }
 387
 388 static int smsusb_probe(struct usb_interface *intf,
 389                         const struct usb_device_id *id)
 390 {
 391         struct usb_device *udev = interface_to_usbdev(intf);
 392         char devpath[32];
 393         int i, rc;
 394
 395         rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81));
 396         rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02));
 397
 398         if (intf->num_altsetting > 0) {
 399                 rc = usb_set_interface(
 400                         udev, intf->cur_altsetting->desc.bInterfaceNumber, 0);
 401                 if (rc < 0) {
 402                         sms_err("usb_set_interface failed, rc %d", rc);
 403                         return rc;
 404                 }
 405         }
 406
 407         sms_info("smsusb_probe %d",
 408                intf->cur_altsetting->desc.bInterfaceNumber);
 409         for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
 410                 sms_info("endpoint %d %02x %02x %d", i,
 411                        intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
 412                        intf->cur_altsetting->endpoint[i].desc.bmAttributes,
 413                        intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
 414
 415         if ((udev->actconfig->desc.bNumInterfaces == 2) &&
 416             (intf->cur_altsetting->desc.bInterfaceNumber == 0)) {
 417                 sms_err("rom interface 0 is not used");
 418                 return -ENODEV;
 419         }
 420
 421         if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
 422                 snprintf(devpath, sizeof(devpath), "usb\\%d-%s",
 423                          udev->bus->busnum, udev->devpath);
 424                 sms_info("stellar device was found.");
 425                 return smsusb1_load_firmware(
 426                                 udev, smscore_registry_getmode(devpath),
 427                                 id->driver_info);
 428         }
 429
 430         rc = smsusb_init_device(intf, id->driver_info);
 431         sms_info("rc %d", rc);
 432         sms_board_load_modules(id->driver_info);
 433         return rc;
 434 }
 435
 436 static void smsusb_disconnect(struct usb_interface *intf)
 437 {
 438         smsusb_term_device(intf);
 439 }
 440
 441 static int smsusb_suspend(struct usb_interface *intf, pm_message_t msg)
 442 {
 443         struct smsusb_device_t *dev =
 444                 (struct smsusb_device_t *)usb_get_intfdata(intf);
 445         printk(KERN_INFO "%s: Entering status %d.\n", __func__, msg.event);
 446         smsusb_stop_streaming(dev);
 447         return 0;
 448 }
 449
 450 static int smsusb_resume(struct usb_interface *intf)
 451 {
 452         int rc, i;
 453         struct smsusb_device_t *dev =
 454                 (struct smsusb_device_t *)usb_get_intfdata(intf);
 455         struct usb_device *udev = interface_to_usbdev(intf);
 456
 457         printk(KERN_INFO "%s: Entering.\n", __func__);
 458         usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81));
 459         usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02));
 460
 461         for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
 462                 printk(KERN_INFO "endpoint %d %02x %02x %d\n", i,
 463                        intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
 464                        intf->cur_altsetting->endpoint[i].desc.bmAttributes,
 465                        intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
 466
 467         if (intf->num_altsetting > 0) {
 468                 rc = usb_set_interface(udev,
 469                                        intf->cur_altsetting->desc.
 470                                        bInterfaceNumber, 0);
 471                 if (rc < 0) {
 472                         printk(KERN_INFO "%s usb_set_interface failed, "
 473                                "rc %d\n", __func__, rc);
 474                         return rc;
 475                 }
 476         }
 477
 478         smsusb_start_streaming(dev);
 479         return 0;
 480 }
 481
 482 struct usb_device_id smsusb_id_table[] = {
 483 #ifdef CONFIG_DVB_SIANO_SMS1XXX_SMS_IDS
 484         { USB_DEVICE(0x187f, 0x0010),
 485                 .driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
 486         { USB_DEVICE(0x187f, 0x0100),
 487                 .driver_info = SMS1XXX_BOARD_SIANO_STELLAR },
 488         { USB_DEVICE(0x187f, 0x0200),
 489                 .driver_info = SMS1XXX_BOARD_SIANO_NOVA_A },
 490         { USB_DEVICE(0x187f, 0x0201),
 491                 .driver_info = SMS1XXX_BOARD_SIANO_NOVA_B },
 492         { USB_DEVICE(0x187f, 0x0300),
 493                 .driver_info = SMS1XXX_BOARD_SIANO_VEGA },
 494 #endif
 495         { USB_DEVICE(0x2040, 0x1700),
 496                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_CATAMOUNT },
 497         { USB_DEVICE(0x2040, 0x1800),
 498                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_A },
 499         { USB_DEVICE(0x2040, 0x1801),
 500                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_OKEMO_B },
 501         { USB_DEVICE(0x2040, 0x2000),
 502                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
 503         { USB_DEVICE(0x2040, 0x2009),
 504                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD_R2 },
 505         { USB_DEVICE(0x2040, 0x200a),
 506                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
 507         { USB_DEVICE(0x2040, 0x2010),
 508                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
 509         { USB_DEVICE(0x2040, 0x2011),
 510                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
 511         { USB_DEVICE(0x2040, 0x2019),
 512                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_TIGER_MINICARD },
 513         { USB_DEVICE(0x2040, 0x5500),
 514                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
 515         { USB_DEVICE(0x2040, 0x5510),
 516                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
 517         { USB_DEVICE(0x2040, 0x5520),
 518                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
 519         { USB_DEVICE(0x2040, 0x5530),
 520                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
 521         { USB_DEVICE(0x2040, 0x5580),
 522                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
 523         { USB_DEVICE(0x2040, 0x5590),
 524                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
 525         { }             /* Terminating entry */
 526 };
 527 MODULE_DEVICE_TABLE(usb, smsusb_id_table);
 528
 529 static struct usb_driver smsusb_driver = {
 530         .name                   = "smsusb",
 531         .probe                  = smsusb_probe,
 532         .disconnect             = smsusb_disconnect,
 533         .id_table               = smsusb_id_table,
 534
 535         .suspend                = smsusb_suspend,
 536         .resume                 = smsusb_resume,
 537 };
 538
 539 int smsusb_module_init(void)
 540 {
 541         int rc = usb_register(&smsusb_driver);
 542         if (rc)
 543                 sms_err("usb_register failed. Error number %d", rc);
 544
 545         sms_debug("");
 546
 547         return rc;
 548 }
 549
 550 void smsusb_module_exit(void)
 551 {
 552         sms_debug("");
 553         /* Regular USB Cleanup */
 554         usb_deregister(&smsusb_driver);
 555 }
 556
 557 module_init(smsusb_module_init);
 558 module_exit(smsusb_module_exit);
 559
 560 MODULE_DESCRIPTION("Driver for the Siano SMS1XXX USB dongle");
 561 MODULE_AUTHOR("Siano Mobile Silicon, INC. (uris@siano-ms.com)");
 562 MODULE_LICENSE("GPL");