sl11.c

Linux2.4.20针对三星公司的s3c2440内核基础上的一些设备驱动代码

	}
}


/**
* udc_endpoint_halted - is endpoint halted
* @ep:
*
* Return non-zero if endpoint is halted
 */
int udc_endpoint_halted (unsigned int ep)
{
	return 0;
}


/**
 * udc_set_address - set the USB address for this device
 * @address:
 *
 * Called from control endpoint function after it decodes a set address setup packet.
 */
void udc_set_address (unsigned char address)
{
	// address cannot be setup until ack received
	usb_address = address;
}

/**
 * udc_serial_init - set a serial number if available
 */
static int __init udc_serial_init (struct usb_bus_instance *bus)
{
	return -EINVAL;
}

/* ********************************************************************************************* */

/**
 * udc_max_endpoints - max physical endpoints 
 *
 * Return number of physical endpoints.
 */
int udc_max_endpoints (void)
{
	return UDC_MAX_ENDPOINTS;
}


/**
 * udc_check_ep - check logical endpoint 
 * @lep:
 *
 * Return physical endpoint number to use for this logical endpoint or zero if not valid.
 */
int udc_check_ep (int logical_endpoint, int packetsize)
{

	return (((logical_endpoint & 0xf) >= UDC_MAX_ENDPOINTS) || (packetsize > 64)) ?
	    0 : (logical_endpoint & 0xf);
}


/**
 * udc_set_ep - setup endpoint 
 * @ep:
 * @endpoint:
 *
 * Associate a physical endpoint with endpoint_instance
 */
void udc_setup_ep (struct usb_device_instance *device, unsigned int ep,
		   struct usb_endpoint_instance *endpoint)
{
	if (ep < UDC_MAX_ENDPOINTS) {

		ep_endpoints[ep] = endpoint;

		sl11write_epn (ep, EPN_Control, 0);
		sl11write_epn (ep, EPN_XferLen, 0);
		sl11write_epn (ep, EPN_Status, 0);
		sl11write_epn (ep, EPN_Counter, 0);

		ep_address[ep] = EP_S_BUF;
		ep_address[ep * 2] = EP_S_BUF;

		// ep0
		if (ep == 0) {
			sl11write_epn (ep, EPN_Address, EP_S_BUF);
			sl11write_epn (ep, EPN_Control,
				       EPN_CTRL_ARM | EPN_CTRL_ENABLE | EPN_CTRL_DIRECTION_OUT);
			sl11write_epn (ep, EPN_XferLen, endpoint->rcv_packetSize);
			sl11write_epn (ep, EPN_Status, 0);
			sl11write_epn (ep, EPN_Counter, 0);
		}
		// IN
		else if (endpoint->endpoint_address & 0x80) {
			sl11write_epn (ep, EPN_Address, EP_S_BUF);
			sl11write_epn (ep, EPN_Control,
				       EPN_CTRL_ARM | EPN_CTRL_ENABLE | EPN_CTRL_DIRECTION_IN);
		}
		// OUT
		else if (endpoint->endpoint_address) {
			usbd_fill_rcv (device, endpoint, 5);
			endpoint->rcv_urb = first_urb_detached (&endpoint->rdy);

			ep_sequence[ep] = 0;

			sl11write_epn (ep + 0, EPN_Address, EP_A_BUF);
			sl11write_epn (ep + 4, EPN_Address, EP_B_BUF);

			ep_address[ep + 0] = EP_A_BUF;
			ep_address[ep + 4] = EP_B_BUF;

			sl11write_epn (ep + 0, EPN_XferLen, endpoint->rcv_packetSize);
			sl11write_epn (ep + 4, EPN_XferLen, endpoint->rcv_packetSize);

			sl11write_epn (ep + 0, EPN_Control,
				       EPN_CTRL_ARM | EPN_CTRL_ENABLE | EPN_CTRL_DIRECTION_OUT);
			sl11write_epn (ep + 0, EPN_Control,
				       EPN_CTRL_ARM | EPN_CTRL_ENABLE | EPN_CTRL_DIRECTION_OUT |
				       EPN_CTRL_NEXTDATA);

			sl11write_epn (ep + 4, EPN_Control,
				       EPN_CTRL_ARM | EPN_CTRL_ENABLE | EPN_CTRL_DIRECTION_OUT);

			printk (KERN_DEBUG "udc_setup_ep[%d]: setup OUT\n", ep);
			sl11_dump_epn (ep + 0, " ");
			sl11_dump_epn (ep + 4, "\n");
		}
	}
	//sl11_dump(0, 64);
}

/**
 * udc_disable_ep - disable endpoint
 * @ep:
 *
 * Disable specified endpoint 
 */
void udc_disable_ep (unsigned int ep)
{
#if 0
	if (ep < UDC_MAX_ENDPOINTS) {
		struct usb_endpoint_instance *endpoint;

		if ((endpoint = ep_endpoints[ep])) {
			ep_endpoints[ep] = NULL;
			usbd_flush_ep (endpoint);
		}
	}
#endif
}

/* ********************************************************************************************* */

/**
 * udc_connected - is the USB cable connected
 *
 * Return non-zeron if cable is connected.
 */
int udc_connected (void)
{
	return 1;
}


/**
 * udc_connect - enable pullup resistor
 *
 * Turn on the USB connection by enabling the pullup resistor.
 */
void udc_connect (void)
{
	// enable UDC
	sl11write_byte (CtrlReg, CTRL_USB_ENABLE);
}


/**
 * udc_disconnect - disable pullup resistor
 *
 * Turn off the USB connection by disabling the pullup resistor.
 */
void udc_disconnect (void)
{
	// disable UDC
	sl11write_byte (CtrlReg, 0);
}

/* ********************************************************************************************* */

/**
 * udc_enable_interrupts - enable interrupts
 *
 * Switch on UDC interrupts.
 *
 */
void udc_all_interrupts (struct usb_device_instance *device)
{
	printk (KERN_DEBUG "udc_enable_interrupts:\n");

	// set interrupt mask
	sl11write_byte (IntEna,
			INT_EP0_DONE | INT_EP1_DONE | INT_EP2_DONE | INT_EP3_DONE |
			INT_SOF_RECEIVED /*| INT_USB_RESET */ );

}


/**
 * udc_suspended_interrupts - enable suspended interrupts
 *
 * Switch on only UDC resume interrupt.
 *
 */
void udc_suspended_interrupts (struct usb_device_instance *device)
{
	printk (KERN_DEBUG "udc_enable_interrupts:\n");

	// set interrupt mask
	sl11write_byte (IntEna, INT_SOF_RECEIVED | INT_USB_RESET);

}


/**
 * udc_disable_interrupts - disable interrupts.
 *
 * switch off interrupts
 */
void udc_disable_interrupts (struct usb_device_instance *device)
{

	printk (KERN_DEBUG "udc_disable_interrupts:\n");

	// reset interrupt mask
	sl11write_byte (IntEna, 0);
}

/* ********************************************************************************************* */

/**
 * udc_ep0_packetsize - return ep0 packetsize
 */
int udc_ep0_packetsize (void)
{
	return EP0_PACKETSIZE;
}

/**
 * udc_enable - enable the UDC
 *
 * Switch on the UDC
 */
void udc_enable (struct usb_device_instance *device)
{

	printk (KERN_DEBUG "\n");
	printk (KERN_DEBUG "udc_enable: device: %p\n", device);

	// save the device structure pointer
	udc_device = device;

	// ep0 urb
	if (!ep0_urb) {
		if (!(ep0_urb = usbd_alloc_urb (device, device->function_instance_array, 0, 512))) {
			printk (KERN_ERR "udc_enable: usbd_alloc_urb failed\n");
		}
	} else {
		printk (KERN_ERR "udc_enable: ep0_urb already allocated\n");
	}

	//ep0_urb->device = device;
	//usbd_alloc_urb_data(&ep0_urb, 512);

	// enable UDC
	// sl11write_byte(CtrlReg, CTRL_USB_ENABLE);

	// setup tick
	// XXX sl11_tq.sync = 0;
	sl11_tq.routine = sl11_tick;
	sl11_tq.data = &udc_saw_sof;
	queue_task (&sl11_tq, &tq_timer);

	udc_suspended = 1;
}


/**
 * udc_disable - disable the UDC
 *
 * Switch off the UDC
 */
void udc_disable (void)
{
	printk (KERN_DEBUG "************************* udc_disable:\n");

	// tell tick task to stop
	sl11_tq.data = NULL;
	while (sl11_tq.sync) {
		printk (KERN_DEBUG "waiting for sl11_tq to stop\n");
		schedule_timeout (10 * HZ);
	}

	// XXX del_timer() or wait 

	// disable UDC
	// sl11write_byte(CtrlReg, 0);

	// reset device pointer
	udc_device = NULL;

	// ep0 urb
	//kfree(ep0_urb.buffer);

	if (ep0_urb) {
		usbd_dealloc_urb (ep0_urb);
		ep0_urb = 0;
	} else {
		printk (KERN_ERR "udc_disable: ep0_urb already NULL\n");
	}

}


/**
 * udc_startup - allow udc code to do any additional startup
 */
void udc_startup_events (struct usb_device_instance *device)
{
	usbd_device_event (device, DEVICE_INIT, 0);
	usbd_device_event (device, DEVICE_CREATE, 0);
	usbd_device_event (device, DEVICE_HUB_CONFIGURED, 0);
	usbd_device_event (device, DEVICE_RESET, 0);	// XXX should be done from device event
}


/* ********************************************************************************************* */

/**
 * udc_init - initialize USB Device Controller
 * 
 * Get ready to use the USB Device Controller.
 *
 * Register an interrupt handler and IO region. Return non-zero for error.
 */
int udc_init (void)
{
	printk (KERN_DEBUG "udc_init:\n");

	// probe for Sl11
	return sl11_probe ();
}


/**
 * udc_regs - dump registers
 *
 * Dump registers with printk
 */
void udc_regs (void)
{
	sl11_dump_epn (0, " ");

	printk (" Ctrl: %02x Addr: %02x IntE: %02x IntS: %02x Data: %02x SOF: %02x %02x Sus: %d\n",
		sl11read_byte (CtrlReg), sl11read_byte (USBAdd), sl11read_byte (IntEna),
		sl11read_byte (IntStatus), sl11read_byte (DATASet),
		sl11read_byte (SOFHigh), sl11read_byte (SOFLow), udc_suspended);

	sl11_dump_epn (1, " ");
	sl11_dump_epn (5, "\n");

	sl11_dump_epn (2, " ");
	sl11_dump_epn (3, "\n");
}

/* ********************************************************************************************* */

/**
 * udc_name - return name of USB Device Controller
 */
char *udc_name (void)
{
	return UDC_NAME;
}

/**
 * udc_request_udc_irq - request UDC interrupt
 *
 * Return non-zero if not successful.
 */
int udc_request_udc_irq ()
{
	// request IRQ  and IO region
	if (request_irq (UDC_IRQ, sl11_int_hndlr, SA_INTERRUPT | SA_SAMPLE_RANDOM, UDC_NAME, NULL)
	    != 0) {
		printk (KERN_DEBUG "usb_ctl: Couldn't request USB irq\n");
		return -EINVAL;
	}
	return 0;
}

/**
 * udc_request_cable_irq - request Cable interrupt
 *
 * Return non-zero if not successful.
 */
int udc_request_cable_irq ()
{
	return 0;
}

/**
 * udc_request_udc_io - request UDC io region
 *
 * Return non-zero if not successful.
 */
int udc_request_io ()
{
	int rc = 0;
#ifdef CONFIG_X86
	// reserve io
	{
		unsigned long flags;
		local_irq_save (flags);
		if (check_region (UDC_ADDR, UDC_ADDR_SIZE)) {
			printk (KERN_DEBUG "udc_request_io: failed %x %x\n", UDC_ADDR,
				UDC_ADDR_SIZE);
			rc = -EINVAL;
		}
		request_region (UDC_ADDR, UDC_ADDR_SIZE, UDC_NAME);
		local_irq_restore (flags);
	}
#endif
	return rc;
}

/**
 * udc_release_udc_irq - release UDC irq
 */
void udc_release_udc_irq ()
{
	free_irq (UDC_IRQ, NULL);
}

/**
 * udc_release_cable_irq - release Cable irq
 */
void udc_release_cable_irq ()
{
}

/**
 * udc_release_io - release UDC io region
 */
void udc_release_io ()
{
#ifdef CONFIG_X86
	release_region (UDC_ADDR, UDC_ADDR_SIZE);
#endif
}