drivers/scsi/bnx2fc/bnx2fc_tgt.c

   1 /* bnx2fc_tgt.c: Broadcom NetXtreme II Linux FCoE offload driver.
   2  * Handles operations such as session offload/upload etc, and manages
   3  * session resources such as connection id and qp resources.
   4  *
   5  * Copyright (c) 2008 - 2010 Broadcom Corporation
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation.
  10  *
  11  * Written by: Bhanu Prakash Gollapudi (bprakash@broadcom.com)
  12  */
  13
  14 #include "bnx2fc.h"
  15 static void bnx2fc_upld_timer(unsigned long data);
  16 static void bnx2fc_ofld_timer(unsigned long data);
  17 static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
  18                            struct fcoe_port *port,
  19                            struct fc_rport_priv *rdata);
  20 static u32 bnx2fc_alloc_conn_id(struct bnx2fc_hba *hba,
  21                                 struct bnx2fc_rport *tgt);
  22 static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
  23                               struct bnx2fc_rport *tgt);
  24 static void bnx2fc_free_session_resc(struct bnx2fc_hba *hba,
  25                               struct bnx2fc_rport *tgt);
  26 static void bnx2fc_free_conn_id(struct bnx2fc_hba *hba, u32 conn_id);
  27
  28 static void bnx2fc_upld_timer(unsigned long data)
  29 {
  30
  31         struct bnx2fc_rport *tgt = (struct bnx2fc_rport *)data;
  32
  33         BNX2FC_TGT_DBG(tgt, "upld_timer - Upload compl not received!!\n");
  34         /* fake upload completion */
  35         clear_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags);
  36         set_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags);
  37         wake_up_interruptible(&tgt->upld_wait);
  38 }
  39
  40 static void bnx2fc_ofld_timer(unsigned long data)
  41 {
  42
  43         struct bnx2fc_rport *tgt = (struct bnx2fc_rport *)data;
  44
  45         BNX2FC_TGT_DBG(tgt, "entered bnx2fc_ofld_timer\n");
  46         /* NOTE: This function should never be called, as
  47          * offload should never timeout
  48          */
  49         /*
  50          * If the timer has expired, this session is dead
  51          * Clear offloaded flag and logout of this device.
  52          * Since OFFLOADED flag is cleared, this case
  53          * will be considered as offload error and the
  54          * port will be logged off, and conn_id, session
  55          * resources are freed up in bnx2fc_offload_session
  56          */
  57         clear_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags);
  58         set_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
  59         wake_up_interruptible(&tgt->ofld_wait);
  60 }
  61
  62 static void bnx2fc_offload_session(struct fcoe_port *port,
  63                                         struct bnx2fc_rport *tgt,
  64                                         struct fc_rport_priv *rdata)
  65 {
  66         struct fc_lport *lport = rdata->local_port;
  67         struct fc_rport *rport = rdata->rport;
  68         struct bnx2fc_hba *hba = port->priv;
  69         int rval;
  70         int i = 0;
  71
  72         /* Initialize bnx2fc_rport */
  73         /* NOTE: tgt is already bzero'd */
  74         rval = bnx2fc_init_tgt(tgt, port, rdata);
  75         if (rval) {
  76                 printk(KERN_ERR PFX "Failed to allocate conn id for "
  77                         "port_id (%6x)\n", rport->port_id);
  78                 goto ofld_err;
  79         }
  80
  81         /* Allocate session resources */
  82         rval = bnx2fc_alloc_session_resc(hba, tgt);
  83         if (rval) {
  84                 printk(KERN_ERR PFX "Failed to allocate resources\n");
  85                 goto ofld_err;
  86         }
  87
  88         /*
  89          * Initialize FCoE session offload process.
  90          * Upon completion of offload process add
  91          * rport to list of rports
  92          */
  93 retry_ofld:
  94         clear_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
  95         rval = bnx2fc_send_session_ofld_req(port, tgt);
  96         if (rval) {
  97                 printk(KERN_ERR PFX "ofld_req failed\n");
  98                 goto ofld_err;
  99         }
 100
 101         /*
 102          * wait for the session is offloaded and enabled. 3 Secs
 103          * should be ample time for this process to complete.
 104          */
 105         setup_timer(&tgt->ofld_timer, bnx2fc_ofld_timer, (unsigned long)tgt);
 106         mod_timer(&tgt->ofld_timer, jiffies + BNX2FC_FW_TIMEOUT);
 107
 108         wait_event_interruptible(tgt->ofld_wait,
 109                                  (test_bit(
 110                                   BNX2FC_FLAG_OFLD_REQ_CMPL,
 111                                   &tgt->flags)));
 112         if (signal_pending(current))
 113                 flush_signals(current);
 114
 115         del_timer_sync(&tgt->ofld_timer);
 116
 117         if (!(test_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags))) {
 118                 if (test_and_clear_bit(BNX2FC_FLAG_CTX_ALLOC_FAILURE,
 119                                        &tgt->flags)) {
 120                         BNX2FC_TGT_DBG(tgt, "ctx_alloc_failure, "
 121                                 "retry ofld..%d\n", i++);
 122                         msleep_interruptible(1000);
 123                         if (i > 3) {
 124                                 i = 0;
 125                                 goto ofld_err;
 126                         }
 127                         goto retry_ofld;
 128                 }
 129                 goto ofld_err;
 130         }
 131         if (bnx2fc_map_doorbell(tgt)) {
 132                 printk(KERN_ERR PFX "map doorbell failed - no mem\n");
 133                 /* upload will take care of cleaning up sess resc */
 134                 lport->tt.rport_logoff(rdata);
 135         }
 136         return;
 137
 138 ofld_err:
 139         /* couldn't offload the session. log off from this rport */
 140         BNX2FC_TGT_DBG(tgt, "bnx2fc_offload_session - offload error\n");
 141         lport->tt.rport_logoff(rdata);
 142         /* Free session resources */
 143         bnx2fc_free_session_resc(hba, tgt);
 144         if (tgt->fcoe_conn_id != -1)
 145                 bnx2fc_free_conn_id(hba, tgt->fcoe_conn_id);
 146 }
 147
 148 void bnx2fc_flush_active_ios(struct bnx2fc_rport *tgt)
 149 {
 150         struct bnx2fc_cmd *io_req;
 151         struct list_head *list;
 152         struct list_head *tmp;
 153         int rc;
 154         int i = 0;
 155         BNX2FC_TGT_DBG(tgt, "Entered flush_active_ios - %d\n",
 156                        tgt->num_active_ios.counter);
 157
 158         spin_lock_bh(&tgt->tgt_lock);
 159         tgt->flush_in_prog = 1;
 160
 161         list_for_each_safe(list, tmp, &tgt->active_cmd_queue) {
 162                 i++;
 163                 io_req = (struct bnx2fc_cmd *)list;
 164                 list_del_init(&io_req->link);
 165                 io_req->on_active_queue = 0;
 166                 BNX2FC_IO_DBG(io_req, "cmd_queue cleanup\n");
 167
 168                 if (cancel_delayed_work(&io_req->timeout_work)) {
 169                         if (test_and_clear_bit(BNX2FC_FLAG_EH_ABORT,
 170                                                 &io_req->req_flags)) {
 171                                 /* Handle eh_abort timeout */
 172                                 BNX2FC_IO_DBG(io_req, "eh_abort for IO "
 173                                               "cleaned up\n");
 174                                 complete(&io_req->tm_done);
 175                         }
 176                         kref_put(&io_req->refcount,
 177                                  bnx2fc_cmd_release); /* drop timer hold */
 178                 }
 179
 180                 set_bit(BNX2FC_FLAG_IO_COMPL, &io_req->req_flags);
 181                 set_bit(BNX2FC_FLAG_IO_CLEANUP, &io_req->req_flags);
 182                 rc = bnx2fc_initiate_cleanup(io_req);
 183                 BUG_ON(rc);
 184         }
 185
 186         list_for_each_safe(list, tmp, &tgt->els_queue) {
 187                 i++;
 188                 io_req = (struct bnx2fc_cmd *)list;
 189                 list_del_init(&io_req->link);
 190                 io_req->on_active_queue = 0;
 191
 192                 BNX2FC_IO_DBG(io_req, "els_queue cleanup\n");
 193
 194                 if (cancel_delayed_work(&io_req->timeout_work))
 195                         kref_put(&io_req->refcount,
 196                                  bnx2fc_cmd_release); /* drop timer hold */
 197
 198                 if ((io_req->cb_func) && (io_req->cb_arg)) {
 199                         io_req->cb_func(io_req->cb_arg);
 200                         io_req->cb_arg = NULL;
 201                 }
 202
 203                 rc = bnx2fc_initiate_cleanup(io_req);
 204                 BUG_ON(rc);
 205         }
 206
 207         list_for_each_safe(list, tmp, &tgt->io_retire_queue) {
 208                 i++;
 209                 io_req = (struct bnx2fc_cmd *)list;
 210                 list_del_init(&io_req->link);
 211
 212                 BNX2FC_IO_DBG(io_req, "retire_queue flush\n");
 213
 214                 if (cancel_delayed_work(&io_req->timeout_work))
 215                         kref_put(&io_req->refcount, bnx2fc_cmd_release);
 216
 217                 clear_bit(BNX2FC_FLAG_ISSUE_RRQ, &io_req->req_flags);
 218         }
 219
 220         BNX2FC_TGT_DBG(tgt, "IOs flushed = %d\n", i);
 221         i = 0;
 222         spin_unlock_bh(&tgt->tgt_lock);
 223         /* wait for active_ios to go to 0 */
 224         while ((tgt->num_active_ios.counter != 0) && (i++ < BNX2FC_WAIT_CNT))
 225                 msleep(25);
 226         if (tgt->num_active_ios.counter != 0)
 227                 printk(KERN_ERR PFX "CLEANUP on port 0x%x:"
 228                                     " active_ios = %d\n",
 229                         tgt->rdata->ids.port_id, tgt->num_active_ios.counter);
 230         spin_lock_bh(&tgt->tgt_lock);
 231         tgt->flush_in_prog = 0;
 232         spin_unlock_bh(&tgt->tgt_lock);
 233 }
 234
 235 static void bnx2fc_upload_session(struct fcoe_port *port,
 236                                         struct bnx2fc_rport *tgt)
 237 {
 238         struct bnx2fc_hba *hba = port->priv;
 239
 240         BNX2FC_TGT_DBG(tgt, "upload_session: active_ios = %d\n",
 241                 tgt->num_active_ios.counter);
 242
 243         /*
 244          * Called with hba->hba_mutex held.
 245          * This is a blocking call
 246          */
 247         clear_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags);
 248         bnx2fc_send_session_disable_req(port, tgt);
 249
 250         /*
 251          * wait for upload to complete. 3 Secs
 252          * should be sufficient time for this process to complete.
 253          */
 254         setup_timer(&tgt->upld_timer, bnx2fc_upld_timer, (unsigned long)tgt);
 255         mod_timer(&tgt->upld_timer, jiffies + BNX2FC_FW_TIMEOUT);
 256
 257         BNX2FC_TGT_DBG(tgt, "waiting for disable compl\n");
 258         wait_event_interruptible(tgt->upld_wait,
 259                                  (test_bit(
 260                                   BNX2FC_FLAG_UPLD_REQ_COMPL,
 261                                   &tgt->flags)));
 262
 263         if (signal_pending(current))
 264                 flush_signals(current);
 265
 266         del_timer_sync(&tgt->upld_timer);
 267
 268         /*
 269          * traverse thru the active_q and tmf_q and cleanup
 270          * IOs in these lists
 271          */
 272         BNX2FC_TGT_DBG(tgt, "flush/upload - disable wait flags = 0x%lx\n",
 273                        tgt->flags);
 274         bnx2fc_flush_active_ios(tgt);
 275
 276         /* Issue destroy KWQE */
 277         if (test_bit(BNX2FC_FLAG_DISABLED, &tgt->flags)) {
 278                 BNX2FC_TGT_DBG(tgt, "send destroy req\n");
 279                 clear_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags);
 280                 bnx2fc_send_session_destroy_req(hba, tgt);
 281
 282                 /* wait for destroy to complete */
 283                 setup_timer(&tgt->upld_timer,
 284                             bnx2fc_upld_timer, (unsigned long)tgt);
 285                 mod_timer(&tgt->upld_timer, jiffies + BNX2FC_FW_TIMEOUT);
 286
 287                 wait_event_interruptible(tgt->upld_wait,
 288                                          (test_bit(
 289                                           BNX2FC_FLAG_UPLD_REQ_COMPL,
 290                                           &tgt->flags)));
 291
 292                 if (!(test_bit(BNX2FC_FLAG_DESTROYED, &tgt->flags)))
 293                         printk(KERN_ERR PFX "ERROR!! destroy timed out\n");
 294
 295                 BNX2FC_TGT_DBG(tgt, "destroy wait complete flags = 0x%lx\n",
 296                         tgt->flags);
 297                 if (signal_pending(current))
 298                         flush_signals(current);
 299
 300                 del_timer_sync(&tgt->upld_timer);
 301
 302         } else
 303                 printk(KERN_ERR PFX "ERROR!! DISABLE req timed out, destroy"
 304                                 " not sent to FW\n");
 305
 306         /* Free session resources */
 307         spin_lock_bh(&tgt->cq_lock);
 308         bnx2fc_free_session_resc(hba, tgt);
 309         bnx2fc_free_conn_id(hba, tgt->fcoe_conn_id);
 310         spin_unlock_bh(&tgt->cq_lock);
 311 }
 312
 313 static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
 314                            struct fcoe_port *port,
 315                            struct fc_rport_priv *rdata)
 316 {
 317
 318         struct fc_rport *rport = rdata->rport;
 319         struct bnx2fc_hba *hba = port->priv;
 320
 321         tgt->rport = rport;
 322         tgt->rdata = rdata;
 323         tgt->port = port;
 324
 325         if (hba->num_ofld_sess >= BNX2FC_NUM_MAX_SESS) {
 326                 BNX2FC_TGT_DBG(tgt, "exceeded max sessions. logoff this tgt\n");
 327                 tgt->fcoe_conn_id = -1;
 328                 return -1;
 329         }
 330
 331         tgt->fcoe_conn_id = bnx2fc_alloc_conn_id(hba, tgt);
 332         if (tgt->fcoe_conn_id == -1)
 333                 return -1;
 334
 335         BNX2FC_TGT_DBG(tgt, "init_tgt - conn_id = 0x%x\n", tgt->fcoe_conn_id);
 336
 337         tgt->max_sqes = BNX2FC_SQ_WQES_MAX;
 338         tgt->max_rqes = BNX2FC_RQ_WQES_MAX;
 339         tgt->max_cqes = BNX2FC_CQ_WQES_MAX;
 340
 341         /* Initialize the toggle bit */
 342         tgt->sq_curr_toggle_bit = 1;
 343         tgt->cq_curr_toggle_bit = 1;
 344         tgt->sq_prod_idx = 0;
 345         tgt->cq_cons_idx = 0;
 346         tgt->rq_prod_idx = 0x8000;
 347         tgt->rq_cons_idx = 0;
 348         atomic_set(&tgt->num_active_ios, 0);
 349
 350         tgt->work_time_slice = 2;
 351
 352         spin_lock_init(&tgt->tgt_lock);
 353         spin_lock_init(&tgt->cq_lock);
 354
 355         /* Initialize active_cmd_queue list */
 356         INIT_LIST_HEAD(&tgt->active_cmd_queue);
 357
 358         /* Initialize IO retire queue */
 359         INIT_LIST_HEAD(&tgt->io_retire_queue);
 360
 361         INIT_LIST_HEAD(&tgt->els_queue);
 362
 363         /* Initialize active_tm_queue list */
 364         INIT_LIST_HEAD(&tgt->active_tm_queue);
 365
 366         init_waitqueue_head(&tgt->ofld_wait);
 367         init_waitqueue_head(&tgt->upld_wait);
 368
 369         return 0;
 370 }
 371
 372 /**
 373  * This event_callback is called after successful completion of libfc
 374  * initiated target login. bnx2fc can proceed with initiating the session
 375  * establishment.
 376  */
 377 void bnx2fc_rport_event_handler(struct fc_lport *lport,
 378                                 struct fc_rport_priv *rdata,
 379                                 enum fc_rport_event event)
 380 {
 381         struct fcoe_port *port = lport_priv(lport);
 382         struct bnx2fc_hba *hba = port->priv;
 383         struct fc_rport *rport = rdata->rport;
 384         struct fc_rport_libfc_priv *rp;
 385         struct bnx2fc_rport *tgt;
 386         u32 port_id;
 387
 388         BNX2FC_HBA_DBG(lport, "rport_event_hdlr: event = %d, port_id = 0x%x\n",
 389                 event, rdata->ids.port_id);
 390         switch (event) {
 391         case RPORT_EV_READY:
 392                 if (!rport) {
 393                         printk(KERN_ALERT PFX "rport is NULL: ERROR!\n");
 394                         break;
 395                 }
 396
 397                 rp = rport->dd_data;
 398                 if (rport->port_id == FC_FID_DIR_SERV) {
 399                         /*
 400                          * bnx2fc_rport structure doesnt exist for
 401                          * directory server.
 402                          * We should not come here, as lport will
 403                          * take care of fabric login
 404                          */
 405                         printk(KERN_ALERT PFX "%x - rport_event_handler ERROR\n",
 406                                 rdata->ids.port_id);
 407                         break;
 408                 }
 409
 410                 if (rdata->spp_type != FC_TYPE_FCP) {
 411                         BNX2FC_HBA_DBG(lport, "not FCP type target."
 412                                    " not offloading\n");
 413                         break;
 414                 }
 415                 if (!(rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET)) {
 416                         BNX2FC_HBA_DBG(lport, "not FCP_TARGET"
 417                                    " not offloading\n");
 418                         break;
 419                 }
 420
 421                 /*
 422                  * Offlaod process is protected with hba mutex.
 423                  * Use the same mutex_lock for upload process too
 424                  */
 425                 mutex_lock(&hba->hba_mutex);
 426                 tgt = (struct bnx2fc_rport *)&rp[1];
 427
 428                 /* This can happen when ADISC finds the same target */
 429                 if (test_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags)) {
 430                         BNX2FC_TGT_DBG(tgt, "already offloaded\n");
 431                         mutex_unlock(&hba->hba_mutex);
 432                         return;
 433                 }
 434
 435                 /*
 436                  * Offload the session. This is a blocking call, and will
 437                  * wait until the session is offloaded.
 438                  */
 439                 bnx2fc_offload_session(port, tgt, rdata);
 440
 441                 BNX2FC_TGT_DBG(tgt, "OFFLOAD num_ofld_sess = %d\n",
 442                         hba->num_ofld_sess);
 443
 444                 if (test_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags)) {
 445                         /*
 446                          * Session is offloaded and enabled. Map
 447                          * doorbell register for this target
 448                          */
 449                         BNX2FC_TGT_DBG(tgt, "sess offloaded\n");
 450                         /* This counter is protected with hba mutex */
 451                         hba->num_ofld_sess++;
 452
 453                         set_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags);
 454                 } else {
 455                         /*
 456                          * Offload or enable would have failed.
 457                          * In offload/enable completion path, the
 458                          * rport would have already been removed
 459                          */
 460                         BNX2FC_TGT_DBG(tgt, "Port is being logged off as "
 461                                    "offloaded flag not set\n");
 462                 }
 463                 mutex_unlock(&hba->hba_mutex);
 464                 break;
 465         case RPORT_EV_LOGO:
 466         case RPORT_EV_FAILED:
 467         case RPORT_EV_STOP:
 468                 port_id = rdata->ids.port_id;
 469                 if (port_id == FC_FID_DIR_SERV)
 470                         break;
 471
 472                 if (!rport) {
 473                         printk(KERN_ALERT PFX "%x - rport not created Yet!!\n",
 474                                 port_id);
 475                         break;
 476                 }
 477                 rp = rport->dd_data;
 478                 mutex_lock(&hba->hba_mutex);
 479                 /*
 480                  * Perform session upload. Note that rdata->peers is already
 481                  * removed from disc->rports list before we get this event.
 482                  */
 483                 tgt = (struct bnx2fc_rport *)&rp[1];
 484
 485                 if (!(test_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags))) {
 486                         mutex_unlock(&hba->hba_mutex);
 487                         break;
 488                 }
 489                 clear_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags);
 490
 491                 bnx2fc_upload_session(port, tgt);
 492                 hba->num_ofld_sess--;
 493                 BNX2FC_TGT_DBG(tgt, "UPLOAD num_ofld_sess = %d\n",
 494                         hba->num_ofld_sess);
 495                 /*
 496                  * Try to wake up the linkdown wait thread. If num_ofld_sess
 497                  * is 0, the waiting therad wakes up
 498                  */
 499                 if ((hba->wait_for_link_down) &&
 500                     (hba->num_ofld_sess == 0)) {
 501                         wake_up_interruptible(&hba->shutdown_wait);
 502                 }
 503                 if (test_bit(BNX2FC_FLAG_EXPL_LOGO, &tgt->flags)) {
 504                         printk(KERN_ERR PFX "Relogin to the tgt\n");
 505                         mutex_lock(&lport->disc.disc_mutex);
 506                         lport->tt.rport_login(rdata);
 507                         mutex_unlock(&lport->disc.disc_mutex);
 508                 }
 509                 mutex_unlock(&hba->hba_mutex);
 510
 511                 break;
 512
 513         case RPORT_EV_NONE:
 514                 break;
 515         }
 516 }
 517
 518 /**
 519  * bnx2fc_tgt_lookup() - Lookup a bnx2fc_rport by port_id
 520  *
 521  * @port:  fcoe_port struct to lookup the target port on
 522  * @port_id: The remote port ID to look up
 523  */
 524 struct bnx2fc_rport *bnx2fc_tgt_lookup(struct fcoe_port *port,
 525                                              u32 port_id)
 526 {
 527         struct bnx2fc_hba *hba = port->priv;
 528         struct bnx2fc_rport *tgt;
 529         struct fc_rport_priv *rdata;
 530         int i;
 531
 532         for (i = 0; i < BNX2FC_NUM_MAX_SESS; i++) {
 533                 tgt = hba->tgt_ofld_list[i];
 534                 if ((tgt) && (tgt->port == port)) {
 535                         rdata = tgt->rdata;
 536                         if (rdata->ids.port_id == port_id) {
 537                                 if (rdata->rp_state != RPORT_ST_DELETE) {
 538                                         BNX2FC_TGT_DBG(tgt, "rport "
 539                                                 "obtained\n");
 540                                         return tgt;
 541                                 } else {
 542                                         printk(KERN_ERR PFX "rport 0x%x "
 543                                                 "is in DELETED state\n",
 544                                                 rdata->ids.port_id);
 545                                         return NULL;
 546                                 }
 547                         }
 548                 }
 549         }
 550         return NULL;
 551 }
 552
 553
 554 /**
 555  * bnx2fc_alloc_conn_id - allocates FCOE Connection id
 556  *
 557  * @hba:        pointer to adapter structure
 558  * @tgt:        pointer to bnx2fc_rport structure
 559  */
 560 static u32 bnx2fc_alloc_conn_id(struct bnx2fc_hba *hba,
 561                                 struct bnx2fc_rport *tgt)
 562 {
 563         u32 conn_id, next;
 564
 565         /* called with hba mutex held */
 566
 567         /*
 568          * tgt_ofld_list access is synchronized using
 569          * both hba mutex and hba lock. Atleast hba mutex or
 570          * hba lock needs to be held for read access.
 571          */
 572
 573         spin_lock_bh(&hba->hba_lock);
 574         next = hba->next_conn_id;
 575         conn_id = hba->next_conn_id++;
 576         if (hba->next_conn_id == BNX2FC_NUM_MAX_SESS)
 577                 hba->next_conn_id = 0;
 578
 579         while (hba->tgt_ofld_list[conn_id] != NULL) {
 580                 conn_id++;
 581                 if (conn_id == BNX2FC_NUM_MAX_SESS)
 582                         conn_id = 0;
 583
 584                 if (conn_id == next) {
 585                         /* No free conn_ids are available */
 586                         spin_unlock_bh(&hba->hba_lock);
 587                         return -1;
 588                 }
 589         }
 590         hba->tgt_ofld_list[conn_id] = tgt;
 591         tgt->fcoe_conn_id = conn_id;
 592         spin_unlock_bh(&hba->hba_lock);
 593         return conn_id;
 594 }
 595
 596 static void bnx2fc_free_conn_id(struct bnx2fc_hba *hba, u32 conn_id)
 597 {
 598         /* called with hba mutex held */
 599         spin_lock_bh(&hba->hba_lock);
 600         hba->tgt_ofld_list[conn_id] = NULL;
 601         hba->next_conn_id = conn_id;
 602         spin_unlock_bh(&hba->hba_lock);
 603 }
 604
 605 /**
 606  *bnx2fc_alloc_session_resc - Allocate qp resources for the session
 607  *
 608  */
 609 static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
 610                                         struct bnx2fc_rport *tgt)
 611 {
 612         dma_addr_t page;
 613         int num_pages;
 614         u32 *pbl;
 615
 616         /* Allocate and map SQ */
 617         tgt->sq_mem_size = tgt->max_sqes * BNX2FC_SQ_WQE_SIZE;
 618         tgt->sq_mem_size = (tgt->sq_mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
 619
 620         tgt->sq = dma_alloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
 621                                      &tgt->sq_dma, GFP_KERNEL);
 622         if (!tgt->sq) {
 623                 printk(KERN_ALERT PFX "unable to allocate SQ memory %d\n",
 624                         tgt->sq_mem_size);
 625                 goto mem_alloc_failure;
 626         }
 627         memset(tgt->sq, 0, tgt->sq_mem_size);
 628
 629         /* Allocate and map CQ */
 630         tgt->cq_mem_size = tgt->max_cqes * BNX2FC_CQ_WQE_SIZE;
 631         tgt->cq_mem_size = (tgt->cq_mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
 632
 633         tgt->cq = dma_alloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
 634                                      &tgt->cq_dma, GFP_KERNEL);
 635         if (!tgt->cq) {
 636                 printk(KERN_ALERT PFX "unable to allocate CQ memory %d\n",
 637                         tgt->cq_mem_size);
 638                 goto mem_alloc_failure;
 639         }
 640         memset(tgt->cq, 0, tgt->cq_mem_size);
 641
 642         /* Allocate and map RQ and RQ PBL */
 643         tgt->rq_mem_size = tgt->max_rqes * BNX2FC_RQ_WQE_SIZE;
 644         tgt->rq_mem_size = (tgt->rq_mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
 645
 646         tgt->rq = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
 647                                         &tgt->rq_dma, GFP_KERNEL);
 648         if (!tgt->rq) {
 649                 printk(KERN_ALERT PFX "unable to allocate RQ memory %d\n",
 650                         tgt->rq_mem_size);
 651                 goto mem_alloc_failure;
 652         }
 653         memset(tgt->rq, 0, tgt->rq_mem_size);
 654
 655         tgt->rq_pbl_size = (tgt->rq_mem_size / PAGE_SIZE) * sizeof(void *);
 656         tgt->rq_pbl_size = (tgt->rq_pbl_size + (PAGE_SIZE - 1)) & PAGE_MASK;
 657
 658         tgt->rq_pbl = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
 659                                          &tgt->rq_pbl_dma, GFP_KERNEL);
 660         if (!tgt->rq_pbl) {
 661                 printk(KERN_ALERT PFX "unable to allocate RQ PBL %d\n",
 662                         tgt->rq_pbl_size);
 663                 goto mem_alloc_failure;
 664         }
 665
 666         memset(tgt->rq_pbl, 0, tgt->rq_pbl_size);
 667         num_pages = tgt->rq_mem_size / PAGE_SIZE;
 668         page = tgt->rq_dma;
 669         pbl = (u32 *)tgt->rq_pbl;
 670
 671         while (num_pages--) {
 672                 *pbl = (u32)page;
 673                 pbl++;
 674                 *pbl = (u32)((u64)page >> 32);
 675                 pbl++;
 676                 page += PAGE_SIZE;
 677         }
 678
 679         /* Allocate and map XFERQ */
 680         tgt->xferq_mem_size = tgt->max_sqes * BNX2FC_XFERQ_WQE_SIZE;
 681         tgt->xferq_mem_size = (tgt->xferq_mem_size + (PAGE_SIZE - 1)) &
 682                                PAGE_MASK;
 683
 684         tgt->xferq = dma_alloc_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,
 685                                         &tgt->xferq_dma, GFP_KERNEL);
 686         if (!tgt->xferq) {
 687                 printk(KERN_ALERT PFX "unable to allocate XFERQ %d\n",
 688                         tgt->xferq_mem_size);
 689                 goto mem_alloc_failure;
 690         }
 691         memset(tgt->xferq, 0, tgt->xferq_mem_size);
 692
 693         /* Allocate and map CONFQ & CONFQ PBL */
 694         tgt->confq_mem_size = tgt->max_sqes * BNX2FC_CONFQ_WQE_SIZE;
 695         tgt->confq_mem_size = (tgt->confq_mem_size + (PAGE_SIZE - 1)) &
 696                                PAGE_MASK;
 697
 698         tgt->confq = dma_alloc_coherent(&hba->pcidev->dev, tgt->confq_mem_size,
 699                                         &tgt->confq_dma, GFP_KERNEL);
 700         if (!tgt->confq) {
 701                 printk(KERN_ALERT PFX "unable to allocate CONFQ %d\n",
 702                         tgt->confq_mem_size);
 703                 goto mem_alloc_failure;
 704         }
 705         memset(tgt->confq, 0, tgt->confq_mem_size);
 706
 707         tgt->confq_pbl_size =
 708                 (tgt->confq_mem_size / PAGE_SIZE) * sizeof(void *);
 709         tgt->confq_pbl_size =
 710                 (tgt->confq_pbl_size + (PAGE_SIZE - 1)) & PAGE_MASK;
 711
 712         tgt->confq_pbl = dma_alloc_coherent(&hba->pcidev->dev,
 713                                             tgt->confq_pbl_size,
 714                                             &tgt->confq_pbl_dma, GFP_KERNEL);
 715         if (!tgt->confq_pbl) {
 716                 printk(KERN_ALERT PFX "unable to allocate CONFQ PBL %d\n",
 717                         tgt->confq_pbl_size);
 718                 goto mem_alloc_failure;
 719         }
 720
 721         memset(tgt->confq_pbl, 0, tgt->confq_pbl_size);
 722         num_pages = tgt->confq_mem_size / PAGE_SIZE;
 723         page = tgt->confq_dma;
 724         pbl = (u32 *)tgt->confq_pbl;
 725
 726         while (num_pages--) {
 727                 *pbl = (u32)page;
 728                 pbl++;
 729                 *pbl = (u32)((u64)page >> 32);
 730                 pbl++;
 731                 page += PAGE_SIZE;
 732         }
 733
 734         /* Allocate and map ConnDB */
 735         tgt->conn_db_mem_size = sizeof(struct fcoe_conn_db);
 736
 737         tgt->conn_db = dma_alloc_coherent(&hba->pcidev->dev,
 738                                           tgt->conn_db_mem_size,
 739                                           &tgt->conn_db_dma, GFP_KERNEL);
 740         if (!tgt->conn_db) {
 741                 printk(KERN_ALERT PFX "unable to allocate conn_db %d\n",
 742                                                 tgt->conn_db_mem_size);
 743                 goto mem_alloc_failure;
 744         }
 745         memset(tgt->conn_db, 0, tgt->conn_db_mem_size);
 746
 747
 748         /* Allocate and map LCQ */
 749         tgt->lcq_mem_size = (tgt->max_sqes + 8) * BNX2FC_SQ_WQE_SIZE;
 750         tgt->lcq_mem_size = (tgt->lcq_mem_size + (PAGE_SIZE - 1)) &
 751                              PAGE_MASK;
 752
 753         tgt->lcq = dma_alloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
 754                                       &tgt->lcq_dma, GFP_KERNEL);
 755
 756         if (!tgt->lcq) {
 757                 printk(KERN_ALERT PFX "unable to allocate lcq %d\n",
 758                        tgt->lcq_mem_size);
 759                 goto mem_alloc_failure;
 760         }
 761         memset(tgt->lcq, 0, tgt->lcq_mem_size);
 762
 763         /* Arm CQ */
 764         tgt->conn_db->cq_arm.lo = -1;
 765         tgt->conn_db->rq_prod = 0x8000;
 766
 767         return 0;
 768
 769 mem_alloc_failure:
 770         bnx2fc_free_session_resc(hba, tgt);
 771         bnx2fc_free_conn_id(hba, tgt->fcoe_conn_id);
 772         return -ENOMEM;
 773 }
 774
 775 /**
 776  * bnx2i_free_session_resc - free qp resources for the session
 777  *
 778  * @hba:        adapter structure pointer
 779  * @tgt:        bnx2fc_rport structure pointer
 780  *
 781  * Free QP resources - SQ/RQ/CQ/XFERQ memory and PBL
 782  */
 783 static void bnx2fc_free_session_resc(struct bnx2fc_hba *hba,
 784                                                 struct bnx2fc_rport *tgt)
 785 {
 786         BNX2FC_TGT_DBG(tgt, "Freeing up session resources\n");
 787
 788         if (tgt->ctx_base) {
 789                 iounmap(tgt->ctx_base);
 790                 tgt->ctx_base = NULL;
 791         }
 792         /* Free LCQ */
 793         if (tgt->lcq) {
 794                 dma_free_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
 795                                     tgt->lcq, tgt->lcq_dma);
 796                 tgt->lcq = NULL;
 797         }
 798         /* Free connDB */
 799         if (tgt->conn_db) {
 800                 dma_free_coherent(&hba->pcidev->dev, tgt->conn_db_mem_size,
 801                                     tgt->conn_db, tgt->conn_db_dma);
 802                 tgt->conn_db = NULL;
 803         }
 804         /* Free confq  and confq pbl */
 805         if (tgt->confq_pbl) {
 806                 dma_free_coherent(&hba->pcidev->dev, tgt->confq_pbl_size,
 807                                     tgt->confq_pbl, tgt->confq_pbl_dma);
 808                 tgt->confq_pbl = NULL;
 809         }
 810         if (tgt->confq) {
 811                 dma_free_coherent(&hba->pcidev->dev, tgt->confq_mem_size,
 812                                     tgt->confq, tgt->confq_dma);
 813                 tgt->confq = NULL;
 814         }
 815         /* Free XFERQ */
 816         if (tgt->xferq) {
 817                 dma_free_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,
 818                                     tgt->xferq, tgt->xferq_dma);
 819                 tgt->xferq = NULL;
 820         }
 821         /* Free RQ PBL and RQ */
 822         if (tgt->rq_pbl) {
 823                 dma_free_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
 824                                     tgt->rq_pbl, tgt->rq_pbl_dma);
 825                 tgt->rq_pbl = NULL;
 826         }
 827         if (tgt->rq) {
 828                 dma_free_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
 829                                     tgt->rq, tgt->rq_dma);
 830                 tgt->rq = NULL;
 831         }
 832         /* Free CQ */
 833         if (tgt->cq) {
 834                 dma_free_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
 835                                     tgt->cq, tgt->cq_dma);
 836                 tgt->cq = NULL;
 837         }
 838         /* Free SQ */
 839         if (tgt->sq) {
 840                 dma_free_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
 841                                     tgt->sq, tgt->sq_dma);
 842                 tgt->sq = NULL;
 843         }
 844 }