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.
5 * Copyright (c) 2008 - 2013 Broadcom Corporation
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.
11 * Written by: Bhanu Prakash Gollapudi (bprakash@broadcom.com)
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);
28 static void bnx2fc_upld_timer(unsigned long data)
31 struct bnx2fc_rport *tgt = (struct bnx2fc_rport *)data;
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 clear_bit(BNX2FC_FLAG_ENABLED, &tgt->flags);
37 set_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags);
38 wake_up_interruptible(&tgt->upld_wait);
41 static void bnx2fc_ofld_timer(unsigned long data)
44 struct bnx2fc_rport *tgt = (struct bnx2fc_rport *)data;
46 BNX2FC_TGT_DBG(tgt, "entered bnx2fc_ofld_timer\n");
47 /* NOTE: This function should never be called, as
48 * offload should never timeout
51 * If the timer has expired, this session is dead
52 * Clear offloaded flag and logout of this device.
53 * Since OFFLOADED flag is cleared, this case
54 * will be considered as offload error and the
55 * port will be logged off, and conn_id, session
56 * resources are freed up in bnx2fc_offload_session
58 clear_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags);
59 clear_bit(BNX2FC_FLAG_ENABLED, &tgt->flags);
60 set_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
61 wake_up_interruptible(&tgt->ofld_wait);
64 static void bnx2fc_ofld_wait(struct bnx2fc_rport *tgt)
66 setup_timer(&tgt->ofld_timer, bnx2fc_ofld_timer, (unsigned long)tgt);
67 mod_timer(&tgt->ofld_timer, jiffies + BNX2FC_FW_TIMEOUT);
69 wait_event_interruptible(tgt->ofld_wait,
71 BNX2FC_FLAG_OFLD_REQ_CMPL,
73 if (signal_pending(current))
74 flush_signals(current);
75 del_timer_sync(&tgt->ofld_timer);
78 static void bnx2fc_offload_session(struct fcoe_port *port,
79 struct bnx2fc_rport *tgt,
80 struct fc_rport_priv *rdata)
82 struct fc_lport *lport = rdata->local_port;
83 struct fc_rport *rport = rdata->rport;
84 struct bnx2fc_interface *interface = port->priv;
85 struct bnx2fc_hba *hba = interface->hba;
89 /* Initialize bnx2fc_rport */
90 /* NOTE: tgt is already bzero'd */
91 rval = bnx2fc_init_tgt(tgt, port, rdata);
93 printk(KERN_ERR PFX "Failed to allocate conn id for "
94 "port_id (%6x)\n", rport->port_id);
98 /* Allocate session resources */
99 rval = bnx2fc_alloc_session_resc(hba, tgt);
101 printk(KERN_ERR PFX "Failed to allocate resources\n");
106 * Initialize FCoE session offload process.
107 * Upon completion of offload process add
108 * rport to list of rports
111 clear_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
112 rval = bnx2fc_send_session_ofld_req(port, tgt);
114 printk(KERN_ERR PFX "ofld_req failed\n");
119 * wait for the session is offloaded and enabled. 3 Secs
120 * should be ample time for this process to complete.
122 bnx2fc_ofld_wait(tgt);
124 if (!(test_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags))) {
125 if (test_and_clear_bit(BNX2FC_FLAG_CTX_ALLOC_FAILURE,
127 BNX2FC_TGT_DBG(tgt, "ctx_alloc_failure, "
128 "retry ofld..%d\n", i++);
129 msleep_interruptible(1000);
138 if (bnx2fc_map_doorbell(tgt)) {
139 printk(KERN_ERR PFX "map doorbell failed - no mem\n");
142 clear_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
143 rval = bnx2fc_send_session_enable_req(port, tgt);
145 pr_err(PFX "enable session failed\n");
148 bnx2fc_ofld_wait(tgt);
149 if (!(test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags)))
154 /* couldn't offload the session. log off from this rport */
155 BNX2FC_TGT_DBG(tgt, "bnx2fc_offload_session - offload error\n");
156 clear_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags);
157 /* Free session resources */
158 bnx2fc_free_session_resc(hba, tgt);
160 if (tgt->fcoe_conn_id != -1)
161 bnx2fc_free_conn_id(hba, tgt->fcoe_conn_id);
162 lport->tt.rport_logoff(rdata);
165 void bnx2fc_flush_active_ios(struct bnx2fc_rport *tgt)
167 struct bnx2fc_cmd *io_req;
168 struct bnx2fc_cmd *tmp;
171 BNX2FC_TGT_DBG(tgt, "Entered flush_active_ios - %d\n",
172 tgt->num_active_ios.counter);
174 spin_lock_bh(&tgt->tgt_lock);
175 tgt->flush_in_prog = 1;
177 list_for_each_entry_safe(io_req, tmp, &tgt->active_cmd_queue, link) {
179 list_del_init(&io_req->link);
180 io_req->on_active_queue = 0;
181 BNX2FC_IO_DBG(io_req, "cmd_queue cleanup\n");
183 if (cancel_delayed_work(&io_req->timeout_work)) {
184 if (test_and_clear_bit(BNX2FC_FLAG_EH_ABORT,
185 &io_req->req_flags)) {
186 /* Handle eh_abort timeout */
187 BNX2FC_IO_DBG(io_req, "eh_abort for IO "
189 complete(&io_req->tm_done);
191 kref_put(&io_req->refcount,
192 bnx2fc_cmd_release); /* drop timer hold */
195 set_bit(BNX2FC_FLAG_IO_COMPL, &io_req->req_flags);
196 set_bit(BNX2FC_FLAG_IO_CLEANUP, &io_req->req_flags);
198 /* Do not issue cleanup when disable request failed */
199 if (test_bit(BNX2FC_FLAG_DISABLE_FAILED, &tgt->flags))
200 bnx2fc_process_cleanup_compl(io_req, io_req->task, 0);
202 rc = bnx2fc_initiate_cleanup(io_req);
207 list_for_each_entry_safe(io_req, tmp, &tgt->active_tm_queue, link) {
209 list_del_init(&io_req->link);
210 io_req->on_tmf_queue = 0;
211 BNX2FC_IO_DBG(io_req, "tm_queue cleanup\n");
212 if (io_req->wait_for_comp)
213 complete(&io_req->tm_done);
216 list_for_each_entry_safe(io_req, tmp, &tgt->els_queue, link) {
218 list_del_init(&io_req->link);
219 io_req->on_active_queue = 0;
221 BNX2FC_IO_DBG(io_req, "els_queue cleanup\n");
223 if (cancel_delayed_work(&io_req->timeout_work))
224 kref_put(&io_req->refcount,
225 bnx2fc_cmd_release); /* drop timer hold */
227 if ((io_req->cb_func) && (io_req->cb_arg)) {
228 io_req->cb_func(io_req->cb_arg);
229 io_req->cb_arg = NULL;
232 /* Do not issue cleanup when disable request failed */
233 if (test_bit(BNX2FC_FLAG_DISABLE_FAILED, &tgt->flags))
234 bnx2fc_process_cleanup_compl(io_req, io_req->task, 0);
236 rc = bnx2fc_initiate_cleanup(io_req);
241 list_for_each_entry_safe(io_req, tmp, &tgt->io_retire_queue, link) {
243 list_del_init(&io_req->link);
245 BNX2FC_IO_DBG(io_req, "retire_queue flush\n");
247 if (cancel_delayed_work(&io_req->timeout_work)) {
248 if (test_and_clear_bit(BNX2FC_FLAG_EH_ABORT,
249 &io_req->req_flags)) {
250 /* Handle eh_abort timeout */
251 BNX2FC_IO_DBG(io_req, "eh_abort for IO "
253 if (io_req->wait_for_comp)
254 complete(&io_req->tm_done);
256 kref_put(&io_req->refcount, bnx2fc_cmd_release);
259 clear_bit(BNX2FC_FLAG_ISSUE_RRQ, &io_req->req_flags);
262 BNX2FC_TGT_DBG(tgt, "IOs flushed = %d\n", i);
264 spin_unlock_bh(&tgt->tgt_lock);
265 /* wait for active_ios to go to 0 */
266 while ((tgt->num_active_ios.counter != 0) && (i++ < BNX2FC_WAIT_CNT))
268 if (tgt->num_active_ios.counter != 0)
269 printk(KERN_ERR PFX "CLEANUP on port 0x%x:"
270 " active_ios = %d\n",
271 tgt->rdata->ids.port_id, tgt->num_active_ios.counter);
272 spin_lock_bh(&tgt->tgt_lock);
273 tgt->flush_in_prog = 0;
274 spin_unlock_bh(&tgt->tgt_lock);
277 static void bnx2fc_upld_wait(struct bnx2fc_rport *tgt)
279 setup_timer(&tgt->upld_timer, bnx2fc_upld_timer, (unsigned long)tgt);
280 mod_timer(&tgt->upld_timer, jiffies + BNX2FC_FW_TIMEOUT);
281 wait_event_interruptible(tgt->upld_wait,
283 BNX2FC_FLAG_UPLD_REQ_COMPL,
285 if (signal_pending(current))
286 flush_signals(current);
287 del_timer_sync(&tgt->upld_timer);
290 static void bnx2fc_upload_session(struct fcoe_port *port,
291 struct bnx2fc_rport *tgt)
293 struct bnx2fc_interface *interface = port->priv;
294 struct bnx2fc_hba *hba = interface->hba;
296 BNX2FC_TGT_DBG(tgt, "upload_session: active_ios = %d\n",
297 tgt->num_active_ios.counter);
300 * Called with hba->hba_mutex held.
301 * This is a blocking call
303 clear_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags);
304 bnx2fc_send_session_disable_req(port, tgt);
307 * wait for upload to complete. 3 Secs
308 * should be sufficient time for this process to complete.
310 BNX2FC_TGT_DBG(tgt, "waiting for disable compl\n");
311 bnx2fc_upld_wait(tgt);
314 * traverse thru the active_q and tmf_q and cleanup
317 BNX2FC_TGT_DBG(tgt, "flush/upload - disable wait flags = 0x%lx\n",
319 bnx2fc_flush_active_ios(tgt);
321 /* Issue destroy KWQE */
322 if (test_bit(BNX2FC_FLAG_DISABLED, &tgt->flags)) {
323 BNX2FC_TGT_DBG(tgt, "send destroy req\n");
324 clear_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags);
325 bnx2fc_send_session_destroy_req(hba, tgt);
327 /* wait for destroy to complete */
328 bnx2fc_upld_wait(tgt);
330 if (!(test_bit(BNX2FC_FLAG_DESTROYED, &tgt->flags)))
331 printk(KERN_ERR PFX "ERROR!! destroy timed out\n");
333 BNX2FC_TGT_DBG(tgt, "destroy wait complete flags = 0x%lx\n",
336 } else if (test_bit(BNX2FC_FLAG_DISABLE_FAILED, &tgt->flags)) {
337 printk(KERN_ERR PFX "ERROR!! DISABLE req failed, destroy"
338 " not sent to FW\n");
340 printk(KERN_ERR PFX "ERROR!! DISABLE req timed out, destroy"
341 " not sent to FW\n");
344 /* Free session resources */
345 bnx2fc_free_session_resc(hba, tgt);
346 bnx2fc_free_conn_id(hba, tgt->fcoe_conn_id);
349 static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
350 struct fcoe_port *port,
351 struct fc_rport_priv *rdata)
354 struct fc_rport *rport = rdata->rport;
355 struct bnx2fc_interface *interface = port->priv;
356 struct bnx2fc_hba *hba = interface->hba;
357 struct b577xx_doorbell_set_prod *sq_db = &tgt->sq_db;
358 struct b577xx_fcoe_rx_doorbell *rx_db = &tgt->rx_db;
364 if (hba->num_ofld_sess >= BNX2FC_NUM_MAX_SESS) {
365 BNX2FC_TGT_DBG(tgt, "exceeded max sessions. logoff this tgt\n");
366 tgt->fcoe_conn_id = -1;
370 tgt->fcoe_conn_id = bnx2fc_alloc_conn_id(hba, tgt);
371 if (tgt->fcoe_conn_id == -1)
374 BNX2FC_TGT_DBG(tgt, "init_tgt - conn_id = 0x%x\n", tgt->fcoe_conn_id);
376 tgt->max_sqes = BNX2FC_SQ_WQES_MAX;
377 tgt->max_rqes = BNX2FC_RQ_WQES_MAX;
378 tgt->max_cqes = BNX2FC_CQ_WQES_MAX;
379 atomic_set(&tgt->free_sqes, BNX2FC_SQ_WQES_MAX);
381 /* Initialize the toggle bit */
382 tgt->sq_curr_toggle_bit = 1;
383 tgt->cq_curr_toggle_bit = 1;
384 tgt->sq_prod_idx = 0;
385 tgt->cq_cons_idx = 0;
386 tgt->rq_prod_idx = 0x8000;
387 tgt->rq_cons_idx = 0;
388 atomic_set(&tgt->num_active_ios, 0);
389 tgt->retry_delay_timestamp = 0;
391 if (rdata->flags & FC_RP_FLAGS_RETRY &&
392 rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET &&
393 !(rdata->ids.roles & FC_RPORT_ROLE_FCP_INITIATOR)) {
394 tgt->dev_type = TYPE_TAPE;
395 tgt->io_timeout = 0; /* use default ULP timeout */
397 tgt->dev_type = TYPE_DISK;
398 tgt->io_timeout = BNX2FC_IO_TIMEOUT;
401 /* initialize sq doorbell */
402 sq_db->header.header = B577XX_DOORBELL_HDR_DB_TYPE;
403 sq_db->header.header |= B577XX_FCOE_CONNECTION_TYPE <<
404 B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT;
405 /* initialize rx doorbell */
406 rx_db->hdr.header = ((0x1 << B577XX_DOORBELL_HDR_RX_SHIFT) |
407 (0x1 << B577XX_DOORBELL_HDR_DB_TYPE_SHIFT) |
408 (B577XX_FCOE_CONNECTION_TYPE <<
409 B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT));
410 rx_db->params = (0x2 << B577XX_FCOE_RX_DOORBELL_NEGATIVE_ARM_SHIFT) |
411 (0x3 << B577XX_FCOE_RX_DOORBELL_OPCODE_SHIFT);
413 spin_lock_init(&tgt->tgt_lock);
414 spin_lock_init(&tgt->cq_lock);
416 /* Initialize active_cmd_queue list */
417 INIT_LIST_HEAD(&tgt->active_cmd_queue);
419 /* Initialize IO retire queue */
420 INIT_LIST_HEAD(&tgt->io_retire_queue);
422 INIT_LIST_HEAD(&tgt->els_queue);
424 /* Initialize active_tm_queue list */
425 INIT_LIST_HEAD(&tgt->active_tm_queue);
427 init_waitqueue_head(&tgt->ofld_wait);
428 init_waitqueue_head(&tgt->upld_wait);
434 * This event_callback is called after successful completion of libfc
435 * initiated target login. bnx2fc can proceed with initiating the session
438 void bnx2fc_rport_event_handler(struct fc_lport *lport,
439 struct fc_rport_priv *rdata,
440 enum fc_rport_event event)
442 struct fcoe_port *port = lport_priv(lport);
443 struct bnx2fc_interface *interface = port->priv;
444 struct bnx2fc_hba *hba = interface->hba;
445 struct fc_rport *rport = rdata->rport;
446 struct fc_rport_libfc_priv *rp;
447 struct bnx2fc_rport *tgt;
450 BNX2FC_HBA_DBG(lport, "rport_event_hdlr: event = %d, port_id = 0x%x\n",
451 event, rdata->ids.port_id);
455 printk(KERN_ERR PFX "rport is NULL: ERROR!\n");
460 if (rport->port_id == FC_FID_DIR_SERV) {
462 * bnx2fc_rport structure doesn't exist for
464 * We should not come here, as lport will
465 * take care of fabric login
467 printk(KERN_ERR PFX "%x - rport_event_handler ERROR\n",
472 if (rdata->spp_type != FC_TYPE_FCP) {
473 BNX2FC_HBA_DBG(lport, "not FCP type target."
474 " not offloading\n");
477 if (!(rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET)) {
478 BNX2FC_HBA_DBG(lport, "not FCP_TARGET"
479 " not offloading\n");
484 * Offlaod process is protected with hba mutex.
485 * Use the same mutex_lock for upload process too
487 mutex_lock(&hba->hba_mutex);
488 tgt = (struct bnx2fc_rport *)&rp[1];
490 /* This can happen when ADISC finds the same target */
491 if (test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags)) {
492 BNX2FC_TGT_DBG(tgt, "already offloaded\n");
493 mutex_unlock(&hba->hba_mutex);
498 * Offload the session. This is a blocking call, and will
499 * wait until the session is offloaded.
501 bnx2fc_offload_session(port, tgt, rdata);
503 BNX2FC_TGT_DBG(tgt, "OFFLOAD num_ofld_sess = %d\n",
506 if (test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags)) {
507 /* Session is offloaded and enabled. */
508 BNX2FC_TGT_DBG(tgt, "sess offloaded\n");
509 /* This counter is protected with hba mutex */
510 hba->num_ofld_sess++;
512 set_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags);
515 * Offload or enable would have failed.
516 * In offload/enable completion path, the
517 * rport would have already been removed
519 BNX2FC_TGT_DBG(tgt, "Port is being logged off as "
520 "offloaded flag not set\n");
522 mutex_unlock(&hba->hba_mutex);
525 case RPORT_EV_FAILED:
527 port_id = rdata->ids.port_id;
528 if (port_id == FC_FID_DIR_SERV)
532 printk(KERN_INFO PFX "%x - rport not created Yet!!\n",
537 mutex_lock(&hba->hba_mutex);
539 * Perform session upload. Note that rdata->peers is already
540 * removed from disc->rports list before we get this event.
542 tgt = (struct bnx2fc_rport *)&rp[1];
544 if (!(test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags))) {
545 mutex_unlock(&hba->hba_mutex);
548 clear_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags);
550 bnx2fc_upload_session(port, tgt);
551 hba->num_ofld_sess--;
552 BNX2FC_TGT_DBG(tgt, "UPLOAD num_ofld_sess = %d\n",
555 * Try to wake up the linkdown wait thread. If num_ofld_sess
556 * is 0, the waiting therad wakes up
558 if ((hba->wait_for_link_down) &&
559 (hba->num_ofld_sess == 0)) {
560 wake_up_interruptible(&hba->shutdown_wait);
562 if (test_bit(BNX2FC_FLAG_EXPL_LOGO, &tgt->flags)) {
563 printk(KERN_ERR PFX "Relogin to the tgt\n");
564 mutex_lock(&lport->disc.disc_mutex);
565 lport->tt.rport_login(rdata);
566 mutex_unlock(&lport->disc.disc_mutex);
568 mutex_unlock(&hba->hba_mutex);
578 * bnx2fc_tgt_lookup() - Lookup a bnx2fc_rport by port_id
580 * @port: fcoe_port struct to lookup the target port on
581 * @port_id: The remote port ID to look up
583 struct bnx2fc_rport *bnx2fc_tgt_lookup(struct fcoe_port *port,
586 struct bnx2fc_interface *interface = port->priv;
587 struct bnx2fc_hba *hba = interface->hba;
588 struct bnx2fc_rport *tgt;
589 struct fc_rport_priv *rdata;
592 for (i = 0; i < BNX2FC_NUM_MAX_SESS; i++) {
593 tgt = hba->tgt_ofld_list[i];
594 if ((tgt) && (tgt->port == port)) {
596 if (rdata->ids.port_id == port_id) {
597 if (rdata->rp_state != RPORT_ST_DELETE) {
598 BNX2FC_TGT_DBG(tgt, "rport "
602 BNX2FC_TGT_DBG(tgt, "rport 0x%x "
603 "is in DELETED state\n",
615 * bnx2fc_alloc_conn_id - allocates FCOE Connection id
617 * @hba: pointer to adapter structure
618 * @tgt: pointer to bnx2fc_rport structure
620 static u32 bnx2fc_alloc_conn_id(struct bnx2fc_hba *hba,
621 struct bnx2fc_rport *tgt)
625 /* called with hba mutex held */
628 * tgt_ofld_list access is synchronized using
629 * both hba mutex and hba lock. Atleast hba mutex or
630 * hba lock needs to be held for read access.
633 spin_lock_bh(&hba->hba_lock);
634 next = hba->next_conn_id;
635 conn_id = hba->next_conn_id++;
636 if (hba->next_conn_id == BNX2FC_NUM_MAX_SESS)
637 hba->next_conn_id = 0;
639 while (hba->tgt_ofld_list[conn_id] != NULL) {
641 if (conn_id == BNX2FC_NUM_MAX_SESS)
644 if (conn_id == next) {
645 /* No free conn_ids are available */
646 spin_unlock_bh(&hba->hba_lock);
650 hba->tgt_ofld_list[conn_id] = tgt;
651 tgt->fcoe_conn_id = conn_id;
652 spin_unlock_bh(&hba->hba_lock);
656 static void bnx2fc_free_conn_id(struct bnx2fc_hba *hba, u32 conn_id)
658 /* called with hba mutex held */
659 spin_lock_bh(&hba->hba_lock);
660 hba->tgt_ofld_list[conn_id] = NULL;
661 spin_unlock_bh(&hba->hba_lock);
665 *bnx2fc_alloc_session_resc - Allocate qp resources for the session
668 static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
669 struct bnx2fc_rport *tgt)
675 /* Allocate and map SQ */
676 tgt->sq_mem_size = tgt->max_sqes * BNX2FC_SQ_WQE_SIZE;
677 tgt->sq_mem_size = (tgt->sq_mem_size + (CNIC_PAGE_SIZE - 1)) &
680 tgt->sq = dma_alloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
681 &tgt->sq_dma, GFP_KERNEL);
683 printk(KERN_ERR PFX "unable to allocate SQ memory %d\n",
685 goto mem_alloc_failure;
687 memset(tgt->sq, 0, tgt->sq_mem_size);
689 /* Allocate and map CQ */
690 tgt->cq_mem_size = tgt->max_cqes * BNX2FC_CQ_WQE_SIZE;
691 tgt->cq_mem_size = (tgt->cq_mem_size + (CNIC_PAGE_SIZE - 1)) &
694 tgt->cq = dma_alloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
695 &tgt->cq_dma, GFP_KERNEL);
697 printk(KERN_ERR PFX "unable to allocate CQ memory %d\n",
699 goto mem_alloc_failure;
701 memset(tgt->cq, 0, tgt->cq_mem_size);
703 /* Allocate and map RQ and RQ PBL */
704 tgt->rq_mem_size = tgt->max_rqes * BNX2FC_RQ_WQE_SIZE;
705 tgt->rq_mem_size = (tgt->rq_mem_size + (CNIC_PAGE_SIZE - 1)) &
708 tgt->rq = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
709 &tgt->rq_dma, GFP_KERNEL);
711 printk(KERN_ERR PFX "unable to allocate RQ memory %d\n",
713 goto mem_alloc_failure;
715 memset(tgt->rq, 0, tgt->rq_mem_size);
717 tgt->rq_pbl_size = (tgt->rq_mem_size / CNIC_PAGE_SIZE) * sizeof(void *);
718 tgt->rq_pbl_size = (tgt->rq_pbl_size + (CNIC_PAGE_SIZE - 1)) &
721 tgt->rq_pbl = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
722 &tgt->rq_pbl_dma, GFP_KERNEL);
724 printk(KERN_ERR PFX "unable to allocate RQ PBL %d\n",
726 goto mem_alloc_failure;
729 memset(tgt->rq_pbl, 0, tgt->rq_pbl_size);
730 num_pages = tgt->rq_mem_size / CNIC_PAGE_SIZE;
732 pbl = (u32 *)tgt->rq_pbl;
734 while (num_pages--) {
737 *pbl = (u32)((u64)page >> 32);
739 page += CNIC_PAGE_SIZE;
742 /* Allocate and map XFERQ */
743 tgt->xferq_mem_size = tgt->max_sqes * BNX2FC_XFERQ_WQE_SIZE;
744 tgt->xferq_mem_size = (tgt->xferq_mem_size + (CNIC_PAGE_SIZE - 1)) &
747 tgt->xferq = dma_alloc_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,
748 &tgt->xferq_dma, GFP_KERNEL);
750 printk(KERN_ERR PFX "unable to allocate XFERQ %d\n",
751 tgt->xferq_mem_size);
752 goto mem_alloc_failure;
754 memset(tgt->xferq, 0, tgt->xferq_mem_size);
756 /* Allocate and map CONFQ & CONFQ PBL */
757 tgt->confq_mem_size = tgt->max_sqes * BNX2FC_CONFQ_WQE_SIZE;
758 tgt->confq_mem_size = (tgt->confq_mem_size + (CNIC_PAGE_SIZE - 1)) &
761 tgt->confq = dma_alloc_coherent(&hba->pcidev->dev, tgt->confq_mem_size,
762 &tgt->confq_dma, GFP_KERNEL);
764 printk(KERN_ERR PFX "unable to allocate CONFQ %d\n",
765 tgt->confq_mem_size);
766 goto mem_alloc_failure;
768 memset(tgt->confq, 0, tgt->confq_mem_size);
770 tgt->confq_pbl_size =
771 (tgt->confq_mem_size / CNIC_PAGE_SIZE) * sizeof(void *);
772 tgt->confq_pbl_size =
773 (tgt->confq_pbl_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
775 tgt->confq_pbl = dma_alloc_coherent(&hba->pcidev->dev,
777 &tgt->confq_pbl_dma, GFP_KERNEL);
778 if (!tgt->confq_pbl) {
779 printk(KERN_ERR PFX "unable to allocate CONFQ PBL %d\n",
780 tgt->confq_pbl_size);
781 goto mem_alloc_failure;
784 memset(tgt->confq_pbl, 0, tgt->confq_pbl_size);
785 num_pages = tgt->confq_mem_size / CNIC_PAGE_SIZE;
786 page = tgt->confq_dma;
787 pbl = (u32 *)tgt->confq_pbl;
789 while (num_pages--) {
792 *pbl = (u32)((u64)page >> 32);
794 page += CNIC_PAGE_SIZE;
797 /* Allocate and map ConnDB */
798 tgt->conn_db_mem_size = sizeof(struct fcoe_conn_db);
800 tgt->conn_db = dma_alloc_coherent(&hba->pcidev->dev,
801 tgt->conn_db_mem_size,
802 &tgt->conn_db_dma, GFP_KERNEL);
804 printk(KERN_ERR PFX "unable to allocate conn_db %d\n",
805 tgt->conn_db_mem_size);
806 goto mem_alloc_failure;
808 memset(tgt->conn_db, 0, tgt->conn_db_mem_size);
811 /* Allocate and map LCQ */
812 tgt->lcq_mem_size = (tgt->max_sqes + 8) * BNX2FC_SQ_WQE_SIZE;
813 tgt->lcq_mem_size = (tgt->lcq_mem_size + (CNIC_PAGE_SIZE - 1)) &
816 tgt->lcq = dma_alloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
817 &tgt->lcq_dma, GFP_KERNEL);
820 printk(KERN_ERR PFX "unable to allocate lcq %d\n",
822 goto mem_alloc_failure;
824 memset(tgt->lcq, 0, tgt->lcq_mem_size);
826 tgt->conn_db->rq_prod = 0x8000;
835 * bnx2i_free_session_resc - free qp resources for the session
837 * @hba: adapter structure pointer
838 * @tgt: bnx2fc_rport structure pointer
840 * Free QP resources - SQ/RQ/CQ/XFERQ memory and PBL
842 static void bnx2fc_free_session_resc(struct bnx2fc_hba *hba,
843 struct bnx2fc_rport *tgt)
845 void __iomem *ctx_base_ptr;
847 BNX2FC_TGT_DBG(tgt, "Freeing up session resources\n");
849 spin_lock_bh(&tgt->cq_lock);
850 ctx_base_ptr = tgt->ctx_base;
851 tgt->ctx_base = NULL;
855 dma_free_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
856 tgt->lcq, tgt->lcq_dma);
861 dma_free_coherent(&hba->pcidev->dev, tgt->conn_db_mem_size,
862 tgt->conn_db, tgt->conn_db_dma);
865 /* Free confq and confq pbl */
866 if (tgt->confq_pbl) {
867 dma_free_coherent(&hba->pcidev->dev, tgt->confq_pbl_size,
868 tgt->confq_pbl, tgt->confq_pbl_dma);
869 tgt->confq_pbl = NULL;
872 dma_free_coherent(&hba->pcidev->dev, tgt->confq_mem_size,
873 tgt->confq, tgt->confq_dma);
878 dma_free_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,
879 tgt->xferq, tgt->xferq_dma);
882 /* Free RQ PBL and RQ */
884 dma_free_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
885 tgt->rq_pbl, tgt->rq_pbl_dma);
889 dma_free_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
890 tgt->rq, tgt->rq_dma);
895 dma_free_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
896 tgt->cq, tgt->cq_dma);
901 dma_free_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
902 tgt->sq, tgt->sq_dma);
905 spin_unlock_bh(&tgt->cq_lock);
908 iounmap(ctx_base_ptr);