/*
- * OHCI HCD (Host Controller Driver) for USB.
+ * ADM5120 HCD (Host Controller Driver) for USB
*
- * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
- * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
+ * Copyright (C) 2007,2008 Gabor Juhos <juhosg at openwrt.org>
*
- * [ Initialisation is based on Linus' ]
- * [ uhci code and gregs ahcd fragments ]
- * [ (C) Copyright 1999 Linus Torvalds ]
- * [ (C) Copyright 1999 Gregory P. Smith]
+ * This file was derived from: drivers/usb/host/ohci-hcd.c
+ * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
+ * (C) Copyright 2000-2004 David Brownell <dbrownell@users.sourceforge.net>
*
+ * [ Initialisation is based on Linus' ]
+ * [ uhci code and gregs ahcd fragments ]
+ * [ (C) Copyright 1999 Linus Torvalds ]
+ * [ (C) Copyright 1999 Gregory P. Smith]
*
- * OHCI is the main "non-Intel/VIA" standard for USB 1.1 host controller
- * interfaces (though some non-x86 Intel chips use it). It supports
- * smarter hardware than UHCI. A download link for the spec available
- * through the http://www.usb.org website.
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
*
- * This file is licenced under the GPL.
*/
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <linux/dmapool.h>
#include <linux/reboot.h>
+#include <linux/debugfs.h>
#include <asm/io.h>
#include <asm/irq.h>
#include "../core/hcd.h"
#include "../core/hub.h"
-#define DRIVER_VERSION "v0.10.1"
+#define DRIVER_VERSION "0.25.0"
#define DRIVER_AUTHOR "Gabor Juhos <juhosg at openwrt.org>"
#define DRIVER_DESC "ADMtek USB 1.1 Host Controller Driver"
/*
* queue up an urb for anything except the root hub
*/
-static int admhc_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *ep,
- struct urb *urb, gfp_t mem_flags)
+static int admhc_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
+ gfp_t mem_flags)
{
struct admhcd *ahcd = hcd_to_admhcd(hcd);
struct ed *ed;
#ifdef ADMHC_VERBOSE_DEBUG
spin_lock_irqsave(&ahcd->lock, flags);
- urb_print(ahcd, urb, "ENQEUE", usb_pipein(pipe));
+ urb_print(ahcd, urb, "ENQEUE", usb_pipein(pipe), -EINPROGRESS);
spin_unlock_irqrestore(&ahcd->lock, flags);
#endif
/* every endpoint has an ed, locate and maybe (re)initialize it */
- ed = ed_get(ahcd, ep, urb->dev, pipe, urb->interval);
+ ed = ed_get(ahcd, urb->ep, urb->dev, pipe, urb->interval);
if (!ed)
return -ENOMEM;
/* number of packets from URB */
td_cnt = urb->number_of_packets;
break;
- default:
- /* paranoia */
- admhc_err(ahcd, "bad EP type %d", ed->type);
- return -EINVAL;
}
urb_priv = urb_priv_alloc(ahcd, td_cnt, mem_flags);
goto fail;
}
- /* in case of unlink-during-submit */
- spin_lock(&urb->lock);
- if (urb->status != -EINPROGRESS) {
- spin_unlock(&urb->lock);
- urb->hcpriv = urb_priv;
- finish_urb(ahcd, urb);
- ret = 0;
+ ret = usb_hcd_link_urb_to_ep(hcd, urb);
+ if (ret)
goto fail;
- }
/* schedule the ed if needed */
if (ed->state == ED_IDLE) {
ret = ed_schedule(ahcd, ed);
- if (ret < 0)
- goto fail0;
-
+ if (ret < 0) {
+ usb_hcd_unlink_urb_from_ep(hcd, urb);
+ goto fail;
+ }
if (ed->type == PIPE_ISOCHRONOUS) {
u16 frame = admhc_frame_no(ahcd);
#ifdef ADMHC_VERBOSE_DEBUG
admhc_dump_ed(ahcd, "admhc_urb_enqueue", urb_priv->ed, 1);
#endif
-fail0:
- spin_unlock(&urb->lock);
+
fail:
if (ret)
urb_priv_free(ahcd, urb_priv);
}
/*
- * decouple the URB from the HC queues (TDs, urb_priv); it's
- * already marked using urb->status. reporting is always done
+ * decouple the URB from the HC queues (TDs, urb_priv);
+ * reporting is always done
* asynchronously, and we might be dealing with an urb that's
* partially transferred, or an ED with other urbs being unlinked.
*/
-static int admhc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
+static int admhc_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
+ int status)
{
struct admhcd *ahcd = hcd_to_admhcd(hcd);
unsigned long flags;
+ int ret;
spin_lock_irqsave(&ahcd->lock, flags);
#ifdef ADMHC_VERBOSE_DEBUG
- urb_print(ahcd, urb, "DEQUEUE", 1);
+ urb_print(ahcd, urb, "DEQUEUE", 1, status);
#endif
-
- if (HC_IS_RUNNING(hcd->state)) {
+ ret = usb_hcd_check_unlink_urb(hcd, urb, status);
+ if (ret) {
+ /* Do nothing */
+ ;
+ } else if (HC_IS_RUNNING(hcd->state)) {
struct urb_priv *urb_priv;
/* Unless an IRQ completed the unlink while it was being
* any more ... just clean up every urb's memory.
*/
if (urb->hcpriv)
- finish_urb(ahcd, urb);
+ finish_urb(ahcd, urb, status);
}
spin_unlock_irqrestore(&ahcd->lock, flags);
- return 0;
+ return ret;
}
/*-------------------------------------------------------------------------*/
#error "missing bus glue for admhc-hcd"
#endif
-#define DRIVER_INFO DRIVER_DESC " " DRIVER_VERSION
+#define DRIVER_INFO DRIVER_DESC " version " DRIVER_VERSION
static int __init admhc_hcd_mod_init(void)
{
pr_info("%s: block sizes: ed %Zd td %Zd\n", hcd_name,
sizeof (struct ed), sizeof (struct td));
+#ifdef DEBUG
+ admhc_debug_root = debugfs_create_dir("admhc", NULL);
+ if (!admhc_debug_root) {
+ ret = -ENOENT;
+ goto error_debug;
+ }
+#endif
+
#ifdef PLATFORM_DRIVER
ret = platform_driver_register(&PLATFORM_DRIVER);
if (ret < 0)
#ifdef PLATFORM_DRIVER
platform_driver_unregister(&PLATFORM_DRIVER);
error_platform:
+#endif
+
+#ifdef DEBUG
+ debugfs_remove(admhc_debug_root);
+ admhc_debug_root = NULL;
+error_debug:
#endif
return ret;
}
static void __exit admhc_hcd_mod_exit(void)
{
platform_driver_unregister(&PLATFORM_DRIVER);
+#ifdef DEBUG
+ debugfs_remove(admhc_debug_root);
+#endif
}
module_exit(admhc_hcd_mod_exit);
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_INFO);
-MODULE_LICENSE("GPL");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");
projects / openwrt.git / blobdiff