drivers/media/mdtv/smsusb.c

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