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: releng/8.0/sys/dev/cxgb/cxgb_offload.h 183321 2008-09-24 01:19:08Z kmacy $
30
31 ***************************************************************************/
32
33 #ifndef _CXGB_OFFLOAD_H
34 #define _CXGB_OFFLOAD_H
35
36 #include <common/cxgb_version.h>
37 #include <cxgb_config.h>
38 #include <common/cxgb_tcb.h>
39 #include <t3cdev.h>
40
41 MALLOC_DECLARE(M_CXGB);
42
43 struct adapter;
44 struct cxgb_client;
45
46 void cxgb_offload_init(void);
47 void cxgb_offload_exit(void);
48
49 void cxgb_adapter_ofld(struct adapter *adapter);
50 void cxgb_adapter_unofld(struct adapter *adapter);
51 int cxgb_offload_activate(struct adapter *adapter);
52 void cxgb_offload_deactivate(struct adapter *adapter);
53 int cxgb_ofld_recv(struct t3cdev *dev, struct mbuf **m, int n);
54
55 void cxgb_set_dummy_ops(struct t3cdev *dev);
56
57
58 /*
59 * Client registration. Users of T3 driver must register themselves.
60 * The T3 driver will call the add function of every client for each T3
61 * adapter activated, passing up the t3cdev ptr. Each client fills out an
62 * array of callback functions to process CPL messages.
63 */
64
65 void cxgb_register_client(struct cxgb_client *client);
66 void cxgb_unregister_client(struct cxgb_client *client);
67 void cxgb_add_clients(struct t3cdev *tdev);
68 void cxgb_remove_clients(struct t3cdev *tdev);
69
70 typedef int (*cxgb_cpl_handler_func)(struct t3cdev *dev,
71 struct mbuf *m, void *ctx);
72
73 struct l2t_entry;
74 struct cxgb_client {
75 char *name;
76 void (*add) (struct t3cdev *);
77 void (*remove) (struct t3cdev *);
78 cxgb_cpl_handler_func *handlers;
79 int (*redirect)(void *ctx, struct rtentry *old,
80 struct rtentry *new,
81 struct l2t_entry *l2t);
82 TAILQ_ENTRY(cxgb_client) client_entry;
83 };
84
85 /*
86 * TID allocation services.
87 */
88 int cxgb_alloc_atid(struct t3cdev *dev, struct cxgb_client *client,
89 void *ctx);
90 int cxgb_alloc_stid(struct t3cdev *dev, struct cxgb_client *client,
91 void *ctx);
92 void *cxgb_free_atid(struct t3cdev *dev, int atid);
93 void cxgb_free_stid(struct t3cdev *dev, int stid);
94 void *cxgb_get_lctx(struct t3cdev *tdev, int stid);
95 void cxgb_insert_tid(struct t3cdev *dev, struct cxgb_client *client,
96 void *ctx,
97 unsigned int tid);
98 void cxgb_queue_tid_release(struct t3cdev *dev, unsigned int tid);
99 void cxgb_remove_tid(struct t3cdev *dev, void *ctx, unsigned int tid);
100
101 struct toe_tid_entry {
102 struct cxgb_client *client;
103 void *ctx;
104 };
105
106 /* CPL message priority levels */
107 enum {
108 CPL_PRIORITY_DATA = 0, /* data messages */
109 CPL_PRIORITY_SETUP = 1, /* connection setup messages */
110 CPL_PRIORITY_TEARDOWN = 0, /* connection teardown messages */
111 CPL_PRIORITY_LISTEN = 1, /* listen start/stop messages */
112 CPL_PRIORITY_ACK = 1, /* RX ACK messages */
113 CPL_PRIORITY_CONTROL = 1 /* offload control messages */
114 };
115
116 /* Flags for return value of CPL message handlers */
117 enum {
118 CPL_RET_BUF_DONE = 1, // buffer processing done, buffer may be freed
119 CPL_RET_BAD_MSG = 2, // bad CPL message (e.g., unknown opcode)
120 CPL_RET_UNKNOWN_TID = 4 // unexpected unknown TID
121 };
122
123 typedef int (*cpl_handler_func)(struct t3cdev *dev, struct mbuf *m);
124
125 /*
126 * Returns a pointer to the first byte of the CPL header in an sk_buff that
127 * contains a CPL message.
128 */
129 static inline void *cplhdr(struct mbuf *m)
130 {
131 return mtod(m, uint8_t *);
132 }
133
134 void t3_register_cpl_handler(unsigned int opcode, cpl_handler_func h);
135
136 union listen_entry {
137 struct toe_tid_entry toe_tid;
138 union listen_entry *next;
139 };
140
141 union active_open_entry {
142 struct toe_tid_entry toe_tid;
143 union active_open_entry *next;
144 };
145
146 /*
147 * Holds the size, base address, free list start, etc of the TID, server TID,
148 * and active-open TID tables for a offload device.
149 * The tables themselves are allocated dynamically.
150 */
151 struct tid_info {
152 struct toe_tid_entry *tid_tab;
153 unsigned int ntids;
154 volatile unsigned int tids_in_use;
155
156 union listen_entry *stid_tab;
157 unsigned int nstids;
158 unsigned int stid_base;
159
160 union active_open_entry *atid_tab;
161 unsigned int natids;
162 unsigned int atid_base;
163
164 /*
165 * The following members are accessed R/W so we put them in their own
166 * cache lines.
167 *
168 * XXX We could combine the atid fields above with the lock here since
169 * atids are use once (unlike other tids). OTOH the above fields are
170 * usually in cache due to tid_tab.
171 */
172 struct mtx atid_lock /* ____cacheline_aligned_in_smp */;
173 union active_open_entry *afree;
174 unsigned int atids_in_use;
175
176 struct mtx stid_lock /*____cacheline_aligned */;
177 union listen_entry *sfree;
178 unsigned int stids_in_use;
179 };
180
181 struct t3c_data {
182 struct t3cdev *dev;
183 unsigned int tx_max_chunk; /* max payload for TX_DATA */
184 unsigned int max_wrs; /* max in-flight WRs per connection */
185 unsigned int nmtus;
186 const unsigned short *mtus;
187 struct tid_info tid_maps;
188
189 struct toe_tid_entry *tid_release_list;
190 struct mtx tid_release_lock;
191 struct task tid_release_task;
192 };
193
194 /*
195 * t3cdev -> toe_data accessor
196 */
197 #define T3C_DATA(dev) (*(struct t3c_data **)&(dev)->l4opt)
198
199 /*
200 * Map an ATID or STID to their entries in the corresponding TID tables.
201 */
202 static inline union active_open_entry *atid2entry(const struct tid_info *t,
203 unsigned int atid)
204 {
205 return &t->atid_tab[atid - t->atid_base];
206 }
207
208
209 static inline union listen_entry *stid2entry(const struct tid_info *t,
210 unsigned int stid)
211 {
212 return &t->stid_tab[stid - t->stid_base];
213 }
214
215 /*
216 * Find the connection corresponding to a TID.
217 */
218 static inline struct toe_tid_entry *lookup_tid(const struct tid_info *t,
219 unsigned int tid)
220 {
221 return tid < t->ntids ? &(t->tid_tab[tid]) : NULL;
222 }
223
224 /*
225 * Find the connection corresponding to a server TID.
226 */
227 static inline struct toe_tid_entry *lookup_stid(const struct tid_info *t,
228 unsigned int tid)
229 {
230 if (tid < t->stid_base || tid >= t->stid_base + t->nstids)
231 return NULL;
232 return &(stid2entry(t, tid)->toe_tid);
233 }
234
235 /*
236 * Find the connection corresponding to an active-open TID.
237 */
238 static inline struct toe_tid_entry *lookup_atid(const struct tid_info *t,
239 unsigned int tid)
240 {
241 if (tid < t->atid_base || tid >= t->atid_base + t->natids)
242 return NULL;
243 return &(atid2entry(t, tid)->toe_tid);
244 }
245
246 void *cxgb_alloc_mem(unsigned long size);
247 void cxgb_free_mem(void *addr);
248 void cxgb_neigh_update(struct rtentry *rt, uint8_t *enaddr, struct sockaddr *sa);
249 void cxgb_redirect(struct rtentry *old, struct rtentry *new, struct sockaddr *sa);
250 int process_rx(struct t3cdev *dev, struct mbuf **m, int n);
251 int attach_t3cdev(struct t3cdev *dev);
252 void detach_t3cdev(struct t3cdev *dev);
253
254 #define CXGB_UNIMPLEMENTED() panic("IMPLEMENT: %s:%s:%d", __FUNCTION__, __FILE__, __LINE__)
255 #endif
Cache object: 703d9217baa62b1a58e24b0b0dc1f9a5
|