11 files changed, 361 insertions, 377 deletions

diff --git a/linux/drivers/media/dvb/dvb-core/Kconfig b/linux/drivers/media/dvb/dvb-core/Kconfig
index 7dc3511c7..a9a7b3421 100644
--- a/linux/drivers/media/dvb/dvb-core/Kconfig
+++ b/linux/drivers/media/dvb/dvb-core/Kconfig
@@ -8,4 +8,4 @@ config DVB_CORE
 	  to build your drivers outside the kernel, but need the DVB core. All 
 	  in-kernel drivers will select this automatically if needed.
 	  If unsure say N.
- 
+
diff --git a/linux/drivers/media/dvb/dvb-core/demux.h b/linux/drivers/media/dvb/dvb-core/demux.h
index 806c4e656..fb55eaa5c 100644
--- a/linux/drivers/media/dvb/dvb-core/demux.h
+++ b/linux/drivers/media/dvb/dvb-core/demux.h
@@ -1,8 +1,8 @@
-/* 
- * demux.h 
+/*
+ * demux.h
  *
  * Copyright (c) 2002 Convergence GmbH
- * 
+ *
  * based on code:
  * Copyright (c) 2000 Nokia Research Center
  *                    Tampere, FINLAND
@@ -23,56 +23,56 @@
  *
  */
 
-#ifndef __DEMUX_H 
-#define __DEMUX_H 
+#ifndef __DEMUX_H
+#define __DEMUX_H
 
 #include <linux/types.h>
 #include <linux/errno.h>
-#include <linux/list.h> 
-#include <linux/time.h> 
+#include <linux/list.h>
+#include <linux/time.h>
 
-/*--------------------------------------------------------------------------*/ 
-/* Common definitions */ 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
+/* Common definitions */
+/*--------------------------------------------------------------------------*/
 
 /*
  * DMX_MAX_FILTER_SIZE: Maximum length (in bytes) of a section/PES filter.
- */ 
+ */
 
-#ifndef DMX_MAX_FILTER_SIZE 
+#ifndef DMX_MAX_FILTER_SIZE
 #define DMX_MAX_FILTER_SIZE 18
-#endif 
+#endif
 
 /*
  * DMX_MAX_SECFEED_SIZE: Maximum length (in bytes) of a private section feed filter.
- */ 
+ */
 
-#ifndef DMX_MAX_SECFEED_SIZE 
+#ifndef DMX_MAX_SECFEED_SIZE
 #define DMX_MAX_SECFEED_SIZE 4096
-#endif 
+#endif
 
 
 /*
- * enum dmx_success: Success codes for the Demux Callback API. 
- */ 
-
-enum dmx_success { 
-  DMX_OK = 0, /* Received Ok */ 
-  DMX_LENGTH_ERROR, /* Incorrect length */ 
-  DMX_OVERRUN_ERROR, /* Receiver ring buffer overrun */ 
-  DMX_CRC_ERROR, /* Incorrect CRC */ 
-  DMX_FRAME_ERROR, /* Frame alignment error */ 
-  DMX_FIFO_ERROR, /* Receiver FIFO overrun */ 
-  DMX_MISSED_ERROR /* Receiver missed packet */ 
-} ; 
-
-/*--------------------------------------------------------------------------*/ 
-/* TS packet reception */ 
+ * enum dmx_success: Success codes for the Demux Callback API.
+ */
+
+enum dmx_success {
+  DMX_OK = 0, /* Received Ok */
+  DMX_LENGTH_ERROR, /* Incorrect length */
+  DMX_OVERRUN_ERROR, /* Receiver ring buffer overrun */
+  DMX_CRC_ERROR, /* Incorrect CRC */
+  DMX_FRAME_ERROR, /* Frame alignment error */
+  DMX_FIFO_ERROR, /* Receiver FIFO overrun */
+  DMX_MISSED_ERROR /* Receiver missed packet */
+} ;
+
+/*--------------------------------------------------------------------------*/
+/* TS packet reception */
 /*--------------------------------------------------------------------------*/
 
 /* TS filter type for set() */
 
-#define TS_PACKET       1   /* send TS packets (188 bytes) to callback (default) */ 
+#define TS_PACKET       1   /* send TS packets (188 bytes) to callback (default) */
 #define	TS_PAYLOAD_ONLY 2   /* in case TS_PACKET is set, only send the TS
 			       payload (<=184 bytes per packet) to callback */
 #define TS_DECODER      4   /* send stream to built-in decoder (if present) */
@@ -116,38 +116,38 @@ enum dmx_ts_pes
 #define DMX_TS_PES_PCR      DMX_TS_PES_PCR0
 
 
-struct dmx_ts_feed { 
+struct dmx_ts_feed {
         int is_filtering; /* Set to non-zero when filtering in progress */
         struct dmx_demux *parent; /* Back-pointer */
-        void *priv; /* Pointer to private data of the API client */ 
-        int (*set) (struct dmx_ts_feed *feed, 
+        void *priv; /* Pointer to private data of the API client */
+        int (*set) (struct dmx_ts_feed *feed,
 		    u16 pid,
-		    int type, 
+		    int type,
 		    enum dmx_ts_pes pes_type,
-		    size_t callback_length, 
-		    size_t circular_buffer_size, 
-		    int descramble, 
-		    struct timespec timeout); 
-        int (*start_filtering) (struct dmx_ts_feed* feed); 
-        int (*stop_filtering) (struct dmx_ts_feed* feed); 
+		    size_t callback_length,
+		    size_t circular_buffer_size,
+		    int descramble,
+		    struct timespec timeout);
+        int (*start_filtering) (struct dmx_ts_feed* feed);
+        int (*stop_filtering) (struct dmx_ts_feed* feed);
 };
 
-/*--------------------------------------------------------------------------*/ 
-/* Section reception */ 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
+/* Section reception */
+/*--------------------------------------------------------------------------*/
 
-struct dmx_section_filter { 
-        u8 filter_value [DMX_MAX_FILTER_SIZE]; 
-        u8 filter_mask [DMX_MAX_FILTER_SIZE]; 
-        u8 filter_mode [DMX_MAX_FILTER_SIZE]; 
-        struct dmx_section_feed* parent; /* Back-pointer */ 
-        void* priv; /* Pointer to private data of the API client */ 
+struct dmx_section_filter {
+        u8 filter_value [DMX_MAX_FILTER_SIZE];
+        u8 filter_mask [DMX_MAX_FILTER_SIZE];
+        u8 filter_mode [DMX_MAX_FILTER_SIZE];
+        struct dmx_section_feed* parent; /* Back-pointer */
+        void* priv; /* Pointer to private data of the API client */
 };
 
-struct dmx_section_feed { 
-        int is_filtering; /* Set to non-zero when filtering in progress */ 
+struct dmx_section_feed {
+        int is_filtering; /* Set to non-zero when filtering in progress */
         struct dmx_demux* parent; /* Back-pointer */
-        void* priv; /* Pointer to private data of the API client */ 
+        void* priv; /* Pointer to private data of the API client */
 
         int check_crc;
 	u32 crc_val;
@@ -156,42 +156,42 @@ struct dmx_section_feed {
         u8 secbuf_base[DMX_MAX_SECFEED_SIZE];
         u16 secbufp, seclen, tsfeedp;
 
-        int (*set) (struct dmx_section_feed* feed, 
-		    u16 pid, 
-		    size_t circular_buffer_size, 
-		    int descramble, 
-		    int check_crc); 
-        int (*allocate_filter) (struct dmx_section_feed* feed, 
-				struct dmx_section_filter** filter); 
-        int (*release_filter) (struct dmx_section_feed* feed, 
-			       struct dmx_section_filter* filter); 
-        int (*start_filtering) (struct dmx_section_feed* feed); 
-        int (*stop_filtering) (struct dmx_section_feed* feed); 
+        int (*set) (struct dmx_section_feed* feed,
+		    u16 pid,
+		    size_t circular_buffer_size,
+		    int descramble,
+		    int check_crc);
+        int (*allocate_filter) (struct dmx_section_feed* feed,
+				struct dmx_section_filter** filter);
+        int (*release_filter) (struct dmx_section_feed* feed,
+			       struct dmx_section_filter* filter);
+        int (*start_filtering) (struct dmx_section_feed* feed);
+        int (*stop_filtering) (struct dmx_section_feed* feed);
 };
 
-/*--------------------------------------------------------------------------*/ 
-/* Callback functions */ 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
+/* Callback functions */
+/*--------------------------------------------------------------------------*/
 
-typedef int (*dmx_ts_cb) ( const u8 * buffer1, 
+typedef int (*dmx_ts_cb) ( const u8 * buffer1,
 			   size_t buffer1_length,
-			   const u8 * buffer2, 
+			   const u8 * buffer2,
 			   size_t buffer2_length,
-			   struct dmx_ts_feed* source, 
-			   enum dmx_success success); 
+			   struct dmx_ts_feed* source,
+			   enum dmx_success success);
 
 typedef int (*dmx_section_cb) (	const u8 * buffer1,
 				size_t buffer1_len,
-				const u8 * buffer2, 
+				const u8 * buffer2,
 				size_t buffer2_len,
-			       	struct dmx_section_filter * source,
-			       	enum dmx_success success);
+				struct dmx_section_filter * source,
+				enum dmx_success success);
 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /* DVB Front-End */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 
-enum dmx_frontend_source { 
+enum dmx_frontend_source {
 	DMX_MEMORY_FE,
 	DMX_FRONTEND_0,
 	DMX_FRONTEND_1,
@@ -201,84 +201,84 @@ enum dmx_frontend_source {
 	DMX_STREAM_1,
 	DMX_STREAM_2,
 	DMX_STREAM_3
-}; 
+};
 
-struct dmx_frontend { 
-        struct list_head connectivity_list; /* List of front-ends that can 
-					       be connected to a particular 
-					       demux */ 
-        void* priv;     /* Pointer to private data of the API client */ 
+struct dmx_frontend {
+        struct list_head connectivity_list; /* List of front-ends that can
+					       be connected to a particular
+					       demux */
+        void* priv;     /* Pointer to private data of the API client */
         enum dmx_frontend_source source;
 };
 
-/*--------------------------------------------------------------------------*/ 
-/* MPEG-2 TS Demux */ 
-/*--------------------------------------------------------------------------*/ 
-
-/* 
- * Flags OR'ed in the capabilites field of struct dmx_demux. 
- */ 
-
-#define DMX_TS_FILTERING                        1 
-#define DMX_PES_FILTERING                       2 
-#define DMX_SECTION_FILTERING                   4 
-#define DMX_MEMORY_BASED_FILTERING              8    /* write() available */ 
-#define DMX_CRC_CHECKING                        16 
-#define DMX_TS_DESCRAMBLING                     32 
-#define DMX_SECTION_PAYLOAD_DESCRAMBLING        64 
-#define DMX_MAC_ADDRESS_DESCRAMBLING            128 
-
-/* 
- * Demux resource type identifier. 
-*/ 
-
-/* 
- * DMX_FE_ENTRY(): Casts elements in the list of registered 
+/*--------------------------------------------------------------------------*/
+/* MPEG-2 TS Demux */
+/*--------------------------------------------------------------------------*/
+
+/*
+ * Flags OR'ed in the capabilites field of struct dmx_demux.
+ */
+
+#define DMX_TS_FILTERING                        1
+#define DMX_PES_FILTERING                       2
+#define DMX_SECTION_FILTERING                   4
+#define DMX_MEMORY_BASED_FILTERING              8    /* write() available */
+#define DMX_CRC_CHECKING                        16
+#define DMX_TS_DESCRAMBLING                     32
+#define DMX_SECTION_PAYLOAD_DESCRAMBLING        64
+#define DMX_MAC_ADDRESS_DESCRAMBLING            128
+
+/*
+ * Demux resource type identifier.
+*/
+
+/*
+ * DMX_FE_ENTRY(): Casts elements in the list of registered
  * front-ends from the generic type struct list_head
  * to the type * struct dmx_frontend
- *. 
+ *.
 */
 
-#define DMX_FE_ENTRY(list) list_entry(list, struct dmx_frontend, connectivity_list) 
+#define DMX_FE_ENTRY(list) list_entry(list, struct dmx_frontend, connectivity_list)
 
-struct dmx_demux { 
-        u32 capabilities;            /* Bitfield of capability flags */ 
-        struct dmx_frontend* frontend;    /* Front-end connected to the demux */ 
+struct dmx_demux {
+        u32 capabilities;            /* Bitfield of capability flags */
+        struct dmx_frontend* frontend;    /* Front-end connected to the demux */
         struct list_head reg_list;   /* List of registered demuxes */
-        void* priv;                  /* Pointer to private data of the API client */ 
+        void* priv;                  /* Pointer to private data of the API client */
         int users;                   /* Number of users */
-        int (*open) (struct dmx_demux* demux); 
-        int (*close) (struct dmx_demux* demux); 
-        int (*write) (struct dmx_demux* demux, const char* buf, size_t count); 
-        int (*allocate_ts_feed) (struct dmx_demux* demux, 
-				 struct dmx_ts_feed** feed, 
-				 dmx_ts_cb callback); 
-        int (*release_ts_feed) (struct dmx_demux* demux, 
-				struct dmx_ts_feed* feed); 
-        int (*allocate_section_feed) (struct dmx_demux* demux, 
-				      struct dmx_section_feed** feed, 
-				      dmx_section_cb callback); 
+        int (*open) (struct dmx_demux* demux);
+        int (*close) (struct dmx_demux* demux);
+        int (*write) (struct dmx_demux* demux, const char* buf, size_t count);
+        int (*allocate_ts_feed) (struct dmx_demux* demux,
+				 struct dmx_ts_feed** feed,
+				 dmx_ts_cb callback);
+        int (*release_ts_feed) (struct dmx_demux* demux,
+				struct dmx_ts_feed* feed);
+        int (*allocate_section_feed) (struct dmx_demux* demux,
+				      struct dmx_section_feed** feed,
+				      dmx_section_cb callback);
         int (*release_section_feed) (struct dmx_demux* demux,
-				     struct dmx_section_feed* feed); 
-        int (*descramble_mac_address) (struct dmx_demux* demux, 
-				       u8* buffer1, 
-				       size_t buffer1_length, 
-				       u8* buffer2, 
+				     struct dmx_section_feed* feed);
+        int (*descramble_mac_address) (struct dmx_demux* demux,
+				       u8* buffer1,
+				       size_t buffer1_length,
+				       u8* buffer2,
 				       size_t buffer2_length,
-				       u16 pid); 
+				       u16 pid);
         int (*descramble_section_payload) (struct dmx_demux* demux,
-					   u8* buffer1, 
+					   u8* buffer1,
 					   size_t buffer1_length,
 					   u8* buffer2, size_t buffer2_length,
-					   u16 pid); 
-        int (*add_frontend) (struct dmx_demux* demux, 
-			     struct dmx_frontend* frontend); 
+					   u16 pid);
+        int (*add_frontend) (struct dmx_demux* demux,
+			     struct dmx_frontend* frontend);
         int (*remove_frontend) (struct dmx_demux* demux,
-				struct dmx_frontend* frontend); 
-        struct list_head* (*get_frontends) (struct dmx_demux* demux); 
-        int (*connect_frontend) (struct dmx_demux* demux, 
-				 struct dmx_frontend* frontend); 
-        int (*disconnect_frontend) (struct dmx_demux* demux); 
+				struct dmx_frontend* frontend);
+        struct list_head* (*get_frontends) (struct dmx_demux* demux);
+        int (*connect_frontend) (struct dmx_demux* demux,
+				 struct dmx_frontend* frontend);
+        int (*disconnect_frontend) (struct dmx_demux* demux);
 
         int (*get_pes_pids) (struct dmx_demux* demux, u16 *pids);
 
@@ -286,17 +286,16 @@ struct dmx_demux {
 			u64 *stc, unsigned int *base);
 };
 
-/*--------------------------------------------------------------------------*/ 
-/* Demux directory */ 
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
+/* Demux directory */
+/*--------------------------------------------------------------------------*/
 
-/* 
- * DMX_DIR_ENTRY(): Casts elements in the list of registered 
+/*
+ * DMX_DIR_ENTRY(): Casts elements in the list of registered
  * demuxes from the generic type struct list_head* to the type struct dmx_demux
- *. 
- */ 
+ *.
+ */
 
 #define DMX_DIR_ENTRY(list) list_entry(list, struct dmx_demux, reg_list)
 
 #endif /* #ifndef __DEMUX_H */
-
diff --git a/linux/drivers/media/dvb/dvb-core/dmxdev.c b/linux/drivers/media/dvb/dvb-core/dmxdev.c
index d3c774b3d..7d26f91e9 100644
--- a/linux/drivers/media/dvb/dvb-core/dmxdev.c
+++ b/linux/drivers/media/dvb/dvb-core/dmxdev.c
@@ -1,5 +1,5 @@
-/* 
- * dmxdev.c - DVB demultiplexer device 
+/*
+ * dmxdev.c - DVB demultiplexer device
  *
  * Copyright (C) 2000 Ralph  Metzler <ralph@convergence.de>
  *		  & Marcus Metzler <marcus@convergence.de>
@@ -48,7 +48,7 @@ dvb_dmxdev_file_to_filter(struct file *file)
 	return (struct dmxdev_filter *) file->private_data;
 }
 
-static inline void dvb_dmxdev_buffer_init(struct dmxdev_buffer *buffer) 
+static inline void dvb_dmxdev_buffer_init(struct dmxdev_buffer *buffer)
 {
 	buffer->data=NULL;
 	buffer->size=8192;
@@ -58,7 +58,7 @@ static inline void dvb_dmxdev_buffer_init(struct dmxdev_buffer *buffer)
 	init_waitqueue_head(&buffer->queue);
 }
 
-static inline int dvb_dmxdev_buffer_write(struct dmxdev_buffer *buf, const u8 *src, int len) 
+static inline int dvb_dmxdev_buffer_write(struct dmxdev_buffer *buf, const u8 *src, int len)
 {
 	int split;
 	int free;
@@ -68,7 +68,7 @@ static inline int dvb_dmxdev_buffer_write(struct dmxdev_buffer *buf, const u8 *s
 		return 0;
 	if (!buf->data)
 		return 0;
-	
+
 	free=buf->pread-buf->pwrite;
 	split=0;
 	if (free<=0) {
@@ -97,14 +97,14 @@ static ssize_t dvb_dmxdev_buffer_read(struct dmxdev_buffer *src,
 {
 	unsigned long todo=count;
 	int split, avail, error;
-	
+
 	if (!src->data)
 		return 0;
 
 	if ((error=src->error)) {
 		src->pwrite=src->pread;
 		src->error=0;
-		return error; 
+		return error;
 	}
 
 	if (non_blocking && (src->pwrite==src->pread))
@@ -122,9 +122,9 @@ static ssize_t dvb_dmxdev_buffer_read(struct dmxdev_buffer *src,
 		if ((error=src->error)) {
 			src->pwrite=src->pread;
 			src->error=0;
-			return error; 
+			return error;
 		}
-		
+
 		split=src->size;
 		avail=src->pwrite - src->pread;
 		if (avail<0) {
@@ -162,7 +162,7 @@ static struct dmx_frontend * get_fe(struct dmx_demux *demux, int type)
 	list_for_each(pos, head)
 		if (DMX_FE_ENTRY(pos)->source==type)
 			return DMX_FE_ENTRY(pos);
-	
+
 	return NULL;
 }
 
@@ -183,7 +183,7 @@ static int dvb_dvr_open(struct inode *inode, struct file *file)
 
 	if (down_interruptible (&dmxdev->mutex))
 		return -ERESTARTSYS;
-	
+
 	if ((file->f_flags&O_ACCMODE)==O_RDWR) {
 		if (!(dmxdev->capabilities&DMXDEV_CAP_DUPLEX)) {
 			up(&dmxdev->mutex);
@@ -203,20 +203,20 @@ static int dvb_dvr_open(struct inode *inode, struct file *file)
 
 	if ((file->f_flags&O_ACCMODE)==O_WRONLY) {
 		dmxdev->dvr_orig_fe=dmxdev->demux->frontend;
-		
+
 		if (!dmxdev->demux->write) {
 			up(&dmxdev->mutex);
 			return -EOPNOTSUPP;
 		}
-		
+
 		front=get_fe(dmxdev->demux, DMX_MEMORY_FE);
-		
+
 		if (!front) {
 			up(&dmxdev->mutex);
 			return -EINVAL;
 		}
-		dmxdev->demux->disconnect_frontend(dmxdev->demux);	
-		dmxdev->demux->connect_frontend(dmxdev->demux, front);	
+		dmxdev->demux->disconnect_frontend(dmxdev->demux);
+		dmxdev->demux->connect_frontend(dmxdev->demux, front);
 	}
 	up(&dmxdev->mutex);
 	return 0;
@@ -231,8 +231,8 @@ static int dvb_dvr_release(struct inode *inode, struct file *file)
 		return -ERESTARTSYS;
 
 	if ((file->f_flags&O_ACCMODE)==O_WRONLY) {
-		dmxdev->demux->disconnect_frontend(dmxdev->demux);	
-		dmxdev->demux->connect_frontend(dmxdev->demux, 
+		dmxdev->demux->disconnect_frontend(dmxdev->demux);
+		dmxdev->demux->connect_frontend(dmxdev->demux,
 						dmxdev->dvr_orig_fe);
 	}
 	if ((file->f_flags&O_ACCMODE)==O_RDONLY) {
@@ -275,8 +275,8 @@ static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count,
 	int ret;
 
 	//down(&dmxdev->mutex);
-	ret= dvb_dmxdev_buffer_read(&dmxdev->dvr_buffer, 
-			      file->f_flags&O_NONBLOCK, 
+	ret= dvb_dmxdev_buffer_read(&dmxdev->dvr_buffer,
+			      file->f_flags&O_NONBLOCK,
 			      buf, count, ppos);
 	//up(&dmxdev->mutex);
 	return ret;
@@ -302,11 +302,11 @@ static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter *dmxdevfilter, unsign
 	mem=buf->data;
 	buf->data=NULL;
 	buf->size=size;
-	buf->pwrite=buf->pread=0;    
+	buf->pwrite=buf->pread=0;
 	spin_unlock_irq(&dmxdevfilter->dev->lock);
-	if (mem) 
+	if (mem)
 		vfree(mem);
-		
+
 	if (buf->size) {
 		mem=vmalloc(dmxdevfilter->buffer.size);
 		if (!mem)
@@ -321,7 +321,7 @@ static int dvb_dmxdev_set_buffer_size(struct dmxdev_filter *dmxdevfilter, unsign
 static void dvb_dmxdev_filter_timeout(unsigned long data)
 {
 	struct dmxdev_filter *dmxdevfilter=(struct dmxdev_filter *)data;
-	
+
 	dmxdevfilter->buffer.error=-ETIMEDOUT;
 	spin_lock_irq(&dmxdevfilter->dev->lock);
 	dmxdevfilter->state=DMXDEV_STATE_TIMEDOUT;
@@ -332,7 +332,7 @@ static void dvb_dmxdev_filter_timeout(unsigned long data)
 static void dvb_dmxdev_filter_timer(struct dmxdev_filter *dmxdevfilter)
 {
 	struct dmx_sct_filter_params *para=&dmxdevfilter->params.sec;
-  
+
 	del_timer(&dmxdevfilter->timer);
 	if (para->timeout) {
 		dmxdevfilter->timer.function=dvb_dmxdev_filter_timeout;
@@ -348,7 +348,7 @@ static int dvb_dmxdev_section_callback(const u8 *buffer1, size_t buffer1_len,
 {
 	struct dmxdev_filter *dmxdevfilter=(struct dmxdev_filter *) filter->priv;
 	int ret;
-	
+
 	if (dmxdevfilter->buffer.error) {
 		wake_up(&dmxdevfilter->buffer.queue);
 		return 0;
@@ -359,16 +359,16 @@ static int dvb_dmxdev_section_callback(const u8 *buffer1, size_t buffer1_len,
 		return 0;
 	}
 	del_timer(&dmxdevfilter->timer);
-	dprintk("dmxdev: section callback %02x %02x %02x %02x %02x %02x\n", 
-		buffer1[0], buffer1[1], 
-		buffer1[2], buffer1[3], 
+	dprintk("dmxdev: section callback %02x %02x %02x %02x %02x %02x\n",
+		buffer1[0], buffer1[1],
+		buffer1[2], buffer1[3],
 		buffer1[4], buffer1[5]);
 	ret=dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer1, buffer1_len);
 	if (ret==buffer1_len) {
 		ret=dvb_dmxdev_buffer_write(&dmxdevfilter->buffer, buffer2, buffer2_len);
 	}
 	if (ret<0) {
-		dmxdevfilter->buffer.pwrite=dmxdevfilter->buffer.pread;    
+		dmxdevfilter->buffer.pwrite=dmxdevfilter->buffer.pread;
 		dmxdevfilter->buffer.error=-EOVERFLOW;
 	}
 	if (dmxdevfilter->params.sec.flags&DMX_ONESHOT)
@@ -385,7 +385,7 @@ static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len,
 	struct dmxdev_filter *dmxdevfilter=(struct dmxdev_filter *) feed->priv;
 	struct dmxdev_buffer *buffer;
 	int ret;
-	
+
 	spin_lock(&dmxdevfilter->dev->lock);
 	if (dmxdevfilter->params.pes.output==DMX_OUT_DECODER) {
 		spin_unlock(&dmxdevfilter->dev->lock);
@@ -402,10 +402,10 @@ static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len,
 		return 0;
 	}
 	ret=dvb_dmxdev_buffer_write(buffer, buffer1, buffer1_len);
-	if (ret==buffer1_len) 
+	if (ret==buffer1_len)
 		ret=dvb_dmxdev_buffer_write(buffer, buffer2, buffer2_len);
 	if (ret<0) {
-		buffer->pwrite=buffer->pread;    
+		buffer->pwrite=buffer->pread;
 		buffer->error=-EOVERFLOW;
 	}
 	spin_unlock(&dmxdevfilter->dev->lock);
@@ -456,7 +456,7 @@ static int dvb_dmxdev_feed_start(struct dmxdev_filter *filter)
 }
 
 
-/* restart section feed if it has filters left associated with it, 
+/* restart section feed if it has filters left associated with it,
    otherwise release the feed */
 
 static int dvb_dmxdev_feed_restart(struct dmxdev_filter *filter)
@@ -464,15 +464,15 @@ static int dvb_dmxdev_feed_restart(struct dmxdev_filter *filter)
 	int i;
 	struct dmxdev *dmxdev = filter->dev;
 	u16 pid = filter->params.sec.pid;
-	
-	for (i=0; i<dmxdev->filternum; i++) 
+
+	for (i=0; i<dmxdev->filternum; i++)
 		if (dmxdev->filter[i].state>=DMXDEV_STATE_GO &&
 		    dmxdev->filter[i].type==DMXDEV_TYPE_SEC &&
 		    dmxdev->filter[i].pid==pid) {
 			dvb_dmxdev_feed_start(&dmxdev->filter[i]);
 			return 0;
 		}
-	
+
 	filter->dev->demux->release_section_feed(dmxdev->demux, filter->feed.sec);
 
 	return 0;
@@ -480,7 +480,7 @@ static int dvb_dmxdev_feed_restart(struct dmxdev_filter *filter)
 
 static int dvb_dmxdev_filter_stop(struct dmxdev_filter *dmxdevfilter)
 {
-	if (dmxdevfilter->state<DMXDEV_STATE_GO) 
+	if (dmxdevfilter->state<DMXDEV_STATE_GO)
 		return 0;
 
 	switch (dmxdevfilter->type) {
@@ -505,17 +505,17 @@ static int dvb_dmxdev_filter_stop(struct dmxdev_filter *dmxdevfilter)
 		dmxdevfilter->feed.ts=NULL;
 		break;
 	default:
-		if (dmxdevfilter->state==DMXDEV_STATE_ALLOCATED) 
+		if (dmxdevfilter->state==DMXDEV_STATE_ALLOCATED)
 			return 0;
 		return -EINVAL;
 	}
-	dmxdevfilter->buffer.pwrite=dmxdevfilter->buffer.pread=0;    
+	dmxdevfilter->buffer.pwrite=dmxdevfilter->buffer.pread=0;
 	return 0;
 }
 
 static inline int dvb_dmxdev_filter_reset(struct dmxdev_filter *dmxdevfilter)
 {
-	if (dmxdevfilter->state<DMXDEV_STATE_SET) 
+	if (dmxdevfilter->state<DMXDEV_STATE_SET)
 		return 0;
 
 	dmxdevfilter->type=DMXDEV_TYPE_NONE;
@@ -530,11 +530,11 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 	void *mem;
 	int ret, i;
 
-	if (filter->state < DMXDEV_STATE_SET) 
+	if (filter->state < DMXDEV_STATE_SET)
 		return -EINVAL;
 
 	if (filter->state >= DMXDEV_STATE_GO)
-		dvb_dmxdev_filter_stop(filter); 
+		dvb_dmxdev_filter_stop(filter);
 
 	if (!(mem = filter->buffer.data)) {
 		mem = vmalloc(filter->buffer.size);
@@ -560,27 +560,27 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 		/* find active filter/feed with same PID */
 		for (i=0; i<dmxdev->filternum; i++) {
 			if (dmxdev->filter[i].state >= DMXDEV_STATE_GO &&
-			    dmxdev->filter[i].pid == para->pid && 
+			    dmxdev->filter[i].pid == para->pid &&
 			    dmxdev->filter[i].type == DMXDEV_TYPE_SEC) {
 				*secfeed = dmxdev->filter[i].feed.sec;
 				break;
 			}
 		}
 
-		/* if no feed found, try to allocate new one */ 
+		/* if no feed found, try to allocate new one */
 		if (!*secfeed) {
-			ret=dmxdev->demux->allocate_section_feed(dmxdev->demux, 
-								 secfeed, 
+			ret=dmxdev->demux->allocate_section_feed(dmxdev->demux,
+								 secfeed,
 						   dvb_dmxdev_section_callback);
 			if (ret<0) {
 				printk ("DVB (%s): could not alloc feed\n",
 					__FUNCTION__);
 				return ret;
 			}
-			
-			ret=(*secfeed)->set(*secfeed, para->pid, 32768, 0, 
+
+			ret=(*secfeed)->set(*secfeed, para->pid, 32768, 0,
 					    (para->flags & DMX_CHECK_CRC) ? 1 : 0);
-			
+
 			if (ret<0) {
 				printk ("DVB (%s): could not set feed\n",
 					__FUNCTION__);
@@ -590,7 +590,7 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 		} else {
 			dvb_dmxdev_feed_stop(filter);
 		}
-			
+
 		ret=(*secfeed)->allocate_filter(*secfeed, secfilter);
 
 		if (ret < 0) {
@@ -602,11 +602,11 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 
 		(*secfilter)->priv = filter;
 
-		memcpy(&((*secfilter)->filter_value[3]), 
+		memcpy(&((*secfilter)->filter_value[3]),
 		       &(para->filter.filter[1]), DMX_FILTER_SIZE-1);
-		memcpy(&(*secfilter)->filter_mask[3], 
+		memcpy(&(*secfilter)->filter_mask[3],
 		       &para->filter.mask[1], DMX_FILTER_SIZE-1);
-		memcpy(&(*secfilter)->filter_mode[3], 
+		memcpy(&(*secfilter)->filter_mode[3],
 		       &para->filter.mode[1], DMX_FILTER_SIZE-1);
 
 		(*secfilter)->filter_value[0]=para->filter.filter[0];
@@ -614,7 +614,7 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 		(*secfilter)->filter_mode[0]=para->filter.mode[0];
 		(*secfilter)->filter_mask[1]=0;
 		(*secfilter)->filter_mask[2]=0;
-		
+
 		filter->todo = 0;
 
 		ret = filter->feed.sec->start_filtering (filter->feed.sec);
@@ -626,7 +626,7 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 		break;
 	}
 
-	case DMXDEV_TYPE_PES: 
+	case DMXDEV_TYPE_PES:
 	{
 		struct timespec timeout = { 0 };
 		struct dmx_pes_filter_params *para = &filter->params.pes;
@@ -635,27 +635,27 @@ static int dvb_dmxdev_filter_start(struct dmxdev_filter *filter)
 		int ts_type;
 		enum dmx_ts_pes ts_pes;
 		struct dmx_ts_feed **tsfeed = &filter->feed.ts;
-		
+
 		filter->feed.ts = NULL;
 		otype=para->output;
-		
+
 		ts_pes=(enum dmx_ts_pes) para->pes_type;
-		
-		if (ts_pes<DMX_PES_OTHER) 
+
+		if (ts_pes<DMX_PES_OTHER)
 			ts_type=TS_DECODER;
 		else
 			ts_type=0;
-		
-		if (otype == DMX_OUT_TS_TAP) 
+
+		if (otype == DMX_OUT_TS_TAP)
 			ts_type |= TS_PACKET;
-		
-		if (otype == DMX_OUT_TAP) 
+
+		if (otype == DMX_OUT_TAP)
 			ts_type |= TS_PAYLOAD_ONLY|TS_PACKET;
-		
-		ret=dmxdev->demux->allocate_ts_feed(dmxdev->demux, 
-						    tsfeed, 
+
+		ret=dmxdev->demux->allocate_ts_feed(dmxdev->demux,
+						    tsfeed,
 						    dvb_dmxdev_ts_callback);
-		if (ret<0) 
+		if (ret<0)
 			return ret;
 
 		(*tsfeed)->priv = (void *) filter;
@@ -730,13 +730,13 @@ static int dvb_dmxdev_filter_free(struct dmxdev *dmxdev, struct dmxdev_filter *d
 		up(&dmxdev->mutex);
 		return -ERESTARTSYS;
 	}
-	
+
 	dvb_dmxdev_filter_stop(dmxdevfilter);
 	dvb_dmxdev_filter_reset(dmxdevfilter);
-	
+
 	if (dmxdevfilter->buffer.data) {
 		void *mem=dmxdevfilter->buffer.data;
-		
+
 		spin_lock_irq(&dmxdev->lock);
 		dmxdevfilter->buffer.data=NULL;
 		spin_unlock_irq(&dmxdev->lock);
@@ -759,22 +759,22 @@ static inline void invert_mode(dmx_filter_t *filter)
 }
 
 
-static int dvb_dmxdev_filter_set(struct dmxdev *dmxdev, 
-		struct dmxdev_filter *dmxdevfilter, 
+static int dvb_dmxdev_filter_set(struct dmxdev *dmxdev,
+		struct dmxdev_filter *dmxdevfilter,
 		struct dmx_sct_filter_params *params)
 {
 	dprintk ("function : %s\n", __FUNCTION__);
 
 	dvb_dmxdev_filter_stop(dmxdevfilter);
-	
+
 	dmxdevfilter->type=DMXDEV_TYPE_SEC;
 	dmxdevfilter->pid=params->pid;
-	memcpy(&dmxdevfilter->params.sec, 
+	memcpy(&dmxdevfilter->params.sec,
 	       params, sizeof(struct dmx_sct_filter_params));
 	invert_mode(&dmxdevfilter->params.sec.filter);
 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
-		
-	if (params->flags&DMX_IMMEDIATE_START) 
+
+	if (params->flags&DMX_IMMEDIATE_START)
 		return dvb_dmxdev_filter_start(dmxdevfilter);
 
 	return 0;
@@ -795,7 +795,7 @@ static int dvb_dmxdev_pes_filter_set(struct dmxdev *dmxdev,
 
 	dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_SET);
 
-	if (params->flags&DMX_IMMEDIATE_START) 
+	if (params->flags&DMX_IMMEDIATE_START)
 		return dvb_dmxdev_filter_start(dmxdevfilter);
 
 	return 0;
@@ -806,18 +806,18 @@ static ssize_t dvb_dmxdev_read_sec(struct dmxdev_filter *dfil,
 {
 	int result, hcount;
 	int done=0;
-	
+
 	if (dfil->todo<=0) {
 		hcount=3+dfil->todo;
 		if (hcount>count)
 			hcount=count;
-		result=dvb_dmxdev_buffer_read(&dfil->buffer, file->f_flags&O_NONBLOCK, 
+		result=dvb_dmxdev_buffer_read(&dfil->buffer, file->f_flags&O_NONBLOCK,
 					buf, hcount, ppos);
 		if (result<0) {
 			dfil->todo=0;
 			return result;
 		}
-		if (copy_from_user(dfil->secheader-dfil->todo, buf, result)) 
+		if (copy_from_user(dfil->secheader-dfil->todo, buf, result))
 			return -EFAULT;
 		buf+=result;
 		done=result;
@@ -831,7 +831,7 @@ static ssize_t dvb_dmxdev_read_sec(struct dmxdev_filter *dfil,
 	}
 	if (count>dfil->todo)
 		count=dfil->todo;
-	result=dvb_dmxdev_buffer_read(&dfil->buffer, file->f_flags&O_NONBLOCK, 
+	result=dvb_dmxdev_buffer_read(&dfil->buffer, file->f_flags&O_NONBLOCK,
 				buf, count, ppos);
 	if (result<0)
 		return result;
@@ -840,7 +840,7 @@ static ssize_t dvb_dmxdev_read_sec(struct dmxdev_filter *dfil,
 }
 
 
-static ssize_t 
+static ssize_t
 dvb_demux_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
 	struct dmxdev_filter *dmxdevfilter=dvb_dmxdev_file_to_filter(file);
@@ -852,8 +852,8 @@ dvb_demux_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 	if (dmxdevfilter->type==DMXDEV_TYPE_SEC)
 		ret=dvb_dmxdev_read_sec(dmxdevfilter, file, buf, count, ppos);
 	else
-		ret=dvb_dmxdev_buffer_read(&dmxdevfilter->buffer, 
-				     file->f_flags&O_NONBLOCK, 
+		ret=dvb_dmxdev_buffer_read(&dmxdevfilter->buffer,
+				     file->f_flags&O_NONBLOCK,
 				     buf, count, ppos);
 
 	up(&dmxdevfilter->mutex);
@@ -868,7 +868,7 @@ static int dvb_demux_do_ioctl(struct inode *inode, struct file *file,
 	struct dmxdev *dmxdev=dmxdevfilter->dev;
 	unsigned long arg=(unsigned long) parg;
 	int ret=0;
-  
+
 	if (down_interruptible (&dmxdev->mutex))
 		return -ERESTARTSYS;
 
@@ -894,27 +894,27 @@ static int dvb_demux_do_ioctl(struct inode *inode, struct file *file,
 		up(&dmxdevfilter->mutex);
 		break;
 
-	case DMX_SET_FILTER: 
+	case DMX_SET_FILTER:
 		if (down_interruptible(&dmxdevfilter->mutex)) {
 			up(&dmxdev->mutex);
 			return -ERESTARTSYS;
 		}
-		ret = dvb_dmxdev_filter_set(dmxdev, dmxdevfilter, 
+		ret = dvb_dmxdev_filter_set(dmxdev, dmxdevfilter,
 				    (struct dmx_sct_filter_params *)parg);
 		up(&dmxdevfilter->mutex);
 		break;
 
-	case DMX_SET_PES_FILTER: 
+	case DMX_SET_PES_FILTER:
 		if (down_interruptible(&dmxdevfilter->mutex)) {
 			up(&dmxdev->mutex);
 			return -ERESTARTSYS;
 		}
-		ret=dvb_dmxdev_pes_filter_set(dmxdev, dmxdevfilter, 
+		ret=dvb_dmxdev_pes_filter_set(dmxdev, dmxdevfilter,
 					       (struct dmx_pes_filter_params *)parg);
 		up(&dmxdevfilter->mutex);
 		break;
 
-	case DMX_SET_BUFFER_SIZE: 
+	case DMX_SET_BUFFER_SIZE:
 		if (down_interruptible(&dmxdevfilter->mutex)) {
 			up(&dmxdev->mutex);
 			return -ERESTARTSYS;
@@ -922,11 +922,11 @@ static int dvb_demux_do_ioctl(struct inode *inode, struct file *file,
 		ret=dvb_dmxdev_set_buffer_size(dmxdevfilter, arg);
 		up(&dmxdevfilter->mutex);
 		break;
-	
-	case DMX_GET_EVENT: 
+
+	case DMX_GET_EVENT:
 		break;
-		
-	case DMX_GET_PES_PIDS: 
+
+	case DMX_GET_PES_PIDS:
 		if (!dmxdev->demux->get_pes_pids) {
 			ret=-EINVAL;
 			break;
@@ -1023,11 +1023,11 @@ static int dvb_dvr_do_ioctl(struct inode *inode, struct file *file,
 		return -ERESTARTSYS;
 
 	switch (cmd) {
-	case DMX_SET_BUFFER_SIZE: 
+	case DMX_SET_BUFFER_SIZE:
 		// FIXME: implement
 		ret=0;
 		break;
-		
+
 	default:
 		ret=-EINVAL;
 	}
@@ -1059,7 +1059,7 @@ static unsigned int dvb_dvr_poll (struct file *file, poll_table *wait)
 
 		if (dmxdev->dvr_buffer.pread!=dmxdev->dvr_buffer.pwrite)
 			mask |= (POLLIN | POLLRDNORM | POLLPRI);
-	} else 
+	} else
 		mask |= (POLLOUT | POLLWRNORM | POLLPRI);
 
 	return mask;
@@ -1083,14 +1083,14 @@ static struct dvb_device dvbdev_dvr = {
 	.fops		= &dvb_dvr_fops
 };
 
-int 
+int
 dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter)
 {
 	int i;
 
 	if (dmxdev->demux->open(dmxdev->demux) < 0)
 		return -EUSERS;
-	
+
 	dmxdev->filter = vmalloc(dmxdev->filternum*sizeof(struct dmxdev_filter));
 	if (!dmxdev->filter)
 		return -ENOMEM;
@@ -1123,7 +1123,7 @@ dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter)
 }
 EXPORT_SYMBOL(dvb_dmxdev_init);
 
-void 
+void
 dvb_dmxdev_release(struct dmxdev *dmxdev)
 {
 	dvb_unregister_device(dmxdev->dvbdev);
@@ -1141,4 +1141,3 @@ dvb_dmxdev_release(struct dmxdev *dmxdev)
 	dmxdev->demux->close(dmxdev->demux);
 }
 EXPORT_SYMBOL(dvb_dmxdev_release);
-
diff --git a/linux/drivers/media/dvb/dvb-core/dmxdev.h b/linux/drivers/media/dvb/dvb-core/dmxdev.h
index 47d31777c..395a9cd75 100644
--- a/linux/drivers/media/dvb/dvb-core/dmxdev.h
+++ b/linux/drivers/media/dvb/dvb-core/dmxdev.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * dmxdev.h
  *
  * Copyright (C) 2000 Ralph Metzler & Marcus Metzler
diff --git a/linux/drivers/media/dvb/dvb-core/dvb_demux.c b/linux/drivers/media/dvb/dvb-core/dvb_demux.c
index 19fb4d99c..ac9889d22 100644
--- a/linux/drivers/media/dvb/dvb-core/dvb_demux.c
+++ b/linux/drivers/media/dvb/dvb-core/dvb_demux.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * dvb_demux.c - DVB kernel demux API
  *
  * Copyright (C) 2000-2001 Ralph  Metzler <ralph@convergence.de>
@@ -32,8 +32,8 @@
 
 #include "dvb_demux.h"
 
-#define NOBUFS  
-/* 
+#define NOBUFS
+/*
 ** #define DVB_DEMUX_SECTION_LOSS_LOG to monitor payload loss in the syslog
 */
 // #define DVB_DEMUX_SECTION_LOSS_LOG
@@ -42,7 +42,7 @@
 static LIST_HEAD(dmx_muxs);
 
 
-static int dmx_register_demux(struct dmx_demux *demux) 
+static int dmx_register_demux(struct dmx_demux *demux)
 {
 	demux->users = 0;
 	list_add(&demux->reg_list, &dmx_muxs);
@@ -87,14 +87,12 @@ static inline u8 payload(const u8 *tsp)
 {
 	if (!(tsp[3] & 0x10)) // no payload?
 		return 0;
-
 	if (tsp[3] & 0x20) {  // adaptation field?
 		if (tsp[4] > 183)    // corrupted data?
 			return 0;
 		else
 			return 184-1-tsp[4];
 	}
-
 	return 184;
 }
 
@@ -115,7 +113,7 @@ static void dvb_dmx_memcopy (struct dvb_demux_feed *f, u8 *d, const u8 *s, size_
  * Software filter functions
  ******************************************************************************/
 
-static inline int dvb_dmx_swfilter_payload (struct dvb_demux_feed *feed, const u8 *buf) 
+static inline int dvb_dmx_swfilter_payload (struct dvb_demux_feed *feed, const u8 *buf)
 {
 	int count = payload(buf);
 	int p;
@@ -140,11 +138,11 @@ static inline int dvb_dmx_swfilter_payload (struct dvb_demux_feed *feed, const u
 
 	feed->peslen += count;
 
-	return feed->cb.ts (&buf[p], count, NULL, 0, &feed->feed.ts, DMX_OK); 
+	return feed->cb.ts (&buf[p], count, NULL, 0, &feed->feed.ts, DMX_OK);
 }
 
 
-static int dvb_dmx_swfilter_sectionfilter (struct dvb_demux_feed *feed, 
+static int dvb_dmx_swfilter_sectionfilter (struct dvb_demux_feed *feed,
 				    struct dvb_demux_filter *f)
 {
 	u8 neq = 0;
@@ -162,8 +160,8 @@ static int dvb_dmx_swfilter_sectionfilter (struct dvb_demux_feed *feed,
 	if (f->doneq && !neq)
 		return 0;
 
-	return feed->cb.sec (feed->feed.sec.secbuf, feed->feed.sec.seclen, 
-			     NULL, 0, &f->filter, DMX_OK); 
+	return feed->cb.sec (feed->feed.sec.secbuf, feed->feed.sec.seclen,
+			     NULL, 0, &f->filter, DMX_OK);
 }
 
 
@@ -213,7 +211,7 @@ static void dvb_dmx_swfilter_section_new(struct dvb_demux_feed *feed)
 		*/
 		if(sec->secbuf[0] != 0xff || sec->secbuf[n-1] != 0xff)
 		{
-			printk("dvb_demux.c section ts padding loss: %d/%d\n", 
+			printk("dvb_demux.c section ts padding loss: %d/%d\n",
 			       n, sec->tsfeedp);
 			printk("dvb_demux.c pad data:");
 			for(i = 0; i < n; i++)
@@ -227,13 +225,13 @@ static void dvb_dmx_swfilter_section_new(struct dvb_demux_feed *feed)
 	sec->secbuf = sec->secbuf_base;
 }
 
-/* 
+/*
 ** Losless Section Demux 1.4.1 by Emard
 ** Valsecchi Patrick:
 **  - middle of section A  (no PUSI)
-**  - end of section A and start of section B 
+**  - end of section A and start of section B
 **    (with PUSI pointing to the start of the second section)
-**  
+**
 **  In this case, without feed->pusi_seen you'll receive a garbage section
 **  consisting of the end of section A. Basically because tsfeedp
 **  is incemented and the use=0 condition is not raised
@@ -257,7 +255,7 @@ static int dvb_dmx_swfilter_section_copy_dump(struct dvb_demux_feed *feed, const
 	if(sec->tsfeedp + len > DMX_MAX_SECFEED_SIZE)
 	{
 #ifdef DVB_DEMUX_SECTION_LOSS_LOG
-		printk("dvb_demux.c section buffer full loss: %d/%d\n", 
+		printk("dvb_demux.c section buffer full loss: %d/%d\n",
 		       sec->tsfeedp + len - DMX_MAX_SECFEED_SIZE, DMX_MAX_SECFEED_SIZE);
 #endif
 		len = DMX_MAX_SECFEED_SIZE - sec->tsfeedp;
@@ -272,7 +270,7 @@ static int dvb_dmx_swfilter_section_copy_dump(struct dvb_demux_feed *feed, const
 	/* -----------------------------------------------------
 	** Dump all the sections we can find in the data (Emard)
 	*/
-	
+
 	limit = sec->tsfeedp;
 	if(limit > DMX_MAX_SECFEED_SIZE)
 		return -1; /* internal error should never happen */
@@ -283,7 +281,7 @@ static int dvb_dmx_swfilter_section_copy_dump(struct dvb_demux_feed *feed, const
 	for(n = 0; sec->secbufp + 2 < limit; n++)
 	{
 		seclen = section_length(sec->secbuf);
-		if(seclen <= 0 || seclen > DMX_MAX_SECFEED_SIZE 
+		if(seclen <= 0 || seclen > DMX_MAX_SECFEED_SIZE
 		   || seclen + sec->secbufp > limit)
 			return 0;
 		sec->seclen = seclen;
@@ -303,7 +301,7 @@ static int dvb_dmx_swfilter_section_copy_dump(struct dvb_demux_feed *feed, const
 }
 
 
-static int dvb_dmx_swfilter_section_packet(struct dvb_demux_feed *feed, const u8 *buf) 
+static int dvb_dmx_swfilter_section_packet(struct dvb_demux_feed *feed, const u8 *buf)
 {
 	u8 p, count;
 	int ccok, dc_i = 0;
@@ -381,9 +379,9 @@ static inline void dvb_dmx_swfilter_packet_type(struct dvb_demux_feed *feed, con
 			if (feed->ts_type & TS_PAYLOAD_ONLY)
 				dvb_dmx_swfilter_payload(feed, buf);
 			else
-				feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts, DMX_OK); 
+				feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts, DMX_OK);
 		}
-		if (feed->ts_type & TS_DECODER) 
+		if (feed->ts_type & TS_DECODER)
 			if (feed->demux->write_to_decoder)
 				feed->demux->write_to_decoder(feed, buf, 188);
 		break;
@@ -439,7 +437,7 @@ void dvb_dmx_swfilter_packets(struct dvb_demux *demux, const u8 *buf, size_t cou
 	spin_lock(&demux->lock);
 
 	while (count--) {
-               	if(buf[0] == 0x47) {
+		if(buf[0] == 0x47) {
 		        dvb_dmx_swfilter_packet(demux, buf);
 		}
 		buf += 188;
@@ -480,7 +478,7 @@ void dvb_dmx_swfilter(struct dvb_demux *demux, const u8 *buf, size_t count)
 				demux->tsbufp=i;
 				goto bailout;
 			}
-		} else 
+		} else
 			p++;
 	}
 
@@ -524,7 +522,7 @@ void dvb_dmx_swfilter_204(struct dvb_demux *demux, const u8 *buf, size_t count)
 				demux->tsbufp=i;
 				goto bailout;
 			}
-		} else { 
+		} else {
 			p++;
 		}
 	}
@@ -606,9 +604,9 @@ out:
 	spin_unlock_irq(&feed->demux->lock);
 }
 
-static int dmx_ts_feed_set (struct dmx_ts_feed* ts_feed, u16 pid, int ts_type, 
-		     enum dmx_ts_pes pes_type, size_t callback_length, 
-		     size_t circular_buffer_size, int descramble, 
+static int dmx_ts_feed_set (struct dmx_ts_feed* ts_feed, u16 pid, int ts_type,
+		     enum dmx_ts_pes pes_type, size_t callback_length,
+		     size_t circular_buffer_size, int descramble,
 		     struct timespec timeout)
 {
 	struct dvb_demux_feed *feed = (struct dvb_demux_feed *) ts_feed;
@@ -626,7 +624,7 @@ static int dmx_ts_feed_set (struct dmx_ts_feed* ts_feed, u16 pid, int ts_type,
 			return -EINVAL;
 		}
 
-		if (demux->pesfilter[pes_type] && 
+		if (demux->pesfilter[pes_type] &&
 		    demux->pesfilter[pes_type] != feed) {
 			up(&demux->mutex);
 			return -EINVAL;
@@ -662,7 +660,7 @@ static int dmx_ts_feed_set (struct dmx_ts_feed* ts_feed, u16 pid, int ts_type,
 		}
 #endif
 	}
-	
+
 	feed->state = DMX_STATE_READY;
 	up(&demux->mutex);
 
@@ -702,7 +700,7 @@ static int dmx_ts_feed_start_filtering(struct dmx_ts_feed* ts_feed)
 
 	return 0;
 }
- 
+
 static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed* ts_feed)
 {
 	struct dvb_demux_feed *feed = (struct dvb_demux_feed *) ts_feed;
@@ -722,7 +720,7 @@ static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed* ts_feed)
 		return -ENODEV;
 	}
 
-	ret = demux->stop_feed(feed); 
+	ret = demux->stop_feed(feed);
 
 	spin_lock_irq(&demux->lock);
 	ts_feed->is_filtering = 0;
@@ -733,7 +731,7 @@ static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed* ts_feed)
 	return ret;
 }
 
-static int dvbdmx_allocate_ts_feed (struct dmx_demux *dmx, struct dmx_ts_feed **ts_feed, 
+static int dvbdmx_allocate_ts_feed (struct dmx_demux *dmx, struct dmx_ts_feed **ts_feed,
 			     dmx_ts_cb callback)
 {
 	struct dvb_demux *demux = (struct dvb_demux *) dmx;
@@ -772,7 +770,7 @@ static int dvbdmx_allocate_ts_feed (struct dmx_demux *dmx, struct dmx_ts_feed **
 	feed->filter->type = DMX_TYPE_TS;
 	feed->filter->feed = feed;
 	feed->filter->state = DMX_STATE_READY;
-	
+
 	up(&demux->mutex);
 
 	return 0;
@@ -815,8 +813,8 @@ static int dvbdmx_release_ts_feed(struct dmx_demux *dmx, struct dmx_ts_feed *ts_
  * dmx_section_feed API calls
  ******************************************************************************/
 
-static int dmx_section_feed_allocate_filter(struct dmx_section_feed* feed, 
-				     struct dmx_section_filter** filter) 
+static int dmx_section_feed_allocate_filter(struct dmx_section_feed* feed,
+				     struct dmx_section_filter** filter)
 {
 	struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
 	struct dvb_demux *dvbdemux = dvbdmxfeed->demux;
@@ -847,9 +845,9 @@ static int dmx_section_feed_allocate_filter(struct dmx_section_feed* feed,
 }
 
 
-static int dmx_section_feed_set(struct dmx_section_feed* feed, 
-			 u16 pid, size_t circular_buffer_size, 
-			 int descramble, int check_crc) 
+static int dmx_section_feed_set(struct dmx_section_feed* feed,
+			 u16 pid, size_t circular_buffer_size,
+			 int descramble, int check_crc)
 {
 	struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
 	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
@@ -859,7 +857,7 @@ static int dmx_section_feed_set(struct dmx_section_feed* feed,
 
 	if (down_interruptible (&dvbdmx->mutex))
 		return -ERESTARTSYS;
-	
+
 	dvb_demux_feed_add(dvbdmxfeed);
 
 	dvbdmxfeed->pid = pid;
@@ -919,7 +917,7 @@ static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed)
 
 	if (down_interruptible (&dvbdmx->mutex))
 		return -ERESTARTSYS;
-	
+
 	if (feed->is_filtering) {
 		up(&dvbdmx->mutex);
 		return -EBUSY;
@@ -934,7 +932,7 @@ static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed)
 	dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base;
 	dvbdmxfeed->feed.sec.secbufp = 0;
 	dvbdmxfeed->feed.sec.seclen = 0;
-	
+
 	if (!dvbdmx->start_feed) {
 		up(&dvbdmx->mutex);
 		return -ENODEV;
@@ -971,7 +969,7 @@ static int dmx_section_feed_stop_filtering(struct dmx_section_feed* feed)
 		return -ENODEV;
 	}
 
-	ret = dvbdmx->stop_feed(dvbdmxfeed); 
+	ret = dvbdmx->stop_feed(dvbdmxfeed);
 
 	spin_lock_irq(&dvbdmx->lock);
 	dvbdmxfeed->state = DMX_STATE_READY;
@@ -983,7 +981,7 @@ static int dmx_section_feed_stop_filtering(struct dmx_section_feed* feed)
 }
 
 
-static int dmx_section_feed_release_filter(struct dmx_section_feed *feed, 
+static int dmx_section_feed_release_filter(struct dmx_section_feed *feed,
 				struct dmx_section_filter* filter)
 {
 	struct dvb_demux_filter *dvbdmxfilter = (struct dvb_demux_filter *) filter, *f;
@@ -998,9 +996,9 @@ static int dmx_section_feed_release_filter(struct dmx_section_feed *feed,
 		return -EINVAL;
 	}
 
-	if (feed->is_filtering) 
+	if (feed->is_filtering)
 		feed->stop_filtering(feed);
-	
+
 	spin_lock_irq(&dvbdmx->lock);
 	f = dvbdmxfeed->filter;
 
@@ -1018,7 +1016,7 @@ static int dmx_section_feed_release_filter(struct dmx_section_feed *feed,
 	return 0;
 }
 
-static int dvbdmx_allocate_section_feed(struct dmx_demux *demux, 
+static int dvbdmx_allocate_section_feed(struct dmx_demux *demux,
 					struct dmx_section_feed **feed,
 					dmx_section_cb callback)
 {
@@ -1058,7 +1056,7 @@ static int dvbdmx_allocate_section_feed(struct dmx_demux *demux,
 	return 0;
 }
 
-static int dvbdmx_release_section_feed(struct dmx_demux *demux, 
+static int dvbdmx_release_section_feed(struct dmx_demux *demux,
 				       struct dmx_section_feed *feed)
 {
 	struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) feed;
@@ -1137,7 +1135,7 @@ static int dvbdmx_add_frontend(struct dmx_demux *demux, struct dmx_frontend *fro
 {
 	struct dvb_demux *dvbdemux = (struct dvb_demux *) demux;
 	struct list_head *head = &dvbdemux->frontend_list;
-	
+
 	list_add(&(frontend->connectivity_list), head);
 
 	return 0;
@@ -1166,7 +1164,6 @@ static struct list_head * dvbdmx_get_frontends(struct dmx_demux *demux)
 
 	if (list_empty(&dvbdemux->frontend_list))
 		return NULL;
-
 	return &dvbdemux->frontend_list;
 }
 
@@ -1177,7 +1174,7 @@ static int dvbdmx_connect_frontend(struct dmx_demux *demux, struct dmx_frontend
 
 	if (demux->frontend)
 		return -EINVAL;
-	
+
 	if (down_interruptible (&dvbdemux->mutex))
 		return -ERESTARTSYS;
 
@@ -1195,7 +1192,6 @@ static int dvbdmx_disconnect_frontend(struct dmx_demux *demux)
 		return -ERESTARTSYS;
 
 	demux->frontend = NULL;
-
 	up(&dvbdemux->mutex);
 	return 0;
 }
@@ -1226,21 +1222,17 @@ int dvb_dmx_init(struct dvb_demux *dvbdemux)
 		vfree(dvbdemux->filter);
 		return -ENOMEM;
 	}
-
 	for (i=0; i<dvbdemux->filternum; i++) {
 		dvbdemux->filter[i].state = DMX_STATE_FREE;
 		dvbdemux->filter[i].index = i;
 	}
-
 	for (i=0; i<dvbdemux->feednum; i++) {
 		dvbdemux->feed[i].state = DMX_STATE_FREE;
 		dvbdemux->feed[i].index = i;
 	}
-
 	dvbdemux->frontend_list.next=
 	  dvbdemux->frontend_list.prev=
 	    &dvbdemux->frontend_list;
-
 	for (i=0; i<DMX_TS_PES_OTHER; i++) {
 		dvbdemux->pesfilter[i] = NULL;
 		dvbdemux->pids[i] = 0xffff;
@@ -1271,7 +1263,7 @@ int dvb_dmx_init(struct dvb_demux *dvbdemux)
 
 	dmx->descramble_mac_address = NULL;
 	dmx->descramble_section_payload = NULL;
-	
+
 	dmx->add_frontend = dvbdmx_add_frontend;
 	dmx->remove_frontend = dvbdmx_remove_frontend;
 	dmx->get_frontends = dvbdmx_get_frontends;
@@ -1282,7 +1274,7 @@ int dvb_dmx_init(struct dvb_demux *dvbdemux)
 	sema_init(&dvbdemux->mutex, 1);
 	spin_lock_init(&dvbdemux->lock);
 
-	if ((err = dmx_register_demux(dmx)) < 0) 
+	if ((err = dmx_register_demux(dmx)) < 0)
 		return err;
 
 	return 0;
@@ -1300,4 +1292,3 @@ int dvb_dmx_release(struct dvb_demux *dvbdemux)
 	return 0;
 }
 EXPORT_SYMBOL(dvb_dmx_release);
-
diff --git a/linux/drivers/media/dvb/dvb-core/dvb_demux.h b/linux/drivers/media/dvb/dvb-core/dvb_demux.h
index 326cce056..c09beb391 100644
--- a/linux/drivers/media/dvb/dvb-core/dvb_demux.h
+++ b/linux/drivers/media/dvb/dvb-core/dvb_demux.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * dvb_demux.h: DVB kernel demux API
  *
  * Copyright (C) 2000-2001 Marcus Metzler & Ralph Metzler
@@ -45,10 +45,10 @@
 
 struct dvb_demux_filter {
         struct dmx_section_filter filter;
-        u8 maskandmode    [DMX_MAX_FILTER_SIZE]; 
-        u8 maskandnotmode [DMX_MAX_FILTER_SIZE]; 
+        u8 maskandmode    [DMX_MAX_FILTER_SIZE];
+        u8 maskandnotmode [DMX_MAX_FILTER_SIZE];
 	int doneq;
-		
+
         struct dvb_demux_filter *next;
         struct dvb_demux_feed *feed;
         int index;
@@ -85,16 +85,16 @@ struct dvb_demux_feed {
         int buffer_size;
         int descramble;
 
-        struct timespec timeout; 
+        struct timespec timeout;
         struct dvb_demux_filter *filter;
         int cb_length;
-  
+
         int ts_type;
         enum dmx_ts_pes pes_type;
 
         int cc;
         int pusi_seen; /* prevents feeding of garbage from previous section */
-        
+
         u16 peslen;
 
 	struct list_head list_head;
@@ -114,7 +114,7 @@ struct dvb_demux {
 			    const u8 *buf, size_t len);
 	void (*memcopy) (struct dvb_demux_feed *feed, u8 *dst,
 			 const u8 *src, size_t len);
-  
+
         int users;
 #define MAX_DVB_DEMUX_USERS 10
         struct dvb_demux_filter *filter;
@@ -124,8 +124,8 @@ struct dvb_demux {
 
         struct dvb_demux_feed *pesfilter[DMX_TS_PES_OTHER];
         u16 pids[DMX_TS_PES_OTHER];
-        int playing; 
-        int recording; 
+        int playing;
+        int recording;
 
 #define DMX_MAX_PID 0x2000
 	struct list_head feed_list;
@@ -144,4 +144,3 @@ void dvb_dmx_swfilter(struct dvb_demux *demux, const u8 *buf, size_t count);
 void dvb_dmx_swfilter_204(struct dvb_demux *demux, const u8 *buf, size_t count);
 
 #endif /* _DVB_DEMUX_H_ */
-
diff --git a/linux/drivers/media/dvb/dvb-core/dvb_filter.c b/linux/drivers/media/dvb/dvb-core/dvb_filter.c
index 5e541bfb6..bd5143906 100644
--- a/linux/drivers/media/dvb/dvb-core/dvb_filter.c
+++ b/linux/drivers/media/dvb/dvb-core/dvb_filter.c
@@ -22,12 +22,12 @@ static u32 ac3_frames[3][32] =
      {69,87,104,121,139,174,208,243,278,348,417,487,557,696,835,975,1114,
       1253,1393,0,0,0,0,0,0,0,0,0,0,0,0,0},
      {96,120,144,168,192,240,288,336,384,480,576,672,768,960,1152,1344,
-      1536,1728,1920,0,0,0,0,0,0,0,0,0,0,0,0,0}}; 
+      1536,1728,1920,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 
 
 
 #if 0
-static void setup_ts2pes(ipack *pa, ipack *pv, u16 *pida, u16 *pidv, 
+static void setup_ts2pes(ipack *pa, ipack *pv, u16 *pida, u16 *pidv,
 		  void (*pes_write)(u8 *buf, int count, void *data),
 		  void *priv)
 {
@@ -72,7 +72,7 @@ static int read_picture_header(u8 *headr, struct mpg_picture *pic, int field, in
 	u8 pct;
 
 	if (pr) printk( "Pic header: ");
-        pic->temporal_reference[field] = (( headr[0] << 2 ) | 
+        pic->temporal_reference[field] = (( headr[0] << 2 ) |
 					  (headr[1] & 0x03) )& 0x03ff;
 	if (pr) printk( " temp ref: 0x%04x", pic->temporal_reference[field]);
 
@@ -93,31 +93,31 @@ static int read_picture_header(u8 *headr, struct mpg_picture *pic, int field, in
 	}
 
 
-        pic->vinfo.vbv_delay  = (( headr[1] >> 5 ) | ( headr[2] << 3) | 
+        pic->vinfo.vbv_delay  = (( headr[1] >> 5 ) | ( headr[2] << 3) |
 				 ( (headr[3] & 0x1F) << 11) ) & 0xffff;
 
 	if (pr) printk( " vbv delay: 0x%04x", pic->vinfo.vbv_delay);
 
-        pic->picture_header_parameter = ( headr[3] & 0xe0 ) | 
+        pic->picture_header_parameter = ( headr[3] & 0xe0 ) |
 		((headr[4] & 0x80) >> 3);
 
         if ( pct == B_FRAME ){
                 pic->picture_header_parameter |= ( headr[4] >> 3 ) & 0x0f;
         }
-	if (pr) printk( " pic head param: 0x%x", 
+	if (pr) printk( " pic head param: 0x%x",
 			pic->picture_header_parameter);
 
 	return pct;
-} 
+}
 #endif
 
 #if 0
 /* needs 4 byte input */
 static int read_gop_header(u8 *headr, struct mpg_picture *pic, int pr)
 {
-	if (pr) printk("GOP header: "); 
+	if (pr) printk("GOP header: ");
 
-	pic->time_code  = (( headr[0] << 17 ) | ( headr[1] << 9) | 
+	pic->time_code  = (( headr[0] << 17 ) | ( headr[1] << 9) |
 			   ( headr[2] << 1 ) | (headr[3] &0x01)) & 0x1ffffff;
 
 	if (pr) printk(" time: %d:%d.%d ", (headr[0]>>2)& 0x1F,
@@ -129,14 +129,14 @@ static int read_gop_header(u8 *headr, struct mpg_picture *pic, int pr)
         } else {
                 pic->closed_gop = 0;
         }
-	if (pr) printk("closed: %d", pic->closed_gop); 
+	if (pr) printk("closed: %d", pic->closed_gop);
 
         if ( ( headr[3] & 0x20 ) != 0 ){
                 pic->broken_link = 1;
         } else {
                 pic->broken_link = 0;
         }
-	if (pr) printk(" broken: %d\n", pic->broken_link); 
+	if (pr) printk(" broken: %d\n", pic->broken_link);
 
 	return 0;
 }
@@ -153,39 +153,39 @@ static int read_sequence_header(u8 *headr, struct dvb_video_info *vi, int pr)
 
 	vi->horizontal_size	= ((headr[1] &0xF0) >> 4) | (headr[0] << 4);
 	vi->vertical_size	= ((headr[1] &0x0F) << 8) | (headr[2]);
-    
+
         sw = (int)((headr[3]&0xF0) >> 4) ;
 
         switch( sw ){
 	case 1:
 		if (pr)
 			printk("Videostream: ASPECT: 1:1");
-		vi->aspect_ratio = 100;        
+		vi->aspect_ratio = 100;
 		break;
 	case 2:
 		if (pr)
 			printk("Videostream: ASPECT: 4:3");
-                vi->aspect_ratio = 133;        
+                vi->aspect_ratio = 133;
 		break;
 	case 3:
 		if (pr)
 			printk("Videostream: ASPECT: 16:9");
-                vi->aspect_ratio = 177;        
+                vi->aspect_ratio = 177;
 		break;
 	case 4:
 		if (pr)
 			printk("Videostream: ASPECT: 2.21:1");
-                vi->aspect_ratio = 221;        
+                vi->aspect_ratio = 221;
 		break;
 
         case 5 ... 15:
 		if (pr)
 			printk("Videostream: ASPECT: reserved");
-                vi->aspect_ratio = 0;        
+                vi->aspect_ratio = 0;
 		break;
 
         default:
-                vi->aspect_ratio = 0;        
+                vi->aspect_ratio = 0;
                 return -1;
 	}
 
@@ -240,7 +240,7 @@ static int read_sequence_header(u8 *headr, struct dvb_video_info *vi, int pr)
 	}
 
 	vi->bit_rate = (headr[4] << 10) | (headr[5] << 2) | (headr[6] & 0x03);
-	
+
         vi->vbv_buffer_size
                 = (( headr[6] & 0xF8) >> 3 ) | (( headr[7] & 0x1F )<< 5);
 
@@ -303,7 +303,7 @@ static int get_ainfo(u8 *mbuf, int count, struct dvb_audio_info *ai, int pr)
 		else {
 			c++;
 		}
-	}	
+	}
 
 	if (!found) return -1;
 
@@ -333,8 +333,8 @@ static int get_ainfo(u8 *mbuf, int count, struct dvb_audio_info *ai, int pr)
 		if (ai->frequency == 3)
 			printk("  Freq: reserved\n");
 		else
-			printk("  Freq: %d kHz\n",ai->frequency); 
-			       
+			printk("  Freq: %d kHz\n",ai->frequency);
+
 	}
 	ai->off = c;
 	return 0;
@@ -349,7 +349,7 @@ int dvb_filter_get_ac3info(u8 *mbuf, int count, struct dvb_audio_info *ai, int p
 	int c = 0;
 	u8 frame = 0;
 	int fr = 0;
-	
+
 	while ( !found  && c < count){
 		u8 *b = mbuf+c;
 
@@ -358,7 +358,7 @@ int dvb_filter_get_ac3info(u8 *mbuf, int count, struct dvb_audio_info *ai, int p
 		else {
 			c++;
 		}
-	}	
+	}
 
 	if (!found) return -1;
 	if (pr)
@@ -402,7 +402,7 @@ static u8 *skip_pes_header(u8 **bufp)
         int skip = 0;
 
 	static const int mpeg1_skip_table[16] = {
-        	1, 0xffff,      5,     10, 0xffff, 0xffff, 0xffff, 0xffff,
+		1, 0xffff,      5,     10, 0xffff, 0xffff, 0xffff, 0xffff,
 	        0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
 	};
 
@@ -479,9 +479,9 @@ static void initialize_mpg_picture(struct mpg_picture *pic)
 
         pic->picture_display_extension_flag[0] = 0;
         pic->picture_display_extension_flag[1] = 0;
-        pic->sequence_header_flag = 0;      
-	pic->gop_flag = 0;              
-        pic->sequence_end_flag = 0;	
+        pic->sequence_header_flag = 0;
+	pic->gop_flag = 0;
+        pic->sequence_end_flag = 0;
 }
 #endif
 
@@ -553,7 +553,7 @@ static void init_mpg_picture( struct mpg_picture *pic, int chan, int32_t field_t
 }
 #endif
 
-void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts, unsigned short pid, 
+void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts, unsigned short pid,
 			    dvb_filter_pes2ts_cb_t *cb, void *priv)
 {
 	unsigned char *buf=p2ts->buf;
@@ -601,4 +601,3 @@ int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts, unsigned char *pes,
 	return p2ts->cb(p2ts->priv, buf);
 }
 EXPORT_SYMBOL(dvb_filter_pes2ts);
-
diff --git a/linux/drivers/media/dvb/dvb-core/dvb_filter.h b/linux/drivers/media/dvb/dvb-core/dvb_filter.h
index bd328dc25..b0848f783 100644
--- a/linux/drivers/media/dvb/dvb-core/dvb_filter.h
+++ b/linux/drivers/media/dvb/dvb-core/dvb_filter.h
@@ -34,8 +34,8 @@ struct dvb_filter_pes2ts {
 	void *priv;
 };
 
-void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts, unsigned short pid, 
-		 	    dvb_filter_pes2ts_cb_t *cb, void *priv);
+void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts, unsigned short pid,
+			    dvb_filter_pes2ts_cb_t *cb, void *priv);
 
 int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts, unsigned char *pes,
 		      int len, int payload_start);
@@ -70,8 +70,8 @@ int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts, unsigned char *pes,
 #define QUANT_MATRIX_EXTENSION       0x03
 #define PICTURE_DISPLAY_EXTENSION    0x07
 
-#define I_FRAME 0x01 
-#define B_FRAME 0x02 
+#define I_FRAME 0x01
+#define B_FRAME 0x02
 #define P_FRAME 0x03
 
 /* Initialize sequence_data */
@@ -92,7 +92,7 @@ int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts, unsigned char *pes,
 #define PES_CRC_FLAG     0x02
 #define PES_EXT_FLAG     0x01
 
-//pts_dts flags 
+//pts_dts flags
 #define PTS_ONLY         0x80
 #define PTS_DTS          0xC0
 
@@ -165,7 +165,7 @@ struct dvb_video_info {
         s16 vbv_delay;
 	u32 CSPF;
 	u32 off;
-};            
+};
 
 #define OFF_SIZE 4
 #define FIRST_FIELD 0
@@ -181,10 +181,10 @@ struct mpg_picture {
         int       low_delay;
         int       closed_gop;
         int       broken_link;
-        int       sequence_header_flag;      
-        int       gop_flag;              
+        int       sequence_header_flag;
+        int       gop_flag;
         int       sequence_end_flag;
-                                                                
+
         u8        profile_and_level;
         s32       picture_coding_parameter;
         u32       matrix[32];
@@ -211,11 +211,11 @@ struct mpg_picture {
         int       forward_bank;
         int       backward_bank;
         int       compress;
-        s16       frame_centre_horizontal_offset[OFF_SIZE];                   
+        s16       frame_centre_horizontal_offset[OFF_SIZE];
                   /* [0-2] 1st field, [3] 2nd field */
         s16       frame_centre_vertical_offset[OFF_SIZE];
                   /* [0-2] 1st field, [3] 2nd field */
-        s16       temporal_reference[2];                               
+        s16       temporal_reference[2];
                   /* [0] 1st field, [1] 2nd field */
 
         s8        picture_coding_type[2];
diff --git a/linux/drivers/media/dvb/dvb-core/dvb_net.h b/linux/drivers/media/dvb/dvb-core/dvb_net.h
index 5b701efe8..f14e4ca38 100644
--- a/linux/drivers/media/dvb/dvb-core/dvb_net.h
+++ b/linux/drivers/media/dvb/dvb-core/dvb_net.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * dvb_net.h
  *
  * Copyright (C) 2001 Ralph Metzler for convergence integrated media GmbH
@@ -44,4 +44,3 @@ void dvb_net_release(struct dvb_net *);
 int  dvb_net_init(struct dvb_adapter *, struct dvb_net *, struct dmx_demux *);
 
 #endif
-
diff --git a/linux/drivers/media/dvb/dvb-core/dvbdev.c b/linux/drivers/media/dvb/dvb-core/dvbdev.c
index d949ad77d..fa857dd48 100644
--- a/linux/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/linux/drivers/media/dvb/dvb-core/dvbdev.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * dvbdev.c
  *
  * Copyright (C) 2000 Ralph  Metzler <ralph@convergence.de>
@@ -80,7 +80,7 @@ static struct dvb_device* dvbdev_find_device (int minor)
 static int dvb_device_open(struct inode *inode, struct file *file)
 {
 	struct dvb_device *dvbdev;
-	
+
 	dvbdev = dvbdev_find_device (iminor(inode));
 
 	if (dvbdev && dvbdev->fops) {
@@ -152,7 +152,7 @@ int dvb_generic_release(struct inode *inode, struct file *file)
 	} else {
 		dvbdev->writers++;
 	}
-	
+
 	dvbdev->users++;
 	return 0;
 }
@@ -163,7 +163,7 @@ int dvb_generic_ioctl(struct inode *inode, struct file *file,
 		      unsigned int cmd, unsigned long arg)
 {
         struct dvb_device *dvbdev = file->private_data;
-	
+
         if (!dvbdev)
 	        return -ENODEV;
 
@@ -195,7 +195,7 @@ skip:
 }
 
 
-int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev, 
+int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
 			const struct dvb_device *template, void *priv, int type)
 {
 	struct dvb_device *dvbdev;
@@ -219,7 +219,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
 	}
 
 	up (&dvbdev_register_lock);
-	
+
 	memcpy(dvbdev, template, sizeof(struct dvb_device));
 	dvbdev->type = type;
 	dvbdev->id = id;
@@ -231,7 +231,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
 	list_add_tail (&dvbdev->list_head, &adap->device_list);
 
 	devfs_mk_cdev(MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
- 			S_IFCHR | S_IRUSR | S_IWUSR,
+			S_IFCHR | S_IRUSR | S_IWUSR,
 			"dvb/adapter%d/%s%d", adap->num, dnames[type], id);
 
 	class_simple_device_add(dvb_class, MKDEV(DVB_MAJOR, nums2minor(adap->num, type, id)),
@@ -239,7 +239,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
 
 	dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
 		adap->num, dnames[type], id, nums2minor(adap->num, type, id),
- 		nums2minor(adap->num, type, id));
+		nums2minor(adap->num, type, id));
 
 	return 0;
 }
@@ -306,7 +306,7 @@ int dvb_register_adapter(struct dvb_adapter **padap, const char *name, struct mo
 	INIT_LIST_HEAD (&adap->device_list);
 
 	printk ("DVB: registering new adapter (%s).\n", name);
-	
+
 	devfs_mk_dir("dvb/adapter%d", num);
 	adap->num = num;
 	adap->name = name;
@@ -447,4 +447,3 @@ module_exit(exit_dvbdev);
 MODULE_DESCRIPTION("DVB Core Driver");
 MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
 MODULE_LICENSE("GPL");
-
diff --git a/linux/drivers/media/dvb/dvb-core/dvbdev.h b/linux/drivers/media/dvb/dvb-core/dvbdev.h
index ef1f5f9d9..184edba3c 100644
--- a/linux/drivers/media/dvb/dvb-core/dvbdev.h
+++ b/linux/drivers/media/dvb/dvb-core/dvbdev.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * dvbdev.h
  *
  * Copyright (C) 2000 Ralph Metzler & Marcus Metzler
@@ -80,7 +80,7 @@ extern int dvb_register_adapter (struct dvb_adapter **padap, const char *name, s
 extern int dvb_unregister_adapter (struct dvb_adapter *adap);
 
 extern int dvb_register_device (struct dvb_adapter *adap,
-				struct dvb_device **pdvbdev, 
+				struct dvb_device **pdvbdev,
 				const struct dvb_device *template,
 				void *priv,
 				int type);
@@ -100,6 +100,5 @@ extern int dvb_usercopy(struct inode *inode, struct file *file,
 	                    unsigned int cmd, unsigned long arg,
 			    int (*func)(struct inode *inode, struct file *file,
 			    unsigned int cmd, void *arg));
-			      
-#endif /* #ifndef _DVBDEV_H_ */
 
+#endif /* #ifndef _DVBDEV_H_ */