drivers/net/ethernet/cavium/liquidio/response_manager.h

   1 /**********************************************************************
   2  * Author: Cavium, Inc.
   3  *
   4  * Contact: support@cavium.com
   5  *          Please include "LiquidIO" in the subject.
   6  *
   7  * Copyright (c) 2003-2016 Cavium, Inc.
   8  *
   9  * This file is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License, Version 2, as
  11  * published by the Free Software Foundation.
  12  *
  13  * This file is distributed in the hope that it will be useful, but
  14  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  15  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  16  * NONINFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  **********************************************************************/
  19
  20 /*! \file response_manager.h
  21  *  \brief Host Driver:  Response queues for host instructions.
  22  */
  23
  24 #ifndef __RESPONSE_MANAGER_H__
  25 #define __RESPONSE_MANAGER_H__
  26
  27 /** Maximum ordered requests to process in every invocation of
  28  * lio_process_ordered_list(). The function will continue to process requests
  29  * as long as it can find one that has finished processing. If it keeps
  30  * finding requests that have completed, the function can run for ever. The
  31  * value defined here sets an upper limit on the number of requests it can
  32  * process before it returns control to the poll thread.
  33  */
  34 #define  MAX_ORD_REQS_TO_PROCESS   4096
  35
  36 /** Head of a response list. There are several response lists in the
  37  *  system. One for each response order- Unordered, ordered
  38  *  and 1 for noresponse entries on each instruction queue.
  39  */
  40 struct octeon_response_list {
  41         /** List structure to add delete pending entries to */
  42         struct list_head head;
  43
  44         /** A lock for this response list */
  45         spinlock_t lock;
  46
  47         atomic_t pending_req_count;
  48 };
  49
  50 /** The type of response list.
  51  */
  52 enum {
  53         OCTEON_ORDERED_LIST = 0,
  54         OCTEON_UNORDERED_NONBLOCKING_LIST = 1,
  55         OCTEON_UNORDERED_BLOCKING_LIST = 2,
  56         OCTEON_ORDERED_SC_LIST = 3,
  57         OCTEON_DONE_SC_LIST = 4,
  58         OCTEON_ZOMBIE_SC_LIST = 5
  59 };
  60
  61 /** Response Order values for a Octeon Request. */
  62 enum {
  63         OCTEON_RESP_ORDERED = 0,
  64         OCTEON_RESP_UNORDERED = 1,
  65         OCTEON_RESP_NORESPONSE = 2
  66 };
  67
  68 /** Error codes  used in Octeon Host-Core communication.
  69  *
  70  *   31            16 15            0
  71  *   ---------------------------------
  72  *   |               |               |
  73  *   ---------------------------------
  74  *   Error codes are 32-bit wide. The upper 16-bits, called Major Error Number,
  75  *   are reserved to identify the group to which the error code belongs. The
  76  *   lower 16-bits, called Minor Error Number, carry the actual code.
  77  *
  78  *   So error codes are (MAJOR NUMBER << 16)| MINOR_NUMBER.
  79  */
  80
  81 /*------------   Error codes used by host driver   -----------------*/
  82 #define DRIVER_MAJOR_ERROR_CODE           0x0000
  83 /*------   Error codes used by firmware (bits 15..0 set by firmware */
  84 #define FIRMWARE_MAJOR_ERROR_CODE         0x0001
  85
  86 /**  A value of 0x00000000 indicates no error i.e. success */
  87 #define DRIVER_ERROR_NONE                 0x00000000
  88
  89 #define DRIVER_ERROR_REQ_PENDING          0x00000001
  90 #define DRIVER_ERROR_REQ_TIMEOUT          0x00000003
  91 #define DRIVER_ERROR_REQ_EINTR            0x00000004
  92 #define DRIVER_ERROR_REQ_ENXIO            0x00000006
  93 #define DRIVER_ERROR_REQ_ENOMEM           0x0000000C
  94 #define DRIVER_ERROR_REQ_EINVAL           0x00000016
  95 #define DRIVER_ERROR_REQ_FAILED           0x000000ff
  96
  97 /** Status for a request.
  98  * If a request is not queued to Octeon by the driver, the driver returns
  99  * an error condition that's describe by one of the OCTEON_REQ_ERR_* value
 100  * below. If the request is successfully queued, the driver will return
 101  * a OCTEON_REQUEST_PENDING status. OCTEON_REQUEST_TIMEOUT and
 102  * OCTEON_REQUEST_INTERRUPTED are only returned by the driver if the
 103  * response for request failed to arrive before a time-out period or if
 104  * the request processing * got interrupted due to a signal respectively.
 105  */
 106 enum {
 107         OCTEON_REQUEST_DONE = (DRIVER_ERROR_NONE),
 108         OCTEON_REQUEST_PENDING = (DRIVER_ERROR_REQ_PENDING),
 109         OCTEON_REQUEST_TIMEOUT = (DRIVER_ERROR_REQ_TIMEOUT),
 110         OCTEON_REQUEST_INTERRUPTED = (DRIVER_ERROR_REQ_EINTR),
 111         OCTEON_REQUEST_NO_DEVICE = (0x00000021),
 112         OCTEON_REQUEST_NOT_RUNNING,
 113         OCTEON_REQUEST_INVALID_IQ,
 114         OCTEON_REQUEST_INVALID_BUFCNT,
 115         OCTEON_REQUEST_INVALID_RESP_ORDER,
 116         OCTEON_REQUEST_NO_MEMORY,
 117         OCTEON_REQUEST_INVALID_BUFSIZE,
 118         OCTEON_REQUEST_NO_PENDING_ENTRY,
 119         OCTEON_REQUEST_NO_IQ_SPACE = (0x7FFFFFFF)
 120
 121 };
 122
 123 #define FIRMWARE_STATUS_CODE(status) \
 124         ((FIRMWARE_MAJOR_ERROR_CODE << 16) | (status))
 125
 126 /** Initialize the response lists. The number of response lists to create is
 127  * given by count.
 128  * @param octeon_dev      - the octeon device structure.
 129  */
 130 int octeon_setup_response_list(struct octeon_device *octeon_dev);
 131
 132 void octeon_delete_response_list(struct octeon_device *octeon_dev);
 133
 134 /** Check the status of first entry in the ordered list. If the instruction at
 135  * that entry finished processing or has timed-out, the entry is cleaned.
 136  * @param octeon_dev  - the octeon device structure.
 137  * @param force_quit - the request is forced to timeout if this is 1
 138  * @return 1 if the ordered list is empty, 0 otherwise.
 139  */
 140 int lio_process_ordered_list(struct octeon_device *octeon_dev,
 141                              u32 force_quit);
 142
 143 #endif