kernel/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-2015 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  * This file may also be available under a different license from Cavium.
  20  * Contact Cavium, Inc. for more information
  21  **********************************************************************/
  22
  23 /*! \file response_manager.h
  24  *  \brief Host Driver:  Response queues for host instructions.
  25  */
  26
  27 #ifndef __RESPONSE_MANAGER_H__
  28 #define __RESPONSE_MANAGER_H__
  29
  30 /** Maximum ordered requests to process in every invocation of
  31  * lio_process_ordered_list(). The function will continue to process requests
  32  * as long as it can find one that has finished processing. If it keeps
  33  * finding requests that have completed, the function can run for ever. The
  34  * value defined here sets an upper limit on the number of requests it can
  35  * process before it returns control to the poll thread.
  36  */
  37 #define  MAX_ORD_REQS_TO_PROCESS   4096
  38
  39 /** Head of a response list. There are several response lists in the
  40  *  system. One for each response order- Unordered, ordered
  41  *  and 1 for noresponse entries on each instruction queue.
  42  */
  43 struct octeon_response_list {
  44         /** List structure to add delete pending entries to */
  45         struct list_head head;
  46
  47         /** A lock for this response list */
  48         spinlock_t lock;
  49
  50         atomic_t pending_req_count;
  51 };
  52
  53 /** The type of response list.
  54  */
  55 enum {
  56         OCTEON_ORDERED_LIST = 0,
  57         OCTEON_UNORDERED_NONBLOCKING_LIST = 1,
  58         OCTEON_UNORDERED_BLOCKING_LIST = 2,
  59         OCTEON_ORDERED_SC_LIST = 3
  60 };
  61
  62 /** Response Order values for a Octeon Request. */
  63 enum {
  64         OCTEON_RESP_ORDERED = 0,
  65         OCTEON_RESP_UNORDERED = 1,
  66         OCTEON_RESP_NORESPONSE = 2
  67 };
  68
  69 /** Error codes  used in Octeon Host-Core communication.
  70  *
  71  *   31            16 15            0
  72  *   ---------------------------------
  73  *   |               |               |
  74  *   ---------------------------------
  75  *   Error codes are 32-bit wide. The upper 16-bits, called Major Error Number,
  76  *   are reserved to identify the group to which the error code belongs. The
  77  *   lower 16-bits, called Minor Error Number, carry the actual code.
  78  *
  79  *   So error codes are (MAJOR NUMBER << 16)| MINOR_NUMBER.
  80  */
  81
  82 /*------------   Error codes used by host driver   -----------------*/
  83 #define DRIVER_MAJOR_ERROR_CODE           0x0000
  84
  85 /**  A value of 0x00000000 indicates no error i.e. success */
  86 #define DRIVER_ERROR_NONE                 0x00000000
  87
  88 /**  (Major number: 0x0000; Minor Number: 0x0001) */
  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 /** Initialize the response lists. The number of response lists to create is
 124  * given by count.
 125  * @param octeon_dev      - the octeon device structure.
 126  */
 127 int octeon_setup_response_list(struct octeon_device *octeon_dev);
 128
 129 void octeon_delete_response_list(struct octeon_device *octeon_dev);
 130
 131 /** Check the status of first entry in the ordered list. If the instruction at
 132  * that entry finished processing or has timed-out, the entry is cleaned.
 133  * @param octeon_dev  - the octeon device structure.
 134  * @param force_quit - the request is forced to timeout if this is 1
 135  * @return 1 if the ordered list is empty, 0 otherwise.
 136  */
 137 int lio_process_ordered_list(struct octeon_device *octeon_dev,
 138                              u32 force_quit);
 139
 140 #endif