s3c2410_udc.c

ARM S3C2410 USB SLAVE LINUX驱动

	/* kickstart this i/o queue? */
	if (list_empty(&ep->queue)) {
		if (ep->bEndpointAddress == 0 /* ep0 */) {
			switch (dev->ep0state) {
			case EP0_IN_DATA_PHASE:
				if (write_fifo(ep, req)) {
					dev->ep0state = EP0_IDLE;
					req = NULL;
				}
				break;

			case EP0_OUT_DATA_PHASE:
				if (read_fifo(ep,req)) {
					dev->ep0state = EP0_IDLE;
					req = NULL;
				}
				break;

			default:
				spin_unlock_irqrestore(&dev->lock,flags);
				return -EL2HLT;
			}
		}
		else if ((ep->bEndpointAddress & USB_DIR_IN) != 0
				&& (!(ep_csr&S3C2410_UDC_OCSR1_PKTRDY)) && write_fifo(ep, req)) {
			req = NULL;
			msleep(1);
		} else if ((ep_csr & S3C2410_UDC_OCSR1_PKTRDY) && fifo_count && read_fifo(ep, req)) {
			req = NULL;
			msleep(1);
		}

	}

	/* pio or dma irq handler advances the queue. */
	if (likely (req != 0))
		list_add_tail(&req->queue, &ep->queue);

	spin_unlock_irqrestore(&dev->lock,flags);

	dprintk(DEBUG_VERBOSE, "s3c2410_queue normal end\n");
	return 0;
}

/*
 * 	s3c2410_dequeue
 */
static int s3c2410_dequeue (struct usb_ep *_ep, struct usb_request *_req)
{
	struct s3c2410_ep	*ep;
	struct s3c2410_udc	*udc;
	int			retval = -EINVAL;
	unsigned long		flags;
	struct s3c2410_request	*req = NULL;

    	dprintk(DEBUG_VERBOSE,"s3c2410_dequeue(ep=%p,req=%p)\n", _ep, _req);

	if (!the_controller->driver)
		return -ESHUTDOWN;

	if (!_ep || !_req)
		return retval;
	ep = container_of (_ep, struct s3c2410_ep, ep);
	udc = container_of (ep->gadget, struct s3c2410_udc, gadget);

	spin_lock_irqsave (&udc->lock, flags);
	list_for_each_entry (req, &ep->queue, queue) {
		if (&req->req == _req) {
			list_del_init (&req->queue);
			_req->status = -ECONNRESET;
			retval = 0;
			break;
		}
	}
	spin_unlock_irqrestore (&udc->lock, flags);

	if (retval == 0) {
		dprintk(DEBUG_VERBOSE, "dequeued req %p from %s, len %d buf %p\n",
				req, _ep->name, _req->length, _req->buf);

		_req->complete (_ep, _req);
		done(ep, req, -ECONNRESET);
	}
	return retval;
}


/*
 * s3c2410_set_halt
 */
static int
s3c2410_set_halt (struct usb_ep *_ep, int value)
{
	return 0;
}


static const struct usb_ep_ops s3c2410_ep_ops = {
	.enable         = s3c2410_ep_enable,
	.disable        = s3c2410_ep_disable,

	.alloc_request  = s3c2410_alloc_request,
	.free_request   = s3c2410_free_request,

	.alloc_buffer   = s3c2410_alloc_buffer,
	.free_buffer    = s3c2410_free_buffer,

	.queue          = s3c2410_queue,
	.dequeue        = s3c2410_dequeue,

	.set_halt       = s3c2410_set_halt,
};

/*------------------------- usb_gadget_ops ----------------------------------*/

/*
 * 	s3c2410_g_get_frame
 */
static int s3c2410_g_get_frame (struct usb_gadget *_gadget)
{
	int tmp;

	dprintk(DEBUG_VERBOSE,"s3c2410_g_get_frame()\n");

	tmp = udc_readl(S3C2410_UDC_FRAME_NUM2_REG) << 8;
	tmp |= udc_readl(S3C2410_UDC_FRAME_NUM1_REG);

	return tmp & 0xffff;
}

/*
 * 	s3c2410_wakeup
 */
static int s3c2410_wakeup (struct usb_gadget *_gadget)
{

	dprintk(DEBUG_NORMAL,"s3c2410_wakeup()\n");

	return 0;
}

/*
 * 	s3c2410_set_selfpowered
 */
static int s3c2410_set_selfpowered (struct usb_gadget *_gadget, int value)
{
	struct s3c2410_udc  *udc;

	dprintk(DEBUG_NORMAL, "s3c2410_set_selfpowered()\n");

	udc = container_of (_gadget, struct s3c2410_udc, gadget);

	if (value)
		udc->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
	else
		udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);

	return 0;
}



static const struct usb_gadget_ops s3c2410_ops = {
	.get_frame          = s3c2410_g_get_frame,
	.wakeup             = s3c2410_wakeup,
	.set_selfpowered    = s3c2410_set_selfpowered,
};


/*------------------------- gadget driver handling---------------------------*/
/*
 * udc_disable
 */
static void udc_disable(struct s3c2410_udc *dev)
{
	dprintk(DEBUG_NORMAL, "udc_disable called\n");

	/* Disable all interrupts */
	udc_writel(0x00, S3C2410_UDC_USB_INT_EN_REG);
	udc_writel(0x00, S3C2410_UDC_EP_INT_EN_REG);

	/* Clear the interrupt registers */
	udc_writel(   S3C2410_UDC_USBINT_RESET  | \
			S3C2410_UDC_USBINT_RESUME | \
			S3C2410_UDC_USBINT_SUSPEND, \
			S3C2410_UDC_USB_INT_REG);
	udc_writel(   0x1F, S3C2410_UDC_EP_INT_REG);
	

	/* Good bye, cruel world */
	if (udc_info && udc_info->udc_command)
		udc_info->udc_command(S3C2410_UDC_P_DISABLE);

	/* Set address to 0 */
	/*udc_writel( 0x80, S3C2410_UDC_FUNC_ADDR_REG);*/

	/* Set speed to unknown */
	dev->gadget.speed = USB_SPEED_UNKNOWN;
}
/*
 * udc_reinit
 */
static void udc_reinit(struct s3c2410_udc *dev)
{
	u32     i;

	/* device/ep0 records init */
	INIT_LIST_HEAD (&dev->gadget.ep_list);
	INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
	dev->ep0state = EP0_IDLE;


	for (i = 0; i < S3C2410_ENDPOINTS; i++) {
		struct s3c2410_ep *ep = &dev->ep[i];

		if (i != 0)
			list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);

		ep->dev = dev;
		ep->desc = NULL;
		INIT_LIST_HEAD (&ep->queue);
	}
}

/*
 * udc_enable
 */
static void udc_enable(struct s3c2410_udc *dev)
{
	int i;

	dprintk(DEBUG_NORMAL, "udc_enable called\n");

	/* dev->gadget.speed = USB_SPEED_UNKNOWN; */
	dev->gadget.speed = USB_SPEED_FULL;

	/* Set MAXP for all endpoints */
	for (i = 0; i < S3C2410_ENDPOINTS; i++) {

		udc_writel(i, S3C2410_UDC_INDEX_REG);
		udc_writel((dev->ep[i].ep.maxpacket&0x7ff)>>3,S3C2410_UDC_MAXP_REG);
	}

	/* Set default power state */
	udc_writel(DEFAULT_POWER_STATE, S3C2410_UDC_PWR_REG);

	/* Enable reset and suspend interrupt interrupts */
	udc_writel(1<<2 | 1<<0 ,S3C2410_UDC_USB_INT_EN_REG);

	/* Enable ep0 interrupt */
	udc_writel(0x01,S3C2410_UDC_EP_INT_EN_REG);

	/* time to say "hello, world" */
	if (udc_info && udc_info->udc_command)
		udc_info->udc_command(S3C2410_UDC_P_ENABLE);
}


/*
 * 	nop_release
 */
static void nop_release (struct device *dev)
{
	        dprintk(DEBUG_NORMAL, "%s %s\n", __FUNCTION__, dev->bus_id);
}
/*
 *	usb_gadget_register_driver
 */
int
usb_gadget_register_driver (struct usb_gadget_driver *driver)
{
	struct s3c2410_udc *udc = the_controller;
	int		retval;

    	dprintk(DEBUG_NORMAL, "usb_gadget_register_driver() '%s'\n",
		driver->driver.name);

	/* Sanity checks */
	if (!udc)
		return -ENODEV;
	if (udc->driver)
		return -EBUSY;
	if (!driver->bind || !driver->unbind || !driver->setup
			|| driver->speed == USB_SPEED_UNKNOWN)
		return -EINVAL;

	/* Hook the driver */
	udc->driver = driver;
	udc->gadget.dev.driver = &driver->driver;

	/*Bind the driver */
	device_add(&udc->gadget.dev);
	dprintk(DEBUG_NORMAL, "binding gadget driver '%s'\n", driver->driver.name);
	if ((retval = driver->bind (&udc->gadget)) != 0) {
		device_del(&udc->gadget.dev);
		udc->driver = NULL;
		udc->gadget.dev.driver = NULL;
		return retval;
	}

        /* driver->driver.bus = 0; */

	/* Enable udc */
	udc_enable(udc);

	return 0;
}


/*
 * 	usb_gadget_unregister_driver
 */
int
usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
{

	struct s3c2410_udc *udc = the_controller;

	if (!udc)
		return -ENODEV;
	if (!driver || driver != udc->driver)
		return -EINVAL;

   dprintk(DEBUG_NORMAL,"usb_gadget_register_driver() '%s'\n",
		driver->driver.name);


	if (driver->disconnect)
		driver->disconnect(&udc->gadget);

	if (driver->unbind)
		driver->unbind (&udc->gadget);

	device_del(&udc->gadget.dev);
	udc->driver = NULL;

	// Disable udc
	udc_disable(udc);

	return 0;
}
/*---------------------------------------------------------------------------*/
static struct s3c2410_udc memory = {
	.gadget = {
		.ops		= &s3c2410_ops,
		.ep0		= &memory.ep[0].ep,
		.name		= gadget_name,
		.dev = {
			.bus_id		= "gadget",
			.release	= nop_release,
		},
	},

	/* control endpoint */
	.ep[0] = {
		.num		= 0,
		.ep = {
			.name		= ep0name,
			.ops		= &s3c2410_ep_ops,
			.maxpacket	= EP0_FIFO_SIZE,
		},
		.dev		= &memory,
	},

	/* first group of endpoints */
	.ep[1] = {
		.num		= 1,
		.ep = {
			.name		= "ep1-bulk",
			.ops		= &s3c2410_ep_ops,
			.maxpacket	= EP_FIFO_SIZE,
		},
		.dev		= &memory,
		.fifo_size	= EP_FIFO_SIZE,
		.bEndpointAddress = 1,
		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
	},
	.ep[2] = {
		.num		= 2,
		.ep = {
			.name		= "ep2-bulk",
			.ops		= &s3c2410_ep_ops,
			.maxpacket	= EP_FIFO_SIZE,
		},
		.dev		= &memory,
		.fifo_size	= EP_FIFO_SIZE,
		.bEndpointAddress = 2,
		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
	},
	.ep[3] = {
		.num		= 3,
		.ep = {
			.name		= "ep3-bulk",
			.ops		= &s3c2410_ep_ops,
			.maxpacket	= EP_FIFO_SIZE,
		},
		.dev		= &memory,
		.fifo_size	= EP_FIFO_SIZE,
		.bEndpointAddress = 3,
		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
	},
	.ep[4] = {
		.num		= 4,
		.ep = {
			.name		= "ep4-bulk",
			.ops		= &s3c2410_ep_ops,
			.maxpacket	= EP_FIFO_SIZE,
		},
		.dev		= &memory,
		.fifo_size	= EP_FIFO_SIZE,
		.bEndpointAddress = 4,
		.bmAttributes	= USB_ENDPOINT_XFER_BULK,
	}

};

/*
 *	probe - binds to the platform device
 */
static int s3c2410_udc_probe(struct device *_dev)
{
	struct s3c2410_udc *udc = &memory;
	int retval;

	dprintk(DEBUG_NORMAL,"s3c2410_udc_probe\n");

	udc_clock = clk_get(NULL, "usb-device");
	if (IS_ERR(udc_clock)) {
		printk(KERN_INFO "failed to get udc clock source\n");
		return PTR_ERR(udc_clock);
	}

	clk_use(udc_clock);
	clk_enable(udc_clock);

	mdelay(10);

	dprintk(DEBUG_VERBOSE, "got and enabled clock\n");

	if (strncmp(to_platform_device(_dev)->name, "s3c2440", 7) == 0) {
		printk("Detected S3C2440 - increasing FIFO to 128 bytes\n");
		memory.ep[1].fifo_size = S3C2440_EP_FIFO_SIZE;
		memory.ep[2].fifo_size = S3C2440_EP_FIFO_SIZE;
		memory.ep[3].fifo_size = S3C2440_EP_FIFO_SIZE;
		memory.ep[4].fifo_size = S3C2440_EP_FIFO_SIZE;
	}

	spin_lock_init (&udc->lock);
	udc_info = _dev->platform_data;

	rsrc_start = S3C2410_PA_USBDEV;
	rsrc_len   = S3C24XX_SZ_USBDEV;

	if (!request_mem_region(rsrc_start, rsrc_len, gadget_name))
		return -EBUSY;

	base_addr = ioremap(rsrc_start, rsrc_len);
	if (!base_addr) {
		retval = -ENOMEM;
		goto err_mem;
	}
	
	device_initialize(&udc->gadget.dev);
	udc->gadget.dev.parent = _dev;
	udc->gadget.dev.dma_mask = _dev->dma_mask;

	the_controller = udc;
	dev_set_drvdata(_dev, udc);

	udc_disable(udc);
	udc_reinit(udc);

	/* irq setup after old hardware state is cleaned up */
	retval = request_irq(IRQ_USBD, s3c2410_udc_irq,
		SA_INTERRUPT, gadget_name, udc);

	if (retval != 0) {
		printk(KERN_ERR "%s: can't get irq %i, err %d\n",
			gadget_name, IRQ_USBD, retval);
		retval = -EBUSY;
		goto err_map;
	}
	dprintk(DEBUG_VERBOSE, "%s: got irq %i\n", gadget_name, IRQ_USBD);

#ifdef ENABLE_SYSFS
	/* create device files */
	device_create_file(_dev, &dev_attr_regs);
#endif
	return 0;

err_map:
	iounmap(base_addr);
err_mem:
	release_mem_region(rsrc_start, rsrc_len);

	return retval;
}

/*
 * 	s3c2410_udc_remove
 */
static int s3c2410_udc_remove(struct device *_dev)
{
	struct s3c2410_udc *udc = _dev->driver_data;

	dprintk(DEBUG_NORMAL, "s3c2410_udc_remove\n");
	usb_gadget_unregister_driver(udc->driver);

	if (udc->got_irq) {
		free_irq(IRQ_USBD, udc);
		udc->got_irq = 0;
	}

	iounmap(base_addr);
	release_mem_region(rsrc_start, rsrc_len);
	
	dev_set_drvdata(_dev, NULL);
//	kfree(udc);

	if (!IS_ERR(udc_clock) && udc_clock != NULL) {
		clk_disable(udc_clock);
		clk_unuse(udc_clock);
		clk_put(udc_clock);
		udc_clock = NULL;
	}

	return 0;
}

static struct device_driver udc_driver_2410 = {
	.name		= "s3c2410-usbgadget",
	.owner		= THIS_MODULE,
	.bus            = &platform_bus_type,
	.probe          = s3c2410_udc_probe,
	.remove         = s3c2410_udc_remove,
};

static struct device_driver udc_driver_2440 = {
	.name		= "s3c2440-usbgadget",
	.owner		= THIS_MODULE,
	.bus            = &platform_bus_type,
	.probe          = s3c2410_udc_probe,
	.remove         = s3c2410_udc_remove,
};

static int __init udc_init(void)
{
	int retval;

	dprintk(DEBUG_NORMAL, "%s: version %s\n", gadget_name, DRIVER_VERSION);


	udc_clock = clk_get(NULL, "usb-device");
	if (!udc_clock) {
		printk(KERN_INFO "failed to get udc clock source\n");
		return -ENOENT;
	}
	clk_use(udc_clock);

	clk_enable(udc_clock);

	mdelay(10);

	dprintk(DEBUG_VERBOSE, "got and enabled clock\n");

	retval = driver_register(&udc_driver_2410);
	if (retval)
		return retval;

	return driver_register(&udc_driver_2440);
}

static void __exit udc_exit(void)
{
	if (udc_clock) {
		clk_disable(udc_clock);
		clk_unuse(udc_clock);
		clk_put(udc_clock);
		udc_clock = NULL;
	}

	driver_unregister(&udc_driver_2410);
	driver_unregister(&udc_driver_2440);
}


EXPORT_SYMBOL (usb_gadget_unregister_driver);
EXPORT_SYMBOL (usb_gadget_register_driver);

module_init(udc_init);
module_exit(udc_exit);

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