1
2
3
4
5
6
7
8
9
10
11
12
13
14#include "bnx2fc.h"
15static void bnx2fc_upld_timer(unsigned long data);
16static void bnx2fc_ofld_timer(unsigned long data);
17static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
18 struct fcoe_port *port,
19 struct fc_rport_priv *rdata);
20static u32 bnx2fc_alloc_conn_id(struct bnx2fc_hba *hba,
21 struct bnx2fc_rport *tgt);
22static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
23 struct bnx2fc_rport *tgt);
24static void bnx2fc_free_session_resc(struct bnx2fc_hba *hba,
25 struct bnx2fc_rport *tgt);
26static void bnx2fc_free_conn_id(struct bnx2fc_hba *hba, u32 conn_id);
27
28static 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
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);
39}
40
41static void bnx2fc_ofld_timer(unsigned long data)
42{
43
44 struct bnx2fc_rport *tgt = (struct bnx2fc_rport *)data;
45
46 BNX2FC_TGT_DBG(tgt, "entered bnx2fc_ofld_timer\n");
47
48
49
50
51
52
53
54
55
56
57
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);
62}
63
64static void bnx2fc_ofld_wait(struct bnx2fc_rport *tgt)
65{
66 setup_timer(&tgt->ofld_timer, bnx2fc_ofld_timer, (unsigned long)tgt);
67 mod_timer(&tgt->ofld_timer, jiffies + BNX2FC_FW_TIMEOUT);
68
69 wait_event_interruptible(tgt->ofld_wait,
70 (test_bit(
71 BNX2FC_FLAG_OFLD_REQ_CMPL,
72 &tgt->flags)));
73 if (signal_pending(current))
74 flush_signals(current);
75 del_timer_sync(&tgt->ofld_timer);
76}
77
78static void bnx2fc_offload_session(struct fcoe_port *port,
79 struct bnx2fc_rport *tgt,
80 struct fc_rport_priv *rdata)
81{
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;
86 int rval;
87 int i = 0;
88
89
90
91 rval = bnx2fc_init_tgt(tgt, port, rdata);
92 if (rval) {
93 printk(KERN_ERR PFX "Failed to allocate conn id for "
94 "port_id (%6x)\n", rport->port_id);
95 goto tgt_init_err;
96 }
97
98
99 rval = bnx2fc_alloc_session_resc(hba, tgt);
100 if (rval) {
101 printk(KERN_ERR PFX "Failed to allocate resources\n");
102 goto ofld_err;
103 }
104
105
106
107
108
109
110retry_ofld:
111 clear_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
112 rval = bnx2fc_send_session_ofld_req(port, tgt);
113 if (rval) {
114 printk(KERN_ERR PFX "ofld_req failed\n");
115 goto ofld_err;
116 }
117
118
119
120
121
122 bnx2fc_ofld_wait(tgt);
123
124 if (!(test_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags))) {
125 if (test_and_clear_bit(BNX2FC_FLAG_CTX_ALLOC_FAILURE,
126 &tgt->flags)) {
127 BNX2FC_TGT_DBG(tgt, "ctx_alloc_failure, "
128 "retry ofld..%d\n", i++);
129 msleep_interruptible(1000);
130 if (i > 3) {
131 i = 0;
132 goto ofld_err;
133 }
134 goto retry_ofld;
135 }
136 goto ofld_err;
137 }
138 if (bnx2fc_map_doorbell(tgt)) {
139 printk(KERN_ERR PFX "map doorbell failed - no mem\n");
140 goto ofld_err;
141 }
142 clear_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
143 rval = bnx2fc_send_session_enable_req(port, tgt);
144 if (rval) {
145 pr_err(PFX "enable session failed\n");
146 goto ofld_err;
147 }
148 bnx2fc_ofld_wait(tgt);
149 if (!(test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags)))
150 goto ofld_err;
151 return;
152
153ofld_err:
154
155 BNX2FC_TGT_DBG(tgt, "bnx2fc_offload_session - offload error\n");
156 clear_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags);
157
158 bnx2fc_free_session_resc(hba, tgt);
159tgt_init_err:
160 if (tgt->fcoe_conn_id != -1)
161 bnx2fc_free_conn_id(hba, tgt->fcoe_conn_id);
162 lport->tt.rport_logoff(rdata);
163}
164
165void bnx2fc_flush_active_ios(struct bnx2fc_rport *tgt)
166{
167 struct bnx2fc_cmd *io_req;
168 struct bnx2fc_cmd *tmp;
169 int rc;
170 int i = 0;
171 BNX2FC_TGT_DBG(tgt, "Entered flush_active_ios - %d\n",
172 tgt->num_active_ios.counter);
173
174 spin_lock_bh(&tgt->tgt_lock);
175 tgt->flush_in_prog = 1;
176
177 list_for_each_entry_safe(io_req, tmp, &tgt->active_cmd_queue, link) {
178 i++;
179 list_del_init(&io_req->link);
180 io_req->on_active_queue = 0;
181 BNX2FC_IO_DBG(io_req, "cmd_queue cleanup\n");
182
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
187 BNX2FC_IO_DBG(io_req, "eh_abort for IO "
188 "cleaned up\n");
189 complete(&io_req->tm_done);
190 }
191 kref_put(&io_req->refcount,
192 bnx2fc_cmd_release);
193 }
194
195 set_bit(BNX2FC_FLAG_IO_COMPL, &io_req->req_flags);
196 set_bit(BNX2FC_FLAG_IO_CLEANUP, &io_req->req_flags);
197
198
199 if (test_bit(BNX2FC_FLAG_DISABLE_FAILED, &tgt->flags))
200 bnx2fc_process_cleanup_compl(io_req, io_req->task, 0);
201 else {
202 rc = bnx2fc_initiate_cleanup(io_req);
203 BUG_ON(rc);
204 }
205 }
206
207 list_for_each_entry_safe(io_req, tmp, &tgt->active_tm_queue, link) {
208 i++;
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);
214 }
215
216 list_for_each_entry_safe(io_req, tmp, &tgt->els_queue, link) {
217 i++;
218 list_del_init(&io_req->link);
219 io_req->on_active_queue = 0;
220
221 BNX2FC_IO_DBG(io_req, "els_queue cleanup\n");
222
223 if (cancel_delayed_work(&io_req->timeout_work))
224 kref_put(&io_req->refcount,
225 bnx2fc_cmd_release);
226
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;
230 }
231
232
233 if (test_bit(BNX2FC_FLAG_DISABLE_FAILED, &tgt->flags))
234 bnx2fc_process_cleanup_compl(io_req, io_req->task, 0);
235 else {
236 rc = bnx2fc_initiate_cleanup(io_req);
237 BUG_ON(rc);
238 }
239 }
240
241 list_for_each_entry_safe(io_req, tmp, &tgt->io_retire_queue, link) {
242 i++;
243 list_del_init(&io_req->link);
244
245 BNX2FC_IO_DBG(io_req, "retire_queue flush\n");
246
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
251 BNX2FC_IO_DBG(io_req, "eh_abort for IO "
252 "in retire_q\n");
253 if (io_req->wait_for_comp)
254 complete(&io_req->tm_done);
255 }
256 kref_put(&io_req->refcount, bnx2fc_cmd_release);
257 }
258
259 clear_bit(BNX2FC_FLAG_ISSUE_RRQ, &io_req->req_flags);
260 }
261
262 BNX2FC_TGT_DBG(tgt, "IOs flushed = %d\n", i);
263 i = 0;
264 spin_unlock_bh(&tgt->tgt_lock);
265
266 while ((tgt->num_active_ios.counter != 0) && (i++ < BNX2FC_WAIT_CNT))
267 msleep(25);
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);
275}
276
277static void bnx2fc_upld_wait(struct bnx2fc_rport *tgt)
278{
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,
282 (test_bit(
283 BNX2FC_FLAG_UPLD_REQ_COMPL,
284 &tgt->flags)));
285 if (signal_pending(current))
286 flush_signals(current);
287 del_timer_sync(&tgt->upld_timer);
288}
289
290static void bnx2fc_upload_session(struct fcoe_port *port,
291 struct bnx2fc_rport *tgt)
292{
293 struct bnx2fc_interface *interface = port->priv;
294 struct bnx2fc_hba *hba = interface->hba;
295
296 BNX2FC_TGT_DBG(tgt, "upload_session: active_ios = %d\n",
297 tgt->num_active_ios.counter);
298
299
300
301
302
303 clear_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags);
304 bnx2fc_send_session_disable_req(port, tgt);
305
306
307
308
309
310 BNX2FC_TGT_DBG(tgt, "waiting for disable compl\n");
311 bnx2fc_upld_wait(tgt);
312
313
314
315
316
317 BNX2FC_TGT_DBG(tgt, "flush/upload - disable wait flags = 0x%lx\n",
318 tgt->flags);
319 bnx2fc_flush_active_ios(tgt);
320
321
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);
326
327
328 bnx2fc_upld_wait(tgt);
329
330 if (!(test_bit(BNX2FC_FLAG_DESTROYED, &tgt->flags)))
331 printk(KERN_ERR PFX "ERROR!! destroy timed out\n");
332
333 BNX2FC_TGT_DBG(tgt, "destroy wait complete flags = 0x%lx\n",
334 tgt->flags);
335
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");
339 } else {
340 printk(KERN_ERR PFX "ERROR!! DISABLE req timed out, destroy"
341 " not sent to FW\n");
342 }
343
344
345 bnx2fc_free_session_resc(hba, tgt);
346 bnx2fc_free_conn_id(hba, tgt->fcoe_conn_id);
347}
348
349static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
350 struct fcoe_port *port,
351 struct fc_rport_priv *rdata)
352{
353
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;
359
360 tgt->rport = rport;
361 tgt->rdata = rdata;
362 tgt->port = port;
363
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;
367 return -1;
368 }
369
370 tgt->fcoe_conn_id = bnx2fc_alloc_conn_id(hba, tgt);
371 if (tgt->fcoe_conn_id == -1)
372 return -1;
373
374 BNX2FC_TGT_DBG(tgt, "init_tgt - conn_id = 0x%x\n", tgt->fcoe_conn_id);
375
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);
380
381
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
390 if (rdata->flags & FC_RP_FLAGS_RETRY &&
391 rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET &&
392 !(rdata->ids.roles & FC_RPORT_ROLE_FCP_INITIATOR)) {
393 tgt->dev_type = TYPE_TAPE;
394 tgt->io_timeout = 0;
395 } else {
396 tgt->dev_type = TYPE_DISK;
397 tgt->io_timeout = BNX2FC_IO_TIMEOUT;
398 }
399
400
401 sq_db->header.header = B577XX_DOORBELL_HDR_DB_TYPE;
402 sq_db->header.header |= B577XX_FCOE_CONNECTION_TYPE <<
403 B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT;
404
405 rx_db->hdr.header = ((0x1 << B577XX_DOORBELL_HDR_RX_SHIFT) |
406 (0x1 << B577XX_DOORBELL_HDR_DB_TYPE_SHIFT) |
407 (B577XX_FCOE_CONNECTION_TYPE <<
408 B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT));
409 rx_db->params = (0x2 << B577XX_FCOE_RX_DOORBELL_NEGATIVE_ARM_SHIFT) |
410 (0x3 << B577XX_FCOE_RX_DOORBELL_OPCODE_SHIFT);
411
412 spin_lock_init(&tgt->tgt_lock);
413 spin_lock_init(&tgt->cq_lock);
414
415
416 INIT_LIST_HEAD(&tgt->active_cmd_queue);
417
418
419 INIT_LIST_HEAD(&tgt->io_retire_queue);
420
421 INIT_LIST_HEAD(&tgt->els_queue);
422
423
424 INIT_LIST_HEAD(&tgt->active_tm_queue);
425
426 init_waitqueue_head(&tgt->ofld_wait);
427 init_waitqueue_head(&tgt->upld_wait);
428
429 return 0;
430}
431
432
433
434
435
436
437void bnx2fc_rport_event_handler(struct fc_lport *lport,
438 struct fc_rport_priv *rdata,
439 enum fc_rport_event event)
440{
441 struct fcoe_port *port = lport_priv(lport);
442 struct bnx2fc_interface *interface = port->priv;
443 struct bnx2fc_hba *hba = interface->hba;
444 struct fc_rport *rport = rdata->rport;
445 struct fc_rport_libfc_priv *rp;
446 struct bnx2fc_rport *tgt;
447 u32 port_id;
448
449 BNX2FC_HBA_DBG(lport, "rport_event_hdlr: event = %d, port_id = 0x%x\n",
450 event, rdata->ids.port_id);
451 switch (event) {
452 case RPORT_EV_READY:
453 if (!rport) {
454 printk(KERN_ERR PFX "rport is NULL: ERROR!\n");
455 break;
456 }
457
458 rp = rport->dd_data;
459 if (rport->port_id == FC_FID_DIR_SERV) {
460
461
462
463
464
465
466 printk(KERN_ERR PFX "%x - rport_event_handler ERROR\n",
467 rdata->ids.port_id);
468 break;
469 }
470
471 if (rdata->spp_type != FC_TYPE_FCP) {
472 BNX2FC_HBA_DBG(lport, "not FCP type target."
473 " not offloading\n");
474 break;
475 }
476 if (!(rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET)) {
477 BNX2FC_HBA_DBG(lport, "not FCP_TARGET"
478 " not offloading\n");
479 break;
480 }
481
482
483
484
485
486 mutex_lock(&hba->hba_mutex);
487 tgt = (struct bnx2fc_rport *)&rp[1];
488
489
490 if (test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags)) {
491 BNX2FC_TGT_DBG(tgt, "already offloaded\n");
492 mutex_unlock(&hba->hba_mutex);
493 return;
494 }
495
496
497
498
499
500 bnx2fc_offload_session(port, tgt, rdata);
501
502 BNX2FC_TGT_DBG(tgt, "OFFLOAD num_ofld_sess = %d\n",
503 hba->num_ofld_sess);
504
505 if (test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags)) {
506
507 BNX2FC_TGT_DBG(tgt, "sess offloaded\n");
508
509 hba->num_ofld_sess++;
510
511 set_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags);
512 } else {
513
514
515
516
517
518 BNX2FC_TGT_DBG(tgt, "Port is being logged off as "
519 "offloaded flag not set\n");
520 }
521 mutex_unlock(&hba->hba_mutex);
522 break;
523 case RPORT_EV_LOGO:
524 case RPORT_EV_FAILED:
525 case RPORT_EV_STOP:
526 port_id = rdata->ids.port_id;
527 if (port_id == FC_FID_DIR_SERV)
528 break;
529
530 if (!rport) {
531 printk(KERN_INFO PFX "%x - rport not created Yet!!\n",
532 port_id);
533 break;
534 }
535 rp = rport->dd_data;
536 mutex_lock(&hba->hba_mutex);
537
538
539
540
541 tgt = (struct bnx2fc_rport *)&rp[1];
542
543 if (!(test_bit(BNX2FC_FLAG_ENABLED, &tgt->flags))) {
544 mutex_unlock(&hba->hba_mutex);
545 break;
546 }
547 clear_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags);
548
549 bnx2fc_upload_session(port, tgt);
550 hba->num_ofld_sess--;
551 BNX2FC_TGT_DBG(tgt, "UPLOAD num_ofld_sess = %d\n",
552 hba->num_ofld_sess);
553
554
555
556
557 if ((hba->wait_for_link_down) &&
558 (hba->num_ofld_sess == 0)) {
559 wake_up_interruptible(&hba->shutdown_wait);
560 }
561 if (test_bit(BNX2FC_FLAG_EXPL_LOGO, &tgt->flags)) {
562 printk(KERN_ERR PFX "Relogin to the tgt\n");
563 mutex_lock(&lport->disc.disc_mutex);
564 lport->tt.rport_login(rdata);
565 mutex_unlock(&lport->disc.disc_mutex);
566 }
567 mutex_unlock(&hba->hba_mutex);
568
569 break;
570
571 case RPORT_EV_NONE:
572 break;
573 }
574}
575
576
577
578
579
580
581
582struct bnx2fc_rport *bnx2fc_tgt_lookup(struct fcoe_port *port,
583 u32 port_id)
584{
585 struct bnx2fc_interface *interface = port->priv;
586 struct bnx2fc_hba *hba = interface->hba;
587 struct bnx2fc_rport *tgt;
588 struct fc_rport_priv *rdata;
589 int i;
590
591 for (i = 0; i < BNX2FC_NUM_MAX_SESS; i++) {
592 tgt = hba->tgt_ofld_list[i];
593 if ((tgt) && (tgt->port == port)) {
594 rdata = tgt->rdata;
595 if (rdata->ids.port_id == port_id) {
596 if (rdata->rp_state != RPORT_ST_DELETE) {
597 BNX2FC_TGT_DBG(tgt, "rport "
598 "obtained\n");
599 return tgt;
600 } else {
601 BNX2FC_TGT_DBG(tgt, "rport 0x%x "
602 "is in DELETED state\n",
603 rdata->ids.port_id);
604 return NULL;
605 }
606 }
607 }
608 }
609 return NULL;
610}
611
612
613
614
615
616
617
618
619static u32 bnx2fc_alloc_conn_id(struct bnx2fc_hba *hba,
620 struct bnx2fc_rport *tgt)
621{
622 u32 conn_id, next;
623
624
625
626
627
628
629
630
631
632 spin_lock_bh(&hba->hba_lock);
633 next = hba->next_conn_id;
634 conn_id = hba->next_conn_id++;
635 if (hba->next_conn_id == BNX2FC_NUM_MAX_SESS)
636 hba->next_conn_id = 0;
637
638 while (hba->tgt_ofld_list[conn_id] != NULL) {
639 conn_id++;
640 if (conn_id == BNX2FC_NUM_MAX_SESS)
641 conn_id = 0;
642
643 if (conn_id == next) {
644
645 spin_unlock_bh(&hba->hba_lock);
646 return -1;
647 }
648 }
649 hba->tgt_ofld_list[conn_id] = tgt;
650 tgt->fcoe_conn_id = conn_id;
651 spin_unlock_bh(&hba->hba_lock);
652 return conn_id;
653}
654
655static void bnx2fc_free_conn_id(struct bnx2fc_hba *hba, u32 conn_id)
656{
657
658 spin_lock_bh(&hba->hba_lock);
659 hba->tgt_ofld_list[conn_id] = NULL;
660 spin_unlock_bh(&hba->hba_lock);
661}
662
663
664
665
666
667static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
668 struct bnx2fc_rport *tgt)
669{
670 dma_addr_t page;
671 int num_pages;
672 u32 *pbl;
673
674
675 tgt->sq_mem_size = tgt->max_sqes * BNX2FC_SQ_WQE_SIZE;
676 tgt->sq_mem_size = (tgt->sq_mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
677
678 tgt->sq = dma_alloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
679 &tgt->sq_dma, GFP_KERNEL);
680 if (!tgt->sq) {
681 printk(KERN_ERR PFX "unable to allocate SQ memory %d\n",
682 tgt->sq_mem_size);
683 goto mem_alloc_failure;
684 }
685 memset(tgt->sq, 0, tgt->sq_mem_size);
686
687
688 tgt->cq_mem_size = tgt->max_cqes * BNX2FC_CQ_WQE_SIZE;
689 tgt->cq_mem_size = (tgt->cq_mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
690
691 tgt->cq = dma_alloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
692 &tgt->cq_dma, GFP_KERNEL);
693 if (!tgt->cq) {
694 printk(KERN_ERR PFX "unable to allocate CQ memory %d\n",
695 tgt->cq_mem_size);
696 goto mem_alloc_failure;
697 }
698 memset(tgt->cq, 0, tgt->cq_mem_size);
699
700
701 tgt->rq_mem_size = tgt->max_rqes * BNX2FC_RQ_WQE_SIZE;
702 tgt->rq_mem_size = (tgt->rq_mem_size + (PAGE_SIZE - 1)) & PAGE_MASK;
703
704 tgt->rq = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
705 &tgt->rq_dma, GFP_KERNEL);
706 if (!tgt->rq) {
707 printk(KERN_ERR PFX "unable to allocate RQ memory %d\n",
708 tgt->rq_mem_size);
709 goto mem_alloc_failure;
710 }
711 memset(tgt->rq, 0, tgt->rq_mem_size);
712
713 tgt->rq_pbl_size = (tgt->rq_mem_size / PAGE_SIZE) * sizeof(void *);
714 tgt->rq_pbl_size = (tgt->rq_pbl_size + (PAGE_SIZE - 1)) & PAGE_MASK;
715
716 tgt->rq_pbl = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
717 &tgt->rq_pbl_dma, GFP_KERNEL);
718 if (!tgt->rq_pbl) {
719 printk(KERN_ERR PFX "unable to allocate RQ PBL %d\n",
720 tgt->rq_pbl_size);
721 goto mem_alloc_failure;
722 }
723
724 memset(tgt->rq_pbl, 0, tgt->rq_pbl_size);
725 num_pages = tgt->rq_mem_size / PAGE_SIZE;
726 page = tgt->rq_dma;
727 pbl = (u32 *)tgt->rq_pbl;
728
729 while (num_pages--) {
730 *pbl = (u32)page;
731 pbl++;
732 *pbl = (u32)((u64)page >> 32);
733 pbl++;
734 page += PAGE_SIZE;
735 }
736
737
738 tgt->xferq_mem_size = tgt->max_sqes * BNX2FC_XFERQ_WQE_SIZE;
739 tgt->xferq_mem_size = (tgt->xferq_mem_size + (PAGE_SIZE - 1)) &
740 PAGE_MASK;
741
742 tgt->xferq = dma_alloc_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,
743 &tgt->xferq_dma, GFP_KERNEL);
744 if (!tgt->xferq) {
745 printk(KERN_ERR PFX "unable to allocate XFERQ %d\n",
746 tgt->xferq_mem_size);
747 goto mem_alloc_failure;
748 }
749 memset(tgt->xferq, 0, tgt->xferq_mem_size);
750
751
752 tgt->confq_mem_size = tgt->max_sqes * BNX2FC_CONFQ_WQE_SIZE;
753 tgt->confq_mem_size = (tgt->confq_mem_size + (PAGE_SIZE - 1)) &
754 PAGE_MASK;
755
756 tgt->confq = dma_alloc_coherent(&hba->pcidev->dev, tgt->confq_mem_size,
757 &tgt->confq_dma, GFP_KERNEL);
758 if (!tgt->confq) {
759 printk(KERN_ERR PFX "unable to allocate CONFQ %d\n",
760 tgt->confq_mem_size);
761 goto mem_alloc_failure;
762 }
763 memset(tgt->confq, 0, tgt->confq_mem_size);
764
765 tgt->confq_pbl_size =
766 (tgt->confq_mem_size / PAGE_SIZE) * sizeof(void *);
767 tgt->confq_pbl_size =
768 (tgt->confq_pbl_size + (PAGE_SIZE - 1)) & PAGE_MASK;
769
770 tgt->confq_pbl = dma_alloc_coherent(&hba->pcidev->dev,
771 tgt->confq_pbl_size,
772 &tgt->confq_pbl_dma, GFP_KERNEL);
773 if (!tgt->confq_pbl) {
774 printk(KERN_ERR PFX "unable to allocate CONFQ PBL %d\n",
775 tgt->confq_pbl_size);
776 goto mem_alloc_failure;
777 }
778
779 memset(tgt->confq_pbl, 0, tgt->confq_pbl_size);
780 num_pages = tgt->confq_mem_size / PAGE_SIZE;
781 page = tgt->confq_dma;
782 pbl = (u32 *)tgt->confq_pbl;
783
784 while (num_pages--) {
785 *pbl = (u32)page;
786 pbl++;
787 *pbl = (u32)((u64)page >> 32);
788 pbl++;
789 page += PAGE_SIZE;
790 }
791
792
793 tgt->conn_db_mem_size = sizeof(struct fcoe_conn_db);
794
795 tgt->conn_db = dma_alloc_coherent(&hba->pcidev->dev,
796 tgt->conn_db_mem_size,
797 &tgt->conn_db_dma, GFP_KERNEL);
798 if (!tgt->conn_db) {
799 printk(KERN_ERR PFX "unable to allocate conn_db %d\n",
800 tgt->conn_db_mem_size);
801 goto mem_alloc_failure;
802 }
803 memset(tgt->conn_db, 0, tgt->conn_db_mem_size);
804
805
806
807 tgt->lcq_mem_size = (tgt->max_sqes + 8) * BNX2FC_SQ_WQE_SIZE;
808 tgt->lcq_mem_size = (tgt->lcq_mem_size + (PAGE_SIZE - 1)) &
809 PAGE_MASK;
810
811 tgt->lcq = dma_alloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
812 &tgt->lcq_dma, GFP_KERNEL);
813
814 if (!tgt->lcq) {
815 printk(KERN_ERR PFX "unable to allocate lcq %d\n",
816 tgt->lcq_mem_size);
817 goto mem_alloc_failure;
818 }
819 memset(tgt->lcq, 0, tgt->lcq_mem_size);
820
821 tgt->conn_db->rq_prod = 0x8000;
822
823 return 0;
824
825mem_alloc_failure:
826 return -ENOMEM;
827}
828
829
830
831
832
833
834
835
836
837static void bnx2fc_free_session_resc(struct bnx2fc_hba *hba,
838 struct bnx2fc_rport *tgt)
839{
840 void __iomem *ctx_base_ptr;
841
842 BNX2FC_TGT_DBG(tgt, "Freeing up session resources\n");
843
844 spin_lock_bh(&tgt->cq_lock);
845 ctx_base_ptr = tgt->ctx_base;
846 tgt->ctx_base = NULL;
847
848
849 if (tgt->lcq) {
850 dma_free_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
851 tgt->lcq, tgt->lcq_dma);
852 tgt->lcq = NULL;
853 }
854
855 if (tgt->conn_db) {
856 dma_free_coherent(&hba->pcidev->dev, tgt->conn_db_mem_size,
857 tgt->conn_db, tgt->conn_db_dma);
858 tgt->conn_db = NULL;
859 }
860
861 if (tgt->confq_pbl) {
862 dma_free_coherent(&hba->pcidev->dev, tgt->confq_pbl_size,
863 tgt->confq_pbl, tgt->confq_pbl_dma);
864 tgt->confq_pbl = NULL;
865 }
866 if (tgt->confq) {
867 dma_free_coherent(&hba->pcidev->dev, tgt->confq_mem_size,
868 tgt->confq, tgt->confq_dma);
869 tgt->confq = NULL;
870 }
871
872 if (tgt->xferq) {
873 dma_free_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,
874 tgt->xferq, tgt->xferq_dma);
875 tgt->xferq = NULL;
876 }
877
878 if (tgt->rq_pbl) {
879 dma_free_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
880 tgt->rq_pbl, tgt->rq_pbl_dma);
881 tgt->rq_pbl = NULL;
882 }
883 if (tgt->rq) {
884 dma_free_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
885 tgt->rq, tgt->rq_dma);
886 tgt->rq = NULL;
887 }
888
889 if (tgt->cq) {
890 dma_free_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
891 tgt->cq, tgt->cq_dma);
892 tgt->cq = NULL;
893 }
894
895 if (tgt->sq) {
896 dma_free_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
897 tgt->sq, tgt->sq_dma);
898 tgt->sq = NULL;
899 }
900 spin_unlock_bh(&tgt->cq_lock);
901
902 if (ctx_base_ptr)
903 iounmap(ctx_base_ptr);
904}
905