Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 23d3e7a6 authored by Martin Fuzzey's avatar Martin Fuzzey Committed by Greg Kroah-Hartman
Browse files

USB: MXC: Add i.MX21 specific USB host controller driver. 



This driver is a Full / Low speed only USB host for the i.MX21.

Signed-off-by: default avatarMartin Fuzzey <mfuzzey@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 13dda80e

arch/arm/plat-mxc/include/mach/mx21-usbhost.h

0 → 100644
+38 −0
Original line number Diff line number Diff line 
/*

 *	Copyright (C) 2009 Martin Fuzzey <mfuzzey@gmail.com>

 *

 *	This program is free software; you can redistribute it and/or modify

 *	it under the terms of the GNU General Public License as published by

 *	the Free Software Foundation; either version 2 of the License, or

 *	(at your option) any later version.

 *

 *	This program 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 General Public License for more details.

 */



#ifndef __ASM_ARCH_MX21_USBH

#define __ASM_ARCH_MX21_USBH



enum mx21_usbh_xcvr {

	/* Values below as used by hardware (HWMODE register) */

	MX21_USBXCVR_TXDIF_RXDIF = 0,

	MX21_USBXCVR_TXDIF_RXSE = 1,

	MX21_USBXCVR_TXSE_RXDIF = 2,

	MX21_USBXCVR_TXSE_RXSE = 3,

};



struct mx21_usbh_platform_data {

	enum mx21_usbh_xcvr host_xcvr; /* tranceiver mode host 1,2 ports */

	enum mx21_usbh_xcvr otg_xcvr; /* tranceiver mode otg (as host) port */

	u16 	enable_host1:1,

		enable_host2:1,

		enable_otg_host:1, /* enable "OTG" port (as host) */

		host1_xcverless:1, /* traceiverless host1 port */

		host1_txenoe:1, /* output enable host1 transmit enable */

		otg_ext_xcvr:1, /* external tranceiver for OTG port */

		unused:10;

};



#endif /* __ASM_ARCH_MX21_USBH */

drivers/usb/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ obj-$(CONFIG_USB_U132_HCD) += host/ 
obj-$(CONFIG_USB_R8A66597_HCD)	+= host/

obj-$(CONFIG_USB_HWA_HCD)	+= host/

obj-$(CONFIG_USB_ISP1760_HCD)	+= host/

obj-$(CONFIG_USB_IMX21_HCD)	+= host/



obj-$(CONFIG_USB_C67X00_HCD)	+= c67x00/

drivers/usb/host/Kconfig

+11 −0
Original line number Diff line number Diff line
@@ -399,3 +399,14 @@ config USB_HWA_HCD 


	  To compile this driver a module, choose M here: the module

	  will be called "hwa-hc".



config USB_IMX21_HCD

       tristate "iMX21 HCD support"

       depends on USB && ARM && MACH_MX21

       help

         This driver enables support for the on-chip USB host in the

         iMX21 processor.



         To compile this driver as a module, choose M here: the

         module will be called "imx21-hcd".

drivers/usb/host/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -32,3 +32,5 @@ obj-$(CONFIG_USB_U132_HCD) += u132-hcd.o 
obj-$(CONFIG_USB_R8A66597_HCD)	+= r8a66597-hcd.o

obj-$(CONFIG_USB_ISP1760_HCD)	+= isp1760.o

obj-$(CONFIG_USB_HWA_HCD)	+= hwa-hc.o

obj-$(CONFIG_USB_IMX21_HCD)	+= imx21-hcd.o

drivers/usb/host/imx21-dbg.c

0 → 100644
+527 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2009 by Martin Fuzzey

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by the

 * Free Software Foundation; either version 2 of the License, or (at your

 * option) any later version.

 *

 * This program 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 General Public License

 * for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 */



/* this file is part of imx21-hcd.c */



#ifndef DEBUG



static inline void create_debug_files(struct imx21 *imx21) { }

static inline void remove_debug_files(struct imx21 *imx21) { }

static inline void debug_urb_submitted(struct imx21 *imx21, struct urb *urb) {}

static inline void debug_urb_completed(struct imx21 *imx21, struct urb *urb,

	int status) {}

static inline void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb) {}

static inline void debug_urb_queued_for_etd(struct imx21 *imx21,

	struct urb *urb) {}

static inline void debug_urb_queued_for_dmem(struct imx21 *imx21,

	struct urb *urb) {}

static inline void debug_etd_allocated(struct imx21 *imx21) {}

static inline void debug_etd_freed(struct imx21 *imx21) {}

static inline void debug_dmem_allocated(struct imx21 *imx21, int size) {}

static inline void debug_dmem_freed(struct imx21 *imx21, int size) {}

static inline void debug_isoc_submitted(struct imx21 *imx21,

	int frame, struct td *td) {}

static inline void debug_isoc_completed(struct imx21 *imx21,

	int frame, struct td *td, int cc, int len) {}



#else



#include <linux/debugfs.h>

#include <linux/seq_file.h>



static const char *dir_labels[] = {

	"TD 0",

	"OUT",

	"IN",

	"TD 1"

};



static const char *speed_labels[] = {

	"Full",

	"Low"

};



static const char *format_labels[] = {

	"Control",

	"ISO",

	"Bulk",

	"Interrupt"

};



static inline struct debug_stats *stats_for_urb(struct imx21 *imx21,

	struct urb *urb)

{

	return usb_pipeisoc(urb->pipe) ?

		&imx21->isoc_stats : &imx21->nonisoc_stats;

}



static void debug_urb_submitted(struct imx21 *imx21, struct urb *urb)

{

	stats_for_urb(imx21, urb)->submitted++;

}



static void debug_urb_completed(struct imx21 *imx21, struct urb *urb, int st)

{

	if (st)

		stats_for_urb(imx21, urb)->completed_failed++;

	else

		stats_for_urb(imx21, urb)->completed_ok++;

}



static void debug_urb_unlinked(struct imx21 *imx21, struct urb *urb)

{

	stats_for_urb(imx21, urb)->unlinked++;

}



static void debug_urb_queued_for_etd(struct imx21 *imx21, struct urb *urb)

{

	stats_for_urb(imx21, urb)->queue_etd++;

}



static void debug_urb_queued_for_dmem(struct imx21 *imx21, struct urb *urb)

{

	stats_for_urb(imx21, urb)->queue_dmem++;

}



static inline void debug_etd_allocated(struct imx21 *imx21)

{

	imx21->etd_usage.maximum = max(

			++(imx21->etd_usage.value),

			imx21->etd_usage.maximum);

}



static inline void debug_etd_freed(struct imx21 *imx21)

{

	imx21->etd_usage.value--;

}



static inline void debug_dmem_allocated(struct imx21 *imx21, int size)

{

	imx21->dmem_usage.value += size;

	imx21->dmem_usage.maximum = max(

			imx21->dmem_usage.value,

			imx21->dmem_usage.maximum);

}



static inline void debug_dmem_freed(struct imx21 *imx21, int size)

{

	imx21->dmem_usage.value -= size;

}





static void debug_isoc_submitted(struct imx21 *imx21,

	int frame, struct td *td)

{

	struct debug_isoc_trace *trace = &imx21->isoc_trace[

		imx21->isoc_trace_index++];



	imx21->isoc_trace_index %= ARRAY_SIZE(imx21->isoc_trace);

	trace->schedule_frame = td->frame;

	trace->submit_frame = frame;

	trace->request_len = td->len;

	trace->td = td;

}



static inline void debug_isoc_completed(struct imx21 *imx21,

	int frame, struct td *td, int cc, int len)

{

	struct debug_isoc_trace *trace, *trace_failed;

	int i;

	int found = 0;



	trace = imx21->isoc_trace;

	for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++) {

		if (trace->td == td) {

			trace->done_frame = frame;

			trace->done_len = len;

			trace->cc = cc;

			trace->td = NULL;

			found = 1;

			break;

		}

	}



	if (found && cc) {

		trace_failed = &imx21->isoc_trace_failed[

					imx21->isoc_trace_index_failed++];



		imx21->isoc_trace_index_failed %= ARRAY_SIZE(

						imx21->isoc_trace_failed);

		*trace_failed = *trace;

	}

}





static char *format_ep(struct usb_host_endpoint *ep, char *buf, int bufsize)

{

	if (ep)

		snprintf(buf, bufsize, "ep_%02x (type:%02X kaddr:%p)",

			ep->desc.bEndpointAddress,

			usb_endpoint_type(&ep->desc),

			ep);

	else

		snprintf(buf, bufsize, "none");

	return buf;

}



static char *format_etd_dword0(u32 value, char *buf, int bufsize)

{

	snprintf(buf, bufsize,

		"addr=%d ep=%d dir=%s speed=%s format=%s halted=%d",

		value & 0x7F,

		(value >> DW0_ENDPNT) & 0x0F,

		dir_labels[(value >> DW0_DIRECT) & 0x03],

		speed_labels[(value >> DW0_SPEED) & 0x01],

		format_labels[(value >> DW0_FORMAT) & 0x03],

		(value >> DW0_HALTED) & 0x01);

	return buf;

}



static int debug_status_show(struct seq_file *s, void *v)

{

	struct imx21 *imx21 = s->private;

	int etds_allocated = 0;

	int etds_sw_busy = 0;

	int etds_hw_busy = 0;

	int dmem_blocks = 0;

	int queued_for_etd = 0;

	int queued_for_dmem = 0;

	unsigned int dmem_bytes = 0;

	int i;

	struct etd_priv *etd;

	u32 etd_enable_mask;

	unsigned long flags;

	struct imx21_dmem_area *dmem;

	struct ep_priv *ep_priv;



	spin_lock_irqsave(&imx21->lock, flags);



	etd_enable_mask = readl(imx21->regs + USBH_ETDENSET);

	for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {

		if (etd->alloc)

			etds_allocated++;

		if (etd->urb)

			etds_sw_busy++;

		if (etd_enable_mask & (1<<i))

			etds_hw_busy++;

	}



	list_for_each_entry(dmem, &imx21->dmem_list, list) {

		dmem_bytes += dmem->size;

		dmem_blocks++;

	}



	list_for_each_entry(ep_priv, &imx21->queue_for_etd, queue)

		queued_for_etd++;



	list_for_each_entry(etd, &imx21->queue_for_dmem, queue)

		queued_for_dmem++;



	spin_unlock_irqrestore(&imx21->lock, flags);



	seq_printf(s,

		"Frame: %d\n"

		"ETDs allocated: %d/%d (max=%d)\n"

		"ETDs in use sw: %d\n"

		"ETDs in use hw: %d\n"

		"DMEM alocated: %d/%d (max=%d)\n"

		"DMEM blocks: %d\n"

		"Queued waiting for ETD: %d\n"

		"Queued waiting for DMEM: %d\n",

		readl(imx21->regs + USBH_FRMNUB) & 0xFFFF,

		etds_allocated, USB_NUM_ETD, imx21->etd_usage.maximum,

		etds_sw_busy,

		etds_hw_busy,

		dmem_bytes, DMEM_SIZE, imx21->dmem_usage.maximum,

		dmem_blocks,

		queued_for_etd,

		queued_for_dmem);



	return 0;

}



static int debug_dmem_show(struct seq_file *s, void *v)

{

	struct imx21 *imx21 = s->private;

	struct imx21_dmem_area *dmem;

	unsigned long flags;

	char ep_text[40];



	spin_lock_irqsave(&imx21->lock, flags);



	list_for_each_entry(dmem, &imx21->dmem_list, list)

		seq_printf(s,

			"%04X: size=0x%X "

			"ep=%s\n",

			dmem->offset, dmem->size,

			format_ep(dmem->ep, ep_text, sizeof(ep_text)));



	spin_unlock_irqrestore(&imx21->lock, flags);



	return 0;

}



static int debug_etd_show(struct seq_file *s, void *v)

{

	struct imx21 *imx21 = s->private;

	struct etd_priv *etd;

	char buf[60];

	u32 dword;

	int i, j;

	unsigned long flags;



	spin_lock_irqsave(&imx21->lock, flags);



	for (i = 0, etd = imx21->etd; i < USB_NUM_ETD; i++, etd++) {

		int state = -1;

		struct urb_priv *urb_priv;

		if (etd->urb) {

			urb_priv = etd->urb->hcpriv;

			if (urb_priv)

				state = urb_priv->state;

		}



		seq_printf(s,

			"etd_num: %d\n"

			"ep: %s\n"

			"alloc: %d\n"

			"len: %d\n"

			"busy sw: %d\n"

			"busy hw: %d\n"

			"urb state: %d\n"

			"current urb: %p\n",



			i,

			format_ep(etd->ep, buf, sizeof(buf)),

			etd->alloc,

			etd->len,

			etd->urb != NULL,

			(readl(imx21->regs + USBH_ETDENSET) & (1 << i)) > 0,

			state,

			etd->urb);



		for (j = 0; j < 4; j++) {

			dword = etd_readl(imx21, i, j);

			switch (j) {

			case 0:

				format_etd_dword0(dword, buf, sizeof(buf));

				break;

			case 2:

				snprintf(buf, sizeof(buf),

					"cc=0X%02X", dword >> DW2_COMPCODE);

				break;

			default:

				*buf = 0;

				break;

			}

			seq_printf(s,

				"dword %d: submitted=%08X cur=%08X [%s]\n",

				j,

				etd->submitted_dwords[j],

				dword,

				buf);

		}

		seq_printf(s, "\n");

	}



	spin_unlock_irqrestore(&imx21->lock, flags);



	return 0;

}



static void debug_statistics_show_one(struct seq_file *s,

	const char *name, struct debug_stats *stats)

{

	seq_printf(s, "%s:\n"

		"submitted URBs: %lu\n"

		"completed OK: %lu\n"

		"completed failed: %lu\n"

		"unlinked: %lu\n"

		"queued for ETD: %lu\n"

		"queued for DMEM: %lu\n\n",

		name,

		stats->submitted,

		stats->completed_ok,

		stats->completed_failed,

		stats->unlinked,

		stats->queue_etd,

		stats->queue_dmem);

}



static int debug_statistics_show(struct seq_file *s, void *v)

{

	struct imx21 *imx21 = s->private;

	unsigned long flags;



	spin_lock_irqsave(&imx21->lock, flags);



	debug_statistics_show_one(s, "nonisoc", &imx21->nonisoc_stats);

	debug_statistics_show_one(s, "isoc", &imx21->isoc_stats);

	seq_printf(s, "unblock kludge triggers: %lu\n", imx21->debug_unblocks);

	spin_unlock_irqrestore(&imx21->lock, flags);



	return 0;

}



static void debug_isoc_show_one(struct seq_file *s,

	const char *name, int index, 	struct debug_isoc_trace *trace)

{

	seq_printf(s, "%s %d:\n"

		"cc=0X%02X\n"

		"scheduled frame %d (%d)\n"

		"submittted frame %d (%d)\n"

		"completed frame %d (%d)\n"

		"requested length=%d\n"

		"completed length=%d\n\n",

		name, index,

		trace->cc,

		trace->schedule_frame, trace->schedule_frame & 0xFFFF,

		trace->submit_frame, trace->submit_frame & 0xFFFF,

		trace->done_frame, trace->done_frame & 0xFFFF,

		trace->request_len,

		trace->done_len);

}



static int debug_isoc_show(struct seq_file *s, void *v)

{

	struct imx21 *imx21 = s->private;

	struct debug_isoc_trace *trace;

	unsigned long flags;

	int i;



	spin_lock_irqsave(&imx21->lock, flags);



	trace = imx21->isoc_trace_failed;

	for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace_failed); i++, trace++)

		debug_isoc_show_one(s, "isoc failed", i, trace);



	trace = imx21->isoc_trace;

	for (i = 0; i < ARRAY_SIZE(imx21->isoc_trace); i++, trace++)

		debug_isoc_show_one(s, "isoc", i, trace);



	spin_unlock_irqrestore(&imx21->lock, flags);



	return 0;

}



static int debug_status_open(struct inode *inode, struct file *file)

{

	return single_open(file, debug_status_show, inode->i_private);

}



static int debug_dmem_open(struct inode *inode, struct file *file)

{

	return single_open(file, debug_dmem_show, inode->i_private);

}



static int debug_etd_open(struct inode *inode, struct file *file)

{

	return single_open(file, debug_etd_show, inode->i_private);

}



static int debug_statistics_open(struct inode *inode, struct file *file)

{

	return single_open(file, debug_statistics_show, inode->i_private);

}



static int debug_isoc_open(struct inode *inode, struct file *file)

{

	return single_open(file, debug_isoc_show, inode->i_private);

}



static const struct file_operations debug_status_fops = {

	.open = debug_status_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static const struct file_operations debug_dmem_fops = {

	.open = debug_dmem_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static const struct file_operations debug_etd_fops = {

	.open = debug_etd_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static const struct file_operations debug_statistics_fops = {

	.open = debug_statistics_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static const struct file_operations debug_isoc_fops = {

	.open = debug_isoc_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static void create_debug_files(struct imx21 *imx21)

{

	imx21->debug_root = debugfs_create_dir(dev_name(imx21->dev), NULL);

	if (!imx21->debug_root)

		goto failed_create_rootdir;



	if (!debugfs_create_file("status", S_IRUGO,

			imx21->debug_root, imx21, &debug_status_fops))

		goto failed_create;



	if (!debugfs_create_file("dmem", S_IRUGO,

			imx21->debug_root, imx21, &debug_dmem_fops))

		goto failed_create;



	if (!debugfs_create_file("etd", S_IRUGO,

			imx21->debug_root, imx21, &debug_etd_fops))

		goto failed_create;



	if (!debugfs_create_file("statistics", S_IRUGO,

			imx21->debug_root, imx21, &debug_statistics_fops))

		goto failed_create;



	if (!debugfs_create_file("isoc", S_IRUGO,

			imx21->debug_root, imx21, &debug_isoc_fops))

		goto failed_create;



	return;



failed_create:

	debugfs_remove_recursive(imx21->debug_root);



failed_create_rootdir:

	imx21->debug_root = NULL;

}





static void remove_debug_files(struct imx21 *imx21)

{

	if (imx21->debug_root) {

		debugfs_remove_recursive(imx21->debug_root);

		imx21->debug_root = NULL;

	}

}



#endif