/* interrupt out endpoint 2 every 1 millisecond */
 #define UNUSED_REPORT          23
 
+#define MAX_REPORT_SIZE                64
+
 
 
 /**************************************************************************
  */
 static int si470x_get_report(struct si470x_device *radio, void *buf, int size)
 {
-       unsigned char *report = (unsigned char *) buf;
+       unsigned char *report = buf;
        int retval;
 
        retval = usb_control_msg(radio->usbdev,
  */
 static int si470x_set_report(struct si470x_device *radio, void *buf, int size)
 {
-       unsigned char *report = (unsigned char *) buf;
+       unsigned char *report = buf;
        int retval;
 
        retval = usb_control_msg(radio->usbdev,
  */
 int si470x_get_register(struct si470x_device *radio, int regnr)
 {
-       unsigned char buf[REGISTER_REPORT_SIZE];
        int retval;
 
-       buf[0] = REGISTER_REPORT(regnr);
+       radio->usb_buf[0] = REGISTER_REPORT(regnr);
 
-       retval = si470x_get_report(radio, (void *) &buf, sizeof(buf));
+       retval = si470x_get_report(radio, radio->usb_buf, REGISTER_REPORT_SIZE);
 
        if (retval >= 0)
-               radio->registers[regnr] = get_unaligned_be16(&buf[1]);
+               radio->registers[regnr] = get_unaligned_be16(&radio->usb_buf[1]);
 
        return (retval < 0) ? -EINVAL : 0;
 }
  */
 int si470x_set_register(struct si470x_device *radio, int regnr)
 {
-       unsigned char buf[REGISTER_REPORT_SIZE];
        int retval;
 
-       buf[0] = REGISTER_REPORT(regnr);
-       put_unaligned_be16(radio->registers[regnr], &buf[1]);
+       radio->usb_buf[0] = REGISTER_REPORT(regnr);
+       put_unaligned_be16(radio->registers[regnr], &radio->usb_buf[1]);
 
-       retval = si470x_set_report(radio, (void *) &buf, sizeof(buf));
+       retval = si470x_set_report(radio, radio->usb_buf, REGISTER_REPORT_SIZE);
 
        return (retval < 0) ? -EINVAL : 0;
 }
  */
 static int si470x_get_all_registers(struct si470x_device *radio)
 {
-       unsigned char buf[ENTIRE_REPORT_SIZE];
        int retval;
        unsigned char regnr;
 
-       buf[0] = ENTIRE_REPORT;
+       radio->usb_buf[0] = ENTIRE_REPORT;
 
-       retval = si470x_get_report(radio, (void *) &buf, sizeof(buf));
+       retval = si470x_get_report(radio, radio->usb_buf, ENTIRE_REPORT_SIZE);
 
        if (retval >= 0)
                for (regnr = 0; regnr < RADIO_REGISTER_NUM; regnr++)
                        radio->registers[regnr] = get_unaligned_be16(
-                               &buf[regnr * RADIO_REGISTER_SIZE + 1]);
+                               &radio->usb_buf[regnr * RADIO_REGISTER_SIZE + 1]);
 
        return (retval < 0) ? -EINVAL : 0;
 }
 static int si470x_set_led_state(struct si470x_device *radio,
                unsigned char led_state)
 {
-       unsigned char buf[LED_REPORT_SIZE];
        int retval;
 
-       buf[0] = LED_REPORT;
-       buf[1] = LED_COMMAND;
-       buf[2] = led_state;
+       radio->usb_buf[0] = LED_REPORT;
+       radio->usb_buf[1] = LED_COMMAND;
+       radio->usb_buf[2] = led_state;
 
-       retval = si470x_set_report(radio, (void *) &buf, sizeof(buf));
+       retval = si470x_set_report(radio, radio->usb_buf, LED_REPORT_SIZE);
 
        return (retval < 0) ? -EINVAL : 0;
 }
  */
 static int si470x_get_scratch_page_versions(struct si470x_device *radio)
 {
-       unsigned char buf[SCRATCH_REPORT_SIZE];
        int retval;
 
-       buf[0] = SCRATCH_REPORT;
+       radio->usb_buf[0] = SCRATCH_REPORT;
 
-       retval = si470x_get_report(radio, (void *) &buf, sizeof(buf));
+       retval = si470x_get_report(radio, radio->usb_buf, SCRATCH_REPORT_SIZE);
 
        if (retval < 0)
                dev_warn(&radio->intf->dev, "si470x_get_scratch: "
                        "si470x_get_report returned %d\n", retval);
        else {
-               radio->software_version = buf[1];
-               radio->hardware_version = buf[2];
+               radio->software_version = radio->usb_buf[1];
+               radio->hardware_version = radio->usb_buf[2];
        }
 
        return (retval < 0) ? -EINVAL : 0;
        v4l2_device_unregister(&radio->v4l2_dev);
        kfree(radio->int_in_buffer);
        kfree(radio->buffer);
+       kfree(radio->usb_buf);
        kfree(radio);
 }
 
                retval = -ENOMEM;
                goto err_initial;
        }
+       radio->usb_buf = kmalloc(MAX_REPORT_SIZE, GFP_KERNEL);
+       if (radio->usb_buf == NULL) {
+               retval = -ENOMEM;
+               goto err_radio;
+       }
        radio->usbdev = interface_to_usbdev(intf);
        radio->intf = intf;
        radio->band = 1; /* Default to 76 - 108 MHz */
        if (!radio->int_in_endpoint) {
                dev_info(&intf->dev, "could not find interrupt in endpoint\n");
                retval = -EIO;
-               goto err_radio;
+               goto err_usbbuf;
        }
 
        int_end_size = le16_to_cpu(radio->int_in_endpoint->wMaxPacketSize);
        if (!radio->int_in_buffer) {
                dev_info(&intf->dev, "could not allocate int_in_buffer");
                retval = -ENOMEM;
-               goto err_radio;
+               goto err_usbbuf;
        }
 
        radio->int_in_urb = usb_alloc_urb(0, GFP_KERNEL);
        usb_free_urb(radio->int_in_urb);
 err_intbuffer:
        kfree(radio->int_in_buffer);
+err_usbbuf:
+       kfree(radio->usb_buf);
 err_radio:
        kfree(radio);
 err_initial: