Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/sys/dev/ic/sl811hs.c,v rcsdiff: /ftp/cvs/cvsroot/src/sys/dev/ic/sl811hs.c,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.6 retrieving revision 1.6.2.6 diff -u -p -r1.6 -r1.6.2.6 --- src/sys/dev/ic/sl811hs.c 2005/06/01 19:40:58 1.6 +++ src/sys/dev/ic/sl811hs.c 2008/02/27 08:36:34 1.6.2.6 @@ -1,167 +1,687 @@ -/* $NetBSD: sl811hs.c,v 1.6 2005/06/01 19:40:58 drochner Exp $ */ +/* $NetBSD: sl811hs.c,v 1.6.2.6 2008/02/27 08:36:34 yamt Exp $ */ /* - * Copyright (c) 2001 The NetBSD Foundation, Inc. - * All rights reserved. + * Not (c) 2007 Matthew Orgass + * This file is public domain, meaning anyone can make any use of part or all + * of this file including copying into other works without credit. Any use, + * modified or not, is solely the responsibility of the user. If this file is + * part of a collection then use in the collection is governed by the terms of + * the collection. + */ + +/* + * Cypress/ScanLogic SL811HS/T USB Host Controller + * Datasheet, Errata, and App Note available at www.cypress.com + * + * Uses: Ratoc CFU1U PCMCIA USB Host Controller, Nereid Mac 68k USB HC, ISA + * HCs. The Ratoc CFU2 uses a different chip. * - * This code is derived from software contributed to The NetBSD Foundation - * by Tetsuya Isaki. + * This chip puts the serial in USB. It implements USB by means of an eight + * bit I/O interface. It can be used for ISA, PCMCIA/CF, parallel port, + * serial port, or any eight bit interface. It has 256 bytes of memory, the + * first 16 of which are used for register access. There are two sets of + * registers for sending individual bus transactions. Because USB is polled, + * this organization means that some amount of card access must often be made + * when devices are attached, even if when they are not directly being used. + * A per-ms frame interrupt is necessary and many devices will poll with a + * per-frame bulk transfer. * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the NetBSD - * Foundation, Inc. and its contributors. - * 4. Neither the name of The NetBSD Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. + * It is possible to write a little over two bytes to the chip (auto + * incremented) per full speed byte time on the USB. Unfortunately, + * auto-increment does not work reliably so write and bus speed is + * approximately the same for full speed devices. + * + * In addition to the 240 byte packet size limit for isochronous transfers, + * this chip has no means of determining the current frame number other than + * getting all 1ms SOF interrupts, which is not always possible even on a fast + * system. Isochronous transfers guarantee that transfers will never be + * retried in a later frame, so this can cause problems with devices beyond + * the difficulty in actually performing the transfer most frames. I tried + * implementing isoc transfers and was able to play CD-derrived audio via an + * iMic on a 2GHz PC, however it would still be interrupted at times and + * once interrupted, would stay out of sync. All isoc support has been + * removed. + * + * BUGS: all chip revisions have problems with low speed devices through hubs. + * The chip stops generating SOF with hubs that send SE0 during SOF. See + * comment in dointr(). All performance enhancing features of this chip seem + * not to work properly, most confirmed buggy in errata doc. * - * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS - * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED - * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. */ /* - * ScanLogic SL811HS/T USB Host Controller + * The hard interrupt is the main entry point. Start, callbacks, and repeat + * are the only others called frequently. + * + * Since this driver attaches to pcmcia, card removal at any point should be + * expected and not cause panics or infinite loops. + * + * This driver does fine grained locking for its own data structures, however + * the general USB code does not yet have locks, some of which would need to + * be used in this driver. This is mostly for debug use on single processor + * systems. Actual MP use of this driver would be unreliable on ports where + * splipi is above splhigh unless splipi can be safely blocked when + * calculating remaining bus time prior to transfers. + * + * The theory of the wait lock is that start is the only function that would + * be frequently called from arbitrary processors, so it should not need to + * wait for the rest to be completed. However, once entering the lock as much + * device access as possible is done, so any other CPU that tries to service + * an interrupt would be blocked. Ideally, the hard and soft interrupt could + * be assigned to the same CPU and start would normally just put work on the + * wait queue and generate a soft interrupt. + * + * Any use of the main lock must check the wait lock before returning. The + * aquisition order is main lock then wait lock, but the wait lock must be + * released last when clearing the wait queue. */ -/* - * !! HIGHLY EXPERIMENTAL CODE !! + +/* XXX TODO: + * copy next output packet while transfering + * usb suspend + * could keep track of known values of all buffer space? + * combined print/log function for errors + * + * use_polling support is untested and may not work */ #include -__KERNEL_RCSID(0, "$NetBSD: sl811hs.c,v 1.6 2005/06/01 19:40:58 drochner Exp $"); - -#include "opt_slhci.h" +__KERNEL_RCSID(0, "$NetBSD: sl811hs.c,v 1.6.2.6 2008/02/27 08:36:34 yamt Exp $"); +#include #include #include #include #include #include #include - -#include -#include +#include +#include +#include +#include +#include +#include #include #include #include #include #include +#include #include #include -static inline u_int8_t sl11read(struct slhci_softc *, int); -static inline void sl11write(struct slhci_softc *, int, u_int8_t); -static inline void sl11read_region(struct slhci_softc *, u_char *, int, int); -static inline void sl11write_region(struct slhci_softc *, int, u_char *, int); - -static void sl11_reset(struct slhci_softc *); -static void sl11_speed(struct slhci_softc *); - -static usbd_status slhci_open(usbd_pipe_handle); -static void slhci_softintr(void *); -static void slhci_poll(struct usbd_bus *); -static void slhci_poll_hub(void *); -static void slhci_poll_device(void *arg); -static usbd_status slhci_allocm(struct usbd_bus *, usb_dma_t *, u_int32_t); -static void slhci_freem(struct usbd_bus *, usb_dma_t *); -static usbd_xfer_handle slhci_allocx(struct usbd_bus *); -static void slhci_freex(struct usbd_bus *, usbd_xfer_handle); - -static int slhci_str(usb_string_descriptor_t *, int, const char *); - -static usbd_status slhci_root_ctrl_transfer(usbd_xfer_handle); -static usbd_status slhci_root_ctrl_start(usbd_xfer_handle); -static void slhci_root_ctrl_abort(usbd_xfer_handle); -static void slhci_root_ctrl_close(usbd_pipe_handle); -static void slhci_root_ctrl_done(usbd_xfer_handle); - -static usbd_status slhci_root_intr_transfer(usbd_xfer_handle); -static usbd_status slhci_root_intr_start(usbd_xfer_handle); -static void slhci_root_intr_abort(usbd_xfer_handle); -static void slhci_root_intr_close(usbd_pipe_handle); -static void slhci_root_intr_done(usbd_xfer_handle); - -static usbd_status slhci_device_ctrl_transfer(usbd_xfer_handle); -static usbd_status slhci_device_ctrl_start(usbd_xfer_handle); -static void slhci_device_ctrl_abort(usbd_xfer_handle); -static void slhci_device_ctrl_close(usbd_pipe_handle); -static void slhci_device_ctrl_done(usbd_xfer_handle); - -static usbd_status slhci_device_intr_transfer(usbd_xfer_handle); -static usbd_status slhci_device_intr_start(usbd_xfer_handle); -static void slhci_device_intr_abort(usbd_xfer_handle); -static void slhci_device_intr_close(usbd_pipe_handle); -static void slhci_device_intr_done(usbd_xfer_handle); - -static usbd_status slhci_device_isoc_transfer(usbd_xfer_handle); -static usbd_status slhci_device_isoc_start(usbd_xfer_handle); -static void slhci_device_isoc_abort(usbd_xfer_handle); -static void slhci_device_isoc_close(usbd_pipe_handle); -static void slhci_device_isoc_done(usbd_xfer_handle); - -static usbd_status slhci_device_bulk_transfer(usbd_xfer_handle); -static usbd_status slhci_device_bulk_start(usbd_xfer_handle); -static void slhci_device_bulk_abort(usbd_xfer_handle); -static void slhci_device_bulk_close(usbd_pipe_handle); -static void slhci_device_bulk_done(usbd_xfer_handle); - -static int slhci_transaction(struct slhci_softc *, - usbd_pipe_handle, u_int8_t, int, u_char *, u_int8_t); -static void slhci_noop(usbd_pipe_handle); -static void slhci_abort_xfer(usbd_xfer_handle, usbd_status); -static void slhci_device_clear_toggle(usbd_pipe_handle); +#define Q_CB 0 /* Control/Bulk */ +#define Q_NEXT_CB 1 +#define Q_MAX_XFER Q_CB +#define Q_CALLBACKS 2 +#define Q_MAX Q_CALLBACKS + +#define F_AREADY (0x00000001) +#define F_BREADY (0x00000002) +#define F_AINPROG (0x00000004) +#define F_BINPROG (0x00000008) +#define F_LOWSPEED (0x00000010) +#define F_UDISABLED (0x00000020) /* Consider disabled for USB */ +#define F_NODEV (0x00000040) +#define F_ROOTINTR (0x00000080) +#define F_REALPOWER (0x00000100) /* Actual power state */ +#define F_POWER (0x00000200) /* USB reported power state */ +#define F_ACTIVE (0x00000400) +#define F_CALLBACK (0x00000800) /* Callback scheduled */ +#define F_SOFCHECK1 (0x00001000) +#define F_SOFCHECK2 (0x00002000) +#define F_CRESET (0x00004000) /* Reset done not reported */ +#define F_CCONNECT (0x00008000) /* Connect change not reported */ +#define F_RESET (0x00010000) +#define F_ISOC_WARNED (0x00020000) +#define F_LSVH_WARNED (0x00040000) -extern int usbdebug; -int slhci_dummy; +#define F_DISABLED (F_NODEV|F_UDISABLED) +#define F_CHANGE (F_CRESET|F_CCONNECT) + +#ifdef SLHCI_TRY_LSVH +unsigned int slhci_try_lsvh = 1; +#else +unsigned int slhci_try_lsvh = 0; +#endif + +#define ADR 0 +#define LEN 1 +#define PID 2 +#define DEV 3 +#define STAT 2 +#define CONT 3 + +#define A 0 +#define B 1 + +static const uint8_t slhci_tregs[2][4] = +{{SL11_E0ADDR, SL11_E0LEN, SL11_E0PID, SL11_E0DEV }, + {SL11_E1ADDR, SL11_E1LEN, SL11_E1PID, SL11_E1DEV }}; + +#define PT_ROOT_CTRL 0 +#define PT_ROOT_INTR 1 +#define PT_CTRL_SETUP 2 +#define PT_CTRL_DATA 3 +#define PT_CTRL_STATUS 4 +#define PT_INTR 5 +#define PT_BULK 6 +#define PT_MAX 6 + +#ifdef SLHCI_DEBUG +#define SLHCI_MEM_ACCOUNTING +static const char * +pnames(int ptype) +{ + static const char * const names[] = { "ROOT Ctrl", "ROOT Intr", + "Control (setup)", "Control (data)", "Control (status)", + "Interrupt", "Bulk", "BAD PTYPE" }; + + KASSERT(sizeof(names) / sizeof(names[0]) == PT_MAX + 2); + if (ptype > PT_MAX) + ptype = PT_MAX + 1; + return names[ptype]; +} +#endif + +#define SLHCI_XFER_TYPE(x) (((struct slhci_pipe *)((x)->pipe))->ptype) + +/* Maximum allowable reserved bus time. Since intr/isoc transfers have + * unconditional priority, this is all that ensures control and bulk transfers + * get a chance. It is a single value for all frames since all transfers can + * use multiple consecutive frames if an error is encountered. Note that it + * is not really possible to fill the bus with transfers, so this value should + * be on the low side. Defaults to giving a warning unless SLHCI_NO_OVERTIME + * is defined. Full time is 12000 - END_BUSTIME. */ +#ifndef SLHCI_RESERVED_BUSTIME +#define SLHCI_RESERVED_BUSTIME 5000 +#endif + +/* Rate for "exceeds reserved bus time" warnings (default) or errors. + * Warnings only happen when an endpoint open causes the time to go above + * SLHCI_RESERVED_BUSTIME, not if it is already above. */ +#ifndef SLHCI_OVERTIME_WARNING_RATE +#define SLHCI_OVERTIME_WARNING_RATE { 60, 0 } /* 60 seconds */ +#endif +static const struct timeval reserved_warn_rate = SLHCI_OVERTIME_WARNING_RATE; + +/* Rate for overflow warnings */ +#ifndef SLHCI_OVERFLOW_WARNING_RATE +#define SLHCI_OVERFLOW_WARNING_RATE { 60, 0 } /* 60 seconds */ +#endif +static const struct timeval overflow_warn_rate = SLHCI_OVERFLOW_WARNING_RATE; + +/* For EOF, the spec says 42 bit times, plus (I think) a possible hub skew of + * 20 bit times. By default leave 66 bit times to start the transfer beyond + * the required time. Units are full-speed bit times (a bit over 5us per 64). + * Only multiples of 64 are significant. */ +#define SLHCI_STANDARD_END_BUSTIME 128 +#ifndef SLHCI_EXTRA_END_BUSTIME +#define SLHCI_EXTRA_END_BUSTIME 0 +#endif + +#define SLHCI_END_BUSTIME (SLHCI_STANDARD_END_BUSTIME+SLHCI_EXTRA_END_BUSTIME) + +/* This is an approximation of the USB worst-case timings presented on p. 54 of + * the USB 1.1 spec translated to full speed bit times. + * FS = full speed with handshake, FSII = isoc in, FSIO = isoc out, + * FSI = isoc (worst case), LS = low speed */ +#define SLHCI_FS_CONST 114 +#define SLHCI_FSII_CONST 92 +#define SLHCI_FSIO_CONST 80 +#define SLHCI_FSI_CONST 92 +#define SLHCI_LS_CONST 804 +#ifndef SLHCI_PRECICE_BUSTIME +/* These values are < 3% too high (compared to the multiply and divide) for + * max sized packets. */ +#define SLHCI_FS_DATA_TIME(len) (((u_int)(len)<<3)+(len)+((len)>>1)) +#define SLHCI_LS_DATA_TIME(len) (((u_int)(len)<<6)+((u_int)(len)<<4)) +#else +#define SLHCI_FS_DATA_TIME(len) (56*(len)/6) +#define SLHCI_LS_DATA_TIME(len) (449*(len)/6) +#endif + +/* Set SLHCI_WAIT_SIZE to the desired maximum size of single FS transfer + * to poll for after starting a transfer. 64 gets all full speed transfers. + * Note that even if 0 polling will occur if data equal or greater than the + * transfer size is copied to the chip while the transfer is in progress. + * Setting SLHCI_WAIT_TIME to -12000 will disable polling. + */ +#ifndef SLHCI_WAIT_SIZE +#define SLHCI_WAIT_SIZE 8 +#endif +#ifndef SLHCI_WAIT_TIME +#define SLHCI_WAIT_TIME (SLHCI_FS_CONST + \ + SLHCI_FS_DATA_TIME(SLHCI_WAIT_SIZE)) +#endif +const int slhci_wait_time = SLHCI_WAIT_TIME; + +/* Root hub intr endpoint */ +#define ROOT_INTR_ENDPT 1 -/* For root hub */ -#define SLHCI_INTR_ENDPT (1) +#ifndef SLHCI_MAX_RETRIES +#define SLHCI_MAX_RETRIES 3 +#endif +/* Check IER values for corruption after this many unrecognized interrupts. */ +#ifndef SLHCI_IER_CHECK_FREQUENCY #ifdef SLHCI_DEBUG -#define D_TRACE (0x0001) /* function trace */ -#define D_MSG (0x0002) /* debug messages */ -#define D_XFER (0x0004) /* transfer messages (noisy!) */ -#define D_MEM (0x0008) /* memory allocation */ - -int slhci_debug = D_MSG | D_XFER; -#define DPRINTF(z,x) if((slhci_debug&(z))!=0)printf x -void print_req(usb_device_request_t *); -void print_req_hub(usb_device_request_t *); -void print_dumpreg(struct slhci_softc *); -void print_xfer(usbd_xfer_handle); +#define SLHCI_IER_CHECK_FREQUENCY 1 #else -#define DPRINTF(z,x) +#define SLHCI_IER_CHECK_FREQUENCY 100 +#endif #endif +/* Note that buffer points to the start of the buffer for this transfer. */ +struct slhci_pipe { + struct usbd_pipe pipe; + struct usbd_xfer *xfer; /* xfer in progress */ + uint8_t *buffer; /* I/O buffer (if needed) */ + struct gcq ap; /* All pipes */ + struct gcq to; /* Timeout list */ + struct gcq xq; /* Xfer queues */ + unsigned int pflags; /* Pipe flags */ +#define PF_GONE (0x01) /* Pipe is on disabled device */ +#define PF_TOGGLE (0x02) /* Data toggle status */ +#define PF_LS (0x04) /* Pipe is low speed */ +#define PF_PREAMBLE (0x08) /* Needs preamble */ + Frame to_frame; /* Frame number for timeout */ + Frame frame; /* Frame number for intr xfer */ + Frame lastframe; /* Previous frame number for intr */ + uint16_t bustime; /* Worst case bus time usage */ + uint16_t newbustime[2]; /* new bustimes (see index below) */ + uint8_t tregs[4]; /* ADR, LEN, PID, DEV */ + uint8_t newlen[2]; /* 0 = short data, 1 = ctrl data */ + uint8_t newpid; /* for ctrl */ + uint8_t wantshort; /* last xfer must be short */ + uint8_t control; /* Host control register settings */ + uint8_t nerrs; /* Current number of errors */ + uint8_t ptype; /* Pipe type */ +}; + +#if defined(MULTIPROCESSOR) || defined(LOCKDEBUG) +#define SLHCI_WAITLOCK 1 +#endif -/* XXX: sync with argument */ -static const char *sltypestr [] = { - "SL11H/T", - "SL811HS/T", +#ifdef SLHCI_PROFILE_TRANSFER +#if defined(__mips__) +/* MIPS cycle counter does not directly count cpu cycles but is a different + * fraction of cpu cycles depending on the cpu. */ +typedef u_int32_t cc_type; +#define CC_TYPE_FMT "%u" +#define slhci_cc_set(x) __asm volatile ("mfc0 %[cc], $9\n\tnop\n\tnop\n\tnop" \ + : [cc] "=r"(x)) +#elif defined(__i386__) +typedef u_int64_t cc_type; +#define CC_TYPE_FMT "%llu" +#define slhci_cc_set(x) __asm volatile ("rdtsc" : "=A"(x)) +#else +#error "SLHCI_PROFILE_TRANSFER not implemented on this MACHINE_ARCH (see sys/dev/ic/sl811hs.c)" +#endif +struct slhci_cc_time { + cc_type start; + cc_type stop; + unsigned int miscdata; +}; +#ifndef SLHCI_N_TIMES +#define SLHCI_N_TIMES 200 +#endif +struct slhci_cc_times { + struct slhci_cc_time times[SLHCI_N_TIMES]; + int current; + int wraparound; }; +static struct slhci_cc_times t_ab[2]; +static struct slhci_cc_times t_abdone; +static struct slhci_cc_times t_copy_to_dev; +static struct slhci_cc_times t_copy_from_dev; +static struct slhci_cc_times t_intr; +static struct slhci_cc_times t_lock; +static struct slhci_cc_times t_delay; +static struct slhci_cc_times t_hard_int; +static struct slhci_cc_times t_callback; + +static inline void +start_cc_time(struct slhci_cc_times *times, unsigned int misc) { + times->times[times->current].miscdata = misc; + slhci_cc_set(times->times[times->current].start); +} +static inline void +stop_cc_time(struct slhci_cc_times *times) { + slhci_cc_set(times->times[times->current].stop); + if (++times->current >= SLHCI_N_TIMES) { + times->current = 0; + times->wraparound = 1; + } +} + +void slhci_dump_cc_times(int); + +void +slhci_dump_cc_times(int n) { + struct slhci_cc_times *times; + int i; + + switch (n) { + default: + case 0: + printf("USBA start transfer to intr:\n"); + times = &t_ab[A]; + break; + case 1: + printf("USBB start transfer to intr:\n"); + times = &t_ab[B]; + break; + case 2: + printf("abdone:\n"); + times = &t_abdone; + break; + case 3: + printf("copy to device:\n"); + times = &t_copy_to_dev; + break; + case 4: + printf("copy from device:\n"); + times = &t_copy_from_dev; + break; + case 5: + printf("intr to intr:\n"); + times = &t_intr; + break; + case 6: + printf("lock to release:\n"); + times = &t_lock; + break; + case 7: + printf("delay time:\n"); + times = &t_delay; + break; + case 8: + printf("hard interrupt enter to exit:\n"); + times = &t_hard_int; + break; + case 9: + printf("callback:\n"); + times = &t_callback; + break; + } + + if (times->wraparound) + for (i = times->current + 1; i < SLHCI_N_TIMES; i++) + printf("start " CC_TYPE_FMT " stop " CC_TYPE_FMT + " difference %8i miscdata %#x\n", + times->times[i].start, times->times[i].stop, + (int)(times->times[i].stop - + times->times[i].start), times->times[i].miscdata); + + for (i = 0; i < times->current; i++) + printf("start " CC_TYPE_FMT " stop " CC_TYPE_FMT + " difference %8i miscdata %#x\n", times->times[i].start, + times->times[i].stop, (int)(times->times[i].stop - + times->times[i].start), times->times[i].miscdata); +} +#else +#define start_cc_time(x, y) +#define stop_cc_time(x) +#endif /* SLHCI_PROFILE_TRANSFER */ + +typedef usbd_status (*LockCallFunc)(struct slhci_softc *, struct slhci_pipe + *, struct usbd_xfer *); + +usbd_status slhci_allocm(struct usbd_bus *, usb_dma_t *, u_int32_t); +void slhci_freem(struct usbd_bus *, usb_dma_t *); +struct usbd_xfer * slhci_allocx(struct usbd_bus *); +void slhci_freex(struct usbd_bus *, struct usbd_xfer *); + +usbd_status slhci_transfer(struct usbd_xfer *); +usbd_status slhci_start(struct usbd_xfer *); +usbd_status slhci_root_start(struct usbd_xfer *); +usbd_status slhci_open(struct usbd_pipe *); + +/* slhci_supported_rev, slhci_preinit, slhci_attach, slhci_detach, + * slhci_activate */ + +void slhci_abort(struct usbd_xfer *); +void slhci_close(struct usbd_pipe *); +void slhci_clear_toggle(struct usbd_pipe *); +void slhci_poll(struct usbd_bus *); +void slhci_done(struct usbd_xfer *); +void slhci_void(void *); + +/* lock entry functions */ + +#ifdef SLHCI_MEM_ACCOUNTING +void slhci_mem_use(struct usbd_bus *, int); +#endif + +void slhci_reset_entry(void *); +usbd_status slhci_lock_call(struct slhci_softc *, LockCallFunc, + struct slhci_pipe *, struct usbd_xfer *); +void slhci_start_entry(struct slhci_softc *, struct slhci_pipe *); +void slhci_callback_entry(void *arg); +void slhci_do_callback(struct slhci_softc *, struct usbd_xfer *, int *); + +/* slhci_intr */ + +void slhci_main(struct slhci_softc *, int *); + +/* in lock functions */ + +static void slhci_write(struct slhci_softc *, uint8_t, uint8_t); +static uint8_t slhci_read(struct slhci_softc *, uint8_t); +static void slhci_write_multi(struct slhci_softc *, uint8_t, uint8_t *, int); +static void slhci_read_multi(struct slhci_softc *, uint8_t, uint8_t *, int); + +static void slhci_waitintr(struct slhci_softc *, int); +static int slhci_dointr(struct slhci_softc *); +static void slhci_abdone(struct slhci_softc *, int); +static void slhci_tstart(struct slhci_softc *); +static void slhci_dotransfer(struct slhci_softc *); + +static void slhci_callback(struct slhci_softc *, int *); +static void slhci_enter_xfer(struct slhci_softc *, struct slhci_pipe *); +#ifdef SLHCI_WAITLOCK +static void slhci_enter_xfers(struct slhci_softc *); +#endif +static void slhci_queue_timed(struct slhci_softc *, struct slhci_pipe *); +static void slhci_xfer_timer(struct slhci_softc *, struct slhci_pipe *); + +static void slhci_do_repeat(struct slhci_softc *, struct usbd_xfer *); +static void slhci_callback_schedule(struct slhci_softc *); +static void slhci_do_callback_schedule(struct slhci_softc *); +#if 0 +void slhci_pollxfer(struct slhci_softc *, struct usbd_xfer *, int *); /* XXX */ +#endif + +static usbd_status slhci_do_poll(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); +static usbd_status slhci_lsvh_warn(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); +static usbd_status slhci_isoc_warn(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); +static usbd_status slhci_open_pipe(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); +static usbd_status slhci_close_pipe(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); +static usbd_status slhci_do_abort(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); +static usbd_status slhci_do_attach(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); +static usbd_status slhci_halt(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); + +static void slhci_intrchange(struct slhci_softc *, uint8_t); +static void slhci_drain(struct slhci_softc *); +static void slhci_reset(struct slhci_softc *); +static int slhci_reserve_bustime(struct slhci_softc *, struct slhci_pipe *, + int); +static void slhci_insert(struct slhci_softc *); + +static usbd_status slhci_clear_feature(struct slhci_softc *, unsigned int); +static usbd_status slhci_set_feature(struct slhci_softc *, unsigned int); +static void slhci_get_status(struct slhci_softc *, usb_port_status_t *); +static usbd_status slhci_root(struct slhci_softc *, struct slhci_pipe *, + struct usbd_xfer *); + +#ifdef SLHCI_DEBUG +void slhci_log_buffer(struct usbd_xfer *); +void slhci_log_req(usb_device_request_t *); +void slhci_log_req_hub(usb_device_request_t *); +void slhci_log_dumpreg(void); +void slhci_log_xfer(struct usbd_xfer *); +void slhci_log_spipe(struct slhci_pipe *); +void slhci_print_intr(void); +void slhci_log_sc(void); +void slhci_log_slreq(struct slhci_pipe *); + +extern int usbdebug; + +/* Constified so you can read the values from ddb */ +const int SLHCI_D_TRACE = 0x0001; +const int SLHCI_D_MSG = 0x0002; +const int SLHCI_D_XFER = 0x0004; +const int SLHCI_D_MEM = 0x0008; +const int SLHCI_D_INTR = 0x0010; +const int SLHCI_D_SXFER = 0x0020; +const int SLHCI_D_ERR = 0x0080; +const int SLHCI_D_BUF = 0x0100; +const int SLHCI_D_SOFT = 0x0200; +const int SLHCI_D_WAIT = 0x0400; +const int SLHCI_D_ROOT = 0x0800; +/* SOF/NAK alone normally ignored, SOF also needs D_INTR */ +const int SLHCI_D_SOF = 0x1000; +const int SLHCI_D_NAK = 0x2000; + +int slhci_debug = 0x1cbc; /* 0xc8c; */ /* 0xffff; */ /* 0xd8c; */ +struct slhci_softc *ssc; +#ifdef USB_DEBUG +int slhci_usbdebug = -1; /* value to set usbdebug on attach, -1 = leave alone */ +#endif + +/* Add UVMHIST history for debugging: + * + * Before uvm_hist in sys/uvm/uvm_stat.c add: + * UVMHIST_DECL(slhcihist); + * + * In uvm_hist add: + * if ((bitmask & UVMHIST_SLHCI)) + * hists[i++] = &slhcihist; + * + * In sys/uvm/uvm_stat.h add UVMHIST_SLHCI define. + */ + +#include +UVMHIST_DECL(slhcihist); + +#if !defined(UVMHIST) || !defined(UVMHIST_SLHCI) +#error "SLHCI_DEBUG requires UVMHIST (with modifications, see sys/dev/ic/sl81hs.c)" +#endif + +#ifndef SLHCI_NHIST +#define SLHCI_NHIST 409600 +#endif +const unsigned int SLHCI_HISTMASK = UVMHIST_SLHCI; +struct uvm_history_ent slhci_he[SLHCI_NHIST]; -struct usbd_bus_methods slhci_bus_methods = { +#define SLHCI_DEXEC(x, y) do { if ((slhci_debug & SLHCI_ ## x)) { y; } \ +} while (/*CONSTCOND*/ 0) +#define DDOLOG(f, a, b, c, d) do { const char *_uvmhist_name = __func__; \ + u_long _uvmhist_call = 0; UVMHIST_LOG(slhcihist, f, a, b, c, d); \ +} while (/*CONSTCOND*/0) +#define DLOG(x, f, a, b, c, d) SLHCI_DEXEC(x, DDOLOG(f, a, b, c, d)) +/* DLOGFLAG8 is a macro not a function so that flag name expressions are not + * evaluated unless the flag bit is set (which could save a register read). + * x is debug mask, y is flag identifier, z is flag variable, + * a-h are flag names (must evaluate to string constants, msb first). */ +#define DDOLOGFLAG8(y, z, a, b, c, d, e, f, g, h) do { uint8_t _DLF8 = (z); \ + const char *_uvmhist_name = __func__; u_long _uvmhist_call = 0; \ + if (_DLF8 & 0xf0) UVMHIST_LOG(slhcihist, y " %s %s %s %s", _DLF8 & 0x80 ? \ + (a) : "", _DLF8 & 0x40 ? (b) : "", _DLF8 & 0x20 ? (c) : "", _DLF8 & 0x10 ? \ + (d) : ""); if (_DLF8 & 0x0f) UVMHIST_LOG(slhcihist, y " %s %s %s %s", \ + _DLF8 & 0x08 ? (e) : "", _DLF8 & 0x04 ? (f) : "", _DLF8 & 0x02 ? (g) : "", \ + _DLF8 & 0x01 ? (h) : ""); \ +} while (/*CONSTCOND*/ 0) +#define DLOGFLAG8(x, y, z, a, b, c, d, e, f, g, h) \ + SLHCI_DEXEC(x, DDOLOGFLAG8(y, z, a, b, c, d, e, f, g, h)) +/* DDOLOGBUF logs a buffer up to 8 bytes at a time. No identifier so that we + * can make it a real function. */ +static void +DDOLOGBUF(uint8_t *buf, unsigned int length) +{ + int i; + + for(i=0; i+8 <= length; i+=8) + DDOLOG("%.4x %.4x %.4x %.4x", (buf[i] << 8) | buf[i+1], + (buf[i+2] << 8) | buf[i+3], (buf[i+4] << 8) | buf[i+5], + (buf[i+6] << 8) | buf[i+7]); + if (length == i+7) + DDOLOG("%.4x %.4x %.4x %.2x", (buf[i] << 8) | buf[i+1], + (buf[i+2] << 8) | buf[i+3], (buf[i+4] << 8) | buf[i+5], + buf[i+6]); + else if (length == i+6) + DDOLOG("%.4x %.4x %.4x", (buf[i] << 8) | buf[i+1], + (buf[i+2] << 8) | buf[i+3], (buf[i+4] << 8) | buf[i+5], 0); + else if (length == i+5) + DDOLOG("%.4x %.4x %.2x", (buf[i] << 8) | buf[i+1], + (buf[i+2] << 8) | buf[i+3], buf[i+4], 0); + else if (length == i+4) + DDOLOG("%.4x %.4x", (buf[i] << 8) | buf[i+1], + (buf[i+2] << 8) | buf[i+3], 0,0); + else if (length == i+3) + DDOLOG("%.4x %.2x", (buf[i] << 8) | buf[i+1], buf[i+2], 0,0); + else if (length == i+2) + DDOLOG("%.4x", (buf[i] << 8) | buf[i+1], 0,0,0); + else if (length == i+1) + DDOLOG("%.2x", buf[i], 0,0,0); +} +#define DLOGBUF(x, b, l) SLHCI_DEXEC(x, DDOLOGBUF(b, l)) +#else /* now !SLHCI_DEBUG */ +#define slhci_log_spipe(spipe) ((void)0) +#define slhci_log_xfer(xfer) ((void)0) +#define SLHCI_DEXEC(x, y) ((void)0) +#define DDOLOG(f, a, b, c, d) ((void)0) +#define DLOG(x, f, a, b, c, d) ((void)0) +#define DDOLOGFLAG8(y, z, a, b, c, d, e, f, g, h) ((void)0) +#define DLOGFLAG8(x, y, z, a, b, c, d, e, f, g, h) ((void)0) +#define DDOLOGBUF(b, l) ((void)0) +#define DLOGBUF(x, b, l) ((void)0) +#endif /* SLHCI_DEBUG */ + +#define SLHCI_MAINLOCKASSERT(sc) ((void)0) +#define SLHCI_LOCKASSERT(sc, main, wait) ((void)0) + +#ifdef DIAGNOSTIC +#define LK_SLASSERT(exp, sc, spipe, xfer, ext) do { \ + if (!(exp)) { \ + printf("%s: assertion %s failed line %u function %s!" \ + " halted\n", SC_NAME(sc), #exp, __LINE__, __func__);\ + DDOLOG("%s: assertion %s failed line %u function %s!" \ + " halted\n", SC_NAME(sc), #exp, __LINE__, __func__);\ + slhci_halt(sc, spipe, xfer); \ + ext; \ + } \ +} while (/*CONSTCOND*/0) +#define UL_SLASSERT(exp, sc, spipe, xfer, ext) do { \ + if (!(exp)) { \ + printf("%s: assertion %s failed line %u function %s!" \ + " halted\n", SC_NAME(sc), #exp, __LINE__, __func__); \ + DDOLOG("%s: assertion %s failed line %u function %s!" \ + " halted\n", SC_NAME(sc), #exp, __LINE__, __func__); \ + slhci_lock_call(sc, &slhci_halt, spipe, xfer); \ + ext; \ + } \ +} while (/*CONSTCOND*/0) +#else +#define LK_SLASSERT(exp, sc, spipe, xfer, ext) ((void)0) +#define UL_SLASSERT(exp, sc, spipe, xfer, ext) ((void)0) +#endif + +const struct usbd_bus_methods slhci_bus_methods = { slhci_open, - slhci_softintr, + slhci_void, slhci_poll, slhci_allocm, slhci_freem, @@ -169,1373 +689,2781 @@ struct usbd_bus_methods slhci_bus_method slhci_freex, }; -struct usbd_pipe_methods slhci_root_ctrl_methods = { - slhci_root_ctrl_transfer, - slhci_root_ctrl_start, - slhci_root_ctrl_abort, - slhci_root_ctrl_close, - slhci_noop, - slhci_root_ctrl_done, +const struct usbd_pipe_methods slhci_pipe_methods = { + slhci_transfer, + slhci_start, + slhci_abort, + slhci_close, + slhci_clear_toggle, + slhci_done, }; -struct usbd_pipe_methods slhci_root_intr_methods = { - slhci_root_intr_transfer, - slhci_root_intr_start, - slhci_root_intr_abort, - slhci_root_intr_close, - slhci_noop, - slhci_root_intr_done, +const struct usbd_pipe_methods slhci_root_methods = { + slhci_transfer, + slhci_root_start, + slhci_abort, + (void (*)(struct usbd_pipe *))slhci_void, /* XXX safe? */ + slhci_clear_toggle, + slhci_done, }; -struct usbd_pipe_methods slhci_device_ctrl_methods = { - slhci_device_ctrl_transfer, - slhci_device_ctrl_start, - slhci_device_ctrl_abort, - slhci_device_ctrl_close, - slhci_noop, - slhci_device_ctrl_done, -}; +/* Queue inlines */ -struct usbd_pipe_methods slhci_device_intr_methods = { - slhci_device_intr_transfer, - slhci_device_intr_start, - slhci_device_intr_abort, - slhci_device_intr_close, - slhci_device_clear_toggle, - slhci_device_intr_done, -}; +#define GOT_FIRST_TO(tvar, t) \ + GCQ_GOT_FIRST_TYPED(tvar, &(t)->to, struct slhci_pipe, to) -struct usbd_pipe_methods slhci_device_isoc_methods = { - slhci_device_isoc_transfer, - slhci_device_isoc_start, - slhci_device_isoc_abort, - slhci_device_isoc_close, - slhci_noop, - slhci_device_isoc_done, -}; +#define FIND_TO(var, t, tvar, cond) \ + GCQ_FIND_TYPED(var, &(t)->to, tvar, struct slhci_pipe, to, cond) -struct usbd_pipe_methods slhci_device_bulk_methods = { - slhci_device_bulk_transfer, - slhci_device_bulk_start, - slhci_device_bulk_abort, - slhci_device_bulk_close, - slhci_noop, - slhci_device_bulk_done, -}; +#define FOREACH_AP(var, t, tvar) \ + GCQ_FOREACH_TYPED(var, &(t)->ap, tvar, struct slhci_pipe, ap) -struct slhci_pipe { - struct usbd_pipe pipe; -}; +#define GOT_FIRST_TIMED_COND(tvar, t, cond) \ + GCQ_GOT_FIRST_COND_TYPED(tvar, &(t)->timed, struct slhci_pipe, xq, cond) +#define GOT_FIRST_CB(tvar, t) \ + GCQ_GOT_FIRST_TYPED(tvar, &(t)->q[Q_CB], struct slhci_pipe, xq) -/* - * SL811HS Register read/write routine - */ -static inline u_int8_t -sl11read(struct slhci_softc *sc, int reg) +#define DEQUEUED_CALLBACK(tvar, t) \ + GCQ_DEQUEUED_FIRST_TYPED(tvar, &(t)->q[Q_CALLBACKS], struct slhci_pipe, xq) + +#define FIND_TIMED(var, t, tvar, cond) \ + GCQ_FIND_TYPED(var, &(t)->timed, tvar, struct slhci_pipe, xq, cond) + +#ifdef SLHCI_WAITLOCK +#define DEQUEUED_WAITQ(tvar, sc) \ + GCQ_DEQUEUED_FIRST_TYPED(tvar, &(sc)->sc_waitq, struct slhci_pipe, xq) + +static inline void +enter_waitq(struct slhci_softc *sc, struct slhci_pipe *spipe) { - bus_space_write_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_ADDR, reg); - return bus_space_read_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_DATA); + gcq_insert_tail(&sc->sc_waitq, &spipe->xq); } +#endif static inline void -sl11write(struct slhci_softc *sc, int reg, u_int8_t data) +enter_q(struct slhci_transfers *t, struct slhci_pipe *spipe, int i) { - bus_space_write_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_ADDR, reg); - bus_space_write_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_DATA, data); + gcq_insert_tail(&t->q[i], &spipe->xq); } static inline void -sl11read_region(struct slhci_softc *sc, u_char *buf, int reg, int len) +enter_callback(struct slhci_transfers *t, struct slhci_pipe *spipe) { - int i; - bus_space_write_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_ADDR, reg); - for (i = 0; i < len; i++) - buf[i] = bus_space_read_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_DATA); + gcq_insert_tail(&t->q[Q_CALLBACKS], &spipe->xq); } static inline void -sl11write_region(struct slhci_softc *sc, int reg, u_char *buf, int len) +enter_all_pipes(struct slhci_transfers *t, struct slhci_pipe *spipe) { - int i; - bus_space_write_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_ADDR, reg); - for (i = 0; i < len; i++) - bus_space_write_1(sc->sc_iot, sc->sc_ioh, SL11_IDX_DATA, buf[i]); + gcq_insert_tail(&t->ap, &spipe->ap); } -/* - * USB bus reset. From sl811hs_appnote.pdf, p22 - */ -static void -sl11_reset(struct slhci_softc *sc) -{ - u_int8_t r; +/* Start out of lock functions. */ - DPRINTF(D_TRACE, ("%s() ", __FUNCTION__)); - r = sl11read(sc, SL11_CTRL); - sl11write(sc, SL11_CTRL, r | SL11_CTRL_RESETENGINE); - delay_ms(250); - sl11write(sc, SL11_CTRL, r | SL11_CTRL_RESETENGINE | SL11_CTRL_SUSPEND); - delay_ms(150); - sl11write(sc, SL11_CTRL, r | SL11_CTRL_RESETENGINE); - delay_ms(10); - sl11write(sc, SL11_CTRL, r); -} +struct slhci_mem { + usb_dma_block_t block; + uint8_t data[]; +}; -/* - * Detect the speed of attached device. - */ -static void -sl11_speed(struct slhci_softc *sc) +/* The SL811HS does not do DMA as a host controller, but NetBSD's USB interface + * assumes DMA is used. So we fake the DMA block. */ +usbd_status +slhci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size) { - u_int8_t r; + struct slhci_mem *mem; - sl11write(sc, SL11_ISR, 0xff); - r = sl11read(sc, SL11_ISR); - if ((r & SL11_ISR_RESET)) { - DPRINTF(D_MSG, ("NC ")); - sl11write(sc, SL11_ISR, SL11_ISR_RESET); - sc->sc_connect = 0; - } + mem = malloc(sizeof(struct slhci_mem) + size, M_USB, M_NOWAIT|M_ZERO); - if ((sl11read(sc, SL11_ISR) & SL11_ISR_RESET)) { - sl11write(sc, SL11_ISR, 0xff); - } else { - u_int8_t pol = 0, ctrl = 0; + DLOG(D_MEM, "allocm %p", mem, 0,0,0); - sc->sc_connect = 1; - if (r & SL11_ISR_DATA) { - DPRINTF(D_MSG, ("FS ")); - pol = 0; - ctrl = SL11_CTRL_EOF2; - sc->sc_fullspeed = 1; - } else { - DPRINTF(D_MSG, ("LS ")); - pol = SL811_CSOF_POLARITY; - ctrl = SL11_CTRL_LOWSPEED; - sc->sc_fullspeed = 0; - } - sl11write(sc, SL811_CSOF, pol | SL811_CSOF_MASTER | 0x2e); - sl11write(sc, SL11_DATA, 0xe0); - sl11write(sc, SL11_CTRL, ctrl | SL11_CTRL_ENABLESOF); - } + if (mem == NULL) + return USBD_NOMEM; + + dma->block = &mem->block; + dma->block->kaddr = mem->data; + + /* dma->offs = 0; */ + dma->block->nsegs = 1; + dma->block->size = size; + dma->block->align = size; + dma->block->flags |= USB_DMA_FULLBLOCK; - sl11write(sc, SL11_E0PID, (SL11_PID_SOF << 4) + 0); - sl11write(sc, SL11_E0DEV, 0); - sl11write(sc, SL11_E0CTRL, SL11_EPCTRL_ARM); - delay_ms(30); +#ifdef SLHCI_MEM_ACCOUNTING + slhci_mem_use(bus, 1); +#endif + + return USBD_NORMAL_COMPLETION; } -/* - * If detect some known controller, return the type. - * If does not, return -1. - */ -int -sl811hs_find(struct slhci_softc *sc) +void +slhci_freem(struct usbd_bus *bus, usb_dma_t *dma) { - int rev; + DLOG(D_MEM, "freem %p", dma->block, 0,0,0); - sc->sc_sltype = -1; - rev = sl11read(sc, SL11_REV) >> 4; - if (rev >= SLTYPE_SL11H && rev <= SLTYPE_SL811HS_R14) - sc->sc_sltype = rev; - return sc->sc_sltype; +#ifdef SLHCI_MEM_ACCOUNTING + slhci_mem_use(bus, -1); +#endif + + free(dma->block, M_USB); } -/* - * Attach SL11H/SL811HS. Return 0 if success. - */ -int -slhci_attach(struct slhci_softc *sc, struct device *self) +struct usbd_xfer * +slhci_allocx(struct usbd_bus *bus) { - int rev; + struct usbd_xfer *xfer; - /* Detect and check the controller type */ - rev = sl811hs_find(sc); - if (rev == -1) - return -1; + xfer = malloc(sizeof(*xfer), M_USB, M_NOWAIT|M_ZERO); - printf("%s: ScanLogic %s USB Host Controller", - sc->sc_bus.bdev.dv_xname, sltypestr[(rev > 0)]); - switch (rev) { - case SLTYPE_SL11H: - break; - case SLTYPE_SL811HS_R12: - printf(" (rev 1.2)"); - break; - case SLTYPE_SL811HS_R14: - printf(" (rev 1.4)"); - break; - default: - printf(" (unknown revision)"); - break; + DLOG(D_MEM, "allocx %p", xfer, 0,0,0); + +#ifdef SLHCI_MEM_ACCOUNTING + slhci_mem_use(bus, 1); +#endif +#ifdef DIAGNOSTIC + if (xfer != NULL) + xfer->busy_free = XFER_BUSY; +#endif + return xfer; +} + +void +slhci_freex(struct usbd_bus *bus, struct usbd_xfer *xfer) +{ + DLOG(D_MEM, "freex xfer %p spipe %p", xfer, xfer->pipe,0,0); + +#ifdef SLHCI_MEM_ACCOUNTING + slhci_mem_use(bus, -1); +#endif +#ifdef DIAGNOSTIC + if (xfer->busy_free != XFER_BUSY) { + struct slhci_softc *sc = (struct slhci_softc *)bus; + printf("%s: slhci_freex: xfer=%p not busy, %#08x halted\n", + SC_NAME(sc), xfer, xfer->busy_free); + DDOLOG("%s: slhci_freex: xfer=%p not busy, %#08x halted\n", + SC_NAME(sc), xfer, xfer->busy_free, 0); + slhci_lock_call(sc, &slhci_halt, NULL, NULL); + return; } - printf("\n"); + xfer->busy_free = XFER_FREE; +#endif - /* Initialize sc */ - sc->sc_bus.usbrev = USBREV_1_1; - sc->sc_bus.methods = &slhci_bus_methods; - sc->sc_bus.pipe_size = sizeof(struct slhci_pipe); - sc->sc_bus.dmatag = sc->sc_dmat; + free(xfer, M_USB); +} - SIMPLEQ_INIT(&sc->sc_free_xfers); +usbd_status +slhci_transfer(struct usbd_xfer *xfer) +{ + usbd_status error; + int s; - usb_callout_init(sc->sc_poll_handle); + DLOG(D_TRACE, "%s transfer xfer %p spipe %p ", + pnames(SLHCI_XFER_TYPE(xfer)), xfer, xfer->pipe,0); - /* Initialize controller */ - sl11write(sc, SL811_CSOF, SL811_CSOF_MASTER | 0x2e); - sl11write(sc, SL11_ISR, 0xff); - - /* Disable interrupt, then wait 40msec */ - sl11write(sc, SL11_IER, 0x00); - delay_ms(40); - - /* Reset USB engine */ - sl11write(sc, SL11_CTRL, SL11_CTRL_RESETENGINE | SL11_CTRL_SUSPEND); - delay_ms(40); - sl11write(sc, SL11_CTRL, 0x00); - delay_ms(10); - - /* USB Bus reset for GET_PORT_STATUS */ - sl11_reset(sc); - - /* Enable interrupt */ - sl11write(sc, SL11_IER, SL11_IER_INSERT); - /* x68k Nereid USB controller needs it */ - if (sc->sc_enable_intr) - sc->sc_enable_intr(sc->sc_arg, INTR_ON); + /* Insert last in queue */ + error = usb_insert_transfer(xfer); + if (error) { + if (error != USBD_IN_PROGRESS) + DLOG(D_ERR, "usb_insert_transfer returns %d!", error, + 0,0,0); + return error; + } -#ifdef USB_DEBUG - usbdebug = 0; -#endif + /* + * Pipe isn't running (otherwise error would be USBD_INPROG), + * so start it first. + */ - /* Attach USB devices */ - sc->sc_child = config_found(self, &sc->sc_bus, usbctlprint); + /* Start next is always done at splsoftusb, so we do this here so + * start functions are always called at softusb. XXX */ + s = splsoftusb(); + error = xfer->pipe->methods->start(SIMPLEQ_FIRST(&xfer->pipe->queue)); + splx(s); - return 0; + return error; } -int -slhci_intr(void *arg) +/* It is not safe for start to return anything other than USBD_INPROG. */ +usbd_status +slhci_start(struct usbd_xfer *xfer) { - struct slhci_softc *sc = arg; - u_int8_t r; -#ifdef SLHCI_DEBUG - char bitbuf[256]; + struct slhci_softc *sc; + struct usbd_pipe *pipe; + struct slhci_pipe *spipe; + struct slhci_transfers *t; + usb_endpoint_descriptor_t *ed; + unsigned int max_packet; + + pipe = xfer->pipe; + sc = (struct slhci_softc *)pipe->device->bus; + spipe = (struct slhci_pipe *)xfer->pipe; + t = &sc->sc_transfers; + ed = pipe->endpoint->edesc; + + max_packet = UGETW(ed->wMaxPacketSize); + + DLOG(D_TRACE, "%s start xfer %p spipe %p length %d", + pnames(spipe->ptype), xfer, spipe, xfer->length); + + /* root transfers use slhci_root_start */ + + KASSERT(spipe->xfer == NULL); /* not SLASSERT */ + + xfer->actlen = 0; + xfer->status = USBD_IN_PROGRESS; + + spipe->xfer = xfer; + + spipe->nerrs = 0; + spipe->frame = t->frame; + spipe->control = SL11_EPCTRL_ARM_ENABLE; + spipe->tregs[DEV] = pipe->device->address; + spipe->tregs[PID] = spipe->newpid = UE_GET_ADDR(ed->bEndpointAddress) + | (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN ? SL11_PID_IN : + SL11_PID_OUT); + spipe->newlen[0] = xfer->length % max_packet; + spipe->newlen[1] = min(xfer->length, max_packet); + + if (spipe->ptype == PT_BULK || spipe->ptype == PT_INTR) { + if (spipe->pflags & PF_TOGGLE) + spipe->control |= SL11_EPCTRL_DATATOGGLE; + spipe->tregs[LEN] = spipe->newlen[1]; + if (spipe->tregs[LEN]) + spipe->buffer = KERNADDR(&xfer->dmabuf, 0); + else + spipe->buffer = NULL; + spipe->lastframe = t->frame; +#if defined(DEBUG) || defined(SLHCI_DEBUG) + if (__predict_false(spipe->ptype == PT_INTR && + xfer->length > spipe->tregs[LEN])) { + printf("%s: Long INTR transfer not supported!\n", + SC_NAME(sc)); + DDOLOG("%s: Long INTR transfer not supported!\n", + SC_NAME(sc), 0,0,0); + xfer->status = USBD_INVAL; + } #endif + } else { + /* ptype may be currently set to any control transfer type. */ + SLHCI_DEXEC(D_TRACE, slhci_log_xfer(xfer)); - r = sl11read(sc, SL11_ISR); - - sl11write(sc, SL11_ISR, SL11_ISR_DATA | SL11_ISR_SOFTIMER); + /* SETUP contains IN/OUT bits also */ + spipe->tregs[PID] |= SL11_PID_SETUP; + spipe->tregs[LEN] = 8; + spipe->buffer = (uint8_t *)&xfer->request; + DLOGBUF(D_XFER, spipe->buffer, spipe->tregs[LEN]); + spipe->ptype = PT_CTRL_SETUP; + spipe->newpid &= ~SL11_PID_BITS; + if (xfer->length == 0 || (xfer->request.bmRequestType & + UT_READ)) + spipe->newpid |= SL11_PID_IN; + else + spipe->newpid |= SL11_PID_OUT; + } + + if (xfer->flags & USBD_FORCE_SHORT_XFER && spipe->tregs[LEN] == + max_packet && (spipe->newpid & SL11_PID_BITS) == SL11_PID_OUT) + spipe->wantshort = 1; + else + spipe->wantshort = 0; - if ((r & SL11_ISR_RESET)) { - sc->sc_flags |= SLF_RESET; - sl11write(sc, SL11_ISR, SL11_ISR_RESET); - } - if ((r & SL11_ISR_INSERT)) { - sc->sc_flags |= SLF_INSERT; - sl11write(sc, SL11_ISR, SL11_ISR_INSERT); - } + /* The goal of newbustime and newlen is to avoid bustime calculation + * in the interrupt. The calculations are not too complex, but they + * complicate the conditional logic somewhat and doing them all in the + * same place shares constants. Index 0 is "short length" for bulk and + * ctrl data and 1 is "full length" for ctrl data (bulk/intr are + * already set to full length). */ + if (spipe->pflags & PF_LS) { + /* Setting PREAMBLE for directly connnected LS devices will + * lock up the chip. */ + if (spipe->pflags & PF_PREAMBLE) + spipe->control |= SL11_EPCTRL_PREAMBLE; + if (max_packet <= 8) { + spipe->bustime = SLHCI_LS_CONST + + SLHCI_LS_DATA_TIME(spipe->tregs[LEN]); + spipe->newbustime[0] = SLHCI_LS_CONST + + SLHCI_LS_DATA_TIME(spipe->newlen[0]); + spipe->newbustime[1] = SLHCI_LS_CONST + + SLHCI_LS_DATA_TIME(spipe->newlen[1]); + } else + xfer->status = USBD_INVAL; + } else { + UL_SLASSERT(pipe->device->speed == USB_SPEED_FULL, sc, + spipe, xfer, return USBD_IN_PROGRESS); + if (max_packet <= SL11_MAX_PACKET_SIZE) { + spipe->bustime = SLHCI_FS_CONST + + SLHCI_FS_DATA_TIME(spipe->tregs[LEN]); + spipe->newbustime[0] = SLHCI_FS_CONST + + SLHCI_FS_DATA_TIME(spipe->newlen[0]); + spipe->newbustime[1] = SLHCI_FS_CONST + + SLHCI_FS_DATA_TIME(spipe->newlen[1]); + } else + xfer->status = USBD_INVAL; + } + + /* The datasheet incorrectly indicates that DIRECTION is for + * "transmit to host". It is for OUT and SETUP. The app note + * describes its use correctly. */ + if ((spipe->tregs[PID] & SL11_PID_BITS) != SL11_PID_IN) + spipe->control |= SL11_EPCTRL_DIRECTION; -#ifdef SLHCI_DEBUG - bitmask_snprintf(r, - (sl11read(sc, SL11_CTRL) & SL11_CTRL_SUSPEND) - ? "\20\x8""D+\7RESUME\6INSERT\5SOF\4res\3""BABBLE\2USBB\1USBA" - : "\20\x8""D+\7RESET\6INSERT\5SOF\4res\3""BABBLE\2USBB\1USBA", - bitbuf, sizeof(bitbuf)); - DPRINTF(D_XFER, ("I=%s ", bitbuf)); -#endif /* SLHCI_DEBUG */ + slhci_start_entry(sc, spipe); - return 0; + return USBD_IN_PROGRESS; } usbd_status -slhci_open(usbd_pipe_handle pipe) +slhci_root_start(struct usbd_xfer *xfer) { - usbd_device_handle dev = pipe->device; - struct slhci_softc *sc = (struct slhci_softc *)dev->bus; - usb_endpoint_descriptor_t *ed = pipe->endpoint->edesc; + struct slhci_softc *sc; + struct slhci_pipe *spipe; + + spipe = (struct slhci_pipe *)xfer->pipe; + sc = (struct slhci_softc *)xfer->pipe->device->bus; - DPRINTF(D_TRACE, ("slhci_open(addr=%d,ep=%d,scaddr=%d)", - dev->address, ed->bEndpointAddress, sc->sc_addr)); + return slhci_lock_call(sc, &slhci_root, spipe, xfer); +} + +usbd_status +slhci_open(struct usbd_pipe *pipe) +{ + struct usbd_device *dev; + struct slhci_softc *sc; + struct slhci_pipe *spipe; + usb_endpoint_descriptor_t *ed; + struct slhci_transfers *t; + unsigned int max_packet, pmaxpkt; + + dev = pipe->device; + sc = (struct slhci_softc *)dev->bus; + spipe = (struct slhci_pipe *)pipe; + ed = pipe->endpoint->edesc; + t = &sc->sc_transfers; + + DLOG(D_TRACE, "slhci_open(addr=%d,ep=%d,rootaddr=%d)", + dev->address, ed->bEndpointAddress, t->rootaddr, 0); + + spipe->pflags = 0; + spipe->frame = 0; + spipe->lastframe = 0; + spipe->xfer = NULL; + spipe->buffer = NULL; + + gcq_init(&spipe->ap); + gcq_init(&spipe->to); + gcq_init(&spipe->xq); + + /* The endpoint descriptor will not have been set up yet in the case + * of the standard control pipe, so the max packet checks are also + * necessary in start. */ + + max_packet = UGETW(ed->wMaxPacketSize); + + if (dev->speed == USB_SPEED_LOW) { + spipe->pflags |= PF_LS; + if (dev->myhub->address != t->rootaddr) { + spipe->pflags |= PF_PREAMBLE; + if (!slhci_try_lsvh) + return slhci_lock_call(sc, &slhci_lsvh_warn, + spipe, NULL); + } + pmaxpkt = 8; + } else + pmaxpkt = SL11_MAX_PACKET_SIZE; + + if (max_packet > pmaxpkt) { + DLOG(D_ERR, "packet too large! size %d spipe %p", max_packet, + spipe, 0,0); + return USBD_INVAL; + } - if (dev->address == sc->sc_addr) { + if (dev->address == t->rootaddr) { switch (ed->bEndpointAddress) { case USB_CONTROL_ENDPOINT: - pipe->methods = &slhci_root_ctrl_methods; + spipe->ptype = PT_ROOT_CTRL; + pipe->interval = 0; break; - case UE_DIR_IN | SLHCI_INTR_ENDPT: - pipe->methods = &slhci_root_intr_methods; + case UE_DIR_IN | ROOT_INTR_ENDPT: + spipe->ptype = PT_ROOT_INTR; + pipe->interval = 1; break; default: - printf("open:endpointErr!\n"); + printf("%s: Invalid root endpoint!\n", SC_NAME(sc)); + DDOLOG("%s: Invalid root endpoint!\n", SC_NAME(sc), + 0,0,0); return USBD_INVAL; } + pipe->methods = __UNCONST(&slhci_root_methods); + return USBD_NORMAL_COMPLETION; } else { switch (ed->bmAttributes & UE_XFERTYPE) { case UE_CONTROL: - DPRINTF(D_MSG, ("control ")); - pipe->methods = &slhci_device_ctrl_methods; + spipe->ptype = PT_CTRL_SETUP; + pipe->interval = 0; break; case UE_INTERRUPT: - DPRINTF(D_MSG, ("interrupt ")); - pipe->methods = &slhci_device_intr_methods; + spipe->ptype = PT_INTR; + if (pipe->interval == USBD_DEFAULT_INTERVAL) + pipe->interval = ed->bInterval; break; case UE_ISOCHRONOUS: - DPRINTF(D_MSG, ("isochronous ")); - pipe->methods = &slhci_device_isoc_methods; - break; + return slhci_lock_call(sc, &slhci_isoc_warn, spipe, + NULL); case UE_BULK: - DPRINTF(D_MSG, ("bluk ")); - pipe->methods = &slhci_device_bulk_methods; + spipe->ptype = PT_BULK; + pipe->interval = 0; break; } + + DLOG(D_MSG, "open pipe %s interval %d", pnames(spipe->ptype), + pipe->interval, 0,0); + + pipe->methods = __UNCONST(&slhci_pipe_methods); + + return slhci_lock_call(sc, &slhci_open_pipe, spipe, NULL); } - return USBD_NORMAL_COMPLETION; } -void -slhci_softintr(void *arg) +int +slhci_supported_rev(uint8_t rev) { - DPRINTF(D_TRACE, ("%s()", __FUNCTION__)); + return (rev >= SLTYPE_SL811HS_R12 && rev <= SLTYPE_SL811HS_R15); } +/* Must be called before the ISR is registered. Interrupts can be shared so + * slhci_intr could be called as soon as the ISR is registered. + * Note max_current argument is actual current, but stored as current/2 */ void -slhci_poll(struct usbd_bus *bus) +slhci_preinit(struct slhci_softc *sc, PowerFunc pow, bus_space_tag_t iot, + bus_space_handle_t ioh, uint16_t max_current, uint8_t stride) { - DPRINTF(D_TRACE, ("%s()", __FUNCTION__)); -} + struct slhci_transfers *t; + int i; -/* - * Emulation of interrupt transfer for status change endpoint - * of root hub. - */ -void -slhci_poll_hub(void *arg) -{ - usbd_xfer_handle xfer = arg; - usbd_pipe_handle pipe = xfer->pipe; - struct slhci_softc *sc = (struct slhci_softc *)pipe->device->bus; - int s; - u_char *p; + t = &sc->sc_transfers; - usb_callout(sc->sc_poll_handle, sc->sc_interval, slhci_poll_hub, xfer); +#ifdef SLHCI_DEBUG + UVMHIST_INIT_STATIC(slhcihist, slhci_he); +#endif + simple_lock_init(&sc->sc_lock); +#ifdef SLHCI_WAITLOCK + simple_lock_init(&sc->sc_wait_lock); +#endif + /* sc->sc_ier = 0; */ + /* t->rootintr = NULL; */ + t->flags = F_NODEV|F_UDISABLED; + t->pend = INT_MAX; + KASSERT(slhci_wait_time != INT_MAX); + t->len[0] = t->len[1] = -1; + if (max_current > 500) + max_current = 500; + t->max_current = (uint8_t)(max_current / 2); + sc->sc_enable_power = pow; + sc->sc_iot = iot; + sc->sc_ioh = ioh; + sc->sc_stride = stride; + + KASSERT(Q_MAX+1 == sizeof(t->q) / sizeof(t->q[0])); + + for (i = 0; i <= Q_MAX; i++) + gcq_init_head(&t->q[i]); + gcq_init_head(&t->timed); + gcq_init_head(&t->to); + gcq_init_head(&t->ap); +#ifdef SLHCI_WAITLOCK + gcq_init_head(&sc->sc_waitq); +#endif +} - /* USB spec 11.13.3 (p.260) */ - p = KERNADDR(&xfer->dmabuf, 0); - p[0] = 0; - if ((sc->sc_flags & (SLF_INSERT | SLF_RESET))) { - p[0] = 2; - DPRINTF(D_TRACE, ("!")); - } +int +slhci_attach(struct slhci_softc *sc) +{ + if (slhci_lock_call(sc, &slhci_do_attach, NULL, NULL) != + USBD_NORMAL_COMPLETION) + return -1; - /* no change, return NAK */ - if (p[0] == 0) - return; + /* Attach usb and uhub. */ + sc->sc_child = config_found(SC_DEV(sc), &sc->sc_bus, usbctlprint); - xfer->actlen = 1; - xfer->status = USBD_NORMAL_COMPLETION; - s = splusb(); - xfer->device->bus->intr_context++; - usb_transfer_complete(xfer); - xfer->device->bus->intr_context--; - splx(s); + if (!sc->sc_child) + return -1; + else + return 0; } -usbd_status -slhci_allocm(struct usbd_bus *bus, usb_dma_t *dma, u_int32_t size) +int +slhci_detach(struct slhci_softc *sc, int flags) { - struct slhci_softc *sc = (struct slhci_softc *)bus; + struct slhci_transfers *t; + int ret; - DPRINTF(D_MEM, ("SLallocm")); - return usb_allocmem(&sc->sc_bus, size, 0, dma); -} + t = &sc->sc_transfers; -void -slhci_freem(struct usbd_bus *bus, usb_dma_t *dma) + /* By this point bus access is no longer allowed. */ + + KASSERT(!(t->flags & F_ACTIVE)); + + /* To be MPSAFE is not sufficient to cancel callouts and soft + * interrupts and assume they are dead since the code could already be + * running or about to run. Wait until they are known to be done. */ + while (t->flags & (F_RESET|F_CALLBACK)) + tsleep(&sc, PPAUSE, "slhci_detach", hz); + + softint_disestablish(sc->sc_cb_softintr); + + ret = 0; + + if (sc->sc_child) + ret = config_detach(sc->sc_child, flags); + +#ifdef SLHCI_MEM_ACCOUNTING + if (sc->sc_mem_use) { + printf("%s: Memory still in use after detach! mem_use (count)" + " = %d\n", SC_NAME(sc), sc->sc_mem_use); + DDOLOG("%s: Memory still in use after detach! mem_use (count)" + " = %d\n", SC_NAME(sc), sc->sc_mem_use, 0,0); + } +#endif + + return ret; +} + +int +slhci_activate(struct device *self, enum devact act) { - struct slhci_softc *sc = (struct slhci_softc *)bus; + struct slhci_softc *sc; + + sc = (void *)self; + + if (act != DVACT_DEACTIVATE) + return EOPNOTSUPP; - DPRINTF(D_MEM, ("SLfreem")); - usb_freemem(&sc->sc_bus, dma); + slhci_lock_call(sc, &slhci_halt, NULL, NULL); + + if (sc->sc_child) + return config_deactivate(sc->sc_child); + else + return 0; } -usbd_xfer_handle -slhci_allocx(struct usbd_bus *bus) +void +slhci_abort(struct usbd_xfer *xfer) { - struct slhci_softc *sc = (struct slhci_softc *)bus; - usbd_xfer_handle xfer; + struct slhci_softc *sc; + struct slhci_pipe *spipe; + + spipe = (struct slhci_pipe *)xfer->pipe; + + if (spipe == NULL) + goto callback; + + sc = (struct slhci_softc *)spipe->pipe.device->bus; + + DLOG(D_TRACE, "%s abort xfer %p spipe %p spipe->xfer %p", + pnames(spipe->ptype), xfer, spipe, spipe->xfer); + + slhci_lock_call(sc, &slhci_do_abort, spipe, xfer); + +callback: + xfer->status = USBD_CANCELLED; + /* Abort happens at splsoftusb. */ + usb_transfer_complete(xfer); +} + +void +slhci_close(struct usbd_pipe *pipe) +{ + struct slhci_softc *sc; + struct slhci_pipe *spipe; + struct slhci_transfers *t; + + sc = (struct slhci_softc *)pipe->device->bus; + spipe = (struct slhci_pipe *)pipe; + t = &sc->sc_transfers; + + DLOG(D_TRACE, "%s close spipe %p spipe->xfer %p", + pnames(spipe->ptype), spipe, spipe->xfer, 0); + + slhci_lock_call(sc, &slhci_close_pipe, spipe, NULL); +} + +void +slhci_clear_toggle(struct usbd_pipe *pipe) +{ + struct slhci_pipe *spipe; + + spipe = (struct slhci_pipe *)pipe; - DPRINTF(D_MEM, ("SLallocx")); + DLOG(D_TRACE, "%s toggle spipe %p", pnames(spipe->ptype), + spipe,0,0); + + spipe->pflags &= ~PF_TOGGLE; - xfer = SIMPLEQ_FIRST(&sc->sc_free_xfers); - if (xfer) { - SIMPLEQ_REMOVE_HEAD(&sc->sc_free_xfers, next); #ifdef DIAGNOSTIC - if (xfer->busy_free != XFER_FREE) { - printf("slhci_allocx: xfer=%p not free, 0x%08x\n", - xfer, xfer->busy_free); - } + if (spipe->xfer != NULL) { + struct slhci_softc *sc = (struct slhci_softc + *)pipe->device->bus; + + printf("%s: Clear toggle on transfer in progress! halted\n", + SC_NAME(sc)); + DDOLOG("%s: Clear toggle on transfer in progress! halted\n", + SC_NAME(sc), 0,0,0); + slhci_halt(sc, NULL, NULL); + } +#endif +} + +void +slhci_poll(struct usbd_bus *bus) /* XXX necessary? */ +{ + struct slhci_softc *sc; + + sc = (struct slhci_softc *)bus; + + DLOG(D_TRACE, "slhci_poll", 0,0,0,0); + + slhci_lock_call(sc, &slhci_do_poll, NULL, NULL); +} + +void +slhci_done(struct usbd_xfer *xfer) +{ + /* xfer may not be valid here */ +} + +void +slhci_void(void *v) {} + +/* End out of lock functions. Start lock entry functions. */ + +#ifdef SLHCI_MEM_ACCOUNTING +void +slhci_mem_use(struct usbd_bus *bus, int val) +{ + struct slhci_softc *sc = (struct slhci_softc *)bus; + int s; + + s = splhardusb(); + simple_lock(&sc->sc_wait_lock); + sc->sc_mem_use += val; + simple_unlock(&sc->sc_wait_lock); + splx(s); +} #endif + +void +slhci_reset_entry(void *arg) +{ + struct slhci_softc *sc; + int s; + + sc = (struct slhci_softc *)arg; + + s = splhardusb(); + simple_lock(&sc->sc_lock); + slhci_reset(sc); + /* We cannot call the calback directly since we could then be reset + * again before finishing and need the callout delay for timing. + * Scheduling the callout again before we exit would defeat the reap + * mechanism since we could be unlocked while the reset flag is not + * set. The callback code will check the wait queue. */ + slhci_callback_schedule(sc); + simple_unlock(&sc->sc_lock); + splx(s); +} + +usbd_status +slhci_lock_call(struct slhci_softc *sc, LockCallFunc lcf, struct slhci_pipe + *spipe, struct usbd_xfer *xfer) +{ + usbd_status ret; + int x, s; + + x = splsoftusb(); + s = splhardusb(); + simple_lock(&sc->sc_lock); + ret = (*lcf)(sc, spipe, xfer); + slhci_main(sc, &s); + splx(s); + splx(x); + + return ret; +} + +void +slhci_start_entry(struct slhci_softc *sc, struct slhci_pipe *spipe) +{ + struct slhci_transfers *t; + int s; + + t = &sc->sc_transfers; + + s = splhardusb(); +#ifdef SLHCI_WAITLOCK + if (simple_lock_try(&sc->sc_lock)) +#else + simple_lock(&sc->sc_lock); +#endif + { + slhci_enter_xfer(sc, spipe); + slhci_dotransfer(sc); + slhci_main(sc, &s); +#ifdef SLHCI_WAITLOCK } else { - xfer = malloc(sizeof(*xfer), M_USB, M_NOWAIT); + simple_lock(&sc->sc_wait_lock); + enter_waitq(sc, spipe); + simple_unlock(&sc->sc_wait_lock); +#endif } + splx(s); +} - if (xfer) { - memset(xfer, 0, sizeof(*xfer)); -#ifdef DIAGNOSTIC - xfer->busy_free = XFER_BUSY; +void +slhci_callback_entry(void *arg) +{ + struct slhci_softc *sc; + struct slhci_transfers *t; + int s, x; + + + sc = (struct slhci_softc *)arg; + + x = splsoftusb(); + s = splhardusb(); + simple_lock(&sc->sc_lock); + t = &sc->sc_transfers; + DLOG(D_SOFT, "callback_entry flags %#x", t->flags, 0,0,0); + +#ifdef SLHCI_WAITLOCK +repeat: #endif + slhci_callback(sc, &s); + +#ifdef SLHCI_WAITLOCK + simple_lock(&sc->sc_wait_lock); + if (!gcq_empty(&sc->sc_waitq)) { + slhci_enter_xfers(sc); + simple_unlock(&sc->sc_wait_lock); + slhci_dotransfer(sc); + slhci_waitintr(sc, 0); + goto repeat; } - return xfer; + t->flags &= ~F_CALLBACK; + simple_unlock(&sc->sc_lock); + simple_unlock(&sc->sc_wait_lock); +#else + t->flags &= ~F_CALLBACK; + simple_unlock(&sc->sc_lock); +#endif + splx(s); + splx(x); } void -slhci_freex(struct usbd_bus *bus, usbd_xfer_handle xfer) +slhci_do_callback(struct slhci_softc *sc, struct usbd_xfer *xfer, int *s) { - struct slhci_softc *sc = (struct slhci_softc *)bus; + SLHCI_LOCKASSERT(sc, locked, unlocked); - DPRINTF(D_MEM, ("SLfreex")); + int repeat; -#ifdef DIAGNOSTIC - if (xfer->busy_free != XFER_BUSY) { - printf("slhci_freex: xfer=%p not busy, 0x%08x\n", - xfer, xfer->busy_free); - return; + sc->sc_bus.intr_context++; + start_cc_time(&t_callback, (u_int)xfer); + simple_unlock(&sc->sc_lock); + splx(*s); + + repeat = xfer->pipe->repeat; + + usb_transfer_complete(xfer); + + *s = splhardusb(); + simple_lock(&sc->sc_lock); + stop_cc_time(&t_callback); + sc->sc_bus.intr_context--; + + if (repeat && !sc->sc_bus.use_polling) + slhci_do_repeat(sc, xfer); +} + +int +slhci_intr(void *arg) +{ + struct slhci_softc *sc; + int ret; + + sc = (struct slhci_softc *)arg; + + start_cc_time(&t_hard_int, (unsigned int)arg); + simple_lock(&sc->sc_lock); + + ret = slhci_dointr(sc); + slhci_main(sc, NULL); + + stop_cc_time(&t_hard_int); + return ret; +} + +/* called with main lock only held, returns with locks released. */ +void +slhci_main(struct slhci_softc *sc, int *s) +{ + struct slhci_transfers *t; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + +#ifdef SLHCI_WAITLOCK +waitcheck: +#endif + slhci_waitintr(sc, slhci_wait_time); + + + /* + * XXX Directly calling the callback anytime s != NULL + * causes panic:sbdrop with aue (simultaneously using umass). + * Doing that affects process accounting, but is supposed to work as + * far as I can tell. + * + * The direct call is needed in the use_polling and disabled cases + * since the soft interrupt is not available. In the disabled case, + * this code can be reached from the usb detach, after the reaping of + * the soft interrupt. That test could be !F_ACTIVE (in which case + * s != NULL could be an assertion), but there is no reason not to + * make the callbacks directly in the other DISABLED cases. + */ + if ((t->flags & F_ROOTINTR) || !gcq_empty(&t->q[Q_CALLBACKS])) { + if (__predict_false(sc->sc_bus.use_polling || t->flags & + F_DISABLED) && s != NULL) + slhci_callback(sc, s); + else + slhci_callback_schedule(sc); + } + +#ifdef SLHCI_WAITLOCK + simple_lock(&sc->sc_wait_lock); + + if (!gcq_empty(&sc->sc_waitq)) { + slhci_enter_xfers(sc); + simple_unlock(&sc->sc_wait_lock); + slhci_dotransfer(sc); + goto waitcheck; } - xfer->busy_free = XFER_FREE; + + simple_unlock(&sc->sc_lock); + simple_unlock(&sc->sc_wait_lock); +#else + simple_unlock(&sc->sc_lock); #endif - SIMPLEQ_INSERT_HEAD(&sc->sc_free_xfers, xfer, next); } -void -slhci_noop(usbd_pipe_handle pipe) +/* End lock entry functions. Start in lock function. */ + +/* Register read/write routines and barriers. */ +#ifdef SLHCI_BUS_SPACE_BARRIERS +#define BSB(a, b, c, d, e) bus_space_barrier(a, b, c, d, BUS_SPACE_BARRIER_ # e) +#define BSB_SYNC(a, b, c, d) bus_space_barrier(a, b, c, d, BUS_SPACE_BARRIER_SYNC) +#else /* now !SLHCI_BUS_SPACE_BARRIERS */ +#define BSB(a, b, c, d, e) +#define BSB_SYNC(a, b, c, d) +#endif /* SLHCI_BUS_SPACE_BARRIERS */ + +static void +slhci_write(struct slhci_softc *sc, uint8_t addr, uint8_t data) { - DPRINTF(D_TRACE, ("%s()", __FUNCTION__)); + bus_size_t paddr, pdata, pst, psz; + bus_space_tag_t iot; + bus_space_handle_t ioh; + + paddr = pst = 0; + pdata = sc->sc_stride; + psz = pdata * 2; + iot = sc->sc_iot; + ioh = sc->sc_ioh; + + bus_space_write_1(iot, ioh, paddr, addr); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_WRITE); + bus_space_write_1(iot, ioh, pdata, data); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_WRITE); +} + +static uint8_t +slhci_read(struct slhci_softc *sc, uint8_t addr) +{ + bus_size_t paddr, pdata, pst, psz; + bus_space_tag_t iot; + bus_space_handle_t ioh; + uint8_t data; + + paddr = pst = 0; + pdata = sc->sc_stride; + psz = pdata * 2; + iot = sc->sc_iot; + ioh = sc->sc_ioh; + + bus_space_write_1(iot, ioh, paddr, addr); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_READ); + data = bus_space_read_1(iot, ioh, pdata); + BSB(iot, ioh, pst, psz, READ_BEFORE_WRITE); + return data; } -/* - * Data structures and routines to emulate the root hub. - */ -usb_device_descriptor_t slhci_devd = { - USB_DEVICE_DESCRIPTOR_SIZE, - UDESC_DEVICE, /* type */ - {0x01, 0x01}, /* USB version */ - UDCLASS_HUB, /* class */ - UDSUBCLASS_HUB, /* subclass */ - 0, /* protocol */ - 64, /* max packet */ - {USB_VENDOR_SCANLOGIC & 0xff, /* vendor ID (low) */ - USB_VENDOR_SCANLOGIC >> 8 }, /* vendor ID (high) */ - {0} /* ? */, /* product ID */ - {0}, /* device */ - 1, /* index to manufacturer */ - 2, /* index to product */ - 0, /* index to serial number */ - 1 /* number of configurations */ -}; +#if 0 /* auto-increment mode broken, see errata doc */ +static void +slhci_write_multi(struct slhci_softc *sc, uint8_t addr, uint8_t *buf, int l) +{ + bus_size_t paddr, pdata, pst, psz; + bus_space_tag_t iot; + bus_space_handle_t ioh; + + paddr = pst = 0; + pdata = sc->sc_stride; + psz = pdata * 2; + iot = sc->sc_iot; + ioh = sc->sc_ioh; + + bus_space_write_1(iot, ioh, paddr, addr); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_WRITE); + bus_space_write_multi_1(iot, ioh, pdata, buf, l); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_WRITE); +} -usb_config_descriptor_t slhci_confd = { - USB_CONFIG_DESCRIPTOR_SIZE, - UDESC_CONFIG, - {USB_CONFIG_DESCRIPTOR_SIZE + - USB_INTERFACE_DESCRIPTOR_SIZE + - USB_ENDPOINT_DESCRIPTOR_SIZE}, - 1, /* number of interfaces */ - 1, /* configuration value */ - 0, /* index to configuration */ - UC_SELF_POWERED, /* attributes */ - 15 /* max current is 30mA... */ -}; +static void +slhci_read_multi(struct slhci_softc *sc, uint8_t addr, uint8_t *buf, int l) +{ + bus_size_t paddr, pdata, pst, psz; + bus_space_tag_t iot; + bus_space_handle_t ioh; + + paddr = pst = 0; + pdata = sc->sc_stride; + psz = pdata * 2; + iot = sc->sc_iot; + ioh = sc->sc_ioh; + + bus_space_write_1(iot, ioh, paddr, addr); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_READ); + bus_space_read_multi_1(iot, ioh, pdata, buf, l); + BSB(iot, ioh, pst, psz, READ_BEFORE_WRITE); +} +#else +static void +slhci_write_multi(struct slhci_softc *sc, uint8_t addr, uint8_t *buf, int l) +{ +#if 1 + for (; l; addr++, buf++, l--) + slhci_write(sc, addr, *buf); +#else + bus_size_t paddr, pdata, pst, psz; + bus_space_tag_t iot; + bus_space_handle_t ioh; + + paddr = pst = 0; + pdata = sc->sc_stride; + psz = pdata * 2; + iot = sc->sc_iot; + ioh = sc->sc_ioh; + + for (; l; addr++, buf++, l--) { + bus_space_write_1(iot, ioh, paddr, addr); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_WRITE); + bus_space_write_1(iot, ioh, pdata, *buf); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_WRITE); + } +#endif +} -usb_interface_descriptor_t slhci_ifcd = { - USB_INTERFACE_DESCRIPTOR_SIZE, - UDESC_INTERFACE, - 0, /* interface number */ - 0, /* alternate setting */ - 1, /* number of endpoint */ - UICLASS_HUB, /* class */ - UISUBCLASS_HUB, /* subclass */ - 0, /* protocol */ - 0 /* index to interface */ -}; +static void +slhci_read_multi(struct slhci_softc *sc, uint8_t addr, uint8_t *buf, int l) +{ +#if 1 + for (; l; addr++, buf++, l--) + *buf = slhci_read(sc, addr); +#else + bus_size_t paddr, pdata, pst, psz; + bus_space_tag_t iot; + bus_space_handle_t ioh; + + paddr = pst = 0; + pdata = sc->sc_stride; + psz = pdata * 2; + iot = sc->sc_iot; + ioh = sc->sc_ioh; + + for (; l; addr++, buf++, l--) { + bus_space_write_1(iot, ioh, paddr, addr); + BSB(iot, ioh, pst, psz, WRITE_BEFORE_READ); + *buf = bus_space_read_1(iot, ioh, pdata); + BSB(iot, ioh, pst, psz, READ_BEFORE_WRITE); + } +#endif +} +#endif -usb_endpoint_descriptor_t slhci_endpd = { - USB_ENDPOINT_DESCRIPTOR_SIZE, - UDESC_ENDPOINT, - UE_DIR_IN | SLHCI_INTR_ENDPT, /* endpoint address */ - UE_INTERRUPT, /* attributes */ - {8}, /* max packet size */ - 255 /* interval */ -}; +/* After calling waitintr it is necessary to either call slhci_callback or + * schedule the callback if necessary. The callback cannot be called directly + * from the hard interrupt since it interrupts at a high IPL and callbacks + * can do copyout and such. */ +static void +slhci_waitintr(struct slhci_softc *sc, int wait_time) +{ + struct slhci_transfers *t; -usb_hub_descriptor_t slhci_hubd = { - USB_HUB_DESCRIPTOR_SIZE, - UDESC_HUB, - 1, /* number of ports */ - {UHD_PWR_INDIVIDUAL | UHD_OC_NONE, 0}, /* hub characteristics */ - 20 /* ? */, /* 5:power on to power good */ - 50, /* 6:maximum current */ - { 0x00 }, /* both ports are removable */ - { 0x00 } /* port power control mask */ -}; + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + if (__predict_false(sc->sc_bus.use_polling)) + wait_time = 12000; + + while (t->pend <= wait_time) { + DLOG(D_WAIT, "waiting... frame %d pend %d flags %#x", + t->frame, t->pend, t->flags, 0); + LK_SLASSERT(t->flags & F_ACTIVE, sc, NULL, NULL, return); + LK_SLASSERT(t->flags & (F_AINPROG|F_BINPROG), sc, NULL, NULL, + return); + slhci_dointr(sc); + } +} static int -slhci_str(usb_string_descriptor_t *p, int l, const char *s) +slhci_dointr(struct slhci_softc *sc) { - int i; + struct slhci_transfers *t; + struct slhci_pipe *tosp; + uint8_t r; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); - if (l == 0) + if (sc->sc_ier == 0) return 0; - p->bLength = 2 * strlen(s) + 2; - if (l == 1) + + r = slhci_read(sc, SL11_ISR); + +#ifdef SLHCI_DEBUG + if (slhci_debug & SLHCI_D_INTR && r & sc->sc_ier && + ((r & ~(SL11_ISR_SOF|SL11_ISR_DATA)) || slhci_debug & + SLHCI_D_SOF)) { + uint8_t e, f; + + e = slhci_read(sc, SL11_IER); + f = slhci_read(sc, SL11_CTRL); + DDOLOG("Flags=%#x IER=%#x ISR=%#x", t->flags, e, r, 0); + DDOLOGFLAG8("Status=", r, "D+", (f & SL11_CTRL_SUSPEND) ? + "RESUME" : "NODEV", "INSERT", "SOF", "res", "BABBLE", + "USBB", "USBA"); + } +#endif + + /* check IER for corruption occasionally. Assume that the above + * sc_ier == 0 case works correctly. */ + if (__predict_false(sc->sc_ier_check++ > SLHCI_IER_CHECK_FREQUENCY)) { + sc->sc_ier_check = 0; + if (sc->sc_ier != slhci_read(sc, SL11_IER)) { + printf("%s: IER value corrupted! halted\n", + SC_NAME(sc)); + DDOLOG("%s: IER value corrupted! halted\n", + SC_NAME(sc), 0,0,0); + slhci_halt(sc, NULL, NULL); + return 1; + } + } + + r &= sc->sc_ier; + + if (r == 0) + return 0; + + sc->sc_ier_check = 0; + + slhci_write(sc, SL11_ISR, r); + BSB_SYNC(sc->iot, sc->ioh, sc->pst, sc->psz); + + + /* If we have an insertion event we do not care about anything else. */ + if (__predict_false(r & SL11_ISR_INSERT)) { + slhci_insert(sc); return 1; - p->bDescriptorType = UDESC_STRING; - l -= 2; - for (i = 0; s[i] && l > 1; i++, l -= 2) - USETW2(p->bString[i], 0, s[i]); - return 2 * i + 2; -} + } -usbd_status -slhci_root_ctrl_transfer(usbd_xfer_handle xfer) -{ - usbd_status error; + stop_cc_time(&t_intr); + start_cc_time(&t_intr, r); - DPRINTF(D_TRACE, ("SLRCtrans ")); + if (r & SL11_ISR_SOF) { + t->frame++; - /* Insert last in queue */ - error = usb_insert_transfer(xfer); - if (error) { - DPRINTF(D_MSG, ("usb_insert_transfer returns err! ")); - return error; + gcq_merge_tail(&t->q[Q_CB], &t->q[Q_NEXT_CB]); + + /* SOFCHECK flags are cleared in tstart. Two flags are needed + * since the first SOF interrupt processed after the transfer + * is started might have been generated before the transfer + * was started. */ + if (__predict_false(t->flags & F_SOFCHECK2 && t->flags & + (F_AINPROG|F_BINPROG))) { + printf("%s: Missed transfer completion. halted\n", + SC_NAME(sc)); + DDOLOG("%s: Missed transfer completion. halted\n", + SC_NAME(sc), 0,0,0); + slhci_halt(sc, NULL, NULL); + return 1; + } else if (t->flags & F_SOFCHECK1) { + t->flags |= F_SOFCHECK2; + } else + t->flags |= F_SOFCHECK1; + + if (t->flags & F_CHANGE) + t->flags |= F_ROOTINTR; + + while (__predict_true(GOT_FIRST_TO(tosp, t)) && + __predict_false(tosp->to_frame <= t->frame)) { + tosp->xfer->status = USBD_TIMEOUT; + slhci_do_abort(sc, tosp, tosp->xfer); + enter_callback(t, tosp); + } + + /* Start any waiting transfers right away. If none, we will + * start any new transfers later. */ + slhci_tstart(sc); + } + + if (r & (SL11_ISR_USBA|SL11_ISR_USBB)) { + int ab; + + if ((r & (SL11_ISR_USBA|SL11_ISR_USBB)) == + (SL11_ISR_USBA|SL11_ISR_USBB)) { + if (!(t->flags & (F_AINPROG|F_BINPROG))) + return 1; /* presume card pulled */ + + LK_SLASSERT((t->flags & (F_AINPROG|F_BINPROG)) != + (F_AINPROG|F_BINPROG), sc, NULL, NULL, return 1); + + /* This should never happen (unless card removal just + * occurred) but appeared frequently when both + * transfers were started at the same time and was + * accompanied by data corruption. It still happens + * at times. I have not seen data correption except + * when the STATUS bit gets set, which now causes the + * driver to halt, however this should still not + * happen so the warning is kept. See comment in + * abdone, below. + */ + printf("%s: Transfer reported done but not started! " + "Verify data integrity if not detaching. " + " flags %#x r %x\n", SC_NAME(sc), t->flags, r); + + if (!(t->flags & F_AINPROG)) + r &= ~SL11_ISR_USBA; + else + r &= ~SL11_ISR_USBB; + } + t->pend = INT_MAX; + + if (r & SL11_ISR_USBA) + ab = A; + else + ab = B; + + /* This happens when a low speed device is attached to + * a hub with chip rev 1.5. SOF stops, but a few transfers + * still work before causing this error. + */ + if (!(t->flags & (ab ? F_BINPROG : F_AINPROG))) { + printf("%s: %s done but not in progress! halted\n", + SC_NAME(sc), ab ? "B" : "A"); + DDOLOG("%s: %s done but not in progress! halted\n", + SC_NAME(sc), ab ? "B" : "A", 0,0); + slhci_halt(sc, NULL, NULL); + return 1; + } + + t->flags &= ~(ab ? F_BINPROG : F_AINPROG); + slhci_tstart(sc); + stop_cc_time(&t_ab[ab]); + start_cc_time(&t_abdone, t->flags); + slhci_abdone(sc, ab); + stop_cc_time(&t_abdone); } - /* - * Pipe isn't running (otherwise error would be USBD_INPROG), - * so start it first. - */ - return slhci_root_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)); + slhci_dotransfer(sc); + + return 1; } -usbd_status -slhci_root_ctrl_start(usbd_xfer_handle xfer) +static void +slhci_abdone(struct slhci_softc *sc, int ab) { - struct slhci_softc *sc = (struct slhci_softc *)xfer->pipe->device->bus; - usb_device_request_t *req; - int len, value, index, l, s, status; - int totlen = 0; - void *buf = NULL; - usb_port_status_t ps; - usbd_status error; - char slbuf[50]; - u_int8_t r; + struct slhci_transfers *t; + struct slhci_pipe *spipe; + struct usbd_xfer *xfer; + uint8_t status, buf_start; + uint8_t *target_buf; + unsigned int actlen; + int head; - DPRINTF(D_TRACE, ("SLRCstart ")); + t = &sc->sc_transfers; - req = &xfer->request; + SLHCI_LOCKASSERT(sc, locked, unlocked); - len = UGETW(req->wLength); - value = UGETW(req->wValue); - index = UGETW(req->wIndex); + DLOG(D_TRACE, "ABDONE flags %#x", t->flags, 0,0,0); - if (len) - buf = KERNADDR(&xfer->dmabuf, 0); + DLOG(D_MSG, "DONE %s spipe %p len %d xfer %p", ab ? "B" : "A", + t->spipe[ab], t->len[ab], t->spipe[ab] ? + t->spipe[ab]->xfer : NULL); + + spipe = t->spipe[ab]; + + /* skip this one if aborted; do not call return from the rest of the + * function unless halting, else t->len will not be cleared. */ + if (spipe == NULL) + goto done; + + t->spipe[ab] = NULL; + + xfer = spipe->xfer; + + gcq_remove(&spipe->to); + + LK_SLASSERT(xfer != NULL, sc, spipe, NULL, return); + + status = slhci_read(sc, slhci_tregs[ab][STAT]); + + /* + * I saw no status or remaining length greater than the requested + * length in early driver versions in circumstances I assumed caused + * excess power draw. I am no longer able to reproduce this when + * causing excess power draw circumstances. + * + * Disabling a power check and attaching aue to a keyboard and hub + * that is directly attached (to CFU1U, 100mA max, aue 160mA, keyboard + * 98mA) sometimes works and sometimes fails to configure. After + * removing the aue and attaching a self-powered umass dvd reader + * (unknown if it draws power from the host also) soon a single Error + * status occurs then only timeouts. The controller soon halts freeing + * memory due to being ONQU instead of BUSY. This may be the same + * basic sequence that caused the no status/bad length errors. The + * umass device seems to work (better at least) with the keyboard hub + * when not first attaching aue (tested once reading an approximately + * 200MB file). + * + * Overflow can indicate that the device and host disagree about how + * much data has been transfered. This may indicate a problem at any + * point during the transfer, not just when the error occurs. It may + * indicate data corruption. A warning message is printed. + * + * Trying to use both A and B transfers at the same time results in + * incorrect transfer completion ISR reports and the status will then + * include SL11_EPSTAT_SETUP, which is apparently set while the + * transfer is in progress. I also noticed data corruption, even + * after waiting for the transfer to complete. The driver now avoids + * trying to start both at the same time. + * + * I had accidently initialized the B registers before they were valid + * in some driver versions. Since every other performance enhancing + * feature has been confirmed buggy in the errata doc, I have not + * tried both transfers at once again with the documented + * initialization order. + * + * However, I have seen this problem again ("done but not started" + * errors), which in some cases cases the SETUP status bit to remain + * set on future transfers. In other cases, the SETUP bit is not set + * and no data corruption occurs. This occured while using both umass + * and aue on a powered hub (maybe triggered by some local activity + * also) and needs several reads of the 200MB file to trigger. The + * driver now halts if SETUP is detected. + */ + + actlen = 0; + + if (__predict_false(!status)) { + DDOLOG("no status! xfer %p spipe %p", xfer, spipe, 0,0); + printf("%s: no status! halted\n", SC_NAME(sc)); + slhci_halt(sc, spipe, xfer); + return; + } #ifdef SLHCI_DEBUG - if ((slhci_debug & D_TRACE)) - print_req_hub(req); + if (slhci_debug & SLHCI_D_NAK || (status & SL11_EPSTAT_ERRBITS) != + SL11_EPSTAT_NAK) + DLOGFLAG8(D_XFER, "STATUS=", status, "STALL", "NAK", + "Overflow", "Setup", "Data Toggle", "Timeout", "Error", + "ACK"); #endif -#define C(x,y) ((x) | ((y) << 8)) - switch (C(req->bRequest, req->bmRequestType)) { - case C(UR_CLEAR_FEATURE, UT_WRITE_DEVICE): - case C(UR_CLEAR_FEATURE, UT_WRITE_INTERFACE): - case C(UR_CLEAR_FEATURE, UT_WRITE_ENDPOINT): - DPRINTF(D_MSG, ("UR_CLEAR_FEATURE ")); - break; - case C(UR_GET_CONFIG, UT_READ_DEVICE): - DPRINTF(D_MSG, ("UR_GET_CONFIG ")); - if (len > 0) { - *(u_int8_t *)buf = sc->sc_conf; - totlen = 1; + if (!(status & SL11_EPSTAT_ERRBITS)) { + unsigned int cont; + cont = slhci_read(sc, slhci_tregs[ab][CONT]); + if (cont != 0) + DLOG(D_XFER, "cont %d len %d", cont, + spipe->tregs[LEN], 0,0); + if (__predict_false(cont > spipe->tregs[LEN])) { + DDOLOG("cont > len! cont %d len %d xfer->length %d " + "spipe %p", cont, spipe->tregs[LEN], xfer->length, + spipe); + printf("%s: cont > len! cont %d len %d xfer->length " + "%d", SC_NAME(sc), cont, spipe->tregs[LEN], + xfer->length); + slhci_halt(sc, spipe, xfer); + return; + } else { + spipe->nerrs = 0; + actlen = spipe->tregs[LEN] - cont; } - break; - case C(UR_GET_DESCRIPTOR, UT_READ_DEVICE): - switch (value >> 8) { - case UDESC_DEVICE: - DPRINTF(D_MSG, ("UDESC_DEVICE ")); - if ((value & 0xff) != 0) { - error = USBD_IOERROR; - goto ret; - } - totlen = l = min(len, USB_DEVICE_DESCRIPTOR_SIZE); - memcpy(buf, &slhci_devd, l); - break; - case UDESC_CONFIG: - DPRINTF(D_MSG, ("UDESC_CONFIG ")); - if ((value & 0xff) != 0) { - error = USBD_IOERROR; - goto ret; + } + + /* Actual copyin done after starting next transfer. */ + if (actlen && (spipe->tregs[PID] & SL11_PID_BITS) == SL11_PID_IN) { + target_buf = spipe->buffer; + buf_start = spipe->tregs[ADR]; + } else { + target_buf = NULL; + buf_start = 0; /* XXX gcc uninitialized warnings */ + } + + if (status & SL11_EPSTAT_ERRBITS) { + status &= SL11_EPSTAT_ERRBITS; + if (status & SL11_EPSTAT_SETUP) { + printf("%s: Invalid controller state detected! " + "halted\n", SC_NAME(sc)); + DDOLOG("%s: Invalid controller state detected! " + "halted\n", SC_NAME(sc), 0,0,0); + slhci_halt(sc, spipe, xfer); + return; + } else if (__predict_false(sc->sc_bus.use_polling)) { + if (status == SL11_EPSTAT_STALL) + xfer->status = USBD_STALLED; + else if (status == SL11_EPSTAT_TIMEOUT) + xfer->status = USBD_TIMEOUT; + else if (status == SL11_EPSTAT_NAK) + xfer->status = USBD_TIMEOUT; /*XXX*/ + else + xfer->status = USBD_IOERROR; + head = Q_CALLBACKS; + } else if (status == SL11_EPSTAT_NAK) { + if (spipe->pipe.interval) { + spipe->lastframe = spipe->frame = + t->frame + spipe->pipe.interval; + slhci_queue_timed(sc, spipe); + goto queued; } - totlen = l = min(len, USB_CONFIG_DESCRIPTOR_SIZE); - memcpy(buf, &slhci_confd, l); - buf = (char *)buf + l; - len -= l; - - l = min(len, USB_INTERFACE_DESCRIPTOR_SIZE); - totlen += l; - memcpy(buf, &slhci_ifcd, l); - buf = (char *)buf + l; - len -= l; - - l = min(len, USB_ENDPOINT_DESCRIPTOR_SIZE); - totlen += l; - memcpy(buf, &slhci_endpd, l); - break; - case UDESC_STRING: - DPRINTF(D_MSG, ("UDESC_STR ")); - if (len == 0) - break; - *(u_int8_t *)buf = 0; - totlen = 1; - switch (value & 0xff) { - case 0: - break; - case 1: /* Vendor */ - totlen = slhci_str(buf, len, "ScanLogic"); - break; - case 2: /* Product */ - snprintf(slbuf, sizeof(slbuf), "%s root hub", - sltypestr[sc->sc_sltype]); - totlen = slhci_str(buf, len, slbuf); - break; - default: - printf("strerr%d ", value & 0xff); - break; + head = Q_NEXT_CB; + } else if (++spipe->nerrs > SLHCI_MAX_RETRIES || + status == SL11_EPSTAT_STALL) { + if (status == SL11_EPSTAT_STALL) + xfer->status = USBD_STALLED; + else if (status == SL11_EPSTAT_TIMEOUT) + xfer->status = USBD_TIMEOUT; + else + xfer->status = USBD_IOERROR; + + DLOG(D_ERR, "Max retries reached! status %#x " + "xfer->status %#x", status, xfer->status, 0,0); + DLOGFLAG8(D_ERR, "STATUS=", status, "STALL", + "NAK", "Overflow", "Setup", "Data Toggle", + "Timeout", "Error", "ACK"); + + if (status == SL11_EPSTAT_OVERFLOW && + ratecheck(&sc->sc_overflow_warn_rate, + &overflow_warn_rate)) { + printf("%s: Overflow condition: " + "data corruption possible\n", + SC_NAME(sc)); + DDOLOG("%s: Overflow condition: " + "data corruption possible\n", + SC_NAME(sc), 0,0,0); } - break; - default: - printf("unknownGetDescriptor=%x", value); - error = USBD_IOERROR; - break; - } - break; - case C(UR_GET_INTERFACE, UT_READ_INTERFACE): - /* Get Interface, 9.4.4 */ - if (len > 0) { - *(u_int8_t *)buf = 0; - totlen = 1; - } - break; - case C(UR_GET_STATUS, UT_READ_DEVICE): - /* Get Status from device, 9.4.5 */ - if (len > 1) { - USETW(((usb_status_t *)buf)->wStatus, UDS_SELF_POWERED); - totlen = 2; - } - break; - case C(UR_GET_STATUS, UT_READ_INTERFACE): - case C(UR_GET_STATUS, UT_READ_ENDPOINT): - /* Get Status from interface, endpoint, 9.4.5 */ - if (len > 1) { - USETW(((usb_status_t *)buf)->wStatus, 0); - totlen = 2; + head = Q_CALLBACKS; + } else { + head = Q_NEXT_CB; } - break; - case C(UR_SET_ADDRESS, UT_WRITE_DEVICE): - /* Set Address, 9.4.6 */ - DPRINTF(D_MSG, ("UR_SET_ADDRESS ")); - if (value >= USB_MAX_DEVICES) { - error = USBD_IOERROR; - goto ret; + } else if (spipe->ptype == PT_CTRL_SETUP) { + spipe->tregs[PID] = spipe->newpid; + + if (xfer->length) { + LK_SLASSERT(spipe->newlen[1] != 0, sc, spipe, xfer, + return); + spipe->tregs[LEN] = spipe->newlen[1]; + spipe->bustime = spipe->newbustime[1]; + spipe->buffer = KERNADDR(&xfer->dmabuf, 0); + spipe->ptype = PT_CTRL_DATA; + } else { +status_setup: + /* CTRL_DATA swaps direction in PID then jumps here */ + spipe->tregs[LEN] = 0; + if (spipe->pflags & PF_LS) + spipe->bustime = SLHCI_LS_CONST; + else + spipe->bustime = SLHCI_FS_CONST; + spipe->ptype = PT_CTRL_STATUS; + spipe->buffer = NULL; + } + + /* Status or first data packet must be DATA1. */ + spipe->control |= SL11_EPCTRL_DATATOGGLE; + if ((spipe->tregs[PID] & SL11_PID_BITS) == SL11_PID_IN) + spipe->control &= ~SL11_EPCTRL_DIRECTION; + else + spipe->control |= SL11_EPCTRL_DIRECTION; + + head = Q_CB; + } else if (spipe->ptype == PT_CTRL_STATUS) { + head = Q_CALLBACKS; + } else { /* bulk, intr, control data */ + xfer->actlen += actlen; + spipe->control ^= SL11_EPCTRL_DATATOGGLE; + + if (actlen == spipe->tregs[LEN] && (xfer->length > + xfer->actlen || spipe->wantshort)) { + spipe->buffer += actlen; + LK_SLASSERT(xfer->length >= xfer->actlen, sc, + spipe, xfer, return); + if (xfer->length - xfer->actlen < actlen) { + spipe->wantshort = 0; + spipe->tregs[LEN] = spipe->newlen[0]; + spipe->bustime = spipe->newbustime[0]; + LK_SLASSERT(xfer->actlen + + spipe->tregs[LEN] == xfer->length, sc, + spipe, xfer, return); + } + head = Q_CB; + } else if (spipe->ptype == PT_CTRL_DATA) { + spipe->tregs[PID] ^= SLHCI_PID_SWAP_IN_OUT; + goto status_setup; + } else { + if (spipe->ptype == PT_INTR) { + spipe->lastframe += + spipe->pipe.interval; + /* If ack, we try to keep the + * interrupt rate by using lastframe + * instead of the current frame. */ + spipe->frame = spipe->lastframe + + spipe->pipe.interval; + } + + /* Set the toggle for the next transfer. It + * has already been toggled above, so the + * current setting will apply to the next + * transfer. */ + if (spipe->control & SL11_EPCTRL_DATATOGGLE) + spipe->pflags |= PF_TOGGLE; + else + spipe->pflags &= ~PF_TOGGLE; + + head = Q_CALLBACKS; } - sc->sc_addr = value; - break; - case C(UR_SET_CONFIG, UT_WRITE_DEVICE): - /* Set Configuration, 9.4.7 */ - DPRINTF(D_MSG, ("UR_SET_CONFIG ")); - if (value != 0 && value != 1) { - error = USBD_IOERROR; - goto ret; + } + + if (head == Q_CALLBACKS) { + gcq_remove(&spipe->to); + + if (xfer->status == USBD_IN_PROGRESS) { + LK_SLASSERT(xfer->actlen <= xfer->length, sc, + spipe, xfer, return); + xfer->status = USBD_NORMAL_COMPLETION; +#if 0 /* usb_transfer_complete will do this */ + if (xfer->length == xfer->actlen || xfer->flags & + USBD_SHORT_XFER_OK) + xfer->status = USBD_NORMAL_COMPLETION; + else + xfer->status = USBD_SHORT_XFER; +#endif } - sc->sc_conf = value; - break; - case C(UR_SET_DESCRIPTOR, UT_WRITE_DEVICE): - /* Set Descriptor, 9.4.8, not supported */ - DPRINTF(D_MSG, ("UR_SET_DESCRIPTOR,WRITE_DEVICE not supported\n")); - break; - case C(UR_SET_FEATURE, UT_WRITE_DEVICE): - case C(UR_SET_FEATURE, UT_WRITE_INTERFACE): - case C(UR_SET_FEATURE, UT_WRITE_ENDPOINT): - /* Set Feature, 9.4.9, not supported */ - DPRINTF(D_MSG, ("UR_SET_FEATURE not supported\n")); - error = USBD_IOERROR; - break; - case C(UR_SET_INTERFACE, UT_WRITE_INTERFACE): - /* Set Interface, 9.4.10, not supported */ - break; - case C(UR_SYNCH_FRAME, UT_WRITE_ENDPOINT): - /* Synch Frame, 9.4.11, not supported */ - break; + } - /* - * Hub specific requests - */ - case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_DEVICE): - /* Clear Hub Feature, 11.16.2.1, not supported */ - DPRINTF(D_MSG, ("ClearHubFeature not supported\n")); - break; - case C(UR_CLEAR_FEATURE, UT_WRITE_CLASS_OTHER): - /* Clear Port Feature, 11.16.2.2 */ - if (index != 1) { - error = USBD_IOERROR; - goto ret; - } - switch (value) { - case UHF_PORT_POWER: - DPRINTF(D_MSG, ("POWER_OFF ")); - sc->sc_powerstat = POWER_OFF; - /* x68k Nereid USB controller needs it */ - if (sc->sc_enable_power) - sc->sc_enable_power(sc, sc->sc_powerstat); - break; - case UHF_PORT_SUSPEND: - DPRINTF(D_MSG, ("SUSPEND ")); - sl11write(sc, SL11_CTRL, - sl11read(sc, SL11_CTRL) & ~SL11_CTRL_SUSPEND); - break; - case UHF_C_PORT_CONNECTION: - sc->sc_change &= ~UPS_C_CONNECT_STATUS; - break; - case UHF_C_PORT_RESET: - sc->sc_change &= ~UPS_C_PORT_RESET; - break; - case UHF_PORT_ENABLE: - break; - case UHF_C_PORT_SUSPEND: - case UHF_C_PORT_ENABLE: - case UHF_C_PORT_OVER_CURRENT: - default: - printf("ClrPortFeatERR:value=0x%x ", value); - error = USBD_IOERROR; - break; + enter_q(t, spipe, head); + +queued: + if (target_buf != NULL) { + slhci_dotransfer(sc); + start_cc_time(&t_copy_from_dev, actlen); + slhci_read_multi(sc, buf_start, target_buf, actlen); + stop_cc_time(&t_copy_from_dev); + DLOGBUF(D_BUF, target_buf, actlen); + t->pend -= SLHCI_FS_CONST + SLHCI_FS_DATA_TIME(actlen); + } + +done: + t->len[ab] = -1; +} + +static void +slhci_tstart(struct slhci_softc *sc) +{ + struct slhci_transfers *t; + struct slhci_pipe *spipe; + int remaining_bustime; + int s; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + if (!(t->flags & (F_AREADY|F_BREADY))) + return; + + if (t->flags & (F_AINPROG|F_BINPROG|F_DISABLED)) + return; + + /* We have about 6 us to get from the bus time check to + * starting the transfer or we might babble or the chip might fail to + * signal transfer complete. This leaves no time for any other + * interrupts. Some ports have splipi (MP only) higher than splhigh + * which might cause longer delays. */ + s = splhigh(); + remaining_bustime = (int)(slhci_read(sc, SL811_CSOF)) << 6; + remaining_bustime -= SLHCI_END_BUSTIME; + + /* Start one transfer only, clearing any aborted transfers that are + * not yet in progress and skipping missed isoc. It is easier to copy + * & paste most of the A/B sections than to make the logic work + * otherwise and this allows better constant use. */ + if (t->flags & F_AREADY) { + spipe = t->spipe[A]; + if (spipe == NULL) { + t->flags &= ~F_AREADY; + t->len[A] = -1; + } else if (remaining_bustime >= spipe->bustime) { + t->flags &= ~(F_AREADY|F_SOFCHECK1|F_SOFCHECK2); + t->flags |= F_AINPROG; + start_cc_time(&t_ab[A], spipe->tregs[LEN]); + slhci_write(sc, SL11_E0CTRL, spipe->control); + goto pend; + } + } + if (t->flags & F_BREADY) { + spipe = t->spipe[B]; + if (spipe == NULL) { + t->flags &= ~F_BREADY; + t->len[B] = -1; + } else if (remaining_bustime >= spipe->bustime) { + t->flags &= ~(F_BREADY|F_SOFCHECK1|F_SOFCHECK2); + t->flags |= F_BINPROG; + start_cc_time(&t_ab[B], spipe->tregs[LEN]); + slhci_write(sc, SL11_E1CTRL, spipe->control); +pend: + t->pend = spipe->bustime; } - //DPRINTF(D_XFER, ("CH=%04x ", sc->sc_change)); - break; - case C(UR_GET_BUS_STATE, UT_READ_CLASS_OTHER): - /* Get Bus State, 11.16.2.3, not supported */ - /* shall return a STALL... */ - break; - case C(UR_GET_DESCRIPTOR, UT_READ_CLASS_DEVICE): - /* Get Hub Descriptor, 11.16.2.4 */ - if (value != 0) { - error = USBD_IOERROR; - goto ret; - } - l = min(len, USB_HUB_DESCRIPTOR_SIZE); - totlen = l; - memcpy(buf, &slhci_hubd, l); - break; - case C(UR_GET_STATUS, UT_READ_CLASS_DEVICE): - /* Get Hub Status, 11.16.2.5 */ - DPRINTF(D_MSG, ("UR_GET_STATUS RCD")); - if (len != 4) { - error = USBD_IOERROR; - goto ret; + } + splx(s); +} + +static void +slhci_dotransfer(struct slhci_softc *sc) +{ + struct slhci_transfers *t; + struct slhci_pipe *spipe; + int ab, i; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + while ((t->len[A] == -1 || t->len[B] == -1) && + (GOT_FIRST_TIMED_COND(spipe, t, spipe->frame <= t->frame) || + GOT_FIRST_CB(spipe, t))) { + LK_SLASSERT(spipe->xfer != NULL, sc, spipe, NULL, return); + LK_SLASSERT(spipe->ptype != PT_ROOT_CTRL && spipe->ptype != + PT_ROOT_INTR, sc, spipe, NULL, return); + + /* Check that this transfer can fit in the remaining memory. */ + if (t->len[A] + t->len[B] + spipe->tregs[LEN] + 1 > + SL11_MAX_PACKET_SIZE) { + DLOG(D_XFER, "Transfer does not fit. alen %d blen %d " + "len %d", t->len[A], t->len[B], spipe->tregs[LEN], + 0); + return; } - memset(buf, 0, len); - totlen = len; - break; - case C(UR_GET_STATUS, UT_READ_CLASS_OTHER): - /* Get Port Status, 11.16.2.6 */ - if (index != 1 || len != 4) { - printf("index=%d,len=%d ", index, len); - error = USBD_IOERROR; - goto ret; - } - /* - * change - * o port is always enabled. - * o cannot detect over current. - */ - s = splusb(); - sc->sc_change &= ~(UPS_C_CONNECT_STATUS | UPS_C_PORT_RESET); - if ((sc->sc_flags & SLF_INSERT)) { - sc->sc_flags &= ~SLF_INSERT; - sc->sc_change |= UPS_C_CONNECT_STATUS; - } - if ((sc->sc_flags & SLF_RESET)) { - sc->sc_flags &= ~SLF_RESET; - sc->sc_change |= UPS_C_PORT_RESET; - } - splx(s); - /* - * XXX It can recognize that device is detached, - * while there is sl11_speed() here. - */ - if (sc->sc_change) - sl11_speed(sc); - /* - * status - * o port is always enabled. - * o cannot detect over current. - */ - status = 0; - if (sc->sc_connect) - status |= UPS_CURRENT_CONNECT_STATUS | UPS_PORT_ENABLED; - r = sl11read(sc, SL11_CTRL); - if (r & SL11_CTRL_SUSPEND) - status |= UPS_SUSPEND; - if (sc->sc_powerstat) - status |= UPS_PORT_POWER; - if (!sc->sc_fullspeed) - status |= UPS_LOW_SPEED; - - //DPRINTF(D_XFER, ("ST=%04x,CH=%04x ", status, sc->sc_change)); - USETW(ps.wPortStatus, status); - USETW(ps.wPortChange, sc->sc_change); - l = min(len, sizeof(ps)); - memcpy(buf, &ps, l); - totlen = l; - break; - case C(UR_SET_DESCRIPTOR, UT_WRITE_CLASS_DEVICE): - /* Set Hub Descriptor, 11.16.2.7, not supported */ - /* STALL ? */ - error = USBD_IOERROR; - break; - case C(UR_SET_FEATURE, UT_WRITE_CLASS_DEVICE): - /* Set Hub Feature, 11.16.2.8, not supported */ - break; - case C(UR_SET_FEATURE, UT_WRITE_CLASS_OTHER): - /* Set Port Feature, 11.16.2.9 */ - if (index != 1) { - printf("index=%d ", index); - error = USBD_IOERROR; - goto ret; - } - switch (value) { - case UHF_PORT_RESET: - DPRINTF(D_MSG, ("PORT_RESET ")); - sl11_reset(sc); - sl11_speed(sc); - sc->sc_change = 0; - break; - case UHF_PORT_POWER: - DPRINTF(D_MSG, ("PORT_POWER ")); - sc->sc_powerstat = POWER_ON; - /* x68k Nereid USB controller needs it */ - if (sc->sc_enable_power) - sc->sc_enable_power(sc, sc->sc_powerstat); - delay_ms(25); - break; - default: - printf("SetPortFeatERR=0x%x ", value); - error = USBD_IOERROR; - break; + + gcq_remove(&spipe->xq); + + if (t->len[A] == -1) { + ab = A; + spipe->tregs[ADR] = SL11_BUFFER_START; + } else { + ab = B; + spipe->tregs[ADR] = SL11_BUFFER_END - + spipe->tregs[LEN]; + } + + t->len[ab] = spipe->tregs[LEN]; + + if (spipe->tregs[LEN] && (spipe->tregs[PID] & SL11_PID_BITS) + != SL11_PID_IN) { + start_cc_time(&t_copy_to_dev, + spipe->tregs[LEN]); + slhci_write_multi(sc, spipe->tregs[ADR], + spipe->buffer, spipe->tregs[LEN]); + stop_cc_time(&t_copy_to_dev); + t->pend -= SLHCI_FS_CONST + + SLHCI_FS_DATA_TIME(spipe->tregs[LEN]); + } + + DLOG(D_MSG, "NEW TRANSFER %s flags %#x alen %d blen %d", + ab ? "B" : "A", t->flags, t->len[0], t->len[1]); + + if (spipe->tregs[LEN]) + i = 0; + else + i = 1; + + for (; i <= 3; i++) + if (t->current_tregs[ab][i] != spipe->tregs[i]) { + t->current_tregs[ab][i] = spipe->tregs[i]; + slhci_write(sc, slhci_tregs[ab][i], + spipe->tregs[i]); + } + + DLOG(D_SXFER, "Transfer len %d pid %#x dev %d type %s", + spipe->tregs[LEN], spipe->tregs[PID], spipe->tregs[DEV], + pnames(spipe->ptype)); + + t->spipe[ab] = spipe; + t->flags |= ab ? F_BREADY : F_AREADY; + + slhci_tstart(sc); + } +} + +/* slhci_callback is called after the lock is taken from splsoftusb. + * s is pointer to old spl (splsoftusb). */ +static void +slhci_callback(struct slhci_softc *sc, int *s) +{ + struct slhci_transfers *t; + struct slhci_pipe *spipe; + struct usbd_xfer *xfer; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + DLOG(D_SOFT, "CB flags %#x", t->flags, 0,0,0); + for (;;) { + if (__predict_false(t->flags & F_ROOTINTR)) { + t->flags &= ~F_ROOTINTR; + if (t->rootintr != NULL) { + u_char *p; + + p = KERNADDR(&t->rootintr->dmabuf, 0); + p[0] = 2; + t->rootintr->actlen = 1; + t->rootintr->status = USBD_NORMAL_COMPLETION; + xfer = t->rootintr; + goto do_callback; + } + } + + + if (!DEQUEUED_CALLBACK(spipe, t)) + return; + + xfer = spipe->xfer; + LK_SLASSERT(xfer != NULL, sc, spipe, NULL, return); + spipe->xfer = NULL; + DLOG(D_XFER, "xfer callback length %d actlen %d spipe %x " + "type %s", xfer->length, xfer->actlen, spipe, + pnames(spipe->ptype)); +do_callback: + slhci_do_callback(sc, xfer, s); + } +} + +static void +slhci_enter_xfer(struct slhci_softc *sc, struct slhci_pipe *spipe) +{ + struct slhci_transfers *t; + + t = &sc->sc_transfers; + + SLHCI_MAINLOCKASSERT(sc); + + if (__predict_false(t->flags & F_DISABLED) || + __predict_false(spipe->pflags & PF_GONE)) { + DLOG(D_MSG, "slhci_enter_xfer: DISABLED or GONE", 0,0,0,0); + spipe->xfer->status = USBD_CANCELLED; + } + + if (spipe->xfer->status == USBD_IN_PROGRESS) { + if (spipe->xfer->timeout) { + spipe->to_frame = t->frame + spipe->xfer->timeout; + slhci_xfer_timer(sc, spipe); } - break; - default: - DPRINTF(D_MSG, ("ioerr(UR=%02x,UT=%02x) ", - req->bRequest, req->bmRequestType)); - error = USBD_IOERROR; - goto ret; + if (spipe->pipe.interval) + slhci_queue_timed(sc, spipe); + else + enter_q(t, spipe, Q_CB); + } else + enter_callback(t, spipe); +} + +#ifdef SLHCI_WAITLOCK +static void +slhci_enter_xfers(struct slhci_softc *sc) +{ + struct slhci_pipe *spipe; + + SLHCI_LOCKASSERT(sc, locked, locked); + + while (DEQUEUED_WAITQ(spipe, sc)) + slhci_enter_xfer(sc, spipe); +} +#endif + +static void +slhci_queue_timed(struct slhci_softc *sc, struct slhci_pipe *spipe) +{ + struct slhci_transfers *t; + struct gcq *q; + struct slhci_pipe *spp; + + t = &sc->sc_transfers; + + SLHCI_MAINLOCKASSERT(sc); + + FIND_TIMED(q, t, spp, spp->frame > spipe->frame); + gcq_insert_before(q, &spipe->xq); +} + +static void +slhci_xfer_timer(struct slhci_softc *sc, struct slhci_pipe *spipe) +{ + struct slhci_transfers *t; + struct gcq *q; + struct slhci_pipe *spp; + + t = &sc->sc_transfers; + + SLHCI_MAINLOCKASSERT(sc); + + FIND_TO(q, t, spp, spp->to_frame >= spipe->to_frame); + gcq_insert_before(q, &spipe->to); +} + +static void +slhci_do_repeat(struct slhci_softc *sc, struct usbd_xfer *xfer) +{ + struct slhci_transfers *t; + struct slhci_pipe *spipe; + + t = &sc->sc_transfers; + spipe = (struct slhci_pipe *)xfer->pipe; + + if (xfer == t->rootintr) + return; + + DLOG(D_TRACE, "REPEAT: xfer %p actlen %d frame %u now %u", + xfer, xfer->actlen, spipe->frame, sc->sc_transfers.frame); + + xfer->actlen = 0; + spipe->xfer = xfer; + if (spipe->tregs[LEN]) + KASSERT(spipe->buffer == KERNADDR(&xfer->dmabuf, 0)); + slhci_queue_timed(sc, spipe); + slhci_dotransfer(sc); +} + +static void +slhci_callback_schedule(struct slhci_softc *sc) +{ + struct slhci_transfers *t; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + if (t->flags & F_ACTIVE) + slhci_do_callback_schedule(sc); +} + +static void +slhci_do_callback_schedule(struct slhci_softc *sc) +{ + struct slhci_transfers *t; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + if (!(t->flags & F_CALLBACK)) { + t->flags |= F_CALLBACK; + softint_schedule(sc->sc_cb_softintr); } - xfer->actlen = totlen; - error = USBD_NORMAL_COMPLETION; - ret: - xfer->status = error; - s = splusb(); - usb_transfer_complete(xfer); - splx(s); - return USBD_IN_PROGRESS; } -void -slhci_root_ctrl_abort(usbd_xfer_handle xfer) +#if 0 +/* must be called with lock taken from splsoftusb */ +/* XXX static */ void +slhci_pollxfer(struct slhci_softc *sc, struct usbd_xfer *xfer, int *s) { - DPRINTF(D_TRACE, ("SLRCabort ")); + SLHCI_LOCKASSERT(sc, locked, unlocked); + slhci_dotransfer(sc); + do { + slhci_dointr(sc); + } while (xfer->status == USBD_IN_PROGRESS); + slhci_do_callback(sc, xfer, s); } +#endif -void -slhci_root_ctrl_close(usbd_pipe_handle pipe) +static usbd_status +slhci_do_poll(struct slhci_softc *sc, struct slhci_pipe *spipe, struct + usbd_xfer *xfer) { - DPRINTF(D_TRACE, ("SLRCclose ")); + slhci_waitintr(sc, 0); + + return USBD_NORMAL_COMPLETION; } -void -slhci_root_ctrl_done(usbd_xfer_handle xfer) +static usbd_status +slhci_lsvh_warn(struct slhci_softc *sc, struct slhci_pipe *spipe, struct + usbd_xfer *xfer) { - DPRINTF(D_TRACE, ("SLRCdone\n")); + struct slhci_transfers *t; + + t = &sc->sc_transfers; + + if (!(t->flags & F_LSVH_WARNED)) { + printf("%s: Low speed device via hub disabled, " + "see slhci(4)\n", SC_NAME(sc)); + DDOLOG("%s: Low speed device via hub disabled, " + "see slhci(4)\n", SC_NAME(sc), 0,0,0); + t->flags |= F_LSVH_WARNED; + } + return USBD_INVAL; } static usbd_status -slhci_root_intr_transfer(usbd_xfer_handle xfer) +slhci_isoc_warn(struct slhci_softc *sc, struct slhci_pipe *spipe, struct + usbd_xfer *xfer) { - usbd_status error; + struct slhci_transfers *t; - DPRINTF(D_TRACE, ("SLRItransfer ")); + t = &sc->sc_transfers; - /* Insert last in queue */ - error = usb_insert_transfer(xfer); - if (error) - return error; + if (!(t->flags & F_ISOC_WARNED)) { + printf("%s: ISOC transfer not supported " + "(see slhci(4))\n", SC_NAME(sc)); + DDOLOG("%s: ISOC transfer not supported " + "(see slhci(4))\n", SC_NAME(sc), 0,0,0); + t->flags |= F_ISOC_WARNED; + } + return USBD_INVAL; +} - /* - * Pipe isn't running (otherwise error would be USBD_INPROG), - * start first. - */ - return slhci_root_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)); +static usbd_status +slhci_open_pipe(struct slhci_softc *sc, struct slhci_pipe *spipe, struct + usbd_xfer *xfer) +{ + struct slhci_transfers *t; + struct usbd_pipe *pipe; + + t = &sc->sc_transfers; + pipe = &spipe->pipe; + + if (t->flags & F_DISABLED) + return USBD_CANCELLED; + else if (pipe->interval && !slhci_reserve_bustime(sc, spipe, 1)) + return USBD_PENDING_REQUESTS; + else { + enter_all_pipes(t, spipe); + return USBD_NORMAL_COMPLETION; + } } static usbd_status -slhci_root_intr_start(usbd_xfer_handle xfer) +slhci_close_pipe(struct slhci_softc *sc, struct slhci_pipe *spipe, struct + usbd_xfer *xfer) { - usbd_pipe_handle pipe = xfer->pipe; - struct slhci_softc *sc = (struct slhci_softc *)pipe->device->bus; + struct slhci_transfers *t; + struct usbd_pipe *pipe; - DPRINTF(D_TRACE, ("SLRIstart ")); + t = &sc->sc_transfers; + pipe = &spipe->pipe; - sc->sc_interval = MS_TO_TICKS(xfer->pipe->endpoint->edesc->bInterval); - usb_callout(sc->sc_poll_handle, sc->sc_interval, slhci_poll_hub, xfer); - sc->sc_intr_xfer = xfer; - return USBD_IN_PROGRESS; + if (pipe->interval && spipe->ptype != PT_ROOT_INTR) + slhci_reserve_bustime(sc, spipe, 0); + gcq_remove(&spipe->ap); + return USBD_NORMAL_COMPLETION; } -static void -slhci_root_intr_abort(usbd_xfer_handle xfer) +static usbd_status +slhci_do_abort(struct slhci_softc *sc, struct slhci_pipe *spipe, struct + usbd_xfer *xfer) { - DPRINTF(D_TRACE, ("SLRIabort ")); + struct slhci_transfers *t; + + t = &sc->sc_transfers; + + SLHCI_MAINLOCKASSERT(sc); + + if (spipe->xfer == xfer) { + if (spipe->ptype == PT_ROOT_INTR) { + if (t->rootintr == spipe->xfer) /* XXX assert? */ + t->rootintr = NULL; + } else { + gcq_remove(&spipe->to); + gcq_remove(&spipe->xq); + + if (t->spipe[A] == spipe) { + t->spipe[A] = NULL; + if (!(t->flags & F_AINPROG)) + t->len[A] = -1; + } else if (t->spipe[B] == spipe) { + t->spipe[B] = NULL; + if (!(t->flags & F_BINPROG)) + t->len[B] = -1; + } + } + + if (xfer->status != USBD_TIMEOUT) { + spipe->xfer = NULL; + spipe->pipe.repeat = 0; /* XXX timeout? */ + } + } + + return USBD_NORMAL_COMPLETION; } -static void -slhci_root_intr_close(usbd_pipe_handle pipe) +static usbd_status +slhci_do_attach(struct slhci_softc *sc, struct slhci_pipe *spipe, struct + usbd_xfer *xfer) { - struct slhci_softc *sc = (struct slhci_softc *)pipe->device->bus; + struct slhci_transfers *t; + const char *rev; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + /* Detect and check the controller type */ + t->sltype = SL11_GET_REV(slhci_read(sc, SL11_REV)); + + /* SL11H not supported */ + if (!slhci_supported_rev(t->sltype)) { + if (t->sltype == SLTYPE_SL11H) + printf("%s: SL11H unsupported or bus error!\n", + SC_NAME(sc)); + else + printf("%s: Unknown chip revision!\n", SC_NAME(sc)); + return USBD_INVAL; + } + + callout_init(&sc->sc_timer, CALLOUT_MPSAFE); + callout_setfunc(&sc->sc_timer, slhci_reset_entry, sc); + + /* It is not safe to call the soft interrupt directly as + * usb_schedsoftintr does in the use_polling case (due to locking). + */ + sc->sc_cb_softintr = softint_establish(SOFTINT_NET, + slhci_callback_entry, sc); + +#ifdef SLHCI_DEBUG + ssc = sc; +#ifdef USB_DEBUG + if (slhci_usbdebug >= 0) + usbdebug = slhci_usbdebug; +#endif +#endif + + if (t->sltype == SLTYPE_SL811HS_R12) + rev = " (rev 1.2)"; + else if (t->sltype == SLTYPE_SL811HS_R14) + rev = " (rev 1.4 or 1.5)"; + else + rev = " (unknown revision)"; + + aprint_normal("%s: ScanLogic SL811HS/T USB Host Controller %s\n", + SC_NAME(sc), rev); + + aprint_normal("%s: Max Current %u mA (value by code, not by probe)\n", + SC_NAME(sc), t->max_current * 2); + +#if defined(SLHCI_DEBUG) || defined(SLHCI_NO_OVERTIME) || \ + defined(SLHCI_TRY_LSVH) || defined(SLHCI_PROFILE_TRANSFER) + aprint_normal("%s: driver options:" +#ifdef SLHCI_DEBUG + " SLHCI_DEBUG" +#endif +#ifdef SLHCI_TRY_LSVH + " SLHCI_TRY_LSVH" +#endif +#ifdef SLHCI_NO_OVERTIME + " SLHCI_NO_OVERTIME" +#endif +#ifdef SLHCI_PROFILE_TRANSFER + " SLHCI_PROFILE_TRANSFER" +#endif + "\n", SC_NAME(sc)); +#endif + sc->sc_bus.usbrev = USBREV_1_1; + sc->sc_bus.methods = __UNCONST(&slhci_bus_methods); + sc->sc_bus.pipe_size = sizeof(struct slhci_pipe); - DPRINTF(D_TRACE, ("SLRIclose ")); + if (!sc->sc_enable_power) + t->flags |= F_REALPOWER; - usb_uncallout(sc->sc_poll_handle, slhci_poll_hub, sc->sc_intr_xfer); - sc->sc_intr_xfer = NULL; -} + t->flags |= F_ACTIVE; -static void -slhci_root_intr_done(usbd_xfer_handle xfer) -{ - //DPRINTF(D_XFER, ("RIdn ")); + return USBD_NORMAL_COMPLETION; } +/* Called to deactivate or stop use of the controller instead of panicing. + * Will cancel the xfer correctly even when not on a list. + */ static usbd_status -slhci_device_ctrl_transfer(usbd_xfer_handle xfer) +slhci_halt(struct slhci_softc *sc, struct slhci_pipe *spipe, struct usbd_xfer + *xfer) { - usbd_status error; + struct slhci_transfers *t; - DPRINTF(D_TRACE, ("C")); + SLHCI_LOCKASSERT(sc, locked, unlocked); - error = usb_insert_transfer(xfer); - if (error) - return error; + t = &sc->sc_transfers; - return slhci_device_ctrl_start(SIMPLEQ_FIRST(&xfer->pipe->queue)); -} + DDOLOG("Halt! sc %p spipe %p xfer %p", sc, spipe, xfer, 0); -static usbd_status -slhci_device_ctrl_start(usbd_xfer_handle xfer) -{ - usb_device_request_t *req = &xfer->request; - usbd_pipe_handle pipe = xfer->pipe; - struct slhci_softc *sc = (struct slhci_softc *)pipe->device->bus; - usbd_status status = USBD_NORMAL_COMPLETION; - void *buf; - int pid = SL11_PID_OUT; - int len, actlen, size; - int s; - u_int8_t toggle = 0; + if (spipe != NULL) + slhci_log_spipe(spipe); - DPRINTF(D_TRACE, ("st ")); -#ifdef SLHCI_DEBUG - if ((slhci_debug & D_TRACE)) - print_req_hub(req); -#endif + if (xfer != NULL) + slhci_log_xfer(xfer); - /* SETUP transaction */ - if (slhci_transaction(sc, pipe, SL11_PID_SETUP, - sizeof(*req), (u_char*)req, toggle) == -1) { - status = USBD_IOERROR; - goto ret; + if (spipe != NULL && xfer != NULL && spipe->xfer == xfer && + !gcq_onlist(&spipe->xq) && t->spipe[A] != spipe && t->spipe[B] != + spipe) { + xfer->status = USBD_CANCELLED; + enter_callback(t, spipe); } - toggle ^= SL11_EPCTRL_DATATOGGLE; - /* DATA transaction */ - actlen = 0; - len = UGETW(req->wLength); - if (len) { - buf = KERNADDR(&xfer->dmabuf, 0); - if (req->bmRequestType & UT_READ) - pid = SL11_PID_IN; - for (; actlen < len; ) { - size = min(len - actlen, 8/* Minimum size */); - if (slhci_transaction(sc, pipe, pid, size, buf, toggle) == -1) - break; - toggle ^= SL11_EPCTRL_DATATOGGLE; - (u_char*)buf += size; - actlen += size; - } - } - xfer->actlen = actlen; - - /* ACK (status) */ - if (pid == SL11_PID_IN) - pid = SL11_PID_OUT; - else - pid = SL11_PID_IN; - if (slhci_transaction(sc, pipe, pid, 0, NULL, toggle) == -1) - status = USBD_IOERROR; + if (t->flags & F_ACTIVE) { + slhci_intrchange(sc, 0); + /* leave power on when halting in case flash devices or disks + * are attached, which may be writing and could be damaged + * by abrupt power loss. The root hub clear power feature + * should still work after halting. + */ + } - ret: - xfer->status = status; + t->flags &= ~F_ACTIVE; + t->flags |= F_UDISABLED; + if (!(t->flags & F_NODEV)) + t->flags |= F_NODEV|F_CCONNECT|F_ROOTINTR; + slhci_drain(sc); -#ifdef SLHCI_DEBUG - if((slhci_debug & D_TRACE) && UGETW(req->wLength) > 0){ - int i; - for(i=0; i < UGETW(req->wLength); i++) - printf("%02x", *(unsigned char*)(KERNADDR(&xfer->dmabuf, i))); - printf(" "); - } -#endif - s = splusb(); - usb_transfer_complete(xfer); - splx(s); - return USBD_IN_PROGRESS; -} + /* One last callback for the drain and device removal. */ + slhci_do_callback_schedule(sc); -static void -slhci_device_ctrl_abort(usbd_xfer_handle xfer) -{ - DPRINTF(D_TRACE, ("Cab ")); - slhci_abort_xfer(xfer, USBD_CANCELLED); + return USBD_NORMAL_COMPLETION; } +/* There are three interrupt states: no interrupts during reset and after + * device deactivation, INSERT only for no device present but power on, and + * SOF, INSERT, ADONE, and BDONE when device is present. + */ static void -slhci_device_ctrl_close(usbd_pipe_handle pipe) +slhci_intrchange(struct slhci_softc *sc, uint8_t new_ier) { - DPRINTF(D_TRACE, ("Ccl ")); + SLHCI_MAINLOCKASSERT(sc); + if (sc->sc_ier != new_ier) { + sc->sc_ier = new_ier; + slhci_write(sc, SL11_IER, new_ier); + BSB_SYNC(sc->iot, sc->ioh, sc->pst, sc->psz); + } } +/* Drain: cancel all pending transfers and put them on the callback list and + * set the UDISABLED flag. UDISABLED is cleared only by reset. */ static void -slhci_device_ctrl_done(usbd_xfer_handle xfer) +slhci_drain(struct slhci_softc *sc) { - DPRINTF(D_TRACE, ("Cdn ")); -} + struct slhci_transfers *t; + struct slhci_pipe *spipe; + struct gcq *q; + int i; -static usbd_status -slhci_device_intr_transfer(usbd_xfer_handle xfer) -{ - usbd_status error; + SLHCI_LOCKASSERT(sc, locked, unlocked); - DPRINTF(D_TRACE, ("INTRtrans ")); + t = &sc->sc_transfers; - error = usb_insert_transfer(xfer); - if (error) - return error; + DLOG(D_MSG, "DRAIN flags %#x", t->flags, 0,0,0); + + t->pend = INT_MAX; + + for (i=0; i<=1; i++) { + t->len[i] = -1; + if (t->spipe[i] != NULL) { + enter_callback(t, t->spipe[i]); + t->spipe[i] = NULL; + } + } + + /* Merge the queues into the callback queue. */ + gcq_merge_tail(&t->q[Q_CALLBACKS], &t->q[Q_CB]); + gcq_merge_tail(&t->q[Q_CALLBACKS], &t->q[Q_NEXT_CB]); + gcq_merge_tail(&t->q[Q_CALLBACKS], &t->timed); + + /* Cancel all pipes. Note that not all of these may be on the + * callback queue yet; some could be in slhci_start, for example. */ + FOREACH_AP(q, t, spipe) { + spipe->pflags = PF_GONE; + spipe->pipe.repeat = 0; + spipe->pipe.aborting = 1; + if (spipe->xfer != NULL) + spipe->xfer->status = USBD_CANCELLED; + } + + gcq_remove_all(&t->to); - return slhci_device_intr_start(SIMPLEQ_FIRST(&xfer->pipe->queue)); + t->flags |= F_UDISABLED; + t->flags &= ~(F_AREADY|F_BREADY|F_AINPROG|F_BINPROG|F_LOWSPEED); } -static usbd_status -slhci_device_intr_start(usbd_xfer_handle xfer) +/* RESET: SL11_CTRL_RESETENGINE=1 and SL11_CTRL_JKSTATE=0 for 50ms + * reconfigure SOF after reset, must wait 2.5us before USB bus activity (SOF) + * check attached device speed. + * must wait 100ms before USB transaction according to app note, 10ms + * by spec. uhub does this delay + * + * Started from root hub set feature reset, which does step one. + * use_polling will call slhci_reset directly, otherwise the callout goes + * through slhci_reset_entry. + */ +void +slhci_reset(struct slhci_softc *sc) { - usbd_pipe_handle pipe = xfer->pipe; - struct slhci_xfer *sx; + struct slhci_transfers *t; + uint8_t r, pol, ctrl; - DPRINTF(D_TRACE, ("INTRstart ")); + t = &sc->sc_transfers; + SLHCI_MAINLOCKASSERT(sc); - sx = malloc(sizeof(*sx), M_USB, M_NOWAIT); - if (sx == NULL) - goto reterr; - memset(sx, 0, sizeof(*sx)); - sx->sx_xfer = xfer; - xfer->hcpriv = sx; - - /* initialize callout */ - usb_callout_init(sx->sx_callout_t); - usb_callout(sx->sx_callout_t, - MS_TO_TICKS(pipe->endpoint->edesc->bInterval), - slhci_poll_device, sx); + stop_cc_time(&t_delay); - /* ACK */ - return USBD_IN_PROGRESS; + KASSERT(t->flags & F_ACTIVE); + + start_cc_time(&t_delay, 0); + stop_cc_time(&t_delay); + + slhci_write(sc, SL11_CTRL, 0); + start_cc_time(&t_delay, 3); + DELAY(3); + stop_cc_time(&t_delay); + slhci_write(sc, SL11_ISR, 0xff); + + r = slhci_read(sc, SL11_ISR); + + if (r & SL11_ISR_INSERT) + slhci_write(sc, SL11_ISR, SL11_ISR_INSERT); + + if (r & SL11_ISR_NODEV) { + DLOG(D_MSG, "NC", 0,0,0,0); + /* Normally, the hard interrupt insert routine will issue + * CCONNECT, however we need to do it here if the detach + * happened during reset. */ + if (!(t->flags & F_NODEV)) + t->flags |= F_CCONNECT|F_ROOTINTR|F_NODEV; + slhci_intrchange(sc, SL11_IER_INSERT); + } else { + if (t->flags & F_NODEV) + t->flags |= F_CCONNECT; + t->flags &= ~(F_NODEV|F_LOWSPEED); + if (r & SL11_ISR_DATA) { + DLOG(D_MSG, "FS", 0,0,0,0); + pol = ctrl = 0; + } else { + DLOG(D_MSG, "LS", 0,0,0,0); + pol = SL811_CSOF_POLARITY; + ctrl = SL11_CTRL_LOWSPEED; + t->flags |= F_LOWSPEED; + } - reterr: - return USBD_IOERROR; + /* Enable SOF auto-generation */ + t->frame = 0; /* write to SL811_CSOF will reset frame */ + slhci_write(sc, SL11_SOFTIME, 0xe0); + slhci_write(sc, SL811_CSOF, pol|SL811_CSOF_MASTER|0x2e); + slhci_write(sc, SL11_CTRL, ctrl|SL11_CTRL_ENABLESOF); + + /* According to the app note, ARM must be set + * for SOF generation to work. We initialize all + * USBA registers here for current_tregs. */ + slhci_write(sc, SL11_E0ADDR, SL11_BUFFER_START); + slhci_write(sc, SL11_E0LEN, 0); + slhci_write(sc, SL11_E0PID, SL11_PID_SOF); + slhci_write(sc, SL11_E0DEV, 0); + slhci_write(sc, SL11_E0CTRL, SL11_EPCTRL_ARM); + + /* Initialize B registers. This can't be done earlier since + * they are not valid until the SL811_CSOF register is written + * above due to SL11H compatability. */ + slhci_write(sc, SL11_E1ADDR, SL11_BUFFER_END - 8); + slhci_write(sc, SL11_E1LEN, 0); + slhci_write(sc, SL11_E1PID, 0); + slhci_write(sc, SL11_E1DEV, 0); + + t->current_tregs[0][ADR] = SL11_BUFFER_START; + t->current_tregs[0][LEN] = 0; + t->current_tregs[0][PID] = SL11_PID_SOF; + t->current_tregs[0][DEV] = 0; + t->current_tregs[1][ADR] = SL11_BUFFER_END - 8; + t->current_tregs[1][LEN] = 0; + t->current_tregs[1][PID] = 0; + t->current_tregs[1][DEV] = 0; + + /* SOF start will produce USBA interrupt */ + t->len[A] = 0; + t->flags |= F_AINPROG; + + slhci_intrchange(sc, SLHCI_NORMAL_INTERRUPTS); + } + + t->flags &= ~(F_UDISABLED|F_RESET); + t->flags |= F_CRESET|F_ROOTINTR; + DLOG(D_MSG, "RESET done flags %#x", t->flags, 0,0,0); } -static void -slhci_poll_device(void *arg) +/* returns 1 if succeeded, 0 if failed, reserve == 0 is unreserve */ +static int +slhci_reserve_bustime(struct slhci_softc *sc, struct slhci_pipe *spipe, int + reserve) { - struct slhci_xfer *sx = (struct slhci_xfer *)arg; - usbd_xfer_handle xfer = sx->sx_xfer; - usbd_pipe_handle pipe = xfer->pipe; - struct slhci_softc *sc = (struct slhci_softc *)pipe->device->bus; - void *buf; - int pid; - int r; - int s; + struct slhci_transfers *t; + int bustime, max_packet; - DPRINTF(D_TRACE, ("pldev")); + SLHCI_LOCKASSERT(sc, locked, unlocked); - usb_callout(sx->sx_callout_t, - MS_TO_TICKS(pipe->endpoint->edesc->bInterval), - slhci_poll_device, sx); - - /* interrupt transfer */ - pid = (UE_GET_DIR(pipe->endpoint->edesc->bEndpointAddress) == UE_DIR_IN) - ? SL11_PID_IN : SL11_PID_OUT; - buf = KERNADDR(&xfer->dmabuf, 0); - - r = slhci_transaction(sc, pipe, pid, xfer->length, buf, 0/*toggle*/); - if (r < 0) { - DPRINTF(D_MSG, ("%s error", __FUNCTION__)); - return; + t = &sc->sc_transfers; + max_packet = UGETW(spipe->pipe.endpoint->edesc->wMaxPacketSize); + + if (spipe->pflags & PF_LS) + bustime = SLHCI_LS_CONST + SLHCI_LS_DATA_TIME(max_packet); + else + bustime = SLHCI_FS_CONST + SLHCI_FS_DATA_TIME(max_packet); + + if (!reserve) { + t->reserved_bustime -= bustime; +#ifdef DIAGNOSTIC + if (t->reserved_bustime < 0) { + printf("%s: reserved_bustime %d < 0!\n", + SC_NAME(sc), t->reserved_bustime); + DDOLOG("%s: reserved_bustime %d < 0!\n", + SC_NAME(sc), t->reserved_bustime, 0,0); + t->reserved_bustime = 0; + } +#endif + return 1; } - /* no change, return NAK */ - if (r == 0) - return; - xfer->status = USBD_NORMAL_COMPLETION; - s = splusb(); - xfer->device->bus->intr_context++; - usb_transfer_complete(xfer); - xfer->device->bus->intr_context--; - splx(s); + if (t->reserved_bustime + bustime > SLHCI_RESERVED_BUSTIME) { + if (ratecheck(&sc->sc_reserved_warn_rate, + &reserved_warn_rate)) +#ifdef SLHCI_NO_OVERTIME + { + printf("%s: Max reserved bus time exceeded! " + "Erroring request.\n", SC_NAME(sc)); + DDOLOG("%s: Max reserved bus time exceeded! " + "Erroring request.\n", SC_NAME(sc), 0,0,0); + } + return 0; +#else + { + printf("%s: Reserved bus time exceeds %d!\n", + SC_NAME(sc), SLHCI_RESERVED_BUSTIME); + DDOLOG("%s: Reserved bus time exceeds %d!\n", + SC_NAME(sc), SLHCI_RESERVED_BUSTIME, 0,0); + } +#endif + } + + t->reserved_bustime += bustime; + return 1; } +/* Device insertion/removal interrupt */ static void -slhci_device_intr_abort(usbd_xfer_handle xfer) +slhci_insert(struct slhci_softc *sc) { - struct slhci_xfer *sx; + struct slhci_transfers *t; - DPRINTF(D_TRACE, ("INTRabort ")); + t = &sc->sc_transfers; - sx = xfer->hcpriv; - if (sx) { - usb_uncallout(sx->sx_callout_t, slhci_poll_device, sx); - free(sx, M_USB); - xfer->hcpriv = NULL; - } else { - printf("%s: sx == NULL!\n", __FUNCTION__); + SLHCI_LOCKASSERT(sc, locked, unlocked); + + if (t->flags & F_NODEV) + slhci_intrchange(sc, 0); + else { + slhci_drain(sc); + slhci_intrchange(sc, SL11_IER_INSERT); } - slhci_abort_xfer(xfer, USBD_CANCELLED); + t->flags ^= F_NODEV; + t->flags |= F_ROOTINTR|F_CCONNECT; + DLOG(D_MSG, "INSERT intr: flags after %#x", t->flags, 0,0,0); } -static void -slhci_device_intr_close(usbd_pipe_handle pipe) -{ - DPRINTF(D_TRACE, ("INTRclose ")); -} +/* + * Data structures and routines to emulate the root hub. + */ +static const usb_device_descriptor_t slhci_devd = { + USB_DEVICE_DESCRIPTOR_SIZE, + UDESC_DEVICE, /* type */ + {0x01, 0x01}, /* USB version */ + UDCLASS_HUB, /* class */ + UDSUBCLASS_HUB, /* subclass */ + 0, /* protocol */ + 64, /* max packet */ + {USB_VENDOR_SCANLOGIC & 0xff, /* vendor ID (low) */ + USB_VENDOR_SCANLOGIC >> 8 }, /* vendor ID (high) */ + {0} /* ? */, /* product ID */ + {0}, /* device */ + 1, /* index to manufacturer */ + 2, /* index to product */ + 0, /* index to serial number */ + 1 /* number of configurations */ +}; -static void -slhci_device_intr_done(usbd_xfer_handle xfer) -{ - DPRINTF(D_TRACE, ("INTRdone ")); -} +static const struct slhci_confd_t { + const usb_config_descriptor_t confd; + const usb_interface_descriptor_t ifcd; + const usb_endpoint_descriptor_t endpd; +} UPACKED slhci_confd = { + { /* Configuration */ + USB_CONFIG_DESCRIPTOR_SIZE, + UDESC_CONFIG, + {USB_CONFIG_DESCRIPTOR_SIZE + + USB_INTERFACE_DESCRIPTOR_SIZE + + USB_ENDPOINT_DESCRIPTOR_SIZE}, + 1, /* number of interfaces */ + 1, /* configuration value */ + 0, /* index to configuration */ + UC_SELF_POWERED, /* attributes */ + 0 /* max current, filled in later */ + }, { /* Interface */ + USB_INTERFACE_DESCRIPTOR_SIZE, + UDESC_INTERFACE, + 0, /* interface number */ + 0, /* alternate setting */ + 1, /* number of endpoint */ + UICLASS_HUB, /* class */ + UISUBCLASS_HUB, /* subclass */ + 0, /* protocol */ + 0 /* index to interface */ + }, { /* Endpoint */ + USB_ENDPOINT_DESCRIPTOR_SIZE, + UDESC_ENDPOINT, + UE_DIR_IN | ROOT_INTR_ENDPT, /* endpoint address */ + UE_INTERRUPT, /* attributes */ + {240, 0}, /* max packet size */ + 255 /* interval */ + } +}; -static usbd_status -slhci_device_isoc_transfer(usbd_xfer_handle xfer) -{ - DPRINTF(D_TRACE, ("S")); - return USBD_NORMAL_COMPLETION; -} +static const usb_hub_descriptor_t slhci_hubd = { + USB_HUB_DESCRIPTOR_SIZE, + UDESC_HUB, + 1, /* number of ports */ + {UHD_PWR_INDIVIDUAL | UHD_OC_NONE, 0}, /* hub characteristics */ + 50, /* 5:power on to power good, units of 2ms */ + 0, /* 6:maximum current, filled in later */ + { 0x00 }, /* port is removable */ + { 0x00 } /* port power control mask */ +}; static usbd_status -slhci_device_isoc_start(usbd_xfer_handle xfer) +slhci_clear_feature(struct slhci_softc *sc, unsigned int what) { - DPRINTF(D_TRACE, ("st ")); - return USBD_NORMAL_COMPLETION; -} + struct slhci_transfers *t; + usbd_status error; -static void -slhci_device_isoc_abort(usbd_xfer_handle xfer) -{ - DPRINTF(D_TRACE, ("Sab ")); -} + t = &sc->sc_transfers; + error = USBD_NORMAL_COMPLETION; -static void -slhci_device_isoc_close(usbd_pipe_handle pipe) -{ - DPRINTF(D_TRACE, ("Scl ")); -} + SLHCI_LOCKASSERT(sc, locked, unlocked); -static void -slhci_device_isoc_done(usbd_xfer_handle xfer) -{ - DPRINTF(D_TRACE, ("Sdn ")); -} + if (what == UHF_PORT_POWER) { + DLOG(D_MSG, "POWER_OFF", 0,0,0,0); + t->flags &= ~F_POWER; + if (!(t->flags & F_NODEV)) + t->flags |= F_NODEV|F_CCONNECT|F_ROOTINTR; + /* for x68k Nereid USB controller */ + if (sc->sc_enable_power && (t->flags & F_REALPOWER)) { + t->flags &= ~F_REALPOWER; + sc->sc_enable_power(sc, POWER_OFF); + } + slhci_intrchange(sc, 0); + slhci_drain(sc); + } else if (what == UHF_C_PORT_CONNECTION) { + t->flags &= ~F_CCONNECT; + } else if (what == UHF_C_PORT_RESET) { + t->flags &= ~F_CRESET; + } else if (what == UHF_PORT_ENABLE) { + slhci_drain(sc); + } else if (what != UHF_PORT_SUSPEND) { + DDOLOG("ClrPortFeatERR:value=%#.4x", what, 0,0,0); + error = USBD_IOERROR; + } -static usbd_status -slhci_device_bulk_transfer(usbd_xfer_handle xfer) -{ - DPRINTF(D_TRACE, ("B")); - return USBD_NORMAL_COMPLETION; + return error; } static usbd_status -slhci_device_bulk_start(usbd_xfer_handle xfer) +slhci_set_feature(struct slhci_softc *sc, unsigned int what) { - DPRINTF(D_TRACE, ("st ")); + struct slhci_transfers *t; + uint8_t r; + + t = &sc->sc_transfers; + + SLHCI_LOCKASSERT(sc, locked, unlocked); + + if (what == UHF_PORT_RESET) { + if (!(t->flags & F_ACTIVE)) { + DDOLOG("SET PORT_RESET when not ACTIVE!", + 0,0,0,0); + return USBD_INVAL; + } + if (!(t->flags & F_POWER)) { + DDOLOG("SET PORT_RESET without PORT_POWER! flags %p", + t->flags, 0,0,0); + return USBD_INVAL; + } + if (t->flags & F_RESET) + return USBD_NORMAL_COMPLETION; + DLOG(D_MSG, "RESET flags %#x", t->flags, 0,0,0); + slhci_intrchange(sc, 0); + slhci_drain(sc); + slhci_write(sc, SL11_CTRL, SL11_CTRL_RESETENGINE); + /* usb spec says delay >= 10ms, app note 50ms */ + start_cc_time(&t_delay, 50000); + if (sc->sc_bus.use_polling) { + DELAY(50000); + slhci_reset(sc); + } else { + t->flags |= F_RESET; + callout_schedule(&sc->sc_timer, max(mstohz(50), 2)); + } + } else if (what == UHF_PORT_SUSPEND) { + printf("%s: USB Suspend not implemented!\n", SC_NAME(sc)); + DDOLOG("%s: USB Suspend not implemented!\n", SC_NAME(sc), + 0,0,0); + } else if (what == UHF_PORT_POWER) { + DLOG(D_MSG, "PORT_POWER", 0,0,0,0); + /* for x68k Nereid USB controller */ + if (!(t->flags & F_ACTIVE)) + return USBD_INVAL; + if (t->flags & F_POWER) + return USBD_NORMAL_COMPLETION; + if (!(t->flags & F_REALPOWER)) { + if (sc->sc_enable_power) + sc->sc_enable_power(sc, POWER_ON); + t->flags |= F_REALPOWER; + } + t->flags |= F_POWER; + r = slhci_read(sc, SL11_ISR); + if (r & SL11_ISR_INSERT) + slhci_write(sc, SL11_ISR, SL11_ISR_INSERT); + if (r & SL11_ISR_NODEV) { + slhci_intrchange(sc, SL11_IER_INSERT); + t->flags |= F_NODEV; + } else { + t->flags &= ~F_NODEV; + t->flags |= F_CCONNECT|F_ROOTINTR; + } + } else { + DDOLOG("SetPortFeatERR=%#.8x", what, 0,0,0); + return USBD_IOERROR; + } + return USBD_NORMAL_COMPLETION; } static void -slhci_device_bulk_abort(usbd_xfer_handle xfer) +slhci_get_status(struct slhci_softc *sc, usb_port_status_t *ps) { - DPRINTF(D_TRACE, ("Bab ")); -} + struct slhci_transfers *t; + unsigned int status, change; -static void -slhci_device_bulk_close(usbd_pipe_handle pipe) -{ - DPRINTF(D_TRACE, ("Bcl ")); -} + t = &sc->sc_transfers; -static void -slhci_device_bulk_done(usbd_xfer_handle xfer) -{ - DPRINTF(D_TRACE, ("Bdn ")); -} + SLHCI_LOCKASSERT(sc, locked, unlocked); -#define DATA0_RD (0x03) -#define DATA0_WR (0x07) -#define SLHCI_TIMEOUT (5000) + /* We do not have a way to detect over current or bable and + * suspend is currently not implemented, so connect and reset + * are the only changes that need to be reported. */ + change = 0; + if (t->flags & F_CCONNECT) + change |= UPS_C_CONNECT_STATUS; + if (t->flags & F_CRESET) + change |= UPS_C_PORT_RESET; + + status = 0; + if (!(t->flags & F_NODEV)) + status |= UPS_CURRENT_CONNECT_STATUS; + if (!(t->flags & F_UDISABLED)) + status |= UPS_PORT_ENABLED; + if (t->flags & F_RESET) + status |= UPS_RESET; + if (t->flags & F_POWER) + status |= UPS_PORT_POWER; + if (t->flags & F_LOWSPEED) + status |= UPS_LOW_SPEED; + USETW(ps->wPortStatus, status); + USETW(ps->wPortChange, change); + DLOG(D_ROOT, "status=%#.4x, change=%#.4x", status, change, 0,0); +} -/* - * Do a transaction. - * return 1 if ACK, 0 if NAK, -1 if error. - */ -static int -slhci_transaction(struct slhci_softc *sc, usbd_pipe_handle pipe, - u_int8_t pid, int len, u_char *buf, u_int8_t toggle) +static usbd_status +slhci_root(struct slhci_softc *sc, struct slhci_pipe *spipe, struct usbd_xfer + *xfer) { -#ifdef SLHCI_DEBUG - char str[64]; - int i; -#endif - int timeout; - int ls_via_hub = 0; - int pl; - u_int8_t isr; - u_int8_t result = 0; - u_int8_t devaddr = pipe->device->address; - u_int8_t endpointaddr = pipe->endpoint->edesc->bEndpointAddress; - u_int8_t endpoint; - u_int8_t cmd = DATA0_RD; - - endpoint = UE_GET_ADDR(endpointaddr); - DPRINTF(D_XFER, ("\n(%x,%d%s%d,%d) ", - pid, len, (pid == SL11_PID_IN) ? "<-" : "->", devaddr, endpoint)); - - /* Set registers */ - sl11write(sc, SL11_E0ADDR, 0x40); - sl11write(sc, SL11_E0LEN, len); - sl11write(sc, SL11_E0PID, (pid << 4) + endpoint); - sl11write(sc, SL11_E0DEV, devaddr); - - /* Set buffer unless PID_IN */ - if (pid != SL11_PID_IN) { - if (len > 0) - sl11write_region(sc, 0x40, buf, len); - cmd = DATA0_WR; - } - - /* timing ? */ - pl = (len >> 3) + 3; - - /* Low speed device via HUB */ - /* XXX does not work... */ - if ((sc->sc_fullspeed) && pipe->device->speed == USB_SPEED_LOW) { - pl = len + 16; - cmd |= SL11_EPCTRL_PREAMBLE; - - /* - * SL811HS/T rev 1.2 has a bug, when it got PID_IN - * from LowSpeed device via HUB. - */ - if (sc->sc_sltype == SLTYPE_SL811HS_R12 && pid == SL11_PID_IN) { - ls_via_hub = 1; - DPRINTF(D_MSG, ("LSvH ")); - } - } + struct slhci_transfers *t; + usb_device_request_t *req; + unsigned int len, value, index, actlen, type; + uint8_t *buf; + usbd_status error; - /* timing ? */ - if (sl11read(sc, SL811_CSOF) <= (u_int8_t)pl) - cmd |= SL11_EPCTRL_SOF; + t = &sc->sc_transfers; + buf = NULL; - /* Transfer */ - sl11write(sc, SL11_ISR, 0xff); - sl11write(sc, SL11_E0CTRL, cmd | toggle); + LK_SLASSERT(spipe != NULL && xfer != NULL, sc, spipe, xfer, return + USBD_CANCELLED); - /* Polling */ - for (timeout = SLHCI_TIMEOUT; timeout; timeout--) { - isr = sl11read(sc, SL11_ISR); - if ((isr & SL11_ISR_USBA)) - break; - } + DLOG(D_TRACE, "%s start", pnames(SLHCI_XFER_TYPE(xfer)), 0,0,0); + SLHCI_LOCKASSERT(sc, locked, unlocked); - /* Check result status */ - result = sl11read(sc, SL11_E0STAT); - if (!(result & SL11_EPSTAT_NAK) && ls_via_hub) { - /* Resend PID_IN within 20usec */ - sl11write(sc, SL11_ISR, 0xff); - sl11write(sc, SL11_E0CTRL, SL11_EPCTRL_ARM); + if (spipe->ptype == PT_ROOT_INTR) { + LK_SLASSERT(t->rootintr == NULL, sc, spipe, xfer, return + USBD_CANCELLED); + t->rootintr = xfer; + if (t->flags & F_CHANGE) + t->flags |= F_ROOTINTR; + return USBD_IN_PROGRESS; } - sl11write(sc, SL11_ISR, 0xff); + error = USBD_IOERROR; /* XXX should be STALL */ + actlen = 0; + req = &xfer->request; - DPRINTF(D_XFER, ("t=%d i=%x ", SLHCI_TIMEOUT - timeout, isr)); -#if SLHCI_DEBUG - bitmask_snprintf(result, - "\20\x8STALL\7NAK\6OV\5SETUP\4DATA1\3TIMEOUT\2ERR\1ACK", - str, sizeof(str)); - DPRINTF(D_XFER, ("STAT=%s ", str)); -#endif + len = UGETW(req->wLength); + value = UGETW(req->wValue); + index = UGETW(req->wIndex); - if ((result & SL11_EPSTAT_ERROR)) - return -1; + type = req->bmRequestType; - if ((result & SL11_EPSTAT_NAK)) - return 0; + if (len) + buf = KERNADDR(&xfer->dmabuf, 0); - /* Read buffer if PID_IN */ - if (pid == SL11_PID_IN && len > 0) { - sl11read_region(sc, buf, 0x40, len); -#if SLHCI_DEBUG - for (i = 0; i < len; i++) - DPRINTF(D_XFER, ("%02X ", buf[i])); -#endif + SLHCI_DEXEC(D_TRACE, slhci_log_req_hub(req)); + + /* + * USB requests for hubs have two basic types, standard and class. + * Each could potentially have recipients of device, interface, + * endpoint, or other. For the hub class, CLASS_OTHER means the port + * and CLASS_DEVICE means the hub. For standard requests, OTHER + * is not used. Standard request are described in section 9.4 of the + * standard, hub class requests in 11.16. Each request is either read + * or write. + * + * Clear Feature, Set Feature, and Status are defined for each of the + * used recipients. Get Descriptor and Set Descriptor are defined for + * both standard and hub class types with different descriptors. + * Other requests have only one defined recipient and type. These + * include: Get/Set Address, Get/Set Configuration, Get/Set Interface, + * and Synch Frame for standard requests and Get Bus State for hub + * class. + * + * When a device is first powered up it has address 0 until the + * address is set. + * + * Hubs are only allowed to support one interface and may not have + * isochronous endpoints. The results of the related requests are + * undefined. + * + * The standard requires invalid or unsupported requests to return + * STALL in the data stage, however this does not work well with + * current error handling. XXX + * + * Some unsupported fields: + * Clear Hub Feature is for C_HUB_LOCAL_POWER and C_HUB_OVER_CURRENT + * Set Device Features is for ENDPOINT_HALT and DEVICE_REMOTE_WAKEUP + * Get Bus State is optional sample of D- and D+ at EOF2 + */ + + switch (req->bRequest) { + /* Write Requests */ + case UR_CLEAR_FEATURE: + if (type == UT_WRITE_CLASS_OTHER) { + if (index == 1 /* Port */) + error = slhci_clear_feature(sc, value); + else + DLOG(D_ROOT, "Clear Port Feature " + "index = %#.4x", index, 0,0,0); + } + break; + case UR_SET_FEATURE: + if (type == UT_WRITE_CLASS_OTHER) { + if (index == 1 /* Port */) + error = slhci_set_feature(sc, value); + else + DLOG(D_ROOT, "Set Port Feature " + "index = %#.4x", index, 0,0,0); + } else if (type != UT_WRITE_CLASS_DEVICE) + DLOG(D_ROOT, "Set Device Feature " + "ENDPOINT_HALT or DEVICE_REMOTE_WAKEUP " + "not supported", 0,0,0,0); + break; + case UR_SET_ADDRESS: + if (type == UT_WRITE_DEVICE) { + DLOG(D_ROOT, "Set Address %#.4x", value, 0,0,0); + if (value < USB_MAX_DEVICES) { + t->rootaddr = value; + error = USBD_NORMAL_COMPLETION; + } + } + break; + case UR_SET_CONFIG: + if (type == UT_WRITE_DEVICE) { + DLOG(D_ROOT, "Set Config %#.4x", value, 0,0,0); + if (value == 0 || value == 1) { + t->rootconf = value; + error = USBD_NORMAL_COMPLETION; + } + } + break; + /* Read Requests */ + case UR_GET_STATUS: + if (type == UT_READ_CLASS_OTHER) { + if (index == 1 /* Port */ && len == /* XXX >=? */ + sizeof(usb_port_status_t)) { + slhci_get_status(sc, (usb_port_status_t *) + buf); + actlen = sizeof(usb_port_status_t); + error = USBD_NORMAL_COMPLETION; + } else + DLOG(D_ROOT, "Get Port Status index = %#.4x " + "len = %#.4x", index, len, 0,0); + } else if (type == UT_READ_CLASS_DEVICE) { /* XXX index? */ + if (len == sizeof(usb_hub_status_t)) { + DLOG(D_ROOT, "Get Hub Status", + 0,0,0,0); + actlen = sizeof(usb_hub_status_t); + memset(buf, 0, actlen); + error = USBD_NORMAL_COMPLETION; + } else + DLOG(D_ROOT, "Get Hub Status bad len %#.4x", + len, 0,0,0); + } else if (type == UT_READ_DEVICE) { + if (len >= 2) { + USETW(((usb_status_t *)buf)->wStatus, UDS_SELF_POWERED); + actlen = 2; + error = USBD_NORMAL_COMPLETION; + } + } else if (type == (UT_READ_INTERFACE|UT_READ_ENDPOINT)) { + if (len >= 2) { + USETW(((usb_status_t *)buf)->wStatus, 0); + actlen = 2; + error = USBD_NORMAL_COMPLETION; + } + } + break; + case UR_GET_CONFIG: + if (type == UT_READ_DEVICE) { + DLOG(D_ROOT, "Get Config", 0,0,0,0); + if (len > 0) { + *buf = t->rootconf; + actlen = 1; + error = USBD_NORMAL_COMPLETION; + } + } + break; + case UR_GET_INTERFACE: + if (type == UT_READ_INTERFACE) { + if (len > 0) { + *buf = 0; + actlen = 1; + error = USBD_NORMAL_COMPLETION; + } + } + break; + case UR_GET_DESCRIPTOR: + if (type == UT_READ_DEVICE) { + /* value is type (&0xff00) and index (0xff) */ + if (value == (UDESC_DEVICE<<8)) { + actlen = min(len, sizeof(slhci_devd)); + memcpy(buf, &slhci_devd, actlen); + error = USBD_NORMAL_COMPLETION; + } else if (value == (UDESC_CONFIG<<8)) { + actlen = min(len, sizeof(slhci_confd)); + memcpy(buf, &slhci_confd, actlen); + if (actlen > offsetof(usb_config_descriptor_t, + bMaxPower)) + ((usb_config_descriptor_t *) + buf)->bMaxPower = t->max_current; + /* 2 mA units */ + error = USBD_NORMAL_COMPLETION; + } else if (value == (UDESC_STRING<<8)) { + /* language table XXX */ + } else if (value == ((UDESC_STRING<<8)|1)) { + /* Vendor */ + actlen = usb_makestrdesc((usb_string_descriptor_t *) + buf, len, "ScanLogic/Cypress"); + error = USBD_NORMAL_COMPLETION; + } else if (value == ((UDESC_STRING<<8)|2)) { + /* Product */ + actlen = usb_makestrdesc((usb_string_descriptor_t *) + buf, len, "SL811HS/T root hub"); + error = USBD_NORMAL_COMPLETION; + } else + DDOLOG("Unknown Get Descriptor %#.4x", + value, 0,0,0); + } else if (type == UT_READ_CLASS_DEVICE) { + /* Descriptor number is 0 */ + if (value == (UDESC_HUB<<8)) { + actlen = min(len, sizeof(slhci_hubd)); + memcpy(buf, &slhci_hubd, actlen); + if (actlen > offsetof(usb_config_descriptor_t, + bMaxPower)) + ((usb_hub_descriptor_t *) + buf)->bHubContrCurrent = 500 - + t->max_current; + error = USBD_NORMAL_COMPLETION; + } else + DDOLOG("Unknown Get Hub Descriptor %#.4x", + value, 0,0,0); + } + break; } - return 1; -} + if (error == USBD_NORMAL_COMPLETION) + xfer->actlen = actlen; + xfer->status = error; + KASSERT(spipe->xfer == NULL); + spipe->xfer = xfer; + enter_callback(t, spipe); -void -slhci_abort_xfer(usbd_xfer_handle xfer, usbd_status status) -{ - xfer->status = status; - usb_transfer_complete(xfer); + return USBD_IN_PROGRESS; } +/* End in lock functions. Start debug functions. */ + +#ifdef SLHCI_DEBUG void -slhci_device_clear_toggle(usbd_pipe_handle pipe) +slhci_log_buffer(struct usbd_xfer *xfer) { - DPRINTF(D_TRACE, ("SLdevice_clear_toggle ")); + u_char *buf; + + if(xfer->length > 0 && + UE_GET_DIR(xfer->pipe->endpoint->edesc->bEndpointAddress) == + UE_DIR_IN) { + buf = KERNADDR(&xfer->dmabuf, 0); + DDOLOGBUF(buf, xfer->actlen); + DDOLOG("len %d actlen %d short %d", xfer->length, + xfer->actlen, xfer->length - xfer->actlen, 0); + } } -#ifdef SLHCI_DEBUG void -print_req(usb_device_request_t *r) +slhci_log_req(usb_device_request_t *r) { - char *xmes[]={ + static const char *xmes[]={ "GETSTAT", "CLRFEAT", "res", @@ -1548,27 +3476,29 @@ print_req(usb_device_request_t *r) "SETCONF", "GETIN/F", "SETIN/F", - "SYNC_FR" + "SYNC_FR", + "UNKNOWN" }; - int req, type, value, index, len; + int req, mreq, type, value, index, len; req = r->bRequest; + mreq = (req > 13) ? 13 : req; type = r->bmRequestType; value = UGETW(r->wValue); index = UGETW(r->wIndex); len = UGETW(r->wLength); - printf("%x,%s,v=%d,i=%d,l=%d ", - type, xmes[req], value, index, len); + DDOLOG("request: %s %#x", xmes[mreq], type, 0,0); + DDOLOG("request: r=%d,v=%d,i=%d,l=%d ", req, value, index, len); } void -print_req_hub(usb_device_request_t *r) +slhci_log_req_hub(usb_device_request_t *r) { - struct { + static const struct { int req; int type; - char *str; + const char *str; } conf[] = { { 1, 0x20, "ClrHubFeat" }, { 1, 0x23, "ClrPortFeat" }, @@ -1583,45 +3513,165 @@ print_req_hub(usb_device_request_t *r) }; int i; int value, index, len; + const char *str; value = UGETW(r->wValue); index = UGETW(r->wIndex); len = UGETW(r->wLength); for (i = 0; ; i++) { - if (conf[i].req == -1 ) - return print_req(r); + if (conf[i].req == -1 ) { + slhci_log_req(r); + return; + } if (r->bmRequestType == conf[i].type && r->bRequest == conf[i].req) { - printf("%s", conf[i].str); + str = conf[i].str; break; } } - printf(",v=%d,i=%d,l=%d ", value, index, len); + DDOLOG("hub request: %s v=%d,i=%d,l=%d ", str, value, index, len); } void -print_dumpreg(struct slhci_softc *sc) +slhci_log_dumpreg(void) { - printf("00=%02x,01=%02x,02=%02x,03=%02x,04=%02x," - "08=%02x,09=%02x,0A=%02x,0B=%02x,0C=%02x,", - sl11read(sc, 0), sl11read(sc, 1), - sl11read(sc, 2), sl11read(sc, 3), - sl11read(sc, 4), sl11read(sc, 8), - sl11read(sc, 9), sl11read(sc, 10), - sl11read(sc, 11), sl11read(sc, 12) - ); - printf("CR1=%02x,IER=%02x,0D=%02x,0E=%02x,0F=%02x ", - sl11read(sc, 5), sl11read(sc, 6), - sl11read(sc, 13), sl11read(sc, 14), sl11read(sc, 15) - ); + uint8_t r; + unsigned int aaddr, alen, baddr, blen; + static u_char buf[240]; + + r = slhci_read(ssc, SL11_E0CTRL); + DDOLOG("USB A Host Control = %#.2x", r, 0,0,0); + DDOLOGFLAG8("E0CTRL=", r, "Preamble", "Data Toggle", "SOF Sync", + "ISOC", "res", "Out", "Enable", "Arm"); + aaddr = slhci_read(ssc, SL11_E0ADDR); + DDOLOG("USB A Base Address = %u", aaddr, 0,0,0); + alen = slhci_read(ssc, SL11_E0LEN); + DDOLOG("USB A Length = %u", alen, 0,0,0); + r = slhci_read(ssc, SL11_E0STAT); + DDOLOG("USB A Status = %#.2x", r, 0,0,0); + DDOLOGFLAG8("E0STAT=", r, "STALL", "NAK", "Overflow", "Setup", + "Data Toggle", "Timeout", "Error", "ACK"); + r = slhci_read(ssc, SL11_E0CONT); + DDOLOG("USB A Remaining or Overflow Length = %u", r, 0,0,0); + r = slhci_read(ssc, SL11_E1CTRL); + DDOLOG("USB B Host Control = %#.2x", r, 0,0,0); + DDOLOGFLAG8("E1CTRL=", r, "Preamble", "Data Toggle", "SOF Sync", + "ISOC", "res", "Out", "Enable", "Arm"); + baddr = slhci_read(ssc, SL11_E1ADDR); + DDOLOG("USB B Base Address = %u", baddr, 0,0,0); + blen = slhci_read(ssc, SL11_E1LEN); + DDOLOG("USB B Length = %u", blen, 0,0,0); + r = slhci_read(ssc, SL11_E1STAT); + DDOLOG("USB B Status = %#.2x", r, 0,0,0); + DDOLOGFLAG8("E1STAT=", r, "STALL", "NAK", "Overflow", "Setup", + "Data Toggle", "Timeout", "Error", "ACK"); + r = slhci_read(ssc, SL11_E1CONT); + DDOLOG("USB B Remaining or Overflow Length = %u", r, 0,0,0); + + r = slhci_read(ssc, SL11_CTRL); + DDOLOG("Control = %#.2x", r, 0,0,0); + DDOLOGFLAG8("CTRL=", r, "res", "Suspend", "LOW Speed", + "J-K State Force", "Reset", "res", "res", "SOF"); + r = slhci_read(ssc, SL11_IER); + DDOLOG("Interrupt Enable = %#.2x", r, 0,0,0); + DDOLOGFLAG8("IER=", r, "D+ **IER!**", "Device Detect/Resume", + "Insert/Remove", "SOF", "res", "res", "USBB", "USBA"); + r = slhci_read(ssc, SL11_ISR); + DDOLOG("Interrupt Status = %#.2x", r, 0,0,0); + DDOLOGFLAG8("ISR=", r, "D+", "Device Detect/Resume", + "Insert/Remove", "SOF", "res", "res", "USBB", "USBA"); + r = slhci_read(ssc, SL11_REV); + DDOLOG("Revision = %#.2x", r, 0,0,0); + r = slhci_read(ssc, SL811_CSOF); + DDOLOG("SOF Counter = %#.2x", r, 0,0,0); + + if (alen && aaddr >= SL11_BUFFER_START && aaddr < SL11_BUFFER_END && + alen <= SL11_MAX_PACKET_SIZE && aaddr + alen <= SL11_BUFFER_END) { + slhci_read_multi(ssc, aaddr, buf, alen); + DDOLOG("USBA Buffer: start %u len %u", aaddr, alen, 0,0); + DDOLOGBUF(buf, alen); + } else if (alen) + DDOLOG("USBA Buffer Invalid", 0,0,0,0); + + if (blen && baddr >= SL11_BUFFER_START && baddr < SL11_BUFFER_END && + blen <= SL11_MAX_PACKET_SIZE && baddr + blen <= SL11_BUFFER_END) { + slhci_read_multi(ssc, baddr, buf, blen); + DDOLOG("USBB Buffer: start %u len %u", baddr, blen, 0,0); + DDOLOGBUF(buf, blen); + } else if (blen) + DDOLOG("USBB Buffer Invalid", 0,0,0,0); } void -print_xfer(usbd_xfer_handle xfer) +slhci_log_xfer(struct usbd_xfer *xfer) { - printf("xfer: length=%d, actlen=%d, flags=%x, timeout=%d,", + DDOLOG("xfer: length=%u, actlen=%u, flags=%#x, timeout=%u,", xfer->length, xfer->actlen, xfer->flags, xfer->timeout); - printf("request{ "); - print_req_hub(&xfer->request); - printf("} "); + if (xfer->dmabuf.block) + DDOLOG("buffer=%p", KERNADDR(&xfer->dmabuf, 0), 0,0,0); + slhci_log_req_hub(&xfer->request); +} + +void +slhci_log_spipe(struct slhci_pipe *spipe) +{ + DDOLOG("spipe %p onlists: %s %s %s", spipe, gcq_onlist(&spipe->ap) ? + "AP" : "", gcq_onlist(&spipe->to) ? "TO" : "", + gcq_onlist(&spipe->xq) ? "XQ" : ""); + DDOLOG("spipe: xfer %p buffer %p pflags %#x ptype %s", + spipe->xfer, spipe->buffer, spipe->pflags, pnames(spipe->ptype)); +} + +void +slhci_print_intr(void) +{ + unsigned int ier, isr; + ier = slhci_read(ssc, SL11_IER); + isr = slhci_read(ssc, SL11_ISR); + printf("IER: %#x ISR: %#x \n", ier, isr); +} + +#if 0 +void +slhci_log_sc() +{ + struct slhci_transfers *t; + int i; + + t = &ssc->sc_transfers; + + DDOLOG("Flags=%#x", t->flags, 0,0,0); + DDOLOG("a = %p Alen=%d b = %p Blen=%d", t->spipe[0], t->len[0], + t->spipe[1], t->len[1]); + + for (i=0; i<=Q_MAX; i++) + DDOLOG("Q %d: %p", i, gcq_first(&t->q[i]), 0,0); + + DDOLOG("TIMED: %p", GCQ_ITEM(gcq_first(&t->to), + struct slhci_pipe, to), 0,0,0); + + DDOLOG("frame=%d rootintr=%p", t->frame, t->rootintr, 0,0); + + DDOLOG("use_polling=%d intr_context=%d", ssc->sc_bus.use_polling, + ssc->sc_bus.intr_context, 0,0); +} + +void +slhci_log_slreq(struct slhci_pipe *r) +{ + DDOLOG("next: %p", r->q.next.sqe_next, 0,0,0); + DDOLOG("xfer: %p", r->xfer, 0,0,0); + DDOLOG("buffer: %p", r->buffer, 0,0,0); + DDOLOG("bustime: %u", r->bustime, 0,0,0); + DDOLOG("control: %#x", r->control, 0,0,0); + DDOLOGFLAG8("control=", r->control, "Preamble", "Data Toggle", + "SOF Sync", "ISOC", "res", "Out", "Enable", "Arm"); + DDOLOG("pid: %#x", r->tregs[PID], 0,0,0); + DDOLOG("dev: %u", r->tregs[DEV], 0,0,0); + DDOLOG("len: %u", r->tregs[LEN], 0,0,0); + + if (r->xfer) + slhci_log_xfer(r->xfer); } +#endif #endif /* SLHCI_DEBUG */ +/* End debug functions. */