static int dvb_dvr_open(struct inode *inode, struct file *file)
 {
-       struct dvb_device *dvbdev=(struct dvb_device *) file->private_data;
-       struct dmxdev *dmxdev=(struct dmxdev *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dmxdev *dmxdev = dvbdev->priv;
        struct dmx_frontend *front;
 
        dprintk ("function : %s\n", __FUNCTION__);
 
 static int dvb_dvr_release(struct inode *inode, struct file *file)
 {
-       struct dvb_device *dvbdev=(struct dvb_device *) file->private_data;
-       struct dmxdev *dmxdev=(struct dmxdev *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dmxdev *dmxdev = dvbdev->priv;
 
        if (down_interruptible (&dmxdev->mutex))
                return -ERESTARTSYS;
 static ssize_t dvb_dvr_write(struct file *file, const char __user *buf,
                size_t count, loff_t *ppos)
 {
-       struct dvb_device *dvbdev=(struct dvb_device *) file->private_data;
-       struct dmxdev *dmxdev=(struct dmxdev *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dmxdev *dmxdev = dvbdev->priv;
        int ret;
 
        if (!dmxdev->demux->write)
 static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count,
                loff_t *ppos)
 {
-       struct dvb_device *dvbdev=(struct dvb_device *) file->private_data;
-       struct dmxdev *dmxdev=(struct dmxdev *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dmxdev *dmxdev = dvbdev->priv;
        int ret;
 
        //down(&dmxdev->mutex);
                            const u8 *buffer2, size_t buffer2_len,
                            struct dmx_section_filter *filter, enum dmx_success success)
 {
-       struct dmxdev_filter *dmxdevfilter=(struct dmxdev_filter *) filter->priv;
+       struct dmxdev_filter *dmxdevfilter = filter->priv;
        int ret;
 
        if (dmxdevfilter->buffer.error) {
                       const u8 *buffer2, size_t buffer2_len,
                       struct dmx_ts_feed *feed, enum dmx_success success)
 {
-       struct dmxdev_filter *dmxdevfilter=(struct dmxdev_filter *) feed->priv;
+       struct dmxdev_filter *dmxdevfilter = feed->priv;
        struct dmxdev_buffer *buffer;
        int ret;
 
 
 static int dvb_demux_open(struct inode *inode, struct file *file)
 {
-       struct dvb_device *dvbdev=(struct dvb_device *) file->private_data;
-       struct dmxdev *dmxdev=(struct dmxdev *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dmxdev *dmxdev = dvbdev->priv;
        int i;
        struct dmxdev_filter *dmxdevfilter;
 
 static int dvb_dvr_do_ioctl(struct inode *inode, struct file *file,
                     unsigned int cmd, void *parg)
 {
-       struct dvb_device *dvbdev=(struct dvb_device *) file->private_data;
-       struct dmxdev *dmxdev=(struct dmxdev *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dmxdev *dmxdev = dvbdev->priv;
 
        int ret=0;
 
 
 static unsigned int dvb_dvr_poll (struct file *file, poll_table *wait)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dmxdev *dmxdev = (struct dmxdev *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dmxdev *dmxdev = dvbdev->priv;
        unsigned int mask = 0;
 
        dprintk ("function : %s\n", __FUNCTION__);
 
  */
 void dvb_ca_en50221_camchange_irq(struct dvb_ca_en50221 *pubca, int slot, int change_type)
 {
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) pubca->private;
+       struct dvb_ca_private *ca = pubca->private;
 
        dprintk("CAMCHANGE IRQ slot:%i change_type:%i\n", slot, change_type);
 
  */
 void dvb_ca_en50221_camready_irq(struct dvb_ca_en50221 *pubca, int slot)
 {
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) pubca->private;
+       struct dvb_ca_private *ca = pubca->private;
 
        dprintk("CAMREADY IRQ slot:%i\n", slot);
 
  */
 void dvb_ca_en50221_frda_irq(struct dvb_ca_en50221 *pubca, int slot)
 {
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) pubca->private;
+       struct dvb_ca_private *ca = pubca->private;
        int flags;
 
        dprintk("FR/DA IRQ slot:%i\n", slot);
  */
 static int dvb_ca_en50221_thread(void *data)
 {
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) data;
+       struct dvb_ca_private *ca = data;
        char name[15];
        int slot;
        int flags;
 static int dvb_ca_en50221_io_do_ioctl(struct inode *inode, struct file *file,
                                      unsigned int cmd, void *parg)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dvb_ca_private *ca = dvbdev->priv;
        int err = 0;
        int slot;
 
                break;
 
        case CA_GET_CAP: {
-               struct ca_caps *caps = (struct ca_caps *) parg;
+               struct ca_caps *caps = parg;
 
                caps->slot_num = ca->slot_count;
                caps->slot_type = CA_CI_LINK;
        }
 
        case CA_GET_SLOT_INFO: {
-               struct ca_slot_info *info = (struct ca_slot_info *) parg;
+               struct ca_slot_info *info = parg;
 
                if ((info->num > ca->slot_count) || (info->num < 0))
                        return -EINVAL;
 static ssize_t dvb_ca_en50221_io_write(struct file *file,
                                       const char __user * buf, size_t count, loff_t * ppos)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dvb_ca_private *ca = dvbdev->priv;
        u8 slot, connection_id;
        int status;
        char fragbuf[HOST_LINK_BUF_SIZE];
 static ssize_t dvb_ca_en50221_io_read(struct file *file, char __user * buf,
                                      size_t count, loff_t * ppos)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dvb_ca_private *ca = dvbdev->priv;
        int status;
        int result = 0;
        u8 hdr[2];
  */
 static int dvb_ca_en50221_io_open(struct inode *inode, struct file *file)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dvb_ca_private *ca = dvbdev->priv;
        int err;
        int i;
 
  */
 static int dvb_ca_en50221_io_release(struct inode *inode, struct file *file)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dvb_ca_private *ca = dvbdev->priv;
        int err = 0;
 
        dprintk("%s\n", __FUNCTION__);
  */
 static unsigned int dvb_ca_en50221_io_poll(struct file *file, poll_table * wait)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dvb_ca_private *ca = dvbdev->priv;
        unsigned int mask = 0;
        int slot;
        int result = 0;
  */
 void dvb_ca_en50221_release(struct dvb_ca_en50221 *pubca)
 {
-       struct dvb_ca_private *ca = (struct dvb_ca_private *) pubca->private;
+       struct dvb_ca_private *ca = pubca->private;
        int i;
 
        dprintk("%s\n", __FUNCTION__);
 
 
 static void dvb_frontend_add_event(struct dvb_frontend *fe, fe_status_t status)
 {
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
        struct dvb_fe_events *events = &fepriv->events;
        struct dvb_frontend_event *e;
        int wp;
 static int dvb_frontend_get_event(struct dvb_frontend *fe,
                            struct dvb_frontend_event *event, int flags)
 {
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
        struct dvb_fe_events *events = &fepriv->events;
 
        dprintk ("%s\n", __FUNCTION__);
 {
        int autoinversion;
        int ready = 0;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
        int original_inversion = fepriv->parameters.inversion;
        u32 original_frequency = fepriv->parameters.frequency;
 
 
 static int dvb_frontend_is_exiting(struct dvb_frontend *fe)
 {
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
        if (fepriv->exit)
                return 1;
 
 static int dvb_frontend_should_wakeup(struct dvb_frontend *fe)
 {
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
        if (fepriv->wakeup) {
                fepriv->wakeup = 0;
 
 static void dvb_frontend_wakeup(struct dvb_frontend *fe)
 {
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
        fepriv->wakeup = 1;
        wake_up_interruptible(&fepriv->wait_queue);
  */
 static int dvb_frontend_thread(void *data)
 {
-       struct dvb_frontend *fe = (struct dvb_frontend *) data;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend *fe = data;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
        unsigned long timeout;
        char name [15];
        int quality = 0, delay = 3*HZ;
 static void dvb_frontend_stop(struct dvb_frontend *fe)
 {
        unsigned long ret;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
        dprintk ("%s\n", __FUNCTION__);
 
 static int dvb_frontend_start(struct dvb_frontend *fe)
 {
        int ret;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
        dprintk ("%s\n", __FUNCTION__);
 
 {
        struct dvb_device *dvbdev = file->private_data;
        struct dvb_frontend *fe = dvbdev->priv;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
        int err = -EOPNOTSUPP;
 
        dprintk ("%s\n", __FUNCTION__);
 
        switch (cmd) {
        case FE_GET_INFO: {
-               struct dvb_frontend_info* info = (struct dvb_frontend_info*) parg;
+               struct dvb_frontend_info* info = parg;
                memcpy(info, &fe->ops->info, sizeof(struct dvb_frontend_info));
 
                /* Force the CAN_INVERSION_AUTO bit on. If the frontend doesn't
 {
        struct dvb_device *dvbdev = file->private_data;
        struct dvb_frontend *fe = dvbdev->priv;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
        dprintk ("%s\n", __FUNCTION__);
 
 {
        struct dvb_device *dvbdev = file->private_data;
        struct dvb_frontend *fe = dvbdev->priv;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
        int ret;
 
        dprintk ("%s\n", __FUNCTION__);
 {
        struct dvb_device *dvbdev = file->private_data;
        struct dvb_frontend *fe = dvbdev->priv;
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
 
        dprintk ("%s\n", __FUNCTION__);
 
                up(&frontend_mutex);
                return -ENOMEM;
        }
-       fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       fepriv = fe->frontend_priv;
        memset(fe->frontend_priv, 0, sizeof(struct dvb_frontend_private));
 
        init_MUTEX (&fepriv->sem);
 
 int dvb_unregister_frontend(struct dvb_frontend* fe)
 {
-       struct dvb_frontend_private *fepriv = (struct dvb_frontend_private*) fe->frontend_priv;
+       struct dvb_frontend_private *fepriv = fe->frontend_priv;
        dprintk ("%s\n", __FUNCTION__);
 
        down (&frontend_mutex);
 
  */
 static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv *)dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
        unsigned long skipped = 0L;
        u8 *ts, *ts_end, *from_where = NULL, ts_remain = 0, how_much = 0, new_ts = 1;
        struct ethhdr *ethh = NULL;
                               const u8 *buffer2, size_t buffer2_len,
                               struct dmx_ts_feed *feed, enum dmx_success success)
 {
-       struct net_device *dev = (struct net_device *)feed->priv;
+       struct net_device *dev = feed->priv;
 
        if (buffer2 != 0)
                printk(KERN_WARNING "buffer2 not 0: %p.\n", buffer2);
                 struct dmx_section_filter *filter,
                 enum dmx_success success)
 {
-        struct net_device *dev=(struct net_device *) filter->priv;
+        struct net_device *dev = filter->priv;
 
        /**
         * we rely on the DVB API definition where exactly one complete
                   struct dmx_section_filter **secfilter,
                   u8 *mac, u8 *mac_mask)
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
        int ret;
 
        *secfilter=NULL;
 static int dvb_net_feed_start(struct net_device *dev)
 {
        int ret, i;
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
         struct dmx_demux *demux = priv->demux;
         unsigned char *mac = (unsigned char *) dev->dev_addr;
 
 
 static int dvb_net_feed_stop(struct net_device *dev)
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
        int i;
 
        dprintk("%s\n", __FUNCTION__);
 
 static int dvb_set_mc_filter (struct net_device *dev, struct dev_mc_list *mc)
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
 
        if (priv->multi_num == DVB_NET_MULTICAST_MAX)
                return -ENOMEM;
 static void wq_set_multicast_list (void *data)
 {
        struct net_device *dev = data;
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
 
        dvb_net_feed_stop(dev);
 
 
 static void dvb_net_set_multicast_list (struct net_device *dev)
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
        schedule_work(&priv->set_multicast_list_wq);
 }
 
 
 static int dvb_net_set_mac (struct net_device *dev, void *p)
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
        struct sockaddr *addr=p;
 
        memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 
 static int dvb_net_open(struct net_device *dev)
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
 
        priv->in_use++;
        dvb_net_feed_start(dev);
 
 static int dvb_net_stop(struct net_device *dev)
 {
-       struct dvb_net_priv *priv = (struct dvb_net_priv*) dev->priv;
+       struct dvb_net_priv *priv = dev->priv;
 
        priv->in_use--;
         return dvb_net_feed_stop(dev);
 static int dvb_net_do_ioctl(struct inode *inode, struct file *file,
                  unsigned int cmd, void *parg)
 {
-       struct dvb_device *dvbdev = (struct dvb_device *) file->private_data;
-       struct dvb_net *dvbnet = (struct dvb_net *) dvbdev->priv;
+       struct dvb_device *dvbdev = file->private_data;
+       struct dvb_net *dvbnet = dvbdev->priv;
 
        if (((file->f_flags&O_ACCMODE)==O_RDONLY))
                return -EPERM;
        switch (cmd) {
        case NET_ADD_IF:
        {
-               struct dvb_net_if *dvbnetif=(struct dvb_net_if *)parg;
+               struct dvb_net_if *dvbnetif = parg;
                int result;
 
                if (!capable(CAP_SYS_ADMIN))
        {
                struct net_device *netdev;
                struct dvb_net_priv *priv_data;
-               struct dvb_net_if *dvbnetif=(struct dvb_net_if *)parg;
+               struct dvb_net_if *dvbnetif = parg;
 
                if (dvbnetif->if_num >= DVB_NET_DEVICES_MAX ||
                    !dvbnet->state[dvbnetif->if_num])
 
                netdev = dvbnet->device[dvbnetif->if_num];
 
-               priv_data=(struct dvb_net_priv*)netdev->priv;
+               priv_data = netdev->priv;
                dvbnetif->pid=priv_data->pid;
                dvbnetif->feedtype=priv_data->feedtype;
                break;
        /* binary compatiblity cruft */
        case __NET_ADD_IF_OLD:
        {
-               struct __dvb_net_if_old *dvbnetif=(struct __dvb_net_if_old *)parg;
+               struct __dvb_net_if_old *dvbnetif = parg;
                int result;
 
                if (!capable(CAP_SYS_ADMIN))
        {
                struct net_device *netdev;
                struct dvb_net_priv *priv_data;
-               struct __dvb_net_if_old *dvbnetif=(struct __dvb_net_if_old *)parg;
+               struct __dvb_net_if_old *dvbnetif = parg;
 
                if (dvbnetif->if_num >= DVB_NET_DEVICES_MAX ||
                    !dvbnet->state[dvbnetif->if_num])
 
                netdev = dvbnet->device[dvbnetif->if_num];
 
-               priv_data=(struct dvb_net_priv*)netdev->priv;
+               priv_data = netdev->priv;
                dvbnetif->pid=priv_data->pid;
                break;
        }