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