sys/dev/cxgb/cxgb_offload.h

   1
   2 /**************************************************************************
   3
   4 Copyright (c) 2007-2008, Chelsio Inc.
   5 All rights reserved.
   6
   7 Redistribution and use in source and binary forms, with or without
   8 modification, are permitted provided that the following conditions are met:
   9
  10  1. Redistributions of source code must retain the above copyright notice,
  11     this list of conditions and the following disclaimer.
  12
  13  2. Neither the name of the Chelsio Corporation nor the names of its
  14     contributors may be used to endorse or promote products derived from
  15     this software without specific prior written permission.
  16
  17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 POSSIBILITY OF SUCH DAMAGE.
  28
  29 $FreeBSD$
  30
  31 ***************************************************************************/
  32
  33 #ifndef _CXGB_OFFLOAD_H
  34 #define _CXGB_OFFLOAD_H
  35
  36 #include <common/cxgb_tcb.h>
  37 #include <t3cdev.h>
  38
  39 MALLOC_DECLARE(M_CXGB);
  40
  41 struct adapter;
  42 struct cxgb_client;
  43
  44 void cxgb_offload_init(void);
  45 void cxgb_offload_exit(void);
  46
  47 void cxgb_adapter_ofld(struct adapter *adapter);
  48 void cxgb_adapter_unofld(struct adapter *adapter);
  49 int cxgb_offload_activate(struct adapter *adapter);
  50 void cxgb_offload_deactivate(struct adapter *adapter);
  51 int cxgb_ofld_recv(struct t3cdev *dev, struct mbuf **m, int n);
  52
  53 void cxgb_set_dummy_ops(struct t3cdev *dev);
  54
  55
  56 /*
  57  * Client registration.  Users of T3 driver must register themselves.
  58  * The T3 driver will call the add function of every client for each T3
  59  * adapter activated, passing up the t3cdev ptr.  Each client fills out an
  60  * array of callback functions to process CPL messages.
  61  */
  62
  63 void cxgb_register_client(struct cxgb_client *client);
  64 void cxgb_unregister_client(struct cxgb_client *client);
  65 void cxgb_add_clients(struct t3cdev *tdev);
  66 void cxgb_remove_clients(struct t3cdev *tdev);
  67
  68 typedef int (*cxgb_cpl_handler_func)(struct t3cdev *dev,
  69                                       struct mbuf *m, void *ctx);
  70
  71 struct l2t_entry;
  72 struct cxgb_client {
  73         char                    *name;
  74         void                    (*add) (struct t3cdev *);
  75         void                    (*remove) (struct t3cdev *);
  76         cxgb_cpl_handler_func   *handlers;
  77         int                     (*redirect)(void *ctx, struct rtentry *old,
  78                                             struct rtentry *new,
  79                                             struct l2t_entry *l2t);
  80         TAILQ_ENTRY(cxgb_client)         client_entry;
  81 };
  82
  83 /*
  84  * TID allocation services.
  85  */
  86 int cxgb_alloc_atid(struct t3cdev *dev, struct cxgb_client *client,
  87                      void *ctx);
  88 int cxgb_alloc_stid(struct t3cdev *dev, struct cxgb_client *client,
  89                      void *ctx);
  90 void *cxgb_free_atid(struct t3cdev *dev, int atid);
  91 void cxgb_free_stid(struct t3cdev *dev, int stid);
  92 void *cxgb_get_lctx(struct t3cdev *tdev, int stid);
  93 void cxgb_insert_tid(struct t3cdev *dev, struct cxgb_client *client,
  94                       void *ctx,
  95         unsigned int tid);
  96 void cxgb_queue_tid_release(struct t3cdev *dev, unsigned int tid);
  97 void cxgb_remove_tid(struct t3cdev *dev, void *ctx, unsigned int tid);
  98
  99 struct toe_tid_entry {
 100         struct cxgb_client      *client;
 101         void                    *ctx;
 102 };
 103
 104 /* CPL message priority levels */
 105 enum {
 106         CPL_PRIORITY_DATA = 0,     /* data messages */
 107         CPL_PRIORITY_SETUP = 1,    /* connection setup messages */
 108         CPL_PRIORITY_TEARDOWN = 0, /* connection teardown messages */
 109         CPL_PRIORITY_LISTEN = 1,   /* listen start/stop messages */
 110         CPL_PRIORITY_ACK = 1,      /* RX ACK messages */
 111         CPL_PRIORITY_CONTROL = 1   /* offload control messages */
 112 };
 113
 114 /* Flags for return value of CPL message handlers */
 115 enum {
 116         CPL_RET_BUF_DONE = 1,   // buffer processing done, buffer may be freed
 117         CPL_RET_BAD_MSG = 2,    // bad CPL message (e.g., unknown opcode)
 118         CPL_RET_UNKNOWN_TID = 4 // unexpected unknown TID
 119 };
 120
 121 typedef int (*cpl_handler_func)(struct t3cdev *dev, struct mbuf *m);
 122
 123 /*
 124  * Returns a pointer to the first byte of the CPL header in an sk_buff that
 125  * contains a CPL message.
 126  */
 127 static inline void *cplhdr(struct mbuf *m)
 128 {
 129         return mtod(m, uint8_t *);
 130 }
 131
 132 void t3_register_cpl_handler(unsigned int opcode, cpl_handler_func h);
 133
 134 union listen_entry {
 135         struct toe_tid_entry toe_tid;
 136         union listen_entry *next;
 137 };
 138
 139 union active_open_entry {
 140         struct toe_tid_entry toe_tid;
 141         union active_open_entry *next;
 142 };
 143
 144 /*
 145  * Holds the size, base address, free list start, etc of the TID, server TID,
 146  * and active-open TID tables for a offload device.
 147  * The tables themselves are allocated dynamically.
 148  */
 149 struct tid_info {
 150         struct toe_tid_entry *tid_tab;
 151         unsigned int ntids;
 152         volatile unsigned int tids_in_use;
 153
 154         union listen_entry *stid_tab;
 155         unsigned int nstids;
 156         unsigned int stid_base;
 157
 158         union active_open_entry *atid_tab;
 159         unsigned int natids;
 160         unsigned int atid_base;
 161
 162         /*
 163          * The following members are accessed R/W so we put them in their own
 164          * cache lines.
 165          *
 166          * XXX We could combine the atid fields above with the lock here since
 167          * atids are use once (unlike other tids).  OTOH the above fields are
 168          * usually in cache due to tid_tab.
 169          */
 170         struct mtx atid_lock /* ____cacheline_aligned_in_smp */;
 171         union active_open_entry *afree;
 172         unsigned int atids_in_use;
 173
 174         struct mtx stid_lock /*____cacheline_aligned */;
 175         union listen_entry *sfree;
 176         unsigned int stids_in_use;
 177 };
 178
 179 struct t3c_data {
 180         struct t3cdev *dev;
 181         unsigned int tx_max_chunk;  /* max payload for TX_DATA */
 182         unsigned int max_wrs;       /* max in-flight WRs per connection */
 183         unsigned int nmtus;
 184         const unsigned short *mtus;
 185         struct tid_info tid_maps;
 186
 187         struct toe_tid_entry *tid_release_list;
 188         struct mtx tid_release_lock;
 189         struct task tid_release_task;
 190 };
 191
 192 /*
 193  * t3cdev -> toe_data accessor
 194  */
 195 #define T3C_DATA(dev) (*(struct t3c_data **)&(dev)->l4opt)
 196
 197 /*
 198  * Map an ATID or STID to their entries in the corresponding TID tables.
 199  */
 200 static inline union active_open_entry *atid2entry(const struct tid_info *t,
 201                                                   unsigned int atid)
 202 {
 203         return &t->atid_tab[atid - t->atid_base];
 204 }
 205
 206
 207 static inline union listen_entry *stid2entry(const struct tid_info *t,
 208                                              unsigned int stid)
 209 {
 210         return &t->stid_tab[stid - t->stid_base];
 211 }
 212
 213 /*
 214  * Find the connection corresponding to a TID.
 215  */
 216 static inline struct toe_tid_entry *lookup_tid(const struct tid_info *t,
 217                                                unsigned int tid)
 218 {
 219         return tid < t->ntids ? &(t->tid_tab[tid]) : NULL;
 220 }
 221
 222 /*
 223  * Find the connection corresponding to a server TID.
 224  */
 225 static inline struct toe_tid_entry *lookup_stid(const struct tid_info *t,
 226                                                 unsigned int tid)
 227 {
 228         if (tid < t->stid_base || tid >= t->stid_base + t->nstids)
 229                 return NULL;
 230         return &(stid2entry(t, tid)->toe_tid);
 231 }
 232
 233 /*
 234  * Find the connection corresponding to an active-open TID.
 235  */
 236 static inline struct toe_tid_entry *lookup_atid(const struct tid_info *t,
 237                                                 unsigned int tid)
 238 {
 239         if (tid < t->atid_base || tid >= t->atid_base + t->natids)
 240                 return NULL;
 241         return &(atid2entry(t, tid)->toe_tid);
 242 }
 243
 244 void *cxgb_alloc_mem(unsigned long size);
 245 void cxgb_free_mem(void *addr);
 246 void cxgb_neigh_update(struct rtentry *rt, uint8_t *enaddr, struct sockaddr *sa);
 247 void cxgb_redirect(struct rtentry *old, struct rtentry *new, struct sockaddr *sa);
 248 int process_rx(struct t3cdev *dev, struct mbuf **m, int n);
 249 int attach_t3cdev(struct t3cdev *dev);
 250 void detach_t3cdev(struct t3cdev *dev);
 251
 252 #define CXGB_UNIMPLEMENTED() panic("IMPLEMENT: %s:%s:%d", __FUNCTION__, __FILE__, __LINE__)
 253 #endif