1 files changed, 161 insertions, 170 deletions

diff --git a/linux/drivers/media/dvb/dibusb/dvb-dibusb.c b/linux/drivers/media/dvb/dibusb/dvb-dibusb.c
index 32d52b2c9..65fbd3940 100644
--- a/linux/drivers/media/dvb/dibusb/dvb-dibusb.c
+++ b/linux/drivers/media/dvb/dibusb/dvb-dibusb.c
@@ -18,7 +18,7 @@
  * Acknowledgements
  * 
  *  Amaury Demol (ademol@dibcom.fr) from DiBcom for providing specs and driver
- *  sources, on which this driver (and the dib3000mb frontend) are based.
+ *  sources, on which this driver (and the dib3000mb/mc/p frontends) are based.
  * 
  * see Documentation/dvb/README.dibusb for more information
  */
@@ -36,7 +36,7 @@
 #include "dvb_filter.h"
 #include "dvb_net.h"
 #include "dvb_frontend.h"
-#include "dib3000mb.h"
+#include "dib3000.h"
 
 #include "dvb-dibusb.h"
 
@@ -44,7 +44,7 @@
 /* debug */
 
 #ifdef CONFIG_DVB_DIBCOM_DEBUG
-#define dprintk_new(level,args...) \
+#define dprintk(level,args...) \
 	    do { if ((debug & level)) { printk(args); } } while (0)
 
 #define debug_dump(b,l) if (debug) {\
@@ -57,18 +57,18 @@ static int debug;
 module_param(debug, int, 0x644);
 MODULE_PARM_DESC(debug, "set debugging level (1=info,2=xfer,4=alotmore,8=ts,16=err (|-able)).");
 #else
-#define dprintk_new(args...)
+#define dprintk(args...)
 #define debug_dump(b,l)
 #endif
 
-#define deb_info(args...) dprintk_new(0x01,args)
-#define deb_xfer(args...) dprintk_new(0x02,args)
-#define deb_alot(args...) dprintk_new(0x04,args)
-#define deb_ts(args...)   dprintk_new(0x08,args)
-#define deb_err(args...)   dprintk_new(0x10,args)
+#define deb_info(args...) dprintk(0x01,args)
+#define deb_xfer(args...) dprintk(0x02,args)
+#define deb_alot(args...) dprintk(0x04,args)
+#define deb_ts(args...)   dprintk(0x08,args)
+#define deb_err(args...)   dprintk(0x10,args)
 
 /* Version information */
-#define DRIVER_VERSION "0.0"
+#define DRIVER_VERSION "0.1"
 #define DRIVER_DESC "Driver for DiBcom based USB Budget DVB-T device"
 #define DRIVER_AUTHOR "Patrick Boettcher, patrick.boettcher@desy.de"
 
@@ -83,25 +83,28 @@ static int dibusb_readwrite_usb(struct usb_dibusb *dib,
 	if ((ret = down_interruptible(&dib->usb_sem)))
 		return ret;
 
-	if (dib->streaming && wbuf[0] == DIBUSB_REQ_I2C_WRITE)
-		deb_err("BUG: writing to i2c, while TS-streaming destroys the stream. What"
-			" did you do ? Please enable debugging and send the syslog to the author. (%x reg: %x %x)",
-			wbuf[0],wbuf[2],wbuf[3]);
+	if (dib->feedcount && 
+		wbuf[0] == DIBUSB_REQ_I2C_WRITE && 
+		dib->dibdev->parm->type == DIBUSB1_1)
+		deb_err("BUG: writing to i2c, while TS-streaming destroys the stream."
+				"(%x reg: %x %x)", wbuf[0],wbuf[2],wbuf[3]);
 			
 	debug_dump(wbuf,wlen);
-		
-	ret = usb_bulk_msg(dib->udev,COMMAND_PIPE,
-			wbuf,wlen,&actlen,DIBUSB_I2C_TIMEOUT);
+
+	ret = usb_bulk_msg(dib->udev,usb_sndbulkpipe(dib->udev,
+			dib->dibdev->parm->cmd_pipe), wbuf,wlen,&actlen,
+			DIBUSB_I2C_TIMEOUT);
 		
 	if (ret)
 		err("bulk message failed: %d (%d/%d)",ret,wlen,actlen);
 	else
 		ret = actlen != wlen ? -1 : 0;
 
-	/* an answer is expected */
+	/* an answer is expected, and no error before */
 	if (!ret && rbuf && rlen) {
-		ret = usb_bulk_msg(dib->udev,RESULT_PIPE,rbuf,rlen,
-				&actlen,DIBUSB_I2C_TIMEOUT);
+		ret = usb_bulk_msg(dib->udev,usb_rcvbulkpipe(dib->udev,
+				dib->dibdev->parm->result_pipe),rbuf,rlen,&actlen,
+				DIBUSB_I2C_TIMEOUT);
 
 		if (ret)
 			err("recv bulk message failed: %d",ret);
@@ -141,82 +144,6 @@ static int dibusb_i2c_msg(struct usb_dibusb *dib, u8 addr,
 /*
  * DVB stuff 
  */
-
-static struct dibusb_pid * dibusb_get_free_pid(struct usb_dibusb *dib)
-{
-	int i;
-	unsigned long flags;
-	struct dibusb_pid *dpid = NULL;
-
-	spin_lock_irqsave(&dib->pid_list_lock,flags);
-	for (i=0; i < DIBUSB_MAX_PIDS; i++)
-		if (!dib->pid_list[i].active) {
-			dpid = dib->pid_list + i;
-			dpid->active = 1;
-			break;
-		}
-	spin_unlock_irqrestore(&dib->pid_list_lock,flags);
-	return dpid;
-}
-
-static int dibusb_start_xfer(struct usb_dibusb *dib)
-{
-	u8 b[4] = { 
-		(DIB3000MB_REG_FIFO >> 8) & 0xff,
-		(DIB3000MB_REG_FIFO) & 0xff,
-		(DIB3000MB_FIFO_ACTIVATE >> 8) & 0xff,
-		(DIB3000MB_FIFO_ACTIVATE) & 0xff
-	};
-	dib->streaming = 1;
-	deb_ts("start streaming\n");
-	return dibusb_i2c_msg(dib,DIBUSB_DEMOD_I2C_ADDR_DEFAULT,b,4,NULL,0);
-}
-
-static int dibusb_stop_xfer(struct usb_dibusb *dib)
-{
-	u8 b[4] = { 
-		(DIB3000MB_REG_FIFO >> 8) & 0xff,
-		(DIB3000MB_REG_FIFO) & 0xff,
-		(DIB3000MB_FIFO_INHIBIT >> 8) & 0xff,
-		(DIB3000MB_FIFO_INHIBIT) & 0xff
-	};
-	dib->streaming = 0;
-	deb_ts("stop streaming\n");
-	return dibusb_i2c_msg(dib,DIBUSB_DEMOD_I2C_ADDR_DEFAULT,b,4,NULL,0);
-}
-
-static int dibusb_set_pid(struct dibusb_pid *dpid)
-{
-	struct usb_dibusb *dib = dpid->dib;
-	u16 pid = dpid->pid | (dpid->active ? DIB3000MB_ACTIVATE_FILTERING : 0);
-	u8 b[4] = { 
-		(dpid->reg >> 8) & 0xff,
-		(dpid->reg) & 0xff,
-		(pid >> 8) & 0xff,
-		(pid) & 0xff
-	};
-	int ret;
-	
-	/* firmware bug, i2c write during mpeg transfer */
-	if (dib->feedcount) {
-		deb_info("stop streaming\n");
-		ret = dibusb_stop_xfer(dib);
-	}
-	
-	if (dpid->active) 
-		dib->feedcount++;
-	else
-		dib->feedcount--;
-
-	ret = dibusb_i2c_msg(dib,DIBUSB_DEMOD_I2C_ADDR_DEFAULT,b,4,NULL,0);
-	
-	if (ret == 0 && dib->feedcount) {
-		deb_info("start streaming\n");
-		ret = dibusb_start_xfer(dib);
-	}
-	return ret;
-}
-
 static void dibusb_urb_complete(struct urb *urb, struct pt_regs *ptregs)
 {
 	struct usb_dibusb *dib = urb->context;
@@ -231,7 +158,7 @@ static void dibusb_urb_complete(struct urb *urb, struct pt_regs *ptregs)
 		/* Francois recommends to drop not full-filled packets, even if they may 
 		 * contain valid TS packets
 		 */
-		if (urb->actual_length == DIBUSB_TS_DEFAULT_SIZE && dib->dvb_is_ready)
+		if (urb->actual_length == dib->dibdev->parm->default_size && dib->dvb_is_ready)
 			dvb_dmx_swfilter_packets(&dib->demux, (u8*) urb->transfer_buffer,urb->actual_length/188);
 		else
 			deb_ts("URB dropped because of the " 
@@ -242,46 +169,73 @@ static void dibusb_urb_complete(struct urb *urb, struct pt_regs *ptregs)
 	usb_submit_urb(urb,GFP_KERNEL);
 }
 
-
-static int dibusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
+static int dibusb_ctrl_feed(struct usb_dibusb *dib, int pid, int onoff) 
 {
-//	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
-	struct usb_dibusb *dib = dvbdmxfeed->demux->priv;
-	struct dibusb_pid *dpid;
-
-	deb_ts("pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid,dvbdmxfeed->type);
+	if (dib->dibdev->parm->firmware_bug && dib->feedcount) {
+		deb_ts("stop feeding\n");
+		if (dib->xfer_ops.fifo_ctrl != NULL) {
+			if (dib->xfer_ops.fifo_ctrl(dib->fe,0)) {
+				err("error while inhibiting fifo.");
+				return -ENODEV;
+			}
+		} else {
+			err("fifo_ctrl is not set.");
+			return -ENODEV;
+		}
+	}
+	
+	dib->feedcount += onoff ? 1 : -1;
 
-	if ((dpid = dibusb_get_free_pid(dib)) == NULL) {
-		err("no free pid in list.");
+	if (dib->xfer_ops.pid_ctrl != NULL) {
+		if (dib->xfer_ops.pid_ctrl(dib->fe,pid,onoff) < 0) {
+			err("no free pid in list.");
+			return -ENODEV;
+		}
+	} else {
+		err("no pid ctrl callback.");
 		return -ENODEV;
 	}
-	dvbdmxfeed->priv = dpid;
-	dpid->pid = dvbdmxfeed->pid;
-
-	dibusb_set_pid(dpid);
-
+	/* 
+	 * start the feed, either if there is the firmware bug or 
+	 * if this was the first pid to set.
+	 */
+	if (dib->dibdev->parm->firmware_bug || dib->feedcount == onoff) {
+		deb_ts("start feeding\n");
+		if (dib->xfer_ops.fifo_ctrl != NULL) {
+			if (dib->xfer_ops.fifo_ctrl(dib->fe,1)) {
+				err("error while enabling fifo.");
+				return -ENODEV;
+			}
+		} else {
+			err("fifo_ctrl is not set.");
+			return -ENODEV;
+		}
+	}
 	return 0;
 }
 
-static int dibusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
+static int dibusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
 {
-	struct dibusb_pid *dpid = (struct dibusb_pid *) dvbdmxfeed->priv;
+	struct usb_dibusb *dib = dvbdmxfeed->demux->priv;
+	deb_ts("pid: 0x%04x, feedtype: %d\n", dvbdmxfeed->pid,dvbdmxfeed->type);
+	dvbdmxfeed->priv = dib;
+	return dibusb_ctrl_feed(dib,dvbdmxfeed->pid,1);
+}
 
-	deb_ts("stopfeed pid: 0x%04x, feedtype: %d\n",dvbdmxfeed->pid, dvbdmxfeed->type);
-	
-	if (dpid == NULL)
-		err("channel in dmxfeed->priv was NULL");
-	else {
-		dpid->active = 0;
-		dpid->pid = 0;
-		dibusb_set_pid(dpid);
+static int dibusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
+{
+	struct usb_dibusb *dib = (struct usb_dibusb *) dvbdmxfeed->priv;
+	if (dib == NULL) {
+		err("dib in dmxfeed->priv was NULL");
+		return -EINVAL;
 	}
-
-	return 0;
+	deb_ts("dvbdmxfeed pid: 0x%04x, feedtype: %d\n",
+			dvbdmxfeed->pid, dvbdmxfeed->type);
+	return dibusb_ctrl_feed(dib,dvbdmxfeed->pid,0);
 }
 
 /*
- * Cypress transfers
+ * Cypress controls
  */
 
 #if 0
@@ -318,8 +272,6 @@ static int dibusb_read_remote_control(struct usb_dibusb *dib)
 	if ((ret = dibusb_readwrite_usb(dib,b,1,rb,5))) 
 		return ret;
 
-
-	
 	switch (rb[0]) {
 		case DIBUSB_RC_NEC_KEY_PRESSED:
 
@@ -398,7 +350,7 @@ static u32 dibusb_i2c_func(struct i2c_adapter *adapter)
 
 static int thomson_cable_eu_pll_set(struct dvb_frontend* fe, struct dvb_frontend_parameters* params);
 
-static struct dib3000mb_config thomson_cable_eu_config = {
+static struct dib3000_config thomson_cable_eu_config = {
 	.demod_address = 0x10,
 	.pll_addr = 194,
 	.pll_set = thomson_cable_eu_pll_set,
@@ -446,7 +398,7 @@ static struct i2c_algorithm dibusb_algo = {
 
 static void frontend_init(struct usb_dibusb* dib)
 {
-	dib->fe = dib3000mb_attach(&thomson_cable_eu_config, &dib->i2c_adap);
+	dib->fe = dib3000mb_attach(&thomson_cable_eu_config, &dib->i2c_adap,&dib->xfer_ops);
 
 	if (dib->fe == NULL) {
 		printk("dvb-dibusb: A frontend driver was not found for device %04x/%04x\n",
@@ -462,7 +414,6 @@ static void frontend_init(struct usb_dibusb* dib)
 	}
 }
 
-
 static int dibusb_dvb_init(struct usb_dibusb *dib)
 {
 	int ret;
@@ -498,8 +449,8 @@ static int dibusb_dvb_init(struct usb_dibusb *dib)
 	dib->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
 
 	dib->demux.priv = (void *)dib;
-	dib->demux.filternum = DIBUSB_MAX_PIDS;
-	dib->demux.feednum = DIBUSB_MAX_PIDS;
+	/* get pidcount from demod */
+	dib->demux.feednum = dib->demux.filternum = 16;
 	dib->demux.start_feed = dibusb_start_feed;
 	dib->demux.stop_feed = dibusb_stop_feed;
 	dib->demux.write_to_decoder = NULL;
@@ -552,21 +503,36 @@ static int dibusb_dvb_exit(struct usb_dibusb *dib)
 static int dibusb_exit(struct usb_dibusb *dib)
 {
 	int i;
-	for (i = 0; i < DIBUSB_TS_NUM_URBS; i++) 
-		if (dib->buf_urb[i] != NULL) {
-			deb_info("killing URB no. %d.\n",i);
-			usb_kill_urb(dib->buf_urb[i]); // TODO kernel version ifdef for unlink_urb
-			
-			deb_info("freeing URB no. %d.\n",i);
-			usb_free_urb(dib->buf_urb[i]);
+	if (dib->urb_list != NULL) {
+		for (i = 0; i < dib->dibdev->parm->num_urbs; i++) {
+			if (dib->urb_list[i] != NULL) {
+				deb_info("killing URB no. %d.\n",i);
+
+				/* stop the URBs */
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,7)
+				usb_unlink_urb(dib->urb_list[i]); 
+#else
+				usb_kill_urb(dib->urb_list[i]);
+#endif
+				
+				deb_info("freeing URB no. %d.\n",i);
+				/* free the URBs */
+				usb_free_urb(dib->urb_list[i]);
+			}
 		}
-	pci_free_consistent(NULL,DIBUSB_TS_BUFFER_SIZE,dib->buffer,dib->dma_handle);
+		/* free the urb array */
+		kfree(dib->urb_list);
+	}
+	
+	pci_free_consistent(NULL,
+		dib->dibdev->parm->urb_buf_size*dib->dibdev->parm->num_urbs,dib->buffer,
+		dib->dma_handle);
 	return 0;
 }
 
 static int dibusb_init(struct usb_dibusb *dib)
 {
-	int ret,i;
+	int ret,i,bufsize;
 	sema_init(&dib->usb_sem, 1);
 	sema_init(&dib->i2c_sem, 1);
 	
@@ -574,45 +540,51 @@ static int dibusb_init(struct usb_dibusb *dib)
 	 * when reloading the driver w/o replugging the device 
 	 * a timeout occures, this helps
 	 */
-	usb_clear_halt(dib->udev,COMMAND_PIPE);
-	usb_clear_halt(dib->udev,RESULT_PIPE);
-	usb_clear_halt(dib->udev,DATA_PIPE);
+	usb_clear_halt(dib->udev,usb_sndbulkpipe(dib->udev,dib->dibdev->parm->cmd_pipe));
+	usb_clear_halt(dib->udev,usb_rcvbulkpipe(dib->udev,dib->dibdev->parm->result_pipe));
+	usb_clear_halt(dib->udev,usb_rcvbulkpipe(dib->udev,dib->dibdev->parm->data_pipe));
 
-	/* dibusb_reset_cpu(dib); */
-
-	if ((dib->buffer = pci_alloc_consistent(NULL,DIBUSB_TS_BUFFER_SIZE, &dib->dma_handle)) == NULL) {
+	/* allocate the array for the data transfer URBs */
+	dib->urb_list = kmalloc(dib->dibdev->parm->num_urbs*sizeof(struct urb *),GFP_KERNEL);
+	if (dib->urb_list == NULL)
+		return -ENOMEM;
+	memset(dib->urb_list,0,dib->dibdev->parm->num_urbs*sizeof(struct urb *));
+	
+	bufsize = dib->dibdev->parm->num_urbs*dib->dibdev->parm->urb_buf_size;
+	deb_info("allocate %d bytes as buffersize for all URBs\n",bufsize);
+	/* allocate the actual buffer for the URBs */
+	if ((dib->buffer = pci_alloc_consistent(NULL,bufsize,&dib->dma_handle)) == NULL) {
+		dibusb_exit(dib);
 		return -ENOMEM;
 	}
-	memset(dib->buffer,0,DIBUSB_TS_BUFFER_SIZE);
-	for (i = 0; i < DIBUSB_TS_NUM_URBS; i++) {
-		if (!(dib->buf_urb[i] = usb_alloc_urb(0,GFP_KERNEL))) {
+	memset(dib->buffer,0,bufsize);
+
+	/* allocate and submit the URBs */
+	for (i = 0; i < dib->dibdev->parm->num_urbs; i++) {
+		if (!(dib->urb_list[i] = usb_alloc_urb(0,GFP_KERNEL))) {
 			dibusb_exit(dib);
 			return -ENOMEM;
 		}
 		deb_info("submitting URB no. %d\n",i);
 
-		usb_fill_bulk_urb( dib->buf_urb[i], dib->udev, DATA_PIPE,
-				&dib->buffer[i*DIBUSB_TS_URB_BUFFER_SIZE], DIBUSB_TS_URB_BUFFER_SIZE, 
+		usb_fill_bulk_urb( dib->urb_list[i], dib->udev, 
+				usb_rcvbulkpipe(dib->udev,dib->dibdev->parm->data_pipe),
+				&dib->buffer[i*dib->dibdev->parm->urb_buf_size], 
+				dib->dibdev->parm->urb_buf_size, 
 				dibusb_urb_complete, dib);
-		dib->buf_urb[i]->transfer_flags = 0;
+		
+		dib->urb_list[i]->transfer_flags = 0;
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,7)
+		dib->urb_list[i]->timeout = 0;
+#endif
 
-		if ((ret = usb_submit_urb(dib->buf_urb[i],GFP_KERNEL))) {
+		if ((ret = usb_submit_urb(dib->urb_list[i],GFP_KERNEL))) {
 			err("could not submit buffer urb no. %d\n",i);
 			dibusb_exit(dib);
 			return ret;
 		}
 	}
 	
-	dib->pid_list_lock = SPIN_LOCK_UNLOCKED;
-	for (i=0; i < DIBUSB_MAX_PIDS; i++) {
-		dib->pid_list[i].reg = i+DIB3000MB_REG_FIRST_PID;
-		dib->pid_list[i].pid = 0;
-		dib->pid_list[i].active = 0;
-		dib->pid_list[i].dib = dib;
-	}
-
-	dib->feedcount = 0;
-	dib->streaming = 0;
 	dib->dvb_is_ready = 0;
 	
 	if ((ret = dibusb_dvb_init(dib))) {
@@ -635,17 +607,20 @@ static int dibusb_loadfirmware(struct usb_device *udev,
 		struct dibusb_device *dibdev) 
 {
 	const struct firmware *fw = NULL;
+	const char **fws;
 	u16 addr;
 	u8 *b,*p;
 	int ret = 0,i;
-
-	for (i = 0; i < sizeof(valid_firmware_filenames)/sizeof(const char*); i++) {
-		if ((ret = request_firmware(&fw, valid_firmware_filenames[i], &udev->dev)) == 0) {
-			info("using firmware file (%s).",valid_firmware_filenames[i]);
+	
+	fws = dibdev->parm->fw_filenames;
+	
+	for (i = 0; i < sizeof(fws)/sizeof(const char*); i++) {
+		if ((ret = request_firmware(&fw, fws[i], &udev->dev)) == 0) {
+			info("using firmware file (%s).",fws[i]);
 			break;
 		}
 		deb_info("tried to find '%s' firmware - unsuccessful. (%d)\n",
-				valid_firmware_filenames[i],ret);
+				fws[i],ret);
 	}
 		
 	if (fw == NULL) {
@@ -665,7 +640,7 @@ static int dibusb_loadfirmware(struct usb_device *udev,
 
 		/* stop the CPU */
 		reset = 1;
-		if ((ret = dibusb_writemem(udev,DIBUSB_CPU_CSREG,&reset,1)) != 1) 
+		if ((ret = dibusb_writemem(udev,dibdev->parm->usb_cpu_csreg,&reset,1)) != 1) 
 			err("could not stop the USB controller CPU.");
 		for(i = 0; p[i+3] == 0 && i < fw->size; ) { 
 			b = (u8 *) &p[i];
@@ -687,7 +662,7 @@ static int dibusb_loadfirmware(struct usb_device *udev,
 			ret = 0;
 		/* restart the CPU */
 		reset = 0;
-		if (ret || dibusb_writemem(udev,DIBUSB_CPU_CSREG,&reset,1) != 1) {
+		if (ret || dibusb_writemem(udev,dibdev->parm->usb_cpu_csreg,&reset,1) != 1) {
 			err("could not restart the USB controller CPU.");
 			ret = -EINVAL;
 		}
@@ -735,6 +710,21 @@ static int dibusb_probe(struct usb_interface *intf,
 	if (cold)
 		ret = dibusb_loadfirmware(udev,dibdev);
 	else {
+		switch (udev->speed) {
+			case USB_SPEED_LOW:
+				err("cannot handle USB speed because it is to sLOW.");
+				break;
+			case USB_SPEED_FULL:
+				info("running at FULL speed, will use pid filter.");
+				break;
+			case USB_SPEED_HIGH:
+				info("running at HIGH speed, will deliver the complete TS.");
+				break;
+			case USB_SPEED_UNKNOWN: /* fall through */
+			default:
+				err("cannot handle USB speed because it is unkown.");
+				break;
+		}
 		dib = kmalloc(sizeof(struct usb_dibusb),GFP_KERNEL);
 		if (dib == NULL) {
 			err("no memory");
@@ -748,6 +738,7 @@ static int dibusb_probe(struct usb_interface *intf,
 		usb_set_intfdata(intf, dib);
 
 		ret = dibusb_init(dib);
+
 	}
 	
 	if (ret == 0)