1 files changed, 123 insertions, 35 deletions

diff --git a/drivers/media/usb/siano/smsusb.c b/drivers/media/usb/siano/smsusb.c
index de2c10289eec..03761c6f472f 100644
--- a/drivers/media/usb/siano/smsusb.c
+++ b/drivers/media/usb/siano/smsusb.c
@@ -35,16 +35,23 @@ module_param_named(debug, sms_dbg, int, 0644);
 MODULE_PARM_DESC(debug, "set debug level (info=1, adv=2 (or-able))");
 
 #define USB1_BUFFER_SIZE                0x1000
-#define USB2_BUFFER_SIZE                0x4000
+#define USB2_BUFFER_SIZE                0x2000
 
 #define MAX_BUFFERS             50
 #define MAX_URBS                10
 
 struct smsusb_device_t;
 
+enum smsusb_state {
+        SMSUSB_DISCONNECTED,
+        SMSUSB_SUSPENDED,
+        SMSUSB_ACTIVE
+};
+
 struct smsusb_urb_t {
+        struct list_head entry;
         struct smscore_buffer_t *cb;
-        struct smsusb_device_t  *dev;
+        struct smsusb_device_t *dev;
 
         struct urb urb;
 };
@@ -57,11 +64,23 @@ struct smsusb_device_t {
 
         int             response_alignment;
         int             buffer_size;
+
+        unsigned char in_ep;
+        unsigned char out_ep;
+        enum smsusb_state state;
 };
 
 static int smsusb_submit_urb(struct smsusb_device_t *dev,
                              struct smsusb_urb_t *surb);
 
+/**
+ * Completing URB's callback handler - top half (interrupt context)
+ * adds completing sms urb to the global surbs list and activtes the worker
+ * thread the surb
+ * IMPORTANT - blocking functions must not be called from here !!!
+
+ * @param urb pointer to a completing urb object
+ */
 static void smsusb_onresponse(struct urb *urb)
 {
         struct smsusb_urb_t *surb = (struct smsusb_urb_t *) urb->context;
@@ -74,26 +93,26 @@ static void smsusb_onresponse(struct urb *urb)
         }
 
         if ((urb->actual_length > 0) && (urb->status == 0)) {
-                struct SmsMsgHdr_ST *phdr = (struct SmsMsgHdr_ST *)surb->cb->p;
+                struct sms_msg_hdr *phdr = (struct sms_msg_hdr *)surb->cb->p;
 
                 smsendian_handle_message_header(phdr);
-                if (urb->actual_length >= phdr->msgLength) {
-                        surb->cb->size = phdr->msgLength;
+                if (urb->actual_length >= phdr->msg_length) {
+                        surb->cb->size = phdr->msg_length;
 
                         if (dev->response_alignment &&
-                            (phdr->msgFlags & MSG_HDR_FLAG_SPLIT_MSG)) {
+                            (phdr->msg_flags & MSG_HDR_FLAG_SPLIT_MSG)) {
 
                                 surb->cb->offset =
                                         dev->response_alignment +
-                                        ((phdr->msgFlags >> 8) & 3);
+                                        ((phdr->msg_flags >> 8) & 3);
 
                                 /* sanity check */
-                                if (((int) phdr->msgLength +
+                                if (((int) phdr->msg_length +
                                      surb->cb->offset) > urb->actual_length) {
                                         sms_err("invalid response "
                                                 "msglen %d offset %d "
                                                 "size %d",
-                                                phdr->msgLength,
+                                                phdr->msg_length,
                                                 surb->cb->offset,
                                                 urb->actual_length);
                                         goto exit_and_resubmit;
@@ -102,16 +121,22 @@ static void smsusb_onresponse(struct urb *urb)
                                 /* move buffer pointer and
                                  * copy header to its new location */
                                 memcpy((char *) phdr + surb->cb->offset,
-                                       phdr, sizeof(struct SmsMsgHdr_ST));
+                                       phdr, sizeof(struct sms_msg_hdr));
                         } else
                                 surb->cb->offset = 0;
 
+                        sms_debug("received %s(%d) size: %d",
+                                  smscore_translate_msg(phdr->msg_type),
+                                  phdr->msg_type, phdr->msg_length);
+
+                        smsendian_handle_rx_message((struct sms_msg_data *) phdr);
+
                         smscore_onresponse(dev->coredev, surb->cb);
                         surb->cb = NULL;
                 } else {
                         sms_err("invalid response "
                                 "msglen %d actual %d",
-                                phdr->msgLength, urb->actual_length);
+                                phdr->msg_length, urb->actual_length);
                 }
         } else
                 sms_err("error, urb status %d, %d bytes",
@@ -136,7 +161,7 @@ static int smsusb_submit_urb(struct smsusb_device_t *dev,
         usb_fill_bulk_urb(
                 &surb->urb,
                 dev->udev,
-                usb_rcvbulkpipe(dev->udev, 0x81),
+                usb_rcvbulkpipe(dev->udev, dev->in_ep),
                 surb->cb->p,
                 dev->buffer_size,
                 smsusb_onresponse,
@@ -181,9 +206,18 @@ static int smsusb_start_streaming(struct smsusb_device_t *dev)
 static int smsusb_sendrequest(void *context, void *buffer, size_t size)
 {
         struct smsusb_device_t *dev = (struct smsusb_device_t *) context;
+        struct sms_msg_hdr *phdr = (struct sms_msg_hdr *) buffer;
         int dummy;
 
-        smsendian_handle_message_header((struct SmsMsgHdr_ST *)buffer);
+        if (dev->state != SMSUSB_ACTIVE)
+                return -ENOENT;
+
+        sms_debug("sending %s(%d) size: %d",
+                  smscore_translate_msg(phdr->msg_type), phdr->msg_type,
+                  phdr->msg_length);
+
+        smsendian_handle_tx_message((struct sms_msg_data *) phdr);
+        smsendian_handle_message_header((struct sms_msg_hdr *)buffer);
         return usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, 2),
                             buffer, size, &dummy, 1000);
 }
@@ -276,15 +310,15 @@ static void smsusb1_detectmode(void *context, int *mode)
 
 static int smsusb1_setmode(void *context, int mode)
 {
-        struct SmsMsgHdr_ST Msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,
-                             sizeof(struct SmsMsgHdr_ST), 0 };
+        struct sms_msg_hdr msg = { MSG_SW_RELOAD_REQ, 0, HIF_TASK,
+                             sizeof(struct sms_msg_hdr), 0 };
 
         if (mode < DEVICE_MODE_DVBT || mode > DEVICE_MODE_DVBT_BDA) {
                 sms_err("invalid firmware id specified %d", mode);
                 return -EINVAL;
         }
 
-        return smsusb_sendrequest(context, &Msg, sizeof(Msg));
+        return smsusb_sendrequest(context, &msg, sizeof(msg));
 }
 
 static void smsusb_term_device(struct usb_interface *intf)
@@ -292,13 +326,15 @@ static void smsusb_term_device(struct usb_interface *intf)
         struct smsusb_device_t *dev = usb_get_intfdata(intf);
 
         if (dev) {
+                dev->state = SMSUSB_DISCONNECTED;
+
                 smsusb_stop_streaming(dev);
 
                 /* unregister from smscore */
                 if (dev->coredev)
                         smscore_unregister_device(dev->coredev);
 
-                sms_info("device %p destroyed", dev);
+                sms_info("device 0x%p destroyed", dev);
                 kfree(dev);
         }
 
@@ -321,6 +357,7 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
         memset(&params, 0, sizeof(params));
         usb_set_intfdata(intf, dev);
         dev->udev = interface_to_usbdev(intf);
+        dev->state = SMSUSB_DISCONNECTED;
 
         params.device_type = sms_get_board(board_id)->type;
 
@@ -331,21 +368,29 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
                 params.setmode_handler = smsusb1_setmode;
                 params.detectmode_handler = smsusb1_detectmode;
                 break;
-        default:
+        case SMS_UNKNOWN_TYPE:
                 sms_err("Unspecified sms device type!");
                 /* fall-thru */
-        case SMS_NOVA_A0:
-        case SMS_NOVA_B0:
-        case SMS_VEGA:
+        default:
                 dev->buffer_size = USB2_BUFFER_SIZE;
                 dev->response_alignment =
                     le16_to_cpu(dev->udev->ep_in[1]->desc.wMaxPacketSize) -
-                    sizeof(struct SmsMsgHdr_ST);
+                    sizeof(struct sms_msg_hdr);
 
                 params.flags |= SMS_DEVICE_FAMILY2;
                 break;
         }
 
+        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
+                if (intf->cur_altsetting->endpoint[i].desc. bEndpointAddress & USB_DIR_IN)
+                        dev->in_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
+                else
+                        dev->out_ep = intf->cur_altsetting->endpoint[i].desc.bEndpointAddress;
+        }
+
+        sms_info("in_ep = %02x, out_ep = %02x",
+                dev->in_ep, dev->out_ep);
+
         params.device = &dev->udev->dev;
         params.buffer_size = dev->buffer_size;
         params.num_buffers = MAX_BUFFERS;
@@ -363,6 +408,8 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
 
         smscore_set_board_id(dev->coredev, board_id);
 
+        dev->coredev->is_usb_device = true;
+
         /* initialize urbs */
         for (i = 0; i < MAX_URBS; i++) {
                 dev->surbs[i].dev = dev;
@@ -377,6 +424,8 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
                 return rc;
         }
 
+        dev->state = SMSUSB_ACTIVE;
+
         rc = smscore_start_device(dev->coredev);
         if (rc < 0) {
                 sms_err("smscore_start_device(...) failed");
@@ -384,7 +433,7 @@ static int smsusb_init_device(struct usb_interface *intf, int board_id)
                 return rc;
         }
 
-        sms_info("device %p created", dev);
+        sms_info("device 0x%p created", dev);
 
         return rc;
 }
@@ -396,12 +445,21 @@ static int smsusb_probe(struct usb_interface *intf,
         char devpath[32];
         int i, rc;
 
-        rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81));
-        rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02));
+        sms_info("interface number %d",
+                 intf->cur_altsetting->desc.bInterfaceNumber);
 
-        if (intf->num_altsetting > 0) {
-                rc = usb_set_interface(
-                        udev, intf->cur_altsetting->desc.bInterfaceNumber, 0);
+        if (sms_get_board(id->driver_info)->intf_num !=
+            intf->cur_altsetting->desc.bInterfaceNumber) {
+                sms_err("interface number is %d expecting %d",
+                        sms_get_board(id->driver_info)->intf_num,
+                        intf->cur_altsetting->desc.bInterfaceNumber);
+                return -ENODEV;
+        }
+
+        if (intf->num_altsetting > 1) {
+                rc = usb_set_interface(udev,
+                                       intf->cur_altsetting->desc.bInterfaceNumber,
+                                       0);
                 if (rc < 0) {
                         sms_err("usb_set_interface failed, rc %d", rc);
                         return rc;
@@ -410,19 +468,27 @@ static int smsusb_probe(struct usb_interface *intf,
 
         sms_info("smsusb_probe %d",
                intf->cur_altsetting->desc.bInterfaceNumber);
-        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
+        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
                 sms_info("endpoint %d %02x %02x %d", i,
                        intf->cur_altsetting->endpoint[i].desc.bEndpointAddress,
                        intf->cur_altsetting->endpoint[i].desc.bmAttributes,
                        intf->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
-
+                if (intf->cur_altsetting->endpoint[i].desc.bEndpointAddress &
+                    USB_DIR_IN)
+                        rc = usb_clear_halt(udev, usb_rcvbulkpipe(udev,
+                                intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
+                else
+                        rc = usb_clear_halt(udev, usb_sndbulkpipe(udev,
+                                intf->cur_altsetting->endpoint[i].desc.bEndpointAddress));
+        }
         if ((udev->actconfig->desc.bNumInterfaces == 2) &&
             (intf->cur_altsetting->desc.bInterfaceNumber == 0)) {
                 sms_err("rom interface 0 is not used");
                 return -ENODEV;
         }
 
-        if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
+        if (id->driver_info == SMS1XXX_BOARD_SIANO_STELLAR_ROM) {
+                sms_info("stellar device was found.");
                 snprintf(devpath, sizeof(devpath), "usb\\%d-%s",
                          udev->bus->busnum, udev->devpath);
                 sms_info("stellar device was found.");
@@ -445,7 +511,9 @@ static void smsusb_disconnect(struct usb_interface *intf)
 static int smsusb_suspend(struct usb_interface *intf, pm_message_t msg)
 {
         struct smsusb_device_t *dev = usb_get_intfdata(intf);
-        printk(KERN_INFO "%s: Entering status %d.\n", __func__, msg.event);
+        printk(KERN_INFO "%s  Entering status %d.\n", __func__, msg.event);
+        dev->state = SMSUSB_SUSPENDED;
+        /*smscore_set_power_mode(dev, SMS_POWER_MODE_SUSPENDED);*/
         smsusb_stop_streaming(dev);
         return 0;
 }
@@ -456,9 +524,9 @@ static int smsusb_resume(struct usb_interface *intf)
         struct smsusb_device_t *dev = usb_get_intfdata(intf);
         struct usb_device *udev = interface_to_usbdev(intf);
 
-        printk(KERN_INFO "%s: Entering.\n", __func__);
-        usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x81));
-        usb_clear_halt(udev, usb_rcvbulkpipe(udev, 0x02));
+        printk(KERN_INFO "%s  Entering.\n", __func__);
+        usb_clear_halt(udev, usb_rcvbulkpipe(udev, dev->in_ep));
+        usb_clear_halt(udev, usb_sndbulkpipe(udev, dev->out_ep));
 
         for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++)
                 printk(KERN_INFO "endpoint %d %02x %02x %d\n", i,
@@ -546,6 +614,26 @@ static const struct usb_device_id smsusb_id_table[] = {
                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
         { USB_DEVICE(0x2040, 0xf5a0),
                 .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM },
+        { USB_DEVICE(0x187f, 0x0202),
+                .driver_info = SMS1XXX_BOARD_SIANO_NICE },
+        { USB_DEVICE(0x187f, 0x0301),
+                .driver_info = SMS1XXX_BOARD_SIANO_VENICE },
+        { USB_DEVICE(0x187f, 0x0302),
+                .driver_info = SMS1XXX_BOARD_SIANO_VENICE },
+        { USB_DEVICE(0x187f, 0x0310),
+                .driver_info = SMS1XXX_BOARD_SIANO_MING },
+        { USB_DEVICE(0x187f, 0x0500),
+                .driver_info = SMS1XXX_BOARD_SIANO_PELE },
+        { USB_DEVICE(0x187f, 0x0600),
+                .driver_info = SMS1XXX_BOARD_SIANO_RIO },
+        { USB_DEVICE(0x187f, 0x0700),
+                .driver_info = SMS1XXX_BOARD_SIANO_DENVER_2160 },
+        { USB_DEVICE(0x187f, 0x0800),
+                .driver_info = SMS1XXX_BOARD_SIANO_DENVER_1530 },
+        { USB_DEVICE(0x19D2, 0x0086),
+                .driver_info = SMS1XXX_BOARD_ZTE_DVB_DATA_CARD },
+        { USB_DEVICE(0x19D2, 0x0078),
+                .driver_info = SMS1XXX_BOARD_ONDA_MDTV_DATA_CARD },
         { } /* Terminating entry */
         };