qcamvc_usb.c

VC编写的USB QuickCam驱动程序,实现四种视频格式在linux下的编码,信号来自摄像源

	unsigned char regs [7];
	int retval = 0;
	
	if ((udev==NULL)||(buffer==NULL))
		return -1;
		
	reset_uss(udev);
	get_1284_register(udev, GET_USS720_CONTROL, regs);
	set_1284_register(udev, SET_USS720_USSCTRL, ALL_INT_MASK);
	get_1284_register(udev, GET_USS720_CONTROL, regs);
	set_1284_register(udev, SET_USS720_USSCTRL, ALL_INT_MASK);
	set_1284_register(udev, SET_USS720_CONTROL, EPP_MASK | NINIT | HLH | SELECT_IN);
	set_1284_register(udev, SET_USS720_DATA, 0x10);
	set_1284_register(udev, SET_USS720_CONTROL, EPP_MASK | NINIT | HLH | AUTO_FD);
	get_1284_register(udev, GET_USS720_CONTROL, regs);
	set_1284_register(udev, SET_USS720_CONTROL, EPP_MASK | NINIT | HLH | AUTO_FD |STROBE );
	set_1284_register(udev, SET_USS720_CONTROL, EPP_MASK | NINIT | HLH);
	get_1284_register(udev, GET_USS720_CONTROL, regs);
	set_1284_register(udev, SET_USS720_CONTROL, EPP_MASK | NINIT | HLH | AUTO_FD);
	get_1284_register(udev, GET_USS720_CONTROL, regs);
	get_1284_register(udev, GET_USS720_STATUS,  regs);
	set_1284_register(udev, SET_USS720_EXTCTRL, ECR_ECP | BULK_IN_EMPTY| BULK_OUT_EMPTY );
	set_1284_register(udev, SET_USS720_CONTROL, EPP_MASK | NINIT | HLH);
	set_1284_register(udev, SET_USS720_ECPCMD,  reg);
	reset_uss(udev);
	
	if ((len > 0)&(buffer!=NULL))
	{
		retval = qcamvc_bulk_read(udev, buffer, len);
		reset_uss(udev);
	}
	
	USB_DBG("Read 0x%02x, len=%02x, \n", reg, sizeof(buffer));
	
	return retval;
}

static size_t qcamvc_stream_read(void *privdata, void *buffer, size_t len)
{
	struct usb_qcamvc *usb_qcamvc =  (struct usb_qcamvc*)privdata;
	struct usb_device *udev = usb_qcamvc->udev;
	//unsigned char buf = 0;
	size_t ret;
	
	reset_uss(udev);
	//qcamvc_bulk_write(udev, &buf, 1);
	ret = qcamvc_bulk_read(udev, buffer, len);
	
	return ret;
}

static int get_1284_register(struct usb_device *usbdev, unsigned char reg, unsigned char *val) 
{
	int ret;
	
	if (usbdev==NULL)
	{
		printk("QuickCam VC(USB):get_1284_reg not usbdev!\n");
		return -1;
	}
	
	ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev,0), 3, 0xc0, 
		((unsigned int)reg) << 8, 0, val, 7, HZ);
	if (ret < 0)
	{
		printk("QuickCam VC(USB): get_1284_register(%d) failed, status 0x%02x\n",
			(unsigned int)reg, ret);
	}
	else
	{
	}     
	
	return ret;
}


static int set_1284_register(struct usb_device *usbdev, unsigned char reg, unsigned char val)
{
	int ret;
		
	if (usbdev==NULL)
	{
		printk("QuickCam VC(USB):set_1284_reg not usbdev!\n");
		return -1;
	}
		
	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev,0), 4, 0x40, 
		(((unsigned int)reg) << 8) | val, 0, NULL, 0, HZ);      
	if (ret)
	{
		printk("QuickCam VC(USB): set_1284_register(%u,0x%02x) failed, status 0x%02x\n", 
			(unsigned int)reg, (unsigned int)val, ret);
	}
	else
	{
	}
	return ret;
}

static int reset_uss(struct usb_device *usbdev)
{
	int ret;
	if (usbdev==NULL)
		return -1;
	ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev,0), 2, 0x23, 
		0, 0, NULL, 0, HZ);
	if (ret)
	{
		printk("QuickCam VC(USB): reset_uss failed, status 0x%02x\n", ret);
	}
	else
	{
	}
	
	return ret;
}

static size_t qcamvc_bulk_write(struct usb_device *usbdev, void *buffer, size_t len )
{
	int rlen;
	int i;
	
	if (usbdev==NULL)
	{
		printk("QuickCam VC(USB):Bulk_write not usbdev!");
		return -1;
	}
	if (buffer==NULL)
	{
		printk("QuickCam VC(USB):Bulk_write NULL pointer buffer!");
		return -1;
	}
	USB_DBG("bulk write len=%d\n",(int) len);           
	i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, HZ*20);
	if (i)
		printk("QuickCam VC(USB): bulkwrite buf %p len %u rlen %u\n", buffer, (int)len, rlen);
	
	return rlen;
}

static size_t qcamvc_bulk_read(struct usb_device *usbdev, void *buffer, size_t len)
{
	int rlen;
	int i;
	
	if (usbdev==NULL)
	{
		printk("QuickCam VC(USB):Bulk_read not usbdev!");
		return -1;
	}
	if (buffer==NULL)
	{
		printk("QuickCam VC(USB):Bulk_read NULL pointer buffer!");
		return -1;
	}
	USB_DBG("bulk read len=0x%x ",(int) len);         
	
	i = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), buffer, len, &rlen, HZ*20);
	if (len!=rlen)
		printk("QuickCam VC(USB): bulkread buf %p len 0x%x rlen 0x%x\n", buffer, (int)len, rlen);
		
	USB_DBG("rlen=%d\n",(int) rlen);
	
	return rlen;
}

static int probe_qcamvc(struct usb_interface *intf, const struct usb_device_id *id)
{
	struct usb_device *udev = interface_to_usbdev(intf);
	struct usb_host_interface *interface = NULL;
	struct usb_qcamvc *usb_qcamvc = NULL;
	struct qcamvc_data *qcamvc = NULL;
	int ret;
  
	printk(KERN_INFO "QuickCam VC(USB): Found Vendor ID: 0x%x, Product ID: %d\n", 
		udev->descriptor.idVendor, udev->descriptor.idProduct);
	
	/* See if the device offered us matches what we can accept */
	if ((udev->descriptor.idVendor != 0x0478) || (udev->descriptor.idProduct != 0x0001))
	{
		printk(KERN_INFO "QuickCam VC(USB): That device is not a QuickCam VC (0x%x,%d)\n", 
			udev->descriptor.idVendor, udev->descriptor.idProduct);
		return -ENODEV;
	}

	usb_qcamvc = kmalloc(sizeof(*usb_qcamvc), GFP_KERNEL);
	if (!usb_qcamvc) {
		printk(KERN_ERR "couldn't kmalloc usb_qcamvc struct\n");
		return -ENOMEM;
	}

	interface = &intf->altsetting[0];
	usb_qcamvc->iface = interface->desc.bInterfaceNumber;
	usb_qcamvc->udev = udev;

	ret = usb_set_interface(udev, usb_qcamvc->iface, 2);
	if (ret < 0)
	{
		printk(KERN_ERR "qcamvc_probe: usb_set_interface error (returned %d)\n", ret);
	}
	USB_DBG(" USS720: set inteface result %d\n", i);

	if ( (qcamvc = qcamvc_register_camera(&qcamvc_usb_ops, usb_qcamvc, "QuickCam VC(USB)")) == NULL )
	{
		printk(KERN_ERR "Failed to qcamvc_register_camera (USB)\n");
		kfree(usb_qcamvc);
		return -EIO;
	}

	spin_lock( &cam_list_lock_usb );
	list_add( &qcamvc->cam_data_list, &cam_list );
	spin_unlock( &cam_list_lock_usb );

	usb_set_intfdata(intf, qcamvc);
	
	printk(KERN_INFO "QuickCam VC(USB): sucessfully registered.\n");
	
	return 0;
}

static void disconnect_qcamvc(struct usb_interface *intf)
{
	struct qcamvc_data *qcamvc = usb_get_intfdata(intf);
	struct usb_qcamvc *usb_qcamvc;
	struct usb_device *udev;
	
	usb_set_intfdata(intf, NULL);
	
	if (!qcamvc)
	{
		//printk(KERN_ERR "usb_get_intfdata() returned NULL!\n");
		return;
	}

	printk(KERN_INFO "QuickCam VC(USB): unregistering video/USB...\n");
	
	usb_qcamvc = (struct usb_qcamvc *) qcamvc->lowlevel_data;
	
	spin_lock( &cam_list_lock_usb );
	list_del(&qcamvc->cam_data_list);
	spin_unlock( &cam_list_lock_usb );

	qcamvc_unregister_camera(qcamvc);
	
	udev = interface_to_usbdev(intf);
	usb_driver_release_interface(&qcamvc_driver, udev->actconfig->interface[0]);
	
	kfree(usb_qcamvc);

	printk(KERN_INFO "QuickCam VC(USB): USB/video devices unregistered.\n");
}

static int __init qcamvc_usb_init (void)
{
	printk("QuickCam VC(USB): (C) 2001 by De Marchi Daniele, <[e-mail]>\n");
	printk("QuickCam VC(USB): lowlevel driver version %s registered.\n",QCAMVCVERSION);

	spin_lock_init(&cam_list_lock_usb);
	
	return usb_register(&qcamvc_driver);
}

static void __exit qcamvc_usb_exit(void)
{
	usb_deregister(&qcamvc_driver);
}

module_init(qcamvc_usb_init);
module_exit(qcamvc_usb_exit);