Commit 91b94366 authored by Uwe Bugla's avatar Uwe Bugla Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (11288): Code cleanup (passes checkpatch now) of the b2c2-flexcop-drivers 2/2 



This is the second part of the code cleanup changing the usb and pci-driver cores.

Signed-off-by: default avatarUwe Bugla <uwe.bugla@gmx.de>
Signed-off-by: default avatarPatrick Boettcher <pb@linuxtv.org>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 1589a993

drivers/media/dvb/b2c2/flexcop-pci.c

+82 −82
Original line number Diff line number Diff line 
/*

 * This file is part of linux driver the digital TV devices equipped with B2C2 FlexcopII(b)/III

 *

 * flexcop-pci.c - covers the PCI part including DMA transfers.

 *

 * see flexcop.c for copyright information.

 * Linux driver the digital TV devices equipped with B2C2 FlexcopII(b)/III

 * flexcop-pci.c - covers the PCI part including DMA transfers

 * see flexcop.c for copyright information

 */



#define FC_LOG_PREFIX "flexcop-pci"
@@ -11,7 +9,8 @@ 


static int enable_pid_filtering = 1;

module_param(enable_pid_filtering, int, 0444);

MODULE_PARM_DESC(enable_pid_filtering, "enable hardware pid filtering: supported values: 0 (fullts), 1");

MODULE_PARM_DESC(enable_pid_filtering,

	"enable hardware pid filtering: supported values: 0 (fullts), 1");



static int irq_chk_intv = 100;

module_param(irq_chk_intv, int, 0644);
@@ -58,23 +57,23 @@ struct flexcop_pci { 
	struct flexcop_dma dma[2];



	int active_dma1_addr; /* 0 = addr0 of dma1; 1 = addr1 of dma1 */

	u32 last_dma1_cur_pos; /* position of the pointer last time the timer/packet irq occured */

	u32 last_dma1_cur_pos;

	/* position of the pointer last time the timer/packet irq occured */

	int count;

	int count_prev;

	int stream_problem;



	spinlock_t irq_lock;



	unsigned long last_irq;



	struct delayed_work irq_check_work;



	struct flexcop_device *fc_dev;

};



static int lastwreg, lastwval, lastrreg, lastrval;



static flexcop_ibi_value flexcop_pci_read_ibi_reg (struct flexcop_device *fc, flexcop_ibi_register r)

static flexcop_ibi_value flexcop_pci_read_ibi_reg(struct flexcop_device *fc,

		flexcop_ibi_register r)

{

	struct flexcop_pci *fc_pci = fc->bus_specific;

	flexcop_ibi_value v;
@@ -88,7 +87,8 @@ static flexcop_ibi_value flexcop_pci_read_ibi_reg (struct flexcop_device *fc, fl 
	return v;

}



static int flexcop_pci_write_ibi_reg(struct flexcop_device *fc, flexcop_ibi_register r, flexcop_ibi_value v)

static int flexcop_pci_write_ibi_reg(struct flexcop_device *fc,

		flexcop_ibi_register r, flexcop_ibi_value v)

{

	struct flexcop_pci *fc_pci = fc->bus_specific;
@@ -151,7 +151,6 @@ static irqreturn_t flexcop_pci_isr(int irq, void *dev_id) 
	irqreturn_t ret = IRQ_HANDLED;



	spin_lock_irqsave(&fc_pci->irq_lock, flags);



	v = fc->read_ibi_reg(fc, irq_20c);



	/* errors */
@@ -169,20 +168,25 @@ static irqreturn_t flexcop_pci_isr(int irq, void *dev_id) 


	if (v.irq_20c.DMA1_IRQ_Status == 1) {

		if (fc_pci->active_dma1_addr == 0)

			flexcop_pass_dmx_packets(fc_pci->fc_dev,fc_pci->dma[0].cpu_addr0,fc_pci->dma[0].size / 188);

			flexcop_pass_dmx_packets(fc_pci->fc_dev,

					fc_pci->dma[0].cpu_addr0,

					fc_pci->dma[0].size / 188);

		else

			flexcop_pass_dmx_packets(fc_pci->fc_dev,fc_pci->dma[0].cpu_addr1,fc_pci->dma[0].size / 188);

			flexcop_pass_dmx_packets(fc_pci->fc_dev,

					fc_pci->dma[0].cpu_addr1,

					fc_pci->dma[0].size / 188);



		deb_irq("page change to page: %d\n",!fc_pci->active_dma1_addr);

		fc_pci->active_dma1_addr = !fc_pci->active_dma1_addr;

	} else if (v.irq_20c.DMA1_Timer_Status == 1) {

		/* for the timer IRQ we only can use buffer dmx feeding, because we don't have

		 * complete TS packets when reading from the DMA memory */

	} else if (v.irq_20c.DMA1_Timer_Status == 1) {

		dma_addr_t cur_addr =

			fc->read_ibi_reg(fc,dma1_008).dma_0x8.dma_cur_addr << 2;

		u32 cur_pos = cur_addr - fc_pci->dma[0].dma_addr0;



		deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, last_cur_pos: %08x ",

		deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, "

			"last_cur_pos: %08x ",

				jiffies_to_usecs(jiffies - fc_pci->last_irq),

				v.raw, (unsigned long long)cur_addr, cur_pos,

				fc_pci->last_dma1_cur_pos);
@@ -192,17 +196,23 @@ static irqreturn_t flexcop_pci_isr(int irq, void *dev_id) 
		 * pass the data from last_cur_pos to the buffer end to the demux

		 */

		if (cur_pos < fc_pci->last_dma1_cur_pos) {

			deb_irq(" end was reached: passing %d bytes ",(fc_pci->dma[0].size*2 - 1) - fc_pci->last_dma1_cur_pos);

			deb_irq(" end was reached: passing %d bytes ",

				(fc_pci->dma[0].size*2 - 1) -

				fc_pci->last_dma1_cur_pos);

			flexcop_pass_dmx_data(fc_pci->fc_dev,

					fc_pci->dma[0].cpu_addr0 + fc_pci->last_dma1_cur_pos,

					(fc_pci->dma[0].size*2) - fc_pci->last_dma1_cur_pos);

				fc_pci->dma[0].cpu_addr0 +

					fc_pci->last_dma1_cur_pos,

				(fc_pci->dma[0].size*2) -

					fc_pci->last_dma1_cur_pos);

			fc_pci->last_dma1_cur_pos = 0;

		}



		if (cur_pos > fc_pci->last_dma1_cur_pos) {

			deb_irq(" passing %d bytes ",cur_pos - fc_pci->last_dma1_cur_pos);

			deb_irq(" passing %d bytes ",

				cur_pos - fc_pci->last_dma1_cur_pos);

			flexcop_pass_dmx_data(fc_pci->fc_dev,

					fc_pci->dma[0].cpu_addr0 + fc_pci->last_dma1_cur_pos,

				fc_pci->dma[0].cpu_addr0 +

					fc_pci->last_dma1_cur_pos,

				cur_pos - fc_pci->last_dma1_cur_pos);

		}

		deb_irq("\n");
@@ -210,12 +220,12 @@ static irqreturn_t flexcop_pci_isr(int irq, void *dev_id) 
		fc_pci->last_dma1_cur_pos = cur_pos;

		fc_pci->count++;

	} else {

		deb_irq("isr for flexcop called, apparently without reason (%08x)\n",v.raw);

		deb_irq("isr for flexcop called, "

			"apparently without reason (%08x)\n", v.raw);

		ret = IRQ_NONE;

	}



	spin_unlock_irqrestore(&fc_pci->irq_lock, flags);



	return ret;

}
@@ -225,50 +235,46 @@ static int flexcop_pci_stream_control(struct flexcop_device *fc, int onoff) 
	if (onoff) {

		flexcop_dma_config(fc, &fc_pci->dma[0], FC_DMA_1);

		flexcop_dma_config(fc, &fc_pci->dma[1], FC_DMA_2);



		flexcop_dma_config_timer(fc, FC_DMA_1, 0);



		flexcop_dma_xfer_control(fc,FC_DMA_1,FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1,1);

		flexcop_dma_xfer_control(fc, FC_DMA_1,

				FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1, 1);

		deb_irq("DMA xfer enabled\n");



		fc_pci->last_dma1_cur_pos = 0;

		flexcop_dma_control_timer_irq(fc, FC_DMA_1, 1);

		deb_irq("IRQ enabled\n");



		fc_pci->count_prev = fc_pci->count;



//		fc_pci->active_dma1_addr = 0;

//		flexcop_dma_control_size_irq(fc,FC_DMA_1,1);



	} else {

		flexcop_dma_control_timer_irq(fc, FC_DMA_1, 0);

		deb_irq("IRQ disabled\n");



//		flexcop_dma_control_size_irq(fc,FC_DMA_1,0);



		flexcop_dma_xfer_control(fc,FC_DMA_1,FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1,0);

		flexcop_dma_xfer_control(fc, FC_DMA_1,

			 FC_DMA_SUBADDR_0 | FC_DMA_SUBADDR_1, 0);

		deb_irq("DMA xfer disabled\n");

	}



	return 0;

}



static int flexcop_pci_dma_init(struct flexcop_pci *fc_pci)

{

	int ret;

	if ((ret = flexcop_dma_allocate(fc_pci->pdev,&fc_pci->dma[0],FC_DEFAULT_DMA1_BUFSIZE)) != 0)

	ret = flexcop_dma_allocate(fc_pci->pdev, &fc_pci->dma[0],

			FC_DEFAULT_DMA1_BUFSIZE);

	if (ret != 0)

		return ret;



	if ((ret = flexcop_dma_allocate(fc_pci->pdev,&fc_pci->dma[1],FC_DEFAULT_DMA2_BUFSIZE)) != 0) {

	ret = flexcop_dma_allocate(fc_pci->pdev, &fc_pci->dma[1],

			FC_DEFAULT_DMA2_BUFSIZE);

	if (ret != 0) {

		flexcop_dma_free(&fc_pci->dma[0]);

		return ret;

	}



	flexcop_sram_set_dest(fc_pci->fc_dev,FC_SRAM_DEST_MEDIA | FC_SRAM_DEST_NET, FC_SRAM_DEST_TARGET_DMA1);

	flexcop_sram_set_dest(fc_pci->fc_dev,FC_SRAM_DEST_CAO   | FC_SRAM_DEST_CAI, FC_SRAM_DEST_TARGET_DMA2);



	flexcop_sram_set_dest(fc_pci->fc_dev, FC_SRAM_DEST_MEDIA |

			FC_SRAM_DEST_NET, FC_SRAM_DEST_TARGET_DMA1);

	flexcop_sram_set_dest(fc_pci->fc_dev, FC_SRAM_DEST_CAO |

			FC_SRAM_DEST_CAI, FC_SRAM_DEST_TARGET_DMA2);

	fc_pci->init_state |= FC_PCI_DMA_INIT;



	return ret;

}
@@ -291,12 +297,8 @@ static int flexcop_pci_init(struct flexcop_pci *fc_pci) 


	if ((ret = pci_enable_device(fc_pci->pdev)) != 0)

		return ret;



	pci_set_master(fc_pci->pdev);



	/* enable interrupts */

	// pci_write_config_dword(pdev, 0x6c, 0x8000);



	if ((ret = pci_request_regions(fc_pci->pdev, DRIVER_NAME)) != 0)

		goto err_pci_disable_device;
@@ -339,8 +341,8 @@ static void flexcop_pci_exit(struct flexcop_pci *fc_pci) 
	fc_pci->init_state &= ~FC_PCI_INIT;

}





static int flexcop_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)

static int flexcop_pci_probe(struct pci_dev *pdev,

		const struct pci_device_id *ent)

{

	struct flexcop_device *fc;

	struct flexcop_pci *fc_pci;
@@ -359,7 +361,6 @@ static int flexcop_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e 
	fc->write_ibi_reg = flexcop_pci_write_ibi_reg;

	fc->i2c_request = flexcop_i2c_request;

	fc->get_mac_addr = flexcop_eeprom_check_mac_addr;



	fc->stream_control = flexcop_pci_stream_control;



	if (enable_pid_filtering)
@@ -369,7 +370,6 @@ static int flexcop_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e 


	fc->pid_filtering = enable_pid_filtering;

	fc->bus_type = FC_PCI;



	fc->dev = &pdev->dev;

	fc->owner = THIS_MODULE;
@@ -390,8 +390,9 @@ static int flexcop_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e 


	if (irq_chk_intv > 0)

		schedule_delayed_work(&fc_pci->irq_check_work,

		msecs_to_jiffies(irq_chk_intv < 100 ? 100 : irq_chk_intv));



				msecs_to_jiffies(irq_chk_intv < 100 ?

					100 :

					irq_chk_intv));

	return ret;



err_fc_exit:
@@ -421,7 +422,6 @@ static void flexcop_pci_remove(struct pci_dev *pdev) 


static struct pci_device_id flexcop_pci_tbl[] = {

	{ PCI_DEVICE(0x13d0, 0x2103) },

/*	{ PCI_DEVICE(0x13d0, 0x2200) }, ? */

	{ },

};

drivers/media/dvb/b2c2/flexcop-usb.c

+199 −169
Original line number Diff line number Diff line 
/*

 * This file is part of linux driver the digital TV devices equipped with B2C2 FlexcopII(b)/III

 *

 * flexcop-usb.c - covers the USB part.

 *

 * see flexcop.c for copyright information.

 * Linux driver for digital TV devices equipped with B2C2 FlexcopII(b)/III

 * flexcop-usb.c - covers the USB part

 * see flexcop.c for copyright information

 */



#define FC_LOG_PREFIX "flexcop_usb"

#include "flexcop-usb.h"

#include "flexcop-common.h"
@@ -18,12 +15,14 @@ 
/* debug */

#ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG

#define dprintk(level,args...) \

	    do { if ((debug & level)) { printk(args); } } while (0)

#define debug_dump(b,l,method) {\

	do { if ((debug & level)) printk(args); } while (0)



#define debug_dump(b, l, method) do {\

	int i; \

	for (i = 0; i < l; i++) method("%02x ", b[i]); \

	for (i = 0; i < l; i++) \

		method("%02x ", b[i]); \

	method("\n"); \

}

} while (0)



#define DEBSTATUS ""

#else
@@ -34,7 +33,8 @@ 


static int debug;

module_param(debug, int, 0644);

MODULE_PARM_DESC(debug, "set debugging level (1=info,ts=2,ctrl=4,i2c=8,v8mem=16 (or-able))." DEBSTATUS);

MODULE_PARM_DESC(debug, "set debugging level (1=info,ts=2,"

		"ctrl=4,i2c=8,v8mem=16 (or-able))." DEBSTATUS);

#undef DEBSTATUS



#define deb_info(args...) dprintk(0x01, args)
@@ -45,15 +45,17 @@ MODULE_PARM_DESC(debug, "set debugging level (1=info,ts=2,ctrl=4,i2c=8,v8mem=16 


/* JLP 111700: we will include the 1 bit gap between the upper and lower 3 bits

 * in the IBI address, to make the V8 code simpler.

 * PCI ADDRESS FORMAT: 0x71C -> 0000 0111 0001 1100 (these are the six bits used)

 * PCI ADDRESS FORMAT: 0x71C -> 0000 0111 0001 1100 (the six bits used)

 *                  in general: 0000 0HHH 000L LL00

 * IBI ADDRESS FORMAT:                    RHHH BLLL

 *

 * where R is the read(1)/write(0) bit, B is the busy bit

 * and HHH and LLL are the two sets of three bits from the PCI address.

 */

#define B2C2_FLEX_PCIOFFSET_TO_INTERNALADDR(usPCI) (u8) (((usPCI >> 2) & 0x07) + ((usPCI >> 4) & 0x70))

#define B2C2_FLEX_INTERNALADDR_TO_PCIOFFSET(ucAddr) (u16) (((ucAddr & 0x07) << 2) + ((ucAddr & 0x70) << 4))

#define B2C2_FLEX_PCIOFFSET_TO_INTERNALADDR(usPCI) (u8) \

	(((usPCI >> 2) & 0x07) + ((usPCI >> 4) & 0x70))

#define B2C2_FLEX_INTERNALADDR_TO_PCIOFFSET(ucAddr) (u16) \

	(((ucAddr & 0x07) << 2) + ((ucAddr & 0x70) << 4))



/*

 * DKT 020228
@@ -69,7 +71,8 @@ static int flexcop_usb_readwrite_dw(struct flexcop_device *fc, u16 wRegOffsPCI, 
	struct flexcop_usb *fc_usb = fc->bus_specific;

	u8 request = read ? B2C2_USB_READ_REG : B2C2_USB_WRITE_REG;

	u8 request_type = (read ? USB_DIR_IN : USB_DIR_OUT) | USB_TYPE_VENDOR;

	u8 wAddress = B2C2_FLEX_PCIOFFSET_TO_INTERNALADDR(wRegOffsPCI) | (read ? 0x80 : 0);

	u8 wAddress = B2C2_FLEX_PCIOFFSET_TO_INTERNALADDR(wRegOffsPCI) |

		(read ? 0x80 : 0);



	int len = usb_control_msg(fc_usb->udev,

			read ? B2C2_USB_CTRL_PIPE_IN : B2C2_USB_CTRL_PIPE_OUT,
@@ -82,13 +85,12 @@ static int flexcop_usb_readwrite_dw(struct flexcop_device *fc, u16 wRegOffsPCI, 
			B2C2_WAIT_FOR_OPERATION_RDW * HZ);



	if (len != sizeof(u32)) {

		err("error while %s dword from %d (%d).",read ? "reading" : "writing",

			wAddress,wRegOffsPCI);

		err("error while %s dword from %d (%d).", read ? "reading" :

				"writing", wAddress, wRegOffsPCI);

		return -EIO;

	}

	return 0;

}



/*

 * DKT 010817 - add support for V8 memory read/write and flash update

 */
@@ -96,31 +98,26 @@ static int flexcop_usb_v8_memory_req(struct flexcop_usb *fc_usb, 
		flexcop_usb_request_t req, u8 page, u16 wAddress,

		u8 *pbBuffer, u32 buflen)

{

//	u8 dwRequestType;

	u8 request_type = USB_TYPE_VENDOR;

	u16 wIndex;

	int nWaitTime, pipe, len;



	wIndex = page << 8;



	switch (req) {

	case B2C2_USB_READ_V8_MEM:

		nWaitTime = B2C2_WAIT_FOR_OPERATION_V8READ;

		request_type |= USB_DIR_IN;

//			dwRequestType = (u8) RTYPE_READ_V8_MEMORY;

		pipe = B2C2_USB_CTRL_PIPE_IN;

		break;

	case B2C2_USB_WRITE_V8_MEM:

		wIndex |= pbBuffer[0];

		request_type |= USB_DIR_OUT;

		nWaitTime = B2C2_WAIT_FOR_OPERATION_V8WRITE;

//			dwRequestType = (u8) RTYPE_WRITE_V8_MEMORY;

		pipe = B2C2_USB_CTRL_PIPE_OUT;

		break;

	case B2C2_USB_FLASH_BLOCK:

		request_type |= USB_DIR_OUT;

		nWaitTime = B2C2_WAIT_FOR_OPERATION_V8FLASH;

//			dwRequestType = (u8) RTYPE_WRITE_V8_FLASH;

		pipe = B2C2_USB_CTRL_PIPE_OUT;

		break;

	default:
@@ -140,7 +137,6 @@ static int flexcop_usb_v8_memory_req(struct flexcop_usb *fc_usb, 
			nWaitTime * HZ);



	debug_dump(pbBuffer, len, deb_v8);



	return len == buflen ? 0 : -EIO;

}
@@ -148,30 +144,45 @@ static int flexcop_usb_v8_memory_req(struct flexcop_usb *fc_usb, 
	((V8_MEMORY_PAGE_SIZE - (paddr & V8_MEMORY_PAGE_MASK)) > buflen \

	 ? buflen : (V8_MEMORY_PAGE_SIZE - (paddr & V8_MEMORY_PAGE_MASK)))



static int flexcop_usb_memory_req(struct flexcop_usb *fc_usb,flexcop_usb_request_t req,

		flexcop_usb_mem_page_t page_start, u32 addr, int extended, u8 *buf, u32 len)

static int flexcop_usb_memory_req(struct flexcop_usb *fc_usb,

		flexcop_usb_request_t req, flexcop_usb_mem_page_t page_start,

		u32 addr, int extended, u8 *buf, u32 len)

{

	int i,ret = 0;

	u16 wMax;

	u32 pagechunk = 0;



	switch(req) {

		case B2C2_USB_READ_V8_MEM:  wMax = USB_MEM_READ_MAX; break;

		case B2C2_USB_WRITE_V8_MEM:	wMax = USB_MEM_WRITE_MAX; break;

		case B2C2_USB_FLASH_BLOCK:  wMax = USB_FLASH_MAX; break;

	case B2C2_USB_READ_V8_MEM:

		wMax = USB_MEM_READ_MAX;

		break;

	case B2C2_USB_WRITE_V8_MEM:

		wMax = USB_MEM_WRITE_MAX;

		break;

	case B2C2_USB_FLASH_BLOCK:

		wMax = USB_FLASH_MAX;

		break;

	default:

		return -EINVAL;

		break;

	}

	for (i = 0; i < len;) {

		pagechunk = wMax < bytes_left_to_read_on_page(addr,len) ? wMax : bytes_left_to_read_on_page(addr,len);

		deb_info("%x\n",(addr & V8_MEMORY_PAGE_MASK) | (V8_MEMORY_EXTENDED*extended));

		if ((ret = flexcop_usb_v8_memory_req(fc_usb,req,

				page_start + (addr / V8_MEMORY_PAGE_SIZE), /* actual page */

				(addr & V8_MEMORY_PAGE_MASK) | (V8_MEMORY_EXTENDED*extended),

				&buf[i],pagechunk)) < 0)

		pagechunk =

			wMax < bytes_left_to_read_on_page(addr, len) ?

				wMax :

				bytes_left_to_read_on_page(addr, len);

		deb_info("%x\n",

			(addr & V8_MEMORY_PAGE_MASK) |

				(V8_MEMORY_EXTENDED*extended));



		ret = flexcop_usb_v8_memory_req(fc_usb, req,

			page_start + (addr / V8_MEMORY_PAGE_SIZE),

			(addr & V8_MEMORY_PAGE_MASK) |

				(V8_MEMORY_EXTENDED*extended),

			&buf[i], pagechunk);



		if (ret < 0)

			return ret;



		addr += pagechunk;

		len -= pagechunk;

	}
@@ -181,7 +192,8 @@ static int flexcop_usb_memory_req(struct flexcop_usb *fc_usb,flexcop_usb_request 
static int flexcop_usb_get_mac_addr(struct flexcop_device *fc, int extended)

{

	return flexcop_usb_memory_req(fc->bus_specific, B2C2_USB_READ_V8_MEM,

			V8_MEMORY_PAGE_FLASH,0x1f010,1,fc->dvb_adapter.proposed_mac,6);

		V8_MEMORY_PAGE_FLASH, 0x1f010, 1,

		fc->dvb_adapter.proposed_mac, 6);

}



#if 0
@@ -191,11 +203,8 @@ static int flexcop_usb_utility_req(struct flexcop_usb *fc_usb, int set, 
{

	u16 wValue;

	u8 request_type = (set ? USB_DIR_OUT : USB_DIR_IN) | USB_TYPE_VENDOR;

//	u8 dwRequestType = (u8) RTYPE_GENERIC,

	int nWaitTime = 2,

		pipe = set ? B2C2_USB_CTRL_PIPE_OUT : B2C2_USB_CTRL_PIPE_IN,

		len;



	    pipe = set ? B2C2_USB_CTRL_PIPE_OUT : B2C2_USB_CTRL_PIPE_IN, len;

	wValue = (func << 8) | extra;



	len = usb_control_msg(fc_usb->udev,pipe,
@@ -218,7 +227,6 @@ static int flexcop_usb_i2c_req(struct flexcop_i2c_adapter *i2c, 
	struct flexcop_usb *fc_usb = i2c->fc->bus_specific;

	u16 wValue, wIndex;

	int nWaitTime,pipe,len;

//	u8 dwRequestType;

	u8 request_type = USB_TYPE_VENDOR;



	switch (func) {
@@ -229,14 +237,12 @@ static int flexcop_usb_i2c_req(struct flexcop_i2c_adapter *i2c, 
	case USB_FUNC_I2C_CHECKWRITE:

		pipe = B2C2_USB_CTRL_PIPE_OUT;

		nWaitTime = 2;

//			dwRequestType = (u8) RTYPE_GENERIC;

		request_type |= USB_DIR_OUT;

		break;

	case USB_FUNC_I2C_READ:

	case USB_FUNC_I2C_REPEATREAD:

		pipe = B2C2_USB_CTRL_PIPE_IN;

		nWaitTime = 2;

//			dwRequestType = (u8) RTYPE_GENERIC;

		request_type |= USB_DIR_IN;

		break;

	default:
@@ -246,8 +252,10 @@ static int flexcop_usb_i2c_req(struct flexcop_i2c_adapter *i2c, 
	wValue = (func << 8) | (i2c->port << 4);

	wIndex = (chipaddr << 8 ) | addr;



	deb_i2c("i2c %2d: %02x %02x %02x %02x %02x %02x\n",func,request_type,req,

		wValue & 0xff, wValue >> 8, wIndex & 0xff, wIndex >> 8);

	deb_i2c("i2c %2d: %02x %02x %02x %02x %02x %02x\n",

			func, request_type, req,

			wValue & 0xff, wValue >> 8,

			wIndex & 0xff, wIndex >> 8);



	len = usb_control_msg(fc_usb->udev,pipe,

			req,
@@ -257,12 +265,13 @@ static int flexcop_usb_i2c_req(struct flexcop_i2c_adapter *i2c, 
			buf,

			buflen,

			nWaitTime * HZ);



	return len == buflen ? 0 : -EREMOTEIO;

}



/* actual bus specific access functions, make sure prototype are/will be equal to pci */

static flexcop_ibi_value flexcop_usb_read_ibi_reg(struct flexcop_device *fc, flexcop_ibi_register reg)

/* actual bus specific access functions,

   make sure prototype are/will be equal to pci */

static flexcop_ibi_value flexcop_usb_read_ibi_reg(struct flexcop_device *fc,

	flexcop_ibi_register reg)

{

	flexcop_ibi_value val;

	val.raw = 0;
@@ -270,7 +279,8 @@ static flexcop_ibi_value flexcop_usb_read_ibi_reg(struct flexcop_device *fc, fle 
	return val;

}



static int flexcop_usb_write_ibi_reg(struct flexcop_device *fc, flexcop_ibi_register reg, flexcop_ibi_value val)

static int flexcop_usb_write_ibi_reg(struct flexcop_device *fc,

		flexcop_ibi_register reg, flexcop_ibi_value val)

{

	return flexcop_usb_readwrite_dw(fc, reg, &val.raw, 0);

}
@@ -286,15 +296,18 @@ static int flexcop_usb_i2c_request(struct flexcop_i2c_adapter *i2c, 
				USB_FUNC_I2C_WRITE, chipaddr, addr, buf, len);

}



static void flexcop_usb_process_frame(struct flexcop_usb *fc_usb, u8 *buffer, int buffer_length)

static void flexcop_usb_process_frame(struct flexcop_usb *fc_usb,

	u8 *buffer, int buffer_length)

{

	u8 *b;

	int l;



	deb_ts("tmp_buffer_length=%d, buffer_length=%d\n", fc_usb->tmp_buffer_length, buffer_length);

	deb_ts("tmp_buffer_length=%d, buffer_length=%d\n",

		fc_usb->tmp_buffer_length, buffer_length);



	if (fc_usb->tmp_buffer_length > 0) {

		memcpy(fc_usb->tmp_buffer+fc_usb->tmp_buffer_length, buffer, buffer_length);

		memcpy(fc_usb->tmp_buffer+fc_usb->tmp_buffer_length, buffer,

				buffer_length);

		fc_usb->tmp_buffer_length += buffer_length;

		b = fc_usb->tmp_buffer;

		l = fc_usb->tmp_buffer_length;
@@ -304,14 +317,17 @@ static void flexcop_usb_process_frame(struct flexcop_usb *fc_usb, u8 *buffer, in 
	}



	while (l >= 190) {

		if (*b == 0xff)

		if (*b == 0xff) {

			switch (*(b+1) & 0x03) {

			case 0x01: /* media packet */

				if (*(b+2) == 0x47)

						flexcop_pass_dmx_packets(fc_usb->fc_dev, b+2, 1);

					flexcop_pass_dmx_packets(

							fc_usb->fc_dev, b+2, 1);

				else

						deb_ts("not ts packet %02x %02x %02x %02x \n", *(b+2), *(b+3), *(b+4), *(b+5) );



					deb_ts(

					"not ts packet %02x %02x %02x %02x \n",

						*(b+2), *(b+3),

						*(b+4), *(b+5));

				b += 190;

				l -= 190;

				break;
@@ -320,7 +336,7 @@ static void flexcop_usb_process_frame(struct flexcop_usb *fc_usb, u8 *buffer, in 
				l = 0;

				break;

			}

		else {

		} else {

			deb_ts("wrong header\n");

			l = 0;

		}
@@ -337,23 +353,26 @@ static void flexcop_usb_urb_complete(struct urb *urb) 
	int i;



	if (urb->actual_length > 0)

		deb_ts("urb completed, bufsize: %d actlen; %d\n",urb->transfer_buffer_length, urb->actual_length);

		deb_ts("urb completed, bufsize: %d actlen; %d\n",

			urb->transfer_buffer_length, urb->actual_length);



	for (i = 0; i < urb->number_of_packets; i++) {

		if (urb->iso_frame_desc[i].status < 0) {

			err("iso frame descriptor %d has an error: %d\n",i,urb->iso_frame_desc[i].status);

			err("iso frame descriptor %d has an error: %d\n", i,

				urb->iso_frame_desc[i].status);

		} else

			if (urb->iso_frame_desc[i].actual_length > 0) {

				deb_ts("passed %d bytes to the demux\n",urb->iso_frame_desc[i].actual_length);

				deb_ts("passed %d bytes to the demux\n",

					urb->iso_frame_desc[i].actual_length);



				flexcop_usb_process_frame(fc_usb,

					urb->transfer_buffer + urb->iso_frame_desc[i].offset,

					urb->transfer_buffer +

						urb->iso_frame_desc[i].offset,

					urb->iso_frame_desc[i].actual_length);

			}

		urb->iso_frame_desc[i].status = 0;

		urb->iso_frame_desc[i].actual_length = 0;

	}



	usb_submit_urb(urb,GFP_ATOMIC);

}
@@ -374,35 +393,47 @@ static void flexcop_usb_transfer_exit(struct flexcop_usb *fc_usb) 
		}



	if (fc_usb->iso_buffer != NULL)

		pci_free_consistent(NULL,fc_usb->buffer_size, fc_usb->iso_buffer, fc_usb->dma_addr);

		pci_free_consistent(NULL,

			fc_usb->buffer_size, fc_usb->iso_buffer,

			fc_usb->dma_addr);

}



static int flexcop_usb_transfer_init(struct flexcop_usb *fc_usb)

{

	u16 frame_size = le16_to_cpu(fc_usb->uintf->cur_altsetting->endpoint[0].desc.wMaxPacketSize);

	int bufsize = B2C2_USB_NUM_ISO_URB * B2C2_USB_FRAMES_PER_ISO * frame_size,i,j,ret;

	u16 frame_size = le16_to_cpu(

		fc_usb->uintf->cur_altsetting->endpoint[0].desc.wMaxPacketSize);

	int bufsize = B2C2_USB_NUM_ISO_URB * B2C2_USB_FRAMES_PER_ISO *

		frame_size, i, j, ret;

	int buffer_offset = 0;



	deb_ts("creating %d iso-urbs with %d frames each of %d bytes size = %d.\n",

			B2C2_USB_NUM_ISO_URB, B2C2_USB_FRAMES_PER_ISO, frame_size,bufsize);

	deb_ts("creating %d iso-urbs with %d frames "

			"each of %d bytes size = %d.\n", B2C2_USB_NUM_ISO_URB,

			B2C2_USB_FRAMES_PER_ISO, frame_size, bufsize);



	fc_usb->iso_buffer = pci_alloc_consistent(NULL,bufsize,&fc_usb->dma_addr);

	fc_usb->iso_buffer = pci_alloc_consistent(NULL,

			bufsize, &fc_usb->dma_addr);

	if (fc_usb->iso_buffer == NULL)

		return -ENOMEM;



	memset(fc_usb->iso_buffer, 0, bufsize);

	fc_usb->buffer_size = bufsize;



	/* creating iso urbs */

	for (i = 0; i < B2C2_USB_NUM_ISO_URB; i++)

		if (!(fc_usb->iso_urb[i] = usb_alloc_urb(B2C2_USB_FRAMES_PER_ISO,GFP_ATOMIC))) {

	for (i = 0; i < B2C2_USB_NUM_ISO_URB; i++) {

		fc_usb->iso_urb[i] = usb_alloc_urb(B2C2_USB_FRAMES_PER_ISO,

			GFP_ATOMIC);

		if (fc_usb->iso_urb[i] == NULL) {

			ret = -ENOMEM;

			goto urb_error;

		}

	}



	/* initialising and submitting iso urbs */

	for (i = 0; i < B2C2_USB_NUM_ISO_URB; i++) {

		int frame_offset = 0;

		struct urb *urb = fc_usb->iso_urb[i];

		deb_ts("initializing and submitting urb no. %d (buf_offset: %d).\n",i,buffer_offset);

		deb_ts("initializing and submitting urb no. %d "

			"(buf_offset: %d).\n", i, buffer_offset);



		urb->dev = fc_usb->udev;

		urb->context = fc_usb;
@@ -416,7 +447,8 @@ static int flexcop_usb_transfer_init(struct flexcop_usb *fc_usb) 


		buffer_offset += frame_size * B2C2_USB_FRAMES_PER_ISO;

		for (j = 0; j < B2C2_USB_FRAMES_PER_ISO; j++) {

			deb_ts("urb no: %d, frame: %d, frame_offset: %d\n",i,j,frame_offset);

			deb_ts("urb no: %d, frame: %d, frame_offset: %d\n",

					i, j, frame_offset);

			urb->iso_frame_desc[j].offset = frame_offset;

			urb->iso_frame_desc[j].length = frame_size;

			frame_offset += frame_size;
@@ -430,12 +462,11 @@ static int flexcop_usb_transfer_init(struct flexcop_usb *fc_usb) 
	}



	/* SRAM */



	flexcop_sram_set_dest(fc_usb->fc_dev,FC_SRAM_DEST_MEDIA | FC_SRAM_DEST_NET |

			FC_SRAM_DEST_CAO | FC_SRAM_DEST_CAI, FC_SRAM_DEST_TARGET_WAN_USB);

	flexcop_sram_set_dest(fc_usb->fc_dev, FC_SRAM_DEST_MEDIA |

			FC_SRAM_DEST_NET | FC_SRAM_DEST_CAO | FC_SRAM_DEST_CAI,

			FC_SRAM_DEST_TARGET_WAN_USB);

	flexcop_wan_set_speed(fc_usb->fc_dev, FC_WAN_SPEED_8MBITS);

	flexcop_sram_ctrl(fc_usb->fc_dev, 1, 1, 1);



	return 0;



urb_error:
@@ -449,7 +480,7 @@ static int flexcop_usb_init(struct flexcop_usb *fc_usb) 
	usb_set_interface(fc_usb->udev,0,1);

	switch (fc_usb->udev->speed) {

	case USB_SPEED_LOW:

			err("cannot handle USB speed because it is to sLOW.");

		err("cannot handle USB speed because it is too slow.");

		return -ENODEV;

		break;

	case USB_SPEED_FULL:
@@ -460,7 +491,7 @@ static int flexcop_usb_init(struct flexcop_usb *fc_usb) 
		break;

	case USB_SPEED_UNKNOWN: /* fall through */

	default:

			err("cannot handle USB speed because it is unkown.");

		err("cannot handle USB speed because it is unknown.");

		return -ENODEV;

	}

	usb_set_intfdata(fc_usb->uintf, fc_usb);
@@ -560,7 +591,6 @@ static int __init flexcop_usb_module_init(void) 
		err("usb_register failed. (%d)", result);

		return result;

	}



	return 0;

}