drivers/media/dvb/siano/smsusb.c

   1 /*
   2  *  Driver for the Siano SMS10xx USB dongle
   3  *
   4  *  author: Anatoly Greenblat
   5  *
   6  *  Copyright (c), 2005-2008 Siano Mobile Silicon, Inc.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 3 as
  10  *  published by the Free Software Foundation;
  11  *
  12  *  Software distributed under the License is distributed on an "AS IS"
  13  *  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
  14  *
  15  *  See the 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, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  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
  29 #define USB1_BUFFER_SIZE                0x1000
  30 #define USB2_BUFFER_SIZE                0x4000
  31
  32 #define MAX_BUFFERS             50
  33 #define MAX_URBS                10
  34
  35 typedef struct _smsusb_device smsusb_device_t;
  36
  37 typedef struct _smsusb_urb
  38 {
  39         smscore_buffer_t *cb;
  40         smsusb_device_t *dev;
  41
  42         struct urb              urb;
  43 } smsusb_urb_t;
  44
  45 typedef struct _smsusb_device
  46 {
  47         struct usb_device *udev;
  48         smscore_device_t *coredev;
  49
  50         smsusb_urb_t    surbs[MAX_URBS];
  51
  52         int                             response_alignment;
  53         int                             buffer_size;
  54 } *psmsusb_device_t;
  55
  56 int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb);
  57
  58 void smsusb_onresponse(struct urb *urb)
  59 {
  60         smsusb_urb_t *surb = (smsusb_urb_t *) urb->context;
  61         smsusb_device_t *dev = surb->dev;
  62
  63         if (urb->status < 0)
  64         {
  65                 printk(KERN_INFO "%s error, urb status %d, %d bytes\n", __func__, urb->status, urb->actual_length);
  66                 return;
  67         }
  68
  69         if (urb->actual_length > 0)
  70         {
  71                 SmsMsgHdr_ST *phdr = (SmsMsgHdr_ST *) surb->cb->p;
  72
  73                 if (urb->actual_length >= phdr->msgLength)
  74                 {
  75                         surb->cb->size = phdr->msgLength;
  76
  77                         if (dev->response_alignment && (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG))
  78                         {
  79                                 surb->cb->offset = dev->response_alignment + ((phdr->msgFlags >> 8) & 3);
  80
  81                                 // sanity check
  82                                 if (((int) phdr->msgLength + surb->cb->offset) > urb->actual_length)
  83                                 {
  84                                         printk("%s: invalid response msglen %d offset %d size %d\n", __func__, phdr->msgLength, surb->cb->offset, urb->actual_length);
  85                                         goto exit_and_resubmit;
  86                                 }
  87
  88                                 // move buffer pointer and copy header to its new location
  89                                 memcpy((char *) phdr + surb->cb->offset,
  90                                        phdr, sizeof(SmsMsgHdr_ST));
  91                         }
  92                         else
  93                                 surb->cb->offset = 0;
  94
  95                         smscore_onresponse(dev->coredev, surb->cb);
  96                         surb->cb = NULL;
  97                 }
  98                 else
  99                 {
 100                         printk("%s invalid response msglen %d actual %d\n", __func__, phdr->msgLength, urb->actual_length);
 101                 }
 102         }
 103
 104 exit_and_resubmit:
 105         smsusb_submit_urb(dev, surb);
 106 }
 107
 108 int smsusb_submit_urb(smsusb_device_t *dev, smsusb_urb_t *surb)
 109 {
 110         if (!surb->cb)
 111         {
 112                 surb->cb = smscore_getbuffer(dev->coredev);
 113                 if (!surb->cb)
 114                 {
 115                         printk(KERN_INFO "%s smscore_getbuffer(...) returned NULL\n", __func__);
 116                         return -ENOMEM;
 117                 }
 118         }
 119
 120         usb_fill_bulk_urb(
 121                 &surb->urb,
 122                 dev->udev,
 123                 usb_rcvbulkpipe(dev->udev, 0x81),
 124                 surb->cb->p,
 125                 dev->buffer_size,
 126                 smsusb_onresponse,
 127                 surb
 128         );
 129         surb->urb.transfer_dma = surb->cb->phys;
 130         surb->urb.transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 131
 132         return usb_submit_urb(&surb->urb, GFP_ATOMIC);
 133 }
 134
 135 void smsusb_stop_streaming(smsusb_device_t *dev)
 136 {
 137         int i;
 138
 139         for (i = 0; i < MAX_URBS; i ++)
 140         {
 141                 usb_kill_urb(&dev->surbs[i].urb);
 142
 143                 if (dev->surbs[i].cb)
 144                 {
 145                         smscore_putbuffer(dev->coredev, dev->surbs[i].cb);
 146                         dev->surbs[i].cb = NULL;
 147                 }
 148         }
 149 }
 150
 151 int smsusb_start_streaming(smsusb_device_t *dev)
 152 {
 153         int i, rc;
 154
 155         for (i = 0; i < MAX_URBS; i ++)
 156         {
 157                 rc = smsusb_submit_urb(dev, &dev->surbs[i]);
 158                 if (rc < 0)
 159                 {
 160                         printk(KERN_INFO "%s smsusb_submit_urb(...) failed\n", __func__);
 161                         smsusb_stop_streaming(dev);
 162                         break;
 163                 }
 164         }
 165
 166         return rc;
 167 }
 168
 169 int smsusb_sendrequest(void *context, void *buffer, size_t size)
 170 {
 171         smsusb_device_t *dev = (smsusb_device_t *) context;
 172         int dummy;
 173
 174         return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2), buffer, size, &dummy, 1000);
 175 }
 176
 177 char *smsusb1_fw_lkup[] =
 178 {
 179         "dvbt_stellar_usb.inp",
 180         "dvbh_stellar_usb.inp",
 181         "tdmb_stellar_usb.inp",
 182         "none",
 183         "dvbt_bda_stellar_usb.inp",
 184 };
 185
 186 int smsusb1_load_firmware(struct usb_device *udev, int id)
 187 {
 188         const struct firmware *fw;
 189         u8 *fw_buffer;
 190         int rc, dummy;
 191
 192         if (id < DEVICE_MODE_DVBT || id > DEVICE_MODE_DVBT_BDA)
 193         {
 194                 printk(KERN_INFO "%s invalid firmware id specified %d\n", __func__, id);
 195                 return -EINVAL;
 196         }
 197
 198         rc = request_firmware(&fw, smsusb1_fw_lkup[id], &udev->dev);
 199         if (rc < 0)
 200         {
 201                 printk(KERN_INFO "%s failed to open \"%s\" mode %d\n", __func__, smsusb1_fw_lkup[id], id);
 202                 return rc;
 203         }
 204
 205         fw_buffer = kmalloc(fw->size, GFP_KERNEL);
 206         if (fw_buffer)
 207         {
 208                 memcpy(fw_buffer, fw->data, fw->size);
 209
 210                 rc = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 2), fw_buffer, fw->size, &dummy, 1000);
 211
 212                 printk(KERN_INFO "%s: sent %d(%d) bytes, rc %d\n", __func__, fw->size, dummy, rc);
 213
 214                 kfree(fw_buffer);
 215         }
 216         else
 217         {
 218                 printk(KERN_INFO "failed to allocate firmware buffer\n");
 219                 rc = -ENOMEM;
 220         }
 221
 222         release_firmware(fw);
 223
 224         return rc;
 225 }
 226
 227 void smsusb1_detectmode(void *context, int *mode)
 228 {
 229         char *product_string = ((smsusb_device_t *) context)->udev->product;
 230
 231         *mode = DEVICE_MODE_NONE;
 232
 233         if (!product_string)
 234         {
 235                 product_string = "none";
 236                 printk("%s product string not found\n", __func__);
 237         }
 238         else
 239         {
 240                 if (strstr(product_string, "DVBH"))
 241                         *mode = 1;
 242                 else if (strstr(product_string, "BDA"))
 243                         *mode = 4;
 244                 else if (strstr(product_string, "DVBT"))
 245                         *mode = 0;
 246                 else if (strstr(product_string, "TDMB"))
 247                         *mode = 2;
 248         }
 249
 250         printk("%s: %d \"%s\"\n", __func__, *mode, product_string);
 251 }
 252
 253 int smsusb1_setmode(void *context, int mode)
 254 {
 255         SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK, sizeof(SmsMsgHdr_ST), 0 };
 256
 257         if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA)
 258         {
 259                 printk(KERN_INFO "%s invalid firmware id specified %d\n", __func__, mode);
 260                 return -EINVAL;
 261         }
 262
 263         return smsusb_sendrequest(context, &Msg, sizeof(Msg));
 264 }
 265
 266 void smsusb_term_device(struct usb_interface *intf)
 267 {
 268         smsusb_device_t *dev = (smsusb_device_t *) usb_get_intfdata(intf);
 269
 270         if (dev)
 271         {
 272                 smsusb_stop_streaming(dev);
 273
 274                 // unregister from smscore
 275                 if (dev->coredev)
 276                         smscore_unregister_device(dev->coredev);
 277
 278                 kfree(dev);
 279
 280                 printk(KERN_INFO "%s device %p destroyed\n", __func__, dev);
 281         }
 282
 283         usb_set_intfdata(intf, NULL);
 284 }
 285
 286 int smsusb_init_device(struct usb_interface *intf)
 287 {
 288         smsdevice_params_t params;
 289         smsusb_device_t *dev;
 290         int i, rc;
 291
 292         // create device object
 293         dev = kzalloc(sizeof(smsusb_device_t), GFP_KERNEL);
 294         if (!dev)
 295         {
 296                 printk(KERN_INFO "%s kzalloc(sizeof(smsusb_device_t) failed\n", __func__);
 297                 return -ENOMEM;
 298         }
 299
 300         memset(&params, 0, sizeof(params));
 301         usb_set_intfdata(intf, dev);
 302         dev->udev = interface_to_usbdev(intf);
 303
 304         switch (dev->udev->descriptor.idProduct)
 305         {
 306                 case 0x100:
 307                         dev->buffer_size = USB1_BUFFER_SIZE;
 308
 309                         params.setmode_handler = smsusb1_setmode;
 310                         params.detectmode_handler = smsusb1_detectmode;
 311                         break;
 312
 313                 default:
 314                         dev->buffer_size = USB2_BUFFER_SIZE;
 315                         dev->response_alignment = dev->udev->ep_in[1]->desc.wMaxPacketSize - sizeof(SmsMsgHdr_ST);
 316
 317                         params.flags |= SMS_DEVICE_FAMILY2;
 318                         break;
 319         }
 320
 321         params.device = &dev->udev->dev;
 322         params.buffer_size = dev->buffer_size;
 323         params.num_buffers = MAX_BUFFERS;
 324         params.sendrequest_handler = smsusb_sendrequest;
 325         params.context = dev;
 326         snprintf(params.devpath, sizeof(params.devpath), "usb\\%d-%s", dev->udev->bus->busnum, dev->udev->devpath);
 327
 328         // register in smscore
 329         rc = smscore_register_device(&params, &dev->coredev);
 330         if (rc < 0)
 331         {
 332                 printk(KERN_INFO "%s smscore_register_device(...) failed, rc %d\n", __func__, rc);
 333                 smsusb_term_device(intf);
 334                 return rc;
 335         }
 336
 337         // initialize urbs
 338         for (i = 0; i < MAX_URBS; i ++)
 339         {
 340                 dev->surbs[i].dev = dev;
 341                 usb_init_urb(&dev->surbs[i].urb);
 342         }
 343
 344         rc = smsusb_start_streaming(dev);
 345         if (rc < 0)
 346         {
 347                 printk(KERN_INFO "%s smsusb_start_streaming(...) failed\n", __func__);
 348                 smsusb_term_device(intf);
 349                 return rc;
 350         }
 351
 352         rc = smscore_start_device(dev->coredev);
 353         if (rc < 0)
 354         {
 355                 printk(KERN_INFO "%s smscore_start_device(...) failed\n", __func__);
 356                 smsusb_term_device(intf);
 357                 return rc;
 358         }
 359
 360         printk(KERN_INFO "%s device %p created\n", __func__, dev);
 361
 362         return rc;
 363 }
 364
 365 int smsusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 366 {
 367         struct usb_device *udev = interface_to_usbdev(intf);
 368         char devpath[32];
 369         int i, rc;
 370
 371         if (intf->num_altsetting > 0)
 372         {
 373                 rc = usb_set_interface(udev, intf->cur_altsetting->desc.bInterfaceNumber, 0);
 374                 if (rc < 0)
 375                 {
 376                         printk(KERN_INFO "%s usb_set_interface failed, rc %d\n", __func__, rc);
 377                         return rc;
 378                 }
 379         }
 380
 381         printk(KERN_INFO "smsusb_probe %d\n", intf->cur_altsetting->desc.bInterfaceNumber);
 382         for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i ++)
 383                 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);
 384
 385         if (udev->actconfig->desc.bNumInterfaces == 2 && intf->cur_altsetting->desc.bInterfaceNumber == 0)
 386         {
 387                 printk(KERN_INFO "rom interface 0 is not used\n");
 388                 return -ENODEV;
 389         }
 390
 391         if (intf->cur_altsetting->desc.bInterfaceNumber == 1)
 392         {
 393                 snprintf(devpath, 32, "%d:%s", udev->bus->busnum, udev->devpath);
 394                 return smsusb1_load_firmware(udev, smscore_registry_getmode(devpath));
 395         }
 396
 397         return smsusb_init_device(intf);
 398 }
 399
 400 void smsusb_disconnect(struct usb_interface *intf)
 401 {
 402         smsusb_term_device(intf);
 403 }
 404
 405 static struct usb_device_id smsusb_id_table [] = {
 406         { USB_DEVICE(0x187F, 0x0010) },
 407         { USB_DEVICE(0x187F, 0x0100) },
 408         { USB_DEVICE(0x187F, 0x0200) },
 409         { }             /* Terminating entry */
 410 };
 411 MODULE_DEVICE_TABLE (usb, smsusb_id_table);
 412
 413 static struct usb_driver smsusb_driver = {
 414         .name                   = "smsusb",
 415         .probe                  = smsusb_probe,
 416         .disconnect     = smsusb_disconnect,
 417         .id_table               = smsusb_id_table,
 418 };
 419
 420 int smsusb_register(void)
 421 {
 422         int rc = usb_register(&smsusb_driver);
 423         if (rc)
 424                 printk(KERN_INFO "usb_register failed. Error number %d\n", rc);
 425
 426         printk(KERN_INFO "%s\n", __func__);
 427
 428         return rc;
 429 }
 430
 431 void smsusb_unregister(void)
 432 {
 433         /* Regular USB Cleanup */
 434         usb_deregister(&smsusb_driver);
 435         printk(KERN_INFO "%s\n", __func__);
 436 }
 437