diff -urp ivtv-latest/driver/ivtv-api.c ivtv/driver/ivtv-api.c
--- ivtv-latest/driver/ivtv-api.c	2003-11-01 09:35:36.000000000 +0100
+++ ivtv/driver/ivtv-api.c	2003-11-05 00:32:32.000000000 +0100
@@ -1481,47 +1481,46 @@ int ivtv_v4l2_open(struct inode *inode, 
 
 int ivtv_v4l2_read(struct file *filp, char *buf, size_t count, loff_t *pos) {
         struct ivtv_open_id *id = filp->private_data;
-
+        struct ivtv *itv = id->itv;
+	struct ivtv_v4l2_stream *stream;
         int ret=0;
-	 
+
 	IVTV_DEBUG(IVTV_DEBUG_INFO,"v4l2 read\n");
 
-	if (down_interruptible(&id->itv->sem_lock))
+	if (down_interruptible(&itv->sem_lock))
 		return -ERESTARTSYS;
 
-	//FIXME need to handle non-blocking io
-	//FIXME needs locking
-	//FIXME this can be collapsed into 1 var i think
-	if (!test_bit(IVTV_F_S_CAP, &id->itv->v4l2.streams[id->type].s_flags) &&
-		     (id->itv->v4l2.streams[id->type].id == -1)) {
-		
-			set_bit(IVTV_F_S_CAP, &id->itv->v4l2.streams[id->type].s_flags);
-			id->itv->v4l2.streams[id->type].id   	  = id->open_id;
+	stream = &itv->v4l2.streams[id->type];
 
-			ret = ivtv_start_v4l2_stream(id);
-			if (ret)
-				IVTV_DEBUG(IVTV_DEBUG_INFO,
-					   "Error in v4l2 stream init\n");
-			id->itv->v4l2.streams[id->type].seq = 0;
-			id->itv->v4l2.streams[id->type].ubytes= 0;
+	if (!test_and_set_bit(IVTV_F_S_CAP, &stream->s_flags)) {
+		stream->id = id->open_id;
+
+		ret = ivtv_start_v4l2_stream(id);
+		if (ret) {
+			IVTV_DEBUG(IVTV_DEBUG_INFO,
+				   "Error in v4l2 stream init\n");
+			/* bit of a hack... but try to reload firmware
+			 * if capture init fails */
+			ret = ivtv_firmware_copy(itv);
+			if (!ret)
+				ret = ivtv_start_v4l2_stream(id);
+		}
+		stream->seq = 0;
+		stream->ubytes = 0;
 	} else {
-		if (id->open_id != id->itv->v4l2.streams[id->type].id)
+		if (id->open_id != stream->id)
 			ret = -EBUSY;
 	}
 
-	up(&id->itv->sem_lock);
+	up(&itv->sem_lock);
 
 	if (ret)
 		return ret;
 
-	if (filp->f_flags & O_NONBLOCK) {
-		if(!(ivtv_stream_has_data(id)) ) 
-			return -EAGAIN;
-	}
-
-        ret = ivtv_read(id,buf,count);
+        ret = ivtv_read(id, buf, count, !(filp->f_flags & O_NONBLOCK));
 
-	if (ret > 0) *pos += ret;
+	if (ret > 0)
+		*pos += ret;
 
 	return ret;
 }
@@ -1529,6 +1528,8 @@ int ivtv_v4l2_read(struct file *filp, ch
 ssize_t ivtv_v4l2_write(struct file *filp, const char *buf, size_t count, loff_t *pos)
 {
 	struct ivtv_open_id *id = filp->private_data;
+        struct ivtv *itv = id->itv;
+	struct ivtv_v4l2_stream *stream;
 	int ret=0;
 	
 	if ( (id->type != IVTV_DEC_STREAM_TYPE_MPG) &&
@@ -1537,20 +1538,21 @@ ssize_t ivtv_v4l2_write(struct file *fil
 		return -EINVAL;
 	}
 
-	if (down_interruptible(&id->itv->sem_lock))
+	if (down_interruptible(&itv->sem_lock))
 		return -ERESTARTSYS;
 
 	// Initialize Decoder
 	/* FIXME we'll need to make this its own stream type */
-	if (!test_and_set_bit(IVTV_F_S_CAP, &id->itv->v4l2.streams[id->type].s_flags)) {
-		id->itv->v4l2.streams[id->type].id = id->open_id;
+	stream = &itv->v4l2.streams[id->type];
+	if (!test_and_set_bit(IVTV_F_S_CAP, &stream->s_flags)) {
+		stream->id = id->open_id;
 		ret = ivtv_start_v4l2_decode(id);
 	} else {
-		if (id->open_id != id->itv->v4l2.streams[id->type].id)
+		if (id->open_id != stream->id)
 			ret = -EBUSY;
 	}
 
-	up(&id->itv->sem_lock);
+	up(&itv->sem_lock);
 
 	if (ret)
 		return ret;
diff -urp ivtv-latest/driver/ivtv-driver.c ivtv/driver/ivtv-driver.c
--- ivtv-latest/driver/ivtv-driver.c	2003-11-02 07:27:07.000000000 +0100
+++ ivtv/driver/ivtv-driver.c	2003-11-05 15:07:20.636718368 +0100
@@ -209,6 +209,17 @@ int ivtv_enq_buf(struct ivtv *itv, struc
 	return 0;
 }
 
+/* called to remove the buffer returned by _peek_ functions */
+void ivtv_del_buf(struct ivtv *itv, struct ivtv_buffer_list *queue,
+		  struct ivtv_buffer *buffer) {
+	unsigned long flags;
+
+	spin_lock_irqsave(&itv->lock, flags);
+	list_del_init(&buffer->list);
+	queue->elements--;
+	spin_unlock_irqrestore(&itv->lock, flags);
+}
+
 /* returns first item in queue, doesn't dequeue */
 struct ivtv_buffer *ivtv_deq_peek_head(struct ivtv *itv,
 				       struct ivtv_buffer_list *queue) {
@@ -367,11 +378,14 @@ int ivtv_init_queue(struct ivtv *itv, st
 int ivtv_move_queue(struct ivtv *itv, struct ivtv_buffer_list *src,
 		    struct ivtv_buffer_list *dst) {
 	struct ivtv_buffer *buf;
+	unsigned long flags;
 
-  	while ((buf = ivtv_deq_buf(itv, src))) {
-		ivtv_enq_buf(itv, dst, buf);
-	}
+	spin_lock_irqsave(&itv->lock, flags);
 
+  	while ((buf = __ivtv_deq_buf(src)))
+		__ivtv_enq_buf(dst, buf);
+
+	spin_unlock_irqrestore(&itv->lock, flags);
 	return 0;
 }
 
@@ -1044,18 +1058,43 @@ int ivtv_stop_decode(struct ivtv_open_id
 	return 0;
 }
 
+struct ivtv_v4l2_stream *ivtv_get_busy_stream(struct ivtv *itv, int start) {
+	struct ivtv_v4l2_stream *stream;
+	unsigned long flags;
+	int i;
+
+	spin_lock_irqsave(&itv->lock, flags);
+	
+	for (i = start; i < itv->v4l2.streamcount; i++) {
+		stream = &itv->v4l2.streams[i];
+		if (test_and_clear_bit(IVTV_F_S_DMAP, &stream->s_flags)) {
+			spin_unlock_irqrestore(&itv->lock, flags);
+			return stream;
+		}
+	}
+
+	spin_unlock_irqrestore(&itv->lock, flags);
+	return NULL;
+}
+
 void ivtv_dec_timeout(unsigned long arg) {
 	struct ivtv *itv = (struct ivtv *)arg;
+	struct ivtv_v4l2_stream *stream;
+
+	if (!ivtv_claimed(itv))
+		IVTV_DEBUG(IVTV_DEBUG_ERR, "timed out, but not busy\n");
 
 	/* FIXME mpg only :/ */
-	struct ivtv_v4l2_stream *stream = &itv->v4l2.streams[IVTV_DEC_STREAM_TYPE_MPG];
+	stream = ivtv_get_busy_stream(itv, IVTV_DEC_STREAM_TYPE_MPG);
 
-	if (!test_bit(IVTV_F_S_DMAP, &stream->s_flags))
+	if (!stream) {
+		IVTV_DEBUG(IVTV_DEBUG_ERR, "timed out, but no expecting irq\n");
 		return;
+	}
 
 	IVTV_DEBUG(IVTV_DEBUG_ERR, "ivtv_dec_timeout: lost IRQ; resetting...\n");
+	set_bit(IVTV_F_S_DMAP, &stream->s_flags);
 	ivtv_dec_DMA_done(itv);
-	/* kick it off again! */
 	set_bit(IVTV_F_I_NEEDS_DATA, &itv->i_flags);
 	ivtv_dec_sched_DMA(itv);
 }
@@ -1244,20 +1283,13 @@ void ivtv_DMA_done_tasklet(unsigned long
 
 	IVTV_DEBUG(IVTV_DEBUG_INFO, "DMA Done tasklet\n");
 
-	for (y=0; y < itv->v4l2.streamcount; y++) {
-		if (test_and_clear_bit(IVTV_F_S_DMAP, &itv->v4l2.streams[y].s_flags)) {
-			stmtype = y;
-			break;
-		}
-	}
+	stream = ivtv_get_busy_stream(itv, 0);
 
-	if (stmtype < 0) {
+	if (stream == NULL) {
 		IVTV_DEBUG(IVTV_DEBUG_ERR, "Got DMA-done, but not expecting one\n");
 		goto debug;
 	}
 
-	stream = &itv->v4l2.streams[stmtype];
-
 #if 0
 	/* Silently return if we're in an overflow state */
 	if (test_bit(IVTV_F_S_OVERFLOW, &stream->s_flags))
@@ -1352,7 +1384,6 @@ void ivtv_sched_DMA_tasklet(unsigned lon
 	
 	type   = data[0];
 
-	/* FIXME should check for null on the stream element */
 	if (itv->v4l2.streamcount <= type) {
 		IVTV_DEBUG(IVTV_DEBUG_ERR,"No stream handler for type %d\n", type);
 		ivtv_ignore_DMA_req(itv, type);
@@ -1441,6 +1472,9 @@ void ivtv_sched_DMA_tasklet(unsigned lon
 		}
 		/* mark overflow condition, next free will restart dma req */
 		set_bit(IVTV_F_S_OVERFLOW, &itv->v4l2.streams[type].s_flags);
+		/* FIXME: must wait a little bit, perhaps use timer to fire
+		 * this tasklet */
+		tasklet_schedule(&itv->dma_sched_tq);
 		return;
 	}
 
@@ -1983,7 +2017,7 @@ static int ivtv_YUV_fixup(struct ivtv_v4
 
 #endif
 
-long ivtv_read(struct ivtv_open_id *id, char *ubuf, size_t count) {
+long ivtv_read(struct ivtv_open_id *id, char *ubuf, size_t count, int block) {
 	int x, sleepctr, datalen, retval=0;
 	struct ivtv *itv = id->itv;
 	size_t newcount;
@@ -2017,6 +2051,11 @@ long ivtv_read(struct ivtv_open_id *id, 
 		if (buf)
 			break;
 
+		if (!block) {
+			retval = -EAGAIN;
+			break;
+		}
+
 		ivtv_sleep_timeout(IVTV_SLEEP_WAIT);
 
 		if (signal_pending(current))
@@ -2089,11 +2128,8 @@ long ivtv_read(struct ivtv_open_id *id, 
 
 		/* if buffer is empty or we've read the whole frame */
 		if ((buf->buffer.bytesused == 0)) {
-			spin_lock_irq(&itv->lock);
-
-			list_del(&buf->list);
-			__ivtv_enq_buf(&st->free_q, buf);
-			spin_unlock_irq(&itv->lock);
+			ivtv_del_buf(itv, &st->full_q, buf);
+			ivtv_enq_buf(itv, &st->free_q, buf);
 
 			if (test_and_clear_bit(IVTV_F_S_OVERFLOW, &st->s_flags))
 				tasklet_schedule(&itv->dma_sched_tq);
@@ -2134,28 +2170,25 @@ long ivtv_read(struct ivtv_open_id *id, 
 
 void ivtv_swap_copy(const char *buf, const char *ubuf, size_t count) {
 	u32 *src,*dst;
-	//int y;
+	int y;
 
 	src=(u32 *)ubuf;
 	dst=(u32 *)buf;
 
-	/* FIXME this might break on non X86 */
-// 	#if __CPU__ > 386
-		/* Ultra-efficient swab+copy! */
-		while ((u32)src <= (u32)ubuf + count) { /* byteswap while copying */
-			__asm__ __volatile__ ("bswap %0" :
-					      "=r" (*dst) :
-					      "0" (*src) );
-			src++;dst++;
-		}
-//	#else
-	#if 0
-		/* Old slow memcpy then swab */
-		memcpy((void *)buf,(void *)ubuf,count);
-		for (y = 0; y < count; y += 4) {
-			swab32s( (u32 *)((u32)buf + y));
-		}
-	#endif
+#ifdef CONFIG_X86
+	while ((u32)src <= (u32)ubuf + count) { /* byteswap while copying */
+		__asm__ __volatile__ ("bswap %0" :
+				      "=r" (*dst) :
+				      "0" (*src) );
+		src++;dst++;
+	}
+#else
+	/* Old slow memcpy then swab */
+	memcpy((void *)buf,(void *)ubuf,count);
+	for (y = 0; y < count; y += 4) {
+		swab32s( (u32 *)((u32)buf + y));
+	}
+#endif
 }
 
 int ivtv_fill_dec_buffers(struct ivtv_open_id *id, const char *ubuf, size_t count) {
@@ -2229,10 +2262,8 @@ int ivtv_fill_dec_buffers(struct ivtv_op
 
 		/* enq buffer when full */
 		if (buf->buffer.bytesused == IVTV_DMA_DEC_BUF_SIZE) {
-			spin_lock_irq(&itv->lock);
-			list_del(&buf->list);
-			__ivtv_enq_buf(&stream->full_q, buf);
-			spin_unlock_irq(&itv->lock);
+			ivtv_del_buf(itv, &stream->free_q, buf);
+			ivtv_enq_buf(itv, &stream->full_q, buf);
 		}
 	}
 
@@ -2274,6 +2305,9 @@ void ivtv_dec_sched_DMA(struct ivtv *itv
 
 	IVTV_DEBUG(IVTV_DEBUG_INFO, "ivtv_dec_sched_DMA\n");
 
+	/* must have pinned down the device */
+	IVTV_ASSERT(ivtv_claimed(itv));
+
 	/* fancy way of saying "if (ivtv->dec_needs_data == 0)" */
 	if (!test_bit(IVTV_F_I_NEEDS_DATA, &itv->i_flags)) {
 		IVTV_DEBUG(IVTV_DEBUG_INFO, "DEC: no data needed\n");
@@ -2300,17 +2334,12 @@ void ivtv_dec_sched_DMA(struct ivtv *itv
 			IVTV_DEBUG(IVTV_DEBUG_ERR, "DEC: unknown stream type %d\n",
 				   data[0]);
 			max = 0;
+			ivtv_unclaim(itv);
 			return;
 	}
 
 	stream = &itv->v4l2.streams[type];
 
-	if (test_bit(IVTV_F_I_DMAP, &itv->i_flags)) {
-		IVTV_DEBUG(IVTV_DEBUG_INFO, "DEC: decoder busy, delaying\n");
-		set_bit(IVTV_F_I_NEEDS_DATA, &itv->i_flags);
-		return;
-	}
-	
 	/* If we got this far, we have data to send and it wants it */
 	clear_bit(IVTV_F_I_NEEDS_DATA, &itv->i_flags);
 
@@ -2319,7 +2348,6 @@ void ivtv_dec_sched_DMA(struct ivtv *itv
 	mem_size   = data[2];
 	buffer_bytes = data[3]; /* # bytes in card's buffer */
 
-
 	while ((max > x) && (mem_size > bytes_written)) { /* send a maximum of 
 							     'max' buffers */
 		buf = ivtv_deq_peek_head(itv, &stream->full_q);
@@ -2362,10 +2390,8 @@ void ivtv_dec_sched_DMA(struct ivtv *itv
 
 		/* buffer is empty? */
 		if (buf->buffer.bytesused == 0) {
-			spin_lock_irqsave(&itv->lock, flags);
-			list_del(&buf->list);
-			__ivtv_enq_buf(&stream->dma_q, buf);
-			spin_unlock_irqrestore(&itv->lock, flags);
+			ivtv_del_buf(itv, &stream->full_q, buf);
+			ivtv_enq_buf(itv, &stream->dma_q, buf);
 		}
 		x++;
 	}
@@ -2390,7 +2416,6 @@ void ivtv_dec_sched_DMA(struct ivtv *itv
 	/* note that we're DMA'ing */
 	mod_timer(&itv->dec_timeout, jiffies + DEC_DMA_TIMEOUT);
 	set_bit(IVTV_F_S_DMAP, &stream->s_flags);
-	set_bit(IVTV_F_I_DMAP, &itv->i_flags);
 
 	ivtv_api_irqsafe(itv->dec_mbox, IVTV_API_DEC_DMA_FROM_HOST, 3,&data[0]);
 	spin_unlock_irqrestore(&itv->lock, flags);
@@ -2403,56 +2428,32 @@ void ivtv_dec_sched_DMA(struct ivtv *itv
 void ivtv_dec_DMA_done(struct ivtv *itv) {
         struct ivtv_v4l2_stream *stream=NULL;
 	struct ivtv_buffer *buf;
-	unsigned long flags;
-	int y, stmtype=-1;
+	int y;
 
 	IVTV_DEBUG(IVTV_DEBUG_INFO, "DEC: DMA Done tasklet\n");
 
-	spin_lock_irqsave(&itv->lock, flags);
+	del_timer(&itv->dec_timeout);
 
-	if (!test_and_clear_bit(IVTV_F_I_DMAP, &itv->i_flags)) {
-		IVTV_DEBUG(IVTV_DEBUG_ERR, "DMAP not set\n");
-		spin_unlock_irqrestore(&itv->lock, flags);
-		goto debug;
-	}
-
-	mod_timer(&itv->dec_timeout, jiffies + DEC_DMA_TIMEOUT);
-	
-	for (y=IVTV_DEC_STREAM_TYPE_MPG; y < itv->v4l2.streamcount; y++) {
-		if (test_and_clear_bit(IVTV_F_S_DMAP, &itv->v4l2.streams[y].s_flags)) {
-			stmtype = y;
-			break;
-		}
-	}
-
-	spin_unlock_irqrestore(&itv->lock, flags);
+	stream = ivtv_get_busy_stream(itv, IVTV_DEC_STREAM_TYPE_MPG);
 
 	/* Handle OSD DMA */
-	if ((itv->user_dma_to_device_state != NULL) && 
-	    (itv->user_dma_to_device_state->page_count != 0)) {
+	if (test_and_clear_bit(IVTV_F_I_OSD_DMA, &itv->i_flags)) {
 		IVTV_DEBUG(IVTV_DEBUG_INFO, "OSD: DMA Done\n");
 		
-		itv->user_dma_to_device_state->page_count = 0;
-		
-		up(&itv->user_dma_to_device_state->lock);
-	
 		/* wake all the normal streams, in case they fell asleep */
-		for (y=IVTV_DEC_STREAM_TYPE_MPG; y < itv->v4l2.streamcount; y++) {
+		for (y=IVTV_DEC_STREAM_TYPE_MPG; y < itv->v4l2.streamcount; y++)
 			wake_up(&itv->v4l2.streams[y].waitq);
-		}
-
-		wake_up(&itv->dec_master_w);
 
+		ivtv_unclaim(itv);
 		return;
 	}
 
-	if (stmtype < 0) {
-		IVTV_DEBUG(IVTV_DEBUG_ERR, "DEC: Got DMA-done, not expecting one\n");
+	if (stream == NULL) {
+		IVTV_DEBUG(IVTV_DEBUG_ERR, "DMAP not set\n");
 		goto debug;
 	}
 
 	IVTV_DEBUG(IVTV_DEBUG_INFO, "DEC: Stream %d dma-done\n", y);
-	stream = &itv->v4l2.streams[y];
 
 	while ((buf = ivtv_deq_buf(itv, &stream->dma_q)) != NULL) {
 		IVTV_ASSERT(buf->dma_handle != IVTV_DMA_UNMAPPED);
@@ -2471,7 +2472,8 @@ void ivtv_dec_DMA_done(struct ivtv *itv)
 
 	/* wake up queue filler */
 	wake_up(&stream->waitq);
-	wake_up(&itv->dec_master_w);
+	/* release device */
+	ivtv_unclaim(itv);
 	return;
 debug:
 	ivtv_show_debug_flags(itv);
@@ -2510,46 +2512,39 @@ int ivtv_get_timing_info(struct ivtv *it
 	return 0;
 }
 
+/* claim device by marking it busy for dma */
+void ivtv_claim(struct ivtv *itv) {
+	DECLARE_WAITQUEUE(wait, current);
+	int i = 0;
+
+	add_wait_queue(&itv->dec_master_w, &wait);
+	do {
+		if (i > 5)
+			IVTV_DEBUG(IVTV_DEBUG_ERR, "waited %d seconds to claim device\n", i);
+		set_current_state(TASK_UNINTERRUPTIBLE);
+
+		if (!test_and_set_bit(IVTV_F_I_BUSY, &itv->i_flags))
+			break;
+
+		schedule_timeout(HZ);
+		i++;
+	} while (test_and_set_bit(IVTV_F_I_BUSY, &itv->i_flags));
+	set_current_state(TASK_RUNNING);
+	remove_wait_queue(&itv->dec_master_w, &wait);
+}
+
+void ivtv_unclaim(struct ivtv *itv) {
+	clear_bit(IVTV_F_I_BUSY, &itv->i_flags);
+	wake_up(&itv->dec_master_w);
+}
+
 ssize_t ivtv_write(struct ivtv_open_id *id, const char *ubuf, size_t count) {
-#if 0
-	u32 result, data[IVTV_MBOX_MAX_DATA];
-	u32 dec_cnt;
 	struct ivtv *itv=id->itv;
-#endif
 	int bytes_written=0, ret;
 
 	IVTV_DEBUG(IVTV_DEBUG_INFO, "ivtv_write\n");
 
-#if 0 /* Lots of extra debugging stuff */
-	/* Last DMA status? */
-	if (ivtv_api(itv->dec_mbox, &itv->sem_lock,
-			IVTV_API_DEC_DMA_STATUS,&result,0,&data[0]))	{
-			IVTV_DEBUG(IVTV_DEBUG_ERR, "DEC: error sending status req\n");
-	}
-	
-	IVTV_DEBUG(IVTV_DEBUG_INFO,
-		   "DEC: DMA status bitmask 0x%08x, stream type: 0x%08x\n",
-		   data[0], data[1]);
-
-	/* buffer fullness stats */
-	if (ivtv_api(itv->dec_mbox, &itv->sem_lock,
-			IVTV_API_DEC_XFER_INFO,&result,0,&data[0]))	{
-			IVTV_DEBUG(IVTV_DEBUG_ERR, "DEC: error sending DMA info\n");
-	}
-	
-	IVTV_DEBUG(IVTV_DEBUG_INFO,
-		   "DEC: Stream type: 0x%08x, maxbytes 0x%08x, bufferbytes 0x%08x\n",
-		   data[0], data[2], data[3]);
-
-
-	/* Timing info. */
-	if (ivtv_api(itv->dec_mbox, &itv->sem_lock,
-			IVTV_API_DEC_TIMING_INFO,&result,0,&data[0]))	{
-			IVTV_DEBUG(IVTV_DEBUG_ERR, "DEC: err sending timing info\n");
-	}
-	
-	IVTV_DEBUG(IVTV_DEBUG_INFO, "DEC: Frames decoded 0x%08x\n", data[0]);
-#endif
+	ivtv_claim(itv);
 
 	while (bytes_written < count) { /* completely use up user data 
 					 * before returning */
diff -urp ivtv-latest/driver/ivtv-fb.c ivtv/driver/ivtv-fb.c
--- ivtv-latest/driver/ivtv-fb.c	2003-11-01 09:35:36.000000000 +0100
+++ ivtv/driver/ivtv-fb.c	2003-11-05 14:42:11.202187296 +0100
@@ -137,9 +137,12 @@ console hijacks, and allow you to unload
 #include <linux/pagemap.h>
 
 #include <asm/io.h>
-#include <asm/mtrr.h>
 #include <asm/ioctl.h>
 
+#ifdef CONFIG_MTRR
+#include <asm/mtrr.h>
+#endif
+
 #include <video/fbcon.h>
 #include <video/fbcon-cfb32.h>
 
@@ -156,8 +159,6 @@ static struct ivtv *ivtv_fb;
 
 /* card */
 static unsigned long video_base;	/* physical addr */
-static unsigned long fb_start_aligned_physaddr;	/* video_base rounded down as required by hardware MTRRs */
-static unsigned long fb_end_aligned_physaddr;	/* video_base rounded up as required by hardware MTRRs */
 static unsigned long video_rel_base;	/* address relative to base of decoder memory */
 static int video_size;
 static char *video_vbase;		/* mapped */
@@ -448,7 +449,11 @@ static union {
     u32 cfb32[16];
 } fbcon_cmap;
 
+#ifdef CONFIG_MTRR
 static int mtrr = 1;		//++MTY
+static unsigned long fb_start_aligned_physaddr;	/* video_base rounded down as required by hardware MTRRs */
+static unsigned long fb_end_aligned_physaddr;	/* video_base rounded up as required by hardware MTRRs */
+#endif
 
 static struct display_switch ivtvfb_sw;
 
@@ -629,7 +634,6 @@ int ivtvfb_alloc_user_dma_to_device(stru
 		       (sizeof(struct ivtv_SG_element) *
 			IVTV_MAX_FB_DMA_PAGES), PCI_DMA_TODEVICE);
 
-    sema_init(&dma->lock, 1);
     return 0;
 }
 
@@ -702,7 +706,6 @@ int ivtvfb_execute_user_dma_to_device(st
 				      *dma)
 {
     u32 data[IVTV_MBOX_MAX_DATA], result;
-    u64 tstart;
     int rc;
     IVTV_DEBUG_FB(IVTV_DEBUG_INFO, "ivtvfb_execute_user_dma_to_device\n");
 
@@ -713,25 +716,19 @@ int ivtvfb_execute_user_dma_to_device(st
     IVTV_DEBUG_FB(IVTV_DEBUG_DMA, "Schedule FB DMA: physical address 0x%08x, "
 	   "arraysize 0x%08x, type 0x%08x\n", data[0], data[1], data[2]);
 
-    flush_write_buffers();
-
     // Enable DMA complete interrupt:
-    ivtv_fb->irqmask &= ~IVTV_IRQ_DEC_DMA_COMPLETE;
-    writel(ivtv_fb->irqmask, (ivtv_fb->reg_mem + IVTV_REG_IRQMASK));
+    ivtv_clear_irq_mask(ivtv_fb, IVTV_IRQ_DEC_DMA_COMPLETE);
 
-    rdtscll(tstart);
-
-    set_bit(IVTV_F_I_DMAP, &ivtv_fb->i_flags);
+    set_bit(IVTV_F_I_OSD_DMA, &ivtv_fb->i_flags);
 
     rc = ivtv_api(ivtv_fb->dec_mbox, &ivtv_fb->sem_lock,
 		  IVTV_API_DEC_DMA_FROM_HOST, &result, 3, &data[0]);
 
     if (rc) {
 	IVTV_DEBUG_FB(IVTV_DEBUG_ERR, "error sending DMA info\n");
-	clear_bit(IVTV_F_I_DMAP, &ivtv_fb->i_flags);
+	ivtv_unclaim(ivtv_fb);
     }
 
-    IVTV_DEBUG_FB(IVTV_DEBUG_DMA, "started DMA request at timestamp %lld!\n", tstart);
     IVTV_DEBUG_FB(IVTV_DEBUG_DMA, "OK, scheduled FB DMA!");
     return 0;
 }
@@ -740,7 +737,6 @@ static inline int ivtv_fb_prep_frame(str
 				     unsigned long destaddr, void *srcaddr,
 				     int count)
 {
-    DECLARE_WAITQUEUE(wait, current);
     int rc;
 
     //if (!srcaddr || verify_area(...)) ...
@@ -752,50 +748,29 @@ static inline int ivtv_fb_prep_frame(str
 #ifdef IVTVFB_DEBUG_PER_FRAME
     printk("ivtv_fb_prep_frame: attempting to acquire semaphore...");
 #endif
-    /* This semaphore will be released in the irq handler for host->device DMA complete */
-    if (down_interruptible(&ivtvfb_current_fb_dma.lock))
-	return -ERESTARTSYS;
 
 #ifdef IVTVFB_DEBUG_PER_FRAME
     printk
 	("ivtv_fb_prep_frame: acquired semaphore; scheduling the DMA...");
 #endif
 
-    rc = 0;
-    add_wait_queue(&ivtv_fb->dec_master_w, &wait);
-    do {
-	set_current_state(TASK_INTERRUPTIBLE);
-	/* FIXME mini-race still .. need to port to 'stream' format */
-	if (!test_bit(IVTV_F_I_DMAP, &ivtv_fb->i_flags))
-	    break;
-
-	schedule();
-
-	if (signal_pending(current))
-	    rc = -ERESTARTSYS;
-
-    } while (!rc);
-    set_current_state(TASK_RUNNING);
-    remove_wait_queue(&ivtv_fb->dec_master_w, &wait);
-
-    if (rc)
-	goto out_dma_lock;
+    ivtv_claim(ivtv_fb);
 
     if (0 != (rc = ivtvfb_prep_user_dma_to_device(&ivtvfb_current_fb_dma, destaddr,
 					(char *) srcaddr, count)))
     {
 	IVTV_DEBUG_FB(IVTV_DEBUG_DMA, "err prep user dma to device=%x\n",rc);
-	goto out_dma_lock;
+	goto out_lock;
     }
     if (0 != (rc = ivtvfb_execute_user_dma_to_device(&ivtvfb_current_fb_dma)))
     {
 	IVTV_DEBUG_FB(IVTV_DEBUG_DMA, "err exec user dma to device=%x\n",rc);
-	goto out_dma_lock;
+	goto out_lock;
     }
 
     return 0;
-out_dma_lock:
-    up(&ivtvfb_current_fb_dma.lock);
+out_lock:
+    ivtv_unclaim(ivtv_fb);
     return rc;
 }
 
@@ -1055,6 +1030,7 @@ int __init ivtvfb_init(void)
     ivtvfb_defined.transp.offset = 24;
     ivtvfb_defined.transp.length = 8;
 
+#ifdef CONFIG_MTRR
     if (mtrr) {
 	/* Find the largest power of two that maps the whole buffer */
 	int size_shift = 31;
@@ -1067,7 +1043,6 @@ int __init ivtvfb_init(void)
 	fb_end_aligned_physaddr =
 	    (video_base + (1 << size_shift) - 1) & ~((1 << size_shift) -
 						     1);
-
 	if (mtrr_add
 	    (fb_start_aligned_physaddr,
 	     (fb_end_aligned_physaddr - fb_start_aligned_physaddr),
@@ -1078,6 +1053,7 @@ int __init ivtvfb_init(void)
 		   (unsigned int) fb_end_aligned_physaddr);
 	}
     }
+#endif
 
     strcpy(fb_info.modename, "iTVC15 TV out");
     fb_info.fontname[0] = '\0';
@@ -1111,8 +1087,10 @@ static void ivtvfb_cleanup(void)
     IVTV_DEBUG_FB(IVTV_DEBUG_INFO, "Unloading framebuffer module\n");
     unregister_framebuffer(&fb_info);
     iounmap(video_vbase);
+#ifdef CONFIG_MTRR
     mtrr_del(-1, fb_start_aligned_physaddr,
 	     (fb_end_aligned_physaddr - fb_start_aligned_physaddr));
+#endif
     ivtv_fb->user_dma_to_device_state = NULL;
     ivtvfb_free_user_dma_to_device(&ivtvfb_current_fb_dma);
     ivtv_fb->fb_id = -1;
diff -urp ivtv-latest/driver/ivtv.h ivtv/driver/ivtv.h
--- ivtv-latest/driver/ivtv.h	2003-11-01 09:35:36.000000000 +0100
+++ ivtv/driver/ivtv.h	2003-11-05 15:00:27.999448768 +0100
@@ -21,13 +21,13 @@
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/video_decoder.h>
-#include <asm/uaccess.h>
-#include <asm/semaphore.h>
-#include <asm/system.h>
-#include <linux/unistd.h>
 #include <linux/i2c.h>
 #include <linux/videodev.h>
 #include <linux/list.h>
+#include <linux/unistd.h>
+#include <asm/uaccess.h>
+#include <asm/semaphore.h>
+#include <asm/system.h>
 #include "msp3400.h"
 /* If you don't want to patch to v4l2, grab a copy of
  * videodev2.h and put it in the same dir as this file */ 
@@ -578,15 +578,16 @@ struct ivtv_dec_options {
 	int prebuffer;		/* 0 = no prebuffer, 1 = enabled, see docs */
 };
 
-/* per-stream */
+/* per-stream, s_flags */
 #define IVTV_F_S_DMAP		0
 #define IVTV_F_S_OVERFLOW	1
 #define IVTV_F_S_CAP		2
 
-/* per-interface */
-#define IVTV_F_I_DMAP		3
-#define IVTV_F_I_NEEDS_DATA	4
-#define IVTV_F_I_EOS		5
+/* per-interface, i_flags */
+#define IVTV_F_I_BUSY		0
+#define IVTV_F_I_NEEDS_DATA	1
+#define IVTV_F_I_EOS		2
+#define IVTV_F_I_OSD_DMA	3
 
 struct ivtv_v4l2_stream {
 	int			buf_size; /* size of buffers this stream */
@@ -651,7 +652,6 @@ struct ivtv_open_id {
 };
 
 struct ivtvfb_user_dma_to_device {
-	struct semaphore lock;
   	int page_count;
 	struct ivtv_SG_element* sglist;
 	struct page **map;
@@ -783,7 +783,7 @@ int ivtv_v4l2_setup(struct ivtv *itv);
 /* Capture related */
 int ivtv_stop_all_captures(struct ivtv *itv);
 int ivtv_stop_capture(struct ivtv_open_id *id);
-long ivtv_read(struct ivtv_open_id *id, char *ubuf, size_t count);
+long ivtv_read(struct ivtv_open_id *id, char *ubuf, size_t count, int block);
 int ivtv_get_timing_info(struct ivtv *itv, struct ivtv_ioctl_framesync *info);
 ssize_t ivtv_write(struct ivtv_open_id *id, const char *buf, size_t count);
 int ivtv_stream_has_data(struct ivtv_open_id *id);
@@ -815,6 +815,10 @@ void ivtv_dec_sched_DMA(struct ivtv *itv
 extern void ivtv_set_irq_mask(struct ivtv *itv, unsigned long mask);
 extern void ivtv_clear_irq_mask(struct ivtv *itv, unsigned long mask);
 extern void ivtv_sleep_timeout(int timeout);
+extern void ivtv_claim(struct ivtv *itv);
+extern void ivtv_unclaim(struct ivtv *itv);
+
+#define ivtv_claimed(itv)	test_bit(IVTV_F_I_BUSY, &(itv)->i_flags)
 
 /* Testing/Debugging */
 int  ivtv_close(struct ivtv_open_id *id);
diff -urp ivtv-latest/driver/saa7115.c ivtv/driver/saa7115.c
--- ivtv-latest/driver/saa7115.c	2003-11-01 09:35:37.000000000 +0100
+++ ivtv/driver/saa7115.c	2003-11-03 11:09:24.000000000 +0100
@@ -39,23 +39,23 @@
 #include <linux/fs.h>
 #include <linux/kernel.h>
 #include <linux/major.h>
+#include <linux/init.h>
 
 #include <linux/slab.h>
 
 #include <linux/mm.h>
 #include <linux/pci.h>
 #include <linux/signal.h>
-#include <asm/io.h>
-#include <asm/pgtable.h>
-#include <asm/page.h>
 #include <linux/sched.h>
-#include <asm/segment.h>
 #include <linux/types.h>
 #include <linux/wrapper.h>
 
 #include <linux/videodev.h>
 #include <linux/version.h>
 #include <asm/uaccess.h>
+#include <asm/io.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
 
 MODULE_DESCRIPTION("Philips SAA7115 video decoder driver");
 MODULE_AUTHOR("Kevin Thayer");
diff -urp ivtv-latest/driver/saa7127.c ivtv/driver/saa7127.c
--- ivtv-latest/driver/saa7127.c	2003-11-01 09:35:37.000000000 +0100
+++ ivtv/driver/saa7127.c	2003-11-02 12:12:58.000000000 +0100
@@ -51,6 +51,7 @@
 #include <linux/version.h>
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/fs.h>
 #include <linux/kernel.h>
diff -urp ivtv-latest/driver/tveeprom.c ivtv/driver/tveeprom.c
--- ivtv-latest/driver/tveeprom.c	2003-11-01 09:35:37.000000000 +0100
+++ ivtv/driver/tveeprom.c	2003-11-02 12:09:58.000000000 +0100
@@ -36,6 +36,7 @@
 #include <linux/fs.h>
 #include <linux/kernel.h>
 #include <linux/major.h>
+#include <linux/init.h>
 
 #include <linux/slab.h>