/**************************************************************************//**
 * @file    cimax+usb-driver.c
 *
 * @brief   CIMaX+ USB Driver for linux based operating systems.
 *
 * Copyright (C) 2009-2011    Bruno Tonelli   <bruno.tonelli@smardtv.com>
 *                          & Franck Descours <franck.descours@smardtv.com>
 *                            for SmarDTV France, La Ciotat
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 ******************************************************************************/

#define FRBIT
/*#define DEBUG*/
/*#define DEBUG_BITRATE*/
/*#define DEBUG_ISOC_IN*/
/*#define DEBUG_ISOC_OUT*/
/*#define DEBUG_CONTINUITY*/

/******************************************************************************
 * Include
 ******************************************************************************/
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/poll.h>
#include <linux/usb.h>
#include <linux/uaccess.h>
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/hrtimer.h>
#include <linux/ktime.h>
#include <linux/dvb/ca.h>
#include <linux/compat.h>

#include "cimax+usb-driver.h"
#include "cimax+usb_fw.h"
#include "cimax+usb_config.h"
#ifdef TIMESTAMP
#include "cimax+usb_time.h"
#endif
#include "../../aml_cimax_usb_priv.h"

/******************************************************************************
 * Defines
 *****************************************************************************/
#define DRIVER_VERSION "v1.1.2"
#define DRIVER_AUTHOR "Bruno Tonelli, tonelli@smardtv.com"
#define DRIVER_DESC "CIMaX+ USB Driver for Linux (c)2009-2011"

#define DRIVER_MAX_NUMBER   1

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_LICENSE("GPL");

/******************************************************************************
 * Structures
 ******************************************************************************/
/******************************************************************************
 * Globals
 ******************************************************************************/
#ifdef FRBIT
int CimaxCfg = 1;
module_param_named(CimaxCfg, CimaxCfg, int, 0644);
MODULE_PARM_DESC(CimaxCfg, "Turn on/off configuration of CIMaX+ (default: on)");
int CimaxDwnl = 1;
module_param_named(CimaxDwnl, CimaxDwnl, int, 0644);
MODULE_PARM_DESC(CimaxDwnl, "Enable upload of FW in CIMaX+ chip (default: on)");
#endif

static struct device_s *gdevice;
static unsigned int gdeviceNumber;

static struct usb_driver device_driver;
static struct timespec gStart;

static __u8 nullHeader[] = {
	0x47, 0x1F, 0xFF, 0x1F, 0xFA, 0xDE, 0xBA, 0xBE
};

static struct bulk_timer_s gbulk_timer[DEVICE_NUM_CAM];
int (*cimax_usb_dev_add)(struct device_s *device, int id);
int (*cimax_usb_dev_remove)(struct device_s *device, int id);

#ifdef TIMESTAMP
static int bSetTimestamps;
#endif

/******************************************************************************
 * Functions
 ******************************************************************************/
#ifdef DEBUG_CONTINUITY
#define TS_MAXPIDS 8192                  /* max value of a PID */
unsigned char    tab_cc[TS_MAXPIDS];

__u16 get_ts_pid(unsigned char *pid)
{
	__u16 pp = 0;

	pp = (pid[0] & 0X1f)<<8;
	pp |= pid[1];

	return pp;
}

static void init_tab_cc(void)
{
	memset(tab_cc, 0xff, TS_MAXPIDS);
}

static int dbg_cc(unsigned char *buf)
{
	int pid;
	unsigned char cc;

	if (buf[0] != DEVICE_MPEG2_SYNC_BYTE) {
		err("Out Of Sync: ");
		return -1;
	}

	pid = get_ts_pid(buf + 1);

	if (!(buf[3] & 0x10))   /* no payload?*/
		return 0;

	if (buf[1] & 0x80)
		err("Error in TS for PID: %d\n", pid);

	/* Check continuity count*/
	cc = tab_cc[pid];
	if (cc == 255)
		cc = (buf[3] & 15);
	else {
		cc = ((cc) + 1) & 15;
		if (cc != (buf[3] & 15)) {
			/* Otherwise, this is a real corruption */
			err("pid %d cc %d expected cc %d actual\n",
					pid, cc, buf[3] & 15);
			cc = (buf[3] & 15);
		}
	}
	return 0;
}
#endif

/*-------------------------------------------------------------------*/
#ifdef DEBUG
static void dbg_dump(char *hdr, unsigned char *data, int size)
{
	int i;
	char line[40];
	char str[9];
	line[0] = 0;
	for (i = 0; i < size; i++) {
		sprintf(line, "%s%.2x ", line, data[i]);
		if ((data[i] >= 32) && (data[i] <= 126))
			str[i%8] = data[i];
		else
			str[i%8] = '.';
		if (!((i+1)%8)) {
			str[i%8 + 1] = 0;
			dbg_s("%s %s %s", hdr, line, str);
			line[0] = 0;
		} /* if */
	} /* for */
	if (i%8) {
		int j;
		str[i%8 + 1] = 0;
		for (j = (i%8); j < 8; j++)
			sprintf(line, "%s   ", line);
		dbg_s("%s %s %s", hdr, line, str);
		line[0] = 0;
	} /* if */
} /* dbg_dump */
#else
#define dbg_dump(format, arg...) do {} while (0)
#endif /* DEBUG */

static unsigned long copyDataFrom(int us,
		void *to, const void *from, unsigned long n)
{
	if (us)
		return copy_from_user(to, from, n);
	memcpy(to, from, n);
	return 0;
}

static unsigned long copyDataTo(int us,
		void *to, const void *from, unsigned long n)
{
	if (us)
		return copy_to_user(to, from, n);
	memcpy(to, from, n);
	return 0;
}

static void vb_init(struct video_buf_s *buf)
{
	buf->readOffset = 0;
	buf->writeOffset = 0;
	buf->isEmpty = 1;
} /* vb_init */

static int vb_get_write_size(struct video_buf_s *buf)
{
	int writeSize = 0;

	if (buf->writeOffset == buf->readOffset) {
		if (buf->isEmpty)
			writeSize = DEVICE_VB_LENGTH;
	} else if (buf->writeOffset > buf->readOffset)
		writeSize =
			DEVICE_VB_LENGTH - (buf->writeOffset - buf->readOffset);
	else
		writeSize = buf->readOffset - buf->writeOffset;
	return writeSize;
} /* vb_get_write_size */

static int vb_write(struct video_buf_s *buf, __u8 *data, int size)
{
	int writeSize = vb_get_write_size(buf);
	int firstPart = DEVICE_VB_LENGTH - buf->writeOffset;
	if (size > writeSize)
		size = writeSize;

	if (size < firstPart) {
		memcpy(&buf->data[buf->writeOffset], data, size);
		buf->writeOffset += size;
	} /* if */ else {
		memcpy(&buf->data[buf->writeOffset], data, firstPart);
		memcpy(buf->data, &data[firstPart], size - firstPart);
		buf->writeOffset = size - firstPart;
	} /* else */

	if (size > 0)
		buf->isEmpty = 0;
	return size;
} /* vb_write */

static int vb_read_next(struct video_buf_s *buf, __u8 *data)
{
	int readSize;
	int firstPart;
	int nextOffset;
	int isStuffing;
	int ret;

	readSize = DEVICE_VB_LENGTH - vb_get_write_size(buf);
	nextOffset = buf->readOffset + DEVICE_MPEG2_PACKET_SIZE;
	if (nextOffset >= DEVICE_VB_LENGTH)
		nextOffset -= DEVICE_VB_LENGTH;
	while (readSize > DEVICE_MPEG2_PACKET_SIZE) {
		if ((buf->data[buf->readOffset] == DEVICE_MPEG2_SYNC_BYTE) &&
			(buf->data[nextOffset] == DEVICE_MPEG2_SYNC_BYTE)) {
			/* packet in sync */
			break;
		} /* if */
		buf->readOffset++;
		if (buf->readOffset == DEVICE_VB_LENGTH)
			buf->readOffset = 0;
		nextOffset++;
		if (nextOffset == DEVICE_VB_LENGTH)
			nextOffset = 0;
		readSize--;
	} /* while */
	if (readSize <= DEVICE_MPEG2_PACKET_SIZE) {
		buf->isEmpty = 1;
		return 0;
	} /* if */

	/* packet is in sync, check if it is a stuffing packet */
	isStuffing = 0;
	firstPart = DEVICE_VB_LENGTH - buf->readOffset;
	if (firstPart < DEVICE_NULL_HEADER_SIZE) {
		if ((memcmp(nullHeader, &buf->data[buf->readOffset], firstPart)
				== 0) &&
				(memcmp(&nullHeader[firstPart], buf->data,
					    DEVICE_NULL_HEADER_SIZE - firstPart)
					== 0)) {
			isStuffing = 1;
		} /* if */
	} /* if */
	else {
		if (memcmp(nullHeader, &buf->data[buf->readOffset],
					DEVICE_NULL_HEADER_SIZE) == 0) {
			isStuffing = 1;
		} /* if */
	} /* else */
	readSize -= DEVICE_MPEG2_PACKET_SIZE;
	if (readSize <= DEVICE_MPEG2_PACKET_SIZE)
		buf->isEmpty = 1;

	/* skip stuffing packet */
	if (isStuffing) {
		buf->readOffset = nextOffset;
		return 0;
	} /* if */

	/* copy packet to user space */
	if (firstPart >= DEVICE_MPEG2_PACKET_SIZE) {
		ret = copy_to_user(data,
			&buf->data[buf->readOffset], DEVICE_MPEG2_PACKET_SIZE);
	} /* if */ else {
		ret = copy_to_user(data,
			&buf->data[buf->readOffset], firstPart);
		ret = copy_to_user(&data[firstPart],
			buf->data, DEVICE_MPEG2_PACKET_SIZE - firstPart);
	} /* else */
	buf->readOffset = nextOffset;
	return DEVICE_MPEG2_PACKET_SIZE;
} /* vb_read_next */

/*-------------------------------------------------------------------*/
#ifdef DEBUG_BITRATE
static void print_bitrate(struct ts_channel_s *channel, __u8 channel_number)
{
	int     readSize;
	ktime_t  currentTime;
	int  diffTime_us;
	int bitrate;

	currentTime = ktime_get_real();
	if (!(channel->bitrateTime.tv64)) {
		channel->bitrateTime = currentTime;
	} else {
		readSize = DEVICE_VB_LENGTH - vb_get_write_size(&channel->inVb);
		dbg("%d bytes received\n", readSize);
		diffTime_us = (int)(ktime_us_delta(currentTime,
					channel->bitrateTime));
		if (diffTime_us) {
			bitrate = (int)((readSize * 8 * USEC_PER_SEC)
					/ diffTime_us);
		}
		channel->bitrateTime = currentTime;
		dbg("received bitrate for channel[%d] = %dbps\n",
			channel_number, bitrate);
	}
}
#endif /* DEBUG_BITRATE */
/*-------------------------------------------------------------------*/

static void device_cibulk_complete(struct urb *urb)
{
	dbg("start");
	kfree(urb->transfer_buffer);
	usb_free_urb(urb);
	dbg("end");
} /* device_cibulk_complete */

static int device_cibulk_send(struct device_s *device,
		struct ioctl_data_s *data,
		int user_space)
{
	int         res;
	struct urb *urb;
	int         size;
	int         index = -1;
	__u8        *ptr;
	__u32       todo = data->txSize;
	__u8        *userData = data->txData;

	dbg("start");

	do {
		/* get a free bulk message */
		urb = usb_alloc_urb(0, GFP_KERNEL);
		if (!urb) {
			err("alloc urb");
			return -ENOMEM;
		} /* if */
		urb->dev = device->usbdev;

		/* allocate bulk data */
		size = device->ciBulk.outMaxPacketSize;
		if (todo < size)
			size = todo;
		urb->transfer_buffer = kmalloc(size, GFP_KERNEL);
		if (!urb->transfer_buffer) {
			err("alloc transfer buffer");
			usb_free_urb(urb);
			return -ENOMEM;
		} /* if */

		/* copy data */
		ptr = urb->transfer_buffer;
		res = copyDataFrom(user_space, ptr, userData, size);

#ifdef TIMESTAMP
		if (bSetTimestamps) {
			if (index == -1) {
				SetTimestamp("urb %x, toSend %d, send %d",
					    urb, todo, size);
				SetTimestamp("cmd 0x%02x", ptr[0]);
			} else {
				SetTimestamp("urb %x, toSend %d, send %d",
					    urb, todo, size);
			}
		}
#endif

		/* first packet, get index */
		if (index == -1) {
			if ((ptr[DEVICE_COMMAND_OFFSET] == DEVICE_CMD_INIT) ||
				(ptr[DEVICE_COMMAND_OFFSET]
					== DEVICE_CMD_WRITE_REG) ||
				(ptr[DEVICE_COMMAND_OFFSET]
					== DEVICE_CMD_READ_REG)) {
				index = 0; /* register command, no module */
			} else if (ptr[DEVICE_COMMAND_OFFSET]
					& DEVICE_SEL_MASK) {
				index = 1; /* module B */
			} else {
				index = 0; /* module A */
			} /* else */
			device->ciBulk.ciData[index].syncDataSize = 0;
			device->ciBulk.ciData[index].syncSignal = 0;
		} /* if */

		/* submit bulk */
		urb->pipe = usb_sndbulkpipe(device->usbdev,
				DEVICE_BULK_OUT_PIPE);
		urb->transfer_buffer_length = size;
		urb->complete = device_cibulk_complete;
		urb->context  = NULL;
		dbg_dump("txBuf", urb->transfer_buffer,
				urb->transfer_buffer_length);
		res = usb_submit_urb(urb, GFP_KERNEL);
		if (res < 0) {
			err("submit urb res = %d", res);
			kfree(urb->transfer_buffer);
			usb_free_urb(urb);
			return -ENOMEM;
		} /* if */
		todo -= size;
		userData += size;
	} while (todo);

	device->ciBulk.ciData[index].bPendingSend = 1;
	dbg("end");
	return index;
} /* device_cibulk_send */

static void device_int_complete(struct urb *urb)
{
	unsigned long   flags;
	struct device_s *device = urb->context;
	__u8            *dataToCopy;
	int             sizeToCopy, SizeReceived;
	__u8            isFirstPacket = 0;
	__u8            isLastPacket = 0;
	__u8            index, i;
	__u8            status;
	struct message_node_s *message;

	dbg("start");

	if (urb->status) {
		dbg("urb status %d, not submitted again", urb->status);
		kfree(urb->transfer_buffer);
		usb_free_urb(urb);
		for (i = 0; i < DEVICE_NUM_INT_IN_URBS; i++) {
			if (device->ciBulk.intUrb[i] == urb)
				device->ciBulk.intUrb[i] = NULL;
		}
		return;
	} /* if */

	spin_lock_irqsave(&device->ciBulk.intUrbLock, flags);
	dbg("urb status %d, transfer_buffer_length %d actual_length %d",
			urb->status,
			urb->transfer_buffer_length,
			urb->actual_length);
	dataToCopy = urb->transfer_buffer;
	SizeReceived =  urb->actual_length;
	dbg_dump("total rxBuf", dataToCopy, SizeReceived);


	do {
		if (device->ciBulk.intSizeToReceive == 0) {
			if (!dataToCopy[DEVICE_STATUS_OFFSET] &&
					!dataToCopy[DEVICE_LENGTH_MSB_OFFSET] &&
					!dataToCopy[DEVICE_LENGTH_LSB_OFFSET] &&
					!dataToCopy[DEVICE_COUNTER_OFFSET]){
				dbg("no data receive");
				memset(urb->transfer_buffer,
						0, urb->transfer_buffer_length);
				usb_submit_urb(urb, GFP_ATOMIC);
				return;
			}
			/* first packet, read header */
			isFirstPacket = 1;
			device->ciBulk.intCurrStatus =
				dataToCopy[DEVICE_STATUS_OFFSET] &
				DEVICE_CMD_MASK;
			if (dataToCopy[DEVICE_STATUS_OFFSET]
				& DEVICE_SEL_MASK) {
				device->ciBulk.intCurrIndex = 1; /* module B */
			} else {
				device->ciBulk.intCurrIndex = 0; /* module A */
			}
			if ((device->ciBulk.intCurrStatus == DEVICE_READ_REGOK)
				|| (device->ciBulk.intCurrStatus
					== DEVICE_WRITE_REGOK)) {
				device->ciBulk.intSizeToReceive =
					dataToCopy[DEVICE_LENGTH_LSB_OFFSET] +
					DEVICE_DATA_OFFSET;
			} else {
				device->ciBulk.intSizeToReceive =
				dataToCopy[DEVICE_LENGTH_MSB_OFFSET] * 256
					+ dataToCopy[DEVICE_LENGTH_LSB_OFFSET]
					+ DEVICE_DATA_OFFSET;
			}
		} /* if */

		/* get last packet state */
		status     = device->ciBulk.intCurrStatus;
		index      = device->ciBulk.intCurrIndex;
		sizeToCopy = device->ciBulk.intSizeToReceive;
		if (sizeToCopy > urb->actual_length) {
			/* limit size to received buffer size */
			sizeToCopy = urb->actual_length;
		} /* if */ else
			isLastPacket = 1;
		dbg_dump("rxBuf", dataToCopy, sizeToCopy);

#ifndef FRBIT
		if (status == DEVICE_DATAREADY) {
			if (device->ciBulk.ciData[index].bPendingSend)
				status = DEVICE_DATAREADY_SYNC;
		}
#endif

#ifdef TIMESTAMP
		if (device->ciBulk.intSizeToReceive > 2000)
			bSetTimestamps = 1;
		if (bSetTimestamps) {
			SetTimestamp("urb %x,toReceive %d,received %d,toCopy%d",
				urb,
				device->ciBulk.intSizeToReceive,
				SizeReceived,
				sizeToCopy);
			SetTimestamp("status 0x%02x, camIndex %d, isLast %d",
				status, index, isLastPacket);
		}
#endif

		switch (status) {
		case DEVICE_INITOK:
		case DEVICE_READ_REGOK:
		case DEVICE_WRITE_REGOK:
			index = 0;
		case DEVICE_CAMRESETOK:
			/*only for debug*/
			if (!dataToCopy[DEVICE_STATUS_OFFSET] &&
				!dataToCopy[DEVICE_LENGTH_MSB_OFFSET] &&
				!dataToCopy[DEVICE_LENGTH_LSB_OFFSET] &&
				!dataToCopy[DEVICE_COUNTER_OFFSET]){
				break;
			}
		case DEVICE_CISOK:
		case DEVICE_WRITECOROK:
		case DEVICE_NEGOTIATEOK:
		case DEVICE_WRITELPDUOK:
		case DEVICE_WRITELPDUBUSY:
		case DEVICE_READLPDUOK:
		case DEVICE_WRITEEXTOK:
		case DEVICE_READEXTOK:
		case DEVICE_NO_CAM:
		case DEVICE_NOK:
		case DEVICE_MCARD_WRITEOK:
		case DEVICE_CAMPARSE_ERROR:
		case DEVICE_CMDPENDING:
		case DEVICE_REGSTATUSOK:
		case DEVICE_DATAREADY_SYNC:
			/* copy partial message */
			spin_lock_irqsave(&device->ciBulk.intLock,
				flags);
			memcpy(&device->ciBulk.ciData[index].
				syncData[device->ciBulk.ciData[index].
				syncDataSize],
				dataToCopy, sizeToCopy);
			device->ciBulk.intSizeToReceive -= sizeToCopy;
			device->ciBulk.ciData[index].syncDataSize +=
				sizeToCopy;
			spin_unlock_irqrestore(&device->ciBulk.intLock,
				flags);
			dbg("copied %d bytes at offset %d", sizeToCopy,
				device->ciBulk.ciData[index].
				syncDataSize - sizeToCopy);

			if (isLastPacket) {
				/* last packet received, sync message */
				device->ciBulk.ciData[index].syncSignal = 1;
				wake_up_interruptible(&device->ciBulk.
					ciData[index].syncWait);
				device->ciBulk.ciData[index].bPendingSend = 0;
				dbg("sync signal return %d %d ",
					device->ciBulk.ciData[index].
						syncDataSize, index);
			} /* if */
			break;
		case DEVICE_CAMDET:
		case DEVICE_DATAREADY:
		case DEVICE_MCARD_READ:
		case DEVICE_FRBit:
			if (isFirstPacket) {
				/* create new async message */
				message = kmalloc(sizeof(struct message_node_s),
					GFP_ATOMIC);
				if (!message) {
					err("cannot allocate async message");
					break;
				}
				memset(message,
					0, sizeof(struct message_node_s));
				list_add_tail(&message->node,
					&device->ciBulk.ciData[index].
						asyncDataList);
			} /* if */
			else {
				/* get tail message */
				message = list_entry((device->ciBulk.
					ciData[index].asyncDataList.prev),
					struct message_node_s, node);
			} /* else */

			/* copy partial message */
			spin_lock_irqsave(&device->ciBulk.intLock, flags);
			memcpy(&message->data[message->size],
					dataToCopy, sizeToCopy);
			device->ciBulk.intSizeToReceive -= sizeToCopy;
			message->size += sizeToCopy;
			spin_unlock_irqrestore(&device->ciBulk.intLock, flags);
			dbg("async copied %d bytes at offset %d", sizeToCopy,
				message->size - sizeToCopy);

			if (isLastPacket) {
				/* last packet received, signal async message */
				wake_up_interruptible(&device->ciBulk.
					ciData[index].asyncWait);
				dbg("async signal %d", index);
			} /* if */
			break;
		case DEVICE_GPIOCHANGE:
			info("GPIO change %x %x %x",
				status, dataToCopy[4], dataToCopy[5]);
			device->ciBulk.intSizeToReceive -= sizeToCopy;
			break;
		default:
			err("unknown status 0x%2x", status);
			break;
		} /* switch */
		dataToCopy += sizeToCopy;
		SizeReceived -= sizeToCopy;

	} while (SizeReceived > 0);

	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
	usb_submit_urb(urb, GFP_ATOMIC);

#ifdef TIMESTAMP
	/*if (bSetTimestamps) {
		SetTimestamp("urb %x submitted", urb);
	}*/
#endif

	spin_unlock_irqrestore(&device->ciBulk.intUrbLock, flags);

	dbg("end");
} /* device_int_complete */

static int device_wait_sync_data(struct device_s *device,
		__u8          index,
		struct ioctl_data_s *data,
		int user_space)
{
	unsigned long flags;
	int ret;

	dbg("start %d", index);

	spin_lock_irqsave(&device->ciBulk.intLock, flags);
	while (device->ciBulk.ciData[index].syncSignal == 0) {
		/* nothing to copy */
		spin_unlock_irqrestore(&device->ciBulk.intLock, flags);
		if (wait_event_interruptible(device->ciBulk.
				ciData[index].syncWait,
				device->ciBulk.ciData[index].syncSignal)) {
			device->ciBulk.ciData[index].bPendingSend = 0;
			err("interrupt");
			return -ERESTARTSYS;
			/* signal: tell the fs layer to handle it */
		} /* if */
		/* otherwise loop, but first reacquire the lock */
		spin_lock_irqsave(&device->ciBulk.intLock, flags);
	} /* while */

	/* copy packet to user space buffer */
	if (device->ciBulk.ciData[index].syncDataSize < data->rxSize)
		/* truncate returned message against user buffer size */
		data->rxSize = device->ciBulk.ciData[index].syncDataSize;
	spin_unlock_irqrestore(&device->ciBulk.intLock, flags);
	/* release the lock */
	ret = copyDataTo(user_space,
			data->rxData,
			device->ciBulk.ciData[index].syncData, data->rxSize);
	dbg_dump("userMsg",
		device->ciBulk.ciData[index].syncData, data->rxSize);
	dbg("userRet %d", data->rxSize);
	device->ciBulk.ciData[index].syncDataSize = 0;
	device->ciBulk.ciData[index].syncSignal = 0;

	dbg("end");
	return 0;
} /* device_wait_sync_data */

static int device_wait_async_data(struct device_s *device,
		__u8       index,
		struct rw_data_s *data,
		int user_space)
{
	struct list_head *item;
	struct message_node_s *message;
	unsigned long     flags;
	int ret;

	dbg("start %d", index);

	if ((device->askToRelease) || (device->askToSuspend)) {
		err("ask to release or ask to suspend");
		return -EINTR; /* device close interrupt */
	} /* if */

	if (index >= DEVICE_NUM_CAM) {
		err("bad index(%d)", index);
		return -EINVAL;
	}

	spin_lock_irqsave(&device->ciBulk.intLock, flags);
	while (list_empty(&device->ciBulk.ciData[index].asyncDataList)) {
		/* nothing to copy */
		spin_unlock_irqrestore(&device->ciBulk.intLock, flags);
		/* release the lock */
		if (wait_event_interruptible(device->ciBulk.
				ciData[index].asyncWait,
			device->askToRelease ||
			device->askToSuspend ||
			(!list_empty(&device->ciBulk.
				ciData[index].asyncDataList)))) {
			err("interrupt");
			return -ERESTARTSYS;
			/* signal: tell the fs layer to handle it */
		} /* if */
		if ((device->askToRelease) || (device->askToSuspend)) {
			err("ask to release or ask to suspend");
			return -EINTR; /* device close interrupt */
		} /* if */
		/* otherwise loop, but first reacquire the lock */
		spin_lock_irqsave(&device->ciBulk.intLock, flags);
	} /* while */

	/* ok, data is there, return first item */
	item = device->ciBulk.ciData[index].asyncDataList.next;
	message = list_entry(item, struct message_node_s, node);
	if (message->size < data->size) {
		/* truncate returned message against user buffer size */
		data->size = message->size;
	} /* if */
	spin_unlock_irqrestore(&device->ciBulk.intLock, flags);
	/* release the lock */
	ret = copyDataTo(user_space, data->data, message->data, data->size);
	dbg_dump("userMsg", message->data, data->size);
	dbg("userRet %d", data->size);
	list_del(item);
	kfree(message);

	dbg("end");
	return 0;
} /* device_wait_async_data */

static int device_start_intr(struct device_s *device)
{
	__u8        i, j;
	struct urb *urb;

	dbg("start");

	for (i = 0; i < DEVICE_NUM_INT_IN_URBS; i++) {
		urb = usb_alloc_urb(0, GFP_KERNEL);
		if (!urb) {
			err("alloc urb");
			return -ENOMEM;
		} /* if */
		urb->transfer_buffer =
			kmalloc(device->ciBulk.inMaxPacketSize, GFP_KERNEL);
		if (!urb->transfer_buffer) {
			err("alloc transfer buffer");
			usb_free_urb(urb);
			urb = NULL;
			return -ENOMEM;
		} /* if */

		urb->dev  = device->usbdev;
		urb->pipe = usb_rcvintpipe(device->usbdev, DEVICE_INT_IN_PIPE);
		urb->transfer_buffer_length = device->ciBulk.inMaxPacketSize;
		urb->complete = device_int_complete;
		urb->context  = device;
		urb->interval = 1;
		device->ciBulk.intUrb[i] = urb;
		for (j = 0; j < DEVICE_NUM_CAM; j++) {
			init_waitqueue_head(&device->ciBulk.ciData[j].syncWait);
			init_waitqueue_head(&device->ciBulk.
				ciData[j].asyncWait);
		} /* for */
		usb_submit_urb(device->ciBulk.intUrb[i], GFP_KERNEL);
	}

	dbg("end");
	return 0;
} /* device_start_intr */

static void device_stop_intr(struct device_s *device)
{
	struct list_head *item;
	struct list_head *tmp;
	struct message_node_s *message;
	int               i, j;

	dbg("start");

	for (i = 0; i < DEVICE_NUM_INT_IN_URBS; i++) {
		if (!device->ciBulk.intUrb[i])
			break;
		usb_unlink_urb(device->ciBulk.intUrb[i]);
		device->ciBulk.intUrb[i] = NULL;
		for (j = 0; j < DEVICE_NUM_CAM; j++) {
			for (item = device->ciBulk.ciData[j].asyncDataList.next;
				item != &device->ciBulk.ciData[j].asyncDataList;
				) {
				message = list_entry(item,
						struct message_node_s, node);
				tmp = item->next;
				list_del(item);
				kfree(item);
				item = tmp;
			} /* for */
		} /* for */
		dbg("unlink urb");
	}

	dbg("end");
} /* device_stop_intr */

static void device_iso_in_complete(struct urb *urb)
{
	unsigned long flags;
	struct ts_channel_s *channel = urb->context;
	__u8          i;
	__u8          *data;

	/*dbg("start");*/

	if (urb->status) {
		dbg("urb status %d, not submitted again", urb->status);
		kfree(urb->transfer_buffer);
		usb_free_urb(urb);
		return;
	} /* if */

	spin_lock_irqsave(&channel->inLock, flags);
	for (i = 0; i < urb->number_of_packets; i++) {
		data = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
		if (!urb->iso_frame_desc[i].status &&
				(urb->iso_frame_desc[i].actual_length > 0)) {
			if (vb_get_write_size(&channel->inVb)
				>= urb->iso_frame_desc[i].actual_length) {
				vb_write(&channel->inVb, data,
					urb->iso_frame_desc[i].actual_length);
			} /* if */
			else {
				err("video buffer is full, packet loss %d",
					urb->iso_frame_desc[i].actual_length);
			} /* else */
		} /* if */
		else {
			err("frame rejected, status %x, actual_length %d bytes",
				urb->iso_frame_desc[i].status,
				urb->iso_frame_desc[i].actual_length);
		}
	} /* for */
	spin_unlock_irqrestore(&channel->inLock, flags);

	if (!channel->inVb.isEmpty)
		wake_up_interruptible(&channel->inWait);

	memset(urb->transfer_buffer,
		0, DEVICE_ISOC_LENGTH(channel->maxPacketSize));
	urb->transfer_buffer_length =
		DEVICE_ISOC_LENGTH(channel->maxPacketSize);
	urb->number_of_packets = DEVICE_NUM_FRAMES_PER_URB;
	urb->complete = device_iso_in_complete;
	urb->context = channel;
	urb->transfer_flags = URB_ISO_ASAP;
	urb->interval = 1;
	for (i = 0; i < DEVICE_NUM_FRAMES_PER_URB; i++) {
		urb->iso_frame_desc[i].offset = i * channel->maxPacketSize;
		urb->iso_frame_desc[i].length = channel->maxPacketSize;
	} /* for */
	usb_submit_urb(urb, GFP_ATOMIC);

	/*dbg("end");*/
} /* device_iso_in_complete */

static void device_tsbulk_in_complete(struct urb *urb)
{
	unsigned long flags;
	struct ts_channel_s *channel = urb->context;
	__u8          *data;
#ifdef DEBUG_CONTINUITY
	unsigned int i;
#endif

	/*dbg("start");*/

	if (urb->status) {
		err("urb status %d(%x), not submitted again",
			urb->status, urb->status);
		kfree(urb->transfer_buffer);
		usb_free_urb(urb);
		return;
	} /* if */

	spin_lock_irqsave(&channel->inLock, flags);
	data = urb->transfer_buffer;

#ifdef DEBUG_CONTINUITY
	i = 0;
	/* check synchro byte*/
	while (i < urb->actual_length) {
		if (!((data[i] == DEVICE_MPEG2_SYNC_BYTE) &&
			(data[i+DEVICE_MPEG2_PACKET_SIZE]
				== DEVICE_MPEG2_SYNC_BYTE))) {
			i++;
		} else {
			/* Synchro find*/
			break;
		}
	}

	/* Synchro Ok, check discontinuity*/
	while (i < urb->actual_length) {
		if (dbg_cc(&data[i]) < 0) {
			dbg("(actual_length= %d i=%d pkt=%d)",
				urb->actual_length,
				i,
				i/DEVICE_MPEG2_PACKET_SIZE);
			dbg("%02x %02x %02x %02x %02x %02x %02x %02x\n",
				data[i-4], data[i-3], data[i-2], data[i-1],
				data[i], data[i+1], data[i+2], data[i+3]);
		}
		i += DEVICE_MPEG2_PACKET_SIZE;
	}
#endif

	if (urb->actual_length) {
		channel->nbByteRead += urb->actual_length;
		if (vb_get_write_size(&channel->inVb) >= urb->actual_length)
			vb_write(&channel->inVb, data, urb->actual_length);
		else
			err("video buffer is full, packet loss %d",
				urb->actual_length);
	} else {
		/*warn("receive size of 0\n");*/
	}

	spin_unlock_irqrestore(&channel->inLock, flags);
	/*  dbg("urb->actual_length=%d",urb->actual_length);*/
	/*  info("urb->actual_length=%d\n",urb->actual_length);*/

	if (!channel->inVb.isEmpty)
		wake_up_interruptible(&channel->inWait);
	kfree(urb->transfer_buffer);
	usb_free_urb(urb);
	/*dbg("end");*/
} /* device_tsbulk_in_complete */

static int device_fill_ts(struct device_s *device,
		__u8       index,
		struct rw_data_s *data)
{
	unsigned long flags;
	__u32         copiedSize;
	struct ts_channel_s *channel = &device->channel[index];

	/*dbg("start");*/

	spin_lock_irqsave(&channel->inLock, flags);
	do {
		while (channel->inVb.isEmpty) {
			/* nothing to copy */
			spin_unlock_irqrestore(&channel->inLock, flags);
			/* release the lock */
			if (wait_event_interruptible(channel->inWait,
					    device->askToRelease ||
					    device->askToSuspend ||
					    (!channel->inVb.isEmpty))) {
				err("interrupt");
				return -ERESTARTSYS;
				/* signal: tell the fs layer to handle it */
			} /* if */
			if ((device->askToRelease) || (device->askToSuspend)) {
				err("ask to release or ask to suspend");
				return -EINTR; /* device close interrupt */
			} /* if */
			/* otherwise loop, but first reacquire the lock */
			spin_lock_irqsave(&channel->inLock, flags);
		} /* while */

		spin_unlock_irqrestore(&channel->inLock, flags);

		copiedSize = vb_read_next(&channel->inVb,
			&data->data[data->copiedSize]);
		if (copiedSize) {
			/*dbg("copied %d bytes in buffer 0x%p, offset %d",
			  copiedSize, data->data, data->copiedSize);*/
			data->copiedSize += copiedSize;
		} /* if */
		spin_lock_irqsave(&channel->inLock, flags);
	} while ((data->copiedSize+DEVICE_MPEG2_PACKET_SIZE) <= data->size);
	/* buffer not full */

	spin_unlock_irqrestore(&channel->inLock, flags);

#ifdef DEBUG_BITRATE
	print_bitrate(channel, index);
#endif

	/*dbg("end, buffer 0x%p", data->data);*/
	return 0;
} /* device_fill_ts */

static int device_start_iso_in(struct device_s *device, __u8 index)
{
	int         i, j;
	int         ret = 0;
	struct urb *urb;

	/*dbg("start");*/

#ifdef DEBUG_BITRATE
	device->channel[index].bitrateTime = ktime_set(0, 0);
#endif
	for (i = 0; i < DEVICE_NUM_ISOC_IN_URBS; i++) {
		urb = usb_alloc_urb(DEVICE_NUM_FRAMES_PER_URB, GFP_KERNEL);
		device->channel[index].isocInUrb[i] = urb;
		if (urb) {
			/*urb->transfer_buffer =
				kmalloc(DEVICE_ISOC_LENGTH, GFP_KERNEL);*/
			urb->transfer_buffer =
				kmalloc(DEVICE_ISOC_LENGTH(
					device->channel[index].maxPacketSize),
					GFP_KERNEL);
			if (!urb->transfer_buffer) {
				ret = -ENOMEM;
				err("transfer_buffer allocation failed %d", i);
				break;
			} /* if */
		} /* if */ else {
			ret = -ENOMEM;
			err("usb_alloc_urb failed %d", i);
			break;
		} /* if */
	} /* for */

	if (ret) {
		/* Allocation error, must free already allocated data */
		for (i = 0; i < DEVICE_NUM_ISOC_IN_URBS; i++) {
			urb = device->channel[index].isocInUrb[i];
			if (urb) {
				kfree(urb->transfer_buffer);
				if (urb->transfer_buffer)
					urb->transfer_buffer = NULL;
				usb_free_urb(urb);
				device->channel[index].isocInUrb[i] = NULL;
			} /* if */
		} /* for */
		return ret;
	} /* if */

	for (i = 0; i < DEVICE_NUM_ISOC_IN_URBS; i++) {
		urb = device->channel[index].isocInUrb[i];
		memset(urb->transfer_buffer,
			0,
			DEVICE_ISOC_LENGTH(
				device->channel[index].maxPacketSize));
		urb->transfer_buffer_length =
			DEVICE_ISOC_LENGTH(
				device->channel[index].maxPacketSize);
		urb->number_of_packets = DEVICE_NUM_FRAMES_PER_URB;
		urb->complete = device_iso_in_complete;
		urb->context = &device->channel[index];
		urb->dev = device->usbdev;
		urb->pipe = usb_rcvisocpipe(
			device->usbdev, DEVICE_TS_IN_PIPE + index);
		urb->transfer_flags = URB_ISO_ASAP;
		urb->interval = 1;
		for (j = 0; j < DEVICE_NUM_FRAMES_PER_URB; j++) {
			urb->iso_frame_desc[j].offset =
				j * device->channel[index].maxPacketSize;
			urb->iso_frame_desc[j].length =
				device->channel[index].maxPacketSize;
		} /* for */
	} /* for */
	for (i = 0; i < DEVICE_NUM_ISOC_IN_URBS; i++)
		usb_submit_urb(device->channel[index].isocInUrb[i], GFP_KERNEL);

	/*dbg("end");*/
	return 0;
} /* device_start_iso_in */

static void device_stop_iso_in(struct device_s *device, __u8 index)
{
	int i;

	/*dbg("start");*/

	for (i = 0; i < DEVICE_NUM_ISOC_IN_URBS; i++) {
		if (device->channel[index].isocInUrb[i]) {
			usb_unlink_urb(device->channel[index].isocInUrb[i]);
			device->channel[index].isocInUrb[i] = NULL;
			dbg("unlink urb %i", i);
		} /* if */
	} /* for */

	/*dbg("end");*/
} /* device_stop_iso_in */

static int device_start_tsbulk_in(struct device_s *device, __u8 index)
{
	struct urb *urb;

	dbg("start");

	urb = usb_alloc_urb(0, GFP_KERNEL);
	if (urb) {
		urb->transfer_buffer  = kmalloc(3072, GFP_KERNEL);
		if (!urb->transfer_buffer) {
			err("transfer_buffer allocation failed");
			usb_free_urb(urb);
			return -ENOMEM;
		} /* if */
	} /* if */ else {
		err("usb_alloc_urb failed");
		return -ENOMEM;
	} /* if */
	device->channel[index].bulkInUrb = urb;
	memset(urb->transfer_buffer, 0, 3072);
	urb->transfer_buffer_length = 3072;

	urb->complete = device_tsbulk_in_complete;
	urb->context = &device->channel[index];
	urb->dev = device->usbdev;
	urb->pipe = usb_rcvbulkpipe(device->usbdev, DEVICE_TS_IN_PIPE + index);
	usb_submit_urb(device->channel[index].bulkInUrb, GFP_KERNEL);

	dbg("end");
	return 0;
} /* device_start_tsbulk_in */

static void device_stop_tsbulk_in(struct device_s *device, __u8 index)
{
	dbg("start");

	if (device->channel[index].bulkInUrb) {
		usb_unlink_urb(device->channel[index].bulkInUrb);
		device->channel[index].bulkInUrb = NULL;
		dbg("unlink urb");
	} /* if */

	dbg("end");
} /* device_stop_tsbulk_in */

static void device_iso_out_complete(struct urb *urb)
{
	struct ts_channel_s *channel = urb->context;
	struct urb    *tmpUrb;
	int           i;
	int ret = 0;

	/*dbg("start");*/

/*dbg_dump("txBuf", urb->transfer_buffer, urb->transfer_buffer_length);*/

	if (urb->status || channel->outStop) {
		/* error, free all coming urbs */
		err("free urb");
		channel->outStop = 1;
		atomic_dec(&channel->numOutUrbs);
		kfree(urb->transfer_buffer);
		usb_free_urb(urb);
		return;
	} /* if */

	for (i = 0; i < DEVICE_NUM_ISOC_OUT_URBS; i++) {
		if (urb == channel->isocOutUrb[i])
			break;
	} /* for */
	if (i == DEVICE_NUM_ISOC_OUT_URBS) {
		/* urb must be deleted */
		kfree(urb->transfer_buffer);
		usb_free_urb(urb);
	} /* if */

	if (atomic_dec_and_test(&channel->numOutUrbs)) {
		/* get next free urb */
		tmpUrb = channel->isocOutUrb[channel->nextFreeOutUrbIndex++];
		if (channel->nextFreeOutUrbIndex == DEVICE_NUM_ISOC_OUT_URBS)
			channel->nextFreeOutUrbIndex = 0;

		/* reinitialize urb with null packets */
		memset(tmpUrb->transfer_buffer,
			0xCD, DEVICE_ISOC_LENGTH(channel->maxPacketSize));
		for (i = 0;
			i < DEVICE_ISOC_LENGTH(channel->maxPacketSize);
			i += DEVICE_MPEG2_PACKET_SIZE) {
			memcpy(tmpUrb->transfer_buffer+i,
				nullHeader, sizeof(nullHeader));
		} /* for */
		tmpUrb->transfer_buffer_length =
			DEVICE_ISOC_LENGTH(channel->maxPacketSize);
		tmpUrb->number_of_packets = DEVICE_NUM_FRAMES_PER_URB;
		tmpUrb->complete = device_iso_out_complete;
		tmpUrb->context = channel;
		tmpUrb->transfer_flags = URB_ISO_ASAP;
		tmpUrb->interval = 1;
		for (i = 0; i < DEVICE_NUM_FRAMES_PER_URB; i++) {
			tmpUrb->iso_frame_desc[i].offset =
				i * channel->maxPacketSize;
			tmpUrb->iso_frame_desc[i].length =
				channel->maxPacketSize;
		} /* for */

		/* submit urb */
		ret = usb_submit_urb(tmpUrb, GFP_ATOMIC);
		if (ret)
			err("usb_submit_urb failed %d", ret);

		atomic_inc(&channel->numOutUrbs);
	} /* if */

	/*dbg("end");*/
} /* device_iso_out_complete */

static int device_tsiso_send(struct device_s *device,
	__u8 index, __u8 *data, int size)
{
	int          i, j;
	struct urb   **urb;
	__u32        numUrbs;
	int          ret = 0;

	/*  dbg("start");*/

	numUrbs =
		size / DEVICE_ISOC_LENGTH(device->channel[index].maxPacketSize);
	urb = kmalloc(numUrbs * sizeof(struct urb *), GFP_KERNEL);
	if (!urb) {
		err("urb array allocation failed %d", numUrbs);
		return -ENOMEM;

	} /* if */
	memset(urb, 0, numUrbs * sizeof(struct urb *));

	for (i = 0; i < numUrbs; i++) {
		urb[i] = usb_alloc_urb(DEVICE_NUM_FRAMES_PER_URB, GFP_KERNEL);
		if (urb[i]) {
			urb[i]->transfer_buffer =
				kmalloc(DEVICE_ISOC_LENGTH(
					device->channel[index].maxPacketSize),
						GFP_KERNEL);
			if (!urb[i]->transfer_buffer) {
				ret = -ENOMEM;
				err("transfer_buffer allocation failed %d", i);
				break;
			} /* if */
		} /* if */
		else {
			ret = -ENOMEM;
			err("usb_alloc_urb failed %d", i);
			break;
		} /* if */
	} /* for */
	if (ret) {
		/* Allocation error, must free already allocated data */
		for (i = 0; i < numUrbs; i++) {
			if (urb[i]) {
				kfree(urb[i]->transfer_buffer);
				urb[i]->transfer_buffer = NULL;
				usb_free_urb(urb[i]);
				urb[i] = NULL;
			} /* if */
		} /* for */
		kfree(urb);
		return ret;
	} /* if */

	for (i = 0; i < numUrbs; i++) {
		ret = copy_from_user(urb[i]->transfer_buffer,
			&data[i*DEVICE_ISOC_LENGTH(
					device->channel[index].maxPacketSize)],
				DEVICE_ISOC_LENGTH(
					device->channel[index].maxPacketSize));
		urb[i]->transfer_buffer_length = DEVICE_ISOC_LENGTH(
			device->channel[index].maxPacketSize);
		urb[i]->number_of_packets = DEVICE_NUM_FRAMES_PER_URB;
		urb[i]->complete = device_iso_out_complete;
		urb[i]->context = &device->channel[index];
		urb[i]->dev = device->usbdev;
		urb[i]->pipe = usb_sndisocpipe(device->usbdev,
			DEVICE_TS_OUT_PIPE + index);
		urb[i]->transfer_flags = URB_ISO_ASAP;
		urb[i]->interval = 1;
		for (j = 0; j < DEVICE_NUM_FRAMES_PER_URB; j++) {
			urb[i]->iso_frame_desc[j].offset =
				j * device->channel[index].maxPacketSize;
			urb[i]->iso_frame_desc[j].length =
				device->channel[index].maxPacketSize;
		} /* for */
	} /* for */

	atomic_add(numUrbs, &device->channel[index].numOutUrbs);
	for (i = 0; i < numUrbs; i++) {
		ret = usb_submit_urb(urb[i], GFP_ATOMIC);
		if (ret)
			err("usb_submit_urb failed %d", ret);
	} /* for */

	kfree(urb);

	/*  dbg("end");*/
	return size;
} /* device_tsiso_send */

static int device_start_iso_out(struct device_s *device, __u8 index)
{
	int         i, j;
	int         ret = 0;
	struct urb  *urb;

	/*dbg("start");*/

	device->channel[index].outStop = 0;
	for (i = 0; i < DEVICE_NUM_ISOC_OUT_URBS; i++) {
		urb = usb_alloc_urb(DEVICE_NUM_FRAMES_PER_URB, GFP_KERNEL);
		device->channel[index].isocOutUrb[i] = urb;
		if (urb) {
			urb->transfer_buffer = kmalloc(DEVICE_ISOC_LENGTH(
				device->channel[index].maxPacketSize),
				GFP_KERNEL);
			if (!urb->transfer_buffer) {
				ret = -ENOMEM;
				err("transfer_buffer allocation failed %d", i);
				break;
			} /* if */
		} /* if */ else {
			ret = -ENOMEM;
			err("usb_alloc_urb failed %d", i);
			break;
		} /* if */
	} /* for */

	if (ret) {
		/* Allocation error, must free already allocated data */
		for (i = 0; i < DEVICE_NUM_ISOC_OUT_URBS; i++) {
			urb = device->channel[index].isocOutUrb[i];
			if (urb) {
				kfree(urb->transfer_buffer);
				urb->transfer_buffer = NULL;
				usb_free_urb(urb);
				device->channel[index].isocOutUrb[i] = NULL;
			} /* if */
		} /* for */
		return ret;
	} /* if */

	for (i = 0; i < DEVICE_NUM_ISOC_OUT_URBS; i++) {
		urb = device->channel[index].isocOutUrb[i];
		memset(urb->transfer_buffer, 0, DEVICE_ISOC_LENGTH(
			device->channel[index].maxPacketSize));
		for (j = 0;
			j < DEVICE_ISOC_LENGTH(
				device->channel[index].maxPacketSize);
			j += DEVICE_MPEG2_PACKET_SIZE) {
			memcpy(urb->transfer_buffer+j,
				nullHeader, sizeof(nullHeader));
		} /* for */
		urb->transfer_buffer_length = DEVICE_ISOC_LENGTH(
			device->channel[index].maxPacketSize);
		urb->number_of_packets = DEVICE_NUM_FRAMES_PER_URB;
		urb->complete = device_iso_out_complete;
		urb->context = &device->channel[index];
		urb->dev = device->usbdev;
		urb->pipe = usb_sndisocpipe(device->usbdev,
			DEVICE_TS_OUT_PIPE + index);
		urb->transfer_flags = URB_ISO_ASAP;
		urb->interval = 1;
		for (j = 0; j < DEVICE_NUM_FRAMES_PER_URB; j++) {
			urb->iso_frame_desc[j].offset =
				j * device->channel[index].maxPacketSize;
			urb->iso_frame_desc[j].length =
				device->channel[index].maxPacketSize;
		} /* for */
	} /* for */
	device->channel[index].nextFreeOutUrbIndex = DEVICE_NUM_ISOC_OUT_URBS-1;
	atomic_set(&device->channel[index].numOutUrbs, 1);
	for (i = 0; i < DEVICE_NUM_ISOC_OUT_URBS-1; i++) {
		ret = usb_submit_urb(
			device->channel[index].isocOutUrb[i], GFP_KERNEL);
		if (ret)
			err("usb_submit_urb failed %d", ret);
	} /* for */

	/*dbg("end");*/
	return 0;
} /* device_start_iso_out */

static void device_stop_iso_out(struct device_s *device, __u8 index)
{
	dbg("start");

	device->channel[index].outStop = 1;

	dbg("end");
} /* device_stop_iso_out */

static void device_tsbulk_complete(struct urb *urb)
{
	struct device_s *device = urb->context;
	__u8 index = 0;

	/*dbg("start");*/
	if (!urb->status) {
		if (usb_endpoint_num(&(urb->ep->desc)) != DEVICE_TS_OUT_PIPE)
			index = 1;
		device->channel[index].nbByteSend += urb->actual_length;
	}
	kfree(urb->transfer_buffer);
	usb_free_urb(urb);
	/*dbg("end");*/
} /* device_tsbulk_complete */

static int device_tsbulk_send(struct device_s *device,
	__u8 index, __u8 *data, int size)
{
	struct urb *urb;
	/*  int         todo = size;*/
	int ret = 0;

	dbg("start");

	/* get a free bulk message */
	urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!urb) {
		err("alloc urb");
		return -ENOMEM;
	} /* if */
	urb->dev = device->usbdev;

	/* allocate bulk data */
	urb->transfer_buffer = kmalloc(size, GFP_KERNEL);
	if (!urb->transfer_buffer) {
		err("alloc transfer buffer");
		usb_free_urb(urb);
		return -ENOMEM;
	} /* if */

	/* copy data */
	ret = copy_from_user(urb->transfer_buffer, data, size);

	/* submit bulk */
	urb->pipe = usb_sndbulkpipe(device->usbdev, DEVICE_TS_OUT_PIPE + index);
	urb->transfer_buffer_length = size;
	urb->complete = device_tsbulk_complete;
	urb->context  = device;
	/*dbg("Transmit %d bytes\n",urb->transfer_buffer_length);*/
	/*dbg_dump("txBuf",
		urb->transfer_buffer, urb->transfer_buffer_length);*/
	mod_timer(&(gbulk_timer[index].StartBulkReadTimer),
		usecs_to_jiffies(50));

	if (usb_submit_urb(urb, GFP_KERNEL) < 0) {
		err("submit urb");
		kfree(urb->transfer_buffer);
		usb_free_urb(urb);
		return -ENOMEM;
	} /* if */

	dbg("end");
	return 0;
} /* device_tsbulk_send */

/* ---------------------------------------------------------- */
static void StartBulkRead_func(struct timer_list * timer)
{
	struct bulk_timer_s *bulk_time = from_timer(bulk_time,timer,StartBulkReadTimer) ;

	device_start_tsbulk_in(bulk_time->device, bulk_time->index);
}

static int device_drv_open(struct device_s *device)
{
	int index;
	mutex_lock(&device->lock);

	if (!device->usbdev) {
		err("no dev, can not start dev");
		mutex_unlock(&device->lock);
		return -ENODEV;
	}

	if (device->opened) {
		mutex_unlock(&device->lock);
		device->opened++;
		info("udev=%p opened=%d", (device->usbdev), device->opened);
		return 0;
	} /* while */

	info("set interface 0");
	if (usb_set_interface(device->usbdev, 0, 0) < 0) {
		mutex_unlock(&device->lock);
		err("set_interface fail");
		return -EINVAL;
	} /* if */

	device->opened++;
	device->askToRelease = 0;
	mutex_unlock(&device->lock);

	for (index = 0; index < DEVICE_NUM_CAM; index++) {
		device->channel[index].nbByteSend = -376;
		device->channel[index].nbByteRead = 0;
		device->channel[index].FirstTransfer = true;
		gbulk_timer[index].device = device;
		gbulk_timer[index].index = index;
		timer_setup(&gbulk_timer[index].StartBulkReadTimer,
			StartBulkRead_func,0);
	}
#ifdef DEBUG_CONTINUITY
	init_tab_cc();
#endif
	info("udev=%p opened=%d", (device->usbdev), device->opened);
	return 0;
}

static int device_ci_unlock_read(struct device_s *device)
{
	if (device->opened) {
		/* release blocking functions */
		device->askToRelease = 1;
		wake_up_interruptible(&device->ciBulk.ciData[0].asyncWait);
		wake_up_interruptible(&device->ciBulk.ciData[1].asyncWait);
		wake_up_interruptible(&device->channel[0].inWait);
		wake_up_interruptible(&device->channel[1].inWait);
	}
	return 0;
}

static int device_drv_close(struct device_s *device)
{
	int i;
	mutex_lock(&device->lock);
	if (device->opened && ((--device->opened) == 0)) {
		device->askToRelease = 1;
		device_stop_intr(device);
		for (i = 0; i < DEVICE_NUM_CAM; i++) {
			if (device->useIsoc) {
				device_stop_iso_out(device, i);
				device_stop_iso_in(device, i);
			} else
				device_stop_tsbulk_in(device, i);
		} /* for */
		device->opened = 0;
	} /* if */
	mutex_unlock(&device->lock);
	return 0;
}

static int device_open(struct inode *inode, struct file *file)
{
	int       devnum = iminor(inode);
#ifdef DEBUG
	int        type = (MINOR(inode->i_rdev) >> 4);
	int        num = (MINOR(inode->i_rdev) & 0xf);
#endif
	int   ret = 0;

	struct device_s *device;

	dbg("start, devnum = %d type = %d num = %d", devnum, type, num);

	if (gdeviceNumber >= DRIVER_MAX_NUMBER) {
		dbg("only support one device open");
		return -EINVAL;
	}
	device = &gdevice[gdeviceNumber];
	/*gdeviceNumber++;*/

	ktime_get_ts(&gStart);

	ret = device_drv_open(device);
	if (ret < 0)
		return ret;

	file->f_pos = 0;
	file->private_data = device;

	dbg("end");
	return nonseekable_open(inode, file);
} /* device_open */

static int device_release(struct inode *inode, struct file *file)
{
	struct device_s *device = (struct device_s *)file->private_data;

	dbg("start");
	device_drv_close(device);
	dbg("end");
	return 0;
} /* device_release */

int cimax_usb_select_interface(struct device_s *device, unsigned long intf)
{
	int          max    =  0;
	int          mult    =  0;
	int          ret    =  0;

	info("set interface %ld", intf);
	if (usb_set_interface(device->usbdev, 0, intf) < 0) {
		err("set_interface failed interface 0, altSetting %ld", intf);
		return -EINVAL;
	} /* if */

	/* check endpoints */
	/* CI bulk out */
	if (!usb_endpoint_is_bulk_out(
			&device->usbdev->ep_out[DEVICE_BULK_OUT_PIPE]->desc)) {
		err("unexpected endpoint %d", DEVICE_BULK_OUT_PIPE);
		return -EINVAL;
	} /* if */
	device->ciBulk.outMaxPacketSize = DEVICE_BULK_OUT_MAXPACKET;
	dbg("CI bulk out (endpoint %d), packet size %d", DEVICE_BULK_OUT_PIPE,
			device->ciBulk.outMaxPacketSize);
	/* CI int in */
	if (!usb_endpoint_is_int_in(
			&device->usbdev->ep_in[DEVICE_INT_IN_PIPE]->desc)) {
		err("unexpected endpoint %d", DEVICE_INT_IN_PIPE);
		return -EINVAL;
	} /* if */
	device->ciBulk.inMaxPacketSize =
		device->usbdev->ep_in[DEVICE_INT_IN_PIPE]->desc.wMaxPacketSize;
	dbg("CI int in (endpoint %d), packet size %d", DEVICE_INT_IN_PIPE,
			device->ciBulk.inMaxPacketSize);
	/* TS out */
	if (device->usbdev->ep_out[DEVICE_TS_OUT_PIPE] == NULL)
		dbg("no TS endpoint");
	else {
		if (usb_endpoint_is_bulk_out(
			&device->usbdev->ep_out[DEVICE_TS_OUT_PIPE]->desc)) {
			device->useIsoc = 0;
			dbg("TS is configured as bulk");
		} else if (usb_endpoint_is_isoc_out(
			&device->usbdev->ep_out[DEVICE_TS_OUT_PIPE]->desc)) {
			device->useIsoc = 1;
			dbg("TS is configured as isochronous");
		} else {
			err("unexpected endpoint %d", DEVICE_TS_OUT_PIPE);
			return -EINVAL;
		} /* if */
		max = device->usbdev->
			ep_out[DEVICE_TS_OUT_PIPE]->desc.wMaxPacketSize;
		mult = 1 + ((max >> 11) & 0x03);
		max &= 0x7ff;
		device->channel[0].maxPacketSize = max * mult;
		dbg("TS out (endpoint %d), packet size %d", DEVICE_TS_OUT_PIPE,
				device->channel[0].maxPacketSize);

		max = device->usbdev->
			ep_out[DEVICE_TS_OUT_PIPE+1]->desc.wMaxPacketSize;
		mult = 1 + ((max >> 11) & 0x03);
		max &= 0x7ff;
		device->channel[1].maxPacketSize = max * mult;
		dbg("TS out (endpoint %d), packet size %d",
				DEVICE_TS_OUT_PIPE + 1,
				device->channel[1].maxPacketSize);
	}

	/* start intr urb */
	if (device->ciBulk.intUrb[0] == NULL) {
		ret = device_start_intr(device);
		if (ret < 0) {
			err("cannot start int urb");
			return ret;
		} /* if */
	} /* if */

	return ret;
}
EXPORT_SYMBOL(cimax_usb_select_interface);

static int device_ci_write(struct device_s *device,
		struct ioctl_data_s *data, int isIoctl)
{
	int ret = 0;
	if (!device)
		return -ENODEV;
	ret = device_cibulk_send(device, data, isIoctl);
	if (ret < 0)
		return ret;
	return device_wait_sync_data(device, ret, data, isIoctl);
}

static int device_ci_write_ioctl(struct device_s *device,
		struct ioctl_data_s *data)
{
	return device_ci_write(device, data, 1);
}

int cimax_usb_ci_write(struct device_s *device,
		u8 *txData, int txSize, u8 *rxData, int rxSize)
{
	struct ioctl_data_s data;
	if (!device)
		return -ENODEV;
	memset(&data, 0, sizeof(data));
	data.txData = txData;
	data.txSize = txSize;
	data.rxData = rxData;
	data.rxSize = rxSize;
	return device_ci_write(device, &data, 0);
}
EXPORT_SYMBOL(cimax_usb_ci_write);

int cimax_usb_ci_read_evt(struct device_s *device,
		int moduleId, u8 *buf, int size)
{
	int ret = 0;
	struct rw_data_s data;
	if (!device || !device->opened)
		return -ENODEV;
	memset(&data, 0, sizeof(data));
	data.moduleId = moduleId;
	data.data = buf;
	data.size = size;
	ret = device_wait_async_data(device, data.moduleId, &data, 0);
	if (ret < 0) {
		err("wait ci read failed");
		return ret;
	} /* if */
	dbg("return CI, moduleId %d, data 0x%p, size %d",
			data.moduleId, data.data, data.size);
	return ret;
}
EXPORT_SYMBOL(cimax_usb_ci_read_evt);

int cimax_usb_device_open(struct device_s *device)
{
	return device_drv_open(device);
}
EXPORT_SYMBOL(cimax_usb_device_open);

int cimax_usb_device_unlock_read(struct device_s *device)
{
	int ret = 0;
	if (!device)
		return 0;
	mutex_lock(&device->lock);
	ret = device_ci_unlock_read(device);
	mutex_unlock(&device->lock);
	return ret;
}
EXPORT_SYMBOL(cimax_usb_device_unlock_read);

int cimax_usb_device_close(struct device_s *device)
{
	if (!device)
		return 0;
	cimax_usb_device_unlock_read(device);
	if (cimax_usb_dev_remove)
		cimax_usb_dev_remove(device, gdeviceNumber);
	return device_drv_close(device);
}
EXPORT_SYMBOL(cimax_usb_device_close);

static long device_ioctl(struct file *file,
		unsigned int cmd, unsigned long arg)
{
	struct device_s *device = (struct device_s *)file->private_data;
	int          err    = 0;
	int          ret    = 0;
	struct ioctl_data_s data;
	void         *transfer_buffer = NULL;

	dbg("start");

	/* Don't decode wrong cmds: return ENOTTY (inappropriate ioctl) */
	if (_IOC_TYPE(cmd) != DEVICE_IOC_MAGIC)
		return -ENOTTY;
	if (_IOC_NR(cmd) > DEVICE_IOC_MAXNR)
		return -ENOTTY;

	/* Verify direction (read/write) */
	if (_IOC_DIR(cmd) & _IOC_READ)
//		err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
		err = !access_ok((void *)arg, _IOC_SIZE(cmd));
	else if (_IOC_DIR(cmd) & _IOC_WRITE)
//		err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
		err = !access_ok((void *)arg, _IOC_SIZE(cmd));
	if (err)
		return -EFAULT;

	if (mutex_lock_interruptible(&device->lock))
		return -ERESTARTSYS;

	switch (cmd) {
	case DEVICE_IOC_SELECT_INTF:
		dbg("DEVICE_IOC_SELECT_INTF start");
		ret = cimax_usb_select_interface(device, arg);
		dbg("DEVICE_IOC_SELECT_INTF end");
		break;

	case DEVICE_IOC_CI_WRITE:
		dbg("DEVICE_IOC_CI_WRITE start");

		/* send CI message */
		ret = copy_from_user(&data,
			(void __user *)arg, sizeof(struct ioctl_data_s));
		dbg("inMsg, rx 0x%p, rxSize %d, tx 0x%p, txSize %d",
			data.rxData,
			data.rxSize,
			data.txData,
			data.txSize);
		ret = device_ci_write_ioctl(device, &data);
		if (ret < 0)
			break;
		ret = copy_to_user((void __user *)arg,
			&data, sizeof(struct ioctl_data_s));

		dbg("DEVICE_IOC_CI_WRITE end");
		break;

	case DEVICE_IOC_UNLOCK_READ:
		dbg("DEVICE_IOC_UNLOCK_READ start");

		ret = device_ci_unlock_read(device);

		dbg("DEVICE_IOC_UNLOCK_READ end");
		break;

	case DEVICE_IOC_SET_CONFIG:
		dbg("DEVICE_IOC_SET_CONFIG start");

		/* send CI message */
		ret = copy_from_user(&data,
			(void __user *)arg, sizeof(struct ioctl_data_s));
		dbg("inMsg, rx 0x%p, rxSize %d, tx 0x%p, txSize %d",
			data.rxData, data.rxSize,
			data.txData, data.txSize);
		transfer_buffer = kmalloc(data.txSize, GFP_KERNEL);
		memcpy(transfer_buffer, data.txData, data.txSize);
		dbg_dump("New config", transfer_buffer, data.txSize);
		err = usb_control_msg(device->usbdev,
			usb_sndctrlpipe(device->usbdev, 0),
			USB_REQ_SET_DESCRIPTOR,
			USB_TYPE_STANDARD,
			(USB_DT_CONFIG << 8),
			0,
			transfer_buffer,
			data.txSize,
			5000);
		if (err < 0) {
			err("set_config failed %d", err);
			ret = -EINVAL;
		}
		kfree(transfer_buffer);
		dbg("DEVICE_IOC_SET_CONFIG end");
		break;

	default:
		ret = -ENOIOCTLCMD;
		break;
	} /* switch */
	mutex_unlock(&device->lock);

	dbg("end, ret %d", ret);
	return ret;
} /* device_ioctl */

static ssize_t device_write(struct file *file, const char __user *buf,
		size_t count, loff_t *ppos)
{
	int       ret;
	struct rw_data_s data;
	struct device_s *device = (struct device_s *)file->private_data;

	dbg("start");

	/* get transmission buffer */
	ret = copy_from_user(&data, buf, sizeof(struct rw_data_s));
	dbg("txBuffer, moduleId %u, data 0x%p, size %d",
			data.moduleId, data.data, data.size);
	if (data.moduleId >= DEVICE_NUM_CAM) {
		err("bad moduleId");
		return 0;
	}

	if (device->useIsoc) {
		if (!data.size || (data.size % DEVICE_ISOC_LENGTH(
			device->channel[data.moduleId].maxPacketSize))) {
			err("transmission buffer size must be a multiple of %d",
				DEVICE_ISOC_LENGTH(
				device->channel[data.moduleId].maxPacketSize));
			return -EINVAL;
		} /* if */
	}

	if (device->useIsoc) {
		if (device->channel[data.moduleId].isocInUrb[0] == NULL) {
			ret = device_start_iso_in(device, data.moduleId);
			if (ret < 0)
				return ret;
		} /* if */

		if (device->channel[data.moduleId].isocOutUrb[0] == NULL) {
			ret = device_start_iso_out(device, data.moduleId);
			if (ret < 0)
				return ret;
		} /* if */

		dbg("call device_tsiso_send moduleId %d, data 0x%p, size %d",
			data.moduleId, data.data, data.size);
		ret = device_tsiso_send(device,
			data.moduleId, data.data, data.size);
	} /* if */
	else {
		ret = device_tsbulk_send(device,
			data.moduleId, data.data, data.size);
	} /* else */

	dbg("end, moduleId %d return %d", data.moduleId, ret);
	return ret;
} /* device_write */

static ssize_t device_read(struct file *file, char __user *buf,
		size_t count, loff_t *ppos)
{
	int       res;
	struct rw_data_s data;
	struct device_s *device = (struct device_s *)file->private_data;

	dbg("start");

	if (count != sizeof(struct rw_data_s)) {
		err("try to read uncorrect size %zd", count);
		return -EFAULT;
	} /* if */
	res = copy_from_user(&data, buf, sizeof(struct rw_data_s));
	data.copiedSize = 0;
	if (data.type == DEVICE_TYPE_TS_READ) {
		res = device_fill_ts(device, data.moduleId, &data);
		if (res < 0) {
			err("fill ts buffer failed");
			return res;
		} /* if */
		dbg("return TS, moduleId %d, data 0x%p, size %d, copiedSize %d",
			data.moduleId, data.data, data.size, data.copiedSize);
		/*res = count;*/
		res = data.copiedSize;
	} /* if */
	else if (data.type == DEVICE_TYPE_CI_READ) {
		res = device_wait_async_data(device, data.moduleId, &data, 1);
		if (res < 0) {
			err("wait ci read failed");
			return res;
		} /* if */
		dbg("return CI, moduleId %d, data 0x%p, size %d",
				data.moduleId, data.data, data.size);
		res = data.size;
	} /* else if */
	else {
		err("unknown data type %d", data.type);
		res = -EFAULT;
	} /* else */

	dbg("end, return %d", res);
	return res;
} /* device_read */

/******************************************************************************
 * @brief
 *   write data on Control endpoint.
 *

 * @param   dev
 *   Pointer to usb device.
 *
 * @param   addr

 *   register address to write.
 *
 * @param   data
 *   data to write.
 *

 * @param   size
 *   size to write.
 *
 * @return

 *   data writen or ENODEV error
 ******************************************************************************/
int write_ctrl_message(struct usb_device *dev, int addr, void *data, int size)
{
	int ret;
	void *ptr = NULL;
#ifdef DEBUG
	/*   int i;*/
	/*   unsigned char dump[500];*/
#endif

	/*   info("%s: . addr = %04x size=%d",DRIVER_NAME,addr,size);*/

	if (size <= 0)
		return 0;

	ptr = kmemdup(data, size, GFP_KERNEL);
	if (!ptr)
		return -ENOMEM;

	ret = usb_control_msg
			(dev, usb_sndctrlpipe(dev, 0), 0xA0, 0x40, addr, 0x0001,
			ptr, size, 300);
	if (ret != size) {
		err("Failed to write CIMaX+ register 0x%04x", addr);
		ret = -ENODEV;
	}

#ifdef DEBUG
	/*   dump[0] =0;
		 for(i=0;i<size;i++) {
		 if((i !=0) && ((i%16) == 0)) {
		 dbg("cimax+usb: %s",dump);
		 dump[0] =0;
		 }
		 sprintf(dump,"%s%02x ",dump,((unsigned char *)ptr)[i]);
		 }
		 dbg("cimax+usb: %s",dump);
	 */
#endif
	kfree(ptr);

	return ret;
}

/******************************************************************************
 * @brief
 *   read data from Control endpoint.
 *

 * @param   dev
 *   Pointer to usb device.
 *
 * @param   addr
 *   firmware address to read.

 *
 * @param   data
 *   pointer to buffer to fill with register data.
 *

 * @param   size
 *   size to read.
 *
 * @return
 *   data writen or ENODEV error

 ******************************************************************************/
int read_ctrl_message(struct usb_device *dev, int addr, void *data, int size)
{
	int ret;
	ret = usb_control_msg
			(dev, usb_rcvctrlpipe(dev, 0), 0xA0, 0xC0, addr, 0x0001,
			(void *)data, size, 300);
	if (ret != size) {
		err("Failed to read CIMaX+ register 0x%04x return %d",
			addr, ret);
		ret = -ENODEV;
	}
	return ret;
}

/******************************************************************************
 * @brief
 *   Start new Firmware.
 *
 * @param   dev
 *   Pointer to usb device.
 *
 * @return
 *   None.
 ******************************************************************************/
int init_fw(struct usb_device *dev)
{
	int len;
	char *bootStatus = NULL;
	bootStatus = kmalloc(sizeof(char), GFP_KERNEL);
	if (!bootStatus) {
		pr_err("%s: init_fw kmalloc failed\n",
				DRIVER_NAME);
		return 0;
	}

	info("%s: .", DRIVER_NAME);
	len = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
		0xA0, 0xC0, 0x0000, 0x0000, bootStatus, 1, 100);
	if (len == 1) {
		info("--> Init Status = %02X", *bootStatus);
		if (bootStatus)
			kfree(bootStatus);
		return 0;
	}
	if (bootStatus)
		kfree(bootStatus);

	return len;
}

/******************************************************************************
 * @brief
 *   Start new Firmware.
 *
 * @param   dev
 *   Pointer to usb device.

 *
 * @return
 *   None.
 ******************************************************************************/
int write_ep6_message(struct usb_device *dev, void *data, int size)
{
	int ret;
	void * ptr = NULL;
	ptr = kmemdup(data, size, GFP_KERNEL);
	if (!ptr)
		return -ENOMEM;

	if (usb_bulk_msg(dev, usb_sndbulkpipe(dev, 6),
			ptr, size, &ret, 200) < 0) {
		err("Failed to write cmd 0x%02x", ((unsigned char *)data)[0]);
		ret = -ENODEV;
	}
	kfree(ptr);
	return ret;
}

/******************************************************************************
 * @brief
 *   Start new Firmware.
 *
 * @param   dev
 *   Pointer to usb device.
 *
 * @return
 *   None.
 ******************************************************************************/
int read_ep5_message(struct usb_device *dev, void *data, int size)
{
	int ret;

	if (usb_interrupt_msg(dev, usb_rcvintpipe(dev, 5),
			data, size, &ret, 200) < 0) {
		err("Failed read interrupt endpoint");
		ret = -ENODEV;
	}
	return ret;
}

#ifdef CONFIG_COMPAT
static long device_compat_ioctl(struct file *filp,
		unsigned int cmd, unsigned long args)
{
	unsigned long ret;

	args = (unsigned long)compat_ptr(args);
	ret = device_ioctl(filp, cmd, args);
	return ret;
}
#endif

static const struct file_operations device_fops = {
	.owner   = THIS_MODULE,
	.open    = device_open,
	.release = device_release,
	.unlocked_ioctl = device_ioctl,
	.write   = device_write,
	.read    = device_read,
	/*
	.poll    = device_poll,
	*/
#ifdef CONFIG_COMPAT
	.compat_ioctl = device_compat_ioctl,
#endif
};

struct cimaxusb_priv_ops_t cimaxusb_priv_ops = {
	.write_ctrl_message  = write_ctrl_message,
	.read_ctrl_message   = read_ctrl_message,
	.init_fw             = init_fw,
	.write_ep6_message   = write_ep6_message,
	.read_ep5_message    = read_ep5_message
};

static struct usb_class_driver device_class = {
	.name = "cimaxusb%d",
	.fops = &device_fops,
	.minor_base = DEVICE_MINOR,
};

/* ---------------------------------------------------------- */


void cimax_usb_set_cb(void *cb1, void *cb2)
{
	cimax_usb_dev_add = cb1;
	cimax_usb_dev_remove = cb2;
}
EXPORT_SYMBOL(cimax_usb_set_cb);

static int device_probe(struct usb_interface *intf,
		const struct usb_device_id *id)
{
	struct usb_device *usbdev = interface_to_usbdev(intf);
	struct device_s *device;
	char cmd[] = { 0x0C, 0x01, 0x00, 0x00 };
	char *rsp;

	dbg("start vendor id 0x%x, product id 0x%x, Device id 0x%x minor 0x%x",
			le16_to_cpu(usbdev->descriptor.idVendor),
			le16_to_cpu(usbdev->descriptor.idProduct),
			le16_to_cpu(usbdev->descriptor.bcdDevice),
			intf->minor);

	/*  device = &gdevice[intf->minor];*/
	device = &gdevice[gdeviceNumber];

	mutex_lock(&device->lock);
	/*  device->usbdev = usbdev;*/
	device->usbdev = usb_get_dev(usbdev);
	dbg("device->usbdev 0x%p", (device->usbdev));

	/* set private callback functions */
	device->ops = &cimaxusb_priv_ops;

	device->askToSuspend = 0;

	usb_set_intfdata(intf, device);
	mutex_unlock(&device->lock);

	if (usb_register_dev(intf, &device_class)) {
		err("usb_register_dev");
		usb_set_intfdata(intf, NULL);
		return -ENOMEM;
	} /* if */

	/* test if firmware loafing is needed */
#ifdef FRBIT
	if ((le16_to_cpu(usbdev->descriptor.bcdDevice) != 0) &&
			(CimaxDwnl == 1)) {
#else
	if (le16_to_cpu(usbdev->descriptor.bcdDevice) != 0) {
#endif
		info("start firmware download");
		/* load firmware*/
		cimaxusb_fw_upload(device);
		info("end firmware download");
	} else {
		info("set alternate setting 1");
		if (usb_set_interface(device->usbdev, 0, 1) < 0) {
			err("set_interface failed intf 0, alt 1");
		} else {
			info("check FW version");
			/* Get BOOT version */
			if (write_ep6_message(device->usbdev,
				cmd, sizeof(cmd)) == sizeof(cmd)) {
				rsp = kcalloc(256,
					sizeof(unsigned char),
					GFP_KERNEL);
				if (!rsp) {
					err("out of memory");
					return -ENOMEM;
				}
				if (read_ep5_message(device->usbdev,
						rsp, 256) >= 0) {
					info("=> ---- F.W. Version -------");
					info("=>= %02X.%02X.%02X.%02X.%02X%c",
						rsp[4], rsp[5], rsp[6],
						rsp[7], rsp[8], rsp[9]);
					info("=> Boot Version = %d.%d",
						rsp[10], rsp[11]);
					info("=> --------------------");
				}
				kfree(rsp);
			}
		}
		info("start cfg download");
		if (cimaxusb_configuration_setting(device) < 0)
			err(" Error : set CIMaX+ configuration");
		info("end cfg download");

		if (cimax_usb_dev_add)
			cimax_usb_dev_add(device, gdeviceNumber);
	}

	dbg("end");
	return 0;
} /* device_probe */

static void device_disconnect(struct usb_interface *intf)
{
	struct device_s *device = usb_get_intfdata(intf);
	int       i;

	dbg("start");

	if (!device)
		return;

	mutex_lock(&device->lock);
	if (device->opened) {
		/* release blocking functions */
		device->askToRelease = 1;
		wake_up_interruptible(&device->ciBulk.ciData[0].asyncWait);
		wake_up_interruptible(&device->ciBulk.ciData[1].asyncWait);
		wake_up_interruptible(&device->channel[0].inWait);
		wake_up_interruptible(&device->channel[1].inWait);
		device_stop_intr(device);
		for (i = 0; i < DEVICE_NUM_CAM; i++) {
			if (device->useIsoc) {
				device_stop_iso_out(device, i);
				device_stop_iso_in(device, i);
			} /* if */
			else
				device_stop_tsbulk_in(device, i);
		} /* for */
		device->opened = 0;

		if (cimax_usb_dev_remove)
			cimax_usb_dev_remove(device, gdeviceNumber);
	} /* if */
	mutex_unlock(&device->lock);
	usb_set_intfdata(intf, NULL);
	if (device) {
		usb_deregister_dev(intf, &device_class);
		device->usbdev = NULL;
	} /* if */
	dbg("end");
} /* device_disconnect */

static int cimaxusb_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct device_s *device = usb_get_intfdata(intf);
	int       i;

	dbg("start");

	if (!device)
		return 0;

	mutex_lock(&device->lock);
	if (device->opened) {
		/* release blocking functions */
		device->askToSuspend = 1;
		wake_up_interruptible(&device->ciBulk.ciData[0].asyncWait);
		wake_up_interruptible(&device->ciBulk.ciData[1].asyncWait);
		wake_up_interruptible(&device->channel[0].inWait);
		wake_up_interruptible(&device->channel[1].inWait);
		device_stop_intr(device);
		for (i = 0; i < DEVICE_NUM_CAM; i++) {
			if (device->useIsoc) {
				device_stop_iso_out(device, i);
				device_stop_iso_in(device, i);
			} /* if */
			else
				device_stop_tsbulk_in(device, i);
		} /* for */
		device->opened = 0;
	} /* if */
	mutex_unlock(&device->lock);
	dbg("end");

	return 0;
}

static int cimaxusb_resume(struct usb_interface *intf)
{
	struct device_s *device = usb_get_intfdata(intf);

	dbg("start");

	if (!device)
		return 0;

	device->askToSuspend = 0;
	dbg("end");
	return 0;
}

static struct usb_device_id device_ids[] = {
	{ USB_DEVICE(0x1b0d, 0x2f00) },
	{ USB_DEVICE(0x1b0d, 0x2f01) },
	{ USB_DEVICE(0x1b0d, 0x2f02) },
	{ USB_DEVICE(0x1b0d, 0x2f03) },
	{ USB_DEVICE(0x1b0d, 0x2f04) },
	{ }           /* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, device_ids);


static struct usb_driver device_driver = {
	.name = "cimaxusb",
	.probe = device_probe,
	.disconnect = device_disconnect,
	.suspend =  cimaxusb_suspend,
	.resume = cimaxusb_resume,
	.id_table = device_ids,
};

/* ---------------------------------------------------------- */

static int device_init_module(void)
{
	int ret = 0;
	int i, j;
	struct device_s *device;

	info("start");

	if (!gdevice)
		gdevice = kcalloc(DRIVER_MAX_NUMBER,
			sizeof(struct device_s), GFP_KERNEL);
	if (!gdevice) {
		err("not enough memory");
		return -ENOMEM;
	}

	for (i = 0; i < DRIVER_MAX_NUMBER; i++) {
		device = &gdevice[i];
		/* initialize struct */
		memset(device, 0, sizeof(struct device_s));
		mutex_init(&device->lock);

		/* initialize ci bulk struct */
		device->ciBulk.counter = 1;
		spin_lock_init(&device->ciBulk.intLock);
		spin_lock_init(&device->ciBulk.intUrbLock);
		for (j = 0; j < DEVICE_NUM_CAM; j++) {
			init_waitqueue_head(&device->ciBulk.ciData[j].syncWait);
			init_waitqueue_head(
				&device->ciBulk.ciData[j].asyncWait);
			INIT_LIST_HEAD(&device->ciBulk.ciData[j].asyncDataList);
		} /* for */

		/* initialize channels */
		for (j = 0; j < DEVICE_NUM_CAM; j++) {
			spin_lock_init(&device->channel[j].inLock);
			init_waitqueue_head(&device->channel[j].inWait);
			vb_init(&device->channel[j].inVb);
			device->channel[j].syncOffset = -1;
			spin_lock_init(&device->channel[j].outLock);
		} /* for */
	} /* for */

	/* register misc device */
	ret = usb_register(&device_driver);

#ifdef TIMESTAMP
	InitTimestamp();
#endif

	if (ret)
		info("end driver register failed");
	else
		info("end driver registered");

	info(DRIVER_VERSION ":" DRIVER_DESC);

	return ret;
} /* device_init_module */

static void device_exit_module(void)
{
	int i;
	struct device_s *device;

	info("start");

#ifdef TIMESTAMP
	ShowTimestamp();
#endif

	for (i = 0; i < DRIVER_MAX_NUMBER; i++) {
		device = &gdevice[i];
		device->askToRelease = 1;
		/* destroy struct */
		mutex_destroy(&device->lock);
	} /* for */
	usb_deregister(&device_driver);
	gdeviceNumber = 0;

	kfree(gdevice);
	gdevice = NULL;
	info("end");
} /* device_exit_module */

module_init(device_init_module);
module_exit(device_exit_module);