ohci-hcd-1.c

Usb1.1驱动c语言源代码

/*
 * URB OHCI HCD (Host Controller Driver) for USB.
 *
 * (C) Copyright 1999 Roman Weissgaerber <[e-mail]>
 * 
 * [ Initialisation is based on Linus'  ]
 * [ uhci code and gregs ohci fragments ]
 * [ (C) Copyright 1999 Linus Torvalds  ]
 * [ (C) Copyright 1999 Gregory P. Smith]
 * 
 * 
 * History:
 * 
 * v5.2 1999/12/07 URB 3rd preview, 
 * v5.1 1999/11/30 URB 2nd preview, cpia, (usb-scsi)
 * v5.0 1999/11/22 URB Technical preview, Paul Mackerras powerbook susp/resume 
 * 	i386: HUB, Keyboard, Mouse, Printer 
 *
 * v4.3 1999/10/27 multiple HCs, bulk_request
 * v4.2 1999/09/05 ISO API alpha, new dev alloc, neg Error-codes
 * v4.1 1999/08/27 Randy Dunlap's - ISO API first impl.
 * v4.0 1999/08/18 
 * v3.0 1999/06/25 
 * v2.1 1999/05/09  code clean up
 * v2.0 1999/05/04 
 * v1.0 1999/04/27 initial release
 * 
 
 */
 
#include <linux/config.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/sched.h>
#include <linux/malloc.h>
#include <linux/smp_lock.h>
#include <linux/errno.h>
#include <linux/timer.h>
// #include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/interrupt.h>  /* for in_interrupt() */

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/system.h>

#define DEBUG

#include "usb.h"
#include "ohci-hcd.h"


#ifdef DEBUG
	#define dbg printk
#else
	#define dbg __xxx
static void __xxx (const char *format, ...) 
{
}
#endif

#ifdef CONFIG_APM
#include <linux/apm_bios.h>
static int handle_apm_event (apm_event_t event);
#endif

#ifdef CONFIG_PMAC_PBOOK
#include <linux/adb.h>
#include <linux/pmu.h>
#endif

static DECLARE_WAIT_QUEUE_HEAD (op_wakeup); 
static LIST_HEAD (ohci_hcd_list);
spinlock_t usb_ed_lock = SPIN_LOCK_UNLOCKED;

/*-------------------------------------------------------------------------*
 * URB support functions 
 *-------------------------------------------------------------------------*/ 
 
/* free the private part of an URB */
 
static void urb_rm_priv (urb_t * urb) 
{
	urb_priv_t * urb_priv = urb->hcpriv;
	int i;
	void * wait;
	
	if (!urb_priv) return;
	
	wait = urb_priv->wait;
	
	for (i = 0; i < urb_priv->length; i++) {
		if (urb_priv->td [i]) {
			OHCI_FREE (urb_priv->td [i]);
		}
	}
	kfree (urb->hcpriv);
	urb->hcpriv = NULL;
	
	if (wait) {
		add_wait_queue (&op_wakeup, wait); 
		wake_up (&op_wakeup);
	}
}

/*-------------------------------------------------------------------------*/
 
#ifdef DEBUG
static int sohci_get_current_frame_number (struct usb_device * dev);

/* debug| print the main components of an URB     
 * small: 0) header + data packets 1) just header */
 
static void urb_print (urb_t * urb, char * str, int small)
{
	unsigned int pipe= urb->pipe;
	int i, len;
	
	if (!urb->dev || !urb->dev->bus) {
		printk(KERN_DEBUG " %s URB: no dev\n", str);
		return;
	}
	
	printk (KERN_DEBUG "%s URB:[%4x] dev:%2d,ep:%2d-%c,type:%s,"
			"flags:%4x,len:%d/%d,stat:%d(%x)\n", 
			str,
		 	sohci_get_current_frame_number (urb->dev), 
		 	usb_pipedevice (pipe),
		 	usb_pipeendpoint (pipe), 
		 	usb_pipeout (pipe)? 'O': 'I',
		 	usb_pipetype (pipe) < 2? (usb_pipeint (pipe)? "INTR": "ISOC"):
		 		(usb_pipecontrol (pipe)? "CTRL": "BULK"),
		 	urb->transfer_flags, 
		 	urb->actual_length, 
		 	urb->transfer_buffer_length,
		 	urb->status, urb->status);
	if (!small) {
		if (usb_pipecontrol (pipe)) {
			printk (KERN_DEBUG " cmd(8):");
			for (i = 0; i < 8 ; i++) 
				printk (" %02x", ((__u8 *) urb->setup_packet) [i]);
			printk ("\n");
		}
		if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) {
			printk (KERN_DEBUG " data(%d/%d):", 
				urb->actual_length, 
				urb->transfer_buffer_length);
			len = usb_pipeout (pipe)? 
						urb->transfer_buffer_length: urb->actual_length;
			for (i = 0; i < 16 && i < len; i++) 
				printk (" %02x", ((__u8 *) urb->transfer_buffer) [i]);
			printk ("%s stat:%d\n", i < len? "...": "", urb->status);
		}
	} 
	
}
/* just for debugging; prints all 32 branches of the int ed tree inclusive iso eds*/
void ep_print_int_eds (ohci_t * ohci, char * str) {
	int i, j;
	 __u32 * ed_p;
	for (i= 0; i < 32; i++) {
		j = 5;
		printk (KERN_DEBUG " %s branch int %2d(%2x): ", str, i, i);
		ed_p = &(ohci->hcca.int_table [i]);
		while (*ed_p != 0 && j--) {
			printk ("ed: %4x; ", (((ed_t *) bus_to_virt (*ed_p))->hwINFO));
			ed_p = &(((ed_t *) bus_to_virt (*ed_p))->hwNextED);
		}
		printk ("\n");
	}
}
		

#endif

/*-------------------------------------------------------------------------*
 * Interface functions (URB)
 *-------------------------------------------------------------------------*/

/* return a request to the completion handler */
 
static int sohci_return_urb (urb_t * urb)
{
	urb_priv_t * urb_priv = urb->hcpriv;
	urb_t * urbt;
	unsigned int flags;
	int i;
	
	/* just to be sure */
	if (!urb->complete) {
		urb_rm_priv (urb);
		usb_dec_dev_use (urb->dev);
		return -1;
	}
	
	if (!urb_priv) return -1; /* urb already unlinked */
	
#ifdef DEBUG
	urb_print (urb, "RET", usb_pipeout (urb->pipe));
#endif

	switch (usb_pipetype (urb->pipe)) {
  		case PIPE_INTERRUPT:
			urb->complete (urb); /* call complete and requeue URB */	
  			urb->actual_length = 0;
  			urb->status = USB_ST_URB_PENDING;
  			if (urb_priv->state != URB_DEL)
  				td_submit_urb (urb);
  			break;
  			
		case PIPE_ISOCHRONOUS:
			for (urbt = urb->next; urbt && (urbt != urb); urbt = urbt->next);
			if (urbt) { /* send the reply and requeue URB */	
				urb->complete (urb);
				
				spin_lock_irqsave (&usb_ed_lock, flags);
				urb->actual_length = 0;
  				urb->status = USB_ST_URB_PENDING;
  				urb->start_frame = urb_priv->ed->last_iso + 1;
  				if (urb_priv->state != URB_DEL) {
  					for (i = 0; i < urb->number_of_packets; i++) {
  						urb->iso_frame_desc[i].actual_length = 0;
  						urb->iso_frame_desc[i].status = -EXDEV;
  					}
  					td_submit_urb (urb);
  				}
  				spin_unlock_irqrestore (&usb_ed_lock, flags);
  				
  			} else { /* unlink URB, call complete */
				urb_rm_priv (urb);
				usb_dec_dev_use (urb->dev);
				urb->complete (urb); 	
			}		
			break;
  				
		case PIPE_BULK:
		case PIPE_CONTROL: /* unlink URB, call complete */
			urb_rm_priv (urb);
			usb_dec_dev_use (urb->dev);
			urb->complete (urb);	
			break;
	}
	return 0;
}

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

/* get a transfer request */
 
static int sohci_submit_urb (urb_t * urb)
{
	ohci_t * ohci;
	ed_t * ed;
	urb_priv_t * urb_priv;
	unsigned int pipe = urb->pipe;
	int i, size = 0;
	unsigned int flags;
	
	if (!urb->dev || !urb->dev->bus) return -EINVAL;
	
	if (urb->hcpriv) return -EINVAL; /* urb already in use */

	usb_inc_dev_use (urb->dev);
	ohci = (ohci_t *) urb->dev->bus->hcpriv;
	
#ifdef DEBUG
	urb_print (urb, "SUB", usb_pipein (pipe));
#endif
	
	if (usb_pipedevice (pipe) == ohci->rh.devnum) 
		return rh_submit_urb (urb); /* a request to the virtual root hub */

	/* every endpoint has a ed, locate and fill it */
	if (!(ed = ep_add_ed (urb->dev, pipe, urb->interval, 1))) {
		usb_dec_dev_use (urb->dev);	
		return -ENOMEM;
	}

	/* for the private part of the URB we need the number of TDs (size) */
	switch (usb_pipetype (pipe)) {
		case PIPE_BULK:	/* one TD for every 4096 Byte */
			size = (urb->transfer_buffer_length - 1) / 4096 + 1;
			break;
		case PIPE_ISOCHRONOUS: /* number of packets from URB */
			size = urb->number_of_packets;
			for (i = 0; i < urb->number_of_packets; i++) {
  				urb->iso_frame_desc[i].actual_length = 0;
  				urb->iso_frame_desc[i].status = -EXDEV;
  			}
			break;
		case PIPE_CONTROL: /* 1 TD for setup, 1 for ACK and 1 for every 4096 B */
			size = (urb->transfer_buffer_length == 0)? 2: 
						(urb->transfer_buffer_length - 1) / 4096 + 3;
			break;
		case PIPE_INTERRUPT: /* one TD */
			size = 1;
			
			break;
	}

	/* allocate the private part or the URB */
	urb_priv = kmalloc (sizeof (urb_priv_t) + size * sizeof (td_t *), 
							in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
	if (!urb_priv) {
		usb_dec_dev_use (urb->dev);	
		return -ENOMEM;
	}
	memset (urb_priv, 0, sizeof (urb_priv_t) + size * sizeof (td_t *));
	
	/* fill the private part of the URB */
	urb->hcpriv = urb_priv;
	urb_priv->length = size;
	urb_priv->td_cnt = 0;
	urb_priv->state = 0;
	urb_priv->ed = ed;	
	urb_priv->wait = NULL;
	
	/* allocate the TDs */
	for (i = 0; i < size; i++) { 
		OHCI_ALLOC (urb_priv->td[i], sizeof (td_t));
		if (!urb_priv->td[i]) {
			usb_dec_dev_use (urb->dev);	
			urb_rm_priv (urb);
			return -ENOMEM;
		}
	}	
	spin_lock_irqsave (&usb_ed_lock, flags);	
	if (ed->state == ED_NEW || (ed->state & ED_DEL)) {
		urb_rm_priv(urb);
		usb_dec_dev_use (urb->dev);	
		return -EINVAL;
	}
	
	/* for ISOC transfers calculate start frame index */
	if (urb->transfer_flags & USB_ISO_ASAP) { 
		urb->start_frame = ((ed->state == ED_OPER)? (ed->last_iso + 1): 
								(ohci->hcca.frame_no + 10)) & 0xffff;
	}	
	
	td_submit_urb (urb); /* fill the TDs and link it to the ed */
						
	if (ed->state != ED_OPER)  /* link the ed into a chain if is not already */
		ep_link (ohci, ed);
	spin_unlock_irqrestore (&usb_ed_lock, flags);
	
	urb->status = USB_ST_URB_PENDING; 
	// queue_urb(s, &urb->urb_list);

	return 0;	
}

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

/* deactivate all TDs and remove the private part of the URB */
 
static int sohci_unlink_urb (urb_t * urb)
{
	unsigned int flags;
	ohci_t * ohci;
	DECLARE_WAITQUEUE (wait, current);
	
	if (!urb) /* just to be sure */ 
		return -EINVAL;
		
#ifdef DEBUG
	urb_print (urb, "UNLINK", 1);
#endif		  

	ohci = (ohci_t *) urb->dev->bus->hcpriv; 

	if (usb_pipedevice (urb->pipe) == ohci->rh.devnum) 
		return rh_unlink_urb (urb); /* a request to the virtual root hub */
	
	if (urb->hcpriv) { 
		if (urb->status == USB_ST_URB_PENDING) { /* URB active? */
			urb_priv_t  * urb_priv = urb->hcpriv;
			urb_priv->state = URB_DEL; 
			/* we want to delete the TDs of an URB from an ed 
			 * request the deletion, it will be handled at the next USB-frame */
			urb_priv->wait = &wait;
			
			spin_lock_irqsave (&usb_ed_lock, flags);
			ep_rm_ed (urb->dev, urb_priv->ed);
			urb_priv->ed->state |= ED_URB_DEL;
			spin_unlock_irqrestore (&usb_ed_lock, flags);

			current->state = TASK_UNINTERRUPTIBLE;
			schedule_timeout (HZ / 10); /* wait until all TDs are deleted */
			remove_wait_queue (&op_wakeup, &wait); 
		} else 
			urb_rm_priv (urb);
		usb_dec_dev_use (urb->dev);		
	}	
	return 0;
}

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

/* allocate private data space for a usb device */

static int sohci_alloc_dev (struct usb_device *usb_dev)
{
	struct ohci_device * dev;

	dev = kmalloc (sizeof (*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;
		
	memset (dev, 0, sizeof (*dev));

	usb_dev->hcpriv = dev;

	return 0;
}

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

/* free private data space of usb device */
  
static int sohci_free_dev (struct usb_device * usb_dev)
{
	unsigned int flags;
	int i, cnt = 0;
	ed_t * ed;
	DECLARE_WAITQUEUE (wait, current);
	struct ohci_device * dev = usb_to_ohci (usb_dev);
	ohci_t * ohci = usb_dev->bus->hcpriv;
	
	if (!dev) return 0;
	
	if (usb_dev->devnum >= 0) {
	
		/* delete all TDs of all EDs */
		spin_lock_irqsave (&usb_ed_lock, flags);	
		for(i = 0; i < NUM_EDS; i++) {
  			ed = &(dev->ed[i]);
  			if (ed->state != ED_NEW) {
  				if (ed->state == ED_OPER) ep_unlink (ohci, ed);
  				ep_rm_ed (usb_dev, ed);
  				ed->state = ED_DEL;
  				cnt++;
  			}
  		}
  		spin_unlock_irqrestore (&usb_ed_lock, flags);
  		
    	if (cnt > 0) { 
    		dev->wait = &wait;
			current->state = TASK_UNINTERRUPTIBLE;
			schedule_timeout (HZ / 10);
			remove_wait_queue (&op_wakeup, &wait);
		}
	}
	kfree (dev);