Lines Matching defs:qedf
23 #include "qedf.h"
72 "by the qedf driver. Default is 0 (use OS default).");
122 void qedf_set_vlan_id(struct qedf_ctx *qedf, int vlan_id)
126 vlan_id_tmp = vlan_id | (qedf->prio << VLAN_PRIO_SHIFT);
127 qedf->vlan_id = vlan_id_tmp;
128 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
130 vlan_id_tmp, qedf->prio);
134 static bool qedf_initiate_fipvlan_req(struct qedf_ctx *qedf)
137 while (qedf->fipvlan_retries--) {
139 if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
140 QEDF_ERR(&qedf->dbg_ctx, "Link not up.\n");
144 if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
145 QEDF_ERR(&qedf->dbg_ctx, "Driver unloading.\n");
149 if (qedf->vlan_id > 0) {
150 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
152 qedf->vlan_id);
153 if (atomic_read(&qedf->link_state) == QEDF_LINK_UP)
154 fcoe_ctlr_link_up(&qedf->ctlr);
158 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
159 "Retry %d.\n", qedf->fipvlan_retries);
160 init_completion(&qedf->fipvlan_compl);
161 qedf_fcoe_send_vlan_req(qedf);
162 wait_for_completion_timeout(&qedf->fipvlan_compl, 1 * HZ);
170 struct qedf_ctx *qedf =
174 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Entered. link_state=%d.\n",
175 atomic_read(&qedf->link_state));
177 if (atomic_read(&qedf->link_state) == QEDF_LINK_UP) {
178 rc = qedf_initiate_fipvlan_req(qedf);
182 if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
183 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
185 qedf->vlan_id = 0;
194 QEDF_WARN(&(qedf->dbg_ctx), "Did not receive FIP VLAN "
197 qedf_set_vlan_id(qedf, qedf_fallback_vlan);
203 eth_zero_addr(qedf->data_src_addr);
204 fcoe_ctlr_link_up(&qedf->ctlr);
205 } else if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
211 atomic_set(&qedf->link_down_tmo_valid, 0);
212 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
214 fcoe_ctlr_link_down(&qedf->ctlr);
215 if (qedf_wait_for_upload(qedf) == false)
216 QEDF_ERR(&qedf->dbg_ctx,
219 qedf->fipvlan_retries = qedf_fipvlan_retries;
226 static void qedf_set_data_src_addr(struct qedf_ctx *qedf, struct fc_frame *fp)
247 ether_addr_copy(qedf->data_src_addr, granted_mac);
249 } else if (qedf->ctlr.sel_fcf->fc_map != 0) {
250 hton24(fc_map, qedf->ctlr.sel_fcf->fc_map);
251 qedf->data_src_addr[0] = fc_map[0];
252 qedf->data_src_addr[1] = fc_map[1];
253 qedf->data_src_addr[2] = fc_map[2];
254 qedf->data_src_addr[3] = fh->fh_d_id[0];
255 qedf->data_src_addr[4] = fh->fh_d_id[1];
256 qedf->data_src_addr[5] = fh->fh_d_id[2];
259 fc_fcoe_set_mac(qedf->data_src_addr, fh->fh_d_id);
263 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
264 "QEDF data_src_mac=%pM method=%d.\n", qedf->data_src_addr, method);
272 struct qedf_ctx *qedf = lport_priv(lport);
274 if (!qedf) {
275 QEDF_ERR(NULL, "qedf is NULL.\n");
284 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
291 qedf->flogi_failed++;
294 qedf_set_data_src_addr(qedf, fp);
295 qedf->flogi_pending = 0;
299 complete(&qedf->flogi_compl);
313 struct qedf_ctx *qedf = lport_priv(lport);
320 qedf->flogi_cnt++;
321 qedf->flogi_pending++;
323 if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
324 QEDF_ERR(&qedf->dbg_ctx, "Driver unloading\n");
325 qedf->flogi_pending = 0;
328 if (qedf->flogi_pending >= QEDF_FLOGI_RETRY_CNT) {
329 schedule_delayed_work(&qedf->stag_work, 2);
340 int qedf_send_flogi(struct qedf_ctx *qedf)
345 lport = qedf->lport;
348 QEDF_ERR(&qedf->dbg_ctx, "tt.elsct_send not set.\n");
354 QEDF_ERR(&(qedf->dbg_ctx), "fc_frame_alloc failed.\n");
358 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
363 init_completion(&qedf->flogi_compl);
375 struct qedf_ctx *qedf =
377 struct fc_lport *lport = qedf->lport;
386 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
393 qedf->ctlr.state = FIP_ST_LINK_WAIT;
394 fcoe_ctlr_link_down(&qedf->ctlr);
400 fcoe_ctlr_link_up(&qedf->ctlr);
403 qedf->fipvlan_retries = qedf_fipvlan_retries;
404 rc = qedf_initiate_fipvlan_req(qedf);
407 qedf_set_vlan_id(qedf, qedf_fallback_vlan);
414 if (qedf->ctlr.sel_fcf) {
415 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
424 QEDF_ERR(&(qedf->dbg_ctx), "Exhausted retries waiting for "
429 rval = qedf_send_flogi(qedf);
434 i = wait_for_completion_timeout(&qedf->flogi_compl,
435 qedf->lport->r_a_tov);
437 QEDF_ERR(&(qedf->dbg_ctx), "FLOGI timed out.\n");
455 static void qedf_update_link_speed(struct qedf_ctx *qedf,
459 struct fc_lport *lport = qedf->lport;
554 struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
558 qed_ops->common->get_link(qedf->cdev, &link);
560 if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
561 QEDF_ERR(&qedf->dbg_ctx,
567 if (atomic_read(&qedf->link_state) == QEDF_LINK_UP)
568 qedf_update_link_speed(qedf, &link);
570 QEDF_ERR(&qedf->dbg_ctx,
574 QEDF_ERR(&qedf->dbg_ctx, "link_up is not set.\n");
580 struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
586 if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
587 QEDF_ERR(&qedf->dbg_ctx,
593 if (atomic_read(&qedf->link_state) == QEDF_LINK_UP) {
594 QEDF_INFO((&qedf->dbg_ctx), QEDF_LOG_DISC,
598 QEDF_ERR(&(qedf->dbg_ctx), "LINK UP (%d GB/s).\n",
602 cancel_delayed_work(&qedf->link_update);
604 atomic_set(&qedf->link_state, QEDF_LINK_UP);
605 qedf_update_link_speed(qedf, link);
607 if (atomic_read(&qedf->dcbx) == QEDF_DCBX_DONE ||
609 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
611 if (atomic_read(&qedf->link_down_tmo_valid) > 0)
612 queue_delayed_work(qedf->link_update_wq,
613 &qedf->link_recovery, 0);
615 queue_delayed_work(qedf->link_update_wq,
616 &qedf->link_update, 0);
617 atomic_set(&qedf->link_down_tmo_valid, 0);
621 QEDF_ERR(&(qedf->dbg_ctx), "LINK DOWN.\n");
623 atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
624 atomic_set(&qedf->dcbx, QEDF_DCBX_PENDING);
630 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
632 atomic_set(&qedf->link_down_tmo_valid, 1);
634 qedf->vlan_id = 0;
635 qedf_update_link_speed(qedf, link);
636 queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
644 struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
647 QEDF_ERR(&(qedf->dbg_ctx), "DCBx event valid=%d enabled=%d fcoe "
653 if (atomic_read(&qedf->dcbx) == QEDF_DCBX_DONE) {
654 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
659 atomic_set(&qedf->dcbx, QEDF_DCBX_DONE);
670 qedf->prio = qedf_default_prio;
672 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
675 qedf->prio = QEDF_DEFAULT_PRIO;
677 qedf->prio = tmp_prio;
679 if (atomic_read(&qedf->link_state) == QEDF_LINK_UP &&
681 if (atomic_read(&qedf->link_down_tmo_valid) > 0)
682 queue_delayed_work(qedf->link_update_wq,
683 &qedf->link_recovery, 0);
685 queue_delayed_work(qedf->link_update_wq,
686 &qedf->link_update, 0);
687 atomic_set(&qedf->link_down_tmo_valid, 0);
695 struct qedf_ctx *qedf;
697 qedf = (struct qedf_ctx *)cookie;
698 return qedf->flogi_failed;
727 struct qedf_ctx *qedf;
739 qedf = (struct qedf_ctx *)lport_priv(lport);
745 QEDF_ERR(&qedf->dbg_ctx, "stale rport, sc_cmd=%p\n", sc_cmd);
753 QEDF_ERR(&qedf->dbg_ctx,
767 QEDF_ERR(&qedf->dbg_ctx,
776 QEDF_ERR(&qedf->dbg_ctx,
789 QEDF_ERR(&qedf->dbg_ctx,
797 QEDF_ERR(&qedf->dbg_ctx, "ABTS succeeded\n");
800 QEDF_ERR(&qedf->dbg_ctx, "ABTS failed\n");
807 QEDF_ERR(&qedf->dbg_ctx, "link not ready.\n");
811 QEDF_ERR(&qedf->dbg_ctx,
816 if (qedf->stop_io_on_error) {
817 qedf_stop_all_io(qedf);
825 QEDF_ERR(&(qedf->dbg_ctx), "Failed to queue ABTS.\n");
831 qedf_scsi_done(qedf, io_req, DID_ERROR);
852 QEDF_ERR(&(qedf->dbg_ctx), "ABTS succeeded, xid=0x%x.\n",
855 QEDF_ERR(&(qedf->dbg_ctx), "ABTS failed, xid=0x%x.\n",
883 bool qedf_wait_for_upload(struct qedf_ctx *qedf)
889 if (atomic_read(&qedf->num_offloads))
890 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
892 atomic_read(&qedf->num_offloads));
899 list_for_each_entry_rcu(fcport, &qedf->fcports, peers) {
903 QEDF_ERR(&qedf->dbg_ctx,
907 QEDF_ERR(&qedf->dbg_ctx,
919 struct qedf_ctx *qedf;
922 qedf = lport_priv(lport);
925 clear_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
930 qedf->flogi_pending = 0;
932 atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
933 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
935 queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
938 if (qedf_wait_for_upload(qedf) == false) {
939 QEDF_ERR(&qedf->dbg_ctx, "Could not upload all sessions.\n");
940 WARN_ON(atomic_read(&qedf->num_offloads));
944 qed_ops->common->get_link(qedf->cdev, &if_link);
947 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
949 clear_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
953 flush_delayed_work(&qedf->link_update);
956 atomic_set(&qedf->link_state, QEDF_LINK_UP);
957 qedf->vlan_id = 0;
958 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
960 queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
962 clear_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
969 struct qedf_ctx *qedf;
972 qedf = lport_priv(lport);
974 if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN ||
975 test_bit(QEDF_UNLOADING, &qedf->flags))
978 QEDF_ERR(&(qedf->dbg_ctx), "HOST RESET Issued...");
1026 static struct qedf_rport *qedf_fcport_lookup(struct qedf_ctx *qedf, u32 port_id)
1032 list_for_each_entry_rcu(fcport, &qedf->fcports, peers) {
1068 * qedf_xmit - qedf FCoE frame transmit function
1073 struct qedf_ctx *qedf;
1089 qedf = (struct qedf_ctx *)lport_priv(lport);
1117 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
1129 if (!qedf->ctlr.sel_fcf) {
1134 if (!test_bit(QEDF_LL2_STARTED, &qedf->flags)) {
1135 QEDF_WARN(&(qedf->dbg_ctx), "LL2 not started\n");
1140 if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
1141 QEDF_WARN(&(qedf->dbg_ctx), "qedf link down\n");
1147 if (fcoe_ctlr_els_send(&qedf->ctlr, lport, skb))
1152 fcport = qedf_fcport_lookup(qedf, ntoh24(fh->fh_d_id));
1209 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), qedf->vlan_id);
1214 if (qedf->ctlr.map_dest)
1218 ether_addr_copy(eh->h_dest, qedf->ctlr.dest_addr);
1221 ether_addr_copy(eh->h_source, qedf->data_src_addr);
1238 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FCoE frame send: "
1245 rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, 0);
1247 QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
1255 static int qedf_alloc_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
1269 fcport->sq = dma_alloc_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
1272 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue.\n");
1277 fcport->sq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
1281 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue PBL.\n");
1302 dma_free_coherent(&qedf->pdev->dev, fcport->sq_mem_size, fcport->sq,
1308 static void qedf_free_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
1311 dma_free_coherent(&qedf->pdev->dev, fcport->sq_pbl_size,
1314 dma_free_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
1318 static int qedf_offload_connection(struct qedf_ctx *qedf,
1326 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Offloading connection "
1328 rval = qed_ops->acquire_conn(qedf->cdev, &fcport->handle,
1331 QEDF_WARN(&(qedf->dbg_ctx), "Could not acquire connection "
1337 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "portid=%06x "
1351 ether_addr_copy(conn_info.src_mac, qedf->data_src_addr);
1353 ether_addr_copy(conn_info.dst_mac, qedf->ctlr.dest_addr);
1356 conn_info.e_d_tov_timer_val = qedf->lport->e_d_tov;
1361 conn_info.vlan_tag = qedf->vlan_id <<
1364 qedf->prio << FCOE_CONN_OFFLOAD_RAMROD_DATA_PRIORITY_SHIFT;
1369 port_id = fc_host_port_id(qedf->lport->host);
1387 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN,
1397 rval = qed_ops->offload_conn(qedf->cdev, fcport->handle, &conn_info);
1399 QEDF_WARN(&(qedf->dbg_ctx), "Could not offload connection "
1403 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Offload "
1411 qed_ops->release_conn(qedf->cdev, fcport->handle);
1417 static void qedf_upload_connection(struct qedf_ctx *qedf,
1427 term_params = dma_alloc_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE,
1432 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Uploading connection "
1435 qed_ops->destroy_conn(qedf->cdev, fcport->handle, term_params_dma);
1436 qed_ops->release_conn(qedf->cdev, fcport->handle);
1438 dma_free_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE, term_params,
1442 static void qedf_cleanup_fcport(struct qedf_ctx *qedf,
1447 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Cleaning up portid=%06x.\n",
1454 qedf_upload_connection(qedf, fcport);
1455 qedf_free_sq(qedf, fcport);
1457 fcport->qedf = NULL;
1463 * initiated target login. qedf can proceed with initiating the session
1470 struct qedf_ctx *qedf = lport_priv(lport);
1478 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "event = %d, "
1484 QEDF_WARN(&(qedf->dbg_ctx), "rport is NULL.\n");
1490 fcport->qedf = qedf;
1492 if (atomic_read(&qedf->num_offloads) >= QEDF_MAX_SESSIONS) {
1493 QEDF_ERR(&(qedf->dbg_ctx), "Not offloading "
1504 QEDF_WARN(&(qedf->dbg_ctx), "Session already "
1517 QEDF_WARN(&(qedf->dbg_ctx), "rport struct does not "
1524 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1529 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1539 rval = qedf_alloc_sq(qedf, fcport);
1541 qedf_cleanup_fcport(qedf, fcport);
1550 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1557 rval = qedf_offload_connection(qedf, fcport);
1559 qedf_cleanup_fcport(qedf, fcport);
1564 spin_lock_irqsave(&qedf->hba_lock, flags);
1565 list_add_rcu(&fcport->peers, &qedf->fcports);
1566 spin_unlock_irqrestore(&qedf->hba_lock, flags);
1573 atomic_inc(&qedf->num_offloads);
1584 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1589 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1595 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1614 qedf_cleanup_fcport(qedf, fcport);
1619 spin_lock_irqsave(&qedf->hba_lock, flags);
1621 spin_unlock_irqrestore(&qedf->hba_lock, flags);
1625 atomic_dec(&qedf->num_offloads);
1658 static void qedf_fcoe_ctlr_setup(struct qedf_ctx *qedf)
1660 fcoe_ctlr_init(&qedf->ctlr, FIP_MODE_AUTO);
1662 qedf->ctlr.send = qedf_fip_send;
1663 qedf->ctlr.get_src_addr = qedf_get_src_mac;
1664 ether_addr_copy(qedf->ctlr.ctl_src_addr, qedf->mac);
1667 static void qedf_setup_fdmi(struct qedf_ctx *qedf)
1669 struct fc_lport *lport = qedf->lport;
1686 pos = pci_find_ext_capability(qedf->pdev, PCI_EXT_CAP_ID_DSN);
1690 pci_read_config_byte(qedf->pdev, pos + i, &buf[i]);
1704 if (qedf->pdev->device == QL45xxx) {
1713 if (qedf->pdev->device == QL41xxx) {
1723 FC_VERSION_STRING_SIZE, "Rev %d", qedf->pdev->revision);
1738 static int qedf_lport_setup(struct qedf_ctx *qedf)
1740 struct fc_lport *lport = qedf->lport;
1755 fc_set_wwnn(lport, qedf->wwnn);
1756 fc_set_wwpn(lport, qedf->wwpn);
1758 if (fcoe_libfc_config(lport, &qedf->ctlr, &qedf_lport_template, 0)) {
1759 QEDF_ERR(&qedf->dbg_ctx,
1782 if (qedf->pdev->device == QL45xxx)
1786 if (qedf->pdev->device == QL41xxx)
1790 qedf_setup_fdmi(qedf);
1870 /* Set qedf data specific to this vport */
1977 struct qedf_ctx *qedf = lport_priv(vn_port);
1979 if (!qedf) {
1980 QEDF_ERR(NULL, "qedf is NULL.\n");
1985 set_bit(QEDF_UNLOADING, &qedf->flags);
2036 static void qedf_wait_for_vport_destroy(struct qedf_ctx *qedf)
2038 struct fc_host_attrs *fc_host = shost_to_fc_host(qedf->lport->host);
2040 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_NPIV,
2043 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_NPIV,
2076 struct qedf_ctx *qedf = lport_priv(lport);
2087 QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate memory for "
2092 mutex_lock(&qedf->stats_mutex);
2095 qed_ops->get_stats(qedf->cdev, fw_fcoe_stats);
2121 qedf_stats->fcp_input_requests += qedf->input_requests;
2122 qedf_stats->fcp_output_requests += qedf->output_requests;
2123 qedf_stats->fcp_control_requests += qedf->control_requests;
2124 qedf_stats->fcp_packet_aborts += qedf->packet_aborts;
2125 qedf_stats->fcp_frame_alloc_failures += qedf->alloc_failures;
2127 mutex_unlock(&qedf->stats_mutex);
2205 struct qedf_ctx *qedf = fp->qedf;
2212 que = qedf->global_queues[fp->sb_id];
2233 struct qedf_ctx *qedf = fp->qedf;
2250 que = qedf->global_queues[fp->sb_id];
2272 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_UNSOL,
2274 qedf_process_unsol_compl(qedf, fp->sb_id, cqe);
2283 io_req = &qedf->cmd_mgr->cmds[xid];
2299 io_work = mempool_alloc(qedf->io_mempool, GFP_ATOMIC);
2301 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate "
2312 io_work->qedf = fp->qedf;
2374 struct qedf_ctx *qedf = (struct qedf_ctx *)cookie;
2376 QEDF_WARN(&(qedf->dbg_ctx), "qedf=%p.\n", qedf);
2380 static void qedf_sync_free_irqs(struct qedf_ctx *qedf)
2386 if (qedf->int_info.msix_cnt) {
2387 for (i = 0; i < qedf->int_info.used_cnt; i++) {
2388 vector_idx = i * qedf->dev_info.common.num_hwfns +
2389 qed_ops->common->get_affin_hwfn_idx(qedf->cdev);
2390 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
2393 vector = qedf->int_info.msix[vector_idx].vector;
2397 free_irq(vector, &qedf->fp_array[i]);
2400 qed_ops->common->simd_handler_clean(qedf->cdev,
2403 qedf->int_info.used_cnt = 0;
2404 qed_ops->common->set_fp_int(qedf->cdev, 0);
2407 static int qedf_request_msix_irq(struct qedf_ctx *qedf)
2414 for (i = 0; i < qedf->num_queues; i++) {
2415 vector_idx = i * qedf->dev_info.common.num_hwfns +
2416 qed_ops->common->get_affin_hwfn_idx(qedf->cdev);
2417 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
2420 vector = qedf->int_info.msix[vector_idx].vector;
2421 rc = request_irq(vector, qedf_msix_handler, 0, "qedf",
2422 &qedf->fp_array[i]);
2425 QEDF_WARN(&(qedf->dbg_ctx), "request_irq failed.\n");
2426 qedf_sync_free_irqs(qedf);
2430 qedf->int_info.used_cnt++;
2438 static int qedf_setup_int(struct qedf_ctx *qedf)
2445 rc = qed_ops->common->set_fp_int(qedf->cdev, num_online_cpus());
2449 rc = qed_ops->common->get_fp_int(qedf->cdev, &qedf->int_info);
2453 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Number of msix_cnt = "
2454 "0x%x num of cpus = 0x%x\n", qedf->int_info.msix_cnt,
2457 if (qedf->int_info.msix_cnt)
2458 return qedf_request_msix_irq(qedf);
2460 qed_ops->common->simd_handler_config(qedf->cdev, &qedf,
2462 qedf->int_info.used_cnt = 1;
2464 QEDF_ERR(&qedf->dbg_ctx,
2470 static void qedf_recv_frame(struct qedf_ctx *qedf,
2485 lport = qedf->lport;
2552 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2558 if (qedf->ctlr.state) {
2559 if (!ether_addr_equal(mac, qedf->ctlr.dest_addr)) {
2560 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2562 mac, qedf->ctlr.dest_addr);
2576 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2587 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2600 fcport = qedf_fcport_lookup(qedf, ntoh24(fh->fh_d_id));
2604 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2610 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FCoE frame receive: "
2624 struct qedf_ctx *qedf = skb_work->qedf;
2628 if (!qedf) {
2629 QEDF_ERR(NULL, "qedf is NULL\n");
2648 qedf_fip_recv(qedf, skb);
2652 qedf_recv_frame(qedf, skb);
2667 struct qedf_ctx *qedf = (struct qedf_ctx *)cookie;
2670 if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
2671 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2679 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate skb_work so "
2687 skb_work->qedf = qedf;
2688 queue_work(qedf->ll2_recv_wq, &skb_work->work);
2714 fc_exch_recv(io_work->qedf->lport, io_work->fp);
2716 qedf_process_cqe(io_work->qedf, &io_work->cqe);
2721 static int qedf_alloc_and_init_sb(struct qedf_ctx *qedf,
2728 sb_virt = dma_alloc_coherent(&qedf->pdev->dev,
2732 QEDF_ERR(&qedf->dbg_ctx,
2738 ret = qed_ops->common->sb_init(qedf->cdev, sb_info, sb_virt, sb_phys,
2742 dma_free_coherent(&qedf->pdev->dev, sizeof(*sb_virt), sb_virt, sb_phys);
2743 QEDF_ERR(&qedf->dbg_ctx,
2752 static void qedf_free_sb(struct qedf_ctx *qedf, struct qed_sb_info *sb_info)
2755 dma_free_coherent(&qedf->pdev->dev, sizeof(*sb_info->sb_virt),
2759 static void qedf_destroy_sb(struct qedf_ctx *qedf)
2764 for (id = 0; id < qedf->num_queues; id++) {
2765 fp = &(qedf->fp_array[id]);
2768 qedf_free_sb(qedf, fp->sb_info);
2771 kfree(qedf->fp_array);
2774 static int qedf_prepare_sb(struct qedf_ctx *qedf)
2780 qedf->fp_array =
2781 kcalloc(qedf->num_queues, sizeof(struct qedf_fastpath),
2784 if (!qedf->fp_array) {
2785 QEDF_ERR(&(qedf->dbg_ctx), "fastpath array allocation "
2790 for (id = 0; id < qedf->num_queues; id++) {
2791 fp = &(qedf->fp_array[id]);
2795 QEDF_ERR(&(qedf->dbg_ctx), "SB info struct "
2799 ret = qedf_alloc_and_init_sb(qedf, fp->sb_info, id);
2801 QEDF_ERR(&(qedf->dbg_ctx), "SB allocation and "
2806 fp->qedf = qedf;
2808 qedf->global_queues[id]->cq_mem_size /
2815 void qedf_process_cqe(struct qedf_ctx *qedf, struct fcoe_cqe *cqe)
2828 io_req = &qedf->cmd_mgr->cmds[xid];
2832 QEDF_ERR(&qedf->dbg_ctx,
2840 QEDF_ERR(&qedf->dbg_ctx,
2851 QEDF_ERR(&qedf->dbg_ctx,
2865 qedf_scsi_completion(qedf, cqe, io_req);
2868 qedf_process_els_compl(qedf, cqe, io_req);
2871 qedf_process_tmf_compl(qedf, cqe, io_req);
2874 qedf_process_seq_cleanup_compl(qedf, cqe, io_req);
2880 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2882 qedf_process_error_detect(qedf, cqe, io_req);
2886 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2888 qedf_process_cleanup_compl(qedf, cqe, io_req);
2892 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2894 qedf_process_abts_compl(qedf, cqe, io_req);
2898 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2903 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2908 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2910 qedf_process_warning_compl(qedf, cqe, io_req);
2914 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2918 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2924 static void qedf_free_bdq(struct qedf_ctx *qedf)
2928 if (qedf->bdq_pbl_list)
2929 dma_free_coherent(&qedf->pdev->dev, QEDF_PAGE_SIZE,
2930 qedf->bdq_pbl_list, qedf->bdq_pbl_list_dma);
2932 if (qedf->bdq_pbl)
2933 dma_free_coherent(&qedf->pdev->dev, qedf->bdq_pbl_mem_size,
2934 qedf->bdq_pbl, qedf->bdq_pbl_dma);
2937 if (qedf->bdq[i].buf_addr) {
2938 dma_free_coherent(&qedf->pdev->dev, QEDF_BDQ_BUF_SIZE,
2939 qedf->bdq[i].buf_addr, qedf->bdq[i].buf_dma);
2944 static void qedf_free_global_queues(struct qedf_ctx *qedf)
2947 struct global_queue **gl = qedf->global_queues;
2949 for (i = 0; i < qedf->num_queues; i++) {
2954 dma_free_coherent(&qedf->pdev->dev,
2957 dma_free_coherent(&qedf->pdev->dev, gl[i]->cq_pbl_size,
2963 qedf_free_bdq(qedf);
2966 static int qedf_alloc_bdq(struct qedf_ctx *qedf)
2974 qedf->bdq[i].buf_addr = dma_alloc_coherent(&qedf->pdev->dev,
2975 QEDF_BDQ_BUF_SIZE, &qedf->bdq[i].buf_dma, GFP_KERNEL);
2976 if (!qedf->bdq[i].buf_addr) {
2977 QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate BDQ "
2984 qedf->bdq_pbl_mem_size =
2986 qedf->bdq_pbl_mem_size =
2987 ALIGN(qedf->bdq_pbl_mem_size, QEDF_PAGE_SIZE);
2989 qedf->bdq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
2990 qedf->bdq_pbl_mem_size, &qedf->bdq_pbl_dma, GFP_KERNEL);
2991 if (!qedf->bdq_pbl) {
2992 QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate BDQ PBL.\n");
2996 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
2998 qedf->bdq_pbl, &qedf->bdq_pbl_dma);
3004 pbl = (struct scsi_bd *)qedf->bdq_pbl;
3006 pbl->address.hi = cpu_to_le32(U64_HI(qedf->bdq[i].buf_dma));
3007 pbl->address.lo = cpu_to_le32(U64_LO(qedf->bdq[i].buf_dma));
3015 qedf->bdq_pbl_list = dma_alloc_coherent(&qedf->pdev->dev,
3017 &qedf->bdq_pbl_list_dma,
3019 if (!qedf->bdq_pbl_list) {
3020 QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate list of PBL pages.\n");
3028 qedf->bdq_pbl_list_num_entries = qedf->bdq_pbl_mem_size /
3030 list = (u64 *)qedf->bdq_pbl_list;
3031 for (i = 0; i < qedf->bdq_pbl_list_num_entries; i++) {
3032 *list = qedf->bdq_pbl_dma;
3039 static int qedf_alloc_global_queues(struct qedf_ctx *qedf)
3053 if (!qedf->num_queues) {
3054 QEDF_ERR(&(qedf->dbg_ctx), "No MSI-X vectors available!\n");
3062 if (!qedf->p_cpuq) {
3063 QEDF_ERR(&qedf->dbg_ctx, "p_cpuq is NULL.\n");
3067 qedf->global_queues = kzalloc((sizeof(struct global_queue *)
3068 * qedf->num_queues), GFP_KERNEL);
3069 if (!qedf->global_queues) {
3070 QEDF_ERR(&(qedf->dbg_ctx), "Unable to allocate global "
3074 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3075 "qedf->global_queues=%p.\n", qedf->global_queues);
3078 status = qedf_alloc_bdq(qedf);
3080 QEDF_ERR(&qedf->dbg_ctx, "Unable to allocate bdq.\n");
3085 for (i = 0; i < qedf->num_queues; i++) {
3086 qedf->global_queues[i] = kzalloc(sizeof(struct global_queue),
3088 if (!qedf->global_queues[i]) {
3089 QEDF_WARN(&(qedf->dbg_ctx), "Unable to allocate "
3095 qedf->global_queues[i]->cq_mem_size =
3097 qedf->global_queues[i]->cq_mem_size =
3098 ALIGN(qedf->global_queues[i]->cq_mem_size, QEDF_PAGE_SIZE);
3100 qedf->global_queues[i]->cq_pbl_size =
3101 (qedf->global_queues[i]->cq_mem_size /
3103 qedf->global_queues[i]->cq_pbl_size =
3104 ALIGN(qedf->global_queues[i]->cq_pbl_size, QEDF_PAGE_SIZE);
3106 qedf->global_queues[i]->cq =
3107 dma_alloc_coherent(&qedf->pdev->dev,
3108 qedf->global_queues[i]->cq_mem_size,
3109 &qedf->global_queues[i]->cq_dma,
3112 if (!qedf->global_queues[i]->cq) {
3113 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq.\n");
3118 qedf->global_queues[i]->cq_pbl =
3119 dma_alloc_coherent(&qedf->pdev->dev,
3120 qedf->global_queues[i]->cq_pbl_size,
3121 &qedf->global_queues[i]->cq_pbl_dma,
3124 if (!qedf->global_queues[i]->cq_pbl) {
3125 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq PBL.\n");
3131 num_pages = qedf->global_queues[i]->cq_mem_size /
3133 page = qedf->global_queues[i]->cq_dma;
3134 pbl = (u32 *)qedf->global_queues[i]->cq_pbl;
3144 qedf->global_queues[i]->cq_cons_idx = 0;
3147 list = (u32 *)qedf->p_cpuq;
3155 for (i = 0; i < qedf->num_queues; i++) {
3156 *list = U64_LO(qedf->global_queues[i]->cq_pbl_dma);
3158 *list = U64_HI(qedf->global_queues[i]->cq_pbl_dma);
3169 qedf_free_global_queues(qedf);
3173 static int qedf_set_fcoe_pf_param(struct qedf_ctx *qedf)
3188 qedf->num_queues = MIN_NUM_CPUS_MSIX(qedf);
3190 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Number of CQs is %d.\n",
3191 qedf->num_queues);
3193 qedf->p_cpuq = dma_alloc_coherent(&qedf->pdev->dev,
3194 qedf->num_queues * sizeof(struct qedf_glbl_q_params),
3195 &qedf->hw_p_cpuq, GFP_KERNEL);
3197 if (!qedf->p_cpuq) {
3198 QEDF_ERR(&(qedf->dbg_ctx), "dma_alloc_coherent failed.\n");
3202 rval = qedf_alloc_global_queues(qedf);
3204 QEDF_ERR(&(qedf->dbg_ctx), "Global queue allocation "
3219 memset(&(qedf->pf_params), 0, sizeof(qedf->pf_params));
3222 qedf->pf_params.fcoe_pf_params.num_cons = QEDF_MAX_SESSIONS;
3223 qedf->pf_params.fcoe_pf_params.num_tasks = FCOE_PARAMS_NUM_TASKS;
3224 qedf->pf_params.fcoe_pf_params.glbl_q_params_addr =
3225 (u64)qedf->hw_p_cpuq;
3226 qedf->pf_params.fcoe_pf_params.sq_num_pbl_pages = sq_num_pbl_pages;
3228 qedf->pf_params.fcoe_pf_params.rq_buffer_log_size = 0;
3230 qedf->pf_params.fcoe_pf_params.cq_num_entries = cq_num_entries;
3231 qedf->pf_params.fcoe_pf_params.num_cqs = qedf->num_queues;
3234 qedf->pf_params.fcoe_pf_params.log_page_size = ilog2(QEDF_PAGE_SIZE);
3236 qedf->pf_params.fcoe_pf_params.mtu = 9000;
3237 qedf->pf_params.fcoe_pf_params.gl_rq_pi = QEDF_FCOE_PARAMS_GL_RQ_PI;
3238 qedf->pf_params.fcoe_pf_params.gl_cmd_pi = QEDF_FCOE_PARAMS_GL_CMD_PI;
3241 qedf->pf_params.fcoe_pf_params.bdq_pbl_base_addr[0] =
3242 qedf->bdq_pbl_list_dma;
3243 qedf->pf_params.fcoe_pf_params.bdq_pbl_num_entries[0] =
3244 qedf->bdq_pbl_list_num_entries;
3245 qedf->pf_params.fcoe_pf_params.rq_buffer_size = QEDF_BDQ_BUF_SIZE;
3247 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3249 qedf->bdq_pbl_list,
3250 qedf->pf_params.fcoe_pf_params.bdq_pbl_base_addr[0],
3251 qedf->pf_params.fcoe_pf_params.bdq_pbl_num_entries[0]);
3253 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3255 qedf->pf_params.fcoe_pf_params.cq_num_entries);
3261 static void qedf_free_fcoe_pf_param(struct qedf_ctx *qedf)
3265 if (qedf->p_cpuq) {
3266 size = qedf->num_queues * sizeof(struct qedf_glbl_q_params);
3267 dma_free_coherent(&qedf->pdev->dev, size, qedf->p_cpuq,
3268 qedf->hw_p_cpuq);
3271 qedf_free_global_queues(qedf);
3273 kfree(qedf->global_queues);
3300 struct qedf_ctx *qedf = NULL;
3333 qedf = lport_priv(lport);
3334 set_bit(QEDF_PROBING, &qedf->flags);
3335 qedf->lport = lport;
3336 qedf->ctlr.lp = lport;
3337 qedf->pdev = pdev;
3338 qedf->dbg_ctx.pdev = pdev;
3339 qedf->dbg_ctx.host_no = lport->host->host_no;
3340 spin_lock_init(&qedf->hba_lock);
3341 INIT_LIST_HEAD(&qedf->fcports);
3342 qedf->curr_conn_id = QEDF_MAX_SESSIONS - 1;
3343 atomic_set(&qedf->num_offloads, 0);
3344 qedf->stop_io_on_error = false;
3345 pci_set_drvdata(pdev, qedf);
3346 init_completion(&qedf->fipvlan_compl);
3347 mutex_init(&qedf->stats_mutex);
3348 mutex_init(&qedf->flush_mutex);
3349 qedf->flogi_pending = 0;
3351 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_INFO,
3352 "QLogic FastLinQ FCoE Module qedf %s, "
3358 qedf = pci_get_drvdata(pdev);
3359 set_bit(QEDF_PROBING, &qedf->flags);
3360 lport = qedf->lport;
3363 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Probe started.\n");
3368 qedf->io_mempool = mempool_create_slab_pool(QEDF_IO_WORK_MIN,
3370 if (qedf->io_mempool == NULL) {
3371 QEDF_ERR(&(qedf->dbg_ctx), "qedf->io_mempool is NULL.\n");
3374 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_INFO, "qedf->io_mempool=%p.\n",
3375 qedf->io_mempool);
3377 qedf->link_update_wq = alloc_workqueue("qedf_%u_link", WQ_MEM_RECLAIM,
3378 1, qedf->lport->host->host_no);
3379 INIT_DELAYED_WORK(&qedf->link_update, qedf_handle_link_update);
3380 INIT_DELAYED_WORK(&qedf->link_recovery, qedf_link_recovery);
3381 INIT_DELAYED_WORK(&qedf->grcdump_work, qedf_wq_grcdump);
3382 INIT_DELAYED_WORK(&qedf->stag_work, qedf_stag_change_work);
3383 qedf->fipvlan_retries = qedf_fipvlan_retries;
3390 qedf->prio = qedf_default_prio;
3392 qedf->prio = QEDF_DEFAULT_PRIO;
3403 qedf->cdev = qed_ops->common->probe(pdev, &qed_params);
3404 if (!qedf->cdev) {
3406 QEDF_ERR(&qedf->dbg_ctx,
3411 QEDF_ERR(&qedf->dbg_ctx, "common probe failed.\n");
3416 /* Learn information crucial for qedf to progress */
3417 rc = qed_ops->fill_dev_info(qedf->cdev, &qedf->dev_info);
3419 QEDF_ERR(&(qedf->dbg_ctx), "Failed to dev info.\n");
3423 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
3425 qedf->dev_info.common.num_hwfns,
3426 qed_ops->common->get_affin_hwfn_idx(qedf->cdev));
3436 rc = qedf_set_fcoe_pf_param(qedf);
3438 QEDF_ERR(&(qedf->dbg_ctx), "Cannot set fcoe pf param.\n");
3441 qed_ops->common->update_pf_params(qedf->cdev, &qedf->pf_params);
3443 /* Learn information crucial for qedf to progress */
3444 rc = qed_ops->fill_dev_info(qedf->cdev, &qedf->dev_info);
3446 QEDF_ERR(&qedf->dbg_ctx, "Failed to fill dev info.\n");
3451 qedf->devlink = qed_ops->common->devlink_register(qedf->cdev);
3452 if (IS_ERR(qedf->devlink)) {
3453 QEDF_ERR(&qedf->dbg_ctx, "Cannot register devlink\n");
3454 rc = PTR_ERR(qedf->devlink);
3455 qedf->devlink = NULL;
3461 qedf->bdq_primary_prod = qedf->dev_info.primary_dbq_rq_addr;
3462 qedf->bdq_secondary_prod = qedf->dev_info.secondary_bdq_rq_addr;
3463 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3464 "BDQ primary_prod=%p secondary_prod=%p.\n", qedf->bdq_primary_prod,
3465 qedf->bdq_secondary_prod);
3467 qed_ops->register_ops(qedf->cdev, &qedf_cb_ops, qedf);
3469 rc = qedf_prepare_sb(qedf);
3472 QEDF_ERR(&(qedf->dbg_ctx), "Cannot start slowpath.\n");
3483 strscpy(slowpath_params.name, "qedf", sizeof(slowpath_params.name));
3484 rc = qed_ops->common->slowpath_start(qedf->cdev, &slowpath_params);
3486 QEDF_ERR(&(qedf->dbg_ctx), "Cannot start slowpath.\n");
3494 qed_ops->common->update_pf_params(qedf->cdev, &qedf->pf_params);
3497 rc = qedf_setup_int(qedf);
3499 QEDF_ERR(&qedf->dbg_ctx, "Setup interrupts failed.\n");
3503 rc = qed_ops->start(qedf->cdev, &qedf->tasks);
3505 QEDF_ERR(&(qedf->dbg_ctx), "Cannot start FCoE function.\n");
3508 task_start = qedf_get_task_mem(&qedf->tasks, 0);
3509 task_end = qedf_get_task_mem(&qedf->tasks, MAX_TID_BLOCKS_FCOE - 1);
3510 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Task context start=%p, "
3512 qedf->tasks.size);
3519 qedf->bdq_prod_idx = QEDF_BDQ_SIZE;
3520 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3522 qedf->bdq_prod_idx);
3523 writew(qedf->bdq_prod_idx, qedf->bdq_primary_prod);
3524 readw(qedf->bdq_primary_prod);
3525 writew(qedf->bdq_prod_idx, qedf->bdq_secondary_prod);
3526 readw(qedf->bdq_secondary_prod);
3528 qed_ops->common->set_power_state(qedf->cdev, PCI_D0);
3533 ether_addr_copy(qedf->mac, qedf->dev_info.common.hw_mac);
3534 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "MAC address is %pM.\n",
3535 qedf->mac);
3544 if (qedf->dev_info.wwnn != 0 && qedf->dev_info.wwpn != 0) {
3545 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3547 qedf->wwnn = qedf->dev_info.wwnn;
3548 qedf->wwpn = qedf->dev_info.wwpn;
3550 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3552 qedf->wwnn = fcoe_wwn_from_mac(qedf->mac, 1, 0);
3553 qedf->wwpn = fcoe_wwn_from_mac(qedf->mac, 2, 0);
3555 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "WWNN=%016llx "
3556 "WWPN=%016llx.\n", qedf->wwnn, qedf->wwpn);
3559 qed_ops->common->set_name(qedf->cdev, host_buf);
3562 qedf->cmd_mgr = qedf_cmd_mgr_alloc(qedf);
3563 if (!qedf->cmd_mgr) {
3564 QEDF_ERR(&(qedf->dbg_ctx), "Failed to allocate cmd mgr.\n");
3577 QEDF_WARN(&qedf->dbg_ctx,
3585 ether_addr_copy(params.ll2_mac_address, qedf->mac);
3588 qedf->ll2_recv_wq = alloc_workqueue("qedf_%d_ll2", WQ_MEM_RECLAIM, 1,
3590 if (!qedf->ll2_recv_wq) {
3591 QEDF_ERR(&(qedf->dbg_ctx), "Failed to LL2 workqueue.\n");
3597 qedf_dbg_host_init(&(qedf->dbg_ctx), qedf_debugfs_ops,
3602 qed_ops->ll2->register_cb_ops(qedf->cdev, &qedf_ll2_cb_ops, qedf);
3603 rc = qed_ops->ll2->start(qedf->cdev, ¶ms);
3605 QEDF_ERR(&(qedf->dbg_ctx), "Could not start Light L2.\n");
3608 set_bit(QEDF_LL2_STARTED, &qedf->flags);
3611 qedf->vlan_id = 0;
3619 qedf_fcoe_ctlr_setup(qedf);
3622 rc = qedf_lport_setup(qedf);
3624 QEDF_ERR(&(qedf->dbg_ctx),
3630 qedf->timer_work_queue = alloc_workqueue("qedf_%u_timer",
3631 WQ_MEM_RECLAIM, 1, qedf->lport->host->host_no);
3632 if (!qedf->timer_work_queue) {
3633 QEDF_ERR(&(qedf->dbg_ctx), "Failed to start timer "
3642 qedf->lport->host->host_no);
3643 qedf->dpc_wq =
3646 INIT_DELAYED_WORK(&qedf->recovery_work, qedf_recovery_handler);
3653 qedf->grcdump_size =
3654 qed_ops->common->dbg_all_data_size(qedf->cdev);
3655 if (qedf->grcdump_size) {
3656 rc = qedf_alloc_grc_dump_buf(&qedf->grcdump,
3657 qedf->grcdump_size);
3659 QEDF_ERR(&(qedf->dbg_ctx),
3661 qedf->grcdump = NULL;
3664 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3666 qedf->grcdump, qedf->grcdump_size);
3668 qedf_create_sysfs_ctx_attr(qedf);
3671 spin_lock_init(&qedf->io_trace_lock);
3672 qedf->io_trace_idx = 0;
3675 init_completion(&qedf->flogi_compl);
3677 status = qed_ops->common->update_drv_state(qedf->cdev, true);
3679 QEDF_ERR(&(qedf->dbg_ctx),
3684 status = qed_ops->common->set_link(qedf->cdev, &link_params);
3686 QEDF_WARN(&(qedf->dbg_ctx), "set_link failed.\n");
3690 fcoe_ctlr_link_up(&qedf->ctlr);
3694 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Probe done.\n");
3696 clear_bit(QEDF_PROBING, &qedf->flags);
3702 if (qedf->ll2_recv_wq)
3703 destroy_workqueue(qedf->ll2_recv_wq);
3704 fc_remove_host(qedf->lport->host);
3705 scsi_remove_host(qedf->lport->host);
3707 qedf_dbg_host_exit(&(qedf->dbg_ctx));
3710 qedf_cmd_mgr_free(qedf->cmd_mgr);
3712 qed_ops->stop(qedf->cdev);
3714 qedf_free_fcoe_pf_param(qedf);
3715 qedf_sync_free_irqs(qedf);
3717 qed_ops->common->slowpath_stop(qedf->cdev);
3719 qed_ops->common->remove(qedf->cdev);
3733 struct qedf_ctx *qedf;
3742 qedf = pci_get_drvdata(pdev);
3748 if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
3749 QEDF_ERR(&qedf->dbg_ctx, "Already removing PCI function.\n");
3754 if (test_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags)) {
3755 QEDF_ERR(&qedf->dbg_ctx, "Stag in progress, cnt=%d.\n", cnt);
3765 set_bit(QEDF_UNLOADING, &qedf->flags);
3769 fcoe_ctlr_link_down(&qedf->ctlr);
3771 fc_fabric_logoff(qedf->lport);
3773 if (!qedf_wait_for_upload(qedf))
3774 QEDF_ERR(&qedf->dbg_ctx, "Could not upload all sessions.\n");
3777 qedf_dbg_host_exit(&(qedf->dbg_ctx));
3781 cancel_delayed_work_sync(&qedf->link_update);
3782 destroy_workqueue(qedf->link_update_wq);
3783 qedf->link_update_wq = NULL;
3785 if (qedf->timer_work_queue)
3786 destroy_workqueue(qedf->timer_work_queue);
3789 clear_bit(QEDF_LL2_STARTED, &qedf->flags);
3790 qed_ops->ll2->stop(qedf->cdev);
3791 if (qedf->ll2_recv_wq)
3792 destroy_workqueue(qedf->ll2_recv_wq);
3795 qedf_sync_free_irqs(qedf);
3796 qedf_destroy_sb(qedf);
3803 qedf_free_grc_dump_buf(&qedf->grcdump);
3804 qedf_remove_sysfs_ctx_attr(qedf);
3807 fcoe_ctlr_destroy(&qedf->ctlr);
3808 fc_lport_destroy(qedf->lport);
3809 fc_remove_host(qedf->lport->host);
3810 scsi_remove_host(qedf->lport->host);
3813 qedf_cmd_mgr_free(qedf->cmd_mgr);
3816 fc_exch_mgr_free(qedf->lport);
3817 fc_lport_free_stats(qedf->lport);
3820 qedf_wait_for_vport_destroy(qedf);
3827 qed_ops->stop(qedf->cdev);
3830 if (qedf->dpc_wq) {
3832 destroy_workqueue(qedf->dpc_wq);
3833 qedf->dpc_wq = NULL;
3838 qedf_free_fcoe_pf_param(qedf);
3840 qed_ops->common->set_power_state(qedf->cdev, PCI_D0);
3844 rc = qed_ops->common->update_drv_state(qedf->cdev, false);
3846 QEDF_ERR(&(qedf->dbg_ctx),
3849 if (mode != QEDF_MODE_RECOVERY && qedf->devlink) {
3850 qed_ops->common->devlink_unregister(qedf->devlink);
3851 qedf->devlink = NULL;
3854 qed_ops->common->slowpath_stop(qedf->cdev);
3855 qed_ops->common->remove(qedf->cdev);
3857 mempool_destroy(qedf->io_mempool);
3861 scsi_host_put(qedf->lport->host);
3875 struct qedf_ctx *qedf =
3878 QEDF_ERR(&(qedf->dbg_ctx), "Collecting GRC dump.\n");
3879 qedf_capture_grc_dump(qedf);
3884 struct qedf_ctx *qedf = dev;
3886 QEDF_ERR(&(qedf->dbg_ctx),
3890 if (test_bit(QEDF_IN_RECOVERY, &qedf->flags)) {
3891 QEDF_ERR(&(qedf->dbg_ctx),
3898 schedule_delayed_work(&qedf->board_disable_work, 0);
3905 qed_ops->common->attn_clr_enable(qedf->cdev, true);
3909 qed_ops->common->attn_clr_enable(qedf->cdev, true);
3911 if (qedf_enable_recovery && qedf->devlink)
3912 qed_ops->common->report_fatal_error(qedf->devlink,
3926 struct qedf_ctx *qedf = dev;
3933 if (!qedf) {
3934 QEDF_ERR(NULL, "qedf is null.\n");
3938 if (test_bit(QEDF_PROBING, &qedf->flags)) {
3939 QEDF_ERR(&qedf->dbg_ctx, "Function is still probing.\n");
3943 lport = qedf->lport;
3966 if (qedf->ctlr.sel_fcf) {
3968 u64_to_wwn(qedf->ctlr.sel_fcf->switch_name, fcoe->switch_name);
3972 /* For qedf we're either link down or fabric attach */
4005 fcoe->tx_lun_rst = qedf->lun_resets;
4008 fcoe->abort_task_sets = qedf->packet_aborts;
4011 fcoe->scsi_busy = qedf->busy;
4014 fcoe->scsi_tsk_full = qedf->task_set_fulls;
4020 struct qedf_ctx *qedf =
4023 if (test_bit(QEDF_IN_RECOVERY, &qedf->flags)) {
4024 QEDF_ERR(&qedf->dbg_ctx,
4029 if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
4030 QEDF_ERR(&qedf->dbg_ctx, "Driver unloading\n");
4034 set_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
4037 dev_name(&qedf->pdev->dev), __func__, __LINE__,
4038 qedf->dbg_ctx.host_no);
4039 qedf_ctx_soft_reset(qedf->lport);
4049 struct qedf_ctx *qedf;
4056 qedf = pci_get_drvdata(pdev);
4058 QEDF_ERR(&qedf->dbg_ctx, "%s: Device does not support suspend operation\n", __func__);
4068 struct qedf_ctx *qedf = dev;
4070 QEDF_ERR(&qedf->dbg_ctx, "Recovery handler scheduled.\n");
4071 schedule_delayed_work(&qedf->recovery_work, 0);
4076 struct qedf_ctx *qedf =
4079 if (test_and_set_bit(QEDF_IN_RECOVERY, &qedf->flags))
4086 qed_ops->common->recovery_prolog(qedf->cdev);
4088 QEDF_ERR(&qedf->dbg_ctx, "Recovery work start.\n");
4089 __qedf_remove(qedf->pdev, QEDF_MODE_RECOVERY);
4095 atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
4096 atomic_set(&qedf->dcbx, QEDF_DCBX_PENDING);
4097 __qedf_probe(qedf->pdev, QEDF_MODE_RECOVERY);
4098 clear_bit(QEDF_IN_RECOVERY, &qedf->flags);
4099 QEDF_ERR(&qedf->dbg_ctx, "Recovery work complete.\n");
4105 struct qedf_ctx *qedf;
4112 qedf = (struct qedf_ctx *)dev;
4115 ether_addr_copy(data->mac[0], qedf->mac);
4162 qedf_dbg_init("qedf");