/*
  * Alsa Constructor - Component probe
  */
-int tm6000_audio_init(struct tm6000_core *dev)
+static int tm6000_audio_init(struct tm6000_core *dev)
 {
        struct snd_card         *card;
        struct snd_tm6000_card  *chip;
        return 0;
 }
 
-struct tm6000_ops audio_ops = {
+static struct tm6000_ops audio_ops = {
        .type   = TM6000_AUDIO,
        .name   = "TM6000 Audio Extension",
        .init   = tm6000_audio_init,
 
        char            *ir_codes;
 };
 
-struct tm6000_board tm6000_boards[] = {
+static struct tm6000_board tm6000_boards[] = {
        [TM6000_BOARD_UNKNOWN] = {
                .name         = "Unknown tm6000 video grabber",
                .caps = {
                        .has_zl10353    = 1,
                        .has_eeprom     = 1,
                        .has_remote     = 1,
-                       .has_radio      = 1.
+                       .has_radio      = 1,
                },
                .gpio = {
                        .tuner_reset    = TM6010_GPIO_0,
 };
 
 /* table of devices that work with this driver */
-struct usb_device_id tm6000_id_table[] = {
+static struct usb_device_id tm6000_id_table[] = {
        { USB_DEVICE(0x6000, 0x0001), .driver_info = TM5600_BOARD_GENERIC },
        { USB_DEVICE(0x6000, 0x0002), .driver_info = TM6010_BOARD_GENERIC },
        { USB_DEVICE(0x06e1, 0xf332), .driver_info = TM6000_BOARD_ADSTECH_DUAL_TV },
        { USB_DEVICE(0x13d3, 0x3264), .driver_info = TM6010_BOARD_TWINHAN_TU501 },
        { USB_DEVICE(0x6000, 0xdec2), .driver_info = TM6010_BOARD_BEHOLD_WANDER_LITE },
        { USB_DEVICE(0x6000, 0xdec3), .driver_info = TM6010_BOARD_BEHOLD_VOYAGER_LITE },
-       { },
+       { }
 };
 
 /* Control power led for show some activity */
 
 int tm6000_cards_setup(struct tm6000_core *dev)
 {
-       int i, rc;
-
        /*
         * Board-specific initialization sequence. Handles all GPIO
         * initialization sequences that are board-specific.
         */
 
        if (dev->gpio.tuner_reset) {
+               int rc;
+               int i;
+
                for (i = 0; i < 2; i++) {
                        rc = tm6000_set_reg(dev, REQ_03_SET_GET_MCU_PIN,
                                                dev->gpio.tuner_reset, 0x00);
        snprintf(dev->name, 29, "tm6000 #%d", nr);
 
        dev->model = id->driver_info;
-       if ((card[nr] >= 0) && (card[nr] < ARRAY_SIZE(tm6000_boards)))
+       if (card[nr] < ARRAY_SIZE(tm6000_boards))
                dev->model = card[nr];
 
        dev->udev = usbdev;
                speed = "unknown";
        }
 
-
-
        /* Get endpoints */
        for (i = 0; i < interface->num_altsetting; i++) {
                int ep;
        printk(KERN_INFO "tm6000: Found %s\n", tm6000_boards[dev->model].name);
 
        rc = tm6000_init_dev(dev);
-
        if (rc < 0)
                goto err;
 
 
        if (len)
                data = kzalloc(len, GFP_KERNEL);
 
-
        if (req_type & USB_DIR_IN)
                pipe = usb_rcvctrlpipe(dev->udev, 0);
        else {
                        printk(">>> ");
                        for (i = 0; i < len; i++)
                                printk(" %02x", buf[i]);
-               printk("\n");
+                       printk("\n");
                }
        }
 
         * FIXME: This is a hack! xc3028 "sleeps" when no channel is detected
         * for more than a few seconds. Not sure why, as this behavior does
         * not happen on other devices with xc3028. So, I suspect that it
-        * is yet another bug at tm6000. After start sleeping, decoding 
+        * is yet another bug at tm6000. After start sleeping, decoding
         * doesn't start automatically. Instead, it requires some
         * I2C commands to wake it up. As we want to have image at the
         * beginning, we needed to add this hack. The better would be to
 };
 
 /* The meaning of those initializations are unknown */
-struct reg_init tm6000_init_tab[] = {
+static struct reg_init tm6000_init_tab[] = {
        /* REG  VALUE */
        { TM6000_REQ07_RDF_PWDOWN_ACLK, 0x1f },
        { TM6010_REQ07_RFF_SOFT_RESET, 0x08 },
        { TM6010_REQ05_R18_IMASK7, 0x00 },
 };
 
-struct reg_init tm6010_init_tab[] = {
+static struct reg_init tm6010_init_tab[] = {
        { TM6010_REQ07_RC0_ACTIVE_VIDEO_SOURCE, 0x00 },
        { TM6010_REQ07_RC4_HSTART0, 0xa0 },
        { TM6010_REQ07_RC6_HEND0, 0x40 },
        return 0;
 }
 
-void tm6010_set_mute_sif(struct tm6000_core *dev, u8 mute)
+static void tm6010_set_mute_sif(struct tm6000_core *dev, u8 mute)
 {
        u8 mute_reg = 0;
 
        tm6000_set_reg_mask(dev, TM6010_REQ08_R0A_A_I2S_MOD, mute_reg, 0x08);
 }
 
-void tm6010_set_mute_adc(struct tm6000_core *dev, u8 mute)
+static void tm6010_set_mute_adc(struct tm6000_core *dev, u8 mute)
 {
        u8 mute_reg = 0;
 
        return 0;
 }
 
-void tm6010_set_volume_sif(struct tm6000_core *dev, int vol)
+static void tm6010_set_volume_sif(struct tm6000_core *dev, int vol)
 {
        u8 vol_reg;
 
        tm6000_set_reg(dev, TM6010_REQ08_R08_A_RIGHT_VOL, vol_reg);
 }
 
-void tm6010_set_volume_adc(struct tm6000_core *dev, int vol)
+static void tm6010_set_volume_adc(struct tm6000_core *dev, int vol)
 {
        u8 vol_reg;
 
 
        }
 }
 
-int tm6000_start_stream(struct tm6000_core *dev)
+static int tm6000_start_stream(struct tm6000_core *dev)
 {
        int ret;
        unsigned int pipe, size;
        return 0;
 }
 
-void tm6000_stop_stream(struct tm6000_core *dev)
+static void tm6000_stop_stream(struct tm6000_core *dev)
 {
        struct tm6000_dvb *dvb = dev->dvb;
 
        }
 }
 
-int tm6000_start_feed(struct dvb_demux_feed *feed)
+static int tm6000_start_feed(struct dvb_demux_feed *feed)
 {
        struct dvb_demux *demux = feed->demux;
        struct tm6000_core *dev = demux->priv;
        return 0;
 }
 
-int tm6000_stop_feed(struct dvb_demux_feed *feed)
+static int tm6000_stop_feed(struct dvb_demux_feed *feed)
 {
        struct dvb_demux *demux = feed->demux;
        struct tm6000_core *dev = demux->priv;
        return 0;
 }
 
-int tm6000_dvb_attach_frontend(struct tm6000_core *dev)
+static int tm6000_dvb_attach_frontend(struct tm6000_core *dev)
 {
        struct tm6000_dvb *dvb = dev->dvb;
 
 
 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 
-int register_dvb(struct tm6000_core *dev)
+static int register_dvb(struct tm6000_core *dev)
 {
        int ret = -1;
        struct tm6000_dvb *dvb = dev->dvb;
        return ret;
 }
 
-void unregister_dvb(struct tm6000_core *dev)
+static void unregister_dvb(struct tm6000_core *dev)
 {
        struct tm6000_dvb *dvb = dev->dvb;
 
 
        cancel_delayed_work_sync(&ir->work);
 }
 
-int tm6000_ir_change_protocol(struct rc_dev *rc, u64 rc_type)
+static int tm6000_ir_change_protocol(struct rc_dev *rc, u64 rc_type)
 {
        struct tm6000_IR *ir = rc->priv;
 
 
 #include "tm6000.h"
 #include "tm6000-regs.h"
 
-static unsigned int tm6010_a_mode = 0;
+static unsigned int tm6010_a_mode;
 module_param(tm6010_a_mode, int, 0644);
 MODULE_PARM_DESC(tm6010_a_mode, "set tm6010 sif audio mode");
 
 
        msleep(40);
 
-
        return 0;
 }
 
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
+
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
        wake_up(&buf->vb.done);
 }
 
-const char *tm6000_msg_type[] = {
-       "unknown(0)",   /* 0 */
-       "video",        /* 1 */
-       "audio",        /* 2 */
-       "vbi",          /* 3 */
-       "pts",          /* 4 */
-       "err",          /* 5 */
-       "unknown(6)",   /* 6 */
-       "unknown(7)",   /* 7 */
-};
-
 /*
  * Identify the tm5600/6000 buffer header type and properly handles
  */
                        if (size > TM6000_URB_MSG_LEN)
                                size = TM6000_URB_MSG_LEN;
                        pktsize = TM6000_URB_MSG_LEN;
-                       /* calculate position in buffer
-                        * and change the buffer
+                       /*
+                        * calculate position in buffer and change the buffer
                         */
                        switch (cmd) {
                        case TM6000_URB_MSG_VIDEO:
                                if (!dev->radio) {
                                        if ((dev->isoc_ctl.vfield != field) &&
                                                (field == 1)) {
-                                       /* Announces that a new buffer
-                                        * were filled
-                                        */
+                                               /*
+                                                * Announces that a new buffer
+                                                * were filled
+                                                */
                                                buffer_filled(dev, dma_q, vbuf);
                                                dprintk(dev, V4L2_DEBUG_ISOC,
                                                        "new buffer filled\n");
                                break;
                        case TM6000_URB_MSG_AUDIO:
                        case TM6000_URB_MSG_PTS:
-                               size = pktsize;         /* Size is always 180 bytes */
+                               size = pktsize; /* Size is always 180 bytes */
                                break;
                        }
                } else {
                        }
                }
                if (ptr + pktsize > endp) {
-                       /* End of URB packet, but cmd processing is not
+                       /*
+                        * End of URB packet, but cmd processing is not
                         * complete. Preserve the state for a next packet
                         */
                        dev->isoc_ctl.pos = pos + cpysize;
 
 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
 {
-       struct tm6000_fh  *fh = priv;
-       struct tm6000_core *dev    = fh->dev;
+       struct tm6000_fh *fh = priv;
+       struct tm6000_core *dev = fh->dev;
 
        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
 
 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 {
-       struct tm6000_fh  *fh = priv;
-       struct tm6000_core *dev    = fh->dev;
+       struct tm6000_fh *fh = priv;
+       struct tm6000_core *dev = fh->dev;
 
        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
+
        if (i != fh->type)
                return -EINVAL;
 
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
 {
        int rc = 0;
-       struct tm6000_fh   *fh = priv;
+       struct tm6000_fh *fh = priv;
        struct tm6000_core *dev = fh->dev;
 
        dev->norm = *norm;
        int i, rc;
        int radio = 0;
 
-       printk(KERN_INFO "tm6000: open called (dev=%s)\n",
-               video_device_node_name(vdev));
-
        dprintk(dev, V4L2_DEBUG_OPEN, "tm6000: open called (dev=%s)\n",
                video_device_node_name(vdev));
 
 
        tm6000_get_std_res(dev);
 
-       fh->width    = dev->width;
-       fh->height   = dev->height;
+       fh->width = dev->width;
+       fh->height = dev->height;
 
        dprintk(dev, V4L2_DEBUG_OPEN, "Open: fh=0x%08lx, dev=0x%08lx, "
                                                "dev->vidq=0x%08lx\n",
-               (unsigned long)fh, (unsigned long)dev, (unsigned long)&dev->vidq);
+                       (unsigned long)fh, (unsigned long)dev,
+                       (unsigned long)&dev->vidq);
        dprintk(dev, V4L2_DEBUG_OPEN, "Open: list_empty "
                                "queued=%d\n", list_empty(&dev->vidq.queued));
        dprintk(dev, V4L2_DEBUG_OPEN, "Open: list_empty "
                buf = list_entry(fh->vb_vidq.stream.next, struct tm6000_buffer, vb.stream);
        } else {
                /* read() capture */
-               return videobuf_poll_stream(file, &fh->vb_vidq,
-                                           wait);
+               return videobuf_poll_stream(file, &fh->vb_vidq, wait);
        }
        poll_wait(file, &buf->vb.done, wait);
        if (buf->vb.state == VIDEOBUF_DONE ||
 
 static int tm6000_mmap(struct file *file, struct vm_area_struct * vma)
 {
-       struct tm6000_fh        *fh = file->private_data;
-       int ret;
-
-       ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
+       struct tm6000_fh *fh = file->private_data;
 
-       return ret;
+       return videobuf_mmap_mapper(&fh->vb_vidq, vma);
 }
 
 static struct v4l2_file_operations tm6000_fops = {
-       .owner          = THIS_MODULE,
-       .open           = tm6000_open,
-       .release        = tm6000_release,
-       .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
-       .read           = tm6000_read,
-       .poll           = tm6000_poll,
-       .mmap           = tm6000_mmap,
+       .owner = THIS_MODULE,
+       .open = tm6000_open,
+       .release = tm6000_release,
+       .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
+       .read = tm6000_read,
+       .poll = tm6000_poll,
+       .mmap = tm6000_mmap,
 };
 
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
        .vidioc_s_frequency     = vidioc_s_frequency,
 };
 
-struct video_device tm6000_radio_template = {
+static struct video_device tm6000_radio_template = {
        .name                   = "tm6000",
        .fops                   = &radio_fops,
        .ioctl_ops              = &radio_ioctl_ops,
 
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-/* Use the tm6000-hack, instead of the proper initialization code i*/
-/* #define HACK 1 */
-
 #include <linux/videodev2.h>
 #include <media/v4l2-common.h>
 #include <media/videobuf-vmalloc.h>
 #include <linux/i2c.h>
 #include <linux/mutex.h>
 #include <media/v4l2-device.h>
-#include <linux/version.h>
+
 #include <linux/dvb/frontend.h>
 #include "dvb_demux.h"
 #include "dvb_frontend.h"