Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1 | /* |
Divy Le Ray | 1d68e93 | 2007-01-30 19:44:35 -0800 | [diff] [blame] | 2 | * Copyright (c) 2006-2007 Chelsio, Inc. All rights reserved. |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 3 | * |
| 4 | * This software is available to you under a choice of one of two |
| 5 | * licenses. You may choose to be licensed under the terms of the GNU |
| 6 | * General Public License (GPL) Version 2, available from the file |
| 7 | * COPYING in the main directory of this source tree, or the |
| 8 | * OpenIB.org BSD license below: |
| 9 | * |
| 10 | * Redistribution and use in source and binary forms, with or |
| 11 | * without modification, are permitted provided that the following |
| 12 | * conditions are met: |
| 13 | * |
| 14 | * - Redistributions of source code must retain the above |
| 15 | * copyright notice, this list of conditions and the following |
| 16 | * disclaimer. |
| 17 | * |
| 18 | * - Redistributions in binary form must reproduce the above |
| 19 | * copyright notice, this list of conditions and the following |
| 20 | * disclaimer in the documentation and/or other materials |
| 21 | * provided with the distribution. |
| 22 | * |
| 23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 25 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| 26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| 27 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| 28 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| 29 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 30 | * SOFTWARE. |
| 31 | */ |
| 32 | |
| 33 | #include <linux/list.h> |
| 34 | #include <net/neighbour.h> |
| 35 | #include <linux/notifier.h> |
| 36 | #include <asm/atomic.h> |
| 37 | #include <linux/proc_fs.h> |
| 38 | #include <linux/if_vlan.h> |
| 39 | #include <net/netevent.h> |
| 40 | #include <linux/highmem.h> |
| 41 | #include <linux/vmalloc.h> |
| 42 | |
| 43 | #include "common.h" |
| 44 | #include "regs.h" |
| 45 | #include "cxgb3_ioctl.h" |
| 46 | #include "cxgb3_ctl_defs.h" |
| 47 | #include "cxgb3_defs.h" |
| 48 | #include "l2t.h" |
| 49 | #include "firmware_exports.h" |
| 50 | #include "cxgb3_offload.h" |
| 51 | |
| 52 | static LIST_HEAD(client_list); |
| 53 | static LIST_HEAD(ofld_dev_list); |
| 54 | static DEFINE_MUTEX(cxgb3_db_lock); |
| 55 | |
| 56 | static DEFINE_RWLOCK(adapter_list_lock); |
| 57 | static LIST_HEAD(adapter_list); |
| 58 | |
| 59 | static const unsigned int MAX_ATIDS = 64 * 1024; |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 60 | static const unsigned int ATID_BASE = 0x10000; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 61 | |
| 62 | static inline int offload_activated(struct t3cdev *tdev) |
| 63 | { |
| 64 | const struct adapter *adapter = tdev2adap(tdev); |
| 65 | |
| 66 | return (test_bit(OFFLOAD_DEVMAP_BIT, &adapter->open_device_map)); |
| 67 | } |
| 68 | |
| 69 | /** |
| 70 | * cxgb3_register_client - register an offload client |
| 71 | * @client: the client |
| 72 | * |
| 73 | * Add the client to the client list, |
| 74 | * and call backs the client for each activated offload device |
| 75 | */ |
| 76 | void cxgb3_register_client(struct cxgb3_client *client) |
| 77 | { |
| 78 | struct t3cdev *tdev; |
| 79 | |
| 80 | mutex_lock(&cxgb3_db_lock); |
| 81 | list_add_tail(&client->client_list, &client_list); |
| 82 | |
| 83 | if (client->add) { |
| 84 | list_for_each_entry(tdev, &ofld_dev_list, ofld_dev_list) { |
| 85 | if (offload_activated(tdev)) |
| 86 | client->add(tdev); |
| 87 | } |
| 88 | } |
| 89 | mutex_unlock(&cxgb3_db_lock); |
| 90 | } |
| 91 | |
| 92 | EXPORT_SYMBOL(cxgb3_register_client); |
| 93 | |
| 94 | /** |
| 95 | * cxgb3_unregister_client - unregister an offload client |
| 96 | * @client: the client |
| 97 | * |
| 98 | * Remove the client to the client list, |
| 99 | * and call backs the client for each activated offload device. |
| 100 | */ |
| 101 | void cxgb3_unregister_client(struct cxgb3_client *client) |
| 102 | { |
| 103 | struct t3cdev *tdev; |
| 104 | |
| 105 | mutex_lock(&cxgb3_db_lock); |
| 106 | list_del(&client->client_list); |
| 107 | |
| 108 | if (client->remove) { |
| 109 | list_for_each_entry(tdev, &ofld_dev_list, ofld_dev_list) { |
| 110 | if (offload_activated(tdev)) |
| 111 | client->remove(tdev); |
| 112 | } |
| 113 | } |
| 114 | mutex_unlock(&cxgb3_db_lock); |
| 115 | } |
| 116 | |
| 117 | EXPORT_SYMBOL(cxgb3_unregister_client); |
| 118 | |
| 119 | /** |
| 120 | * cxgb3_add_clients - activate registered clients for an offload device |
| 121 | * @tdev: the offload device |
| 122 | * |
| 123 | * Call backs all registered clients once a offload device is activated |
| 124 | */ |
| 125 | void cxgb3_add_clients(struct t3cdev *tdev) |
| 126 | { |
| 127 | struct cxgb3_client *client; |
| 128 | |
| 129 | mutex_lock(&cxgb3_db_lock); |
| 130 | list_for_each_entry(client, &client_list, client_list) { |
| 131 | if (client->add) |
| 132 | client->add(tdev); |
| 133 | } |
| 134 | mutex_unlock(&cxgb3_db_lock); |
| 135 | } |
| 136 | |
| 137 | /** |
| 138 | * cxgb3_remove_clients - deactivates registered clients |
| 139 | * for an offload device |
| 140 | * @tdev: the offload device |
| 141 | * |
| 142 | * Call backs all registered clients once a offload device is deactivated |
| 143 | */ |
| 144 | void cxgb3_remove_clients(struct t3cdev *tdev) |
| 145 | { |
| 146 | struct cxgb3_client *client; |
| 147 | |
| 148 | mutex_lock(&cxgb3_db_lock); |
| 149 | list_for_each_entry(client, &client_list, client_list) { |
| 150 | if (client->remove) |
| 151 | client->remove(tdev); |
| 152 | } |
| 153 | mutex_unlock(&cxgb3_db_lock); |
| 154 | } |
| 155 | |
| 156 | static struct net_device *get_iff_from_mac(struct adapter *adapter, |
| 157 | const unsigned char *mac, |
| 158 | unsigned int vlan) |
| 159 | { |
| 160 | int i; |
| 161 | |
| 162 | for_each_port(adapter, i) { |
Dan Aloni | 5c15bde | 2007-03-02 20:44:51 -0800 | [diff] [blame] | 163 | struct vlan_group *grp; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 164 | struct net_device *dev = adapter->port[i]; |
| 165 | const struct port_info *p = netdev_priv(dev); |
| 166 | |
| 167 | if (!memcmp(dev->dev_addr, mac, ETH_ALEN)) { |
| 168 | if (vlan && vlan != VLAN_VID_MASK) { |
| 169 | grp = p->vlan_grp; |
Dan Aloni | 5c15bde | 2007-03-02 20:44:51 -0800 | [diff] [blame] | 170 | dev = NULL; |
| 171 | if (grp) |
| 172 | dev = vlan_group_get_device(grp, vlan); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 173 | } else |
| 174 | while (dev->master) |
| 175 | dev = dev->master; |
| 176 | return dev; |
| 177 | } |
| 178 | } |
| 179 | return NULL; |
| 180 | } |
| 181 | |
| 182 | static int cxgb_ulp_iscsi_ctl(struct adapter *adapter, unsigned int req, |
| 183 | void *data) |
| 184 | { |
| 185 | int ret = 0; |
| 186 | struct ulp_iscsi_info *uiip = data; |
| 187 | |
| 188 | switch (req) { |
| 189 | case ULP_ISCSI_GET_PARAMS: |
| 190 | uiip->pdev = adapter->pdev; |
| 191 | uiip->llimit = t3_read_reg(adapter, A_ULPRX_ISCSI_LLIMIT); |
| 192 | uiip->ulimit = t3_read_reg(adapter, A_ULPRX_ISCSI_ULIMIT); |
| 193 | uiip->tagmask = t3_read_reg(adapter, A_ULPRX_ISCSI_TAGMASK); |
| 194 | /* |
| 195 | * On tx, the iscsi pdu has to be <= tx page size and has to |
| 196 | * fit into the Tx PM FIFO. |
| 197 | */ |
| 198 | uiip->max_txsz = min(adapter->params.tp.tx_pg_size, |
| 199 | t3_read_reg(adapter, A_PM1_TX_CFG) >> 17); |
| 200 | /* on rx, the iscsi pdu has to be < rx page size and the |
| 201 | whole pdu + cpl headers has to fit into one sge buffer */ |
| 202 | uiip->max_rxsz = min_t(unsigned int, |
| 203 | adapter->params.tp.rx_pg_size, |
| 204 | (adapter->sge.qs[0].fl[1].buf_size - |
| 205 | sizeof(struct cpl_rx_data) * 2 - |
| 206 | sizeof(struct cpl_rx_data_ddp))); |
| 207 | break; |
| 208 | case ULP_ISCSI_SET_PARAMS: |
| 209 | t3_write_reg(adapter, A_ULPRX_ISCSI_TAGMASK, uiip->tagmask); |
| 210 | break; |
| 211 | default: |
| 212 | ret = -EOPNOTSUPP; |
| 213 | } |
| 214 | return ret; |
| 215 | } |
| 216 | |
| 217 | /* Response queue used for RDMA events. */ |
| 218 | #define ASYNC_NOTIF_RSPQ 0 |
| 219 | |
| 220 | static int cxgb_rdma_ctl(struct adapter *adapter, unsigned int req, void *data) |
| 221 | { |
| 222 | int ret = 0; |
| 223 | |
| 224 | switch (req) { |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 225 | case RDMA_GET_PARAMS: { |
| 226 | struct rdma_info *rdma = data; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 227 | struct pci_dev *pdev = adapter->pdev; |
| 228 | |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 229 | rdma->udbell_physbase = pci_resource_start(pdev, 2); |
| 230 | rdma->udbell_len = pci_resource_len(pdev, 2); |
| 231 | rdma->tpt_base = |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 232 | t3_read_reg(adapter, A_ULPTX_TPT_LLIMIT); |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 233 | rdma->tpt_top = t3_read_reg(adapter, A_ULPTX_TPT_ULIMIT); |
| 234 | rdma->pbl_base = |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 235 | t3_read_reg(adapter, A_ULPTX_PBL_LLIMIT); |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 236 | rdma->pbl_top = t3_read_reg(adapter, A_ULPTX_PBL_ULIMIT); |
| 237 | rdma->rqt_base = t3_read_reg(adapter, A_ULPRX_RQ_LLIMIT); |
| 238 | rdma->rqt_top = t3_read_reg(adapter, A_ULPRX_RQ_ULIMIT); |
| 239 | rdma->kdb_addr = adapter->regs + A_SG_KDOORBELL; |
| 240 | rdma->pdev = pdev; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 241 | break; |
| 242 | } |
| 243 | case RDMA_CQ_OP:{ |
| 244 | unsigned long flags; |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 245 | struct rdma_cq_op *rdma = data; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 246 | |
| 247 | /* may be called in any context */ |
| 248 | spin_lock_irqsave(&adapter->sge.reg_lock, flags); |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 249 | ret = t3_sge_cqcntxt_op(adapter, rdma->id, rdma->op, |
| 250 | rdma->credits); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 251 | spin_unlock_irqrestore(&adapter->sge.reg_lock, flags); |
| 252 | break; |
| 253 | } |
| 254 | case RDMA_GET_MEM:{ |
| 255 | struct ch_mem_range *t = data; |
| 256 | struct mc7 *mem; |
| 257 | |
| 258 | if ((t->addr & 7) || (t->len & 7)) |
| 259 | return -EINVAL; |
| 260 | if (t->mem_id == MEM_CM) |
| 261 | mem = &adapter->cm; |
| 262 | else if (t->mem_id == MEM_PMRX) |
| 263 | mem = &adapter->pmrx; |
| 264 | else if (t->mem_id == MEM_PMTX) |
| 265 | mem = &adapter->pmtx; |
| 266 | else |
| 267 | return -EINVAL; |
| 268 | |
| 269 | ret = |
| 270 | t3_mc7_bd_read(mem, t->addr / 8, t->len / 8, |
| 271 | (u64 *) t->buf); |
| 272 | if (ret) |
| 273 | return ret; |
| 274 | break; |
| 275 | } |
| 276 | case RDMA_CQ_SETUP:{ |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 277 | struct rdma_cq_setup *rdma = data; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 278 | |
| 279 | spin_lock_irq(&adapter->sge.reg_lock); |
| 280 | ret = |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 281 | t3_sge_init_cqcntxt(adapter, rdma->id, |
| 282 | rdma->base_addr, rdma->size, |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 283 | ASYNC_NOTIF_RSPQ, |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 284 | rdma->ovfl_mode, rdma->credits, |
| 285 | rdma->credit_thres); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 286 | spin_unlock_irq(&adapter->sge.reg_lock); |
| 287 | break; |
| 288 | } |
| 289 | case RDMA_CQ_DISABLE: |
| 290 | spin_lock_irq(&adapter->sge.reg_lock); |
| 291 | ret = t3_sge_disable_cqcntxt(adapter, *(unsigned int *)data); |
| 292 | spin_unlock_irq(&adapter->sge.reg_lock); |
| 293 | break; |
| 294 | case RDMA_CTRL_QP_SETUP:{ |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 295 | struct rdma_ctrlqp_setup *rdma = data; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 296 | |
| 297 | spin_lock_irq(&adapter->sge.reg_lock); |
| 298 | ret = t3_sge_init_ecntxt(adapter, FW_RI_SGEEC_START, 0, |
| 299 | SGE_CNTXT_RDMA, |
| 300 | ASYNC_NOTIF_RSPQ, |
Stephen Hemminger | 9265fab | 2007-10-08 16:22:29 -0700 | [diff] [blame] | 301 | rdma->base_addr, rdma->size, |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 302 | FW_RI_TID_START, 1, 0); |
| 303 | spin_unlock_irq(&adapter->sge.reg_lock); |
| 304 | break; |
| 305 | } |
| 306 | default: |
| 307 | ret = -EOPNOTSUPP; |
| 308 | } |
| 309 | return ret; |
| 310 | } |
| 311 | |
| 312 | static int cxgb_offload_ctl(struct t3cdev *tdev, unsigned int req, void *data) |
| 313 | { |
| 314 | struct adapter *adapter = tdev2adap(tdev); |
| 315 | struct tid_range *tid; |
| 316 | struct mtutab *mtup; |
| 317 | struct iff_mac *iffmacp; |
| 318 | struct ddp_params *ddpp; |
| 319 | struct adap_ports *ports; |
Divy Le Ray | e22bb45 | 2007-08-21 20:49:21 -0700 | [diff] [blame] | 320 | struct ofld_page_info *rx_page_info; |
| 321 | struct tp_params *tp = &adapter->params.tp; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 322 | int i; |
| 323 | |
| 324 | switch (req) { |
| 325 | case GET_MAX_OUTSTANDING_WR: |
| 326 | *(unsigned int *)data = FW_WR_NUM; |
| 327 | break; |
| 328 | case GET_WR_LEN: |
| 329 | *(unsigned int *)data = WR_FLITS; |
| 330 | break; |
| 331 | case GET_TX_MAX_CHUNK: |
| 332 | *(unsigned int *)data = 1 << 20; /* 1MB */ |
| 333 | break; |
| 334 | case GET_TID_RANGE: |
| 335 | tid = data; |
| 336 | tid->num = t3_mc5_size(&adapter->mc5) - |
| 337 | adapter->params.mc5.nroutes - |
| 338 | adapter->params.mc5.nfilters - adapter->params.mc5.nservers; |
| 339 | tid->base = 0; |
| 340 | break; |
| 341 | case GET_STID_RANGE: |
| 342 | tid = data; |
| 343 | tid->num = adapter->params.mc5.nservers; |
| 344 | tid->base = t3_mc5_size(&adapter->mc5) - tid->num - |
| 345 | adapter->params.mc5.nfilters - adapter->params.mc5.nroutes; |
| 346 | break; |
| 347 | case GET_L2T_CAPACITY: |
| 348 | *(unsigned int *)data = 2048; |
| 349 | break; |
| 350 | case GET_MTUS: |
| 351 | mtup = data; |
| 352 | mtup->size = NMTUS; |
| 353 | mtup->mtus = adapter->params.mtus; |
| 354 | break; |
| 355 | case GET_IFF_FROM_MAC: |
| 356 | iffmacp = data; |
| 357 | iffmacp->dev = get_iff_from_mac(adapter, iffmacp->mac_addr, |
| 358 | iffmacp->vlan_tag & |
| 359 | VLAN_VID_MASK); |
| 360 | break; |
| 361 | case GET_DDP_PARAMS: |
| 362 | ddpp = data; |
| 363 | ddpp->llimit = t3_read_reg(adapter, A_ULPRX_TDDP_LLIMIT); |
| 364 | ddpp->ulimit = t3_read_reg(adapter, A_ULPRX_TDDP_ULIMIT); |
| 365 | ddpp->tag_mask = t3_read_reg(adapter, A_ULPRX_TDDP_TAGMASK); |
| 366 | break; |
| 367 | case GET_PORTS: |
| 368 | ports = data; |
| 369 | ports->nports = adapter->params.nports; |
| 370 | for_each_port(adapter, i) |
| 371 | ports->lldevs[i] = adapter->port[i]; |
| 372 | break; |
| 373 | case ULP_ISCSI_GET_PARAMS: |
| 374 | case ULP_ISCSI_SET_PARAMS: |
| 375 | if (!offload_running(adapter)) |
| 376 | return -EAGAIN; |
| 377 | return cxgb_ulp_iscsi_ctl(adapter, req, data); |
| 378 | case RDMA_GET_PARAMS: |
| 379 | case RDMA_CQ_OP: |
| 380 | case RDMA_CQ_SETUP: |
| 381 | case RDMA_CQ_DISABLE: |
| 382 | case RDMA_CTRL_QP_SETUP: |
| 383 | case RDMA_GET_MEM: |
| 384 | if (!offload_running(adapter)) |
| 385 | return -EAGAIN; |
| 386 | return cxgb_rdma_ctl(adapter, req, data); |
Divy Le Ray | e22bb45 | 2007-08-21 20:49:21 -0700 | [diff] [blame] | 387 | case GET_RX_PAGE_INFO: |
| 388 | rx_page_info = data; |
| 389 | rx_page_info->page_size = tp->rx_pg_size; |
| 390 | rx_page_info->num = tp->rx_num_pgs; |
| 391 | break; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 392 | default: |
| 393 | return -EOPNOTSUPP; |
| 394 | } |
| 395 | return 0; |
| 396 | } |
| 397 | |
| 398 | /* |
| 399 | * Dummy handler for Rx offload packets in case we get an offload packet before |
| 400 | * proper processing is setup. This complains and drops the packet as it isn't |
| 401 | * normal to get offload packets at this stage. |
| 402 | */ |
| 403 | static int rx_offload_blackhole(struct t3cdev *dev, struct sk_buff **skbs, |
| 404 | int n) |
| 405 | { |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 406 | while (n--) |
| 407 | dev_kfree_skb_any(skbs[n]); |
| 408 | return 0; |
| 409 | } |
| 410 | |
| 411 | static void dummy_neigh_update(struct t3cdev *dev, struct neighbour *neigh) |
| 412 | { |
| 413 | } |
| 414 | |
| 415 | void cxgb3_set_dummy_ops(struct t3cdev *dev) |
| 416 | { |
| 417 | dev->recv = rx_offload_blackhole; |
| 418 | dev->neigh_update = dummy_neigh_update; |
| 419 | } |
| 420 | |
| 421 | /* |
| 422 | * Free an active-open TID. |
| 423 | */ |
| 424 | void *cxgb3_free_atid(struct t3cdev *tdev, int atid) |
| 425 | { |
| 426 | struct tid_info *t = &(T3C_DATA(tdev))->tid_maps; |
| 427 | union active_open_entry *p = atid2entry(t, atid); |
| 428 | void *ctx = p->t3c_tid.ctx; |
| 429 | |
| 430 | spin_lock_bh(&t->atid_lock); |
| 431 | p->next = t->afree; |
| 432 | t->afree = p; |
| 433 | t->atids_in_use--; |
| 434 | spin_unlock_bh(&t->atid_lock); |
| 435 | |
| 436 | return ctx; |
| 437 | } |
| 438 | |
| 439 | EXPORT_SYMBOL(cxgb3_free_atid); |
| 440 | |
| 441 | /* |
| 442 | * Free a server TID and return it to the free pool. |
| 443 | */ |
| 444 | void cxgb3_free_stid(struct t3cdev *tdev, int stid) |
| 445 | { |
| 446 | struct tid_info *t = &(T3C_DATA(tdev))->tid_maps; |
| 447 | union listen_entry *p = stid2entry(t, stid); |
| 448 | |
| 449 | spin_lock_bh(&t->stid_lock); |
| 450 | p->next = t->sfree; |
| 451 | t->sfree = p; |
| 452 | t->stids_in_use--; |
| 453 | spin_unlock_bh(&t->stid_lock); |
| 454 | } |
| 455 | |
| 456 | EXPORT_SYMBOL(cxgb3_free_stid); |
| 457 | |
| 458 | void cxgb3_insert_tid(struct t3cdev *tdev, struct cxgb3_client *client, |
| 459 | void *ctx, unsigned int tid) |
| 460 | { |
| 461 | struct tid_info *t = &(T3C_DATA(tdev))->tid_maps; |
| 462 | |
| 463 | t->tid_tab[tid].client = client; |
| 464 | t->tid_tab[tid].ctx = ctx; |
| 465 | atomic_inc(&t->tids_in_use); |
| 466 | } |
| 467 | |
| 468 | EXPORT_SYMBOL(cxgb3_insert_tid); |
| 469 | |
| 470 | /* |
| 471 | * Populate a TID_RELEASE WR. The skb must be already propely sized. |
| 472 | */ |
| 473 | static inline void mk_tid_release(struct sk_buff *skb, unsigned int tid) |
| 474 | { |
| 475 | struct cpl_tid_release *req; |
| 476 | |
| 477 | skb->priority = CPL_PRIORITY_SETUP; |
| 478 | req = (struct cpl_tid_release *)__skb_put(skb, sizeof(*req)); |
| 479 | req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); |
| 480 | OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_TID_RELEASE, tid)); |
| 481 | } |
| 482 | |
| 483 | static void t3_process_tid_release_list(struct work_struct *work) |
| 484 | { |
| 485 | struct t3c_data *td = container_of(work, struct t3c_data, |
| 486 | tid_release_task); |
| 487 | struct sk_buff *skb; |
| 488 | struct t3cdev *tdev = td->dev; |
Jeff Garzik | 2eab17a | 2007-11-23 21:59:45 -0500 | [diff] [blame] | 489 | |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 490 | |
| 491 | spin_lock_bh(&td->tid_release_lock); |
| 492 | while (td->tid_release_list) { |
| 493 | struct t3c_tid_entry *p = td->tid_release_list; |
| 494 | |
| 495 | td->tid_release_list = (struct t3c_tid_entry *)p->ctx; |
| 496 | spin_unlock_bh(&td->tid_release_lock); |
| 497 | |
| 498 | skb = alloc_skb(sizeof(struct cpl_tid_release), |
| 499 | GFP_KERNEL | __GFP_NOFAIL); |
| 500 | mk_tid_release(skb, p - td->tid_maps.tid_tab); |
| 501 | cxgb3_ofld_send(tdev, skb); |
| 502 | p->ctx = NULL; |
| 503 | spin_lock_bh(&td->tid_release_lock); |
| 504 | } |
| 505 | spin_unlock_bh(&td->tid_release_lock); |
| 506 | } |
| 507 | |
| 508 | /* use ctx as a next pointer in the tid release list */ |
| 509 | void cxgb3_queue_tid_release(struct t3cdev *tdev, unsigned int tid) |
| 510 | { |
| 511 | struct t3c_data *td = T3C_DATA(tdev); |
| 512 | struct t3c_tid_entry *p = &td->tid_maps.tid_tab[tid]; |
| 513 | |
| 514 | spin_lock_bh(&td->tid_release_lock); |
| 515 | p->ctx = (void *)td->tid_release_list; |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 516 | p->client = NULL; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 517 | td->tid_release_list = p; |
| 518 | if (!p->ctx) |
| 519 | schedule_work(&td->tid_release_task); |
| 520 | spin_unlock_bh(&td->tid_release_lock); |
| 521 | } |
| 522 | |
| 523 | EXPORT_SYMBOL(cxgb3_queue_tid_release); |
| 524 | |
| 525 | /* |
| 526 | * Remove a tid from the TID table. A client may defer processing its last |
| 527 | * CPL message if it is locked at the time it arrives, and while the message |
| 528 | * sits in the client's backlog the TID may be reused for another connection. |
| 529 | * To handle this we atomically switch the TID association if it still points |
| 530 | * to the original client context. |
| 531 | */ |
| 532 | void cxgb3_remove_tid(struct t3cdev *tdev, void *ctx, unsigned int tid) |
| 533 | { |
| 534 | struct tid_info *t = &(T3C_DATA(tdev))->tid_maps; |
| 535 | |
| 536 | BUG_ON(tid >= t->ntids); |
| 537 | if (tdev->type == T3A) |
| 538 | (void)cmpxchg(&t->tid_tab[tid].ctx, ctx, NULL); |
| 539 | else { |
| 540 | struct sk_buff *skb; |
| 541 | |
| 542 | skb = alloc_skb(sizeof(struct cpl_tid_release), GFP_ATOMIC); |
| 543 | if (likely(skb)) { |
| 544 | mk_tid_release(skb, tid); |
| 545 | cxgb3_ofld_send(tdev, skb); |
| 546 | t->tid_tab[tid].ctx = NULL; |
| 547 | } else |
| 548 | cxgb3_queue_tid_release(tdev, tid); |
| 549 | } |
| 550 | atomic_dec(&t->tids_in_use); |
| 551 | } |
| 552 | |
| 553 | EXPORT_SYMBOL(cxgb3_remove_tid); |
| 554 | |
| 555 | int cxgb3_alloc_atid(struct t3cdev *tdev, struct cxgb3_client *client, |
| 556 | void *ctx) |
| 557 | { |
| 558 | int atid = -1; |
| 559 | struct tid_info *t = &(T3C_DATA(tdev))->tid_maps; |
| 560 | |
| 561 | spin_lock_bh(&t->atid_lock); |
Divy Le Ray | 9f23848 | 2007-03-31 00:23:13 -0700 | [diff] [blame] | 562 | if (t->afree && |
| 563 | t->atids_in_use + atomic_read(&t->tids_in_use) + MC5_MIN_TIDS <= |
| 564 | t->ntids) { |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 565 | union active_open_entry *p = t->afree; |
| 566 | |
| 567 | atid = (p - t->atid_tab) + t->atid_base; |
| 568 | t->afree = p->next; |
| 569 | p->t3c_tid.ctx = ctx; |
| 570 | p->t3c_tid.client = client; |
| 571 | t->atids_in_use++; |
| 572 | } |
| 573 | spin_unlock_bh(&t->atid_lock); |
| 574 | return atid; |
| 575 | } |
| 576 | |
| 577 | EXPORT_SYMBOL(cxgb3_alloc_atid); |
| 578 | |
| 579 | int cxgb3_alloc_stid(struct t3cdev *tdev, struct cxgb3_client *client, |
| 580 | void *ctx) |
| 581 | { |
| 582 | int stid = -1; |
| 583 | struct tid_info *t = &(T3C_DATA(tdev))->tid_maps; |
| 584 | |
| 585 | spin_lock_bh(&t->stid_lock); |
| 586 | if (t->sfree) { |
| 587 | union listen_entry *p = t->sfree; |
| 588 | |
| 589 | stid = (p - t->stid_tab) + t->stid_base; |
| 590 | t->sfree = p->next; |
| 591 | p->t3c_tid.ctx = ctx; |
| 592 | p->t3c_tid.client = client; |
| 593 | t->stids_in_use++; |
| 594 | } |
| 595 | spin_unlock_bh(&t->stid_lock); |
| 596 | return stid; |
| 597 | } |
| 598 | |
| 599 | EXPORT_SYMBOL(cxgb3_alloc_stid); |
| 600 | |
Divy Le Ray | 5fbf816 | 2007-08-29 19:15:47 -0700 | [diff] [blame] | 601 | /* Get the t3cdev associated with a net_device */ |
| 602 | struct t3cdev *dev2t3cdev(struct net_device *dev) |
| 603 | { |
| 604 | const struct port_info *pi = netdev_priv(dev); |
| 605 | |
| 606 | return (struct t3cdev *)pi->adapter; |
| 607 | } |
| 608 | |
| 609 | EXPORT_SYMBOL(dev2t3cdev); |
| 610 | |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 611 | static int do_smt_write_rpl(struct t3cdev *dev, struct sk_buff *skb) |
| 612 | { |
| 613 | struct cpl_smt_write_rpl *rpl = cplhdr(skb); |
| 614 | |
| 615 | if (rpl->status != CPL_ERR_NONE) |
| 616 | printk(KERN_ERR |
| 617 | "Unexpected SMT_WRITE_RPL status %u for entry %u\n", |
| 618 | rpl->status, GET_TID(rpl)); |
| 619 | |
| 620 | return CPL_RET_BUF_DONE; |
| 621 | } |
| 622 | |
| 623 | static int do_l2t_write_rpl(struct t3cdev *dev, struct sk_buff *skb) |
| 624 | { |
| 625 | struct cpl_l2t_write_rpl *rpl = cplhdr(skb); |
| 626 | |
| 627 | if (rpl->status != CPL_ERR_NONE) |
| 628 | printk(KERN_ERR |
| 629 | "Unexpected L2T_WRITE_RPL status %u for entry %u\n", |
| 630 | rpl->status, GET_TID(rpl)); |
| 631 | |
| 632 | return CPL_RET_BUF_DONE; |
| 633 | } |
| 634 | |
Divy Le Ray | b881955 | 2007-12-17 18:47:31 -0800 | [diff] [blame] | 635 | static int do_rte_write_rpl(struct t3cdev *dev, struct sk_buff *skb) |
| 636 | { |
| 637 | struct cpl_rte_write_rpl *rpl = cplhdr(skb); |
| 638 | |
| 639 | if (rpl->status != CPL_ERR_NONE) |
| 640 | printk(KERN_ERR |
| 641 | "Unexpected RTE_WRITE_RPL status %u for entry %u\n", |
| 642 | rpl->status, GET_TID(rpl)); |
| 643 | |
| 644 | return CPL_RET_BUF_DONE; |
| 645 | } |
| 646 | |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 647 | static int do_act_open_rpl(struct t3cdev *dev, struct sk_buff *skb) |
| 648 | { |
| 649 | struct cpl_act_open_rpl *rpl = cplhdr(skb); |
| 650 | unsigned int atid = G_TID(ntohl(rpl->atid)); |
| 651 | struct t3c_tid_entry *t3c_tid; |
| 652 | |
| 653 | t3c_tid = lookup_atid(&(T3C_DATA(dev))->tid_maps, atid); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 654 | if (t3c_tid && t3c_tid->ctx && t3c_tid->client && |
| 655 | t3c_tid->client->handlers && |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 656 | t3c_tid->client->handlers[CPL_ACT_OPEN_RPL]) { |
| 657 | return t3c_tid->client->handlers[CPL_ACT_OPEN_RPL] (dev, skb, |
| 658 | t3c_tid-> |
| 659 | ctx); |
| 660 | } else { |
| 661 | printk(KERN_ERR "%s: received clientless CPL command 0x%x\n", |
| 662 | dev->name, CPL_ACT_OPEN_RPL); |
| 663 | return CPL_RET_BUF_DONE | CPL_RET_BAD_MSG; |
| 664 | } |
| 665 | } |
| 666 | |
| 667 | static int do_stid_rpl(struct t3cdev *dev, struct sk_buff *skb) |
| 668 | { |
| 669 | union opcode_tid *p = cplhdr(skb); |
| 670 | unsigned int stid = G_TID(ntohl(p->opcode_tid)); |
| 671 | struct t3c_tid_entry *t3c_tid; |
| 672 | |
| 673 | t3c_tid = lookup_stid(&(T3C_DATA(dev))->tid_maps, stid); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 674 | if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers && |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 675 | t3c_tid->client->handlers[p->opcode]) { |
| 676 | return t3c_tid->client->handlers[p->opcode] (dev, skb, |
| 677 | t3c_tid->ctx); |
| 678 | } else { |
| 679 | printk(KERN_ERR "%s: received clientless CPL command 0x%x\n", |
| 680 | dev->name, p->opcode); |
| 681 | return CPL_RET_BUF_DONE | CPL_RET_BAD_MSG; |
| 682 | } |
| 683 | } |
| 684 | |
| 685 | static int do_hwtid_rpl(struct t3cdev *dev, struct sk_buff *skb) |
| 686 | { |
| 687 | union opcode_tid *p = cplhdr(skb); |
| 688 | unsigned int hwtid = G_TID(ntohl(p->opcode_tid)); |
| 689 | struct t3c_tid_entry *t3c_tid; |
| 690 | |
| 691 | t3c_tid = lookup_tid(&(T3C_DATA(dev))->tid_maps, hwtid); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 692 | if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers && |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 693 | t3c_tid->client->handlers[p->opcode]) { |
| 694 | return t3c_tid->client->handlers[p->opcode] |
| 695 | (dev, skb, t3c_tid->ctx); |
| 696 | } else { |
| 697 | printk(KERN_ERR "%s: received clientless CPL command 0x%x\n", |
| 698 | dev->name, p->opcode); |
| 699 | return CPL_RET_BUF_DONE | CPL_RET_BAD_MSG; |
| 700 | } |
| 701 | } |
| 702 | |
| 703 | static int do_cr(struct t3cdev *dev, struct sk_buff *skb) |
| 704 | { |
| 705 | struct cpl_pass_accept_req *req = cplhdr(skb); |
| 706 | unsigned int stid = G_PASS_OPEN_TID(ntohl(req->tos_tid)); |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 707 | struct tid_info *t = &(T3C_DATA(dev))->tid_maps; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 708 | struct t3c_tid_entry *t3c_tid; |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 709 | unsigned int tid = GET_TID(req); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 710 | |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 711 | if (unlikely(tid >= t->ntids)) { |
| 712 | printk("%s: passive open TID %u too large\n", |
| 713 | dev->name, tid); |
| 714 | t3_fatal_err(tdev2adap(dev)); |
| 715 | return CPL_RET_BUF_DONE; |
| 716 | } |
| 717 | |
| 718 | t3c_tid = lookup_stid(t, stid); |
| 719 | if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers && |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 720 | t3c_tid->client->handlers[CPL_PASS_ACCEPT_REQ]) { |
| 721 | return t3c_tid->client->handlers[CPL_PASS_ACCEPT_REQ] |
| 722 | (dev, skb, t3c_tid->ctx); |
| 723 | } else { |
| 724 | printk(KERN_ERR "%s: received clientless CPL command 0x%x\n", |
| 725 | dev->name, CPL_PASS_ACCEPT_REQ); |
| 726 | return CPL_RET_BUF_DONE | CPL_RET_BAD_MSG; |
| 727 | } |
| 728 | } |
| 729 | |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 730 | /* |
| 731 | * Returns an sk_buff for a reply CPL message of size len. If the input |
| 732 | * sk_buff has no other users it is trimmed and reused, otherwise a new buffer |
| 733 | * is allocated. The input skb must be of size at least len. Note that this |
| 734 | * operation does not destroy the original skb data even if it decides to reuse |
| 735 | * the buffer. |
| 736 | */ |
| 737 | static struct sk_buff *cxgb3_get_cpl_reply_skb(struct sk_buff *skb, size_t len, |
Al Viro | 1f41bb3 | 2007-07-26 17:35:19 +0100 | [diff] [blame] | 738 | gfp_t gfp) |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 739 | { |
| 740 | if (likely(!skb_cloned(skb))) { |
| 741 | BUG_ON(skb->len < len); |
| 742 | __skb_trim(skb, len); |
| 743 | skb_get(skb); |
| 744 | } else { |
| 745 | skb = alloc_skb(len, gfp); |
| 746 | if (skb) |
| 747 | __skb_put(skb, len); |
| 748 | } |
| 749 | return skb; |
| 750 | } |
| 751 | |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 752 | static int do_abort_req_rss(struct t3cdev *dev, struct sk_buff *skb) |
| 753 | { |
| 754 | union opcode_tid *p = cplhdr(skb); |
| 755 | unsigned int hwtid = G_TID(ntohl(p->opcode_tid)); |
| 756 | struct t3c_tid_entry *t3c_tid; |
| 757 | |
| 758 | t3c_tid = lookup_tid(&(T3C_DATA(dev))->tid_maps, hwtid); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 759 | if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers && |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 760 | t3c_tid->client->handlers[p->opcode]) { |
| 761 | return t3c_tid->client->handlers[p->opcode] |
| 762 | (dev, skb, t3c_tid->ctx); |
| 763 | } else { |
| 764 | struct cpl_abort_req_rss *req = cplhdr(skb); |
| 765 | struct cpl_abort_rpl *rpl; |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 766 | struct sk_buff *reply_skb; |
| 767 | unsigned int tid = GET_TID(req); |
| 768 | u8 cmd = req->status; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 769 | |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 770 | if (req->status == CPL_ERR_RTX_NEG_ADVICE || |
| 771 | req->status == CPL_ERR_PERSIST_NEG_ADVICE) |
| 772 | goto out; |
| 773 | |
| 774 | reply_skb = cxgb3_get_cpl_reply_skb(skb, |
| 775 | sizeof(struct |
| 776 | cpl_abort_rpl), |
| 777 | GFP_ATOMIC); |
| 778 | |
| 779 | if (!reply_skb) { |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 780 | printk("do_abort_req_rss: couldn't get skb!\n"); |
| 781 | goto out; |
| 782 | } |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 783 | reply_skb->priority = CPL_PRIORITY_DATA; |
| 784 | __skb_put(reply_skb, sizeof(struct cpl_abort_rpl)); |
| 785 | rpl = cplhdr(reply_skb); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 786 | rpl->wr.wr_hi = |
| 787 | htonl(V_WR_OP(FW_WROPCODE_OFLD_HOST_ABORT_CON_RPL)); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 788 | rpl->wr.wr_lo = htonl(V_WR_TID(tid)); |
| 789 | OPCODE_TID(rpl) = htonl(MK_OPCODE_TID(CPL_ABORT_RPL, tid)); |
| 790 | rpl->cmd = cmd; |
| 791 | cxgb3_ofld_send(dev, reply_skb); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 792 | out: |
| 793 | return CPL_RET_BUF_DONE; |
| 794 | } |
| 795 | } |
| 796 | |
| 797 | static int do_act_establish(struct t3cdev *dev, struct sk_buff *skb) |
| 798 | { |
| 799 | struct cpl_act_establish *req = cplhdr(skb); |
| 800 | unsigned int atid = G_PASS_OPEN_TID(ntohl(req->tos_tid)); |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 801 | struct tid_info *t = &(T3C_DATA(dev))->tid_maps; |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 802 | struct t3c_tid_entry *t3c_tid; |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 803 | unsigned int tid = GET_TID(req); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 804 | |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 805 | if (unlikely(tid >= t->ntids)) { |
| 806 | printk("%s: active establish TID %u too large\n", |
| 807 | dev->name, tid); |
| 808 | t3_fatal_err(tdev2adap(dev)); |
| 809 | return CPL_RET_BUF_DONE; |
| 810 | } |
| 811 | |
| 812 | t3c_tid = lookup_atid(t, atid); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 813 | if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers && |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 814 | t3c_tid->client->handlers[CPL_ACT_ESTABLISH]) { |
| 815 | return t3c_tid->client->handlers[CPL_ACT_ESTABLISH] |
| 816 | (dev, skb, t3c_tid->ctx); |
| 817 | } else { |
| 818 | printk(KERN_ERR "%s: received clientless CPL command 0x%x\n", |
Divy Le Ray | c9a6ce5 | 2007-08-21 20:49:26 -0700 | [diff] [blame] | 819 | dev->name, CPL_ACT_ESTABLISH); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 820 | return CPL_RET_BUF_DONE | CPL_RET_BAD_MSG; |
| 821 | } |
| 822 | } |
| 823 | |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 824 | static int do_trace(struct t3cdev *dev, struct sk_buff *skb) |
| 825 | { |
| 826 | struct cpl_trace_pkt *p = cplhdr(skb); |
| 827 | |
Al Viro | b534497 | 2007-02-09 16:40:10 +0000 | [diff] [blame] | 828 | skb->protocol = htons(0xffff); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 829 | skb->dev = dev->lldev; |
| 830 | skb_pull(skb, sizeof(*p)); |
Arnaldo Carvalho de Melo | 459a98e | 2007-03-19 15:30:44 -0700 | [diff] [blame] | 831 | skb_reset_mac_header(skb); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 832 | netif_receive_skb(skb); |
| 833 | return 0; |
| 834 | } |
| 835 | |
| 836 | static int do_term(struct t3cdev *dev, struct sk_buff *skb) |
| 837 | { |
| 838 | unsigned int hwtid = ntohl(skb->priority) >> 8 & 0xfffff; |
| 839 | unsigned int opcode = G_OPCODE(ntohl(skb->csum)); |
| 840 | struct t3c_tid_entry *t3c_tid; |
| 841 | |
| 842 | t3c_tid = lookup_tid(&(T3C_DATA(dev))->tid_maps, hwtid); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 843 | if (t3c_tid && t3c_tid->ctx && t3c_tid->client->handlers && |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 844 | t3c_tid->client->handlers[opcode]) { |
| 845 | return t3c_tid->client->handlers[opcode] (dev, skb, |
| 846 | t3c_tid->ctx); |
| 847 | } else { |
| 848 | printk(KERN_ERR "%s: received clientless CPL command 0x%x\n", |
| 849 | dev->name, opcode); |
| 850 | return CPL_RET_BUF_DONE | CPL_RET_BAD_MSG; |
| 851 | } |
| 852 | } |
| 853 | |
| 854 | static int nb_callback(struct notifier_block *self, unsigned long event, |
| 855 | void *ctx) |
| 856 | { |
| 857 | switch (event) { |
| 858 | case (NETEVENT_NEIGH_UPDATE):{ |
| 859 | cxgb_neigh_update((struct neighbour *)ctx); |
| 860 | break; |
| 861 | } |
| 862 | case (NETEVENT_PMTU_UPDATE): |
| 863 | break; |
| 864 | case (NETEVENT_REDIRECT):{ |
| 865 | struct netevent_redirect *nr = ctx; |
| 866 | cxgb_redirect(nr->old, nr->new); |
| 867 | cxgb_neigh_update(nr->new->neighbour); |
| 868 | break; |
| 869 | } |
| 870 | default: |
| 871 | break; |
| 872 | } |
| 873 | return 0; |
| 874 | } |
| 875 | |
| 876 | static struct notifier_block nb = { |
| 877 | .notifier_call = nb_callback |
| 878 | }; |
| 879 | |
| 880 | /* |
| 881 | * Process a received packet with an unknown/unexpected CPL opcode. |
| 882 | */ |
| 883 | static int do_bad_cpl(struct t3cdev *dev, struct sk_buff *skb) |
| 884 | { |
| 885 | printk(KERN_ERR "%s: received bad CPL command 0x%x\n", dev->name, |
| 886 | *skb->data); |
| 887 | return CPL_RET_BUF_DONE | CPL_RET_BAD_MSG; |
| 888 | } |
| 889 | |
| 890 | /* |
| 891 | * Handlers for each CPL opcode |
| 892 | */ |
| 893 | static cpl_handler_func cpl_handlers[NUM_CPL_CMDS]; |
| 894 | |
| 895 | /* |
| 896 | * Add a new handler to the CPL dispatch table. A NULL handler may be supplied |
| 897 | * to unregister an existing handler. |
| 898 | */ |
| 899 | void t3_register_cpl_handler(unsigned int opcode, cpl_handler_func h) |
| 900 | { |
| 901 | if (opcode < NUM_CPL_CMDS) |
| 902 | cpl_handlers[opcode] = h ? h : do_bad_cpl; |
| 903 | else |
| 904 | printk(KERN_ERR "T3C: handler registration for " |
| 905 | "opcode %x failed\n", opcode); |
| 906 | } |
| 907 | |
| 908 | EXPORT_SYMBOL(t3_register_cpl_handler); |
| 909 | |
| 910 | /* |
| 911 | * T3CDEV's receive method. |
| 912 | */ |
| 913 | int process_rx(struct t3cdev *dev, struct sk_buff **skbs, int n) |
| 914 | { |
| 915 | while (n--) { |
| 916 | struct sk_buff *skb = *skbs++; |
| 917 | unsigned int opcode = G_OPCODE(ntohl(skb->csum)); |
| 918 | int ret = cpl_handlers[opcode] (dev, skb); |
| 919 | |
| 920 | #if VALIDATE_TID |
| 921 | if (ret & CPL_RET_UNKNOWN_TID) { |
| 922 | union opcode_tid *p = cplhdr(skb); |
| 923 | |
| 924 | printk(KERN_ERR "%s: CPL message (opcode %u) had " |
| 925 | "unknown TID %u\n", dev->name, opcode, |
| 926 | G_TID(ntohl(p->opcode_tid))); |
| 927 | } |
| 928 | #endif |
| 929 | if (ret & CPL_RET_BUF_DONE) |
| 930 | kfree_skb(skb); |
| 931 | } |
| 932 | return 0; |
| 933 | } |
| 934 | |
| 935 | /* |
| 936 | * Sends an sk_buff to a T3C driver after dealing with any active network taps. |
| 937 | */ |
| 938 | int cxgb3_ofld_send(struct t3cdev *dev, struct sk_buff *skb) |
| 939 | { |
| 940 | int r; |
| 941 | |
| 942 | local_bh_disable(); |
| 943 | r = dev->send(dev, skb); |
| 944 | local_bh_enable(); |
| 945 | return r; |
| 946 | } |
| 947 | |
| 948 | EXPORT_SYMBOL(cxgb3_ofld_send); |
| 949 | |
| 950 | static int is_offloading(struct net_device *dev) |
| 951 | { |
| 952 | struct adapter *adapter; |
| 953 | int i; |
| 954 | |
| 955 | read_lock_bh(&adapter_list_lock); |
| 956 | list_for_each_entry(adapter, &adapter_list, adapter_list) { |
| 957 | for_each_port(adapter, i) { |
| 958 | if (dev == adapter->port[i]) { |
| 959 | read_unlock_bh(&adapter_list_lock); |
| 960 | return 1; |
| 961 | } |
| 962 | } |
| 963 | } |
| 964 | read_unlock_bh(&adapter_list_lock); |
| 965 | return 0; |
| 966 | } |
| 967 | |
| 968 | void cxgb_neigh_update(struct neighbour *neigh) |
| 969 | { |
| 970 | struct net_device *dev = neigh->dev; |
| 971 | |
| 972 | if (dev && (is_offloading(dev))) { |
Divy Le Ray | 5fbf816 | 2007-08-29 19:15:47 -0700 | [diff] [blame] | 973 | struct t3cdev *tdev = dev2t3cdev(dev); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 974 | |
| 975 | BUG_ON(!tdev); |
| 976 | t3_l2t_update(tdev, neigh); |
| 977 | } |
| 978 | } |
| 979 | |
| 980 | static void set_l2t_ix(struct t3cdev *tdev, u32 tid, struct l2t_entry *e) |
| 981 | { |
| 982 | struct sk_buff *skb; |
| 983 | struct cpl_set_tcb_field *req; |
| 984 | |
| 985 | skb = alloc_skb(sizeof(*req), GFP_ATOMIC); |
| 986 | if (!skb) { |
| 987 | printk(KERN_ERR "%s: cannot allocate skb!\n", __FUNCTION__); |
| 988 | return; |
| 989 | } |
| 990 | skb->priority = CPL_PRIORITY_CONTROL; |
| 991 | req = (struct cpl_set_tcb_field *)skb_put(skb, sizeof(*req)); |
| 992 | req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD)); |
| 993 | OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid)); |
| 994 | req->reply = 0; |
| 995 | req->cpu_idx = 0; |
| 996 | req->word = htons(W_TCB_L2T_IX); |
| 997 | req->mask = cpu_to_be64(V_TCB_L2T_IX(M_TCB_L2T_IX)); |
| 998 | req->val = cpu_to_be64(V_TCB_L2T_IX(e->idx)); |
| 999 | tdev->send(tdev, skb); |
| 1000 | } |
| 1001 | |
| 1002 | void cxgb_redirect(struct dst_entry *old, struct dst_entry *new) |
| 1003 | { |
| 1004 | struct net_device *olddev, *newdev; |
| 1005 | struct tid_info *ti; |
| 1006 | struct t3cdev *tdev; |
| 1007 | u32 tid; |
| 1008 | int update_tcb; |
| 1009 | struct l2t_entry *e; |
| 1010 | struct t3c_tid_entry *te; |
| 1011 | |
| 1012 | olddev = old->neighbour->dev; |
| 1013 | newdev = new->neighbour->dev; |
| 1014 | if (!is_offloading(olddev)) |
| 1015 | return; |
| 1016 | if (!is_offloading(newdev)) { |
Joe Perches | f07b2e4 | 2007-11-19 17:48:22 -0800 | [diff] [blame] | 1017 | printk(KERN_WARNING "%s: Redirect to non-offload " |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1018 | "device ignored.\n", __FUNCTION__); |
| 1019 | return; |
| 1020 | } |
Divy Le Ray | 5fbf816 | 2007-08-29 19:15:47 -0700 | [diff] [blame] | 1021 | tdev = dev2t3cdev(olddev); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1022 | BUG_ON(!tdev); |
Divy Le Ray | 5fbf816 | 2007-08-29 19:15:47 -0700 | [diff] [blame] | 1023 | if (tdev != dev2t3cdev(newdev)) { |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1024 | printk(KERN_WARNING "%s: Redirect to different " |
| 1025 | "offload device ignored.\n", __FUNCTION__); |
| 1026 | return; |
| 1027 | } |
| 1028 | |
| 1029 | /* Add new L2T entry */ |
| 1030 | e = t3_l2t_get(tdev, new->neighbour, newdev); |
| 1031 | if (!e) { |
| 1032 | printk(KERN_ERR "%s: couldn't allocate new l2t entry!\n", |
| 1033 | __FUNCTION__); |
| 1034 | return; |
| 1035 | } |
| 1036 | |
| 1037 | /* Walk tid table and notify clients of dst change. */ |
| 1038 | ti = &(T3C_DATA(tdev))->tid_maps; |
| 1039 | for (tid = 0; tid < ti->ntids; tid++) { |
| 1040 | te = lookup_tid(ti, tid); |
| 1041 | BUG_ON(!te); |
Divy Le Ray | 606fcd0 | 2007-04-17 11:06:30 -0700 | [diff] [blame] | 1042 | if (te && te->ctx && te->client && te->client->redirect) { |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1043 | update_tcb = te->client->redirect(te->ctx, old, new, e); |
| 1044 | if (update_tcb) { |
| 1045 | l2t_hold(L2DATA(tdev), e); |
| 1046 | set_l2t_ix(tdev, tid, e); |
| 1047 | } |
| 1048 | } |
| 1049 | } |
| 1050 | l2t_release(L2DATA(tdev), e); |
| 1051 | } |
| 1052 | |
| 1053 | /* |
| 1054 | * Allocate a chunk of memory using kmalloc or, if that fails, vmalloc. |
| 1055 | * The allocated memory is cleared. |
| 1056 | */ |
| 1057 | void *cxgb_alloc_mem(unsigned long size) |
| 1058 | { |
| 1059 | void *p = kmalloc(size, GFP_KERNEL); |
| 1060 | |
| 1061 | if (!p) |
| 1062 | p = vmalloc(size); |
| 1063 | if (p) |
| 1064 | memset(p, 0, size); |
| 1065 | return p; |
| 1066 | } |
| 1067 | |
| 1068 | /* |
| 1069 | * Free memory allocated through t3_alloc_mem(). |
| 1070 | */ |
| 1071 | void cxgb_free_mem(void *addr) |
| 1072 | { |
Christoph Lameter | 9e2779f | 2008-02-04 22:28:34 -0800 | [diff] [blame] | 1073 | if (is_vmalloc_addr(addr)) |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1074 | vfree(addr); |
| 1075 | else |
| 1076 | kfree(addr); |
| 1077 | } |
| 1078 | |
| 1079 | /* |
| 1080 | * Allocate and initialize the TID tables. Returns 0 on success. |
| 1081 | */ |
| 1082 | static int init_tid_tabs(struct tid_info *t, unsigned int ntids, |
| 1083 | unsigned int natids, unsigned int nstids, |
| 1084 | unsigned int atid_base, unsigned int stid_base) |
| 1085 | { |
| 1086 | unsigned long size = ntids * sizeof(*t->tid_tab) + |
| 1087 | natids * sizeof(*t->atid_tab) + nstids * sizeof(*t->stid_tab); |
| 1088 | |
| 1089 | t->tid_tab = cxgb_alloc_mem(size); |
| 1090 | if (!t->tid_tab) |
| 1091 | return -ENOMEM; |
| 1092 | |
| 1093 | t->stid_tab = (union listen_entry *)&t->tid_tab[ntids]; |
| 1094 | t->atid_tab = (union active_open_entry *)&t->stid_tab[nstids]; |
| 1095 | t->ntids = ntids; |
| 1096 | t->nstids = nstids; |
| 1097 | t->stid_base = stid_base; |
| 1098 | t->sfree = NULL; |
| 1099 | t->natids = natids; |
| 1100 | t->atid_base = atid_base; |
| 1101 | t->afree = NULL; |
| 1102 | t->stids_in_use = t->atids_in_use = 0; |
| 1103 | atomic_set(&t->tids_in_use, 0); |
| 1104 | spin_lock_init(&t->stid_lock); |
| 1105 | spin_lock_init(&t->atid_lock); |
| 1106 | |
| 1107 | /* |
| 1108 | * Setup the free lists for stid_tab and atid_tab. |
| 1109 | */ |
| 1110 | if (nstids) { |
| 1111 | while (--nstids) |
| 1112 | t->stid_tab[nstids - 1].next = &t->stid_tab[nstids]; |
| 1113 | t->sfree = t->stid_tab; |
| 1114 | } |
| 1115 | if (natids) { |
| 1116 | while (--natids) |
| 1117 | t->atid_tab[natids - 1].next = &t->atid_tab[natids]; |
| 1118 | t->afree = t->atid_tab; |
| 1119 | } |
| 1120 | return 0; |
| 1121 | } |
| 1122 | |
| 1123 | static void free_tid_maps(struct tid_info *t) |
| 1124 | { |
| 1125 | cxgb_free_mem(t->tid_tab); |
| 1126 | } |
| 1127 | |
| 1128 | static inline void add_adapter(struct adapter *adap) |
| 1129 | { |
| 1130 | write_lock_bh(&adapter_list_lock); |
| 1131 | list_add_tail(&adap->adapter_list, &adapter_list); |
| 1132 | write_unlock_bh(&adapter_list_lock); |
| 1133 | } |
| 1134 | |
| 1135 | static inline void remove_adapter(struct adapter *adap) |
| 1136 | { |
| 1137 | write_lock_bh(&adapter_list_lock); |
| 1138 | list_del(&adap->adapter_list); |
| 1139 | write_unlock_bh(&adapter_list_lock); |
| 1140 | } |
| 1141 | |
| 1142 | int cxgb3_offload_activate(struct adapter *adapter) |
| 1143 | { |
| 1144 | struct t3cdev *dev = &adapter->tdev; |
| 1145 | int natids, err; |
| 1146 | struct t3c_data *t; |
| 1147 | struct tid_range stid_range, tid_range; |
| 1148 | struct mtutab mtutab; |
| 1149 | unsigned int l2t_capacity; |
| 1150 | |
| 1151 | t = kcalloc(1, sizeof(*t), GFP_KERNEL); |
| 1152 | if (!t) |
| 1153 | return -ENOMEM; |
| 1154 | |
| 1155 | err = -EOPNOTSUPP; |
| 1156 | if (dev->ctl(dev, GET_TX_MAX_CHUNK, &t->tx_max_chunk) < 0 || |
| 1157 | dev->ctl(dev, GET_MAX_OUTSTANDING_WR, &t->max_wrs) < 0 || |
| 1158 | dev->ctl(dev, GET_L2T_CAPACITY, &l2t_capacity) < 0 || |
| 1159 | dev->ctl(dev, GET_MTUS, &mtutab) < 0 || |
| 1160 | dev->ctl(dev, GET_TID_RANGE, &tid_range) < 0 || |
| 1161 | dev->ctl(dev, GET_STID_RANGE, &stid_range) < 0) |
| 1162 | goto out_free; |
| 1163 | |
| 1164 | err = -ENOMEM; |
| 1165 | L2DATA(dev) = t3_init_l2t(l2t_capacity); |
| 1166 | if (!L2DATA(dev)) |
| 1167 | goto out_free; |
| 1168 | |
| 1169 | natids = min(tid_range.num / 2, MAX_ATIDS); |
| 1170 | err = init_tid_tabs(&t->tid_maps, tid_range.num, natids, |
| 1171 | stid_range.num, ATID_BASE, stid_range.base); |
| 1172 | if (err) |
| 1173 | goto out_free_l2t; |
| 1174 | |
| 1175 | t->mtus = mtutab.mtus; |
| 1176 | t->nmtus = mtutab.size; |
| 1177 | |
| 1178 | INIT_WORK(&t->tid_release_task, t3_process_tid_release_list); |
| 1179 | spin_lock_init(&t->tid_release_lock); |
| 1180 | INIT_LIST_HEAD(&t->list_node); |
| 1181 | t->dev = dev; |
| 1182 | |
| 1183 | T3C_DATA(dev) = t; |
| 1184 | dev->recv = process_rx; |
| 1185 | dev->neigh_update = t3_l2t_update; |
| 1186 | |
| 1187 | /* Register netevent handler once */ |
| 1188 | if (list_empty(&adapter_list)) |
| 1189 | register_netevent_notifier(&nb); |
| 1190 | |
| 1191 | add_adapter(adapter); |
| 1192 | return 0; |
| 1193 | |
| 1194 | out_free_l2t: |
| 1195 | t3_free_l2t(L2DATA(dev)); |
| 1196 | L2DATA(dev) = NULL; |
| 1197 | out_free: |
| 1198 | kfree(t); |
| 1199 | return err; |
| 1200 | } |
| 1201 | |
| 1202 | void cxgb3_offload_deactivate(struct adapter *adapter) |
| 1203 | { |
| 1204 | struct t3cdev *tdev = &adapter->tdev; |
| 1205 | struct t3c_data *t = T3C_DATA(tdev); |
| 1206 | |
| 1207 | remove_adapter(adapter); |
| 1208 | if (list_empty(&adapter_list)) |
| 1209 | unregister_netevent_notifier(&nb); |
| 1210 | |
| 1211 | free_tid_maps(&t->tid_maps); |
| 1212 | T3C_DATA(tdev) = NULL; |
| 1213 | t3_free_l2t(L2DATA(tdev)); |
| 1214 | L2DATA(tdev) = NULL; |
| 1215 | kfree(t); |
| 1216 | } |
| 1217 | |
| 1218 | static inline void register_tdev(struct t3cdev *tdev) |
| 1219 | { |
| 1220 | static int unit; |
| 1221 | |
| 1222 | mutex_lock(&cxgb3_db_lock); |
| 1223 | snprintf(tdev->name, sizeof(tdev->name), "ofld_dev%d", unit++); |
| 1224 | list_add_tail(&tdev->ofld_dev_list, &ofld_dev_list); |
| 1225 | mutex_unlock(&cxgb3_db_lock); |
| 1226 | } |
| 1227 | |
| 1228 | static inline void unregister_tdev(struct t3cdev *tdev) |
| 1229 | { |
| 1230 | mutex_lock(&cxgb3_db_lock); |
| 1231 | list_del(&tdev->ofld_dev_list); |
| 1232 | mutex_unlock(&cxgb3_db_lock); |
| 1233 | } |
| 1234 | |
| 1235 | void __devinit cxgb3_adapter_ofld(struct adapter *adapter) |
| 1236 | { |
| 1237 | struct t3cdev *tdev = &adapter->tdev; |
| 1238 | |
| 1239 | INIT_LIST_HEAD(&tdev->ofld_dev_list); |
| 1240 | |
| 1241 | cxgb3_set_dummy_ops(tdev); |
| 1242 | tdev->send = t3_offload_tx; |
| 1243 | tdev->ctl = cxgb_offload_ctl; |
| 1244 | tdev->type = adapter->params.rev == 0 ? T3A : T3B; |
| 1245 | |
| 1246 | register_tdev(tdev); |
| 1247 | } |
| 1248 | |
| 1249 | void __devexit cxgb3_adapter_unofld(struct adapter *adapter) |
| 1250 | { |
| 1251 | struct t3cdev *tdev = &adapter->tdev; |
| 1252 | |
| 1253 | tdev->recv = NULL; |
| 1254 | tdev->neigh_update = NULL; |
| 1255 | |
| 1256 | unregister_tdev(tdev); |
| 1257 | } |
| 1258 | |
| 1259 | void __init cxgb3_offload_init(void) |
| 1260 | { |
| 1261 | int i; |
| 1262 | |
| 1263 | for (i = 0; i < NUM_CPL_CMDS; ++i) |
| 1264 | cpl_handlers[i] = do_bad_cpl; |
| 1265 | |
| 1266 | t3_register_cpl_handler(CPL_SMT_WRITE_RPL, do_smt_write_rpl); |
| 1267 | t3_register_cpl_handler(CPL_L2T_WRITE_RPL, do_l2t_write_rpl); |
Divy Le Ray | b881955 | 2007-12-17 18:47:31 -0800 | [diff] [blame] | 1268 | t3_register_cpl_handler(CPL_RTE_WRITE_RPL, do_rte_write_rpl); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1269 | t3_register_cpl_handler(CPL_PASS_OPEN_RPL, do_stid_rpl); |
| 1270 | t3_register_cpl_handler(CPL_CLOSE_LISTSRV_RPL, do_stid_rpl); |
| 1271 | t3_register_cpl_handler(CPL_PASS_ACCEPT_REQ, do_cr); |
| 1272 | t3_register_cpl_handler(CPL_PASS_ESTABLISH, do_hwtid_rpl); |
| 1273 | t3_register_cpl_handler(CPL_ABORT_RPL_RSS, do_hwtid_rpl); |
| 1274 | t3_register_cpl_handler(CPL_ABORT_RPL, do_hwtid_rpl); |
| 1275 | t3_register_cpl_handler(CPL_RX_URG_NOTIFY, do_hwtid_rpl); |
| 1276 | t3_register_cpl_handler(CPL_RX_DATA, do_hwtid_rpl); |
| 1277 | t3_register_cpl_handler(CPL_TX_DATA_ACK, do_hwtid_rpl); |
| 1278 | t3_register_cpl_handler(CPL_TX_DMA_ACK, do_hwtid_rpl); |
| 1279 | t3_register_cpl_handler(CPL_ACT_OPEN_RPL, do_act_open_rpl); |
| 1280 | t3_register_cpl_handler(CPL_PEER_CLOSE, do_hwtid_rpl); |
| 1281 | t3_register_cpl_handler(CPL_CLOSE_CON_RPL, do_hwtid_rpl); |
| 1282 | t3_register_cpl_handler(CPL_ABORT_REQ_RSS, do_abort_req_rss); |
| 1283 | t3_register_cpl_handler(CPL_ACT_ESTABLISH, do_act_establish); |
Divy Le Ray | 6cdbd77 | 2007-04-09 20:10:33 -0700 | [diff] [blame] | 1284 | t3_register_cpl_handler(CPL_SET_TCB_RPL, do_hwtid_rpl); |
| 1285 | t3_register_cpl_handler(CPL_GET_TCB_RPL, do_hwtid_rpl); |
Divy Le Ray | 4d22de3 | 2007-01-18 22:04:14 -0500 | [diff] [blame] | 1286 | t3_register_cpl_handler(CPL_RDMA_TERMINATE, do_term); |
| 1287 | t3_register_cpl_handler(CPL_RDMA_EC_STATUS, do_hwtid_rpl); |
| 1288 | t3_register_cpl_handler(CPL_TRACE_PKT, do_trace); |
| 1289 | t3_register_cpl_handler(CPL_RX_DATA_DDP, do_hwtid_rpl); |
| 1290 | t3_register_cpl_handler(CPL_RX_DDP_COMPLETE, do_hwtid_rpl); |
| 1291 | t3_register_cpl_handler(CPL_ISCSI_HDR, do_hwtid_rpl); |
| 1292 | } |