package/platform/lantiq/ltq-hcd/src/ifxhcd.h

   1 /*****************************************************************************
   2  **   FILE NAME       : ifxhcd.h
   3  **   PROJECT         : IFX USB sub-system V3
   4  **   MODULES         : IFX USB sub-system Host and Device driver
   5  **   SRC VERSION     : 3.2
   6  **   DATE            : 1/Jan/2011
   7  **   AUTHOR          : Chen, Howard
   8  **   DESCRIPTION     : This file contains the structures, constants, and interfaces for
   9  **                     the Host Contoller Driver (HCD).
  10  **
  11  **                     The Host Controller Driver (HCD) is responsible for translating requests
  12  **                     from the USB Driver into the appropriate actions on the IFXUSB controller.
  13  **                     It isolates the USBD from the specifics of the controller by providing an
  14  **                     API to the USBD.
  15  **   FUNCTIONS       :
  16  **   COMPILER        : gcc
  17  **   REFERENCE       : Synopsys DWC-OTG Driver 2.7
  18  **   COPYRIGHT       :  Copyright (c) 2010
  19  **                      LANTIQ DEUTSCHLAND GMBH,
  20  **                      Am Campeon 3, 85579 Neubiberg, Germany
  21  **
  22  **    This program is free software; you can redistribute it and/or modify
  23  **    it under the terms of the GNU General Public License as published by
  24  **    the Free Software Foundation; either version 2 of the License, or
  25  **    (at your option) any later version.
  26  **
  27  **  Version Control Section  **
  28  **   $Author$
  29  **   $Date$
  30  **   $Revisions$
  31  **   $Log$       Revision history
  32  *****************************************************************************/
  33
  34 /*
  35  * This file contains code fragments from Synopsys HS OTG Linux Software Driver.
  36  * For this code the following notice is applicable:
  37  *
  38  * ==========================================================================
  39  *
  40  * Synopsys HS OTG Linux Software Driver and documentation (hereinafter,
  41  * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless
  42  * otherwise expressly agreed to in writing between Synopsys and you.
  43  *
  44  * The Software IS NOT an item of Licensed Software or Licensed Product under
  45  * any End User Software License Agreement or Agreement for Licensed Product
  46  * with Synopsys or any supplement thereto. You are permitted to use and
  47  * redistribute this Software in source and binary forms, with or without
  48  * modification, provided that redistributions of source code must retain this
  49  * notice. You may not view, use, disclose, copy or distribute this file or
  50  * any information contained herein except pursuant to this license grant from
  51  * Synopsys. If you do not agree with this notice, including the disclaimer
  52  * below, then you are not authorized to use the Software.
  53  *
  54  * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS
  55  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT,
  58  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  59  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  60  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  61  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  64  * DAMAGE.
  65  * ========================================================================== */
  66
  67 /*!
  68   \defgroup IFXUSB_HCD HCD Interface
  69   \ingroup IFXUSB_DRIVER_V3
  70   \brief  The Host Controller Driver (HCD) is responsible for translating requests
  71  from the USB Driver into the appropriate actions on the IFXUSB controller.
  72  It isolates the USBD from the specifics of the controller by providing an
  73  API to the USBD.
  74  */
  75
  76
  77 /*!
  78   \file ifxhcd.h
  79   \ingroup IFXUSB_DRIVER_V3
  80   \brief This file contains the structures, constants, and interfaces for
  81  the Host Contoller Driver (HCD).
  82  */
  83
  84 #if !defined(__IFXHCD_H__)
  85 #define __IFXHCD_H__
  86
  87
  88 #define __STRICT_ORDER__
  89
  90
  91 #include <linux/list.h>
  92 #include <linux/usb.h>
  93
  94 #include <linux/usb/hcd.h>
  95
  96 #include "ifxusb_cif.h"
  97 #include "ifxusb_plat.h"
  98
  99
 100 #undef __INNAKSTOP__
 101 #if !defined(__INNAKSTOP__) && defined(__INNAKSTOP_CTRL__)
 102         #define __INNAKSTOP__ 1
 103 #endif
 104 #if !defined(__INNAKSTOP__) && defined(__INNAKSTOP_BULK__)
 105         #define __INNAKSTOP__ 1
 106 #endif
 107
 108 #undef __PINGSTOP__
 109 #if !defined(__PINGSTOP__) && defined(__PINGSTOP_CTRL__)
 110         #define __PINGSTOP__ 1
 111 #endif
 112 #if !defined(__PINGSTOP__) && defined(__PINGSTOP_BULK__)
 113         #define __PINGSTOP__ 1
 114 #endif
 115
 116 #undef __NAKSTOP__
 117 #if defined(__INNAKSTOP__) || defined(__PINGSTOP__)
 118         #define __NAKSTOP__ 1
 119 #endif
 120
 121
 122 /* Phases for control transfers.*/
 123 typedef enum ifxhcd_epqh_phase {
 124         EPQH_IDLE=0,
 125         EPQH_DISABLING,
 126 //      EPQH_COMPLETING,
 127         EPQH_STDBY,
 128         EPQH_READY,
 129         EPQH_ACTIVE
 130 } ifxhcd_epqh_phase_e;
 131
 132 /* Phases for control transfers.*/
 133 typedef enum ifxhcd_urbd_phase {
 134         URBD_IDLE=0,
 135         URBD_ACTIVE,
 136         URBD_STARTING,
 137         URBD_STARTED,
 138         URBD_FINISHING,    //URB_Complete already scheduled
 139         URBD_COMPLETING,   //To URB_Complete, it's normal finish
 140         URBD_DEQUEUEING,   //To URB_Complete, it's abnormal finish
 141 } ifxhcd_urbd_phase_e;
 142
 143 /* Phases for control transfers.*/
 144 typedef enum ifxhcd_hc_phase {
 145         HC_IDLE=0,
 146         HC_ASSIGNED,
 147         HC_WAITING,
 148         HC_STARTING,
 149         HC_STARTED,
 150         HC_STOPPING,
 151         HC_STOPPED,
 152 } ifxhcd_hc_phase_e;
 153
 154 /*!
 155   \addtogroup IFXUSB_HCD
 156  */
 157 /*@{*/
 158
 159 /*! \typedef  ifxhcd_control_phase_e
 160         \brief Phases for control transfers.
 161 */
 162
 163 typedef enum ifxhcd_control_phase {
 164         IFXHCD_CONTROL_SETUP,
 165         IFXHCD_CONTROL_DATA,
 166         IFXHCD_CONTROL_STATUS
 167 } ifxhcd_control_phase_e;
 168
 169 /*! \typedef  ifxhcd_halt_status_e
 170         \brief Reasons for halting a host channel.
 171 */
 172 typedef enum ifxhcd_halt_status
 173 {
 174         HC_XFER_NO_HALT_STATUS,         // Initial
 175         HC_XFER_COMPLETE,               // Xact complete without error, upward
 176         HC_XFER_URB_COMPLETE,           // Xfer complete without error, short upward
 177         HC_XFER_STALL,                  // HC stopped abnormally, upward/downward
 178         HC_XFER_XACT_ERR,               // HC stopped abnormally, upward
 179         HC_XFER_FRAME_OVERRUN,          // HC stopped abnormally, upward
 180         HC_XFER_BABBLE_ERR,             // HC stopped abnormally, upward
 181         HC_XFER_AHB_ERR,                // HC stopped abnormally, upward
 182         HC_XFER_DATA_TOGGLE_ERR,
 183         HC_XFER_URB_DEQUEUE,            // HC stopper manually, downward
 184         HC_XFER_NO_URB,                 // HC stopper manually, downward
 185         HC_XFER_NO_EPQH,                // HC stopper manually, downward
 186         #ifdef __NAKSTOP__
 187                 HC_XFER_NAK,                // HC stopped by nak monitor, downward
 188         #endif
 189         #if defined(__INTRNAKRETRY__) || defined(__INTRINCRETRY__)
 190                 HC_XFER_INTR_NAK_RETRY,     // HC stopped by nak monitor, downward
 191         #endif
 192 } ifxhcd_halt_status_e;
 193
 194 struct ifxhcd_urbd;
 195 struct ifxhcd_hc ;
 196 struct ifxhcd_epqh ;
 197 struct ifxhcd_hcd;
 198
 199 /*! typedef ifxhcd_urbd_t
 200  \brief A URB Descriptor (URBD) holds the state of a bulk, control,
 201   interrupt, or isochronous transfer. A single URBD is created for each URB
 202   (of one of these types) submitted to the HCD. The transfer associated with
 203   a URBD may require one or multiple transactions.
 204
 205   A URBD is linked to a EP Queue Head, which is entered in either the
 206   isoc, intr or non-periodic schedule for execution. When a URBD is chosen for
 207   execution, some or all of its transactions may be executed. After
 208   execution, the state of the URBD is updated. The URBD may be retired if all
 209   its transactions are complete or if an error occurred. Otherwise, it
 210   remains in the schedule so more transactions can be executed later.
 211  */
 212 typedef struct ifxhcd_urbd {
 213         ifxhcd_urbd_phase_e       phase;
 214         struct list_head          ql;               // Hook for EPQH->urbd_list
 215         struct urb               *urb;              /*!< URB for this transfer */
 216                                                     //struct urb {
 217                                                     //  struct list_head urb_list;
 218                                                     //  struct list_head anchor_list;
 219                                                     //  struct usb_anchor * anchor;
 220                                                     //  struct usb_device * dev;
 221                                                     //  struct usb_host_endpoint * ep;
 222                                                     //  unsigned int pipe;
 223                                                     //  int status;
 224                                                     //  unsigned int transfer_flags;
 225                                                     //  void * transfer_buffer;
 226                                                     //  dma_addr_t transfer_dma;
 227                                                     //  u32 transfer_buffer_length;
 228                                                     //  u32 actual_length;
 229                                                     //  unsigned char * setup_packet;
 230                                                     //  dma_addr_t setup_dma;
 231                                                     //  int start_frame;
 232                                                     //  int number_of_packets;
 233                                                     //  int interval;
 234                                                     //  int error_count;
 235                                                     //  void * context;
 236                                                     //  usb_complete_t complete;
 237                                                     //  struct usb_iso_packet_descriptor iso_frame_desc[0];
 238                                                     //};
 239                                                     //urb_list         For use by current owner of the URB.
 240                                                     //anchor_list      membership in the list of an anchor
 241                                                     //anchor           to anchor URBs to a common mooring
 242                                                     //dev              Identifies the USB device to perform the request.
 243                                                     //ep               Points to the endpoint's data structure. Will
 244                                                     //                 eventually replace pipe.
 245                                                     //pipe             Holds endpoint number, direction, type, and more.
 246                                                     //                 Create these values with the eight macros available; u
 247                                                     //                 sb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is
 248                                                     //                  "ctrl", "bulk", "int" or "iso". For example
 249                                                     //                 usb_sndbulkpipe or usb_rcvintpipe. Endpoint numbers
 250                                                     //                 range from zero to fifteen. Note that "in" endpoint two
 251                                                     //                 is a different endpoint (and pipe) from "out" endpoint
 252                                                     //                 two. The current configuration controls the existence,
 253                                                     //                 type, and maximum packet size of any given endpoint.
 254                                                     //status           This is read in non-iso completion functions to get
 255                                                     //                 the status of the particular request. ISO requests
 256                                                     //                 only use it to tell whether the URB was unlinked;
 257                                                     //                 detailed status for each frame is in the fields of
 258                                                     //                 the iso_frame-desc.
 259                                                     //transfer_flags   A variety of flags may be used to affect how URB
 260                                                     //                 submission, unlinking, or operation are handled.
 261                                                     //                 Different kinds of URB can use different flags.
 262                                                     //                      URB_SHORT_NOT_OK
 263                                                     //                      URB_ISO_ASAP
 264                                                     //                      URB_NO_TRANSFER_DMA_MAP
 265                                                     //                      URB_NO_SETUP_DMA_MAP
 266                                                     //                      URB_NO_FSBR
 267                                                     //                      URB_ZERO_PACKET
 268                                                     //                      URB_NO_INTERRUPT
 269                                                     //transfer_buffer  This identifies the buffer to (or from) which the I/O
 270                                                     //                 request will be performed (unless URB_NO_TRANSFER_DMA_MAP
 271                                                     //                 is set). This buffer must be suitable for DMA; allocate it
 272                                                     //                 with kmalloc or equivalent. For transfers to "in"
 273                                                     //                 endpoints, contents of this buffer will be modified. This
 274                                                     //                 buffer is used for the data stage of control transfers.
 275                                                     //transfer_dma     When transfer_flags includes URB_NO_TRANSFER_DMA_MAP, the
 276                                                     //                 device driver is saying that it provided this DMA address,
 277                                                     //                 which the host controller driver should use in preference
 278                                                     //                 to the transfer_buffer.
 279                                                     //transfer_buffer_length How big is transfer_buffer. The transfer may be broken
 280                                                     //                 up into chunks according to the current maximum packet size
 281                                                     //                 for the endpoint, which is a function of the configuration
 282                                                     //                 and is encoded in the pipe. When the length is zero, neither
 283                                                     //                 transfer_buffer nor transfer_dma is used.
 284                                                     //actual_length    This is read in non-iso completion functions, and it tells
 285                                                     //                 how many bytes (out of transfer_buffer_length) were transferred.
 286                                                     //                 It will normally be the same as requested, unless either an error
 287                                                     //                 was reported or a short read was performed. The URB_SHORT_NOT_OK
 288                                                     //                 transfer flag may be used to make such short reads be reported
 289                                                     //                 as errors.
 290                                                     //setup_packet     Only used for control transfers, this points to eight bytes of
 291                                                     //                 setup data. Control transfers always start by sending this data
 292                                                     //                 to the device. Then transfer_buffer is read or written, if needed.
 293                                                     //setup_dma        For control transfers with URB_NO_SETUP_DMA_MAP set, the device
 294                                                     //                 driver has provided this DMA address for the setup packet. The
 295                                                     //                 host controller driver should use this in preference to setup_packet.
 296                                                     //start_frame      Returns the initial frame for isochronous transfers.
 297                                                     //number_of_packets Lists the number of ISO transfer buffers.
 298                                                     //interval         Specifies the polling interval for interrupt or isochronous transfers.
 299                                                     //                 The units are frames (milliseconds) for for full and low speed devices,
 300                                                     //                 and microframes (1/8 millisecond) for highspeed ones.
 301                                                     //error_count      Returns the number of ISO transfers that reported errors.
 302                                                     //context          For use in completion functions. This normally points to request-specific
 303                                                     //                 driver context.
 304                                                     //complete         Completion handler. This URB is passed as the parameter to the completion
 305                                                     //                 function. The completion function may then do what it likes with the URB,
 306                                                     //                 including resubmitting or freeing it.
 307                                                     //iso_frame_desc[0] Used to provide arrays of ISO transfer buffers and to collect the transfer
 308                                                     //                 status for each buffer.
 309
 310         struct ifxhcd_epqh       *epqh;
 311                                                 // Actual data portion, not SETUP or STATUS in case of CTRL XFER
 312                                                 // DMA adjusted
 313         uint8_t                  *setup_buff;       /*!< Pointer to the entire transfer buffer. (CPU accessable)*/
 314         uint8_t                  *xfer_buff;        /*!< Pointer to the entire transfer buffer. (CPU accessable)*/
 315         uint32_t                  xfer_len;         /*!< Total number of bytes to transfer in this xfer. */
 316
 317         #if   defined(__UNALIGNED_BUF_ADJ__)
 318 //              uint8_t using_aligned_setup;
 319                 uint8_t *aligned_setup;
 320 //              uint8_t using_aligned_buf;
 321                 uint8_t *aligned_buf;
 322                 unsigned aligned_buf_len : 19;
 323         #endif
 324         #if   defined(__UNALIGNED_BUF_ADJ__) || defined(__UNALIGNED_BUF_CHK__)
 325                 unsigned aligned_checked :  1;
 326         #endif
 327         unsigned     is_in           :1;
 328         #ifndef __STRICT_ORDER__
 329                 struct tasklet_struct  complete_urb_sub;
 330         #endif
 331
 332                                   // For ALL XFER
 333         uint8_t                   error_count;    /*!< Holds the number of bus errors that have occurred for a transaction
 334                                                        within this transfer.
 335                                                    */
 336                                   // For ISOC XFER only
 337         #ifdef __EN_ISOC__
 338                 int                   isoc_frame_index; /*!< Index of the next frame descriptor for an isochronous transfer. A
 339                                                              frame descriptor describes the buffer position and length of the
 340                                                              data to be transferred in the next scheduled (micro)frame of an
 341                                                              isochronous transfer. It also holds status for that transaction.
 342                                                              The frame index starts at 0.
 343                                                          */
 344         #endif
 345         int status;
 346 } ifxhcd_urbd_t;
 347
 348 /*! typedef ifxhcd_epqh_t
 349  \brief A EP Queue Head (EPQH) holds the static characteristics of an endpoint and
 350  maintains a list of transfers (URBDs) for that endpoint. A EPQH structure may
 351  be entered in either the isoc, intr or non-periodic schedule.
 352  */
 353
 354 typedef struct ifxhcd_epqh {
 355         struct ifxhcd_hcd    *ifxhcd;
 356         struct usb_host_endpoint *sysep;
 357         uint8_t devno;
 358
 359         ifxhcd_epqh_phase_e  phase;
 360         struct list_head     ql_all;
 361         struct list_head     ql;                // Hook for EP Queues
 362         struct list_head     urbd_list;         /*!< List of URBDs for this EPQH. */
 363         #ifdef __STRICT_ORDER__
 364                 struct list_head     release_list;
 365                 struct tasklet_struct  complete_urb_sub;
 366         #endif
 367         struct ifxhcd_hc    *hc;                /*!< Host channel currently processing transfers for this EPQH. */
 368         struct ifxhcd_urbd  *urbd;              /*!< URBD currently assigned to a host channel for this EPQH. */
 369         uint8_t              ep_type;           /*!< Endpoint type. One of the following values:
 370                                                      - IFXUSB_EP_TYPE_CTRL
 371                                                      - IFXUSB_EP_TYPE_ISOC
 372                                                      - IFXUSB_EP_TYPE_BULK
 373                                                      - IFXUSB_EP_TYPE_INTR
 374                                                  */
 375         uint16_t             mps;               /*!< wMaxPacketSize Field of Endpoint Descriptor. */
 376         #ifdef __EPQD_DESTROY_TIMEOUT__
 377                 struct timer_list destroy_timer;
 378         #endif
 379
 380         unsigned need_split     : 1 ;
 381         unsigned do_ping        : 1 ; /*!< Set to 1 to indicate that a PING request should be issued on this
 382                                           channel. If 0, process normally.
 383                                       */
 384         unsigned pause          : 1;
 385         unsigned period_do      : 1;
 386         uint16_t             interval;          /*!< Interval between transfers in (micro)frames. (for INTR)*/
 387         uint16_t             period_counter;    /*!< Interval between transfers in (micro)frames. */
 388
 389         #ifdef __EN_ISOC__
 390                 struct tasklet_struct  tasklet_next_isoc;
 391                 uint8_t               isoc_now;
 392                 uint32_t              isoc_start_frame;
 393                                   // For SPLITed ISOC XFER only
 394                 #ifdef __EN_ISOC_SPLIT__
 395                         uint8_t           isoc_split_pos;   /*!< Position of the ISOC split on full/low speed */
 396                         uint16_t          isoc_split_offset;/*!< Position of the ISOC split in the buffer for the current frame */
 397                 #endif
 398         #endif
 399         spinlock_t      urbd_list_lock;
 400         int urbd_count;
 401 } ifxhcd_epqh_t;
 402
 403
 404 /*! typedef ifxhcd_hc_t
 405  \brief Host channel descriptor. This structure represents the state of a single
 406  host channel when acting in host mode. It contains the data items needed to
 407  transfer packets to an endpoint via a host channel.
 408  */
 409 typedef struct ifxhcd_hc
 410 {
 411         struct ifxhcd_epqh *epqh        ; /*!< EP Queue Head for the transfer being processed by this channel. */
 412         uint8_t  hc_num                 ; /*!< Host channel number used for register address lookup */
 413         uint8_t *xfer_buff              ; /*!< Pointer to the entire transfer buffer. */
 414         uint32_t xfer_count             ; /*!< Number of bytes transferred so far. The offset of the begin of the buf */
 415         uint32_t xfer_len               ; /*!< Total number of bytes to transfer in this xfer. */
 416         uint16_t start_pkt_count        ; /*!< Packet count at start of transfer. Used to calculate the actual xfer size*/
 417         ifxhcd_halt_status_e halt_status; /*!< Reason for halting the host channel. */
 418         ifxhcd_hc_phase_e  phase;
 419
 420         unsigned dev_addr       : 7; /*!< Device to access */
 421         unsigned ep_num         : 4; /*!< EP to access */
 422         unsigned is_in          : 1; /*!< EP direction. 0: OUT, 1: IN */
 423         unsigned speed          : 2; /*!< EP speed. */
 424         unsigned ep_type        : 2; /*!< Endpoint type. */
 425         unsigned mps            :11; /*!< Max packet size in bytes */
 426         unsigned data_pid_start : 2; /*!< PID for initial transaction. */
 427         unsigned short_rw       : 1; /*!< When Tx, means termination needed.
 428                                           When Rx, indicate Short Read  */
 429         /* Split settings for the host channel */
 430         unsigned split          : 2; /*!< Split: 0-Non Split, 1-SSPLIT, 2&3 CSPLIT */
 431
 432         unsigned sof_delay      :16;
 433         unsigned erron          : 1;
 434
 435         #ifdef __NAKSTOP__
 436                 unsigned stop_on            : 1;
 437 //              unsigned wait_for_sof_quick : 1;
 438         #endif
 439
 440         ifxhcd_control_phase_e    control_phase;  /*!< Current phase for control transfers (Setup, Data, or Status). */
 441         uint32_t ssplit_out_xfer_count; /*!< How many bytes transferred during SSPLIT OUT */
 442         #ifdef __DEBUG__
 443                 uint32_t          start_hcchar_val;
 444         #endif
 445         uint32_t hcchar;
 446
 447         /* Split settings for the host channel */
 448         uint8_t hub_addr;          /*!< Address of high speed hub */
 449         uint8_t port_addr;         /*!< Port of the low/full speed device */
 450         #if defined(__EN_ISOC__) && defined(__EN_ISOC_SPLIT__)
 451                 uint8_t isoc_xact_pos;          /*!< Split transaction position */
 452         #endif
 453 } ifxhcd_hc_t;
 454
 455
 456 /*! typedef ifxhcd_hcd_t
 457  \brief This structure holds the state of the HCD, including the non-periodic and
 458  periodic schedules.
 459  */
 460 typedef struct ifxhcd_hcd
 461 {
 462         struct device *dev;
 463         struct hc_driver hc_driver;
 464         ifxusb_core_if_t core_if;   /*!< Pointer to the core interface structure. */
 465         struct usb_hcd *syshcd;
 466
 467         volatile union
 468         {
 469                 uint32_t d32;
 470                 struct
 471                 {
 472                         unsigned port_connect_status_change : 1;
 473                         unsigned port_connect_status        : 1;
 474                         unsigned port_reset_change          : 1;
 475                         unsigned port_enable_change         : 1;
 476                         unsigned port_suspend_change        : 1;
 477                         unsigned port_over_current_change   : 1;
 478                         unsigned reserved                   : 27;
 479                 } b;
 480         } flags; /*!< Internal HCD Flags */
 481
 482         struct ifxhcd_hc ifxhc[MAX_EPS_CHANNELS];         /*!< Array of pointers to the host channel descriptors. Allows accessing
 483                                                                a host channel descriptor given the host channel number. This is
 484                                                                useful in interrupt handlers.
 485                                                            */
 486         uint8_t   *status_buf;                            /*!< Buffer to use for any data received during the status phase of a
 487                                                                control transfer. Normally no data is transferred during the status
 488                                                                phase. This buffer is used as a bit bucket.
 489                                                            */
 490                 #define IFXHCD_STATUS_BUF_SIZE 64             /*!< buffer size of status phase in CTRL xfer */
 491
 492         struct list_head epqh_list_all;
 493         struct list_head epqh_list_np;
 494         struct list_head epqh_list_intr;
 495         #ifdef __EN_ISOC__
 496                 struct list_head epqh_list_isoc;
 497         #endif
 498
 499         uint32_t lastframe;
 500
 501         uint16_t pkt_remaining;
 502         uint16_t pkt_remaining_reload;
 503         uint16_t pkt_remaining_reload_hs;
 504         uint16_t pkt_remaining_reload_fs;
 505         uint16_t pkt_remaining_reload_ls;
 506                 #define PKT_REMAINING_RELOAD_HS  88
 507                 #define PKT_REMAINING_RELOAD_FS  10
 508                 #define PKT_REMAINING_RELOAD_LS  20
 509         #ifdef __EN_ISOC__
 510                 uint8_t isoc_ep_count;
 511         #endif
 512
 513         spinlock_t      epqh_list_lock;
 514         spinlock_t      epqh_list_all_lock;
 515
 516         struct timer_list host_probe_timer;
 517         struct timer_list autoprobe_timer;
 518
 519         unsigned        power_status;
 520         int             probe_sec;
 521         int             autoprobe_sec;
 522         #ifdef __DYN_SOF_INTR__
 523                 uint32_t dyn_sof_count;
 524                 #define DYN_SOF_COUNT_DEF 40000
 525         #endif
 526         struct tasklet_struct  tasklet_select_eps;        /*!<  Tasket to do a reset */
 527         struct tasklet_struct  tasklet_free_epqh_list ;        /*!<  Tasket to do a reset */
 528         unsigned disconnecting     : 1 ;
 529
 530         uint8_t              pkt_count_limit_bo;
 531         uint8_t              pkt_count_limit_bi;
 532 } ifxhcd_hcd_t;
 533
 534 /* Gets the ifxhcd_hcd from a struct usb_hcd */
 535 static inline ifxhcd_hcd_t *syshcd_to_ifxhcd(struct usb_hcd *syshcd)
 536 {
 537         return (ifxhcd_hcd_t *)(syshcd->hcd_priv[0]);
 538 }
 539
 540 /* Gets the struct usb_hcd that contains a ifxhcd_hcd_t. */
 541 static inline struct usb_hcd *ifxhcd_to_syshcd(ifxhcd_hcd_t *ifxhcd)
 542 {
 543         return (struct usb_hcd *)(ifxhcd->syshcd);
 544 }
 545
 546
 547 extern ifxhcd_epqh_t * sysep_to_epqh(ifxhcd_hcd_t *_ifxhcd, struct usb_host_endpoint *_sysep);
 548
 549 /* HCD Create/Destroy Functions */
 550         extern int  ifxhcd_init  (ifxhcd_hcd_t *_ifxhcd);
 551         extern void ifxhcd_remove(ifxhcd_hcd_t *_ifxhcd);
 552
 553 /*Linux HC Driver API Functions */
 554
 555 extern int  ifxhcd_start(struct usb_hcd *hcd);
 556 extern void ifxhcd_stop (struct usb_hcd *hcd);
 557 extern int  ifxhcd_get_frame_number(struct usb_hcd *hcd);
 558
 559
 560 /*!
 561    \brief This function does the setup for a data transfer for a host channel and
 562   starts the transfer. May be called in either Slave mode or DMA mode. In
 563   Slave mode, the caller must ensure that there is sufficient space in the
 564   request queue and Tx Data FIFO.
 565
 566   For an OUT transfer in Slave mode, it loads a data packet into the
 567   appropriate FIFO. If necessary, additional data packets will be loaded in
 568   the Host ISR.
 569
 570   For an IN transfer in Slave mode, a data packet is requested. The data
 571   packets are unloaded from the Rx FIFO in the Host ISR. If necessary,
 572   additional data packets are requested in the Host ISR.
 573
 574   For a PING transfer in Slave mode, the Do Ping bit is set in the HCTSIZ
 575   register along with a packet count of 1 and the channel is enabled. This
 576   causes a single PING transaction to occur. Other fields in HCTSIZ are
 577   simply set to 0 since no data transfer occurs in this case.
 578
 579   For a PING transfer in DMA mode, the HCTSIZ register is initialized with
 580   all the information required to perform the subsequent data transfer. In
 581   addition, the Do Ping bit is set in the HCTSIZ register. In this case, the
 582   controller performs the entire PING protocol, then starts the data
 583   transfer.
 584
 585   @param _ifxhc Information needed to initialize the host channel. The xfer_len
 586   value may be reduced to accommodate the max widths of the XferSize and
 587   PktCnt fields in the HCTSIZn register. The multi_count value may be changed
 588   to reflect the final xfer_len value.
 589  */
 590 extern void ifxhcd_hc_start(ifxhcd_hcd_t *_ifxhcd, ifxhcd_hc_t *_ifxhc);
 591
 592 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 593 extern int ifxhcd_urb_enqueue(struct usb_hcd *_syshcd, struct usb_host_endpoint *_sysep, struct urb *_urb, gfp_t mem_flags);
 594 extern int ifxhcd_urb_dequeue(struct usb_hcd *_syshcd, struct urb *_urb);
 595 #else
 596 extern int ifxhcd_urb_enqueue(struct usb_hcd *_syshcd, struct urb *_urb, gfp_t mem_flags);
 597 extern int ifxhcd_urb_dequeue(struct usb_hcd *_syshcd, struct urb *_urb, int status);
 598 #endif
 599 extern irqreturn_t ifxhcd_irq(struct usb_hcd *_syshcd);
 600
 601 extern void ifxhcd_endpoint_disable(struct usb_hcd *_syshcd, struct usb_host_endpoint *_sysep);
 602
 603 extern int ifxhcd_hub_status_data(struct usb_hcd *_syshcd, char *_buf);
 604 extern int ifxhcd_hub_control( struct usb_hcd *_syshcd,
 605                                u16             _typeReq,
 606                                u16             _wValue,
 607                                u16             _wIndex,
 608                                char           *_buf,
 609                                u16             _wLength);
 610
 611 /*@}*/
 612
 613 /*! \brief Transaction Execution Functions */
 614 /*@{*/
 615 extern void                      ifxhcd_complete_urb       (ifxhcd_hcd_t *_ifxhcd, ifxhcd_urbd_t *_urbd,  int _status);
 616
 617 /*!
 618    \brief Clears the transfer state for a host channel. This function is normally
 619   called after a transfer is done and the host channel is being released.
 620  */
 621 extern void ifxhcd_hc_cleanup(ifxusb_core_if_t *_core_if, ifxhcd_hc_t *_ifxhc);
 622
 623 /*!
 624    \brief Attempts to halt a host channel. This function should only be called in
 625   Slave mode or to abort a transfer in either Slave mode or DMA mode. Under
 626   normal circumstances in DMA mode, the controller halts the channel when the
 627   transfer is complete or a condition occurs that requires application
 628   intervention.
 629
 630   In DMA mode, always sets the Channel Enable and Channel Disable bits of the
 631   HCCHARn register. The controller ensures there is space in the request
 632   queue before submitting the halt request.
 633
 634   Some time may elapse before the core flushes any posted requests for this
 635   host channel and halts. The Channel Halted interrupt handler completes the
 636   deactivation of the host channel.
 637  */
 638 extern int ifxhcd_hc_halt(ifxusb_core_if_t *_core_if,
 639                     ifxhcd_hc_t *_ifxhc,
 640                     ifxhcd_halt_status_e _halt_status);
 641
 642 /*!
 643    \brief Prepares a host channel for transferring packets to/from a specific
 644   endpoint. The HCCHARn register is set up with the characteristics specified
 645   in _ifxhc. Host channel interrupts that may need to be serviced while this
 646   transfer is in progress are enabled.
 647  */
 648 extern void ifxhcd_hc_init(ifxusb_core_if_t *_core_if, ifxhcd_hc_t *_ifxhc);
 649
 650 /*!
 651    \brief This function is called to handle the disconnection of host port.
 652  */
 653 int32_t ifxhcd_disconnect(ifxhcd_hcd_t *_ifxhcd);
 654 /*@}*/
 655
 656 /*!  \brief Interrupt Handler Functions */
 657 /*@{*/
 658 extern irqreturn_t ifxhcd_oc_irq(int _irq, void *_dev);
 659
 660 extern int32_t ifxhcd_handle_oc_intr(ifxhcd_hcd_t *_ifxhcd);
 661 extern int32_t ifxhcd_handle_intr   (ifxhcd_hcd_t *_ifxhcd);
 662 /*@}*/
 663
 664
 665 /*! \brief Schedule Queue Functions */
 666 /*@{*/
 667 extern void           ifxhcd_epqh_free   (ifxhcd_epqh_t *_epqh);
 668 extern void           select_eps      (ifxhcd_hcd_t *_ifxhcd);
 669 extern void           ifxhcd_epqh_idle(ifxhcd_epqh_t *_epqh);
 670 extern void           ifxhcd_epqh_idle_periodic(ifxhcd_epqh_t *_epqh);
 671 extern ifxhcd_epqh_t *ifxhcd_urbd_create (ifxhcd_hcd_t *_ifxhcd,struct urb *_urb);
 672 /*@}*/
 673
 674 /*! \brief Gets the usb_host_endpoint associated with an URB. */
 675 static inline struct usb_host_endpoint *ifxhcd_urb_to_endpoint(struct urb *_urb)
 676 {
 677         struct usb_device *dev = _urb->dev;
 678         int    ep_num = usb_pipeendpoint(_urb->pipe);
 679
 680         return (usb_pipein(_urb->pipe))?(dev->ep_in[ep_num]):(dev->ep_out[ep_num]);
 681 }
 682
 683 /*!
 684  * \brief Gets the endpoint number from a _bEndpointAddress argument. The endpoint is
 685  * qualified with its direction (possible 32 endpoints per device).
 686  */
 687 #define ifxhcd_ep_addr_to_endpoint(_bEndpointAddress_) ((_bEndpointAddress_ & USB_ENDPOINT_NUMBER_MASK) | \
 688                                                        ((_bEndpointAddress_ & USB_DIR_IN) != 0) << 4)
 689
 690
 691
 692 /*! Internal debug function */
 693 void         ifxhcd_dump_state(ifxhcd_hcd_t *_ifxhcd);
 694
 695 /*@}*//*IFXUSB_HCD*/
 696
 697 extern struct usb_device *usb_alloc_dev  (struct usb_device *parent, struct usb_bus *, unsigned port);
 698 extern int                usb_add_hcd    (struct usb_hcd *syshcd, unsigned int irqnum, unsigned long irqflags);
 699 extern void               usb_remove_hcd (struct usb_hcd *syshcd);
 700 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 701 extern struct usb_hcd    *usb_create_hcd (const struct hc_driver *driver, struct device *dev, char *bus_name);
 702 #else
 703 extern struct usb_hcd    *usb_create_hcd (const struct hc_driver *driver, struct device *dev, const char *bus_name);
 704 #endif
 705
 706 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)
 707 extern void               usb_hcd_giveback_urb (struct usb_hcd *syshcd, struct urb *urb);
 708 #else
 709 extern void               usb_hcd_giveback_urb (struct usb_hcd *syshcd, struct urb *urb,int status);
 710 #endif
 711
 712 extern void               usb_put_hcd       (struct usb_hcd *syshcd);
 713 extern long               usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount);
 714 extern char *syserr(int errno);
 715
 716
 717
 718 static inline void INIT_EPQH_LIST_ALL(ifxhcd_hcd_t   *_ifxhcd)
 719 {
 720         spin_lock_init(&_ifxhcd->epqh_list_all_lock);
 721 }
 722 static inline void LOCK_EPQH_LIST_ALL(ifxhcd_hcd_t   *_ifxhcd)
 723 {
 724         spin_lock(&_ifxhcd->epqh_list_all_lock);
 725 }
 726 static inline void UNLOCK_EPQH_LIST_ALL(ifxhcd_hcd_t *_ifxhcd)
 727 {
 728         spin_unlock(&_ifxhcd->epqh_list_all_lock);
 729 }
 730
 731 static inline void INIT_EPQH_LIST(ifxhcd_hcd_t   *_ifxhcd)
 732 {
 733         spin_lock_init(&_ifxhcd->epqh_list_lock);
 734 }
 735 static inline void LOCK_EPQH_LIST(ifxhcd_hcd_t   *_ifxhcd)
 736 {
 737         spin_lock(&_ifxhcd->epqh_list_lock);
 738 }
 739 static inline void UNLOCK_EPQH_LIST(ifxhcd_hcd_t *_ifxhcd)
 740 {
 741         spin_unlock(&_ifxhcd->epqh_list_lock);
 742 }
 743
 744 static inline void INIT_URBD_LIST(ifxhcd_epqh_t    *_epqh)
 745 {
 746         spin_lock_init(&_epqh->urbd_list_lock);
 747 }
 748 static inline void LOCK_URBD_LIST(ifxhcd_epqh_t    *_epqh)
 749 {
 750         spin_lock(&_epqh->urbd_list_lock);
 751 }
 752 static inline void UNLOCK_URBD_LIST(ifxhcd_epqh_t  *_epqh)
 753 {
 754         spin_unlock(&_epqh->urbd_list_lock);
 755 }
 756
 757 #endif // __IFXHCD_H__
 758