blob: 5efdffe3236572e4f7b3141a6a8ab5f4fb95d721 [file] [log] [blame]
Tony Olechd774efe2006-09-13 11:27:35 +01001/*
2* Host Controller Driver for the Elan Digital Systems U132 adapter
3*
4* Copyright(C) 2006 Elan Digital Systems Limited
5* http://www.elandigitalsystems.com
6*
7* Author and Maintainer - Tony Olech - Elan Digital Systems
8* tony.olech@elandigitalsystems.com
9*
10* This program is free software;you can redistribute it and/or
11* modify it under the terms of the GNU General Public License as
12* published by the Free Software Foundation, version 2.
13*
14*
15* This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
16* based on various USB host drivers in the 2.6.15 linux kernel
17* with constant reference to the 3rd Edition of Linux Device Drivers
18* published by O'Reilly
19*
20* The U132 adapter is a USB to CardBus adapter specifically designed
21* for PC cards that contain an OHCI host controller. Typical PC cards
22* are the Orange Mobile 3G Option GlobeTrotter Fusion card.
23*
24* The U132 adapter will *NOT *work with PC cards that do not contain
25* an OHCI controller. A simple way to test whether a PC card has an
26* OHCI controller as an interface is to insert the PC card directly
27* into a laptop(or desktop) with a CardBus slot and if "lspci" shows
28* a new USB controller and "lsusb -v" shows a new OHCI Host Controller
29* then there is a good chance that the U132 adapter will support the
30* PC card.(you also need the specific client driver for the PC card)
31*
32* Please inform the Author and Maintainer about any PC cards that
33* contain OHCI Host Controller and work when directly connected to
34* an embedded CardBus slot but do not work when they are connected
35* via an ELAN U132 adapter.
36*
37*/
Tony Olechd774efe2006-09-13 11:27:35 +010038#include <linux/kernel.h>
39#include <linux/module.h>
40#include <linux/moduleparam.h>
41#include <linux/delay.h>
42#include <linux/ioport.h>
Tony Olech4b873612006-12-06 13:16:22 +000043#include <linux/pci_ids.h>
Tony Olechd774efe2006-09-13 11:27:35 +010044#include <linux/sched.h>
45#include <linux/slab.h>
Tony Olechd774efe2006-09-13 11:27:35 +010046#include <linux/errno.h>
47#include <linux/init.h>
48#include <linux/timer.h>
49#include <linux/list.h>
50#include <linux/interrupt.h>
51#include <linux/usb.h>
Eric Lescouet27729aa2010-04-24 23:21:52 +020052#include <linux/usb/hcd.h>
Tony Olechd774efe2006-09-13 11:27:35 +010053#include <linux/workqueue.h>
54#include <linux/platform_device.h>
Matthias Kaehlcked2066eb2007-07-13 21:26:59 +020055#include <linux/mutex.h>
Tony Olechd774efe2006-09-13 11:27:35 +010056#include <asm/io.h>
57#include <asm/irq.h>
Tony Olechd774efe2006-09-13 11:27:35 +010058#include <asm/byteorder.h>
David Brownell47f84682007-04-29 10:21:14 -070059
60 /* FIXME ohci.h is ONLY for internal use by the OHCI driver.
61 * If you're going to try stuff like this, you need to split
62 * out shareable stuff (register declarations?) into its own
63 * file, maybe name <linux/usb/ohci.h>
64 */
65
Tony Olechd774efe2006-09-13 11:27:35 +010066#include "ohci.h"
67#define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
68#define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \
Daniel Walkerb40f8d32008-03-23 00:00:01 -070069 OHCI_INTR_WDH)
Tony Olechd774efe2006-09-13 11:27:35 +010070MODULE_AUTHOR("Tony Olech - Elan Digital Systems Limited");
71MODULE_DESCRIPTION("U132 USB Host Controller Driver");
72MODULE_LICENSE("GPL");
73#define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
74INT_MODULE_PARM(testing, 0);
75/* Some boards misreport power switching/overcurrent*/
Rusty Russell90ab5ee2012-01-13 09:32:20 +103076static bool distrust_firmware = 1;
Tony Olechd774efe2006-09-13 11:27:35 +010077module_param(distrust_firmware, bool, 0);
78MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren"
Daniel Walkerb40f8d32008-03-23 00:00:01 -070079 "t setup");
Adrian Bunk27a3de42006-11-20 03:23:54 +010080static DECLARE_WAIT_QUEUE_HEAD(u132_hcd_wait);
Tony Olechd774efe2006-09-13 11:27:35 +010081/*
82* u132_module_lock exists to protect access to global variables
83*
84*/
Matthias Kaehlcked2066eb2007-07-13 21:26:59 +020085static struct mutex u132_module_lock;
Daniel Walkerb40f8d32008-03-23 00:00:01 -070086static int u132_exiting;
87static int u132_instances;
Tony Olechd774efe2006-09-13 11:27:35 +010088static struct list_head u132_static_list;
89/*
90* end of the global variables protected by u132_module_lock
91*/
92static struct workqueue_struct *workqueue;
93#define MAX_U132_PORTS 7
94#define MAX_U132_ADDRS 128
95#define MAX_U132_UDEVS 4
96#define MAX_U132_ENDPS 100
97#define MAX_U132_RINGS 4
98static const char *cc_to_text[16] = {
Daniel Walkerb40f8d32008-03-23 00:00:01 -070099 "No Error ",
100 "CRC Error ",
101 "Bit Stuff ",
102 "Data Togg ",
103 "Stall ",
104 "DevNotResp ",
105 "PIDCheck ",
106 "UnExpPID ",
107 "DataOver ",
108 "DataUnder ",
109 "(for hw) ",
110 "(for hw) ",
111 "BufferOver ",
112 "BuffUnder ",
113 "(for HCD) ",
114 "(for HCD) "
Tony Olechd774efe2006-09-13 11:27:35 +0100115};
116struct u132_port {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700117 struct u132 *u132;
118 int reset;
119 int enable;
120 int power;
121 int Status;
Tony Olechd774efe2006-09-13 11:27:35 +0100122};
123struct u132_addr {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700124 u8 address;
Tony Olechd774efe2006-09-13 11:27:35 +0100125};
126struct u132_udev {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700127 struct kref kref;
128 struct usb_device *usb_device;
129 u8 enumeration;
130 u8 udev_number;
131 u8 usb_addr;
132 u8 portnumber;
133 u8 endp_number_in[16];
134 u8 endp_number_out[16];
Tony Olechd774efe2006-09-13 11:27:35 +0100135};
136#define ENDP_QUEUE_SHIFT 3
137#define ENDP_QUEUE_SIZE (1<<ENDP_QUEUE_SHIFT)
138#define ENDP_QUEUE_MASK (ENDP_QUEUE_SIZE-1)
139struct u132_urbq {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700140 struct list_head urb_more;
141 struct urb *urb;
Tony Olechd774efe2006-09-13 11:27:35 +0100142};
143struct u132_spin {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700144 spinlock_t slock;
Tony Olechd774efe2006-09-13 11:27:35 +0100145};
146struct u132_endp {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700147 struct kref kref;
148 u8 udev_number;
149 u8 endp_number;
150 u8 usb_addr;
151 u8 usb_endp;
152 struct u132 *u132;
153 struct list_head endp_ring;
154 struct u132_ring *ring;
155 unsigned toggle_bits:2;
156 unsigned active:1;
157 unsigned delayed:1;
158 unsigned input:1;
159 unsigned output:1;
160 unsigned pipetype:2;
161 unsigned dequeueing:1;
162 unsigned edset_flush:1;
163 unsigned spare_bits:14;
164 unsigned long jiffies;
165 struct usb_host_endpoint *hep;
166 struct u132_spin queue_lock;
167 u16 queue_size;
168 u16 queue_last;
169 u16 queue_next;
170 struct urb *urb_list[ENDP_QUEUE_SIZE];
171 struct list_head urb_more;
172 struct delayed_work scheduler;
Tony Olechd774efe2006-09-13 11:27:35 +0100173};
174struct u132_ring {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700175 unsigned in_use:1;
176 unsigned length:7;
177 u8 number;
178 struct u132 *u132;
179 struct u132_endp *curr_endp;
180 struct delayed_work scheduler;
Tony Olechd774efe2006-09-13 11:27:35 +0100181};
Tony Olechd774efe2006-09-13 11:27:35 +0100182struct u132 {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700183 struct kref kref;
184 struct list_head u132_list;
185 struct mutex sw_lock;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700186 struct mutex scheduler_lock;
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700187 struct u132_platform_data *board;
188 struct platform_device *platform_dev;
189 struct u132_ring ring[MAX_U132_RINGS];
190 int sequence_num;
191 int going;
192 int power;
193 int reset;
194 int num_ports;
195 u32 hc_control;
196 u32 hc_fminterval;
197 u32 hc_roothub_status;
198 u32 hc_roothub_a;
199 u32 hc_roothub_portstatus[MAX_ROOT_PORTS];
200 int flags;
201 unsigned long next_statechange;
202 struct delayed_work monitor;
203 int num_endpoints;
204 struct u132_addr addr[MAX_U132_ADDRS];
205 struct u132_udev udev[MAX_U132_UDEVS];
206 struct u132_port port[MAX_U132_PORTS];
207 struct u132_endp *endp[MAX_U132_ENDPS];
Tony Olechd774efe2006-09-13 11:27:35 +0100208};
Adrian Bunk9ce85402006-11-20 03:24:44 +0100209
Tony Olechd774efe2006-09-13 11:27:35 +0100210/*
Matt LaPlante0779bf22006-11-30 05:24:39 +0100211* these cannot be inlines because we need the structure offset!!
Tony Olechd774efe2006-09-13 11:27:35 +0100212* Does anyone have a better way?????
213*/
Tony Olech4b873612006-12-06 13:16:22 +0000214#define ftdi_read_pcimem(pdev, member, data) usb_ftdi_elan_read_pcimem(pdev, \
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700215 offsetof(struct ohci_regs, member), 0, data);
Tony Olech4b873612006-12-06 13:16:22 +0000216#define ftdi_write_pcimem(pdev, member, data) usb_ftdi_elan_write_pcimem(pdev, \
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700217 offsetof(struct ohci_regs, member), 0, data);
Tony Olechd774efe2006-09-13 11:27:35 +0100218#define u132_read_pcimem(u132, member, data) \
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700219 usb_ftdi_elan_read_pcimem(u132->platform_dev, offsetof(struct \
220 ohci_regs, member), 0, data);
Tony Olechd774efe2006-09-13 11:27:35 +0100221#define u132_write_pcimem(u132, member, data) \
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700222 usb_ftdi_elan_write_pcimem(u132->platform_dev, offsetof(struct \
223 ohci_regs, member), 0, data);
Tony Olechd774efe2006-09-13 11:27:35 +0100224static inline struct u132 *udev_to_u132(struct u132_udev *udev)
225{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700226 u8 udev_number = udev->udev_number;
227 return container_of(udev, struct u132, udev[udev_number]);
Tony Olechd774efe2006-09-13 11:27:35 +0100228}
229
230static inline struct u132 *hcd_to_u132(struct usb_hcd *hcd)
231{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700232 return (struct u132 *)(hcd->hcd_priv);
Tony Olechd774efe2006-09-13 11:27:35 +0100233}
234
235static inline struct usb_hcd *u132_to_hcd(struct u132 *u132)
236{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700237 return container_of((void *)u132, struct usb_hcd, hcd_priv);
Tony Olechd774efe2006-09-13 11:27:35 +0100238}
239
240static inline void u132_disable(struct u132 *u132)
241{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700242 u132_to_hcd(u132)->state = HC_STATE_HALT;
Tony Olechd774efe2006-09-13 11:27:35 +0100243}
244
245
246#define kref_to_u132(d) container_of(d, struct u132, kref)
247#define kref_to_u132_endp(d) container_of(d, struct u132_endp, kref)
248#define kref_to_u132_udev(d) container_of(d, struct u132_udev, kref)
249#include "../misc/usb_u132.h"
250static const char hcd_name[] = "u132_hcd";
251#define PORT_C_MASK ((USB_PORT_STAT_C_CONNECTION | USB_PORT_STAT_C_ENABLE | \
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700252 USB_PORT_STAT_C_SUSPEND | USB_PORT_STAT_C_OVERCURRENT | \
253 USB_PORT_STAT_C_RESET) << 16)
Tony Olechd774efe2006-09-13 11:27:35 +0100254static void u132_hcd_delete(struct kref *kref)
255{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700256 struct u132 *u132 = kref_to_u132(kref);
257 struct platform_device *pdev = u132->platform_dev;
258 struct usb_hcd *hcd = u132_to_hcd(u132);
259 u132->going += 1;
260 mutex_lock(&u132_module_lock);
261 list_del_init(&u132->u132_list);
262 u132_instances -= 1;
263 mutex_unlock(&u132_module_lock);
264 dev_warn(&u132->platform_dev->dev, "FREEING the hcd=%p and thus the u13"
265 "2=%p going=%d pdev=%p\n", hcd, u132, u132->going, pdev);
266 usb_put_hcd(hcd);
Tony Olechd774efe2006-09-13 11:27:35 +0100267}
268
269static inline void u132_u132_put_kref(struct u132 *u132)
270{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700271 kref_put(&u132->kref, u132_hcd_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100272}
273
274static inline void u132_u132_init_kref(struct u132 *u132)
275{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700276 kref_init(&u132->kref);
Tony Olechd774efe2006-09-13 11:27:35 +0100277}
278
279static void u132_udev_delete(struct kref *kref)
280{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700281 struct u132_udev *udev = kref_to_u132_udev(kref);
282 udev->udev_number = 0;
283 udev->usb_device = NULL;
284 udev->usb_addr = 0;
285 udev->enumeration = 0;
Tony Olechd774efe2006-09-13 11:27:35 +0100286}
287
288static inline void u132_udev_put_kref(struct u132 *u132, struct u132_udev *udev)
289{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700290 kref_put(&udev->kref, u132_udev_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100291}
292
293static inline void u132_udev_get_kref(struct u132 *u132, struct u132_udev *udev)
294{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700295 kref_get(&udev->kref);
Tony Olechd774efe2006-09-13 11:27:35 +0100296}
297
298static inline void u132_udev_init_kref(struct u132 *u132,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700299 struct u132_udev *udev)
Tony Olechd774efe2006-09-13 11:27:35 +0100300{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700301 kref_init(&udev->kref);
Tony Olechd774efe2006-09-13 11:27:35 +0100302}
303
304static inline void u132_ring_put_kref(struct u132 *u132, struct u132_ring *ring)
305{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700306 kref_put(&u132->kref, u132_hcd_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100307}
308
309static void u132_ring_requeue_work(struct u132 *u132, struct u132_ring *ring,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700310 unsigned int delta)
Tony Olechd774efe2006-09-13 11:27:35 +0100311{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700312 if (delta > 0) {
313 if (queue_delayed_work(workqueue, &ring->scheduler, delta))
314 return;
315 } else if (queue_delayed_work(workqueue, &ring->scheduler, 0))
316 return;
317 kref_put(&u132->kref, u132_hcd_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100318}
319
320static void u132_ring_queue_work(struct u132 *u132, struct u132_ring *ring,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700321 unsigned int delta)
Tony Olechd774efe2006-09-13 11:27:35 +0100322{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700323 kref_get(&u132->kref);
324 u132_ring_requeue_work(u132, ring, delta);
Tony Olechd774efe2006-09-13 11:27:35 +0100325}
326
327static void u132_ring_cancel_work(struct u132 *u132, struct u132_ring *ring)
328{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700329 if (cancel_delayed_work(&ring->scheduler))
330 kref_put(&u132->kref, u132_hcd_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100331}
332
333static void u132_endp_delete(struct kref *kref)
334{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700335 struct u132_endp *endp = kref_to_u132_endp(kref);
336 struct u132 *u132 = endp->u132;
337 u8 usb_addr = endp->usb_addr;
338 u8 usb_endp = endp->usb_endp;
339 u8 address = u132->addr[usb_addr].address;
340 struct u132_udev *udev = &u132->udev[address];
341 u8 endp_number = endp->endp_number;
342 struct usb_host_endpoint *hep = endp->hep;
343 struct u132_ring *ring = endp->ring;
344 struct list_head *head = &endp->endp_ring;
345 ring->length -= 1;
346 if (endp == ring->curr_endp) {
347 if (list_empty(head)) {
348 ring->curr_endp = NULL;
349 list_del(head);
350 } else {
351 struct u132_endp *next_endp = list_entry(head->next,
352 struct u132_endp, endp_ring);
353 ring->curr_endp = next_endp;
354 list_del(head);
355 }
356 } else
357 list_del(head);
358 if (endp->input) {
359 udev->endp_number_in[usb_endp] = 0;
360 u132_udev_put_kref(u132, udev);
361 }
362 if (endp->output) {
363 udev->endp_number_out[usb_endp] = 0;
364 u132_udev_put_kref(u132, udev);
365 }
366 u132->endp[endp_number - 1] = NULL;
367 hep->hcpriv = NULL;
368 kfree(endp);
369 u132_u132_put_kref(u132);
Tony Olechd774efe2006-09-13 11:27:35 +0100370}
371
372static inline void u132_endp_put_kref(struct u132 *u132, struct u132_endp *endp)
373{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700374 kref_put(&endp->kref, u132_endp_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100375}
376
377static inline void u132_endp_get_kref(struct u132 *u132, struct u132_endp *endp)
378{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700379 kref_get(&endp->kref);
Tony Olechd774efe2006-09-13 11:27:35 +0100380}
381
382static inline void u132_endp_init_kref(struct u132 *u132,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700383 struct u132_endp *endp)
Tony Olechd774efe2006-09-13 11:27:35 +0100384{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700385 kref_init(&endp->kref);
386 kref_get(&u132->kref);
Tony Olechd774efe2006-09-13 11:27:35 +0100387}
388
389static void u132_endp_queue_work(struct u132 *u132, struct u132_endp *endp,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700390 unsigned int delta)
Tony Olechd774efe2006-09-13 11:27:35 +0100391{
David Howellsc4028952006-11-22 14:57:56 +0000392 if (queue_delayed_work(workqueue, &endp->scheduler, delta))
393 kref_get(&endp->kref);
Tony Olechd774efe2006-09-13 11:27:35 +0100394}
395
396static void u132_endp_cancel_work(struct u132 *u132, struct u132_endp *endp)
397{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700398 if (cancel_delayed_work(&endp->scheduler))
399 kref_put(&endp->kref, u132_endp_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100400}
401
402static inline void u132_monitor_put_kref(struct u132 *u132)
403{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700404 kref_put(&u132->kref, u132_hcd_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100405}
406
407static void u132_monitor_queue_work(struct u132 *u132, unsigned int delta)
408{
David Howellsc4028952006-11-22 14:57:56 +0000409 if (queue_delayed_work(workqueue, &u132->monitor, delta))
410 kref_get(&u132->kref);
Tony Olechd774efe2006-09-13 11:27:35 +0100411}
412
413static void u132_monitor_requeue_work(struct u132 *u132, unsigned int delta)
414{
David Howellsc4028952006-11-22 14:57:56 +0000415 if (!queue_delayed_work(workqueue, &u132->monitor, delta))
416 kref_put(&u132->kref, u132_hcd_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100417}
418
419static void u132_monitor_cancel_work(struct u132 *u132)
420{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700421 if (cancel_delayed_work(&u132->monitor))
422 kref_put(&u132->kref, u132_hcd_delete);
Tony Olechd774efe2006-09-13 11:27:35 +0100423}
424
425static int read_roothub_info(struct u132 *u132)
426{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700427 u32 revision;
428 int retval;
429 retval = u132_read_pcimem(u132, revision, &revision);
430 if (retval) {
431 dev_err(&u132->platform_dev->dev, "error %d accessing device co"
432 "ntrol\n", retval);
433 return retval;
434 } else if ((revision & 0xFF) == 0x10) {
435 } else if ((revision & 0xFF) == 0x11) {
436 } else {
437 dev_err(&u132->platform_dev->dev, "device revision is not valid"
438 " %08X\n", revision);
439 return -ENODEV;
440 }
441 retval = u132_read_pcimem(u132, control, &u132->hc_control);
442 if (retval) {
443 dev_err(&u132->platform_dev->dev, "error %d accessing device co"
444 "ntrol\n", retval);
445 return retval;
446 }
447 retval = u132_read_pcimem(u132, roothub.status,
448 &u132->hc_roothub_status);
449 if (retval) {
450 dev_err(&u132->platform_dev->dev, "error %d accessing device re"
451 "g roothub.status\n", retval);
452 return retval;
453 }
454 retval = u132_read_pcimem(u132, roothub.a, &u132->hc_roothub_a);
455 if (retval) {
456 dev_err(&u132->platform_dev->dev, "error %d accessing device re"
457 "g roothub.a\n", retval);
458 return retval;
459 }
460 {
461 int I = u132->num_ports;
462 int i = 0;
463 while (I-- > 0) {
464 retval = u132_read_pcimem(u132, roothub.portstatus[i],
465 &u132->hc_roothub_portstatus[i]);
466 if (retval) {
467 dev_err(&u132->platform_dev->dev, "error %d acc"
468 "essing device roothub.portstatus[%d]\n"
469 , retval, i);
470 return retval;
471 } else
472 i += 1;
473 }
474 }
475 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +0100476}
477
David Howellsc4028952006-11-22 14:57:56 +0000478static void u132_hcd_monitor_work(struct work_struct *work)
Tony Olechd774efe2006-09-13 11:27:35 +0100479{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700480 struct u132 *u132 = container_of(work, struct u132, monitor.work);
481 if (u132->going > 1) {
482 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
483 , u132->going);
484 u132_monitor_put_kref(u132);
485 return;
486 } else if (u132->going > 0) {
487 dev_err(&u132->platform_dev->dev, "device is being removed\n");
488 u132_monitor_put_kref(u132);
489 return;
490 } else {
491 int retval;
492 mutex_lock(&u132->sw_lock);
493 retval = read_roothub_info(u132);
494 if (retval) {
495 struct usb_hcd *hcd = u132_to_hcd(u132);
496 u132_disable(u132);
497 u132->going = 1;
498 mutex_unlock(&u132->sw_lock);
499 usb_hc_died(hcd);
500 ftdi_elan_gone_away(u132->platform_dev);
501 u132_monitor_put_kref(u132);
502 return;
503 } else {
504 u132_monitor_requeue_work(u132, 500);
505 mutex_unlock(&u132->sw_lock);
506 return;
507 }
508 }
Tony Olechd774efe2006-09-13 11:27:35 +0100509}
510
511static void u132_hcd_giveback_urb(struct u132 *u132, struct u132_endp *endp,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700512 struct urb *urb, int status)
Tony Olechd774efe2006-09-13 11:27:35 +0100513{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700514 struct u132_ring *ring;
515 unsigned long irqs;
516 struct usb_hcd *hcd = u132_to_hcd(u132);
517 urb->error_count = 0;
518 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
Alan Sterne9df41c2007-08-08 11:48:02 -0400519 usb_hcd_unlink_urb_from_ep(hcd, urb);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700520 endp->queue_next += 1;
521 if (ENDP_QUEUE_SIZE > --endp->queue_size) {
522 endp->active = 0;
523 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
524 } else {
525 struct list_head *next = endp->urb_more.next;
526 struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
527 urb_more);
528 list_del(next);
529 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
530 urbq->urb;
531 endp->active = 0;
532 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
533 kfree(urbq);
534 }
Daniel Walker50d8ca92008-03-23 00:00:02 -0700535 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700536 ring = endp->ring;
537 ring->in_use = 0;
538 u132_ring_cancel_work(u132, ring);
539 u132_ring_queue_work(u132, ring, 0);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700540 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700541 u132_endp_put_kref(u132, endp);
Alan Stern4a000272007-08-24 15:42:24 -0400542 usb_hcd_giveback_urb(hcd, urb, status);
Tony Olechd774efe2006-09-13 11:27:35 +0100543}
544
545static void u132_hcd_forget_urb(struct u132 *u132, struct u132_endp *endp,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700546 struct urb *urb, int status)
Tony Olechd774efe2006-09-13 11:27:35 +0100547{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700548 u132_endp_put_kref(u132, endp);
Tony Olechd774efe2006-09-13 11:27:35 +0100549}
550
551static void u132_hcd_abandon_urb(struct u132 *u132, struct u132_endp *endp,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700552 struct urb *urb, int status)
Tony Olechd774efe2006-09-13 11:27:35 +0100553{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700554 unsigned long irqs;
555 struct usb_hcd *hcd = u132_to_hcd(u132);
556 urb->error_count = 0;
557 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
Alan Sterne9df41c2007-08-08 11:48:02 -0400558 usb_hcd_unlink_urb_from_ep(hcd, urb);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700559 endp->queue_next += 1;
560 if (ENDP_QUEUE_SIZE > --endp->queue_size) {
561 endp->active = 0;
562 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
563 } else {
564 struct list_head *next = endp->urb_more.next;
565 struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
566 urb_more);
567 list_del(next);
568 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
569 urbq->urb;
570 endp->active = 0;
571 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
572 kfree(urbq);
Joe Perches7f26b3a2010-08-04 10:40:08 -0700573 }
574 usb_hcd_giveback_urb(hcd, urb, status);
Tony Olechd774efe2006-09-13 11:27:35 +0100575}
576
577static inline int edset_input(struct u132 *u132, struct u132_ring *ring,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700578 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
579 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
580 int toggle_bits, int error_count, int condition_code, int repeat_number,
581 int halted, int skipped, int actual, int non_null))
Tony Olechd774efe2006-09-13 11:27:35 +0100582{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700583 return usb_ftdi_elan_edset_input(u132->platform_dev, ring->number, endp,
584 urb, address, endp->usb_endp, toggle_bits, callback);
Tony Olechd774efe2006-09-13 11:27:35 +0100585}
586
587static inline int edset_setup(struct u132 *u132, struct u132_ring *ring,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700588 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
589 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
590 int toggle_bits, int error_count, int condition_code, int repeat_number,
591 int halted, int skipped, int actual, int non_null))
Tony Olechd774efe2006-09-13 11:27:35 +0100592{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700593 return usb_ftdi_elan_edset_setup(u132->platform_dev, ring->number, endp,
594 urb, address, endp->usb_endp, toggle_bits, callback);
Tony Olechd774efe2006-09-13 11:27:35 +0100595}
596
597static inline int edset_single(struct u132 *u132, struct u132_ring *ring,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700598 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
599 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
600 int toggle_bits, int error_count, int condition_code, int repeat_number,
601 int halted, int skipped, int actual, int non_null))
Tony Olechd774efe2006-09-13 11:27:35 +0100602{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700603 return usb_ftdi_elan_edset_single(u132->platform_dev, ring->number,
604 endp, urb, address, endp->usb_endp, toggle_bits, callback);
Tony Olechd774efe2006-09-13 11:27:35 +0100605}
606
607static inline int edset_output(struct u132 *u132, struct u132_ring *ring,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700608 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
609 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
610 int toggle_bits, int error_count, int condition_code, int repeat_number,
611 int halted, int skipped, int actual, int non_null))
Tony Olechd774efe2006-09-13 11:27:35 +0100612{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700613 return usb_ftdi_elan_edset_output(u132->platform_dev, ring->number,
614 endp, urb, address, endp->usb_endp, toggle_bits, callback);
Tony Olechd774efe2006-09-13 11:27:35 +0100615}
616
617
618/*
619* must not LOCK sw_lock
620*
621*/
622static void u132_hcd_interrupt_recv(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700623 int len, int toggle_bits, int error_count, int condition_code,
624 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +0100625{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700626 struct u132_endp *endp = data;
627 struct u132 *u132 = endp->u132;
628 u8 address = u132->addr[endp->usb_addr].address;
629 struct u132_udev *udev = &u132->udev[address];
Daniel Walker50d8ca92008-03-23 00:00:02 -0700630 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700631 if (u132->going > 1) {
632 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
633 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700634 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700635 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
636 return;
637 } else if (endp->dequeueing) {
638 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700639 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700640 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
641 return;
642 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -0400643 dev_err(&u132->platform_dev->dev, "device is being removed "
644 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700645 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700646 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
647 return;
Alan Sterneb231052007-08-21 15:40:36 -0400648 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700649 struct u132_ring *ring = endp->ring;
650 u8 *u = urb->transfer_buffer + urb->actual_length;
651 u8 *b = buf;
652 int L = len;
653
654 while (L-- > 0)
655 *u++ = *b++;
656
657 urb->actual_length += len;
658 if ((condition_code == TD_CC_NOERROR) &&
659 (urb->transfer_buffer_length > urb->actual_length)) {
660 endp->toggle_bits = toggle_bits;
661 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
662 1 & toggle_bits);
663 if (urb->actual_length > 0) {
664 int retval;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700665 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700666 retval = edset_single(u132, ring, endp, urb,
667 address, endp->toggle_bits,
668 u132_hcd_interrupt_recv);
669 if (retval != 0)
670 u132_hcd_giveback_urb(u132, endp, urb,
671 retval);
672 } else {
673 ring->in_use = 0;
674 endp->active = 0;
675 endp->jiffies = jiffies +
676 msecs_to_jiffies(urb->interval);
677 u132_ring_cancel_work(u132, ring);
678 u132_ring_queue_work(u132, ring, 0);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700679 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700680 u132_endp_put_kref(u132, endp);
681 }
682 return;
683 } else if ((condition_code == TD_DATAUNDERRUN) &&
684 ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
685 endp->toggle_bits = toggle_bits;
686 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
687 1 & toggle_bits);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700688 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700689 u132_hcd_giveback_urb(u132, endp, urb, 0);
690 return;
691 } else {
692 if (condition_code == TD_CC_NOERROR) {
693 endp->toggle_bits = toggle_bits;
694 usb_settoggle(udev->usb_device, endp->usb_endp,
695 0, 1 & toggle_bits);
696 } else if (condition_code == TD_CC_STALL) {
697 endp->toggle_bits = 0x2;
698 usb_settoggle(udev->usb_device, endp->usb_endp,
699 0, 0);
700 } else {
701 endp->toggle_bits = 0x2;
702 usb_settoggle(udev->usb_device, endp->usb_endp,
703 0, 0);
704 dev_err(&u132->platform_dev->dev, "urb=%p givin"
705 "g back INTERRUPT %s\n", urb,
706 cc_to_text[condition_code]);
707 }
Daniel Walker50d8ca92008-03-23 00:00:02 -0700708 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700709 u132_hcd_giveback_urb(u132, endp, urb,
710 cc_to_error[condition_code]);
711 return;
712 }
713 } else {
Alan Sterneb231052007-08-21 15:40:36 -0400714 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
715 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700716 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -0400717 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700718 return;
719 }
Tony Olechd774efe2006-09-13 11:27:35 +0100720}
721
722static void u132_hcd_bulk_output_sent(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700723 int len, int toggle_bits, int error_count, int condition_code,
724 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +0100725{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700726 struct u132_endp *endp = data;
727 struct u132 *u132 = endp->u132;
728 u8 address = u132->addr[endp->usb_addr].address;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700729 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700730 if (u132->going > 1) {
731 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
732 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700733 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700734 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
735 return;
736 } else if (endp->dequeueing) {
737 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700738 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700739 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
740 return;
741 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -0400742 dev_err(&u132->platform_dev->dev, "device is being removed "
743 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700744 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700745 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
746 return;
Alan Sterneb231052007-08-21 15:40:36 -0400747 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700748 struct u132_ring *ring = endp->ring;
749 urb->actual_length += len;
750 endp->toggle_bits = toggle_bits;
751 if (urb->transfer_buffer_length > urb->actual_length) {
752 int retval;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700753 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700754 retval = edset_output(u132, ring, endp, urb, address,
755 endp->toggle_bits, u132_hcd_bulk_output_sent);
756 if (retval != 0)
757 u132_hcd_giveback_urb(u132, endp, urb, retval);
758 return;
759 } else {
Daniel Walker50d8ca92008-03-23 00:00:02 -0700760 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700761 u132_hcd_giveback_urb(u132, endp, urb, 0);
762 return;
763 }
764 } else {
Alan Sterneb231052007-08-21 15:40:36 -0400765 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
766 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700767 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -0400768 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700769 return;
770 }
Tony Olechd774efe2006-09-13 11:27:35 +0100771}
772
773static void u132_hcd_bulk_input_recv(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700774 int len, int toggle_bits, int error_count, int condition_code,
775 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +0100776{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700777 struct u132_endp *endp = data;
778 struct u132 *u132 = endp->u132;
779 u8 address = u132->addr[endp->usb_addr].address;
780 struct u132_udev *udev = &u132->udev[address];
Daniel Walker50d8ca92008-03-23 00:00:02 -0700781 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700782 if (u132->going > 1) {
783 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
784 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700785 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700786 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
787 return;
788 } else if (endp->dequeueing) {
789 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700790 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700791 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
792 return;
793 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -0400794 dev_err(&u132->platform_dev->dev, "device is being removed "
795 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700796 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700797 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
798 return;
Alan Sterneb231052007-08-21 15:40:36 -0400799 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700800 struct u132_ring *ring = endp->ring;
801 u8 *u = urb->transfer_buffer + urb->actual_length;
802 u8 *b = buf;
803 int L = len;
804
805 while (L-- > 0)
806 *u++ = *b++;
807
808 urb->actual_length += len;
809 if ((condition_code == TD_CC_NOERROR) &&
810 (urb->transfer_buffer_length > urb->actual_length)) {
811 int retval;
812 endp->toggle_bits = toggle_bits;
813 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
814 1 & toggle_bits);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700815 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700816 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
817 ring->number, endp, urb, address,
818 endp->usb_endp, endp->toggle_bits,
819 u132_hcd_bulk_input_recv);
820 if (retval != 0)
821 u132_hcd_giveback_urb(u132, endp, urb, retval);
822 return;
823 } else if (condition_code == TD_CC_NOERROR) {
824 endp->toggle_bits = toggle_bits;
825 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
826 1 & toggle_bits);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700827 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700828 u132_hcd_giveback_urb(u132, endp, urb,
829 cc_to_error[condition_code]);
830 return;
831 } else if ((condition_code == TD_DATAUNDERRUN) &&
832 ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
833 endp->toggle_bits = toggle_bits;
834 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
835 1 & toggle_bits);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700836 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700837 u132_hcd_giveback_urb(u132, endp, urb, 0);
838 return;
839 } else if (condition_code == TD_DATAUNDERRUN) {
840 endp->toggle_bits = toggle_bits;
841 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
842 1 & toggle_bits);
843 dev_warn(&u132->platform_dev->dev, "urb=%p(SHORT NOT OK"
844 ") giving back BULK IN %s\n", urb,
845 cc_to_text[condition_code]);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700846 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700847 u132_hcd_giveback_urb(u132, endp, urb, 0);
848 return;
849 } else if (condition_code == TD_CC_STALL) {
850 endp->toggle_bits = 0x2;
851 usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700852 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700853 u132_hcd_giveback_urb(u132, endp, urb,
854 cc_to_error[condition_code]);
855 return;
856 } else {
857 endp->toggle_bits = 0x2;
858 usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
859 dev_err(&u132->platform_dev->dev, "urb=%p giving back B"
860 "ULK IN code=%d %s\n", urb, condition_code,
861 cc_to_text[condition_code]);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700862 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700863 u132_hcd_giveback_urb(u132, endp, urb,
864 cc_to_error[condition_code]);
865 return;
866 }
867 } else {
Alan Sterneb231052007-08-21 15:40:36 -0400868 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
869 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700870 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -0400871 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700872 return;
873 }
Tony Olechd774efe2006-09-13 11:27:35 +0100874}
875
876static void u132_hcd_configure_empty_sent(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700877 int len, int toggle_bits, int error_count, int condition_code,
878 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +0100879{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700880 struct u132_endp *endp = data;
881 struct u132 *u132 = endp->u132;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700882 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700883 if (u132->going > 1) {
884 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
885 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700886 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700887 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
888 return;
889 } else if (endp->dequeueing) {
890 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700891 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700892 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
893 return;
894 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -0400895 dev_err(&u132->platform_dev->dev, "device is being removed "
896 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700897 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700898 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
899 return;
Alan Sterneb231052007-08-21 15:40:36 -0400900 } else if (!urb->unlinked) {
Daniel Walker50d8ca92008-03-23 00:00:02 -0700901 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700902 u132_hcd_giveback_urb(u132, endp, urb, 0);
903 return;
904 } else {
Alan Sterneb231052007-08-21 15:40:36 -0400905 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
906 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700907 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -0400908 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700909 return;
910 }
Tony Olechd774efe2006-09-13 11:27:35 +0100911}
912
913static void u132_hcd_configure_input_recv(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700914 int len, int toggle_bits, int error_count, int condition_code,
915 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +0100916{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700917 struct u132_endp *endp = data;
918 struct u132 *u132 = endp->u132;
919 u8 address = u132->addr[endp->usb_addr].address;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700920 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700921 if (u132->going > 1) {
922 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
923 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700924 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700925 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
926 return;
927 } else if (endp->dequeueing) {
928 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700929 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700930 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
931 return;
932 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -0400933 dev_err(&u132->platform_dev->dev, "device is being removed "
934 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700935 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700936 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
937 return;
Alan Sterneb231052007-08-21 15:40:36 -0400938 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700939 struct u132_ring *ring = endp->ring;
940 u8 *u = urb->transfer_buffer;
941 u8 *b = buf;
942 int L = len;
943
944 while (L-- > 0)
945 *u++ = *b++;
946
947 urb->actual_length = len;
948 if ((condition_code == TD_CC_NOERROR) || ((condition_code ==
949 TD_DATAUNDERRUN) && ((urb->transfer_flags &
950 URB_SHORT_NOT_OK) == 0))) {
951 int retval;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700952 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700953 retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
954 ring->number, endp, urb, address,
955 endp->usb_endp, 0x3,
956 u132_hcd_configure_empty_sent);
957 if (retval != 0)
958 u132_hcd_giveback_urb(u132, endp, urb, retval);
959 return;
960 } else if (condition_code == TD_CC_STALL) {
Daniel Walker50d8ca92008-03-23 00:00:02 -0700961 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700962 dev_warn(&u132->platform_dev->dev, "giving back SETUP I"
963 "NPUT STALL urb %p\n", urb);
964 u132_hcd_giveback_urb(u132, endp, urb,
965 cc_to_error[condition_code]);
966 return;
967 } else {
Daniel Walker50d8ca92008-03-23 00:00:02 -0700968 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700969 dev_err(&u132->platform_dev->dev, "giving back SETUP IN"
970 "PUT %s urb %p\n", cc_to_text[condition_code],
971 urb);
972 u132_hcd_giveback_urb(u132, endp, urb,
973 cc_to_error[condition_code]);
974 return;
975 }
976 } else {
Alan Sterneb231052007-08-21 15:40:36 -0400977 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
978 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700979 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -0400980 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700981 return;
982 }
Tony Olechd774efe2006-09-13 11:27:35 +0100983}
984
985static void u132_hcd_configure_empty_recv(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700986 int len, int toggle_bits, int error_count, int condition_code,
987 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +0100988{
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700989 struct u132_endp *endp = data;
990 struct u132 *u132 = endp->u132;
Daniel Walker50d8ca92008-03-23 00:00:02 -0700991 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700992 if (u132->going > 1) {
993 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
994 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -0700995 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -0700996 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
997 return;
998 } else if (endp->dequeueing) {
999 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001000 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001001 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1002 return;
1003 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04001004 dev_err(&u132->platform_dev->dev, "device is being removed "
1005 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001006 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001007 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1008 return;
Alan Sterneb231052007-08-21 15:40:36 -04001009 } else if (!urb->unlinked) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001010 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001011 u132_hcd_giveback_urb(u132, endp, urb, 0);
1012 return;
1013 } else {
Alan Sterneb231052007-08-21 15:40:36 -04001014 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1015 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001016 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -04001017 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001018 return;
1019 }
Tony Olechd774efe2006-09-13 11:27:35 +01001020}
1021
1022static void u132_hcd_configure_setup_sent(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001023 int len, int toggle_bits, int error_count, int condition_code,
1024 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +01001025{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001026 struct u132_endp *endp = data;
1027 struct u132 *u132 = endp->u132;
1028 u8 address = u132->addr[endp->usb_addr].address;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001029 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001030 if (u132->going > 1) {
1031 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1032 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001033 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001034 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1035 return;
1036 } else if (endp->dequeueing) {
1037 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001038 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001039 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1040 return;
1041 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04001042 dev_err(&u132->platform_dev->dev, "device is being removed "
1043 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001044 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001045 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1046 return;
Alan Sterneb231052007-08-21 15:40:36 -04001047 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001048 if (usb_pipein(urb->pipe)) {
1049 int retval;
1050 struct u132_ring *ring = endp->ring;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001051 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001052 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1053 ring->number, endp, urb, address,
1054 endp->usb_endp, 0,
1055 u132_hcd_configure_input_recv);
1056 if (retval != 0)
1057 u132_hcd_giveback_urb(u132, endp, urb, retval);
1058 return;
1059 } else {
1060 int retval;
1061 struct u132_ring *ring = endp->ring;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001062 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001063 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1064 ring->number, endp, urb, address,
1065 endp->usb_endp, 0,
1066 u132_hcd_configure_empty_recv);
1067 if (retval != 0)
1068 u132_hcd_giveback_urb(u132, endp, urb, retval);
1069 return;
1070 }
1071 } else {
Alan Sterneb231052007-08-21 15:40:36 -04001072 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1073 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001074 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -04001075 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001076 return;
1077 }
Tony Olechd774efe2006-09-13 11:27:35 +01001078}
1079
1080static void u132_hcd_enumeration_empty_recv(void *data, struct urb *urb,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001081 u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1082 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +01001083{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001084 struct u132_endp *endp = data;
1085 struct u132 *u132 = endp->u132;
1086 u8 address = u132->addr[endp->usb_addr].address;
1087 struct u132_udev *udev = &u132->udev[address];
Daniel Walker50d8ca92008-03-23 00:00:02 -07001088 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001089 if (u132->going > 1) {
1090 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1091 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001092 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001093 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1094 return;
1095 } else if (endp->dequeueing) {
1096 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001097 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001098 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1099 return;
1100 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04001101 dev_err(&u132->platform_dev->dev, "device is being removed "
1102 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001103 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001104 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1105 return;
Alan Sterneb231052007-08-21 15:40:36 -04001106 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001107 u132->addr[0].address = 0;
1108 endp->usb_addr = udev->usb_addr;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001109 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001110 u132_hcd_giveback_urb(u132, endp, urb, 0);
1111 return;
1112 } else {
Alan Sterneb231052007-08-21 15:40:36 -04001113 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1114 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001115 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -04001116 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001117 return;
1118 }
Tony Olechd774efe2006-09-13 11:27:35 +01001119}
1120
1121static void u132_hcd_enumeration_address_sent(void *data, struct urb *urb,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001122 u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1123 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +01001124{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001125 struct u132_endp *endp = data;
1126 struct u132 *u132 = endp->u132;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001127 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001128 if (u132->going > 1) {
1129 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1130 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001131 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001132 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1133 return;
1134 } else if (endp->dequeueing) {
1135 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001136 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001137 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1138 return;
1139 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04001140 dev_err(&u132->platform_dev->dev, "device is being removed "
1141 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001142 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001143 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1144 return;
Alan Sterneb231052007-08-21 15:40:36 -04001145 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001146 int retval;
1147 struct u132_ring *ring = endp->ring;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001148 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001149 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1150 ring->number, endp, urb, 0, endp->usb_endp, 0,
1151 u132_hcd_enumeration_empty_recv);
1152 if (retval != 0)
1153 u132_hcd_giveback_urb(u132, endp, urb, retval);
1154 return;
1155 } else {
Alan Sterneb231052007-08-21 15:40:36 -04001156 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1157 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001158 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -04001159 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001160 return;
1161 }
Tony Olechd774efe2006-09-13 11:27:35 +01001162}
1163
1164static void u132_hcd_initial_empty_sent(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001165 int len, int toggle_bits, int error_count, int condition_code,
1166 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +01001167{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001168 struct u132_endp *endp = data;
1169 struct u132 *u132 = endp->u132;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001170 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001171 if (u132->going > 1) {
1172 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1173 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001174 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001175 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1176 return;
1177 } else if (endp->dequeueing) {
1178 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001179 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001180 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1181 return;
1182 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04001183 dev_err(&u132->platform_dev->dev, "device is being removed "
1184 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001185 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001186 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1187 return;
Alan Sterneb231052007-08-21 15:40:36 -04001188 } else if (!urb->unlinked) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001189 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001190 u132_hcd_giveback_urb(u132, endp, urb, 0);
1191 return;
1192 } else {
Alan Sterneb231052007-08-21 15:40:36 -04001193 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1194 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001195 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -04001196 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001197 return;
1198 }
Tony Olechd774efe2006-09-13 11:27:35 +01001199}
1200
1201static void u132_hcd_initial_input_recv(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001202 int len, int toggle_bits, int error_count, int condition_code,
1203 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +01001204{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001205 struct u132_endp *endp = data;
1206 struct u132 *u132 = endp->u132;
1207 u8 address = u132->addr[endp->usb_addr].address;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001208 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001209 if (u132->going > 1) {
1210 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1211 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001212 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001213 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1214 return;
1215 } else if (endp->dequeueing) {
1216 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001217 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001218 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1219 return;
1220 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04001221 dev_err(&u132->platform_dev->dev, "device is being removed "
1222 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001223 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001224 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1225 return;
Alan Sterneb231052007-08-21 15:40:36 -04001226 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001227 int retval;
1228 struct u132_ring *ring = endp->ring;
1229 u8 *u = urb->transfer_buffer;
1230 u8 *b = buf;
1231 int L = len;
1232
1233 while (L-- > 0)
1234 *u++ = *b++;
1235
1236 urb->actual_length = len;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001237 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001238 retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
1239 ring->number, endp, urb, address, endp->usb_endp, 0x3,
1240 u132_hcd_initial_empty_sent);
1241 if (retval != 0)
1242 u132_hcd_giveback_urb(u132, endp, urb, retval);
1243 return;
1244 } else {
Alan Sterneb231052007-08-21 15:40:36 -04001245 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1246 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001247 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -04001248 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001249 return;
1250 }
Tony Olechd774efe2006-09-13 11:27:35 +01001251}
1252
1253static void u132_hcd_initial_setup_sent(void *data, struct urb *urb, u8 *buf,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001254 int len, int toggle_bits, int error_count, int condition_code,
1255 int repeat_number, int halted, int skipped, int actual, int non_null)
Tony Olechd774efe2006-09-13 11:27:35 +01001256{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001257 struct u132_endp *endp = data;
1258 struct u132 *u132 = endp->u132;
1259 u8 address = u132->addr[endp->usb_addr].address;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001260 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001261 if (u132->going > 1) {
1262 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1263 , u132->going);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001264 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001265 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1266 return;
1267 } else if (endp->dequeueing) {
1268 endp->dequeueing = 0;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001269 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001270 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1271 return;
1272 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04001273 dev_err(&u132->platform_dev->dev, "device is being removed "
1274 "urb=%p\n", urb);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001275 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001276 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1277 return;
Alan Sterneb231052007-08-21 15:40:36 -04001278 } else if (!urb->unlinked) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001279 int retval;
1280 struct u132_ring *ring = endp->ring;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001281 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001282 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1283 ring->number, endp, urb, address, endp->usb_endp, 0,
1284 u132_hcd_initial_input_recv);
1285 if (retval != 0)
1286 u132_hcd_giveback_urb(u132, endp, urb, retval);
1287 return;
1288 } else {
Alan Sterneb231052007-08-21 15:40:36 -04001289 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1290 "unlinked=%d\n", urb, urb->unlinked);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001291 mutex_unlock(&u132->scheduler_lock);
Alan Stern4a000272007-08-24 15:42:24 -04001292 u132_hcd_giveback_urb(u132, endp, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001293 return;
1294 }
Tony Olechd774efe2006-09-13 11:27:35 +01001295}
1296
Tony Olechd774efe2006-09-13 11:27:35 +01001297/*
1298* this work function is only executed from the work queue
1299*
1300*/
David Howellsc4028952006-11-22 14:57:56 +00001301static void u132_hcd_ring_work_scheduler(struct work_struct *work)
Tony Olechd774efe2006-09-13 11:27:35 +01001302{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001303 struct u132_ring *ring =
David Howellsc4028952006-11-22 14:57:56 +00001304 container_of(work, struct u132_ring, scheduler.work);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001305 struct u132 *u132 = ring->u132;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001306 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001307 if (ring->in_use) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001308 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001309 u132_ring_put_kref(u132, ring);
1310 return;
1311 } else if (ring->curr_endp) {
1312 struct u132_endp *last_endp = ring->curr_endp;
1313 struct list_head *scan;
1314 struct list_head *head = &last_endp->endp_ring;
1315 unsigned long wakeup = 0;
1316 list_for_each(scan, head) {
1317 struct u132_endp *endp = list_entry(scan,
1318 struct u132_endp, endp_ring);
1319 if (endp->queue_next == endp->queue_last) {
1320 } else if ((endp->delayed == 0)
1321 || time_after_eq(jiffies, endp->jiffies)) {
1322 ring->curr_endp = endp;
1323 u132_endp_cancel_work(u132, last_endp);
1324 u132_endp_queue_work(u132, last_endp, 0);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001325 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001326 u132_ring_put_kref(u132, ring);
1327 return;
1328 } else {
1329 unsigned long delta = endp->jiffies - jiffies;
1330 if (delta > wakeup)
1331 wakeup = delta;
1332 }
1333 }
1334 if (last_endp->queue_next == last_endp->queue_last) {
1335 } else if ((last_endp->delayed == 0) || time_after_eq(jiffies,
1336 last_endp->jiffies)) {
1337 u132_endp_cancel_work(u132, last_endp);
1338 u132_endp_queue_work(u132, last_endp, 0);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001339 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001340 u132_ring_put_kref(u132, ring);
1341 return;
1342 } else {
1343 unsigned long delta = last_endp->jiffies - jiffies;
1344 if (delta > wakeup)
1345 wakeup = delta;
1346 }
1347 if (wakeup > 0) {
1348 u132_ring_requeue_work(u132, ring, wakeup);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001349 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001350 return;
1351 } else {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001352 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001353 u132_ring_put_kref(u132, ring);
1354 return;
1355 }
1356 } else {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001357 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001358 u132_ring_put_kref(u132, ring);
1359 return;
1360 }
Tony Olechd774efe2006-09-13 11:27:35 +01001361}
1362
David Howellsc4028952006-11-22 14:57:56 +00001363static void u132_hcd_endp_work_scheduler(struct work_struct *work)
Tony Olechd774efe2006-09-13 11:27:35 +01001364{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001365 struct u132_ring *ring;
1366 struct u132_endp *endp =
David Howellsc4028952006-11-22 14:57:56 +00001367 container_of(work, struct u132_endp, scheduler.work);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001368 struct u132 *u132 = endp->u132;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001369 mutex_lock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001370 ring = endp->ring;
1371 if (endp->edset_flush) {
1372 endp->edset_flush = 0;
1373 if (endp->dequeueing)
1374 usb_ftdi_elan_edset_flush(u132->platform_dev,
1375 ring->number, endp);
Daniel Walker50d8ca92008-03-23 00:00:02 -07001376 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001377 u132_endp_put_kref(u132, endp);
1378 return;
1379 } else if (endp->active) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001380 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001381 u132_endp_put_kref(u132, endp);
1382 return;
1383 } else if (ring->in_use) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001384 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001385 u132_endp_put_kref(u132, endp);
1386 return;
1387 } else if (endp->queue_next == endp->queue_last) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001388 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001389 u132_endp_put_kref(u132, endp);
1390 return;
1391 } else if (endp->pipetype == PIPE_INTERRUPT) {
1392 u8 address = u132->addr[endp->usb_addr].address;
1393 if (ring->in_use) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001394 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001395 u132_endp_put_kref(u132, endp);
1396 return;
1397 } else {
1398 int retval;
1399 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1400 endp->queue_next];
1401 endp->active = 1;
1402 ring->curr_endp = endp;
1403 ring->in_use = 1;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001404 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001405 retval = edset_single(u132, ring, endp, urb, address,
1406 endp->toggle_bits, u132_hcd_interrupt_recv);
1407 if (retval != 0)
1408 u132_hcd_giveback_urb(u132, endp, urb, retval);
1409 return;
1410 }
1411 } else if (endp->pipetype == PIPE_CONTROL) {
1412 u8 address = u132->addr[endp->usb_addr].address;
1413 if (ring->in_use) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001414 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001415 u132_endp_put_kref(u132, endp);
1416 return;
1417 } else if (address == 0) {
1418 int retval;
1419 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1420 endp->queue_next];
1421 endp->active = 1;
1422 ring->curr_endp = endp;
1423 ring->in_use = 1;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001424 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001425 retval = edset_setup(u132, ring, endp, urb, address,
1426 0x2, u132_hcd_initial_setup_sent);
1427 if (retval != 0)
1428 u132_hcd_giveback_urb(u132, endp, urb, retval);
1429 return;
1430 } else if (endp->usb_addr == 0) {
1431 int retval;
1432 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1433 endp->queue_next];
1434 endp->active = 1;
1435 ring->curr_endp = endp;
1436 ring->in_use = 1;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001437 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001438 retval = edset_setup(u132, ring, endp, urb, 0, 0x2,
1439 u132_hcd_enumeration_address_sent);
1440 if (retval != 0)
1441 u132_hcd_giveback_urb(u132, endp, urb, retval);
1442 return;
1443 } else {
1444 int retval;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001445 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1446 endp->queue_next];
Randy Dunlap1d6ec812010-05-06 16:46:03 -07001447 address = u132->addr[endp->usb_addr].address;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001448 endp->active = 1;
1449 ring->curr_endp = endp;
1450 ring->in_use = 1;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001451 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001452 retval = edset_setup(u132, ring, endp, urb, address,
1453 0x2, u132_hcd_configure_setup_sent);
1454 if (retval != 0)
1455 u132_hcd_giveback_urb(u132, endp, urb, retval);
1456 return;
1457 }
1458 } else {
1459 if (endp->input) {
1460 u8 address = u132->addr[endp->usb_addr].address;
1461 if (ring->in_use) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001462 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001463 u132_endp_put_kref(u132, endp);
1464 return;
1465 } else {
1466 int retval;
1467 struct urb *urb = endp->urb_list[
1468 ENDP_QUEUE_MASK & endp->queue_next];
1469 endp->active = 1;
1470 ring->curr_endp = endp;
1471 ring->in_use = 1;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001472 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001473 retval = edset_input(u132, ring, endp, urb,
1474 address, endp->toggle_bits,
1475 u132_hcd_bulk_input_recv);
1476 if (retval == 0) {
1477 } else
1478 u132_hcd_giveback_urb(u132, endp, urb,
1479 retval);
1480 return;
1481 }
1482 } else { /* output pipe */
1483 u8 address = u132->addr[endp->usb_addr].address;
1484 if (ring->in_use) {
Daniel Walker50d8ca92008-03-23 00:00:02 -07001485 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001486 u132_endp_put_kref(u132, endp);
1487 return;
1488 } else {
1489 int retval;
1490 struct urb *urb = endp->urb_list[
1491 ENDP_QUEUE_MASK & endp->queue_next];
1492 endp->active = 1;
1493 ring->curr_endp = endp;
1494 ring->in_use = 1;
Daniel Walker50d8ca92008-03-23 00:00:02 -07001495 mutex_unlock(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001496 retval = edset_output(u132, ring, endp, urb,
1497 address, endp->toggle_bits,
1498 u132_hcd_bulk_output_sent);
1499 if (retval == 0) {
1500 } else
1501 u132_hcd_giveback_urb(u132, endp, urb,
1502 retval);
1503 return;
1504 }
1505 }
1506 }
Tony Olechd774efe2006-09-13 11:27:35 +01001507}
Gabriel C5b570d42007-07-30 12:57:03 +02001508#ifdef CONFIG_PM
Tony Olechd774efe2006-09-13 11:27:35 +01001509
1510static void port_power(struct u132 *u132, int pn, int is_on)
1511{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001512 u132->port[pn].power = is_on;
Tony Olechd774efe2006-09-13 11:27:35 +01001513}
1514
Gabriel C5b570d42007-07-30 12:57:03 +02001515#endif
1516
Tony Olechd774efe2006-09-13 11:27:35 +01001517static void u132_power(struct u132 *u132, int is_on)
1518{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001519 struct usb_hcd *hcd = u132_to_hcd(u132)
1520 ; /* hub is inactive unless the port is powered */
1521 if (is_on) {
1522 if (u132->power)
1523 return;
1524 u132->power = 1;
1525 } else {
1526 u132->power = 0;
1527 hcd->state = HC_STATE_HALT;
1528 }
Tony Olechd774efe2006-09-13 11:27:35 +01001529}
1530
1531static int u132_periodic_reinit(struct u132 *u132)
1532{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001533 int retval;
1534 u32 fi = u132->hc_fminterval & 0x03fff;
1535 u32 fit;
1536 u32 fminterval;
1537 retval = u132_read_pcimem(u132, fminterval, &fminterval);
1538 if (retval)
1539 return retval;
1540 fit = fminterval & FIT;
1541 retval = u132_write_pcimem(u132, fminterval,
1542 (fit ^ FIT) | u132->hc_fminterval);
1543 if (retval)
1544 return retval;
1545 retval = u132_write_pcimem(u132, periodicstart,
1546 ((9 * fi) / 10) & 0x3fff);
1547 if (retval)
1548 return retval;
1549 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01001550}
1551
1552static char *hcfs2string(int state)
1553{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001554 switch (state) {
1555 case OHCI_USB_RESET:
1556 return "reset";
1557 case OHCI_USB_RESUME:
1558 return "resume";
1559 case OHCI_USB_OPER:
1560 return "operational";
1561 case OHCI_USB_SUSPEND:
1562 return "suspend";
1563 }
1564 return "?";
Tony Olechd774efe2006-09-13 11:27:35 +01001565}
1566
Tony Olechd774efe2006-09-13 11:27:35 +01001567static int u132_init(struct u132 *u132)
1568{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001569 int retval;
1570 u32 control;
1571 u132_disable(u132);
1572 u132->next_statechange = jiffies;
1573 retval = u132_write_pcimem(u132, intrdisable, OHCI_INTR_MIE);
1574 if (retval)
1575 return retval;
1576 retval = u132_read_pcimem(u132, control, &control);
1577 if (retval)
1578 return retval;
1579 if (u132->num_ports == 0) {
1580 u32 rh_a = -1;
1581 retval = u132_read_pcimem(u132, roothub.a, &rh_a);
1582 if (retval)
1583 return retval;
1584 u132->num_ports = rh_a & RH_A_NDP;
1585 retval = read_roothub_info(u132);
1586 if (retval)
1587 return retval;
1588 }
1589 if (u132->num_ports > MAX_U132_PORTS)
1590 return -EINVAL;
1591
1592 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01001593}
1594
1595
1596/* Start an OHCI controller, set the BUS operational
1597* resets USB and controller
1598* enable interrupts
1599*/
1600static int u132_run(struct u132 *u132)
1601{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001602 int retval;
1603 u32 control;
1604 u32 status;
1605 u32 fminterval;
1606 u32 periodicstart;
1607 u32 cmdstatus;
1608 u32 roothub_a;
1609 int mask = OHCI_INTR_INIT;
1610 int first = u132->hc_fminterval == 0;
1611 int sleep_time = 0;
1612 int reset_timeout = 30; /* ... allow extra time */
1613 u132_disable(u132);
1614 if (first) {
1615 u32 temp;
1616 retval = u132_read_pcimem(u132, fminterval, &temp);
1617 if (retval)
1618 return retval;
1619 u132->hc_fminterval = temp & 0x3fff;
1620 u132->hc_fminterval |= FSMP(u132->hc_fminterval) << 16;
1621 }
1622 retval = u132_read_pcimem(u132, control, &u132->hc_control);
1623 if (retval)
1624 return retval;
1625 dev_info(&u132->platform_dev->dev, "resetting from state '%s', control "
1626 "= %08X\n", hcfs2string(u132->hc_control & OHCI_CTRL_HCFS),
1627 u132->hc_control);
1628 switch (u132->hc_control & OHCI_CTRL_HCFS) {
1629 case OHCI_USB_OPER:
1630 sleep_time = 0;
1631 break;
1632 case OHCI_USB_SUSPEND:
1633 case OHCI_USB_RESUME:
1634 u132->hc_control &= OHCI_CTRL_RWC;
1635 u132->hc_control |= OHCI_USB_RESUME;
1636 sleep_time = 10;
1637 break;
1638 default:
1639 u132->hc_control &= OHCI_CTRL_RWC;
1640 u132->hc_control |= OHCI_USB_RESET;
1641 sleep_time = 50;
1642 break;
1643 }
1644 retval = u132_write_pcimem(u132, control, u132->hc_control);
1645 if (retval)
1646 return retval;
1647 retval = u132_read_pcimem(u132, control, &control);
1648 if (retval)
1649 return retval;
1650 msleep(sleep_time);
1651 retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1652 if (retval)
1653 return retval;
1654 if (!(roothub_a & RH_A_NPS)) {
1655 int temp; /* power down each port */
1656 for (temp = 0; temp < u132->num_ports; temp++) {
1657 retval = u132_write_pcimem(u132,
1658 roothub.portstatus[temp], RH_PS_LSDA);
1659 if (retval)
1660 return retval;
1661 }
1662 }
1663 retval = u132_read_pcimem(u132, control, &control);
1664 if (retval)
1665 return retval;
1666retry:
1667 retval = u132_read_pcimem(u132, cmdstatus, &status);
1668 if (retval)
1669 return retval;
1670 retval = u132_write_pcimem(u132, cmdstatus, OHCI_HCR);
1671 if (retval)
1672 return retval;
1673extra: {
1674 retval = u132_read_pcimem(u132, cmdstatus, &status);
1675 if (retval)
1676 return retval;
1677 if (0 != (status & OHCI_HCR)) {
1678 if (--reset_timeout == 0) {
1679 dev_err(&u132->platform_dev->dev, "USB HC reset"
1680 " timed out!\n");
1681 return -ENODEV;
1682 } else {
1683 msleep(5);
1684 goto extra;
1685 }
1686 }
1687 }
1688 if (u132->flags & OHCI_QUIRK_INITRESET) {
1689 retval = u132_write_pcimem(u132, control, u132->hc_control);
1690 if (retval)
1691 return retval;
1692 retval = u132_read_pcimem(u132, control, &control);
1693 if (retval)
1694 return retval;
1695 }
1696 retval = u132_write_pcimem(u132, ed_controlhead, 0x00000000);
1697 if (retval)
1698 return retval;
1699 retval = u132_write_pcimem(u132, ed_bulkhead, 0x11000000);
1700 if (retval)
1701 return retval;
1702 retval = u132_write_pcimem(u132, hcca, 0x00000000);
1703 if (retval)
1704 return retval;
1705 retval = u132_periodic_reinit(u132);
1706 if (retval)
1707 return retval;
1708 retval = u132_read_pcimem(u132, fminterval, &fminterval);
1709 if (retval)
1710 return retval;
1711 retval = u132_read_pcimem(u132, periodicstart, &periodicstart);
1712 if (retval)
1713 return retval;
1714 if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
1715 if (!(u132->flags & OHCI_QUIRK_INITRESET)) {
1716 u132->flags |= OHCI_QUIRK_INITRESET;
1717 goto retry;
1718 } else
1719 dev_err(&u132->platform_dev->dev, "init err(%08x %04x)"
1720 "\n", fminterval, periodicstart);
1721 } /* start controller operations */
1722 u132->hc_control &= OHCI_CTRL_RWC;
1723 u132->hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
1724 retval = u132_write_pcimem(u132, control, u132->hc_control);
1725 if (retval)
1726 return retval;
1727 retval = u132_write_pcimem(u132, cmdstatus, OHCI_BLF);
1728 if (retval)
1729 return retval;
1730 retval = u132_read_pcimem(u132, cmdstatus, &cmdstatus);
1731 if (retval)
1732 return retval;
1733 retval = u132_read_pcimem(u132, control, &control);
1734 if (retval)
1735 return retval;
1736 u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1737 retval = u132_write_pcimem(u132, roothub.status, RH_HS_DRWE);
1738 if (retval)
1739 return retval;
1740 retval = u132_write_pcimem(u132, intrstatus, mask);
1741 if (retval)
1742 return retval;
1743 retval = u132_write_pcimem(u132, intrdisable,
1744 OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
1745 OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
1746 OHCI_INTR_SO);
1747 if (retval)
1748 return retval; /* handle root hub init quirks ... */
1749 retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1750 if (retval)
1751 return retval;
1752 roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
1753 if (u132->flags & OHCI_QUIRK_SUPERIO) {
1754 roothub_a |= RH_A_NOCP;
1755 roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
1756 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1757 if (retval)
1758 return retval;
1759 } else if ((u132->flags & OHCI_QUIRK_AMD756) || distrust_firmware) {
1760 roothub_a |= RH_A_NPS;
1761 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1762 if (retval)
1763 return retval;
1764 }
1765 retval = u132_write_pcimem(u132, roothub.status, RH_HS_LPSC);
1766 if (retval)
1767 return retval;
1768 retval = u132_write_pcimem(u132, roothub.b,
1769 (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
1770 if (retval)
1771 return retval;
1772 retval = u132_read_pcimem(u132, control, &control);
1773 if (retval)
1774 return retval;
1775 mdelay((roothub_a >> 23) & 0x1fe);
1776 u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1777 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01001778}
1779
1780static void u132_hcd_stop(struct usb_hcd *hcd)
1781{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001782 struct u132 *u132 = hcd_to_u132(hcd);
1783 if (u132->going > 1) {
1784 dev_err(&u132->platform_dev->dev, "u132 device %p(hcd=%p) has b"
1785 "een removed %d\n", u132, hcd, u132->going);
1786 } else if (u132->going > 0) {
1787 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
1788 "ed\n", hcd);
1789 } else {
1790 mutex_lock(&u132->sw_lock);
1791 msleep(100);
1792 u132_power(u132, 0);
1793 mutex_unlock(&u132->sw_lock);
1794 }
Tony Olechd774efe2006-09-13 11:27:35 +01001795}
1796
1797static int u132_hcd_start(struct usb_hcd *hcd)
1798{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001799 struct u132 *u132 = hcd_to_u132(hcd);
1800 if (u132->going > 1) {
1801 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1802 , u132->going);
1803 return -ENODEV;
1804 } else if (u132->going > 0) {
1805 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1806 return -ESHUTDOWN;
1807 } else if (hcd->self.controller) {
1808 int retval;
1809 struct platform_device *pdev =
1810 to_platform_device(hcd->self.controller);
1811 u16 vendor = ((struct u132_platform_data *)
1812 (pdev->dev.platform_data))->vendor;
1813 u16 device = ((struct u132_platform_data *)
1814 (pdev->dev.platform_data))->device;
1815 mutex_lock(&u132->sw_lock);
1816 msleep(10);
1817 if (vendor == PCI_VENDOR_ID_AMD && device == 0x740c) {
1818 u132->flags = OHCI_QUIRK_AMD756;
1819 } else if (vendor == PCI_VENDOR_ID_OPTI && device == 0xc861) {
1820 dev_err(&u132->platform_dev->dev, "WARNING: OPTi workar"
1821 "ounds unavailable\n");
1822 } else if (vendor == PCI_VENDOR_ID_COMPAQ && device == 0xa0f8)
1823 u132->flags |= OHCI_QUIRK_ZFMICRO;
1824 retval = u132_run(u132);
1825 if (retval) {
1826 u132_disable(u132);
1827 u132->going = 1;
1828 }
1829 msleep(100);
1830 mutex_unlock(&u132->sw_lock);
1831 return retval;
1832 } else {
1833 dev_err(&u132->platform_dev->dev, "platform_device missing\n");
1834 return -ENODEV;
1835 }
Tony Olechd774efe2006-09-13 11:27:35 +01001836}
1837
1838static int u132_hcd_reset(struct usb_hcd *hcd)
1839{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001840 struct u132 *u132 = hcd_to_u132(hcd);
1841 if (u132->going > 1) {
1842 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1843 , u132->going);
1844 return -ENODEV;
1845 } else if (u132->going > 0) {
1846 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1847 return -ESHUTDOWN;
1848 } else {
1849 int retval;
1850 mutex_lock(&u132->sw_lock);
1851 retval = u132_init(u132);
1852 if (retval) {
1853 u132_disable(u132);
1854 u132->going = 1;
1855 }
1856 mutex_unlock(&u132->sw_lock);
1857 return retval;
1858 }
Tony Olechd774efe2006-09-13 11:27:35 +01001859}
1860
1861static int create_endpoint_and_queue_int(struct u132 *u132,
Alan Sterne9df41c2007-08-08 11:48:02 -04001862 struct u132_udev *udev, struct urb *urb,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001863 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1864 gfp_t mem_flags)
Tony Olechd774efe2006-09-13 11:27:35 +01001865{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001866 struct u132_ring *ring;
Alan Sterne9df41c2007-08-08 11:48:02 -04001867 unsigned long irqs;
1868 int rc;
1869 u8 endp_number;
1870 struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
1871
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001872 if (!endp)
1873 return -ENOMEM;
Alan Sterne9df41c2007-08-08 11:48:02 -04001874
1875 spin_lock_init(&endp->queue_lock.slock);
1876 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1877 rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
1878 if (rc) {
1879 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1880 kfree(endp);
1881 return rc;
1882 }
1883
1884 endp_number = ++u132->num_endpoints;
1885 urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001886 INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
1887 INIT_LIST_HEAD(&endp->urb_more);
1888 ring = endp->ring = &u132->ring[0];
1889 if (ring->curr_endp) {
1890 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
1891 } else {
1892 INIT_LIST_HEAD(&endp->endp_ring);
1893 ring->curr_endp = endp;
1894 }
1895 ring->length += 1;
1896 endp->dequeueing = 0;
1897 endp->edset_flush = 0;
1898 endp->active = 0;
1899 endp->delayed = 0;
1900 endp->endp_number = endp_number;
1901 endp->u132 = u132;
Alan Sterne9df41c2007-08-08 11:48:02 -04001902 endp->hep = urb->ep;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07001903 endp->pipetype = usb_pipetype(urb->pipe);
1904 u132_endp_init_kref(u132, endp);
1905 if (usb_pipein(urb->pipe)) {
1906 endp->toggle_bits = 0x2;
1907 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1908 endp->input = 1;
1909 endp->output = 0;
1910 udev->endp_number_in[usb_endp] = endp_number;
1911 u132_udev_get_kref(u132, udev);
1912 } else {
1913 endp->toggle_bits = 0x2;
1914 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
1915 endp->input = 0;
1916 endp->output = 1;
1917 udev->endp_number_out[usb_endp] = endp_number;
1918 u132_udev_get_kref(u132, udev);
1919 }
1920 urb->hcpriv = u132;
1921 endp->delayed = 1;
1922 endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1923 endp->udev_number = address;
1924 endp->usb_addr = usb_addr;
1925 endp->usb_endp = usb_endp;
1926 endp->queue_size = 1;
1927 endp->queue_last = 0;
1928 endp->queue_next = 0;
1929 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1930 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1931 u132_endp_queue_work(u132, endp, msecs_to_jiffies(urb->interval));
1932 return 0;
1933}
1934
1935static int queue_int_on_old_endpoint(struct u132 *u132,
1936 struct u132_udev *udev, struct urb *urb,
1937 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
1938 u8 usb_endp, u8 address)
1939{
1940 urb->hcpriv = u132;
1941 endp->delayed = 1;
1942 endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1943 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
1944 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1945 } else {
1946 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
1947 GFP_ATOMIC);
1948 if (urbq == NULL) {
1949 endp->queue_size -= 1;
1950 return -ENOMEM;
1951 } else {
1952 list_add_tail(&urbq->urb_more, &endp->urb_more);
1953 urbq->urb = urb;
1954 }
1955 }
1956 return 0;
1957}
1958
1959static int create_endpoint_and_queue_bulk(struct u132 *u132,
1960 struct u132_udev *udev, struct urb *urb,
1961 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1962 gfp_t mem_flags)
1963{
1964 int ring_number;
1965 struct u132_ring *ring;
1966 unsigned long irqs;
1967 int rc;
1968 u8 endp_number;
1969 struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
1970
1971 if (!endp)
1972 return -ENOMEM;
1973
1974 spin_lock_init(&endp->queue_lock.slock);
1975 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1976 rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
1977 if (rc) {
1978 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1979 kfree(endp);
1980 return rc;
1981 }
1982
1983 endp_number = ++u132->num_endpoints;
1984 urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
1985 INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
1986 INIT_LIST_HEAD(&endp->urb_more);
1987 endp->dequeueing = 0;
1988 endp->edset_flush = 0;
1989 endp->active = 0;
1990 endp->delayed = 0;
1991 endp->endp_number = endp_number;
1992 endp->u132 = u132;
1993 endp->hep = urb->ep;
1994 endp->pipetype = usb_pipetype(urb->pipe);
1995 u132_endp_init_kref(u132, endp);
1996 if (usb_pipein(urb->pipe)) {
1997 endp->toggle_bits = 0x2;
1998 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1999 ring_number = 3;
2000 endp->input = 1;
2001 endp->output = 0;
2002 udev->endp_number_in[usb_endp] = endp_number;
2003 u132_udev_get_kref(u132, udev);
2004 } else {
2005 endp->toggle_bits = 0x2;
2006 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
2007 ring_number = 2;
2008 endp->input = 0;
2009 endp->output = 1;
2010 udev->endp_number_out[usb_endp] = endp_number;
2011 u132_udev_get_kref(u132, udev);
2012 }
2013 ring = endp->ring = &u132->ring[ring_number - 1];
2014 if (ring->curr_endp) {
2015 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2016 } else {
2017 INIT_LIST_HEAD(&endp->endp_ring);
2018 ring->curr_endp = endp;
2019 }
2020 ring->length += 1;
2021 urb->hcpriv = u132;
2022 endp->udev_number = address;
2023 endp->usb_addr = usb_addr;
2024 endp->usb_endp = usb_endp;
2025 endp->queue_size = 1;
2026 endp->queue_last = 0;
2027 endp->queue_next = 0;
2028 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2029 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2030 u132_endp_queue_work(u132, endp, 0);
2031 return 0;
2032}
2033
2034static int queue_bulk_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
2035 struct urb *urb,
2036 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2037 u8 usb_endp, u8 address)
2038{
2039 urb->hcpriv = u132;
2040 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2041 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2042 } else {
2043 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
2044 GFP_ATOMIC);
2045 if (urbq == NULL) {
2046 endp->queue_size -= 1;
2047 return -ENOMEM;
2048 } else {
2049 list_add_tail(&urbq->urb_more, &endp->urb_more);
2050 urbq->urb = urb;
2051 }
2052 }
2053 return 0;
2054}
2055
2056static int create_endpoint_and_queue_control(struct u132 *u132,
2057 struct urb *urb,
2058 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp,
2059 gfp_t mem_flags)
2060{
2061 struct u132_ring *ring;
2062 unsigned long irqs;
2063 int rc;
2064 u8 endp_number;
2065 struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
2066
2067 if (!endp)
2068 return -ENOMEM;
2069
2070 spin_lock_init(&endp->queue_lock.slock);
2071 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2072 rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
2073 if (rc) {
2074 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2075 kfree(endp);
2076 return rc;
2077 }
2078
2079 endp_number = ++u132->num_endpoints;
2080 urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
2081 INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
2082 INIT_LIST_HEAD(&endp->urb_more);
2083 ring = endp->ring = &u132->ring[0];
2084 if (ring->curr_endp) {
2085 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2086 } else {
2087 INIT_LIST_HEAD(&endp->endp_ring);
2088 ring->curr_endp = endp;
2089 }
2090 ring->length += 1;
2091 endp->dequeueing = 0;
2092 endp->edset_flush = 0;
2093 endp->active = 0;
2094 endp->delayed = 0;
2095 endp->endp_number = endp_number;
2096 endp->u132 = u132;
2097 endp->hep = urb->ep;
2098 u132_endp_init_kref(u132, endp);
2099 u132_endp_get_kref(u132, endp);
2100 if (usb_addr == 0) {
2101 u8 address = u132->addr[usb_addr].address;
2102 struct u132_udev *udev = &u132->udev[address];
2103 endp->udev_number = address;
2104 endp->usb_addr = usb_addr;
2105 endp->usb_endp = usb_endp;
2106 endp->input = 1;
2107 endp->output = 1;
2108 endp->pipetype = usb_pipetype(urb->pipe);
2109 u132_udev_init_kref(u132, udev);
2110 u132_udev_get_kref(u132, udev);
2111 udev->endp_number_in[usb_endp] = endp_number;
2112 udev->endp_number_out[usb_endp] = endp_number;
2113 urb->hcpriv = u132;
2114 endp->queue_size = 1;
2115 endp->queue_last = 0;
2116 endp->queue_next = 0;
2117 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2118 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2119 u132_endp_queue_work(u132, endp, 0);
2120 return 0;
2121 } else { /*(usb_addr > 0) */
2122 u8 address = u132->addr[usb_addr].address;
2123 struct u132_udev *udev = &u132->udev[address];
2124 endp->udev_number = address;
2125 endp->usb_addr = usb_addr;
2126 endp->usb_endp = usb_endp;
2127 endp->input = 1;
2128 endp->output = 1;
2129 endp->pipetype = usb_pipetype(urb->pipe);
2130 u132_udev_get_kref(u132, udev);
2131 udev->enumeration = 2;
2132 udev->endp_number_in[usb_endp] = endp_number;
2133 udev->endp_number_out[usb_endp] = endp_number;
2134 urb->hcpriv = u132;
2135 endp->queue_size = 1;
2136 endp->queue_last = 0;
2137 endp->queue_next = 0;
2138 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2139 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2140 u132_endp_queue_work(u132, endp, 0);
2141 return 0;
2142 }
Tony Olechd774efe2006-09-13 11:27:35 +01002143}
2144
2145static int queue_control_on_old_endpoint(struct u132 *u132,
Alan Sterne9df41c2007-08-08 11:48:02 -04002146 struct urb *urb,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002147 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2148 u8 usb_endp)
Tony Olechd774efe2006-09-13 11:27:35 +01002149{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002150 if (usb_addr == 0) {
2151 if (usb_pipein(urb->pipe)) {
2152 urb->hcpriv = u132;
2153 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2154 endp->urb_list[ENDP_QUEUE_MASK &
2155 endp->queue_last++] = urb;
2156 } else {
2157 struct u132_urbq *urbq =
2158 kmalloc(sizeof(struct u132_urbq),
2159 GFP_ATOMIC);
2160 if (urbq == NULL) {
2161 endp->queue_size -= 1;
2162 return -ENOMEM;
2163 } else {
2164 list_add_tail(&urbq->urb_more,
2165 &endp->urb_more);
2166 urbq->urb = urb;
2167 }
2168 }
2169 return 0;
2170 } else { /* usb_pipeout(urb->pipe) */
2171 struct u132_addr *addr = &u132->addr[usb_dev->devnum];
2172 int I = MAX_U132_UDEVS;
2173 int i = 0;
2174 while (--I > 0) {
2175 struct u132_udev *udev = &u132->udev[++i];
2176 if (udev->usb_device) {
2177 continue;
2178 } else {
2179 udev->enumeration = 1;
2180 u132->addr[0].address = i;
2181 endp->udev_number = i;
2182 udev->udev_number = i;
2183 udev->usb_addr = usb_dev->devnum;
2184 u132_udev_init_kref(u132, udev);
2185 udev->endp_number_in[usb_endp] =
2186 endp->endp_number;
2187 u132_udev_get_kref(u132, udev);
2188 udev->endp_number_out[usb_endp] =
2189 endp->endp_number;
2190 udev->usb_device = usb_dev;
2191 ((u8 *) (urb->setup_packet))[2] =
2192 addr->address = i;
2193 u132_udev_get_kref(u132, udev);
2194 break;
2195 }
2196 }
2197 if (I == 0) {
2198 dev_err(&u132->platform_dev->dev, "run out of d"
2199 "evice space\n");
2200 return -EINVAL;
2201 }
2202 urb->hcpriv = u132;
2203 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2204 endp->urb_list[ENDP_QUEUE_MASK &
2205 endp->queue_last++] = urb;
2206 } else {
2207 struct u132_urbq *urbq =
2208 kmalloc(sizeof(struct u132_urbq),
2209 GFP_ATOMIC);
2210 if (urbq == NULL) {
2211 endp->queue_size -= 1;
2212 return -ENOMEM;
2213 } else {
2214 list_add_tail(&urbq->urb_more,
2215 &endp->urb_more);
2216 urbq->urb = urb;
2217 }
2218 }
2219 return 0;
2220 }
2221 } else { /*(usb_addr > 0) */
2222 u8 address = u132->addr[usb_addr].address;
2223 struct u132_udev *udev = &u132->udev[address];
2224 urb->hcpriv = u132;
2225 if (udev->enumeration != 2)
2226 udev->enumeration = 2;
2227 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2228 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
2229 urb;
2230 } else {
2231 struct u132_urbq *urbq =
2232 kmalloc(sizeof(struct u132_urbq), GFP_ATOMIC);
2233 if (urbq == NULL) {
2234 endp->queue_size -= 1;
2235 return -ENOMEM;
2236 } else {
2237 list_add_tail(&urbq->urb_more, &endp->urb_more);
2238 urbq->urb = urb;
2239 }
2240 }
2241 return 0;
2242 }
Tony Olechd774efe2006-09-13 11:27:35 +01002243}
2244
Alan Sterne9df41c2007-08-08 11:48:02 -04002245static int u132_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
2246 gfp_t mem_flags)
Tony Olechd774efe2006-09-13 11:27:35 +01002247{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002248 struct u132 *u132 = hcd_to_u132(hcd);
2249 if (irqs_disabled()) {
2250 if (__GFP_WAIT & mem_flags) {
2251 printk(KERN_ERR "invalid context for function that migh"
2252 "t sleep\n");
2253 return -EINVAL;
2254 }
2255 }
2256 if (u132->going > 1) {
2257 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2258 , u132->going);
2259 return -ENODEV;
2260 } else if (u132->going > 0) {
Alan Sterneb231052007-08-21 15:40:36 -04002261 dev_err(&u132->platform_dev->dev, "device is being removed "
2262 "urb=%p\n", urb);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002263 return -ESHUTDOWN;
2264 } else {
2265 u8 usb_addr = usb_pipedevice(urb->pipe);
2266 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2267 struct usb_device *usb_dev = urb->dev;
2268 if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
2269 u8 address = u132->addr[usb_addr].address;
2270 struct u132_udev *udev = &u132->udev[address];
2271 struct u132_endp *endp = urb->ep->hcpriv;
2272 urb->actual_length = 0;
2273 if (endp) {
2274 unsigned long irqs;
2275 int retval;
2276 spin_lock_irqsave(&endp->queue_lock.slock,
2277 irqs);
Alan Sterne9df41c2007-08-08 11:48:02 -04002278 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2279 if (retval == 0) {
2280 retval = queue_int_on_old_endpoint(
2281 u132, udev, urb,
2282 usb_dev, endp,
2283 usb_addr, usb_endp,
2284 address);
2285 if (retval)
2286 usb_hcd_unlink_urb_from_ep(
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002287 hcd, urb);
Alan Sterne9df41c2007-08-08 11:48:02 -04002288 }
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002289 spin_unlock_irqrestore(&endp->queue_lock.slock,
2290 irqs);
2291 if (retval) {
2292 return retval;
2293 } else {
2294 u132_endp_queue_work(u132, endp,
2295 msecs_to_jiffies(urb->interval))
2296 ;
2297 return 0;
2298 }
2299 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2300 return -EINVAL;
2301 } else { /*(endp == NULL) */
2302 return create_endpoint_and_queue_int(u132, udev,
Alan Sterne9df41c2007-08-08 11:48:02 -04002303 urb, usb_dev, usb_addr,
2304 usb_endp, address, mem_flags);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002305 }
2306 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
2307 dev_err(&u132->platform_dev->dev, "the hardware does no"
2308 "t support PIPE_ISOCHRONOUS\n");
2309 return -EINVAL;
2310 } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
2311 u8 address = u132->addr[usb_addr].address;
2312 struct u132_udev *udev = &u132->udev[address];
2313 struct u132_endp *endp = urb->ep->hcpriv;
2314 urb->actual_length = 0;
2315 if (endp) {
2316 unsigned long irqs;
2317 int retval;
2318 spin_lock_irqsave(&endp->queue_lock.slock,
2319 irqs);
Alan Sterne9df41c2007-08-08 11:48:02 -04002320 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2321 if (retval == 0) {
2322 retval = queue_bulk_on_old_endpoint(
2323 u132, udev, urb,
2324 usb_dev, endp,
2325 usb_addr, usb_endp,
2326 address);
2327 if (retval)
2328 usb_hcd_unlink_urb_from_ep(
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002329 hcd, urb);
Alan Sterne9df41c2007-08-08 11:48:02 -04002330 }
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002331 spin_unlock_irqrestore(&endp->queue_lock.slock,
2332 irqs);
2333 if (retval) {
2334 return retval;
2335 } else {
2336 u132_endp_queue_work(u132, endp, 0);
2337 return 0;
2338 }
2339 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2340 return -EINVAL;
2341 } else
2342 return create_endpoint_and_queue_bulk(u132,
Alan Sterne9df41c2007-08-08 11:48:02 -04002343 udev, urb, usb_dev, usb_addr,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002344 usb_endp, address, mem_flags);
2345 } else {
2346 struct u132_endp *endp = urb->ep->hcpriv;
2347 u16 urb_size = 8;
2348 u8 *b = urb->setup_packet;
2349 int i = 0;
2350 char data[30 * 3 + 4];
2351 char *d = data;
2352 int m = (sizeof(data) - 1) / 3;
2353 int l = 0;
2354 data[0] = 0;
2355 while (urb_size-- > 0) {
2356 if (i > m) {
2357 } else if (i++ < m) {
2358 int w = sprintf(d, " %02X", *b++);
2359 d += w;
2360 l += w;
2361 } else
2362 d += sprintf(d, " ..");
2363 }
2364 if (endp) {
2365 unsigned long irqs;
2366 int retval;
2367 spin_lock_irqsave(&endp->queue_lock.slock,
2368 irqs);
Alan Sterne9df41c2007-08-08 11:48:02 -04002369 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2370 if (retval == 0) {
2371 retval = queue_control_on_old_endpoint(
2372 u132, urb, usb_dev,
2373 endp, usb_addr,
2374 usb_endp);
2375 if (retval)
2376 usb_hcd_unlink_urb_from_ep(
2377 hcd, urb);
2378 }
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002379 spin_unlock_irqrestore(&endp->queue_lock.slock,
2380 irqs);
2381 if (retval) {
2382 return retval;
2383 } else {
2384 u132_endp_queue_work(u132, endp, 0);
2385 return 0;
2386 }
2387 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2388 return -EINVAL;
2389 } else
2390 return create_endpoint_and_queue_control(u132,
Alan Sterne9df41c2007-08-08 11:48:02 -04002391 urb, usb_dev, usb_addr, usb_endp,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002392 mem_flags);
2393 }
2394 }
Tony Olechd774efe2006-09-13 11:27:35 +01002395}
2396
2397static int dequeue_from_overflow_chain(struct u132 *u132,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002398 struct u132_endp *endp, struct urb *urb)
Tony Olechd774efe2006-09-13 11:27:35 +01002399{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002400 struct list_head *scan;
2401 struct list_head *head = &endp->urb_more;
2402 list_for_each(scan, head) {
2403 struct u132_urbq *urbq = list_entry(scan, struct u132_urbq,
2404 urb_more);
2405 if (urbq->urb == urb) {
2406 struct usb_hcd *hcd = u132_to_hcd(u132);
2407 list_del(scan);
2408 endp->queue_size -= 1;
2409 urb->error_count = 0;
Alan Stern4a000272007-08-24 15:42:24 -04002410 usb_hcd_giveback_urb(hcd, urb, 0);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002411 return 0;
2412 } else
2413 continue;
2414 }
2415 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]=%p ring"
2416 "[%d] %c%c usb_endp=%d usb_addr=%d size=%d next=%04X last=%04X"
2417 "\n", urb, endp->endp_number, endp, endp->ring->number,
2418 endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2419 endp->usb_endp, endp->usb_addr, endp->queue_size,
2420 endp->queue_next, endp->queue_last);
2421 return -EINVAL;
Tony Olechd774efe2006-09-13 11:27:35 +01002422}
2423
2424static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
Alan Sterne9df41c2007-08-08 11:48:02 -04002425 struct urb *urb, int status)
Tony Olechd774efe2006-09-13 11:27:35 +01002426{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002427 unsigned long irqs;
Alan Sterne9df41c2007-08-08 11:48:02 -04002428 int rc;
2429
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002430 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
Alan Sterne9df41c2007-08-08 11:48:02 -04002431 rc = usb_hcd_check_unlink_urb(u132_to_hcd(u132), urb, status);
2432 if (rc) {
2433 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2434 return rc;
2435 }
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002436 if (endp->queue_size == 0) {
2437 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]"
2438 "=%p ring[%d] %c%c usb_endp=%d usb_addr=%d\n", urb,
2439 endp->endp_number, endp, endp->ring->number,
2440 endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2441 endp->usb_endp, endp->usb_addr);
2442 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2443 return -EINVAL;
2444 }
2445 if (urb == endp->urb_list[ENDP_QUEUE_MASK & endp->queue_next]) {
2446 if (endp->active) {
2447 endp->dequeueing = 1;
2448 endp->edset_flush = 1;
2449 u132_endp_queue_work(u132, endp, 0);
2450 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2451 return 0;
2452 } else {
2453 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
Alan Stern4a000272007-08-24 15:42:24 -04002454 u132_hcd_abandon_urb(u132, endp, urb, status);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002455 return 0;
2456 }
2457 } else {
2458 u16 queue_list = 0;
2459 u16 queue_size = endp->queue_size;
2460 u16 queue_scan = endp->queue_next;
2461 struct urb **urb_slot = NULL;
2462 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2463 if (urb == endp->urb_list[ENDP_QUEUE_MASK &
2464 ++queue_scan]) {
2465 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2466 queue_scan];
2467 break;
2468 } else
2469 continue;
2470 }
2471 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2472 *urb_slot = endp->urb_list[ENDP_QUEUE_MASK &
2473 ++queue_scan];
2474 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2475 queue_scan];
2476 }
2477 if (urb_slot) {
2478 struct usb_hcd *hcd = u132_to_hcd(u132);
Alan Sterne9df41c2007-08-08 11:48:02 -04002479
2480 usb_hcd_unlink_urb_from_ep(hcd, urb);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002481 endp->queue_size -= 1;
2482 if (list_empty(&endp->urb_more)) {
2483 spin_unlock_irqrestore(&endp->queue_lock.slock,
2484 irqs);
2485 } else {
2486 struct list_head *next = endp->urb_more.next;
2487 struct u132_urbq *urbq = list_entry(next,
2488 struct u132_urbq, urb_more);
2489 list_del(next);
2490 *urb_slot = urbq->urb;
2491 spin_unlock_irqrestore(&endp->queue_lock.slock,
2492 irqs);
2493 kfree(urbq);
2494 } urb->error_count = 0;
Alan Stern4a000272007-08-24 15:42:24 -04002495 usb_hcd_giveback_urb(hcd, urb, status);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002496 return 0;
2497 } else if (list_empty(&endp->urb_more)) {
2498 dev_err(&u132->platform_dev->dev, "urb=%p not found in "
2499 "endp[%d]=%p ring[%d] %c%c usb_endp=%d usb_addr"
2500 "=%d size=%d next=%04X last=%04X\n", urb,
2501 endp->endp_number, endp, endp->ring->number,
2502 endp->input ? 'I' : ' ',
2503 endp->output ? 'O' : ' ', endp->usb_endp,
2504 endp->usb_addr, endp->queue_size,
2505 endp->queue_next, endp->queue_last);
2506 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2507 return -EINVAL;
2508 } else {
Alan Sterne9df41c2007-08-08 11:48:02 -04002509 int retval;
2510
2511 usb_hcd_unlink_urb_from_ep(u132_to_hcd(u132), urb);
2512 retval = dequeue_from_overflow_chain(u132, endp,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002513 urb);
2514 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2515 return retval;
2516 }
2517 }
Tony Olechd774efe2006-09-13 11:27:35 +01002518}
2519
Alan Sterne9df41c2007-08-08 11:48:02 -04002520static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
Tony Olechd774efe2006-09-13 11:27:35 +01002521{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002522 struct u132 *u132 = hcd_to_u132(hcd);
2523 if (u132->going > 2) {
2524 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2525 , u132->going);
2526 return -ENODEV;
2527 } else {
2528 u8 usb_addr = usb_pipedevice(urb->pipe);
2529 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2530 u8 address = u132->addr[usb_addr].address;
2531 struct u132_udev *udev = &u132->udev[address];
2532 if (usb_pipein(urb->pipe)) {
2533 u8 endp_number = udev->endp_number_in[usb_endp];
2534 struct u132_endp *endp = u132->endp[endp_number - 1];
2535 return u132_endp_urb_dequeue(u132, endp, urb, status);
2536 } else {
2537 u8 endp_number = udev->endp_number_out[usb_endp];
2538 struct u132_endp *endp = u132->endp[endp_number - 1];
2539 return u132_endp_urb_dequeue(u132, endp, urb, status);
2540 }
2541 }
Tony Olechd774efe2006-09-13 11:27:35 +01002542}
2543
2544static void u132_endpoint_disable(struct usb_hcd *hcd,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002545 struct usb_host_endpoint *hep)
Tony Olechd774efe2006-09-13 11:27:35 +01002546{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002547 struct u132 *u132 = hcd_to_u132(hcd);
2548 if (u132->going > 2) {
2549 dev_err(&u132->platform_dev->dev, "u132 device %p(hcd=%p hep=%p"
2550 ") has been removed %d\n", u132, hcd, hep,
2551 u132->going);
2552 } else {
2553 struct u132_endp *endp = hep->hcpriv;
2554 if (endp)
2555 u132_endp_put_kref(u132, endp);
2556 }
Tony Olechd774efe2006-09-13 11:27:35 +01002557}
2558
2559static int u132_get_frame(struct usb_hcd *hcd)
2560{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002561 struct u132 *u132 = hcd_to_u132(hcd);
2562 if (u132->going > 1) {
2563 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2564 , u132->going);
2565 return -ENODEV;
2566 } else if (u132->going > 0) {
2567 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2568 return -ESHUTDOWN;
2569 } else {
2570 int frame = 0;
2571 dev_err(&u132->platform_dev->dev, "TODO: u132_get_frame\n");
2572 msleep(100);
2573 return frame;
2574 }
Tony Olechd774efe2006-09-13 11:27:35 +01002575}
2576
2577static int u132_roothub_descriptor(struct u132 *u132,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002578 struct usb_hub_descriptor *desc)
Tony Olechd774efe2006-09-13 11:27:35 +01002579{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002580 int retval;
2581 u16 temp;
2582 u32 rh_a = -1;
2583 u32 rh_b = -1;
2584 retval = u132_read_pcimem(u132, roothub.a, &rh_a);
2585 if (retval)
2586 return retval;
2587 desc->bDescriptorType = 0x29;
2588 desc->bPwrOn2PwrGood = (rh_a & RH_A_POTPGT) >> 24;
2589 desc->bHubContrCurrent = 0;
2590 desc->bNbrPorts = u132->num_ports;
2591 temp = 1 + (u132->num_ports / 8);
2592 desc->bDescLength = 7 + 2 * temp;
2593 temp = 0;
2594 if (rh_a & RH_A_NPS)
2595 temp |= 0x0002;
2596 if (rh_a & RH_A_PSM)
2597 temp |= 0x0001;
2598 if (rh_a & RH_A_NOCP)
2599 temp |= 0x0010;
2600 else if (rh_a & RH_A_OCPM)
2601 temp |= 0x0008;
2602 desc->wHubCharacteristics = cpu_to_le16(temp);
2603 retval = u132_read_pcimem(u132, roothub.b, &rh_b);
2604 if (retval)
2605 return retval;
John Youndbe79bb2001-09-17 00:00:00 -07002606 memset(desc->u.hs.DeviceRemovable, 0xff,
2607 sizeof(desc->u.hs.DeviceRemovable));
2608 desc->u.hs.DeviceRemovable[0] = rh_b & RH_B_DR;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002609 if (u132->num_ports > 7) {
John Youndbe79bb2001-09-17 00:00:00 -07002610 desc->u.hs.DeviceRemovable[1] = (rh_b & RH_B_DR) >> 8;
2611 desc->u.hs.DeviceRemovable[2] = 0xff;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002612 } else
John Youndbe79bb2001-09-17 00:00:00 -07002613 desc->u.hs.DeviceRemovable[1] = 0xff;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002614 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01002615}
2616
2617static int u132_roothub_status(struct u132 *u132, __le32 *desc)
2618{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002619 u32 rh_status = -1;
2620 int ret_status = u132_read_pcimem(u132, roothub.status, &rh_status);
2621 *desc = cpu_to_le32(rh_status);
2622 return ret_status;
Tony Olechd774efe2006-09-13 11:27:35 +01002623}
2624
2625static int u132_roothub_portstatus(struct u132 *u132, __le32 *desc, u16 wIndex)
2626{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002627 if (wIndex == 0 || wIndex > u132->num_ports) {
2628 return -EINVAL;
2629 } else {
2630 int port = wIndex - 1;
2631 u32 rh_portstatus = -1;
2632 int ret_portstatus = u132_read_pcimem(u132,
2633 roothub.portstatus[port], &rh_portstatus);
2634 *desc = cpu_to_le32(rh_portstatus);
2635 if (*(u16 *) (desc + 2)) {
2636 dev_info(&u132->platform_dev->dev, "Port %d Status Chan"
2637 "ge = %08X\n", port, *desc);
2638 }
2639 return ret_portstatus;
2640 }
Tony Olechd774efe2006-09-13 11:27:35 +01002641}
2642
2643
2644/* this timer value might be vendor-specific ... */
2645#define PORT_RESET_HW_MSEC 10
2646#define PORT_RESET_MSEC 10
2647/* wrap-aware logic morphed from <linux/jiffies.h> */
2648#define tick_before(t1, t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
2649static int u132_roothub_portreset(struct u132 *u132, int port_index)
2650{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002651 int retval;
2652 u32 fmnumber;
2653 u16 now;
2654 u16 reset_done;
2655 retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2656 if (retval)
2657 return retval;
2658 now = fmnumber;
2659 reset_done = now + PORT_RESET_MSEC;
2660 do {
2661 u32 portstat;
2662 do {
2663 retval = u132_read_pcimem(u132,
2664 roothub.portstatus[port_index], &portstat);
2665 if (retval)
2666 return retval;
2667 if (RH_PS_PRS & portstat)
2668 continue;
2669 else
2670 break;
2671 } while (tick_before(now, reset_done));
2672 if (RH_PS_PRS & portstat)
2673 return -ENODEV;
2674 if (RH_PS_CCS & portstat) {
2675 if (RH_PS_PRSC & portstat) {
2676 retval = u132_write_pcimem(u132,
2677 roothub.portstatus[port_index],
2678 RH_PS_PRSC);
2679 if (retval)
2680 return retval;
2681 }
2682 } else
2683 break; /* start the next reset,
2684 sleep till it's probably done */
2685 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2686 RH_PS_PRS);
2687 if (retval)
2688 return retval;
2689 msleep(PORT_RESET_HW_MSEC);
2690 retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2691 if (retval)
2692 return retval;
2693 now = fmnumber;
2694 } while (tick_before(now, reset_done));
2695 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01002696}
2697
2698static int u132_roothub_setportfeature(struct u132 *u132, u16 wValue,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002699 u16 wIndex)
Tony Olechd774efe2006-09-13 11:27:35 +01002700{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002701 if (wIndex == 0 || wIndex > u132->num_ports) {
2702 return -EINVAL;
2703 } else {
2704 int retval;
2705 int port_index = wIndex - 1;
2706 struct u132_port *port = &u132->port[port_index];
2707 port->Status &= ~(1 << wValue);
2708 switch (wValue) {
2709 case USB_PORT_FEAT_SUSPEND:
2710 retval = u132_write_pcimem(u132,
2711 roothub.portstatus[port_index], RH_PS_PSS);
2712 if (retval)
2713 return retval;
2714 return 0;
2715 case USB_PORT_FEAT_POWER:
2716 retval = u132_write_pcimem(u132,
2717 roothub.portstatus[port_index], RH_PS_PPS);
2718 if (retval)
2719 return retval;
2720 return 0;
2721 case USB_PORT_FEAT_RESET:
2722 retval = u132_roothub_portreset(u132, port_index);
2723 if (retval)
2724 return retval;
2725 return 0;
2726 default:
2727 return -EPIPE;
2728 }
2729 }
Tony Olechd774efe2006-09-13 11:27:35 +01002730}
2731
2732static int u132_roothub_clearportfeature(struct u132 *u132, u16 wValue,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002733 u16 wIndex)
Tony Olechd774efe2006-09-13 11:27:35 +01002734{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002735 if (wIndex == 0 || wIndex > u132->num_ports) {
2736 return -EINVAL;
2737 } else {
2738 int port_index = wIndex - 1;
2739 u32 temp;
2740 int retval;
2741 struct u132_port *port = &u132->port[port_index];
2742 port->Status &= ~(1 << wValue);
2743 switch (wValue) {
2744 case USB_PORT_FEAT_ENABLE:
2745 temp = RH_PS_CCS;
2746 break;
2747 case USB_PORT_FEAT_C_ENABLE:
2748 temp = RH_PS_PESC;
2749 break;
2750 case USB_PORT_FEAT_SUSPEND:
2751 temp = RH_PS_POCI;
2752 if ((u132->hc_control & OHCI_CTRL_HCFS)
2753 != OHCI_USB_OPER) {
2754 dev_err(&u132->platform_dev->dev, "TODO resume_"
2755 "root_hub\n");
2756 }
2757 break;
2758 case USB_PORT_FEAT_C_SUSPEND:
2759 temp = RH_PS_PSSC;
2760 break;
2761 case USB_PORT_FEAT_POWER:
2762 temp = RH_PS_LSDA;
2763 break;
2764 case USB_PORT_FEAT_C_CONNECTION:
2765 temp = RH_PS_CSC;
2766 break;
2767 case USB_PORT_FEAT_C_OVER_CURRENT:
2768 temp = RH_PS_OCIC;
2769 break;
2770 case USB_PORT_FEAT_C_RESET:
2771 temp = RH_PS_PRSC;
2772 break;
2773 default:
2774 return -EPIPE;
2775 }
2776 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2777 temp);
2778 if (retval)
2779 return retval;
2780 return 0;
2781 }
Tony Olechd774efe2006-09-13 11:27:35 +01002782}
2783
2784
2785/* the virtual root hub timer IRQ checks for hub status*/
2786static int u132_hub_status_data(struct usb_hcd *hcd, char *buf)
2787{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002788 struct u132 *u132 = hcd_to_u132(hcd);
2789 if (u132->going > 1) {
2790 dev_err(&u132->platform_dev->dev, "device hcd=%p has been remov"
2791 "ed %d\n", hcd, u132->going);
2792 return -ENODEV;
2793 } else if (u132->going > 0) {
2794 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
2795 "ed\n", hcd);
2796 return -ESHUTDOWN;
2797 } else {
2798 int i, changed = 0, length = 1;
2799 if (u132->flags & OHCI_QUIRK_AMD756) {
2800 if ((u132->hc_roothub_a & RH_A_NDP) > MAX_ROOT_PORTS) {
2801 dev_err(&u132->platform_dev->dev, "bogus NDP, r"
2802 "ereads as NDP=%d\n",
2803 u132->hc_roothub_a & RH_A_NDP);
2804 goto done;
2805 }
2806 }
2807 if (u132->hc_roothub_status & (RH_HS_LPSC | RH_HS_OCIC))
2808 buf[0] = changed = 1;
2809 else
2810 buf[0] = 0;
2811 if (u132->num_ports > 7) {
2812 buf[1] = 0;
2813 length++;
2814 }
2815 for (i = 0; i < u132->num_ports; i++) {
2816 if (u132->hc_roothub_portstatus[i] & (RH_PS_CSC |
2817 RH_PS_PESC | RH_PS_PSSC | RH_PS_OCIC |
2818 RH_PS_PRSC)) {
2819 changed = 1;
2820 if (i < 7)
2821 buf[0] |= 1 << (i + 1);
2822 else
2823 buf[1] |= 1 << (i - 7);
2824 continue;
2825 }
2826 if (!(u132->hc_roothub_portstatus[i] & RH_PS_CCS))
2827 continue;
2828
2829 if ((u132->hc_roothub_portstatus[i] & RH_PS_PSS))
2830 continue;
2831 }
2832done:
2833 return changed ? length : 0;
2834 }
Tony Olechd774efe2006-09-13 11:27:35 +01002835}
2836
2837static int u132_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002838 u16 wIndex, char *buf, u16 wLength)
Tony Olechd774efe2006-09-13 11:27:35 +01002839{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002840 struct u132 *u132 = hcd_to_u132(hcd);
2841 if (u132->going > 1) {
2842 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2843 , u132->going);
2844 return -ENODEV;
2845 } else if (u132->going > 0) {
2846 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2847 return -ESHUTDOWN;
2848 } else {
2849 int retval = 0;
2850 mutex_lock(&u132->sw_lock);
2851 switch (typeReq) {
2852 case ClearHubFeature:
2853 switch (wValue) {
2854 case C_HUB_OVER_CURRENT:
2855 case C_HUB_LOCAL_POWER:
2856 break;
2857 default:
2858 goto stall;
2859 }
2860 break;
2861 case SetHubFeature:
2862 switch (wValue) {
2863 case C_HUB_OVER_CURRENT:
2864 case C_HUB_LOCAL_POWER:
2865 break;
2866 default:
2867 goto stall;
2868 }
2869 break;
2870 case ClearPortFeature:{
2871 retval = u132_roothub_clearportfeature(u132,
2872 wValue, wIndex);
2873 if (retval)
2874 goto error;
2875 break;
2876 }
2877 case GetHubDescriptor:{
2878 retval = u132_roothub_descriptor(u132,
2879 (struct usb_hub_descriptor *)buf);
2880 if (retval)
2881 goto error;
2882 break;
2883 }
2884 case GetHubStatus:{
2885 retval = u132_roothub_status(u132,
2886 (__le32 *) buf);
2887 if (retval)
2888 goto error;
2889 break;
2890 }
2891 case GetPortStatus:{
2892 retval = u132_roothub_portstatus(u132,
2893 (__le32 *) buf, wIndex);
2894 if (retval)
2895 goto error;
2896 break;
2897 }
2898 case SetPortFeature:{
2899 retval = u132_roothub_setportfeature(u132,
2900 wValue, wIndex);
2901 if (retval)
2902 goto error;
2903 break;
2904 }
2905 default:
2906 goto stall;
2907 error:
2908 u132_disable(u132);
2909 u132->going = 1;
2910 break;
2911 stall:
2912 retval = -EPIPE;
2913 break;
2914 }
2915 mutex_unlock(&u132->sw_lock);
2916 return retval;
2917 }
Tony Olechd774efe2006-09-13 11:27:35 +01002918}
2919
2920static int u132_start_port_reset(struct usb_hcd *hcd, unsigned port_num)
2921{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002922 struct u132 *u132 = hcd_to_u132(hcd);
2923 if (u132->going > 1) {
2924 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2925 , u132->going);
2926 return -ENODEV;
2927 } else if (u132->going > 0) {
2928 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2929 return -ESHUTDOWN;
2930 } else
2931 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01002932}
2933
Tony Olechd774efe2006-09-13 11:27:35 +01002934
2935#ifdef CONFIG_PM
Tony Olechd774efe2006-09-13 11:27:35 +01002936static int u132_bus_suspend(struct usb_hcd *hcd)
2937{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002938 struct u132 *u132 = hcd_to_u132(hcd);
2939 if (u132->going > 1) {
2940 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2941 , u132->going);
2942 return -ENODEV;
2943 } else if (u132->going > 0) {
2944 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2945 return -ESHUTDOWN;
2946 } else
2947 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01002948}
2949
2950static int u132_bus_resume(struct usb_hcd *hcd)
2951{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002952 struct u132 *u132 = hcd_to_u132(hcd);
2953 if (u132->going > 1) {
2954 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2955 , u132->going);
2956 return -ENODEV;
2957 } else if (u132->going > 0) {
2958 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2959 return -ESHUTDOWN;
2960 } else
2961 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01002962}
2963
2964#else
Tony Olechd774efe2006-09-13 11:27:35 +01002965#define u132_bus_suspend NULL
2966#define u132_bus_resume NULL
2967#endif
2968static struct hc_driver u132_hc_driver = {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002969 .description = hcd_name,
2970 .hcd_priv_size = sizeof(struct u132),
2971 .irq = NULL,
2972 .flags = HCD_USB11 | HCD_MEMORY,
2973 .reset = u132_hcd_reset,
2974 .start = u132_hcd_start,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002975 .stop = u132_hcd_stop,
2976 .urb_enqueue = u132_urb_enqueue,
2977 .urb_dequeue = u132_urb_dequeue,
2978 .endpoint_disable = u132_endpoint_disable,
2979 .get_frame_number = u132_get_frame,
2980 .hub_status_data = u132_hub_status_data,
2981 .hub_control = u132_hub_control,
2982 .bus_suspend = u132_bus_suspend,
2983 .bus_resume = u132_bus_resume,
2984 .start_port_reset = u132_start_port_reset,
Tony Olechd774efe2006-09-13 11:27:35 +01002985};
2986
2987/*
2988* This function may be called by the USB core whilst the "usb_all_devices_rwsem"
2989* is held for writing, thus this module must not call usb_remove_hcd()
2990* synchronously - but instead should immediately stop activity to the
Matt LaPlante0779bf22006-11-30 05:24:39 +01002991* device and asynchronously call usb_remove_hcd()
Tony Olechd774efe2006-09-13 11:27:35 +01002992*/
Bill Pembertonfb4e98a2012-11-19 13:26:20 -05002993static int u132_remove(struct platform_device *pdev)
Tony Olechd774efe2006-09-13 11:27:35 +01002994{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07002995 struct usb_hcd *hcd = platform_get_drvdata(pdev);
2996 if (hcd) {
2997 struct u132 *u132 = hcd_to_u132(hcd);
2998 if (u132->going++ > 1) {
2999 dev_err(&u132->platform_dev->dev, "already being remove"
Tony Olech4b873612006-12-06 13:16:22 +00003000 "d\n");
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003001 return -ENODEV;
3002 } else {
3003 int rings = MAX_U132_RINGS;
3004 int endps = MAX_U132_ENDPS;
3005 dev_err(&u132->platform_dev->dev, "removing device u132"
Tony Olech4b873612006-12-06 13:16:22 +00003006 ".%d\n", u132->sequence_num);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003007 msleep(100);
3008 mutex_lock(&u132->sw_lock);
3009 u132_monitor_cancel_work(u132);
3010 while (rings-- > 0) {
3011 struct u132_ring *ring = &u132->ring[rings];
3012 u132_ring_cancel_work(u132, ring);
3013 } while (endps-- > 0) {
3014 struct u132_endp *endp = u132->endp[endps];
3015 if (endp)
3016 u132_endp_cancel_work(u132, endp);
3017 }
3018 u132->going += 1;
3019 printk(KERN_INFO "removing device u132.%d\n",
3020 u132->sequence_num);
3021 mutex_unlock(&u132->sw_lock);
3022 usb_remove_hcd(hcd);
3023 u132_u132_put_kref(u132);
3024 return 0;
3025 }
3026 } else
3027 return 0;
Tony Olechd774efe2006-09-13 11:27:35 +01003028}
3029
3030static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
3031{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003032 int rings = MAX_U132_RINGS;
3033 int ports = MAX_U132_PORTS;
3034 int addrs = MAX_U132_ADDRS;
3035 int udevs = MAX_U132_UDEVS;
3036 int endps = MAX_U132_ENDPS;
3037 u132->board = pdev->dev.platform_data;
3038 u132->platform_dev = pdev;
3039 u132->power = 0;
3040 u132->reset = 0;
3041 mutex_init(&u132->sw_lock);
Daniel Walker50d8ca92008-03-23 00:00:02 -07003042 mutex_init(&u132->scheduler_lock);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003043 while (rings-- > 0) {
3044 struct u132_ring *ring = &u132->ring[rings];
3045 ring->u132 = u132;
3046 ring->number = rings + 1;
3047 ring->length = 0;
3048 ring->curr_endp = NULL;
3049 INIT_DELAYED_WORK(&ring->scheduler,
David Howellsc4028952006-11-22 14:57:56 +00003050 u132_hcd_ring_work_scheduler);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003051 }
3052 mutex_lock(&u132->sw_lock);
3053 INIT_DELAYED_WORK(&u132->monitor, u132_hcd_monitor_work);
3054 while (ports-- > 0) {
3055 struct u132_port *port = &u132->port[ports];
3056 port->u132 = u132;
3057 port->reset = 0;
3058 port->enable = 0;
3059 port->power = 0;
3060 port->Status = 0;
3061 }
3062 while (addrs-- > 0) {
3063 struct u132_addr *addr = &u132->addr[addrs];
3064 addr->address = 0;
3065 }
3066 while (udevs-- > 0) {
3067 struct u132_udev *udev = &u132->udev[udevs];
3068 int i = ARRAY_SIZE(udev->endp_number_in);
3069 int o = ARRAY_SIZE(udev->endp_number_out);
3070 udev->usb_device = NULL;
3071 udev->udev_number = 0;
3072 udev->usb_addr = 0;
3073 udev->portnumber = 0;
3074 while (i-- > 0)
3075 udev->endp_number_in[i] = 0;
3076
3077 while (o-- > 0)
3078 udev->endp_number_out[o] = 0;
3079
3080 }
3081 while (endps-- > 0)
3082 u132->endp[endps] = NULL;
3083
3084 mutex_unlock(&u132->sw_lock);
Tony Olechd774efe2006-09-13 11:27:35 +01003085}
3086
Bill Pemberton41ac7b32012-11-19 13:21:48 -05003087static int u132_probe(struct platform_device *pdev)
Tony Olechd774efe2006-09-13 11:27:35 +01003088{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003089 struct usb_hcd *hcd;
3090 int retval;
3091 u32 control;
3092 u32 rh_a = -1;
3093 u32 num_ports;
3094
3095 msleep(100);
3096 if (u132_exiting > 0)
3097 return -ENODEV;
3098
3099 retval = ftdi_write_pcimem(pdev, intrdisable, OHCI_INTR_MIE);
3100 if (retval)
3101 return retval;
3102 retval = ftdi_read_pcimem(pdev, control, &control);
3103 if (retval)
3104 return retval;
3105 retval = ftdi_read_pcimem(pdev, roothub.a, &rh_a);
3106 if (retval)
3107 return retval;
3108 num_ports = rh_a & RH_A_NDP; /* refuse to confuse usbcore */
3109 if (pdev->dev.dma_mask)
3110 return -EINVAL;
3111
Kay Sievers7071a3c2008-05-02 06:02:41 +02003112 hcd = usb_create_hcd(&u132_hc_driver, &pdev->dev, dev_name(&pdev->dev));
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003113 if (!hcd) {
3114 printk(KERN_ERR "failed to create the usb hcd struct for U132\n"
3115 );
3116 ftdi_elan_gone_away(pdev);
3117 return -ENOMEM;
3118 } else {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003119 struct u132 *u132 = hcd_to_u132(hcd);
Bill Pemberton66414452010-04-29 10:04:56 -04003120 retval = 0;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003121 hcd->rsrc_start = 0;
3122 mutex_lock(&u132_module_lock);
3123 list_add_tail(&u132->u132_list, &u132_static_list);
3124 u132->sequence_num = ++u132_instances;
3125 mutex_unlock(&u132_module_lock);
3126 u132_u132_init_kref(u132);
3127 u132_initialise(u132, pdev);
3128 hcd->product_desc = "ELAN U132 Host Controller";
3129 retval = usb_add_hcd(hcd, 0, 0);
3130 if (retval != 0) {
3131 dev_err(&u132->platform_dev->dev, "init error %d\n",
3132 retval);
3133 u132_u132_put_kref(u132);
3134 return retval;
3135 } else {
3136 u132_monitor_queue_work(u132, 100);
3137 return 0;
3138 }
3139 }
Tony Olechd774efe2006-09-13 11:27:35 +01003140}
3141
3142
3143#ifdef CONFIG_PM
3144/* for this device there's no useful distinction between the controller
3145* and its root hub, except that the root hub only gets direct PM calls
3146* when CONFIG_USB_SUSPEND is enabled.
3147*/
3148static int u132_suspend(struct platform_device *pdev, pm_message_t state)
3149{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003150 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3151 struct u132 *u132 = hcd_to_u132(hcd);
3152 if (u132->going > 1) {
3153 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3154 , u132->going);
3155 return -ENODEV;
3156 } else if (u132->going > 0) {
3157 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3158 return -ESHUTDOWN;
3159 } else {
Mirco Tischler038eb0e2008-02-24 05:16:39 +01003160 int retval = 0, ports;
Rafael J. Wysocki3a2d5b72008-02-23 19:13:25 +01003161
3162 switch (state.event) {
3163 case PM_EVENT_FREEZE:
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003164 retval = u132_bus_suspend(hcd);
Rafael J. Wysocki3a2d5b72008-02-23 19:13:25 +01003165 break;
3166 case PM_EVENT_SUSPEND:
3167 case PM_EVENT_HIBERNATE:
Mirco Tischler038eb0e2008-02-24 05:16:39 +01003168 ports = MAX_U132_PORTS;
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003169 while (ports-- > 0) {
3170 port_power(u132, ports, 0);
3171 }
Rafael J. Wysocki3a2d5b72008-02-23 19:13:25 +01003172 break;
3173 }
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003174 return retval;
3175 }
Tony Olechd774efe2006-09-13 11:27:35 +01003176}
3177
3178static int u132_resume(struct platform_device *pdev)
3179{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003180 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3181 struct u132 *u132 = hcd_to_u132(hcd);
3182 if (u132->going > 1) {
3183 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3184 , u132->going);
3185 return -ENODEV;
3186 } else if (u132->going > 0) {
3187 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3188 return -ESHUTDOWN;
3189 } else {
3190 int retval = 0;
Alan Stern70a1c9e2008-03-06 17:00:58 -05003191 if (!u132->port[0].power) {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003192 int ports = MAX_U132_PORTS;
3193 while (ports-- > 0) {
3194 port_power(u132, ports, 1);
3195 }
3196 retval = 0;
3197 } else {
3198 retval = u132_bus_resume(hcd);
3199 }
3200 return retval;
3201 }
Tony Olechd774efe2006-09-13 11:27:35 +01003202}
3203
3204#else
3205#define u132_suspend NULL
3206#define u132_resume NULL
3207#endif
3208/*
Matt LaPlante0779bf22006-11-30 05:24:39 +01003209* this driver is loaded explicitly by ftdi_u132
Tony Olechd774efe2006-09-13 11:27:35 +01003210*
3211* the platform_driver struct is static because it is per type of module
3212*/
3213static struct platform_driver u132_platform_driver = {
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003214 .probe = u132_probe,
Bill Pemberton76904172012-11-19 13:21:08 -05003215 .remove = u132_remove,
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003216 .suspend = u132_suspend,
3217 .resume = u132_resume,
3218 .driver = {
3219 .name = (char *)hcd_name,
3220 .owner = THIS_MODULE,
3221 },
Tony Olechd774efe2006-09-13 11:27:35 +01003222};
3223static int __init u132_hcd_init(void)
3224{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003225 int retval;
3226 INIT_LIST_HEAD(&u132_static_list);
3227 u132_instances = 0;
3228 u132_exiting = 0;
3229 mutex_init(&u132_module_lock);
3230 if (usb_disabled())
3231 return -ENODEV;
Michal Marek654d1212011-04-05 16:59:11 +02003232 printk(KERN_INFO "driver %s\n", hcd_name);
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003233 workqueue = create_singlethread_workqueue("u132");
3234 retval = platform_driver_register(&u132_platform_driver);
3235 return retval;
Tony Olechd774efe2006-09-13 11:27:35 +01003236}
3237
3238
3239module_init(u132_hcd_init);
3240static void __exit u132_hcd_exit(void)
3241{
Daniel Walkerb40f8d32008-03-23 00:00:01 -07003242 struct u132 *u132;
3243 struct u132 *temp;
3244 mutex_lock(&u132_module_lock);
3245 u132_exiting += 1;
3246 mutex_unlock(&u132_module_lock);
3247 list_for_each_entry_safe(u132, temp, &u132_static_list, u132_list) {
3248 platform_device_unregister(u132->platform_dev);
3249 }
3250 platform_driver_unregister(&u132_platform_driver);
3251 printk(KERN_INFO "u132-hcd driver deregistered\n");
3252 wait_event(u132_hcd_wait, u132_instances == 0);
3253 flush_workqueue(workqueue);
3254 destroy_workqueue(workqueue);
Tony Olechd774efe2006-09-13 11:27:35 +01003255}
3256
3257
3258module_exit(u132_hcd_exit);
3259MODULE_LICENSE("GPL");
Kay Sieversf4fce612008-04-10 21:29:22 -07003260MODULE_ALIAS("platform:u132_hcd");