sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
5f9cb6faf4
nuttx/drivers/usbhost/usbhost_max3421e.c
Gustavo Henrique Nihei e6b204f438 nuttx: Use MIN/MAX definitions from "sys/param.h" 
Signed-off-by: Gustavo Henrique Nihei <gustavo.nihei@espressif.com>
2023-02-01 23:47:44 +08:00

4968 lines
149 KiB
C
Raw Blame History

/****************************************************************************
* drivers/usbhost/usbhost_max3421e.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/* References:
* "MAX3421E USB Peripheral/Host Controller with SPI Interface",
* 19-3953, Rev 4, Maxim Integrated, July 2013 (Datasheet).
* "MAX3421E Programming Guide", Maxim Integrated, December 2006
* (Application Note).
*/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/param.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/arch.h>
#include <nuttx/kmalloc.h>
#include <nuttx/clock.h>
#include <nuttx/signal.h>
#include <nuttx/mutex.h>
#include <nuttx/semaphore.h>
#include <nuttx/wqueue.h>
#include <nuttx/spi/spi.h>
#include <nuttx/usb/usb.h>
#include <nuttx/usb/usbhost.h>
#include <nuttx/usb/usbhost_devaddr.h>
#include <nuttx/usb/max3421e.h>
#include <nuttx/usb/usbhost_trace.h>
#include <nuttx/irq.h>
#ifdef CONFIG_USBHOST_MAX3421E
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
/* MAX3421E USB Host Driver Support
*
* Pre-requisites
*
* CONFIG_USBHOST - Enable general USB host support
* CONFIG_USBHOST_MAX3421E - Enable the MAX3421E USB host support
* CONFIG_SCHED_LPWORK - Low priority work queue support is required.
*
* Options:
*
* CONFIG_MAX3421E_DESCSIZE - Maximum size of a descriptor. Default: 128
* CONFIG_MAX3421E_USBHOST_REGDEBUG - Enable very low-level register access
* debug. Depends on CONFIG_DEBUG_USB_INFO.
* CONFIG_MAX3421E_USBHOST_PKTDUMP - Dump all incoming and outgoing USB
* packets. Depends on CONFIG_DEBUG_USB_INFO.
*/
/* Maximum size of a descriptor */
#ifndef CONFIG_MAX3421E_DESCSIZE
# define CONFIG_MAX3421E_DESCSIZE 128
#endif
/* Low-priority work queue support is required. The high priority work
* queue is not used because this driver requires SPI access and may
* block or wait for a variety of reasons.
*/
#ifndef CONFIG_SCHED_LPWORK
# warning Low priority work thread support is necessary (CONFIG_SCHED_LPWORK)
#endif
/* Register/packet debug depends on CONFIG_DEBUG_FEATURES */
#ifndef CONFIG_DEBUG_USB_INFO
# undef CONFIG_MAX3421E_USBHOST_REGDEBUG
# undef CONFIG_MAX3421E_USBHOST_PKTDUMP
#endif
/* Delays *******************************************************************/
#define MAX3421E_READY_DELAY 200000 /* In loop counts */
#define MAX3421E_FLUSH_DELAY 200000 /* In loop counts */
#define MAX3421E_SETUP_DELAY SEC2TICK(5) /* 5 seconds in system ticks */
#define MAX3421E_DATANAK_DELAY SEC2TICK(5) /* 5 seconds in system ticks */
#define MAX3421E_RETRY_COUNT 5 /* Number of tries before giving up */
#define NO_HOLDER (INVALID_PROCESS_ID)
/* Debug ********************************************************************/
#define TR_FMT1 false
#define TR_FMT2 true
#define TRENTRY(id,fmt1,string) {string}
/****************************************************************************
* Private Types
****************************************************************************/
/* The following enumeration represents the various states of the USB host
* state machine (for debug purposes only)
*/
enum max3421e_smstate_e
{
SMSTATE_DETACHED = 0, /* Not attached to a device */
SMSTATE_ATTACHED, /* Attached to a device */
SMSTATE_ENUM, /* Attached, enumerating */
SMSTATE_CLASS_BOUND, /* Enumeration complete, class bound */
};
/* When a transfer completes and the HXFRDN interrupt is received, this
* informs the HXFRDN interrupt handle of the type of transfer that just
* completed.
*/
enum mx3421e_hxfrdn_e
{
HXFRDN_SETUP = 0, /* A setup transfer just completed */
HXFRDN_SNDZLP, /* A zero length IN transfer just completed */
HXFRDN_SNDFIFO, /* A normal IN transfer using SNDFIFO just completed */
HXFRDN_RCVFIFO, /* A normal OUT transfer using RCVFIFO just completed */
};
/* This structure retains the state of one host channel. NOTE: Since there
* is only one channel operation active at a time, some of the fields in
* in the structure could be moved in struct max3421e_ubhost_s to achieve
* some memory savings.
*/
struct max3421e_chan_s
{
bool inuse; /* True: This channel is "in use" */
bool in; /* True: IN endpoint */
uint8_t chidx; /* Channel index (0-3) */
uint8_t epno; /* Device endpoint number (0-127) */
uint8_t eptype; /* See MAX3421E_EPTYPE_* definitions */
uint8_t funcaddr; /* Device function address */
uint8_t speed; /* Device speed */
uint8_t interval; /* Interrupt/isochronous EP polling interval */
uint8_t maxpacket; /* Max packet size (8 or 64) */
uint8_t toggles; /* Saved data toggles from the HCTL register */
};
/* This structure retains the state of the USB host controller */
struct max3421e_usbhost_s
{
/* Common device fields. This must be the first thing defined in the
* structure so that it is possible to simply cast from struct
* usbhost_driver_s to struct max3421e_usbhost_s.
*/
struct usbhost_driver_s drvr;
/* This is the interface to the max3421e lower-half driver */
FAR const struct max3421e_lowerhalf_s *lower;
/* This is the hub port description understood by class drivers */
struct usbhost_roothubport_s rhport;
/* Overall driver status */
bool connected; /* Connected to device */
bool change; /* Connection change */
bool pscwait; /* True: Thread is waiting for a port event */
#ifdef CONFIG_DEBUG_ASSERTIONS
bool locked; /* The SPI bus is locked */
#endif
uint8_t smstate; /* The state of the USB host state machine */
uint8_t irqset; /* Set of enabled interrupts */
uint8_t xfrtype; /* See enum mx3421e_hxfrdn_e */
uint8_t inflight; /* Number of Tx bytes "in-flight" (<= 128) */
uint8_t result; /* The result of the transfer */
uint16_t buflen; /* Buffer length (at start of transfer) */
uint16_t xfrd; /* Bytes transferred (at end of transfer) */
rmutex_t lock; /* Support mutually exclusive access */
sem_t pscsem; /* Semaphore to wait for a port event */
sem_t waitsem; /* Channel wait semaphore */
FAR uint8_t *buffer; /* Transfer buffer pointer */
#ifdef CONFIG_USBHOST_ASYNCH
usbhost_asynch_t callback; /* Transfer complete callback */
FAR void *arg; /* Argument that accompanies the callback */
#endif
struct work_s irqwork; /* Used to process interrupts */
#ifdef CONFIG_USBHOST_HUB
/* Used to pass external hub port events */
FAR struct usbhost_hubport_s *hport;
#endif
/* The channel waiting for the next event (there will only be one in
* this design)
*/
FAR struct max3421e_chan_s *waiter;
/* The state of each host channel, one for each device endpoint. */
struct max3421e_chan_s chan[MAX3421E_NHOST_CHANNELS];
};
/* This is the MAX3421E connection structure */
struct max3421e_connection_s
{
/* Common device fields. This must be the first thing defined in the
* structure so that it is possible to simply cast from struct
* usbhost_connection_s to struct usbhost_connection_s.
*/
struct usbhost_connection_s conn;
/* Pointer to the associated state structure */
FAR struct max3421e_usbhost_s *priv;
};
/* Supports allocation of both structures simultaneously */
struct usbhost_alloc_s
{
struct max3421e_usbhost_s priv;
struct max3421e_connection_s conn;
};
/* Tracing support */
#ifdef HAVE_USBHOST_TRACE
struct max3421e_usbhost_trace_s
{
#if 0
uint16_t id;
bool fmt2;
#endif
FAR const char *string;
};
enum usbhost_trace1codes_e
{
__TRACE1_BASEVALUE = 0, /* This will force the first value to be 1 */
MAX3421E_TRACE1_ALLOC_FAIL,
#ifdef CONFIG_USBHOST_ASYNCH
MAX3421E_TRACE1_ASYNCHSETUP_FAIL1,
MAX3421E_TRACE1_ASYNCHSETUP_FAIL2,
#endif
MAX3421E_TRACE1_BAD_JKSTATE,
MAX3421E_TRACE1_BADREVISION,
MAX3421E_TRACE1_CHANALLOC_FAIL,
MAX3421E_TRACE1_CHANWAIT_FAIL,
MAX3421E_TRACE1_DEVDISCONN1,
MAX3421E_TRACE1_DEVDISCONN2,
MAX3421E_TRACE1_DEVDISCONN3,
MAX3421E_TRACE1_DEVDISCONN4,
MAX3421E_TRACE1_DEVDISCONN5,
MAX3421E_TRACE1_DEVDISCONN6,
MAX3421E_TRACE1_DEVDISCONN7,
MAX3421E_TRACE1_DEVDISCONN8,
MAX3421E_TRACE1_ENUMERATE_FAIL,
MAX3421E_TRACE1_INSETUP_FAIL1,
#ifdef CONFIG_USBHOST_ASYNCH
MAX3421E_TRACE1_INSETUP_FAIL2,
MAX3421E_TRACE1_INSETUP_FAIL3,
#endif
MAX3421E_TRACE1_IRQATTACH_FAIL,
MAX3421E_TRACE1_OUTSETUP_FAIL1,
#ifdef CONFIG_USBHOST_ASYNCH
MAX3421E_TRACE1_OUTSETUP_FAIL2,
MAX3421E_TRACE1_OUTSETUP_FAIL3,
#endif
MAX3421E_TRACE1_RECVDATA_FAIL,
MAX3421E_TRACE1_RECVSTATUS_FAIL,
MAX3421E_TRACE1_SENDDATA_FAIL,
MAX3421E_TRACE1_SENDSETUP_FAIL1,
MAX3421E_TRACE1_SENDSETUP_FAIL2,
MAX3421E_TRACE1_SENDSTATUS_FAIL,
MAX3421E_TRACE1_TRANSFER_FAILED1,
MAX3421E_TRACE1_TRANSFER_FAILED2,
MAX3421E_TRACE1_TRANSFER_FAILED3,
#ifdef HAVE_USBHOST_TRACE_VERBOSE
MAX3421E_VTRACE1_CANCEL,
MAX3421E_VTRACE1_CONNECTED1,
MAX3421E_VTRACE1_CONNECTED2,
MAX3421E_VTRACE1_CONNECTED3,
MAX3421E_VTRACE1_DISCONNECTED1,
MAX3421E_VTRACE1_DISCONNECTED2,
MAX3421E_VTRACE1_ENUMERATE,
#ifdef CONFIG_USBHOST_HUB
MAX3421E_VTRACE1_HUB_CONNECTED,
#endif
MAX3421E_VTRACE1_INITIALIZED,
#ifdef CONFIG_USBHOST_ASYNCH
MAX3421E_VTRACE1_TRANSFER_COMPLETE,
#endif
#endif
__TRACE1_NSTRINGS, /* Separates the format 1 from the format 2 strings */
#ifdef HAVE_USBHOST_TRACE_VERBOSE
#ifdef CONFIG_USBHOST_ASYNCH
MAX3421E_VTRACE2_ASYNCH,
#endif
MAX3421E_VTRACE2_BULKIN,
MAX3421E_VTRACE2_BULKOUT,
MAX3421E_VTRACE2_CHANWAKEUP_IN,
MAX3421E_VTRACE2_CHANWAKEUP_OUT,
MAX3421E_VTRACE2_CTRLIN,
MAX3421E_VTRACE2_CTRLOUT,
#ifdef CONFIG_USBHOST_HUB
MAX3421E_VTRACE2_HUB_CONNECTED,
#endif
MAX3421E_VTRACE2_INTRIN,
MAX3421E_VTRACE2_INTROUT,
MAX3421E_VTRACE2_ISOCIN,
MAX3421E_VTRACE2_ISOCOUT,
MAX3421E_VTRACE2_RECVSTATUS,
MAX3421E_VTRACE2_SENDSTATUS,
MAX3421E_VTRACE2_STARTTRANSFER1,
MAX3421E_VTRACE2_STARTTRANSFER2,
MAX3421E_VTRACE2_TRANSFER,
#ifdef CONFIG_USBHOST_ASYNCH
MAX3421E_VTRACE2_XFRCOMPLETE,
#endif
#endif
__TRACE2_NSTRINGS /* Total number of enumeration values */
};
# define TRACE1_FIRST ((int)__TRACE1_BASEVALUE + 1)
# define TRACE1_INDEX(id) ((int)(id) - TRACE1_FIRST)
# define TRACE1_NSTRINGS TRACE1_INDEX(__TRACE1_NSTRINGS)
# define TRACE2_FIRST ((int)__TRACE1_NSTRINGS + 1)
# define TRACE2_INDEX(id) ((int)(id) - TRACE2_FIRST)
# define TRACE2_NSTRINGS TRACE2_INDEX(__TRACE2_NSTRINGS)
#endif
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* SPI/Register operations **************************************************/
static void max3421e_lock(FAR struct max3421e_usbhost_s *priv);
static void max3421e_unlock(FAR struct max3421e_usbhost_s *priv);
#ifdef CONFIG_MAX3421E_USBHOST_REGDEBUG
static void max3421e_printreg(uint8_t addr, uint8_t val, bool iswrite);
static void max3421e_checkreg(uint8_t addr, uint8_t val, bool iswrite)
#endif
static inline uint8_t max3421e_fmtcmd(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, uint8_t dir);
static uint32_t max3421e_getreg(FAR struct max3421e_usbhost_s *priv,
uint8_t addr);
static void max3421e_putreg(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, uint8_t value);
static inline void max3421e_modifyreg(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, uint8_t clrbits, uint8_t setbits);
static void max3421e_recvblock(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, FAR void *buffer, size_t buflen);
static void max3421e_sndblock(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, FAR const void *buffer, size_t buflen);
#ifdef CONFIG_MAX3421E_USBHOST_PKTDUMP
# define max3421e_pktdump(m,b,n) lib_dumpbuffer(m,b,n)
#else
# define max3421e_pktdump(m,b,n)
#endif
/* Byte stream access helper functions **************************************/
static inline uint16_t max3421e_getle16(const uint8_t *val);
/* Channel management *******************************************************/
static int max3421e_chan_alloc(FAR struct max3421e_usbhost_s *priv);
static inline void max3421e_chan_free(FAR struct max3421e_usbhost_s *priv,
int chidx);
static int max3421e_chan_waitsetup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
#ifdef CONFIG_USBHOST_ASYNCH
static int max3421e_chan_asynchsetup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan, usbhost_asynch_t callback,
FAR void *arg);
#endif
static int max3421e_chan_wait(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static void max3421e_chan_wakeup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan, int result);
/* Control/data transfer logic **********************************************/
static inline void max3421e_save_toggles(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static inline void max3421e_restore_toggles(
FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static int max3421e_transfer_status(FAR struct max3421e_usbhost_s *priv);
static void max3421e_transfer_terminate(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan, int result);
/* OUT transfers */
static void max3421e_put_sndfifo(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static void max3421e_send_continue(FAR struct max3421e_usbhost_s *priv);
static void max3421e_send_start(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static ssize_t max3421e_out_transfer(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan, FAR uint8_t *buffer,
size_t buflen);
#ifdef CONFIG_USBHOST_ASYNCH
static void max3421e_out_next(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static int max3421e_out_asynch(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan, FAR uint8_t *buffer,
size_t buflen, usbhost_asynch_t callback, FAR void *arg);
#endif
/* Control transfers */
static int max3421e_ctrl_sendsetup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR const struct usb_ctrlreq_s *req);
static int max3421e_ctrl_senddata(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR uint8_t *buffer, unsigned int buflen);
static int max3421e_ctrl_sendstatus(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static int max3421e_ctrl_recvstatus(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static int max3421e_in_setup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static int max3421e_out_setup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
/* IN transfers */
static uint8_t max3421e_get_rcvfifo(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static void max3421e_recv_restart(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static void max3421e_recv_continue(FAR struct max3421e_usbhost_s *priv);
static void max3421e_recv_start(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static ssize_t max3421e_in_transfer(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan, FAR uint8_t *buffer,
size_t buflen);
#ifdef CONFIG_USBHOST_ASYNCH
static void max3421e_in_next(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan);
static int max3421e_in_asynch(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan, FAR uint8_t *buffer,
size_t buflen, usbhost_asynch_t callback, FAR void *arg);
#endif
/* Interrupt handling *******************************************************/
static void max3421e_connect_event(FAR struct max3421e_usbhost_s *priv);
static void max3421e_disconnect_event(FAR struct max3421e_usbhost_s *priv);
static int max3421e_connected(FAR struct max3421e_usbhost_s *priv);
static void max3421e_disconnected(FAR struct max3421e_usbhost_s *priv);
static void max3421e_irqwork(FAR void *arg);
static int max3421e_interrupt(int irq, FAR void *context, FAR void *arg);
/* Interrupt controls */
static inline void max3421e_int_enable(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset);
static inline void max3421e_int_disable(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset);
static inline uint8_t max3421e_int_status(
FAR struct max3421e_usbhost_s *priv);
static inline void max3421e_int_clear(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset);
static void max3421e_int_wait(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset, unsigned int usec);
/* USB host controller operations *******************************************/
static int max3421e_wait(FAR struct usbhost_connection_s *conn,
FAR struct usbhost_hubport_s **hport);
static int max3421e_getspeed(FAR struct max3421e_usbhost_s *priv,
FAR struct usbhost_connection_s *conn,
FAR struct usbhost_hubport_s *hport);
static int max3421e_enumerate(FAR struct usbhost_connection_s *conn,
FAR struct usbhost_hubport_s *hport);
static int max3421e_ep0configure(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep0, uint8_t funcaddr, uint8_t speed,
uint16_t maxpacketsize);
static int max3421e_epalloc(FAR struct usbhost_driver_s *drvr,
FAR const struct usbhost_epdesc_s *epdesc,
FAR usbhost_ep_t *ep);
static int max3421e_epfree(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep);
static int max3421e_alloc(FAR struct usbhost_driver_s *drvr,
FAR uint8_t **buffer, FAR size_t *maxlen);
static int max3421e_free(FAR struct usbhost_driver_s *drvr,
FAR uint8_t *buffer);
static int max3421e_ioalloc(FAR struct usbhost_driver_s *drvr,
FAR uint8_t **buffer, size_t buflen);
static int max3421e_iofree(FAR struct usbhost_driver_s *drvr,
FAR uint8_t *buffer);
static int max3421e_ctrlin(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep0, FAR const struct usb_ctrlreq_s *req,
FAR uint8_t *buffer);
static int max3421e_ctrlout(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep0, FAR const struct usb_ctrlreq_s *req,
FAR const uint8_t *buffer);
static ssize_t max3421e_transfer(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep, FAR uint8_t *buffer, size_t buflen);
#ifdef CONFIG_USBHOST_ASYNCH
static int max3421e_asynch(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep, FAR uint8_t *buffer, size_t buflen,
usbhost_asynch_t callback, FAR void *arg);
#endif
static int max3421e_cancel(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep);
#ifdef CONFIG_USBHOST_HUB
static int max3421e_connect(FAR struct max3421e_usbhost_s *priv,
FAR struct usbhost_hubport_s *hport, bool connected);
#endif
static void max3421e_disconnect(FAR struct usbhost_driver_s *drvr,
FAR struct usbhost_hubport_s *hport);
/* Initialization ***********************************************************/
static void max3421e_busreset(FAR struct max3421e_usbhost_s *priv);
static int max3421e_startsof(FAR struct max3421e_usbhost_s *priv);
static inline int max3421e_sw_initialize(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_connection_s *conn,
FAR const struct max3421e_lowerhalf_s *lower);
static inline int max3421e_hw_initialize(
FAR struct max3421e_usbhost_s *priv);
/****************************************************************************
* Private Data
****************************************************************************/
#ifdef HAVE_USBHOST_TRACE
/* Trace/debug format strings. */
static const struct max3421e_usbhost_trace_s g_trace1[TRACE1_NSTRINGS] =
{
TRENTRY(MAX3421E_TRACE1_ALLOC_FAIL, TR_FMT1,
"INIT: Failed to allocate state structure: %u\n"),
#ifdef CONFIG_USBHOST_ASYNCH
TRENTRY(MAX3421E_TRACE1_ASYNCHSETUP_FAIL1, TR_FMT1,
"OUT: Asynch setup failed: %u\n"),
TRENTRY(MAX3421E_TRACE1_ASYNCHSETUP_FAIL2, TR_FMT1,
"IN: Asynch setup failed: %u\n"),
#endif
TRENTRY(MAX3421E_TRACE1_BAD_JKSTATE, TR_FMT1,
"CONNECT: Bad JK state: %02x\n"),
TRENTRY(MAX3421E_TRACE1_BADREVISION, TR_FMT1,
"INIT: Bad revision number: %02x\n"),
TRENTRY(MAX3421E_TRACE1_CHANALLOC_FAIL, TR_FMT1,
"EPALLOC: Channel allocation failed: %u\n"),
TRENTRY(MAX3421E_TRACE1_CHANWAIT_FAIL, TR_FMT1,
"OUT: Channel wait failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN1, TR_FMT1,
"OUT: Disconnected during wait: %u\n"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN2, TR_FMT1,
"CTRL: Disconnected during SETUP phase: %u\n"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN3, TR_FMT1,
"CTRL OUT: Disconnected during DATA phase: %u\n"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN4, TR_FMT1,
"CTRL IN: Disconnected during DATA phase: %u"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN5, TR_FMT1,
"IN: Disconnected during wait: %u\n"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN6, TR_FMT1,
"CONNECT: Device disconnect #1: %u\n"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN7, TR_FMT1,
"CONNECT: Device disconnect #2: %u\n"),
TRENTRY(MAX3421E_TRACE1_DEVDISCONN8, TR_FMT1,
"CONNECT: Device disconnect #3: %u\n"),
TRENTRY(MAX3421E_TRACE1_ENUMERATE_FAIL, TR_FMT1,
"CONNECT: Enumeration failed: %u\n"),
TRENTRY(MAX3421E_TRACE1_INSETUP_FAIL1, TR_FMT1,
"CTRL IN: SETUP phase failure: %u\n"),
#ifdef CONFIG_USBHOST_ASYNCH
TRENTRY(MAX3421E_TRACE1_INSETUP_FAIL2, TR_FMT1,
"CTRL IN: Asynch SETUP phase failure #1: %u\n"),
TRENTRY(MAX3421E_TRACE1_INSETUP_FAIL3, TR_FMT1,
"CTRL IN: Asynch SETUP phase failure #2: %u\n"),
#endif
TRENTRY(MAX3421E_TRACE1_IRQATTACH_FAIL, TR_FMT1,
"INIT: Failed to attach interrupt: %u\n"),
TRENTRY(MAX3421E_TRACE1_OUTSETUP_FAIL1, TR_FMT1,
"CTRL OUT: SETUP phase failure: %u\n"),
#ifdef CONFIG_USBHOST_ASYNCH
TRENTRY(MAX3421E_TRACE1_OUTSETUP_FAIL2, TR_FMT1,
"CTRL OUT: Asynch SETUP phase failure #1: %u\n"),
TRENTRY(MAX3421E_TRACE1_OUTSETUP_FAIL3, TR_FMT1,
"CTRL OUT: Asynch SETUP phase failure #2: %u\n"),
#endif
TRENTRY(MAX3421E_TRACE1_RECVDATA_FAIL, TR_FMT1,
"CTRL IN: Data phase failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_RECVSTATUS_FAIL, TR_FMT1,
"CTRL OUT: Status phase failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_SENDDATA_FAIL, TR_FMT1,
"CTRL OUT: Data phase failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_SENDSETUP_FAIL1, TR_FMT1,
"CTRL OUT: SETUP phase failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_SENDSETUP_FAIL2, TR_FMT1,
"CTRL IN: SETUP phase failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_SENDSTATUS_FAIL, TR_FMT1,
"CTRL IN: Status phase failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_TRANSFER_FAILED1, TR_FMT1,
"OUT: Transfer wait returned failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_TRANSFER_FAILED2, TR_FMT1,
"CTRL: SETUP wait returned failure: %u\n"),
TRENTRY(MAX3421E_TRACE1_TRANSFER_FAILED3, TR_FMT1,
"IN: Transfer wait returned failure: %u\n"),
#ifdef HAVE_USBHOST_TRACE_VERBOSE
TRENTRY(MAX3421E_VTRACE1_CANCEL, TR_FMT1,
"Transfer canceled: EP%u\n"),
TRENTRY(MAX3421E_VTRACE1_CONNECTED1, TR_FMT1,
"CONNECT: Connection event: %u\n"),
TRENTRY(MAX3421E_VTRACE1_CONNECTED2, TR_FMT1,
"CONNECT: Connection change detected: %u\n"),
TRENTRY(MAX3421E_VTRACE1_CONNECTED3, TR_FMT1,
"CONNECT: Connected: %u\n"),
TRENTRY(MAX3421E_VTRACE1_DISCONNECTED1, TR_FMT1,
"CONNECT: Disconnected: %u\n"),
TRENTRY(MAX3421E_VTRACE1_DISCONNECTED2, TR_FMT1,
"CONNECT: Disconnect detected: %u\n"),
TRENTRY(MAX3421E_VTRACE1_ENUMERATE, TR_FMT1,
"ENUMERATE: Start: %u\n"),
#ifdef CONFIG_USBHOST_HUB
TRENTRY(MAX3421E_VTRACE1_HUB_CONNECTED, TR_FMT1,
"CONNECT: Hub connected: %u\n"),
#endif
TRENTRY(MAX3421E_VTRACE1_INITIALIZED, TR_FMT1,
"INIT: Hardware initialized: %u\n"),
#ifdef CONFIG_USBHOST_ASYNCH
TRENTRY(MAX3421E_VTRACE1_TRANSFER_COMPLETE, TR_FMT1,
"OUT: Asynch transfer complete: %u\n"),
#endif
#endif
};
static const struct max3421e_usbhost_trace_s g_trace2[TRACE2_NSTRINGS] =
{
#ifdef HAVE_USBHOST_TRACE_VERBOSE
#ifdef CONFIG_USBHOST_ASYNCH
TRENTRY(MAX3421E_VTRACE2_ASYNCH, TR_FMT2,
"ASYNCH: Transfer started: EP%u len=%u\n"),
#endif
TRENTRY(MAX3421E_VTRACE2_BULKIN, TR_FMT2,
"BULK IN: SETUP: Chan%u len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_BULKOUT, TR_FMT2,
"BULK OUT: SETUP: Chan%u len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_CHANWAKEUP_IN, TR_FMT2,
"IN: Channel wakeup: Chan%, result=%u\n"),
TRENTRY(MAX3421E_VTRACE2_CHANWAKEUP_OUT, TR_FMT2,
"OUT: Channel wakeup: Chan%u result=%u\n"),
TRENTRY(MAX3421E_VTRACE2_CTRLIN, TR_FMT2,
"CTRL IN: Start: type=%u req=%u\n"),
TRENTRY(MAX3421E_VTRACE2_CTRLOUT, TR_FMT2,
"CTRL OUT: Start: type=%u req=%u\n"),
#ifdef CONFIG_USBHOST_HUB
TRENTRY(MAX3421E_VTRACE2_HUB_CONNECTED, TR_FMT2,
"CONNECT: Hub connected: port=%u, connected=%u\n"),
#endif
TRENTRY(MAX3421E_VTRACE2_INTRIN, TR_FMT2,
"INTR IN: SETUP: Chan%u len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_INTROUT, TR_FMT2,
"INTR OUT: SETUP: Chan%u len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_ISOCIN, TR_FMT2,
"ISOC IN: SETUP: Chan%u len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_ISOCOUT, TR_FMT2,
"ISOC OUT: SETUP: Chan%u len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_RECVSTATUS, TR_FMT2,
"CTRL OUT: Receive status: Chan% len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_SENDSTATUS, TR_FMT2,
"CTRL IN: Send status: Chan% len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_STARTTRANSFER1, TR_FMT2,
"OUT: Send start: Chan% len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_STARTTRANSFER2, TR_FMT2,
"IN: Receive start: Chan% len=%u\n"),
TRENTRY(MAX3421E_VTRACE2_TRANSFER, TR_FMT2,
"Transfer start: EP%u len=%u\n"),
#ifdef CONFIG_USBHOST_ASYNCH
TRENTRY(MAX3421E_VTRACE2_XFRCOMPLETE, TR_FMT2,
"ASYNCH: Transfer complete: EP%u len=%u\n"),
#endif
#endif
};
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: max3421e_lock
*
* Description:
* Lock and configure the SPI bus.
*
****************************************************************************/
static void max3421e_lock(FAR struct max3421e_usbhost_s *priv)
{
FAR const struct max3421e_lowerhalf_s *lower = priv->lower;
FAR struct spi_dev_s *spi;
DEBUGASSERT(lower != NULL && lower->spi != NULL && !priv->locked);
spi = lower->spi;
SPI_LOCK(spi, true);
SPI_SETMODE(spi, lower->mode);
SPI_SETBITS(spi, 8);
SPI_HWFEATURES(spi, 0);
SPI_SETFREQUENCY(spi, lower->frequency);
#ifdef CONFIG_DEBUG_ASSERTIONS
/* Mark the SPI bus as locked (for debug only) */
priv->locked = true;
#endif
}
/****************************************************************************
* Name: max3421e_unlock
*
* Description:
* Unlock the SPI bus.
*
****************************************************************************/
static void max3421e_unlock(FAR struct max3421e_usbhost_s *priv)
{
FAR const struct max3421e_lowerhalf_s *lower = priv->lower;
DEBUGASSERT(lower != NULL && lower->spi != NULL && priv->locked);
SPI_LOCK(lower->spi, false);
#ifdef CONFIG_DEBUG_ASSERTIONS
/* Mark the SPI bus as unlocked (for debug only) */
priv->locked = false;
#endif
}
/****************************************************************************
* Name: max3421e_printreg
*
* Description:
* Print the contents of an MAX3421Exx register operation
*
****************************************************************************/
#ifdef CONFIG_MAX3421E_USBHOST_REGDEBUG
static void max3421e_printreg(uint8_t addr, uint8_t val, bool iswrite)
{
uinfo("%02x%s%02x\n", addr, iswrite ? "<-" : "->", val);
}
#endif
/****************************************************************************
* Name: max3421e_checkreg
*
* Description:
* Get the contents of an MAX3421E register
*
****************************************************************************/
#ifdef CONFIG_MAX3421E_USBHOST_REGDEBUG
static void max3421e_checkreg(uint8_t addr, uint8_t val, bool iswrite)
{
static uint8_t prevaddr = 0;
static uint8_t preval = 0;
static unsigned int count = 0;
static bool prevwrite = false;
/* Is this the same value that we read from/wrote to the same register
* last time? Are we polling the register? If so, suppress the output.
*/
if (addr == prevaddr && val == preval && prevwrite == iswrite)
{
/* Yes.. Just increment the count */
count++;
}
else
{
/* No this is a new address or value or operation. Were there any
* duplicate accesses before this one?
*/
if (count > 0)
{
/* Yes.. Just one? */
if (count == 1)
{
/* Yes.. Just one */
max3421e_printreg(prevaddr, preval, prevwrite);
}
else
{
/* No.. More than one. */
uinfo("[repeats %d more times]\n", count);
}
}
/* Save the new address, value, count, and operation for next time */
prevaddr = addr;
preval = val;
count = 0;
prevwrite = iswrite;
/* Show the new register access */
max3421e_printreg(addr, val, iswrite);
}
}
#endif
/****************************************************************************
* Name: max3421e_fmtcmd
*
* Description:
* Format a command
*
* The command byte contains the register address, a direction bit, and an
* ACKSTAT bit:
*
* Bits 3-7: Command
* Bit 2: Unused
* Bit 1: Direction (read = 0, write = 1)
* Bit 0: ACKSTAT
*
* The ACKSTAT bit is ignored in host mode.
*
****************************************************************************/
static inline uint8_t max3421e_fmtcmd(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, uint8_t dir)
{
return addr | dir | MAX3421E_ACKSTAT_FALSE;
}
/****************************************************************************
* Name: max3421e_getreg
*
* Description:
* Get the contents of an MAX3421E register
*
* Assumption:
* SPI bus is locked
*
****************************************************************************/
static uint32_t max3421e_getreg(FAR struct max3421e_usbhost_s *priv,
uint8_t addr)
{
FAR const struct max3421e_lowerhalf_s *lower = priv->lower;
FAR struct spi_dev_s *spi;
uint8_t cmd;
uint8_t value;
DEBUGASSERT(lower != NULL && lower->spi != NULL && priv->locked);
spi = lower->spi;
/* Select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), true);
/* Send the read command byte */
cmd = max3421e_fmtcmd(priv, addr, MAX3421E_DIR_READ);
SPI_SEND(spi, cmd);
/* Read the value of the register */
value = SPI_SEND(spi, 0xff);
/* De-select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), false);
#ifdef CONFIG_MAX3421E_USBHOST_REGDEBUG
/* Check if we need to print this value */
max3421e_checkreg(addr, value, false);
#endif
return value;
}
/****************************************************************************
* Name: max3421e_putreg
*
* Description:
* Set the contents of an MAX3421E register to a value
*
* Assumption:
* SPI bus is locked
*
****************************************************************************/
static void max3421e_putreg(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, uint8_t value)
{
FAR const struct max3421e_lowerhalf_s *lower = priv->lower;
FAR struct spi_dev_s *spi;
uint8_t cmd;
DEBUGASSERT(lower != NULL && lower->spi != NULL && priv->locked);
spi = lower->spi;
#ifdef CONFIG_MAX3421E_USBHOST_REGDEBUG
/* Check if we need to print this value */
max3421e_checkreg(addr, val, true);
#endif
/* Select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), true);
/* Send the write command byte */
cmd = max3421e_fmtcmd(priv, addr, MAX3421E_DIR_WRITE);
SPI_SEND(spi, cmd);
/* Send the new value for the register */
SPI_SEND(spi, value);
/* De-select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), false);
}
/****************************************************************************
* Name: max3421e_modifyreg
*
* Description:
* Modify selected bits of an MAX3421E register.
*
* Assumption:
* SPI bus is locked
*
****************************************************************************/
static inline void max3421e_modifyreg(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, uint8_t clrbits,
uint8_t setbits)
{
uint8_t value;
value = max3421e_getreg(priv, addr);
value &= ~clrbits;
value |= setbits;
max3421e_putreg(priv, addr, value);
}
/****************************************************************************
* Name: max3421e_recvblock
*
* Description:
* Receive a block of data from the MAX341E.
*
* Assumption:
* SPI bus is locked
*
****************************************************************************/
static void max3421e_recvblock(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, FAR void *buffer, size_t buflen)
{
FAR const struct max3421e_lowerhalf_s *lower = priv->lower;
FAR struct spi_dev_s *spi;
uint8_t cmd;
DEBUGASSERT(lower != NULL && lower->spi != NULL && priv->locked);
spi = lower->spi;
/* Select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), true);
/* Send the read command byte */
cmd = max3421e_fmtcmd(priv, addr, MAX3421E_DIR_READ);
SPI_SEND(spi, cmd);
/* Read the block of values from the register(s) */
SPI_RECVBLOCK(spi, buffer, buflen);
/* De-select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), false);
#ifdef CONFIG_MAX3421E_USBHOST_REGDEBUG
/* Dump the block of data received */
lib_dumpbuffer("Received:", buffer, buflen);
#endif
}
/****************************************************************************
* Name: max3421e_sndblock
*
* Description:
* Send a block of data to the MAX341E.
*
* Assumption:
* SPI bus is locked
*
****************************************************************************/
static void max3421e_sndblock(FAR struct max3421e_usbhost_s *priv,
uint8_t addr, FAR const void *buffer,
size_t buflen)
{
FAR const struct max3421e_lowerhalf_s *lower = priv->lower;
FAR struct spi_dev_s *spi;
uint8_t cmd;
DEBUGASSERT(lower != NULL && lower->spi != NULL && priv->locked);
spi = lower->spi;
#ifdef CONFIG_MAX3421E_USBHOST_REGDEBUG
/* Dump the block of data to be sent */
lib_dumpbuffer("Sending:", buffer, buflen);
#endif
/* Select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), true);
/* Send the wrte command byte */
cmd = max3421e_fmtcmd(priv, addr, MAX3421E_DIR_WRITE);
SPI_SEND(spi, cmd);
/* Send the new value for the register */
SPI_SNDBLOCK(spi, buffer, buflen);
/* De-select the MAX4321E */
SPI_SELECT(spi, SPIDEV_USBHOST(lower->devid), false);
}
/****************************************************************************
* Name: max3421e_getle16
*
* Description:
* Get a (possibly unaligned) 16-bit little endian value.
*
****************************************************************************/
static inline uint16_t max3421e_getle16(const uint8_t *val)
{
return (uint16_t)val[1] << 8 | (uint16_t)val[0];
}
/****************************************************************************
* Name: max3421e_chan_alloc
*
* Description:
* Allocate a channel.
*
****************************************************************************/
static int max3421e_chan_alloc(FAR struct max3421e_usbhost_s *priv)
{
int chidx;
/* Search the table of channels */
for (chidx = 0; chidx < MAX3421E_NHOST_CHANNELS; chidx++)
{
/* Is this channel available? */
if (!priv->chan[chidx].inuse)
{
/* Yes... make it "in use" and return the index */
priv->chan[chidx].inuse = true;
return chidx;
}
}
/* All of the channels are "in-use" */
return -EBUSY;
}
/****************************************************************************
* Name: max3421e_chan_free
*
* Description:
* Free a previoiusly allocated channel.
*
****************************************************************************/
static void max3421e_chan_free(FAR struct max3421e_usbhost_s *priv,
int chidx)
{
DEBUGASSERT((unsigned)chidx < MAX3421E_NHOST_CHANNELS);
/* Halt the channel */
#warning Missing logic
/* Mark the channel available */
priv->chan[chidx].inuse = false;
}
/****************************************************************************
* Name: max3421e_chan_waitsetup
*
* Description:
* Set the request for the transfer complete event well BEFORE enabling
* the transfer (as soon as we are absolutely committed to the transfer).
* We do this to minimize race conditions. This logic would have to be
* expanded if we want to have more than one packet in flight at a time!
*
* Assumptions:
* Called from a normal thread context BEFORE the transfer has been
* started.
*
****************************************************************************/
static int max3421e_chan_waitsetup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
irqstate_t flags = enter_critical_section();
int ret = -ENODEV;
DEBUGASSERT(priv != NULL && chan != NULL && priv->waiter == NULL);
/* Is the device still connected? */
if (priv->connected)
{
/* Yes.. then set waiter to indicate that we expect to be informed
* when either (1) the device is disconnected, or (2) the transfer
* completed.
*/
priv->waiter = chan;
#ifdef CONFIG_USBHOST_ASYNCH
priv->callback = NULL;
priv->arg = NULL;
#endif
ret = OK;
}
leave_critical_section(flags);
return ret;
}
/****************************************************************************
* Name: max3421e_chan_asynchsetup
*
* Description:
* Set the request for the transfer complete event well BEFORE enabling the
* transfer (as soon as we are absolutely committed to transfer). We do
* this to minimize race conditions. This logic would have to be expanded
* if we want to have more than one packet in flight at a time!
*
* Assumptions:
* Might be called from the level of an interrupt handler
*
****************************************************************************/
#ifdef CONFIG_USBHOST_ASYNCH
static int max3421e_chan_asynchsetup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
usbhost_asynch_t callback, FAR void *arg)
{
irqstate_t flags = enter_critical_section();
int ret = -ENODEV;
DEBUGASSERT(priv != NULL && chan != NULL);
/* Is the device still connected? */
if (priv->connected)
{
priv->waiter = NULL; /* No waiter */
priv->callback = callback;
priv->arg = arg;
ret = OK;
}
leave_critical_section(flags);
return ret;
}
#endif
/****************************************************************************
* Name: max3421e_chan_wait
*
* Description:
* Wait for a transfer on a channel to complete.
*
* Assumptions:
* Called from a normal thread context
*
****************************************************************************/
static int max3421e_chan_wait(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
irqstate_t flags;
int ret;
/* Disable interrupts so that the following operations will be atomic. On
* the host global interrupt needs to be disabled. However, here we
* disable all interrupts to exploit that fact that interrupts will be re-
* enabled while we wait.
*/
flags = enter_critical_section();
/* Loop, testing for an end of transfer condition. The channel 'result'
* was set to EBUSY and 'waiter' was set to the channel expecting the
* response before the transfer was started; 'waiter' will be nullified
* and 'result' will be set appropriately when the transfer is completed.
*/
do
{
/* Wait for the transfer to complete. NOTE the transfer may already
* completed before we get here or the transfer may complete while we
* wait here.
*/
ret = nxsem_wait_uninterruptible(&priv->waitsem);
if (ret < 0)
{
leave_critical_section(flags);
return ret;
}
}
while (priv->waiter != NULL);
/* The transfer is complete re-enable interrupts and return the result */
ret = -(int)priv->result;
leave_critical_section(flags);
return ret;
}
/****************************************************************************
* Name: max3421e_chan_wakeup
*
* Description:
* A channel transfer has completed... wakeup any threads waiting for the
* transfer to complete.
*
* Assumptions:
* This function is called from the transfer complete interrupt handler for
* the channel. Interrupts are disabled.
*
****************************************************************************/
static void max3421e_chan_wakeup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
int result)
{
/* Save the result of the operation */
DEBUGASSERT(priv->result != EBUSY);
priv->result = result;
/* Is there a thread waiting for this transfer to complete? */
if (priv->waiter != NULL)
{
#ifdef CONFIG_USBHOST_ASYNCH
/* Yes.. there should not also be a callback scheduled */
DEBUGASSERT(priv->callback == NULL);
#endif
/* Wake'em up! */
usbhost_vtrace2(chan->in ? MAX3421E_VTRACE2_CHANWAKEUP_IN :
MAX3421E_VTRACE2_CHANWAKEUP_OUT,
chan->chidx, priv->result);
nxsem_post(&priv->waitsem);
priv->waiter = NULL;
}
#ifdef CONFIG_USBHOST_ASYNCH
/* No.. is an asynchronous callback expected when the transfer completes? */
else if (priv->callback)
{
/* Handle continuation of IN/OUT pipes */
if (chan->in)
{
max3421e_in_next(priv, chan);
}
else
{
max3421e_out_next(priv, chan);
}
}
#endif
}
/****************************************************************************
* Name: max3421e_save_toggles and max3421e_restore_toggles
*
* Description:
* Save and restore data toggles from/to the HCTL register. The MAX3421E
* will automatically update the toggles for consecutive transfers to the
* same endpoint; We need to use these only when we change endpoints.
*
****************************************************************************/
static inline void
max3421e_save_toggles(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
chan->toggles = max3421e_getreg(priv, MAX3421E_USBHOST_HCTL);
}
static inline void
max3421e_restore_toggles(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
max3421e_modifyreg(priv, MAX3421E_USBHOST_HCTL,
USBHOST_HCTL_TOGGLES_MASK,
chan->toggles & USBHOST_HCTL_TOGGLES_MASK);
}
/****************************************************************************
* Name: max3421e_transfer_status
*
* Description:
* Get the end-of-transfer status from HRSLT register.
*
* REVISIT: Currently NAKs are treated as errors. A NAK on the first
* packet can probably be treated that way. But not NAKs after the
* transfer is in progress. We should also need to reset the peripheral
* in that case. Better to try and retry here within the driver.
*
* Returned value:
* OK - Transfer successful
* -EAGAIN - If devices NAKs the transfer.
* -EPERM - If the endpoint stalls
* -BUSY - The transfer is not complete
* -EIO - Other, undecoded error
*
* Assumptions:
* The SPI bus is locked.
*
****************************************************************************/
static int max3421e_transfer_status(FAR struct max3421e_usbhost_s *priv)
{
uint8_t regval;
int ret;
/* Get the result of the transfer from the HRSLT register */
regval = max3421e_getreg(priv, MAX3421E_USBHOST_HRSL);
/* Make the error result to something that the world knows about */
switch (regval & USBHOST_HRSL_HRSLT_MASK)
{
case USBHOST_HRSL_HRSLT_SUCCESS:
ret = OK;
break;
case USBHOST_HRSL_HRSLT_BUSY:
ret = -EBUSY;
break;
case USBHOST_HRSL_HRSLT_NAK:
ret = -EAGAIN;
break;
case USBHOST_HRSL_HRSLT_STALL:
ret = -EPERM;
break;
default:
ret = -EIO;
break;
}
return ret;
}
/****************************************************************************
* Name: max3421e_transfer_terminate
*
* Description:
* Terminate a IN or OUT transfer due to an error (or because a zero-
* length OUT transfer occurred).
*
* Returned value:
* OK - Transfer successful
* -EAGAIN - If devices NAKs the transfer.
* -EPERM - If the endpoint stalls
* -BUSY - The transfer is not complete
* -EIO - Other, undecoded error
*
* Assumptions:
* The SPI bus is locked.
*
****************************************************************************/
static void max3421e_transfer_terminate(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
int result)
{
/* Disable further SNDBAV, RCVDAV or HXFRDN interrupts */
max3421e_int_disable(priv, USBHOST_HIRQ_SNDBAVIRQ |
USBHOST_HIRQ_RCVDAVIRQ |
USBHOST_HIRQ_HXFRDNIRQ);
/* Save the endpoint toggle settings.
*
* REVISIT: The MAX4321E sends fixed DATA0 and DATA1 PID tokens for the
* various stages of a CONTROL transfer, regardless of the setting of
* the internal data toggle.
*/
max3421e_save_toggles(priv, chan);
/* Wake up any waiters for the end of transfer event */
DEBUGASSERT(priv->waiter != NULL);
max3421e_chan_wakeup(priv, chan, -result);
}
/****************************************************************************
* Name: max3421e_put_sndfifo
*
* Description:
* Copy data from the user-provided buffer into the SNDFIFO.
*
* Assumptions:
* The SPI bus is locked.
* There is data to be remaining to be sent.
* The caller has already set up for the wait event.
*
****************************************************************************/
static void max3421e_put_sndfifo(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
uint16_t committed;
uint16_t wrsize;
uint8_t maxpacket;
int i;
DEBUGASSERT(priv != NULL && chan != NULL);
/* The SNDFIFO is double buffered. We may load up to MAX3421E_SNDFIFO_SIZE
* into one buffer. After loading the SNDFIFO buffer, the write the SNDBC
* (Send Byte Count) register with the number of bytes loaded. The
* MAX3421E will clear SNDBAVIRQ (Send Buffer Available IRQ) and commit
* the FIFO to USB transmission.
*
* If the other buffer is available when SNDBC is written, the MAX3421E
* will clear SNDBAVIRQ then immediately set it to indicate
* availability of the second buffer.
*
* The CPU should load the SNDFIFO only when a SNDBAVIRQ = 1.
*/
maxpacket = chan->maxpacket;
DEBUGASSERT(maxpacket <= MAX3421E_SNDFIFO_SIZE);
committed = priv->xfrd + (uint16_t)priv->inflight;
DEBUGASSERT(committed < priv->buflen);
for (i = 0;
i < 2 && committed < priv->buflen &&
(max3421e_int_status(priv) & USBHOST_HIRQ_SNDBAVIRQ) != 0;
i++)
{
/* Get the size of the biggest thing that we can put in the current
* SNDFIFO buffer.
*/
wrsize = priv->buflen - committed;
if (wrsize > maxpacket)
{
wrsize = maxpacket;
}
/* Write packet into the SNDFIFO. */
max3421e_sndblock(priv, MAX3421E_USBHOST_SNDFIFO,
priv->buffer + committed, wrsize);
/* Write the byte count to the SNDBC register */
max3421e_putreg(priv, MAX3421E_USBHOST_SNDBC, wrsize);
/* Send the OUT token */
max3421e_putreg(priv, MAX3421E_USBHOST_HXFR,
USBHOST_HXFR_TOKEN_OUT | chan->epno);
/* Increment the count of bytes "in-flight" in the SNDFIFO */
priv->inflight += wrsize;
committed = priv->xfrd + wrsize;
}
/* Enable the SNDFIFO interrupt to handle the completion/continuation
* of transfer. Enable the HXFRDNIRQ to catch NAKs and transfer errors.
*/
priv->xfrtype = HXFRDN_SNDFIFO;
max3421e_int_enable(priv, USBHOST_HIRQ_SNDBAVIRQ | USBHOST_HIRQ_HXFRDNIRQ);
}
/****************************************************************************
* Name: max3421e_send_continue
*
* Description:
* Continue the send operation started by max3421e_send_start(). If
* max3421e_put_sndfifo() was unable to load the entire outgoing buffer
* into the SNDFIFO, it enabled SNDBAV interrupt.
*
* When the SNDBAV interrupt occurred, max3421e_irqwork() disabled that
* interrupt and called this function in order to continue that long send
* operations.
*
* Assumptions:
* The SPI bus is locked.
* The SNDBAV interrupt has been disabled.
*
****************************************************************************/
static void max3421e_send_continue(FAR struct max3421e_usbhost_s *priv)
{
FAR struct max3421e_chan_s *chan;
int result;
uint8_t xfrd;
DEBUGASSERT(priv != NULL && priv->waiter != NULL);
chan = priv->waiter;
/* Check the result of a transfer */
result = max3421e_transfer_status(priv);
if (result < 0)
{
/* Terminate the transfer on any error. */
max3421e_transfer_terminate(priv, chan, result);
return;
}
/* Update the number of bytes transferred. We have to be a little clever
* here: We do not keep track of the number of bytes sent in each of the
* SNDFIFO buffers, rather only the outstanding number of buffered
* transferred, 'inflight'. However, we know that all transfers will be
* the max packet size (other than the last one perhaps).
*/
/* If the number inflight is strictly greater than the maxpacket size, then
* we can infer that the transfer that just completed was maxpacket size.
*/
if (priv->inflight > chan->maxpacket)
{
xfrd = chan->maxpacket;
}
/* If the number inflight is less than chan->maxpacket, then that must have
* been the last packet of the transfer.
*/
else if (priv->inflight < chan->maxpacket)
{
xfrd = priv->inflight;
DEBUGASSERT((priv->xfrd + xfrd) == priv->buflen);
}
/* If the number inflight is exactly the maxpacket size and the transfer
* is not yet finished, then the the transfer size must have been max
* packet size.
*/
else if ((priv->xfrd + chan->maxpacket) >= priv->buflen)
{
xfrd = priv->buflen - priv->xfrd;
DEBUGASSERT((priv->xfrd + xfrd) == priv->buflen);
}
/* Otherwise, the transfer must have been the max packet size */
else
{
xfrd = chan->maxpacket;
}
priv->xfrd += xfrd;
priv->inflight -= xfrd;
/* Check for the end of transfer */
if (priv->xfrd >= priv->buflen)
{
/* Successful end-of-transfer */
max3421e_transfer_terminate(priv, chan, OK);
}
else
{
/* No.. there are more bytes to be sent */
max3421e_put_sndfifo(priv, chan);
}
}
/****************************************************************************
* Name: max3421e_send_start
*
* Description:
* Start at transfer on the selected IN or OUT channel.
*
****************************************************************************/
static void max3421e_send_start(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
max3421e_pktdump("Sending", priv->buffer, priv->buflen);
/* Set up the initial state of the transfer */
usbhost_vtrace2(MAX3421E_VTRACE2_STARTTRANSFER1,
chan->chidx, priv->buflen);
priv->result = EBUSY;
priv->inflight = 0;
priv->xfrd = 0;
/* Make sure the peripheral address is correct */
max3421e_putreg(priv, MAX3421E_USBHOST_PERADDR, chan->funcaddr);
/* Checkout for zero length packet */
if (priv->buflen > 0)
{
/* No.. we need to copy the outgoing data into SNDFIFO. */
max3421e_restore_toggles(priv, chan);
/* Then load the data into the SNDFIFO and start the transfer */
max3421e_put_sndfifo(priv, chan);
}
else
{
/* Write the zero byte count to the SNDBC register */
max3421e_putreg(priv, MAX3421E_USBHOST_SNDBC, 0);
/* Send the OUT token */
max3421e_putreg(priv, MAX3421E_USBHOST_HXFR,
USBHOST_HXFR_TOKEN_OUT | chan->epno);
/* Enable the HXFRDNIRQ to catch completion of the ZLP. */
priv->xfrtype = HXFRDN_SNDZLP;
max3421e_int_enable(priv, USBHOST_HIRQ_HXFRDNIRQ);
}
}
/****************************************************************************
* Name: max3421e_out_transfer
*
* Description:
* Transfer the 'buflen' bytes in 'buffer' through an OUT channel.
*
* Assumptions:
* The SPI is not locked. This function is called only from the TRANSFER
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
static ssize_t max3421e_out_transfer(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR uint8_t *buffer, size_t buflen)
{
clock_t start;
clock_t elapsed;
size_t xfrlen;
ssize_t xfrd;
int ret;
/* Loop until the transfer completes (i.e., buflen is decremented to zero)
* or a fatal error occurs (any error other than a simple NAK)
*/
start = clock_systime_ticks();
xfrd = 0;
while (buflen > 0)
{
/* Transfer one packet at a time. The hardware is capable of queueing
* multiple OUT packets, but I just haven't figured out how to handle
* the case where a single OUT packet in the group is NAKed.
*/
xfrlen = MIN(chan->maxpacket, buflen);
priv->buffer = buffer;
priv->buflen = xfrlen;
priv->xfrd = 0;
/* Set up for the wait BEFORE starting the transfer */
ret = max3421e_chan_waitsetup(priv, chan);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN1, 0);
return (ssize_t)ret;
}
/* Set up for the transfer based on the direction and the endpoint */
max3421e_lock(priv);
ret = max3421e_out_setup(priv, chan);
max3421e_unlock(priv);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_OUTSETUP_FAIL1, -ret);
return (ssize_t)ret;
}
/* Wait for the transfer to complete and get the result */
ret = max3421e_chan_wait(priv, chan);
/* Handle transfer failures */
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_TRANSFER_FAILED1, ret);
/* Check for a special case: If (1) the transfer was NAKed and (2)
* no SNDFIFO empty or Rx FIFO not-empty event occurred, then we
* should be able to just flush the Rx and SNDFIFOs and try again.
* We can detect this latter case because then the transfer buffer
* pointer and buffer size will be unaltered.
*/
elapsed = clock_systime_ticks() - start;
if (ret != -EAGAIN || /* Not a NAK condition OR */
elapsed >= MAX3421E_DATANAK_DELAY || /* Timeout has elapsed OR */
priv->xfrd > 0) /* Data has been partially transferred */
{
/* Break out and return the error */
usbhost_trace1(MAX3421E_TRACE1_CHANWAIT_FAIL, -ret);
return (ssize_t)ret;
}
/* Get the device a little time to catch up. Then retry the
* transfer using the same buffer pointer and length.
*/
nxsig_usleep(20 * 1000);
}
else
{
/* Successfully transferred. Update the buffer pointer/length */
buffer += xfrlen;
buflen -= xfrlen;
xfrd += priv->xfrd;
}
}
return xfrd;
}
/****************************************************************************
* Name: max3421e_out_next
*
* Description:
* Initiate the next of a sequence of asynchronous transfers.
*
* Assumptions:
* This function is always called from an interrupt handler
*
****************************************************************************/
#ifdef CONFIG_USBHOST_ASYNCH
static void max3421e_out_next(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
usbhost_asynch_t callback;
FAR void *arg;
ssize_t nbytes;
int result;
int ret;
/* Is the full transfer complete? Did the last chunk transfer OK? */
result = -(int)priv->result;
if (priv->xfrd < priv->buflen && result == OK)
{
/* Yes.. Set up for the next transfer based on the direction and the
* endpoint type
*/
ret = max3421e_out_setup(priv, chan);
if (ret >= 0)
{
return;
}
usbhost_trace1(MAX3421E_TRACE1_OUTSETUP_FAIL2, -ret);
result = ret;
}
/* The transfer is complete, with or without an error */
usbhost_vtrace1(MAX3421E_VTRACE1_TRANSFER_COMPLETE, result);
/* Extract the callback information */
callback = priv->callback;
arg = priv->arg;
nbytes = priv->xfrd;
priv->callback = NULL;
priv->arg = NULL;
priv->xfrd = 0;
/* Then perform the callback */
if (result < 0)
{
nbytes = (ssize_t)result;
}
callback(arg, nbytes);
}
#endif
/****************************************************************************
* Name: max3421e_out_asynch
*
* Description:
* Initiate the first of a sequence of asynchronous transfers.
*
* Assumptions:
* The SPI is not locked. This function is called only from the ASYNCH
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
#ifdef CONFIG_USBHOST_ASYNCH
static int max3421e_out_asynch(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR uint8_t *buffer, size_t buflen,
usbhost_asynch_t callback, FAR void *arg)
{
int ret;
/* Set up for the transfer BEFORE starting the first transfer */
priv->buffer = buffer;
priv->buflen = buflen;
priv->xfrd = 0;
ret = max3421e_chan_asynchsetup(priv, chan, callback, arg);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_ASYNCHSETUP_FAIL1, -ret);
return ret;
}
/* Set up for the transfer based on the direction and the endpoint type */
max3421e_lock(priv);
ret = max3421e_out_setup(priv, chan);
max3421e_unlock(priv);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_OUTSETUP_FAIL3, -ret);
}
/* And return with the transfer pending */
return ret;
}
#endif
/****************************************************************************
* Name: max3421e_ctrl_sendsetup
*
* Description:
* Send an IN/OUT SETUP packet.
*
* Assumptions:
* The SPI is not locked. This function is called only from the CTRLIN and
* CTRLOUT interfaces and must manage the SPI lock itself. The lock, for
* example, must be relinquished before waiting.
*
****************************************************************************/
static int max3421e_ctrl_sendsetup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR const struct usb_ctrlreq_s *req)
{
clock_t start;
clock_t elapsed;
int ret;
/* Loop while the device reports NAK (and a timeout is not exceeded */
start = clock_systime_ticks();
do
{
/* Send the SETUP packet */
priv->buffer = (FAR uint8_t *)req;
priv->buflen = USB_SIZEOF_CTRLREQ;
priv->inflight = 0;
priv->xfrd = 0;
priv->result = EBUSY;
/* Set up for the wait BEFORE starting the transfer */
ret = max3421e_chan_waitsetup(priv, chan);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN2, 0);
return ret;
}
/* Make sure the peripheral address is correct */
max3421e_lock(priv);
max3421e_putreg(priv, MAX3421E_USBHOST_PERADDR, chan->funcaddr);
/* Write packet into the SUDFIFO. */
max3421e_sndblock(priv, MAX3421E_USBHOST_SUDFIFO, priv->buffer,
priv->buflen);
/* Send the SETUP token (always EP0) */
max3421e_putreg(priv, MAX3421E_USBHOST_HXFR,
USBHOST_HXFR_TOKEN_SETUP);
/* Increment the count of bytes "in-flight" in the SNDFIFO */
priv->inflight = priv->buflen;
/* The MAX3421E waits 18 bit times for the device to respond or time
* out then terminates the transfer by asserting the HXFRDNIRQ and
* updating the HSRLT bits. NOTE: The USB spec says that a
* peripheral must always ACK a SETUP packet.
*/
priv->xfrtype = HXFRDN_SETUP;
max3421e_int_enable(priv, USBHOST_HIRQ_HXFRDNIRQ);
/* Wait for the transfer to complete */
max3421e_unlock(priv);
ret = max3421e_chan_wait(priv, chan);
/* Return on success and for all failures other than EAGAIN. EAGAIN
* means that the device NAKed the SETUP command and that we should
* try a few more times. NOTE: The USB spec says that a peripheral
* must always ACK a SETUP packet.
*/
if (ret != -EAGAIN)
{
/* Output some debug information if the transfer failed */
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_TRANSFER_FAILED2, ret);
}
/* Return the result in any event */
return ret;
}
/* Get the elapsed time (in frames) */
elapsed = clock_systime_ticks() - start;
}
while (elapsed < MAX3421E_SETUP_DELAY);
return -ETIMEDOUT;
}
/****************************************************************************
* Name: max3421e_ctrl_senddata
*
* Description:
* Send data in the data phase of an OUT control transfer. Or send status
* in the status phase of an IN control transfer
*
* Assumptions:
* The SPI is not locked. This function is called only from the CTRLOUT
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
static int max3421e_ctrl_senddata(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR uint8_t *buffer, unsigned int buflen)
{
int ret;
/* Save buffer information */
chan->in = false;
priv->xfrd = 0;
priv->buffer = buffer;
priv->buflen = buflen;
/* The MAX4321E sends fixed DATA0 and DATA1 PID tokens for the various
* stages of a CONTROL transfer, regardless of the setting of the internal
* data toggle.
*/
/* Set up for the wait BEFORE starting the transfer */
ret = max3421e_chan_waitsetup(priv, chan);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN3, 0);
return ret;
}
/* Start the transfer */
max3421e_lock(priv);
max3421e_send_start(priv, chan);
max3421e_unlock(priv);
/* Wait for the transfer to complete and return the result */
return max3421e_chan_wait(priv, chan);
}
/****************************************************************************
* Name: max3421e_ctrl_recvdata
*
* Description:
* Receive data in the data phase of an IN control transfer. Or receive
* status in the status phase of an OUT control transfer
*
* Assumptions:
* The SPI is not locked. This function is called only from the CTRLIN
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
static int max3421e_ctrl_recvdata(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR uint8_t *buffer, unsigned int buflen)
{
int ret;
/* Save buffer information */
chan->in = true;
priv->buffer = buffer;
priv->buflen = buflen;
priv->xfrd = 0;
/* The MAX4321E sends fixed DATA0 and DATA1 PID tokens for the various
* stages of a CONTROL transfer, regardless of the setting of the internal
* data toggle.
*/
/* Set up for the wait BEFORE starting the transfer */
ret = max3421e_chan_waitsetup(priv, chan);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN4, 0);
return ret;
}
/* Start the transfer */
max3421e_lock(priv);
max3421e_recv_start(priv, chan);
max3421e_unlock(priv);
/* Wait for the transfer to complete and return the result */
return max3421e_chan_wait(priv, chan);
}
/****************************************************************************
* Name: max3421e_ctrl_sendstatus
*
* Description:
* Send status to complete the status phase of a CTRLIN transfer.
*
* Assumptions:
* The SPI is not locked. This function is called only from the CTRLIN
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
static int max3421e_ctrl_sendstatus(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
/* Set up the initial state of the transfer */
usbhost_vtrace2(MAX3421E_VTRACE2_SENDSTATUS, chan->chidx, priv->buflen);
priv->result = EBUSY;
priv->inflight = 0;
priv->buflen = 0;
priv->xfrd = 0;
/* Make sure the peripheral address is correct */
max3421e_lock(priv);
max3421e_putreg(priv, MAX3421E_USBHOST_PERADDR, chan->funcaddr);
/* Write the zero byte count to the SNDBC register */
max3421e_putreg(priv, MAX3421E_USBHOST_SNDBC, 0);
/* Send the HS-OUT token */
max3421e_putreg(priv, MAX3421E_USBHOST_HXFR,
USBHOST_HXFR_TOKEN_OUTHS | chan->epno);
/* Enable the HXFRDNIRQ to catch completion of the ZLP. */
priv->xfrtype = HXFRDN_SNDZLP;
max3421e_int_enable(priv, USBHOST_HIRQ_HXFRDNIRQ);
max3421e_unlock(priv);
/* Wait for the transfer to complete and return the result */
return max3421e_chan_wait(priv, chan);
}
/****************************************************************************
* Name: max3421e_ctrl_recvstatus
*
* Description:
* Receive status to complete the status phase of a CTRLOUT transfer.
*
* Assumptions:
* The SPI is not locked. This function is called only from the CTRLOUT
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
static int max3421e_ctrl_recvstatus(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
max3421e_pktdump("Sending", priv->buffer, priv->buflen);
/* Set up the initial state of the transfer */
usbhost_vtrace2(MAX3421E_VTRACE2_RECVSTATUS, chan->chidx, priv->buflen);
priv->result = EBUSY;
priv->inflight = 0;
priv->buflen = 0;
priv->xfrd = 0;
/* Make sure the peripheral address is correct */
max3421e_lock(priv);
max3421e_putreg(priv, MAX3421E_USBHOST_PERADDR, chan->funcaddr);
/* Send the HS-IN token. */
max3421e_putreg(priv, MAX3421E_USBHOST_HXFR,
USBHOST_HXFR_TOKEN_INHS | chan->epno);
/* Enable the RCVFIFO interrupt to handle the completion/continuation
* of transfer. Enable the HXFRDNIRQ to catch NAKs and transfer
* errors.
*/
priv->xfrtype = HXFRDN_RCVFIFO;
max3421e_int_enable(priv, USBHOST_HIRQ_RCVDAVIRQ | USBHOST_HIRQ_HXFRDNIRQ);
max3421e_unlock(priv);
/* Wait for the transfer to complete and return the result */
return max3421e_chan_wait(priv, chan);
}
/****************************************************************************
* Name: max3421e_in_setup
*
* Description:
* Initiate an IN transfer on an bulk, interrupt, or isochronous pipe.
*
****************************************************************************/
static int max3421e_in_setup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
/* Set up for the transfer based on the direction and the endpoint type */
switch (chan->eptype)
{
default:
case USB_EP_ATTR_XFER_CONTROL: /* Control */
{
/* This kind of transfer on control endpoints other than EP0 are
* not currently supported
*/
return -ENOSYS;
}
case USB_EP_ATTR_XFER_ISOC: /* Isochronous */
{
/* Set up the IN DATA0 PID */
usbhost_vtrace2(MAX3421E_VTRACE2_ISOCIN,
chan->chidx, priv->buflen);
chan->toggles = USBHOST_HCTL_RCVTOG0 | USBHOST_HCTL_SNDTOG0;
}
break;
case USB_EP_ATTR_XFER_BULK: /* Bulk */
{
usbhost_vtrace2(MAX3421E_VTRACE2_BULKIN,
chan->chidx, priv->buflen);
}
break;
case USB_EP_ATTR_XFER_INT: /* Interrupt */
{
usbhost_vtrace2(MAX3421E_VTRACE2_INTRIN,
chan->chidx, priv->buflen);
}
break;
}
/* Start the transfer. */
max3421e_recv_start(priv, chan);
return OK;
}
/****************************************************************************
* Name: max3421e_out_setup
*
* Description:
* Initiate an OUT transfer on an bulk, interrupt, or isochronous pipe.
*
****************************************************************************/
static int max3421e_out_setup(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
/* Set up for the transfer based on the direction and the endpoint type */
switch (chan->eptype)
{
default:
case USB_EP_ATTR_XFER_CONTROL: /* Control */
{
/* This kind of transfer on control endpoints other than EP0 are
* not currently supported
*/
return -ENOSYS;
}
case USB_EP_ATTR_XFER_ISOC: /* Isochronous */
{
/* Set up the IN DATA0 PID */
usbhost_vtrace2(MAX3421E_VTRACE2_ISOCOUT,
chan->chidx, priv->buflen);
chan->toggles = USBHOST_HCTL_RCVTOG0 | USBHOST_HCTL_SNDTOG0;
}
break;
case USB_EP_ATTR_XFER_BULK: /* Bulk */
{
usbhost_vtrace2(MAX3421E_VTRACE2_BULKOUT,
chan->chidx, priv->buflen);
}
break;
case USB_EP_ATTR_XFER_INT: /* Interrupt */
{
usbhost_vtrace2(MAX3421E_VTRACE2_INTROUT,
chan->chidx, priv->buflen);
}
break;
}
/* Start the transfer */
max3421e_send_start(priv, chan);
return OK;
}
/****************************************************************************
* Name: max3421e_get_rcvfifo
*
* Description:
* Copy data from the RCVFIFO to the user-provided buffer.
*
* The RCVFIFO is double buffered. If another packet is available in the
* other buffer, the MAX3421E will immediately re-assert RCVDAVIRQ and we
* will catch that by interrupt handling logic.
*
* Assumptions:
* The SPI bus is locked.
*
****************************************************************************/
static uint8_t max3421e_get_rcvfifo(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
uint16_t remaining;
uint8_t navail;
uint8_t nrcvd;
/* Get the number of bytes available in the RCVFIFO */
navail = max3421e_getreg(priv, MAX3421E_USBHOST_RCVBC);
/* Get the number that will fit into the user-provided buffer */
remaining = priv->buflen - priv->xfrd;
if (navail > remaining)
{
nrcvd = remaining;
}
else
{
nrcvd = navail;
}
/* Read the received data into the user-buffer. */
max3421e_recvblock(priv, MAX3421E_USBHOST_RCVFIFO,
priv->buffer + priv->xfrd, nrcvd);
/* Update the number of bytes transferred */
priv->xfrd += nrcvd;
/* Discard any byte remaining in the RCVFIFO */
/* REVISIT: Is this necessary? Or the MAX3421E automatically discard any
* unread data?
*/
#if 0
if (nrcvd < navail)
{
max3421e_discard()
}
#endif
return nrcvd;
}
/****************************************************************************
* Name: max3421e_recv_restart
*
* Description:
* Start/Re-start the transfer on the selected IN or OUT channel.
*
****************************************************************************/
static void max3421e_recv_restart(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
/* Send the IN token. */
max3421e_putreg(priv, MAX3421E_USBHOST_HXFR,
USBHOST_HXFR_TOKEN_IN | chan->epno);
/* Enable the RCVFIFO interrupt to handle the completion/continuation
* of transfer. Enable the HXFRDNIRQ to catch NAKs and transfer
* errors.
*/
priv->xfrtype = HXFRDN_RCVFIFO;
max3421e_int_enable(priv, USBHOST_HIRQ_RCVDAVIRQ | USBHOST_HIRQ_HXFRDNIRQ);
}
/****************************************************************************
* Name: max3421e_recv_continue
*
* Description:
* Continue the receive operation started by max3421e_recv_start(). This
* function is called from the interrupt handler worker when an interrupt
* indicates that new, incoming data is available in the RCVFIFO (RCVDAV)
*
* When the RCBBAV interrupt occurred, max3421e_irqwork() disabled that
* interrupt and called this function in order to handle the receipt of
* data
*
* Assumptions:
* The SPI bus is locked.
* The RCVDAV interrupt has been disabled.
*
****************************************************************************/
static void max3421e_recv_continue(FAR struct max3421e_usbhost_s *priv)
{
FAR struct max3421e_chan_s *chan;
uint8_t nrcvd;
int result;
DEBUGASSERT(priv != NULL && priv->waiter != NULL);
chan = priv->waiter;
/* Check the result of a transfer */
result = max3421e_transfer_status(priv);
if (result < 0)
{
/* Terminate the transfer on any error. */
max3421e_transfer_terminate(priv, chan, result);
return;
}
/* Transfer the data from the RCVFIFO to the user buffer */
nrcvd = max3421e_get_rcvfifo(priv, chan);
/* A partial or zero-length packet is an indication that the transfer
* completed early. Terminate the transfer in those cases OR if all
* of the requested data has been received
*/
if (nrcvd < chan->maxpacket || priv->xfrd >= priv->buflen)
{
max3421e_transfer_terminate(priv, chan, OK);
}
/* If not all of the data has been received, then setup to receive
* another packet.
*/
else
{
max3421e_recv_restart(priv, chan);
}
}
/****************************************************************************
* Name: max3421e_recv_start
*
* Description:
* Start at transfer on the selected IN or OUT channel.
*
* Assumptions:
* The caller has the SPI locked.
*
****************************************************************************/
static void max3421e_recv_start(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
max3421e_pktdump("Sending", priv->buffer, priv->buflen);
/* Set up the initial state of the transfer */
usbhost_vtrace2(MAX3421E_VTRACE2_STARTTRANSFER2,
chan->chidx, priv->buflen);
priv->result = EBUSY;
priv->inflight = 0;
priv->xfrd = 0;
/* Make sure the peripheral address is correct */
max3421e_putreg(priv, MAX3421E_USBHOST_PERADDR, chan->funcaddr);
/* Start the transfer. */
max3421e_recv_restart(priv, chan);
}
/****************************************************************************
* Name: max3421e_in_transfer
*
* Description:
* Transfer 'buflen' bytes into 'buffer' from an IN channel.
*
* Assumptions:
* The SPI is not locked. This function is called only from the TRANSFER
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
static ssize_t max3421e_in_transfer(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR uint8_t *buffer, size_t buflen)
{
clock_t start;
ssize_t xfrd;
int ret;
/* Loop until the transfer completes (i.e., buflen is decremented to zero)
* or a fatal error occurs any error other than a simple NAK. NAK would
* simply indicate the end of the transfer (short-transfer).
*/
priv->buffer = buffer;
priv->buflen = buflen;
priv->xfrd = 0;
xfrd = 0;
start = clock_systime_ticks();
while (priv->xfrd < priv->buflen)
{
/* Set up for the wait BEFORE starting the transfer */
ret = max3421e_chan_waitsetup(priv, chan);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN5, 0);
return (ssize_t)ret;
}
/* Set up for the transfer based on the direction and the endpoint */
max3421e_lock(priv);
ret = max3421e_in_setup(priv, chan);
max3421e_unlock(priv);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_INSETUP_FAIL1, -ret);
return (ssize_t)ret;
}
/* Wait for the transfer to complete and get the result */
ret = max3421e_chan_wait(priv, chan);
/* EAGAIN indicates that the device NAKed the transfer. */
if (ret < 0)
{
/* The transfer failed. If we received a NAK, return all data
* buffered so far (if any).
*/
if (ret == -EAGAIN)
{
/* Was data buffered prior to the NAK? */
if (xfrd > 0)
{
/* Yes, return the amount of data received.
*
* REVISIT: This behavior is clearly correct for CDC/ACM
* bulk transfers and HID interrupt transfers. But I am
* not so certain for MSC bulk transfers which, I think,
* could have NAKed packets in the middle of a transfer.
*/
return xfrd;
}
else
{
useconds_t delay;
/* Get the elapsed time. Has the timeout elapsed?
* if not then try again.
*/
clock_t elapsed = clock_systime_ticks() - start;
if (elapsed >= MAX3421E_DATANAK_DELAY)
{
/* Timeout out... break out returning the NAK as
* as a failure.
*/
return (ssize_t)ret;
}
/* Wait a bit before retrying after a NAK. */
if (chan->eptype == USB_EP_ATTR_XFER_INT)
{
/* For interrupt (and isochronous) endpoints, the
* polling rate is determined by the bInterval field
* of the endpoint descriptor (in units of frames
* which we treat as milliseconds here).
*/
if (chan->interval > 0)
{
/* Convert the delay to units of microseconds */
delay = (useconds_t)chan->interval * 1000;
}
else
{
/* Out of range! For interrupt endpoints, the valid
* range is 1-255 frames. Assume one frame.
*/
delay = 1000;
}
}
else
{
/* For Isochronous endpoints, bInterval must be 1.
* Bulk endpoints do not have a polling interval.
* Rather, the should wait until data is received.
*
* REVISIT: For bulk endpoints this 1 msec delay is
* only intended to give the CPU a break from the bulk
* EP tight polling loop. But are there performance
* issues?
*/
delay = 1000;
}
/* Wait for the next polling interval. For interrupt and
* isochronous endpoints, this is necessary to assure the
* polling interval. It is used in other cases only to
* prevent the polling from consuming too much CPU
* bandwidth.
*
* Small delays could require more resolution than is
* provided by the system timer. For example, if the
* system timer resolution is 10MS, then nxsig_usleep(1000)
* will actually request a delay 20MS (due to both
* quantization and rounding).
*
* REVISIT: So which is better? To ignore tiny delays and
* hog the system bandwidth? Or to wait for an excessive
* amount and destroy system throughput?
*/
if (delay > CONFIG_USEC_PER_TICK)
{
nxsig_usleep(delay - CONFIG_USEC_PER_TICK);
}
}
}
else
{
/* Some unexpected, fatal error occurred. */
usbhost_trace1(MAX3421E_TRACE1_TRANSFER_FAILED3, -ret);
/* Break out and return the error */
return (ssize_t)ret;
}
}
else
{
/* Successfully received another chunk of data... add that to the
* running total. Then continue reading until we read 'buflen'
* bytes of data or until the devices NAKs (implying a short
* packet).
*/
xfrd += priv->xfrd;
}
}
return xfrd;
}
/****************************************************************************
* Name: max3421e_in_next
*
* Description:
* Initiate the next of a sequence of asynchronous transfers.
*
* Assumptions:
* This function is always called from an interrupt handler
*
****************************************************************************/
#ifdef CONFIG_USBHOST_ASYNCH
static void max3421e_in_next(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan)
{
usbhost_asynch_t callback;
FAR void *arg;
ssize_t nbytes;
int result;
int ret;
/* Is the full transfer complete? Did the last chunk transfer OK? */
result = -(int)priv->result;
if (priv->xfrd < priv->buflen && result == OK)
{
/* Yes.. Set up for the next transfer based on the direction and the
* endpoint type
*/
ret = max3421e_in_setup(priv, chan);
if (ret >= 0)
{
return;
}
usbhost_trace1(MAX3421E_TRACE1_INSETUP_FAIL2, -ret);
result = ret;
}
/* The transfer is complete, with or without an error */
usbhost_vtrace2(MAX3421E_VTRACE2_XFRCOMPLETE,
(unsigned int)ep, buflen);
/* Extract the callback information */
callback = priv->callback;
arg = priv->arg;
nbytes = priv->xfrd;
priv->callback = NULL;
priv->arg = NULL;
priv->xfrd = 0;
/* Then perform the callback */
if (result < 0)
{
nbytes = (ssize_t)result;
}
callback(arg, nbytes);
}
#endif
/****************************************************************************
* Name: max3421e_in_asynch
*
* Description:
* Initiate the first of a sequence of asynchronous transfers.
*
* Assumptions:
* The SPI is not locked. This function is called only from the ASYNCH
* interface and must manage the SPI lock itself. The lock, for example,
* must be relinquished before waiting.
*
****************************************************************************/
#ifdef CONFIG_USBHOST_ASYNCH
static int max3421e_in_asynch(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_chan_s *chan,
FAR uint8_t *buffer, size_t buflen,
usbhost_asynch_t callback, FAR void *arg)
{
int ret;
/* Set up for the transfer BEFORE starting the first transfer */
priv->buffer = buffer;
priv->buflen = buflen;
priv->xfrd = 0;
ret = max3421e_chan_asynchsetup(priv, chan, callback, arg);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_ASYNCHSETUP_FAIL2, -ret);
return ret;
}
/* Set up for the transfer based on the direction and the endpoint type */
max3421e_lock(priv);
ret = max3421e_in_setup(priv, chan);
max3421e_unlock(priv);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_INSETUP_FAIL3, -ret);
}
/* And return with the transfer pending */
return ret;
}
#endif
/****************************************************************************
* Name: max3421e_connect_event
*
* Description:
* Handle a connection event.
*
****************************************************************************/
static void max3421e_connect_event(FAR struct max3421e_usbhost_s *priv)
{
/* Were we previously disconnected? */
if (!priv->connected)
{
/* Yes.. then now we are connected */
usbhost_vtrace1(MAX3421E_VTRACE1_CONNECTED1, 0);
priv->connected = true;
priv->change = true;
DEBUGASSERT(priv->smstate == SMSTATE_DETACHED);
/* Notify any waiters */
priv->smstate = SMSTATE_ATTACHED;
if (priv->pscwait)
{
nxsem_post(&priv->pscsem);
priv->pscwait = false;
}
}
}
/****************************************************************************
* Name: max3421e_disconnect_event
*
* Description:
* Handle a disconnection event.
*
****************************************************************************/
static void max3421e_disconnect_event(FAR struct max3421e_usbhost_s *priv)
{
/* Were we previously connected? */
if (priv->connected)
{
/* Yes.. then we no longer connected */
usbhost_vtrace1(MAX3421E_VTRACE1_DISCONNECTED1, 0);
/* Are we bound to a class driver? */
if (priv->rhport.hport.devclass)
{
/* Yes.. Disconnect the class driver */
CLASS_DISCONNECTED(priv->rhport.hport.devclass);
priv->rhport.hport.devclass = NULL;
}
/* Re-Initialize Host for new Enumeration */
priv->smstate = SMSTATE_DETACHED;
priv->connected = false;
priv->change = true;
priv->rhport.hport.speed = USB_SPEED_FULL;
priv->rhport.hport.funcaddr = 0;
/* Notify any waiters that there is a change in the connection state */
if (priv->pscwait)
{
nxsem_post(&priv->pscsem);
priv->pscwait = false;
}
}
}
/****************************************************************************
* Name: max3421e_connected
*
* Description:
* USB host port interrupt handler
*
****************************************************************************/
static int max3421e_connected(FAR struct max3421e_usbhost_s *priv)
{
int ret;
/* Stop SOF generation and reset the bus */
max3421e_busreset(priv);
nxsig_sleep(1);
/* Check for low- or full-speed and restart SOF generation. */
ret = max3421e_startsof(priv);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN7, -ret);
return ret;
}
usbhost_vtrace1(MAX3421E_VTRACE1_CONNECTED3, 0);
/* Were we previously disconnected? */
max3421e_connect_event(priv);
return OK;
}
/****************************************************************************
* Name: max3421e_disconnected
*
* Description:
* USB disconnect detected interrupt handler
*
****************************************************************************/
static void max3421e_disconnected(FAR struct max3421e_usbhost_s *priv)
{
usbhost_vtrace1(MAX3421E_VTRACE1_DISCONNECTED2, 0);
/* Disable the SOF generator */
max3421e_modifyreg(priv, MAX3421E_USBHOST_MODE, USBHOST_MODE_SOFKAENAB, 0);
/* Handle the disconnection event */
max3421e_disconnect_event(priv);
}
/****************************************************************************
* Name: max3421e_irqwork
*
* Description:
* MAX3421E interrupt worker. Perform MAX3421E interrupt processing on the
* high priority work queue thread. Interrupts were disabled by the
* interrupt handler when the interrupt was received. This worker must
* re-enable MAX3421E interrupts when interrupt processing is complete.
*
****************************************************************************/
static void max3421e_irqwork(FAR void *arg)
{
FAR struct max3421e_usbhost_s *priv;
FAR const struct max3421e_lowerhalf_s *lower;
uint8_t pending;
int ret;
priv = (FAR struct max3421e_usbhost_s *)arg;
DEBUGASSERT(priv != NULL && priv->lower != NULL);
lower = (FAR const struct max3421e_lowerhalf_s *)priv->lower;
/* Get exclusive access to the SPI bus */
max3421e_lock(priv);
/* Loop while there are pending interrupts to process. This loop may save
* a little interrupt handling overhead.
*/
for (; ; )
{
/* Get the unmasked bits in the GINT status */
pending = max3421e_int_status(priv);
priv->lower->acknowledge(lower);
/* Break out of the loop when there are no pending interrupts. */
if (pending == 0)
{
break;
}
/* Possibilities:
*
* HXFRDNIRQ - Host Transfer Done Interrupt
* FRAMEIRQ - Frame Generator Interrupt
* CONNIRQ - Peripheral Connect/Disconnect Interrupt
* SUSDNIRQ - Suspend operation Done
* SNDBAVIRQ - SNDFIFO is available
* RCVDAVIRQ - RCVFIFO data available
* RSMREQIRQ - Remote Wakeup Interrupt
* BUSEVENTIRQ - Bus Reset or Bus Resume Interrupt
*
* Only CONNIRQ handled here.
*/
/* HXFRDNIRQ: Host transfer done interrupt */
if ((pending & USBHOST_HIRQ_HXFRDNIRQ) != 0 &&
(pending & USBHOST_HIRQ_SNDBAVIRQ) == 0 &&
(pending & USBHOST_HIRQ_RCVDAVIRQ) == 0)
{
int result;
/* Disable further SNDBAV (or HXFRDN) interrupts */
max3421e_int_disable(priv, USBHOST_HIRQ_HXFRDNIRQ);
/* Clear the pending HXFRDN interrupt */
max3421e_int_clear(priv, USBHOST_HIRQ_HXFRDNIRQ);
/* Check transfer status and terminate the transfer if any error
* occurred.
*/
result = max3421e_transfer_status(priv);
if (result < 0 || priv->xfrtype == HXFRDN_SETUP ||
priv->xfrtype == HXFRDN_SNDZLP)
{
FAR struct max3421e_chan_s *chan = priv->waiter;
DEBUGASSERT(chan != NULL);
max3421e_transfer_terminate(priv, chan, result);
}
}
/* CONNIRQ: Has a peripheral been connected or disconnected */
if ((pending & USBHOST_HIRQ_CONNIRQ) != 0)
{
/* Clear the pending CONNIRQ interrupt */
max3421e_int_clear(priv, USBHOST_HIRQ_CONNIRQ);
/* Check if a peripheral device has been connected */
ret = max3421e_connected(priv);
if (ret < 0)
{
/* No.. then a device must have been disconnected. */
max3421e_disconnected(priv);
}
}
/* SNDBAV: The SNDFIFO is available */
else if ((pending & USBHOST_HIRQ_SNDBAVIRQ) != 0)
{
/* Disable further SNDBAV (or HXFRDN) interrupts */
max3421e_int_disable(priv, USBHOST_HIRQ_SNDBAVIRQ |
USBHOST_HIRQ_HXFRDNIRQ);
/* Clear the pending SNDBAV interrupt */
max3421e_int_clear(priv, USBHOST_HIRQ_SNDBAVIRQ);
/* Finish long transfer, possibly re-enabling the SNDBAV
* interrupt (see max3421e_send_start)
*/
max3421e_send_continue(priv);
}
/* RCVDAVIRQ: RCVFIFO data available */
else if ((pending & USBHOST_HIRQ_RCVDAVIRQ) != 0)
{
/* Disable further RCVDAV (or HXFRDN) interrupts */
max3421e_int_disable(priv, USBHOST_HIRQ_RCVDAVIRQ |
USBHOST_HIRQ_HXFRDNIRQ);
/* Clear the pending RCVDAV interrupt. The RCVFIFO is double
* buffered. If another packet is available in the other buffer,
* the MAX3421E will immediately re-assert RCVDAVIRQ and we
* will catch that the next time through this loop.
*/
max3421e_int_clear(priv, USBHOST_HIRQ_RCVDAVIRQ);
/* Handle the receipt of data */
max3421e_recv_continue(priv);
}
}
/* Re-enable interrupts */
lower->enable(lower, true);
max3421e_unlock(priv);
}
/****************************************************************************
* Name: max3421e_interrupt
*
* Description:
* MAX3421E interrupt handler. This interrupt handler simply defers
* interrupt processing to the high priority work queue thread. This is
* necessary because we cannot perform interrupt/DMA driven SPI accesses
* from an interrupt handler.
*
****************************************************************************/
static int max3421e_interrupt(int irq, FAR void *context, FAR void *arg)
{
FAR struct max3421e_usbhost_s *priv;
FAR const struct max3421e_lowerhalf_s *lower;
priv = (FAR struct max3421e_usbhost_s *)arg;
DEBUGASSERT(priv != NULL && priv->lower != NULL);
lower = (FAR const struct max3421e_lowerhalf_s *)priv->lower;
/* Disable further interrupts until work associated with this interrupt
* has been processed.
*/
lower->enable(lower, false);
/* And defer interrupt processing to the high priority work queue thread */
work_queue(LPWORK, &priv->irqwork, max3421e_irqwork, priv, 0);
return OK;
}
/****************************************************************************
* Name: max3421e_int_enable, max3421e_int_disable, max3421e_int_status, and
* max3421e_int_wait
*
* Description:
* Respectively enable, disable, or get status of the USB host interrupt
* (HIRQ) and a mask of enabled interrupts.
*
* Input Parameters:
* priv - Private state data
* irqset - IRQ bits to be set (max3421e_int_status only)
*
* Returned Value:
* The current unmasks interrupt status (max3421e_int_status only)
*
****************************************************************************/
/* Enable a set of interrupts */
static inline void max3421e_int_enable(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset)
{
priv->irqset |= irqset;
max3421e_putreg(priv, MAX3421E_USBHOST_HIEN, priv->irqset);
}
/* Disable a set of interrupts */
static inline void max3421e_int_disable(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset)
{
priv->irqset &= ~irqset;
max3421e_putreg(priv, MAX3421E_USBHOST_HIEN, priv->irqset);
}
/* Get the set of pending interrupts */
static inline uint8_t
max3421e_int_status(FAR struct max3421e_usbhost_s *priv)
{
return max3421e_getreg(priv, MAX3421E_USBHOST_HIRQ) & priv->irqset;
}
/* Clear a set of pending interrupts */
static inline void max3421e_int_clear(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset)
{
max3421e_putreg(priv, MAX3421E_USBHOST_HIRQ, irqset);
}
/* Wait until any interrupt from a set of interrupts occurs */
static void max3421e_int_wait(FAR struct max3421e_usbhost_s *priv,
uint8_t irqset, unsigned int usec)
{
uint8_t regval;
do
{
regval = max3421e_getreg(priv, MAX3421E_USBHOST_HIRQ);
regval &= irqset;
if (regval == 0 && usec > 0)
{
nxsig_usleep(usec);
}
}
while (regval == 0);
}
/****************************************************************************
* Name: max3421e_wait
*
* Description:
* Wait for a device to be connected or disconnected to/from a hub port.
*
* Input Parameters:
* conn - The USB host connection instance obtained as a parameter from
* the call to the USB driver initialization logic.
* hport - The location to return the hub port descriptor that detected the
* connection related event.
*
* Returned Value:
* Zero (OK) is returned on success when a device is connected or
* disconnected. This function will not return until either (1) a device is
* connected or disconnect to/from any hub port or until (2) some failure
* occurs. On a failure, a negated errno value is returned indicating the
* nature of the failure
*
* Assumptions:
* - Called from a single thread so no mutual exclusion is required.
* - Never called from an interrupt handler.
*
****************************************************************************/
static int max3421e_wait(FAR struct usbhost_connection_s *conn,
FAR struct usbhost_hubport_s **hport)
{
FAR struct max3421e_connection_s *maxconn;
FAR struct max3421e_usbhost_s *priv;
struct usbhost_hubport_s *connport;
int ret;
maxconn = (FAR struct max3421e_connection_s *)conn;
DEBUGASSERT(maxconn != NULL && maxconn->priv != NULL);
priv = maxconn->priv;
/* Loop until a change in connection state is detected */
for (; ; )
{
/* We must have exclusive access to USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Is there a change in the connection state of the single root hub
* port?
*/
if (priv->change)
{
connport = &priv->rhport.hport;
/* Yes. Remember the new state */
connport->connected = priv->connected;
priv->change = false;
/* And return the root hub port */
*hport = connport;
usbhost_vtrace1(MAX3421E_VTRACE1_CONNECTED2, connport->connected);
nxrmutex_unlock(&priv->lock);
return OK;
}
#ifdef CONFIG_USBHOST_HUB
/* Is a device connected to an external hub? */
if (priv->hport)
{
/* Yes.. return the external hub port */
connport = (struct usbhost_hubport_s *)priv->hport;
priv->hport = NULL;
*hport = connport;
usbhost_vtrace1(MAX3421E_VTRACE1_HUB_CONNECTED,
connport->connected);
nxrmutex_unlock(&priv->lock);
return OK;
}
#endif
/* Wait for the next connection event */
priv->pscwait = true;
nxrmutex_unlock(&priv->lock);
ret = nxsem_wait_uninterruptible(&priv->pscsem);
if (ret < 0)
{
return ret;
}
}
}
/****************************************************************************
* Name: max3421e_getspeed
*
* Description:
* Get the speed of the connected device.
*
* Input Parameters:
* priv - Driver private state structure
* conn - The USB host connection instance obtained as a parameter from
* the call to the USB driver initialization logic.
* hport - The descriptor of the hub port that has the newly connected
* device.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* The caller has the SPI bus locked.
*
****************************************************************************/
static int max3421e_getspeed(FAR struct max3421e_usbhost_s *priv,
FAR struct usbhost_connection_s *conn,
FAR struct usbhost_hubport_s *hport)
{
int ret;
DEBUGASSERT(conn != NULL && hport != NULL && hport->port == 0);
/* Are we connected to a device? The caller should have called the wait()
* method first to be assured that a device is connected.
*/
if (!priv->connected)
{
/* No, return an error */
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN6, 0);
return -ENODEV;
}
DEBUGASSERT(priv->smstate == SMSTATE_ATTACHED);
/* USB 2.0 spec says at least 50ms delay before port reset. We wait
* 100ms.
*/
nxsig_usleep(100 * 1000);
/* Make sure we are still connected */
if (!priv->connected)
{
/* No, return an error */
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN6, 0);
nxrmutex_unlock(&priv->lock);
return -ENODEV;
}
/* Stop SOF generation and reset the host port */
max3421e_busreset(priv);
nxsig_sleep(1);
/* Get the current device speed */
ret = max3421e_startsof(priv);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_DEVDISCONN8, -ret);
}
return ret;
}
/****************************************************************************
* Name: max3421e_enumerate
*
* Description:
* Enumerate the connected device. As part of this enumeration process,
* the driver will (1) get the device's configuration descriptor, (2)
* extract the class ID info from the configuration descriptor, (3) call
* usbhost_findclass() to find the class that supports this device, (4)
* call the create() method on the struct usbhost_registry_s interface
* to get a class instance, and finally (5) call the connect() method
* of the struct usbhost_class_s interface. After that, the class is in
* charge of the sequence of operations.
*
* Input Parameters:
* conn - The USB host connection instance obtained as a parameter from
* the call to the USB driver initialization logic.
* hport - The descriptor of the hub port that has the newly connected
* device.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* This function will *not* be called from an interrupt handler.
*
****************************************************************************/
static int max3421e_enumerate(FAR struct usbhost_connection_s *conn,
FAR struct usbhost_hubport_s *hport)
{
FAR struct max3421e_connection_s *maxconn;
FAR struct max3421e_usbhost_s *priv;
int ret;
maxconn = (FAR struct max3421e_connection_s *)conn;
DEBUGASSERT(maxconn != NULL && maxconn->priv != NULL);
priv = maxconn->priv;
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* If this is a connection on the root hub, then we need to go to
* little more effort to get the device speed. If it is a connection
* on an external hub, then we already have that information.
*/
max3421e_lock(priv);
#warning REVISIT: Isn't this already done?
#ifdef CONFIG_USBHOST_HUB
if (ROOTHUB(hport))
#endif
{
ret = max3421e_getspeed(priv, conn, hport);
if (ret < 0)
{
nxrmutex_unlock(&priv->lock);
return ret;
}
}
/* Set enumeration data toggles */
max3421e_modifyreg(priv, MAX3421E_USBHOST_HCTL,
USBHOST_HCTL_TOGGLES_MASK,
USBHOST_HCTL_RCVTOG1 | USBHOST_HCTL_SNDTOG1);
max3421e_unlock(priv);
/* Then let the common usbhost_enumerate do the real enumeration. */
usbhost_vtrace1(MAX3421E_VTRACE1_ENUMERATE, 0);
priv->smstate = SMSTATE_ENUM;
ret = usbhost_enumerate(hport, &hport->devclass);
/* The enumeration may fail either because of some HCD interfaces failure
* or because the device class is not supported. In either case, we just
* need to perform the disconnection operation and make ready for a new
* enumeration.
*/
if (ret < 0)
{
/* Return to the disconnected state */
usbhost_trace1(MAX3421E_TRACE1_ENUMERATE_FAIL, -ret);
max3421e_disconnect_event(priv);
}
/* Set post-enumeration data toggles (assuming success) */
max3421e_lock(priv);
max3421e_modifyreg(priv, MAX3421E_USBHOST_HCTL,
USBHOST_HCTL_TOGGLES_MASK,
USBHOST_HCTL_RCVTOG0 | USBHOST_HCTL_SNDTOG0);
max3421e_unlock(priv);
nxrmutex_unlock(&priv->lock);
return ret;
}
/****************************************************************************
* Name: max3421e_ep0configure
*
* Description:
* Configure endpoint 0. This method is normally used internally by the
* enumerate() method but is made available at the interface to support an
* external implementation of the enumeration logic.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter
* from the call to the class create() method.
* ep0 - The (opaque) EP0 endpoint instance
* funcaddr - The USB address of the function containing the endpoint
* that EP0 controls
* speed - The speed of the port USB_SPEED_LOW or _FULL
* maxpacketsize - The maximum number of bytes that can be sent to or
* received from the endpoint in a single data packet
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* This function will *not* be called from an interrupt handler.
*
****************************************************************************/
static int max3421e_ep0configure(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep0,
uint8_t funcaddr, uint8_t speed,
uint16_t maxpacketsize)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
FAR struct max3421e_chan_s *chan;
int ret;
DEBUGASSERT(drvr != NULL && funcaddr < 128 && maxpacketsize <= 64);
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Configure the EP0 channel */
chan = &priv->chan[(intptr_t)ep0];
chan->funcaddr = funcaddr;
chan->speed = speed;
chan->maxpacket = maxpacketsize;
chan->toggles = USBHOST_HCTL_RCVTOG0 | USBHOST_HCTL_SNDTOG0;
nxrmutex_unlock(&priv->lock);
return OK;
}
/****************************************************************************
* Name: max3421e_epalloc
*
* Description:
* Allocate and configure one endpoint.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* epdesc - Describes the endpoint to be allocated.
* ep - A memory location provided by the caller in which to receive
* the allocated endpoint descriptor.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* This function will *not* be called from an interrupt handler.
*
****************************************************************************/
static int max3421e_epalloc(FAR struct usbhost_driver_s *drvr,
FAR const struct usbhost_epdesc_s *epdesc,
FAR usbhost_ep_t *ep)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
struct usbhost_hubport_s *hport;
FAR struct max3421e_chan_s *chan;
int chidx;
int ret;
/* Sanity check. NOTE that this method should only be called if a device
* is connected (because we need a valid low speed indication).
*/
DEBUGASSERT(drvr != 0 && epdesc != NULL && ep != NULL);
hport = epdesc->hport;
DEBUGASSERT(hport != NULL);
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Allocate a host channel for the endpoint */
chidx = max3421e_chan_alloc(priv);
if (chidx < 0)
{
usbhost_trace1(MAX3421E_TRACE1_CHANALLOC_FAIL, -chidx);
nxrmutex_unlock(&priv->lock);
return chidx;
}
/* Decode the endpoint descriptor to initialize the channel data
* structures. Note: Here we depend on the fact that the endpoint point
* type is encoded in the same way in the endpoint descriptor as it is in
* the OTG HS hardware.
*/
chan = &priv->chan[chidx];
chan->epno = epdesc->addr & USB_EPNO_MASK;
chan->in = epdesc->in;
chan->eptype = epdesc->xfrtype;
chan->funcaddr = hport->funcaddr;
chan->speed = hport->speed;
chan->interval = epdesc->interval;
chan->maxpacket = epdesc->mxpacketsize;
chan->toggles = USBHOST_HCTL_RCVTOG0 | USBHOST_HCTL_SNDTOG0;
/* Return the endpoint number as the endpoint "handle" */
*ep = (usbhost_ep_t)chidx;
nxrmutex_unlock(&priv->lock);
return OK;
}
/****************************************************************************
* Name: max3421e_epfree
*
* Description:
* Free and endpoint previously allocated by DRVR_EPALLOC.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* ep - The endpoint to be freed.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* This function will *not* be called from an interrupt handler.
*
****************************************************************************/
static int max3421e_epfree(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
int ret;
DEBUGASSERT(priv);
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret >= 0)
{
/* Halt the channel and mark the channel available */
max3421e_chan_free(priv, (intptr_t)ep);
nxrmutex_unlock(&priv->lock);
}
return ret;
}
/****************************************************************************
* Name: max3421e_alloc
*
* Description:
* Some hardware supports special memory in which request and descriptor
* data can be accessed more efficiently. This method provides a
* mechanism to allocate the request/descriptor memory. If the underlying
* hardware does not support such "special" memory, this functions may
* simply map to kmm_malloc.
*
* This interface was optimized under a particular assumption. It was
* assumed that the driver maintains a pool of small, pre-allocated
* buffers for descriptor traffic. NOTE that size is not an input, but
* an output: The size of the pre-allocated buffer is returned.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* buffer - The address of a memory location provided by the caller in
* which to return the allocated buffer memory address.
* maxlen - The address of a memory location provided by the caller in
* which to return the maximum size of the allocated buffer
* memory.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* - Called from a single thread so no mutual exclusion is required.
* - Never called from an interrupt handler.
*
****************************************************************************/
static int max3421e_alloc(FAR struct usbhost_driver_s *drvr,
FAR uint8_t **buffer, FAR size_t *maxlen)
{
FAR uint8_t *alloc;
DEBUGASSERT(drvr && buffer && maxlen);
/* There is no special memory requirement for the MAX3421E. */
alloc = (FAR uint8_t *)kmm_malloc(CONFIG_MAX3421E_DESCSIZE);
if (!alloc)
{
return -ENOMEM;
}
/* Return the allocated address and size of the descriptor buffer */
*buffer = alloc;
*maxlen = CONFIG_MAX3421E_DESCSIZE;
return OK;
}
/****************************************************************************
* Name: max3421e_free
*
* Description:
* Some hardware supports special memory in which request and descriptor
* data can be accessed more efficiently. This method provides a
* mechanism to free that request/descriptor memory. If the underlying
* hardware does not support such "special" memory, this functions may
* simply map to kmm_free().
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* buffer - The address of the allocated buffer memory to be freed.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* - Never called from an interrupt handler.
*
****************************************************************************/
static int max3421e_free(FAR struct usbhost_driver_s *drvr,
FAR uint8_t *buffer)
{
/* There is no special memory requirement */
DEBUGASSERT(drvr && buffer);
kmm_free(buffer);
return OK;
}
/****************************************************************************
* Name: max3421e_ioalloc
*
* Description:
* Some hardware supports special memory in which larger IO buffers can
* be accessed more efficiently. This method provides a mechanism to
* allocate the request/descriptor memory. If the underlying hardware
* does not support such "special" memory, this functions may simply map
* to kmm_malloc.
*
* This interface differs from DRVR_ALLOC in that the buffers are
* variable-sized.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* buffer - The address of a memory location provided by the caller in
* which to return the allocated buffer memory address.
* buflen - The size of the buffer required.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* This function will *not* be called from an interrupt handler.
*
****************************************************************************/
static int max3421e_ioalloc(FAR struct usbhost_driver_s *drvr,
FAR uint8_t **buffer, size_t buflen)
{
FAR uint8_t *alloc;
DEBUGASSERT(drvr && buffer && buflen > 0);
/* There is no special memory requirement */
alloc = (FAR uint8_t *)kmm_malloc(buflen);
if (!alloc)
{
return -ENOMEM;
}
/* Return the allocated buffer */
*buffer = alloc;
return OK;
}
/****************************************************************************
* Name: max3421e_iofree
*
* Description:
* Some hardware supports special memory in which IO data can be accessed
* more efficiently. This method provides a mechanism to free that IO
* buffer memory. If the underlying hardware does not support such
* "special" memory, this functions may simply map to kmm_free().
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* buffer - The address of the allocated buffer memory to be freed.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* This function will *not* be called from an interrupt handler.
*
****************************************************************************/
static int max3421e_iofree(FAR struct usbhost_driver_s *drvr,
FAR uint8_t *buffer)
{
/* There is no special memory requirement */
DEBUGASSERT(drvr && buffer);
kmm_free(buffer);
return OK;
}
/****************************************************************************
* Name: max3421e_ctrlin and max3421e_ctrlout
*
* Description:
* Process a IN or OUT request on the control endpoint. These methods
* will enqueue the request and wait for it to complete. Only one
* transfer may be queued; Neither these methods nor the transfer() method
* can be called again until the control transfer functions returns.
*
* These are blocking methods; these functions will not return until the
* control transfer has completed.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from
* the call to the class create() method.
* ep0 - The control endpoint to send/receive the control request.
* req - Describes the request to be sent. This request must lie in
* memory created by DRVR_ALLOC.
* buffer - A buffer used for sending the request and for returning any
* responses. This buffer must be large enough to hold the
* length value in the request description. buffer must have been
* allocated using DRVR_ALLOC.
*
* NOTE: On an IN transaction, req and buffer may refer to the same
* allocated memory.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* - Called from a single thread so no mutual exclusion is required.
* - Never called from an interrupt handler.
*
****************************************************************************/
static int max3421e_ctrlin(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep0,
FAR const struct usb_ctrlreq_s *req,
FAR uint8_t *buffer)
{
FAR struct max3421e_usbhost_s *priv;
FAR struct max3421e_chan_s *chan;
uint16_t buflen;
clock_t start;
clock_t elapsed;
int retries;
int ret;
DEBUGASSERT(drvr != NULL && req != NULL);
priv = (FAR struct max3421e_usbhost_s *)drvr;
DEBUGASSERT((intptr_t)ep0 >= 0 && (intptr_t)ep0 < MAX3421E_NHOST_CHANNELS);
chan = &priv->chan[(intptr_t)ep0];
usbhost_vtrace2(MAX3421E_VTRACE2_CTRLIN, req->type, req->req);
uinfo("type:%02x req:%02x value:%02x%02x index:%02x%02x len:%02x%02x\n",
req->type, req->req, req->value[1], req->value[0],
req->index[1], req->index[0], req->len[1], req->len[0]);
/* Extract values from the request */
buflen = max3421e_getle16(req->len);
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Loop, retrying until the retry time expires */
for (retries = 0; retries < MAX3421E_RETRY_COUNT; retries++)
{
/* Send the SETUP request */
ret = max3421e_ctrl_sendsetup(priv, chan, req);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_SENDSETUP_FAIL2, -ret);
continue;
}
/* Get the start time. Loop again until the timeout expires */
start = clock_systime_ticks();
do
{
/* Handle the IN data phase (if any) */
/* The MAX4321E sends fixed DATA0 and DATA1 PID tokens for the
* various stages of a CONTROL transfer, regardless of the
* setting of the internal data toggle.
*/
if (buflen > 0)
{
ret = max3421e_ctrl_recvdata(priv, chan, buffer, buflen);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_RECVDATA_FAIL, -ret);
}
}
/* Handle the status OUT phase */
if (ret >= OK)
{
ret = max3421e_ctrl_sendstatus(priv, chan);
if (ret >= OK)
{
/* All success transactions exit here */
nxrmutex_unlock(&priv->lock);
return OK;
}
usbhost_trace1(MAX3421E_TRACE1_SENDSTATUS_FAIL, -ret);
}
/* Get the elapsed time (in frames) */
elapsed = clock_systime_ticks() - start;
}
while (elapsed < MAX3421E_DATANAK_DELAY);
}
/* All failures exit here after all retries and timeouts are exhausted */
nxrmutex_unlock(&priv->lock);
return -ETIMEDOUT;
}
static int max3421e_ctrlout(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep0,
FAR const struct usb_ctrlreq_s *req,
FAR const uint8_t *buffer)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
FAR struct max3421e_chan_s *chan;
uint16_t buflen;
clock_t start;
clock_t elapsed;
int retries;
int ret;
DEBUGASSERT(drvr != NULL && req != NULL);
priv = (FAR struct max3421e_usbhost_s *)drvr;
DEBUGASSERT((intptr_t)ep0 >= 0 && (intptr_t)ep0 < MAX3421E_NHOST_CHANNELS);
chan = &priv->chan[(intptr_t)ep0];
usbhost_vtrace2(MAX3421E_VTRACE2_CTRLOUT, req->type, req->req);
uinfo("type:%02x req:%02x value:%02x%02x index:%02x%02x len:%02x%02x\n",
req->type, req->req, req->value[1], req->value[0],
req->index[1], req->index[0], req->len[1], req->len[0]);
/* Extract values from the request */
buflen = max3421e_getle16(req->len);
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Loop, retrying until the retry time expires */
for (retries = 0; retries < MAX3421E_RETRY_COUNT; retries++)
{
/* Send the SETUP request */
ret = max3421e_ctrl_sendsetup(priv, chan, req);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_SENDSETUP_FAIL1, -ret);
continue;
}
/* Get the start time. Loop again until the timeout expires */
start = clock_systime_ticks();
do
{
/* Handle the data OUT phase (if any) */
/* The MAX4321E sends fixed DATA0 and DATA1 PID tokens for the
* various stages of a CONTROL transfer, regardless of the setting
* of the internal data toggle.
*/
if (buflen > 0)
{
/* Start DATA out transfer (only one DATA packet) */
ret = max3421e_ctrl_senddata(priv, chan, NULL, 0);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_SENDDATA_FAIL, -ret);
}
}
/* Handle the status IN phase */
if (ret >= OK)
{
ret = max3421e_ctrl_recvstatus(priv, chan);
if (ret >= OK)
{
/* All success transactions exit here */
nxrmutex_unlock(&priv->lock);
return OK;
}
usbhost_trace1(MAX3421E_TRACE1_RECVSTATUS_FAIL, -ret);
}
/* Get the elapsed time (in frames) */
elapsed = clock_systime_ticks() - start;
}
while (elapsed < MAX3421E_DATANAK_DELAY);
}
/* All failures exit here after all retries and timeouts are exhausted */
nxrmutex_unlock(&priv->lock);
return -ETIMEDOUT;
}
/****************************************************************************
* Name: max3421e_transfer
*
* Description:
* Process a request to handle a transfer descriptor. This method will
* enqueue the transfer request, blocking until the transfer completes.
* Only one transfer may be queued; Neither this method nor the ctrlin or
* ctrlout methods can be called again until this function returns.
*
* This is a blocking method; this functions will not return until the
* transfer has completed.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* ep - The IN or OUT endpoint descriptor for the device endpoint on
* which to perform the transfer.
* buffer - A buffer containing the data to be sent (OUT endpoint) or
* received (IN endpoint). buffer must have been allocated
* using DRVR_ALLOC
* buflen - The length of the data to be sent or received.
*
* Returned Value:
* On success, a non-negative value is returned that indicates the number
* of bytes successfully transferred. On a failure, a negated errno value
* is returned that indicates the nature of the failure:
*
* EAGAIN - If devices NAKs the transfer (or NYET or other error where
* it may be appropriate to restart the entire transaction).
* EPERM - If the endpoint stalls
* EIO - On a TX or data toggle error
* EPIPE - Overrun errors
*
* Assumptions:
* - Called from a single thread so no mutual exclusion is required.
* - Never called from an interrupt handler.
*
****************************************************************************/
static ssize_t max3421e_transfer(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep, FAR uint8_t *buffer,
size_t buflen)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
FAR struct max3421e_chan_s *chan;
ssize_t nbytes;
int ret;
DEBUGASSERT(priv != NULL && buffer != NULL && buflen > 0);
DEBUGASSERT((intptr_t)ep >= 0 && (intptr_t)ep < MAX3421E_NHOST_CHANNELS);
chan = &priv->chan[(intptr_t)ep];
usbhost_vtrace2(MAX3421E_VTRACE2_TRANSFER, (unsigned int)ep, buflen);
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Handle IN and OUT transfer differently */
if (chan->in)
{
nbytes = max3421e_in_transfer(priv, chan, buffer, buflen);
}
else
{
nbytes = max3421e_out_transfer(priv, chan, buffer, buflen);
}
nxrmutex_unlock(&priv->lock);
return nbytes;
}
/****************************************************************************
* Name: max3421e_asynch
*
* Description:
* Process a request to handle a transfer descriptor. This method will
* enqueue the transfer request and return immediately. When the transfer
* completes, the callback will be invoked with the provided transfer.
* This method is useful for receiving interrupt transfers which may come
* infrequently.
*
* Only one transfer may be queued; Neither this method nor the ctrlin or
* ctrlout methods can be called again until the transfer completes.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from
* the call to the class create() method.
* ep - The IN or OUT endpoint descriptor for the device endpoint
* on which to perform the transfer.
* buffer - A buffer containing the data to be sent (OUT endpoint) or
* received (IN endpoint). buffer must have been allocated
* using DRVR_ALLOC
* buflen - The length of the data to be sent or received.
* callback - This function will be called when the transfer completes.
* arg - The arbitrary parameter that will be passed to the callback
* function when the transfer completes.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure
*
* Assumptions:
* - Called from a single thread so no mutual exclusion is required.
* - Never called from an interrupt handler.
*
****************************************************************************/
#ifdef CONFIG_USBHOST_ASYNCH
static int max3421e_asynch(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep,
FAR uint8_t *buffer, size_t buflen,
usbhost_asynch_t callback, FAR void *arg)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
FAR struct max3421e_chan_s *chan;
int ret;
DEBUGASSERT(priv != NULL && buffer != NULL && buflen > 0);
DEBUGASSERT((intptr_t)ep >= 0 && ep < MAX3421E_NHOST_CHANNELS);
chan = &priv->chan[(intptr_t)ep];
usbhost_vtrace2(MAX3421E_VTRACE2_ASYNCH, (unsigned int)ep, buflen);
/* We must have exclusive access to the USB host hardware and structures */
ret = nxrmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Handle IN and OUT transfer slightly differently */
if (chan->in)
{
ret = max3421e_in_asynch(priv, chan, buffer, buflen, callback, arg);
}
else
{
ret = max3421e_out_asynch(priv, chan, buffer, buflen, callback, arg);
}
nxrmutex_unlock(&priv->lock);
return ret;
}
#endif /* CONFIG_USBHOST_ASYNCH */
/****************************************************************************
* Name: max3421e_cancel
*
* Description:
* Cancel a pending transfer on an endpoint. Canceled synchronous or
* asynchronous transfer will complete normally with the error -ESHUTDOWN.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* ep - The IN or OUT endpoint descriptor for the device endpoint on
* which an asynchronous transfer should be transferred.
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure.
*
****************************************************************************/
static int max3421e_cancel(FAR struct usbhost_driver_s *drvr,
usbhost_ep_t ep)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
FAR struct max3421e_chan_s *chan;
irqstate_t flags;
DEBUGASSERT(priv != NULL);
DEBUGASSERT((intptr_t)ep >= 0 && (intptr_t)ep < MAX3421E_NHOST_CHANNELS);
chan = &priv->chan[(intptr_t)ep];
usbhost_vtrace1(MAX3421E_VTRACE1_CANCEL, (intptr_t)ep);
/* We need to disable interrupts to avoid race conditions with the
* asynchronous completion of the transfer being canceled.
*/
flags = enter_critical_section();
/* Halt the channel */
#warning Missing logic
UNUSED(chan); /* For now */
priv->result = -ESHUTDOWN;
/* Is there a thread waiting for this transfer to complete? */
if (priv->waiter != NULL)
{
#ifdef CONFIG_USBHOST_ASYNCH
/* Yes.. there should not also be a callback scheduled */
DEBUGASSERT(priv->callback == NULL);
#endif
/* Wake'em up! */
nxsem_post(&priv->waitsem);
priv->waiter = NULL;
}
#ifdef CONFIG_USBHOST_ASYNCH
/* No.. is an asynchronous callback expected when the transfer
* completes?
*/
else if (priv->callback)
{
usbhost_asynch_t callback;
FAR void *arg;
/* Extract the callback information */
callback = priv->callback;
arg = priv->arg;
priv->callback = NULL;
priv->arg = NULL;
priv->xfrd = 0;
/* Then perform the callback */
callback(arg, -ESHUTDOWN);
}
#endif
leave_critical_section(flags);
return OK;
}
/****************************************************************************
* Name: max3421e_connect
*
* Description:
* New connections may be detected by an attached hub. This method is the
* mechanism that is used by the hub class to introduce a new connection
* and port description to the system.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from
* the call to the class create() method.
* hport - The descriptor of the hub port that detected the connection
* related event
* connected - True: device connected; false: device disconnected
*
* Returned Value:
* On success, zero (OK) is returned. On a failure, a negated errno value
* is returned indicating the nature of the failure.
*
****************************************************************************/
#ifdef CONFIG_USBHOST_HUB
static int max3421e_connect(FAR struct usbhost_driver_s *drvr,
FAR struct usbhost_hubport_s *hport,
bool connected)
{
FAR struct max3421e_usbhost_s *priv =
(FAR struct max3421e_usbhost_s *)drvr;
irqstate_t flags;
DEBUGASSERT(priv != NULL && hport != NULL);
/* Set the connected/disconnected flag */
hport->connected = connected;
usbhost_vtrace2(MAX3421E_VTRACE2_HUB_CONNECTED, hport->port, connected);
/* Report the connection event */
flags = enter_critical_section();
priv->hport = hport;
if (priv->pscwait)
{
priv->pscwait = false;
nxsem_post(&priv->pscsem);
}
leave_critical_section(flags);
return OK;
}
#endif
/****************************************************************************
* Name: max3421e_disconnect
*
* Description:
* Called by the class when an error occurs and driver has been
* disconnected. The USB host driver should discard the handle to the
* class instance (it is stale) and not attempt any further interaction
* with the class driver instance (until a new instance is received from
* the create() method). The driver should not called the class'
* disconnected() method.
*
* Input Parameters:
* drvr - The USB host driver instance obtained as a parameter from the
* call to the class create() method.
* hport - The port from which the device is being disconnected. Might be
* a port on a hub.
*
* Returned Value:
* None
*
* Assumptions:
* - Only a single class bound to a single device is supported.
* - Never called from an interrupt handler.
*
****************************************************************************/
static void max3421e_disconnect(FAR struct usbhost_driver_s *drvr,
FAR struct usbhost_hubport_s *hport)
{
DEBUGASSERT(hport != NULL);
hport->devclass = NULL;
}
/****************************************************************************
* Initialization
****************************************************************************/
/****************************************************************************
* Name: max3421e_busreset
*
* Description:
* Reset the USB host port.
*
* Input Parameters:
* priv -- USB host driver private data structure.
*
* Returned Value:
* None
*
****************************************************************************/
static void max3421e_busreset(FAR struct max3421e_usbhost_s *priv)
{
/* Disable the SOF generator */
max3421e_modifyreg(priv, MAX3421E_USBHOST_MODE, USBHOST_MODE_SOFKAENAB, 0);
/* Clear any pending bus event */
max3421e_int_clear(priv, USBHOST_HIRQ_BUSEVENTIRQ);
/* Perform the reset */
max3421e_modifyreg(priv, MAX3421E_USBHOST_HCTL, 0, USBHOST_HCTL_BUSRST);
max3421e_int_wait(priv, USBHOST_HIRQ_BUSEVENTIRQ, 250);
}
/****************************************************************************
* Name: max3421e_startsof
*
* Description:
* Called after bus reset. Determine bus speed and restart SOFs.
*
* Input Parameters:
* priv -- USB host driver private data structure.
*
* Returned Value:
* OK if successfully connect; -ENODEV if not connected.
*
****************************************************************************/
static int max3421e_startsof(FAR struct max3421e_usbhost_s *priv)
{
uint8_t clrbits;
uint8_t setbits;
uint8_t regval;
bool lowspeed;
/* Check if we are already in low- or full-speed mode */
regval = max3421e_getreg(priv, MAX3421E_USBHOST_MODE);
lowspeed = ((regval & USBHOST_MODE_SPEED) != 0);
/* Enable SAMPLEBUS */
max3421e_modifyreg(priv, MAX3421E_USBHOST_HCTL, 0,
USBHOST_HCTL_BUSSAMPLE);
while ((max3421e_getreg(priv, MAX3421E_USBHOST_HCTL) &
USBHOST_HCTL_BUSSAMPLE) == 0)
{
nxsig_usleep(5);
}
/* Check for low- or full-speed and start SOF (actually already started
* by max3421e_busreset).
*/
clrbits = 0;
setbits = USBHOST_MODE_HOST | USBHOST_MODE_SOFKAENAB |
USBHOST_MODE_DMPULLD | USBHOST_MODE_DPPULLDN;
regval = max3421e_getreg(priv, MAX3421E_USBHOST_HRSL);
switch (regval & (USBHOST_HRSL_KSTATUS | USBHOST_HRSL_JSTATUS))
{
default:
case (USBHOST_HRSL_KSTATUS | USBHOST_HRSL_JSTATUS):
/* Invalid state */
usbhost_trace1(MAX3421E_TRACE1_BAD_JKSTATE, regval);
/* Fall through */
case 0:
/* 0: Not connected */
return -ENODEV;
case USBHOST_HRSL_KSTATUS:
/* J=0, K=1: low-speed in full-speed (or vice versa) */
if (lowspeed)
{
/* Full speed in low speed */
clrbits |= USBHOST_MODE_SPEED;
}
else
{
/* Low speed in full speed */
setbits |= USBHOST_MODE_SPEED;
}
break;
case USBHOST_HRSL_JSTATUS:
/* J=1,K=0: full-speed in full-speed (or vice versa) */
if (lowspeed)
{
/* Low speed in low speed */
setbits |= USBHOST_MODE_SPEED;
}
else
{
/* Full speed in full speed */
clrbits |= USBHOST_MODE_SPEED;
}
break;
}
/* Restart the SOF generator */
max3421e_modifyreg(priv, MAX3421E_USBHOST_MODE, clrbits, setbits);
/* Wait for the first SOF received and 20ms has passed */
max3421e_int_wait(priv, USBHOST_HIRQ_FRAMEIRQ, 0);
nxsig_usleep(20 * 1000);
return OK;
}
/****************************************************************************
* Name: max3421e_sw_initialize
*
* Description:
* One-time setup of the host driver state structure.
*
* Input Parameters:
* priv -- USB host driver private data structure.
* conn -- Custom USB host connection structure.
* lower -- The lower half driver instance.
*
* Returned Value:
* None.
*
****************************************************************************/
static inline int max3421e_sw_initialize(FAR struct max3421e_usbhost_s *priv,
FAR struct max3421e_connection_s *conn,
FAR const struct max3421e_lowerhalf_s *lower)
{
FAR struct usbhost_driver_s *drvr;
FAR struct usbhost_hubport_s *hport;
int ret;
int i;
/* Initialize the device operations */
drvr = &priv->drvr;
drvr->ep0configure = max3421e_ep0configure;
drvr->epalloc = max3421e_epalloc;
drvr->epfree = max3421e_epfree;
drvr->alloc = max3421e_alloc;
drvr->free = max3421e_free;
drvr->ioalloc = max3421e_ioalloc;
drvr->iofree = max3421e_iofree;
drvr->ctrlin = max3421e_ctrlin;
drvr->ctrlout = max3421e_ctrlout;
drvr->transfer = max3421e_transfer;
#ifdef CONFIG_USBHOST_ASYNCH
drvr->asynch = max3421e_asynch;
#endif
drvr->cancel = max3421e_cancel;
#ifdef CONFIG_USBHOST_HUB
drvr->connect = max3421e_connect;
#endif
drvr->disconnect = max3421e_disconnect;
/* Initialize the public port representation */
hport = &priv->rhport.hport;
hport->drvr = drvr;
#ifdef CONFIG_USBHOST_HUB
hport->parent = NULL;
#endif
hport->ep0 = 0;
hport->speed = USB_SPEED_FULL;
/* Initialize function address generation logic */
usbhost_devaddr_initialize(&priv->rhport);
/* Initialize semaphores */
nxsem_init(&priv->pscsem, 0, 0);
nxsem_init(&priv->waitsem, 0, 0);
/* Initialize lock */
nxrmutex_init(&priv->lock);
/* Initialize the driver state data */
priv->lower = lower;
priv->smstate = SMSTATE_DETACHED;
priv->connected = false;
priv->irqset = 0;
priv->change = false;
priv->holder = NO_HOLDER;
/* Put all of the channels back in their initial, allocated state */
memset(priv->chan, 0,
MAX3421E_NHOST_CHANNELS * sizeof(struct max3421e_chan_s));
/* Initialize each channel */
for (i = 0; i < MAX3421E_NHOST_CHANNELS; i++)
{
FAR struct max3421e_chan_s *chan = &priv->chan[i];
chan->chidx = i;
}
/* Initialize the connection structure */
conn->conn.wait = max3421e_wait;
conn->conn.enumerate = max3421e_enumerate;
conn->priv = priv;
/* Attach USB host controller interrupt handler */
ret = lower->attach(lower, max3421e_interrupt, priv);
if (ret < 0)
{
usbhost_trace1(MAX3421E_TRACE1_IRQATTACH_FAIL, 0);
return ret;
}
return OK;
}
/****************************************************************************
* Name: max3421e_hw_initialize
*
* Description:
* One-time setup of the host controller hardware for normal operations.
*
* Input Parameters:
* priv -- USB host driver private data structure.
*
* Returned Value:
* Zero on success; a negated errno value on failure.
*
****************************************************************************/
static inline int max3421e_hw_initialize(FAR struct max3421e_usbhost_s *priv)
{
uint8_t revision;
uint8_t regval;
int ret;
/* Get exclusive access to the SPI bus */
max3421e_lock(priv);
/* Configure full duplex SPI, level or edge-active, rising- or falling
* edge interrupt.
*
* NOTE: Initially, the MAX3421E operations in half-duplex mode. MISO is
* tristated and there is no status response to commands. Writes are not
* effected: The MISO pin continues to be high impedance and the master
* continues to drive MOSI.
*
* For reads, however, after the 8-bit command, the max3421e starts driving
* the MOSI pin. The master must turn off its driver to the MOSI pin to
* avoid contention.
*/
regval = priv->lower->intconfig;
regval &= (USBHOST_PINCTL_INTLEVEL | USBHOST_PINCTL_POSINT);
regval |= USBHOST_PINCTL_FDUPSPI;
max3421e_putreg(priv, MAX3421E_USBHOST_PINCTL, regval);
/* Reset the MAX3421E by toggling the CHIPRES bit in the USBCTRL register.
*
* NOTE: The bits that control the SPI interface are not changed by
* CHIPRES: FDUPSPI, INTLEVEL, and POSINT.
*/
max3421e_putreg(priv, MAX3421E_USBHOST_USBCTL, USBHOST_USBCTL_CHIPRES);
max3421e_putreg(priv, MAX3421E_USBHOST_USBCTL, 0);
/* Wait for the oscillator to become stable */
while ((max3421e_getreg(priv, MAX3421E_USBHOST_USBIRQ) &
USBHOST_USBIRQ_OSCOKIRQ) == 0)
{
}
/* Disable interrupts, clear pending interrupts, and reset the interrupt
* state.
*/
max3421e_modifyreg(priv, MAX3421E_USBHOST_CPUCTL, USBHOST_CPUCTL_IE, 0);
max3421e_putreg(priv, MAX3421E_USBHOST_HIEN, 0);
max3421e_int_clear(priv, 0xff);
priv->irqset = 0;
/* Configure as full-speed USB host */
max3421e_modifyreg(priv, MAX3421E_USBHOST_MODE,
USBHOST_MODE_SPEED | USBHOST_MODE_SOFKAENAB,
USBHOST_MODE_HOST | USBHOST_MODE_DMPULLD |
USBHOST_MODE_DPPULLDN);
/* Clear and enable the connection detected (CONDIRQ) interrupt */
max3421e_int_clear(priv, USBHOST_HIRQ_CONNIRQ);
max3421e_int_enable(priv, USBHOST_HIRQ_CONNIRQ);
/* Enable MAX3412E interrupts */
max3421e_modifyreg(priv, MAX3421E_USBHOST_CPUCTL, 0, USBHOST_CPUCTL_IE);
usbhost_vtrace1(MAX3421E_VTRACE1_INITIALIZED, 0);
revision = max3421e_getreg(priv, MAX3421E_USBHOST_REVISION);
if (revision != USBHOST_REVISION)
{
usbhost_trace1(MAX3421E_TRACE1_BADREVISION, revision);
max3421e_unlock(priv);
return -ENODEV;
}
/* Perform a bus reset to reconnect after a power down */
ret = max3421e_connected(priv);
if (ret < 0)
{
/* Nothing connected. */
max3421e_disconnected(priv);
}
max3421e_unlock(priv);
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: max3421e_usbhost_initialize
*
* Description:
* Initialize MAX3421E as USB host controller.
*
* Input Parameters:
* lower - The interface to the lower half driver
*
* Returned Value:
* And instance of the USB host interface. The controlling task should
* use this interface to (1) call the wait() method to wait for a device
* to be connected, and (2) call the enumerate() method to bind the device
* to a class driver.
*
* Assumptions:
* - This function should called in the initialization sequence in order
* to initialize the USB device functionality.
* - Class drivers should be initialized prior to calling this function.
* Otherwise, there is a race condition if the device is already connected.
*
****************************************************************************/
FAR struct usbhost_connection_s *
max3421e_usbhost_initialize(FAR const struct max3421e_lowerhalf_s *lower)
{
FAR struct usbhost_alloc_s *alloc;
FAR struct max3421e_usbhost_s *priv;
FAR struct max3421e_connection_s *conn;
int ret;
DEBUGASSERT(lower != NULL && lower->spi != NULL && lower->attach != NULL &&
lower->attach != NULL && lower->acknowledge != NULL &&
lower->power != NULL);
/* Allocate and instance of the MAX4321E state structure */
alloc = (FAR struct usbhost_alloc_s *)
kmm_zalloc(sizeof(struct usbhost_alloc_s));
if (alloc < 0)
{
usbhost_trace1(MAX3421E_TRACE1_ALLOC_FAIL, 0);
return NULL;
}
priv = &alloc->priv;
conn = &alloc->conn;
/* Initialize the state of the host driver */
ret = max3421e_sw_initialize(priv, conn, lower);
if (ret < 0)
{
goto errout_with_alloc;
}
/* Initialize the MAX3421E, putting it into full operational state. */
ret = max3421e_hw_initialize(priv);
if (ret < 0)
{
goto errout_with_alloc;
}
/* Drive Vbus +5V (the smoke test). */
lower->power(lower, true);
/* Enable host interrupts */
lower->enable(lower, true);
return &conn->conn;
errout_with_alloc:
kmm_free(alloc);
return NULL;
}
/****************************************************************************
* Name: usbhost_trformat1 and usbhost_trformat2
*
* Description:
* This interface must be provided by platform specific logic that knows
* the HCDs encoding of USB trace data.
*
* Given an 9-bit index, return a format string suitable for use with,
* say, printf. The returned format is expected to handle two unsigned
* integer values.
*
****************************************************************************/
#ifdef HAVE_USBHOST_TRACE
FAR const char *usbhost_trformat1(uint16_t id)
{
int ndx = TRACE1_INDEX(id);
if (ndx < TRACE1_NSTRINGS)
{
return g_trace1[ndx].string;
}
return NULL;
}
FAR const char *usbhost_trformat2(uint16_t id)
{
int ndx = TRACE2_INDEX(id);
if (ndx < TRACE2_NSTRINGS)
{
return g_trace2[ndx].string;
}
return NULL;
}
#endif
#endif /* CONFIG_USBHOST_MAX3421E */
Reference in New Issue View Git Blame Copy Permalink