drivers/media/mdtv/smsusb.c

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