13287e96aSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
261d8658bSDupuis, Chad /*
361d8658bSDupuis, Chad * QLogic FCoE Offload Driver
45d1c8b5bSChad Dupuis * Copyright (c) 2016-2018 Cavium Inc.
561d8658bSDupuis, Chad */
661d8658bSDupuis, Chad #include <linux/init.h>
761d8658bSDupuis, Chad #include <linux/kernel.h>
861d8658bSDupuis, Chad #include <linux/module.h>
961d8658bSDupuis, Chad #include <linux/pci.h>
1061d8658bSDupuis, Chad #include <linux/device.h>
1161d8658bSDupuis, Chad #include <linux/highmem.h>
1261d8658bSDupuis, Chad #include <linux/crc32.h>
1361d8658bSDupuis, Chad #include <linux/interrupt.h>
1461d8658bSDupuis, Chad #include <linux/list.h>
1561d8658bSDupuis, Chad #include <linux/kthread.h>
16bdb5d8ecSAlexander Lobakin #include <linux/phylink.h>
1761d8658bSDupuis, Chad #include <scsi/libfc.h>
1861d8658bSDupuis, Chad #include <scsi/scsi_host.h>
19a3cd42a9SChad Dupuis #include <scsi/fc_frame.h>
2061d8658bSDupuis, Chad #include <linux/if_ether.h>
2161d8658bSDupuis, Chad #include <linux/if_vlan.h>
2261d8658bSDupuis, Chad #include <linux/cpu.h>
2361d8658bSDupuis, Chad #include "qedf.h"
24d9ea463aSArnd Bergmann #include "qedf_dbg.h"
255185b328SChad Dupuis #include <uapi/linux/pci_regs.h>
2661d8658bSDupuis, Chad
2761d8658bSDupuis, Chad const struct qed_fcoe_ops *qed_ops;
2861d8658bSDupuis, Chad
2961d8658bSDupuis, Chad static int qedf_probe(struct pci_dev *pdev, const struct pci_device_id *id);
3061d8658bSDupuis, Chad static void qedf_remove(struct pci_dev *pdev);
3131696204SSaurav Kashyap static void qedf_shutdown(struct pci_dev *pdev);
32f6b172f2SChad Dupuis static void qedf_schedule_recovery_handler(void *dev);
33f6b172f2SChad Dupuis static void qedf_recovery_handler(struct work_struct *work);
34ef222f55SNilesh Javali static int qedf_suspend(struct pci_dev *pdev, pm_message_t state);
3561d8658bSDupuis, Chad
3661d8658bSDupuis, Chad /*
3761d8658bSDupuis, Chad * Driver module parameters.
3861d8658bSDupuis, Chad */
3961d8658bSDupuis, Chad static unsigned int qedf_dev_loss_tmo = 60;
4061d8658bSDupuis, Chad module_param_named(dev_loss_tmo, qedf_dev_loss_tmo, int, S_IRUGO);
4161d8658bSDupuis, Chad MODULE_PARM_DESC(dev_loss_tmo, " dev_loss_tmo setting for attached "
4261d8658bSDupuis, Chad "remote ports (default 60)");
4361d8658bSDupuis, Chad
4461d8658bSDupuis, Chad uint qedf_debug = QEDF_LOG_INFO;
4506666464SJaved Hasan module_param_named(debug, qedf_debug, uint, S_IRUGO|S_IWUSR);
460516abdfSChad Dupuis MODULE_PARM_DESC(debug, " Debug mask. Pass '1' to enable default debugging"
4761d8658bSDupuis, Chad " mask");
4861d8658bSDupuis, Chad
49c3ef86f3SChad Dupuis static uint qedf_fipvlan_retries = 60;
5061d8658bSDupuis, Chad module_param_named(fipvlan_retries, qedf_fipvlan_retries, int, S_IRUGO);
5161d8658bSDupuis, Chad MODULE_PARM_DESC(fipvlan_retries, " Number of FIP VLAN requests to attempt "
52c3ef86f3SChad Dupuis "before giving up (default 60)");
5361d8658bSDupuis, Chad
5461d8658bSDupuis, Chad static uint qedf_fallback_vlan = QEDF_FALLBACK_VLAN;
5561d8658bSDupuis, Chad module_param_named(fallback_vlan, qedf_fallback_vlan, int, S_IRUGO);
5661d8658bSDupuis, Chad MODULE_PARM_DESC(fallback_vlan, " VLAN ID to try if fip vlan request fails "
5761d8658bSDupuis, Chad "(default 1002).");
5861d8658bSDupuis, Chad
5984b2ba6eSChad Dupuis static int qedf_default_prio = -1;
6061d8658bSDupuis, Chad module_param_named(default_prio, qedf_default_prio, int, S_IRUGO);
6184b2ba6eSChad Dupuis MODULE_PARM_DESC(default_prio, " Override 802.1q priority for FIP and FCoE"
6284b2ba6eSChad Dupuis " traffic (value between 0 and 7, default 3).");
6361d8658bSDupuis, Chad
6461d8658bSDupuis, Chad uint qedf_dump_frames;
6561d8658bSDupuis, Chad module_param_named(dump_frames, qedf_dump_frames, int, S_IRUGO | S_IWUSR);
6661d8658bSDupuis, Chad MODULE_PARM_DESC(dump_frames, " Print the skb data of FIP and FCoE frames "
6761d8658bSDupuis, Chad "(default off)");
6861d8658bSDupuis, Chad
6961d8658bSDupuis, Chad static uint qedf_queue_depth;
7061d8658bSDupuis, Chad module_param_named(queue_depth, qedf_queue_depth, int, S_IRUGO);
7161d8658bSDupuis, Chad MODULE_PARM_DESC(queue_depth, " Sets the queue depth for all LUNs discovered "
7261d8658bSDupuis, Chad "by the qedf driver. Default is 0 (use OS default).");
7361d8658bSDupuis, Chad
7461d8658bSDupuis, Chad uint qedf_io_tracing;
7561d8658bSDupuis, Chad module_param_named(io_tracing, qedf_io_tracing, int, S_IRUGO | S_IWUSR);
7661d8658bSDupuis, Chad MODULE_PARM_DESC(io_tracing, " Enable logging of SCSI requests/completions "
7761d8658bSDupuis, Chad "into trace buffer. (default off).");
7861d8658bSDupuis, Chad
7961d8658bSDupuis, Chad static uint qedf_max_lun = MAX_FIBRE_LUNS;
8061d8658bSDupuis, Chad module_param_named(max_lun, qedf_max_lun, int, S_IRUGO);
8161d8658bSDupuis, Chad MODULE_PARM_DESC(max_lun, " Sets the maximum luns per target that the driver "
8261d8658bSDupuis, Chad "supports. (default 0xffffffff)");
8361d8658bSDupuis, Chad
8461d8658bSDupuis, Chad uint qedf_link_down_tmo;
8561d8658bSDupuis, Chad module_param_named(link_down_tmo, qedf_link_down_tmo, int, S_IRUGO);
8661d8658bSDupuis, Chad MODULE_PARM_DESC(link_down_tmo, " Delays informing the fcoe transport that the "
8761d8658bSDupuis, Chad "link is down by N seconds.");
8861d8658bSDupuis, Chad
8961d8658bSDupuis, Chad bool qedf_retry_delay;
9061d8658bSDupuis, Chad module_param_named(retry_delay, qedf_retry_delay, bool, S_IRUGO | S_IWUSR);
9161d8658bSDupuis, Chad MODULE_PARM_DESC(retry_delay, " Enable/disable handling of FCP_RSP IU retry "
9261d8658bSDupuis, Chad "delay handling (default off).");
9361d8658bSDupuis, Chad
94ba17d379SChad Dupuis static bool qedf_dcbx_no_wait;
95ba17d379SChad Dupuis module_param_named(dcbx_no_wait, qedf_dcbx_no_wait, bool, S_IRUGO | S_IWUSR);
96ba17d379SChad Dupuis MODULE_PARM_DESC(dcbx_no_wait, " Do not wait for DCBX convergence to start "
97ba17d379SChad Dupuis "sending FIP VLAN requests on link up (Default: off).");
98ba17d379SChad Dupuis
9961d8658bSDupuis, Chad static uint qedf_dp_module;
10061d8658bSDupuis, Chad module_param_named(dp_module, qedf_dp_module, uint, S_IRUGO);
10161d8658bSDupuis, Chad MODULE_PARM_DESC(dp_module, " bit flags control for verbose printk passed "
10261d8658bSDupuis, Chad "qed module during probe.");
10361d8658bSDupuis, Chad
1042b82a62fSChad Dupuis static uint qedf_dp_level = QED_LEVEL_NOTICE;
10561d8658bSDupuis, Chad module_param_named(dp_level, qedf_dp_level, uint, S_IRUGO);
10661d8658bSDupuis, Chad MODULE_PARM_DESC(dp_level, " printk verbosity control passed to qed module "
10761d8658bSDupuis, Chad "during probe (0-3: 0 more verbose).");
10861d8658bSDupuis, Chad
10955e04991SSaurav Kashyap static bool qedf_enable_recovery = true;
11055e04991SSaurav Kashyap module_param_named(enable_recovery, qedf_enable_recovery,
11155e04991SSaurav Kashyap bool, S_IRUGO | S_IWUSR);
11255e04991SSaurav Kashyap MODULE_PARM_DESC(enable_recovery, "Enable/disable recovery on driver/firmware "
11355e04991SSaurav Kashyap "interface level errors 0 = Disabled, 1 = Enabled (Default: 1).");
11455e04991SSaurav Kashyap
11561d8658bSDupuis, Chad struct workqueue_struct *qedf_io_wq;
11661d8658bSDupuis, Chad
11761d8658bSDupuis, Chad static struct fcoe_percpu_s qedf_global;
11861d8658bSDupuis, Chad static DEFINE_SPINLOCK(qedf_global_lock);
11961d8658bSDupuis, Chad
12061d8658bSDupuis, Chad static struct kmem_cache *qedf_io_work_cache;
12161d8658bSDupuis, Chad
qedf_set_vlan_id(struct qedf_ctx * qedf,int vlan_id)12261d8658bSDupuis, Chad void qedf_set_vlan_id(struct qedf_ctx *qedf, int vlan_id)
12361d8658bSDupuis, Chad {
1243480e7a8SSaurav Kashyap int vlan_id_tmp = 0;
1253480e7a8SSaurav Kashyap
1263480e7a8SSaurav Kashyap vlan_id_tmp = vlan_id | (qedf->prio << VLAN_PRIO_SHIFT);
1273480e7a8SSaurav Kashyap qedf->vlan_id = vlan_id_tmp;
1283480e7a8SSaurav Kashyap QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
1293480e7a8SSaurav Kashyap "Setting vlan_id=0x%04x prio=%d.\n",
1303480e7a8SSaurav Kashyap vlan_id_tmp, qedf->prio);
13161d8658bSDupuis, Chad }
13261d8658bSDupuis, Chad
13361d8658bSDupuis, Chad /* Returns true if we have a valid vlan, false otherwise */
qedf_initiate_fipvlan_req(struct qedf_ctx * qedf)13461d8658bSDupuis, Chad static bool qedf_initiate_fipvlan_req(struct qedf_ctx *qedf)
13561d8658bSDupuis, Chad {
13661d8658bSDupuis, Chad
13776dbf4ffSSaurav Kashyap while (qedf->fipvlan_retries--) {
13876dbf4ffSSaurav Kashyap /* This is to catch if link goes down during fipvlan retries */
13976dbf4ffSSaurav Kashyap if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
14076dbf4ffSSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "Link not up.\n");
14161d8658bSDupuis, Chad return false;
14261d8658bSDupuis, Chad }
14361d8658bSDupuis, Chad
1444909e153SSaurav Kashyap if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
1454909e153SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "Driver unloading.\n");
1464909e153SSaurav Kashyap return false;
1474909e153SSaurav Kashyap }
1484909e153SSaurav Kashyap
149e82e6ff7SSaurav Kashyap if (qedf->vlan_id > 0) {
150e82e6ff7SSaurav Kashyap QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
1513480e7a8SSaurav Kashyap "vlan = 0x%x already set, calling ctlr_link_up.\n",
1523480e7a8SSaurav Kashyap qedf->vlan_id);
1533480e7a8SSaurav Kashyap if (atomic_read(&qedf->link_state) == QEDF_LINK_UP)
1543480e7a8SSaurav Kashyap fcoe_ctlr_link_up(&qedf->ctlr);
15561d8658bSDupuis, Chad return true;
156e82e6ff7SSaurav Kashyap }
15776dbf4ffSSaurav Kashyap
15861d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
15961d8658bSDupuis, Chad "Retry %d.\n", qedf->fipvlan_retries);
16061d8658bSDupuis, Chad init_completion(&qedf->fipvlan_compl);
16161d8658bSDupuis, Chad qedf_fcoe_send_vlan_req(qedf);
1623480e7a8SSaurav Kashyap wait_for_completion_timeout(&qedf->fipvlan_compl, 1 * HZ);
16361d8658bSDupuis, Chad }
16461d8658bSDupuis, Chad
16561d8658bSDupuis, Chad return false;
16661d8658bSDupuis, Chad }
16761d8658bSDupuis, Chad
qedf_handle_link_update(struct work_struct * work)16861d8658bSDupuis, Chad static void qedf_handle_link_update(struct work_struct *work)
16961d8658bSDupuis, Chad {
17061d8658bSDupuis, Chad struct qedf_ctx *qedf =
17161d8658bSDupuis, Chad container_of(work, struct qedf_ctx, link_update.work);
17261d8658bSDupuis, Chad int rc;
17361d8658bSDupuis, Chad
174a66c6cd2SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Entered. link_state=%d.\n",
175a66c6cd2SChad Dupuis atomic_read(&qedf->link_state));
17661d8658bSDupuis, Chad
17761d8658bSDupuis, Chad if (atomic_read(&qedf->link_state) == QEDF_LINK_UP) {
17861d8658bSDupuis, Chad rc = qedf_initiate_fipvlan_req(qedf);
17961d8658bSDupuis, Chad if (rc)
18061d8658bSDupuis, Chad return;
18176dbf4ffSSaurav Kashyap
18276dbf4ffSSaurav Kashyap if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
183e82e6ff7SSaurav Kashyap QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
184e82e6ff7SSaurav Kashyap "Link is down, resetting vlan_id.\n");
18576dbf4ffSSaurav Kashyap qedf->vlan_id = 0;
18676dbf4ffSSaurav Kashyap return;
18776dbf4ffSSaurav Kashyap }
18876dbf4ffSSaurav Kashyap
18961d8658bSDupuis, Chad /*
19061d8658bSDupuis, Chad * If we get here then we never received a repsonse to our
19161d8658bSDupuis, Chad * fip vlan request so set the vlan_id to the default and
19261d8658bSDupuis, Chad * tell FCoE that the link is up
19361d8658bSDupuis, Chad */
19461d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "Did not receive FIP VLAN "
19561d8658bSDupuis, Chad "response, falling back to default VLAN %d.\n",
19661d8658bSDupuis, Chad qedf_fallback_vlan);
197cf291163SChad Dupuis qedf_set_vlan_id(qedf, qedf_fallback_vlan);
19861d8658bSDupuis, Chad
19961d8658bSDupuis, Chad /*
20061d8658bSDupuis, Chad * Zero out data_src_addr so we'll update it with the new
20161d8658bSDupuis, Chad * lport port_id
20261d8658bSDupuis, Chad */
20361d8658bSDupuis, Chad eth_zero_addr(qedf->data_src_addr);
20461d8658bSDupuis, Chad fcoe_ctlr_link_up(&qedf->ctlr);
20561d8658bSDupuis, Chad } else if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
20661d8658bSDupuis, Chad /*
20761d8658bSDupuis, Chad * If we hit here and link_down_tmo_valid is still 1 it means
20861d8658bSDupuis, Chad * that link_down_tmo timed out so set it to 0 to make sure any
20961d8658bSDupuis, Chad * other readers have accurate state.
21061d8658bSDupuis, Chad */
21161d8658bSDupuis, Chad atomic_set(&qedf->link_down_tmo_valid, 0);
21261d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
21361d8658bSDupuis, Chad "Calling fcoe_ctlr_link_down().\n");
21461d8658bSDupuis, Chad fcoe_ctlr_link_down(&qedf->ctlr);
215a66c6cd2SChad Dupuis if (qedf_wait_for_upload(qedf) == false)
216a66c6cd2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx,
217a66c6cd2SChad Dupuis "Could not upload all sessions.\n");
21861d8658bSDupuis, Chad /* Reset the number of FIP VLAN retries */
21961d8658bSDupuis, Chad qedf->fipvlan_retries = qedf_fipvlan_retries;
22061d8658bSDupuis, Chad }
22161d8658bSDupuis, Chad }
22261d8658bSDupuis, Chad
223a3cd42a9SChad Dupuis #define QEDF_FCOE_MAC_METHOD_GRANGED_MAC 1
224a3cd42a9SChad Dupuis #define QEDF_FCOE_MAC_METHOD_FCF_MAP 2
225a3cd42a9SChad Dupuis #define QEDF_FCOE_MAC_METHOD_FCOE_SET_MAC 3
qedf_set_data_src_addr(struct qedf_ctx * qedf,struct fc_frame * fp)226a3cd42a9SChad Dupuis static void qedf_set_data_src_addr(struct qedf_ctx *qedf, struct fc_frame *fp)
227a3cd42a9SChad Dupuis {
228a3cd42a9SChad Dupuis u8 *granted_mac;
229a3cd42a9SChad Dupuis struct fc_frame_header *fh = fc_frame_header_get(fp);
230a3cd42a9SChad Dupuis u8 fc_map[3];
231a3cd42a9SChad Dupuis int method = 0;
232a3cd42a9SChad Dupuis
233a3cd42a9SChad Dupuis /* Get granted MAC address from FIP FLOGI payload */
234a3cd42a9SChad Dupuis granted_mac = fr_cb(fp)->granted_mac;
235a3cd42a9SChad Dupuis
236a3cd42a9SChad Dupuis /*
237a3cd42a9SChad Dupuis * We set the source MAC for FCoE traffic based on the Granted MAC
238a3cd42a9SChad Dupuis * address from the switch.
239a3cd42a9SChad Dupuis *
240a3cd42a9SChad Dupuis * If granted_mac is non-zero, we used that.
241a3cd42a9SChad Dupuis * If the granted_mac is zeroed out, created the FCoE MAC based on
242a3cd42a9SChad Dupuis * the sel_fcf->fc_map and the d_id fo the FLOGI frame.
243a3cd42a9SChad Dupuis * If sel_fcf->fc_map is 0 then we use the default FCF-MAC plus the
244a3cd42a9SChad Dupuis * d_id of the FLOGI frame.
245a3cd42a9SChad Dupuis */
246a3cd42a9SChad Dupuis if (!is_zero_ether_addr(granted_mac)) {
247a3cd42a9SChad Dupuis ether_addr_copy(qedf->data_src_addr, granted_mac);
248a3cd42a9SChad Dupuis method = QEDF_FCOE_MAC_METHOD_GRANGED_MAC;
249a3cd42a9SChad Dupuis } else if (qedf->ctlr.sel_fcf->fc_map != 0) {
250a3cd42a9SChad Dupuis hton24(fc_map, qedf->ctlr.sel_fcf->fc_map);
251a3cd42a9SChad Dupuis qedf->data_src_addr[0] = fc_map[0];
252a3cd42a9SChad Dupuis qedf->data_src_addr[1] = fc_map[1];
253a3cd42a9SChad Dupuis qedf->data_src_addr[2] = fc_map[2];
254a3cd42a9SChad Dupuis qedf->data_src_addr[3] = fh->fh_d_id[0];
255a3cd42a9SChad Dupuis qedf->data_src_addr[4] = fh->fh_d_id[1];
256a3cd42a9SChad Dupuis qedf->data_src_addr[5] = fh->fh_d_id[2];
257a3cd42a9SChad Dupuis method = QEDF_FCOE_MAC_METHOD_FCF_MAP;
258a3cd42a9SChad Dupuis } else {
259a3cd42a9SChad Dupuis fc_fcoe_set_mac(qedf->data_src_addr, fh->fh_d_id);
260a3cd42a9SChad Dupuis method = QEDF_FCOE_MAC_METHOD_FCOE_SET_MAC;
261a3cd42a9SChad Dupuis }
262a3cd42a9SChad Dupuis
263a3cd42a9SChad Dupuis QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
264a3cd42a9SChad Dupuis "QEDF data_src_mac=%pM method=%d.\n", qedf->data_src_addr, method);
265a3cd42a9SChad Dupuis }
266a3cd42a9SChad Dupuis
qedf_flogi_resp(struct fc_seq * seq,struct fc_frame * fp,void * arg)26761d8658bSDupuis, Chad static void qedf_flogi_resp(struct fc_seq *seq, struct fc_frame *fp,
26861d8658bSDupuis, Chad void *arg)
26961d8658bSDupuis, Chad {
27061d8658bSDupuis, Chad struct fc_exch *exch = fc_seq_exch(seq);
27161d8658bSDupuis, Chad struct fc_lport *lport = exch->lp;
27261d8658bSDupuis, Chad struct qedf_ctx *qedf = lport_priv(lport);
27361d8658bSDupuis, Chad
27461d8658bSDupuis, Chad if (!qedf) {
27561d8658bSDupuis, Chad QEDF_ERR(NULL, "qedf is NULL.\n");
27661d8658bSDupuis, Chad return;
27761d8658bSDupuis, Chad }
27861d8658bSDupuis, Chad
27961d8658bSDupuis, Chad /*
28061d8658bSDupuis, Chad * If ERR_PTR is set then don't try to stat anything as it will cause
28161d8658bSDupuis, Chad * a crash when we access fp.
28261d8658bSDupuis, Chad */
28361d8658bSDupuis, Chad if (IS_ERR(fp)) {
28461d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
28561d8658bSDupuis, Chad "fp has IS_ERR() set.\n");
28661d8658bSDupuis, Chad goto skip_stat;
28761d8658bSDupuis, Chad }
28861d8658bSDupuis, Chad
28961d8658bSDupuis, Chad /* Log stats for FLOGI reject */
29061d8658bSDupuis, Chad if (fc_frame_payload_op(fp) == ELS_LS_RJT)
29161d8658bSDupuis, Chad qedf->flogi_failed++;
292a3cd42a9SChad Dupuis else if (fc_frame_payload_op(fp) == ELS_LS_ACC) {
293a3cd42a9SChad Dupuis /* Set the source MAC we will use for FCoE traffic */
294a3cd42a9SChad Dupuis qedf_set_data_src_addr(qedf, fp);
295ab0a8299SSaurav Kashyap qedf->flogi_pending = 0;
296a3cd42a9SChad Dupuis }
29761d8658bSDupuis, Chad
29861d8658bSDupuis, Chad /* Complete flogi_compl so we can proceed to sending ADISCs */
29961d8658bSDupuis, Chad complete(&qedf->flogi_compl);
30061d8658bSDupuis, Chad
30161d8658bSDupuis, Chad skip_stat:
30261d8658bSDupuis, Chad /* Report response to libfc */
30361d8658bSDupuis, Chad fc_lport_flogi_resp(seq, fp, lport);
30461d8658bSDupuis, Chad }
30561d8658bSDupuis, Chad
qedf_elsct_send(struct fc_lport * lport,u32 did,struct fc_frame * fp,unsigned int op,void (* resp)(struct fc_seq *,struct fc_frame *,void *),void * arg,u32 timeout)30661d8658bSDupuis, Chad static struct fc_seq *qedf_elsct_send(struct fc_lport *lport, u32 did,
30761d8658bSDupuis, Chad struct fc_frame *fp, unsigned int op,
30861d8658bSDupuis, Chad void (*resp)(struct fc_seq *,
30961d8658bSDupuis, Chad struct fc_frame *,
31061d8658bSDupuis, Chad void *),
31161d8658bSDupuis, Chad void *arg, u32 timeout)
31261d8658bSDupuis, Chad {
31361d8658bSDupuis, Chad struct qedf_ctx *qedf = lport_priv(lport);
31461d8658bSDupuis, Chad
31561d8658bSDupuis, Chad /*
31661d8658bSDupuis, Chad * Intercept FLOGI for statistic purposes. Note we use the resp
31761d8658bSDupuis, Chad * callback to tell if this is really a flogi.
31861d8658bSDupuis, Chad */
31961d8658bSDupuis, Chad if (resp == fc_lport_flogi_resp) {
32061d8658bSDupuis, Chad qedf->flogi_cnt++;
321ab0a8299SSaurav Kashyap if (qedf->flogi_pending >= QEDF_FLOGI_RETRY_CNT) {
322ab0a8299SSaurav Kashyap schedule_delayed_work(&qedf->stag_work, 2);
323ab0a8299SSaurav Kashyap return NULL;
324ab0a8299SSaurav Kashyap }
325ab0a8299SSaurav Kashyap qedf->flogi_pending++;
32661d8658bSDupuis, Chad return fc_elsct_send(lport, did, fp, op, qedf_flogi_resp,
32761d8658bSDupuis, Chad arg, timeout);
32861d8658bSDupuis, Chad }
32961d8658bSDupuis, Chad
33061d8658bSDupuis, Chad return fc_elsct_send(lport, did, fp, op, resp, arg, timeout);
33161d8658bSDupuis, Chad }
33261d8658bSDupuis, Chad
qedf_send_flogi(struct qedf_ctx * qedf)33361d8658bSDupuis, Chad int qedf_send_flogi(struct qedf_ctx *qedf)
33461d8658bSDupuis, Chad {
33561d8658bSDupuis, Chad struct fc_lport *lport;
33661d8658bSDupuis, Chad struct fc_frame *fp;
33761d8658bSDupuis, Chad
33861d8658bSDupuis, Chad lport = qedf->lport;
33961d8658bSDupuis, Chad
340e82e6ff7SSaurav Kashyap if (!lport->tt.elsct_send) {
341e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "tt.elsct_send not set.\n");
34261d8658bSDupuis, Chad return -EINVAL;
343e82e6ff7SSaurav Kashyap }
34461d8658bSDupuis, Chad
34561d8658bSDupuis, Chad fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
34661d8658bSDupuis, Chad if (!fp) {
34761d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "fc_frame_alloc failed.\n");
34861d8658bSDupuis, Chad return -ENOMEM;
34961d8658bSDupuis, Chad }
35061d8658bSDupuis, Chad
35161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
35261d8658bSDupuis, Chad "Sending FLOGI to reestablish session with switch.\n");
35361d8658bSDupuis, Chad lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
35461d8658bSDupuis, Chad ELS_FLOGI, qedf_flogi_resp, lport, lport->r_a_tov);
35561d8658bSDupuis, Chad
35661d8658bSDupuis, Chad init_completion(&qedf->flogi_compl);
35761d8658bSDupuis, Chad
35861d8658bSDupuis, Chad return 0;
35961d8658bSDupuis, Chad }
36061d8658bSDupuis, Chad
36161d8658bSDupuis, Chad /*
36261d8658bSDupuis, Chad * This function is called if link_down_tmo is in use. If we get a link up and
36361d8658bSDupuis, Chad * link_down_tmo has not expired then use just FLOGI/ADISC to recover our
36461d8658bSDupuis, Chad * sessions with targets. Otherwise, just call fcoe_ctlr_link_up().
36561d8658bSDupuis, Chad */
qedf_link_recovery(struct work_struct * work)36661d8658bSDupuis, Chad static void qedf_link_recovery(struct work_struct *work)
36761d8658bSDupuis, Chad {
36861d8658bSDupuis, Chad struct qedf_ctx *qedf =
36961d8658bSDupuis, Chad container_of(work, struct qedf_ctx, link_recovery.work);
3705797bcc8SHannes Reinecke struct fc_lport *lport = qedf->lport;
37161d8658bSDupuis, Chad struct fc_rport_priv *rdata;
37261d8658bSDupuis, Chad bool rc;
37361d8658bSDupuis, Chad int retries = 30;
37461d8658bSDupuis, Chad int rval, i;
37561d8658bSDupuis, Chad struct list_head rdata_login_list;
37661d8658bSDupuis, Chad
37761d8658bSDupuis, Chad INIT_LIST_HEAD(&rdata_login_list);
37861d8658bSDupuis, Chad
37961d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
38061d8658bSDupuis, Chad "Link down tmo did not expire.\n");
38161d8658bSDupuis, Chad
38261d8658bSDupuis, Chad /*
38361d8658bSDupuis, Chad * Essentially reset the fcoe_ctlr here without affecting the state
38461d8658bSDupuis, Chad * of the libfc structs.
38561d8658bSDupuis, Chad */
38661d8658bSDupuis, Chad qedf->ctlr.state = FIP_ST_LINK_WAIT;
38761d8658bSDupuis, Chad fcoe_ctlr_link_down(&qedf->ctlr);
38861d8658bSDupuis, Chad
38961d8658bSDupuis, Chad /*
39061d8658bSDupuis, Chad * Bring the link up before we send the fipvlan request so libfcoe
39161d8658bSDupuis, Chad * can select a new fcf in parallel
39261d8658bSDupuis, Chad */
39361d8658bSDupuis, Chad fcoe_ctlr_link_up(&qedf->ctlr);
39461d8658bSDupuis, Chad
39561d8658bSDupuis, Chad /* Since the link when down and up to verify which vlan we're on */
39661d8658bSDupuis, Chad qedf->fipvlan_retries = qedf_fipvlan_retries;
39761d8658bSDupuis, Chad rc = qedf_initiate_fipvlan_req(qedf);
398cf291163SChad Dupuis /* If getting the VLAN fails, set the VLAN to the fallback one */
39961d8658bSDupuis, Chad if (!rc)
400cf291163SChad Dupuis qedf_set_vlan_id(qedf, qedf_fallback_vlan);
40161d8658bSDupuis, Chad
40261d8658bSDupuis, Chad /*
40361d8658bSDupuis, Chad * We need to wait for an FCF to be selected due to the
40461d8658bSDupuis, Chad * fcoe_ctlr_link_up other the FLOGI will be rejected.
40561d8658bSDupuis, Chad */
40661d8658bSDupuis, Chad while (retries > 0) {
40761d8658bSDupuis, Chad if (qedf->ctlr.sel_fcf) {
40861d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
40961d8658bSDupuis, Chad "FCF reselected, proceeding with FLOGI.\n");
41061d8658bSDupuis, Chad break;
41161d8658bSDupuis, Chad }
41261d8658bSDupuis, Chad msleep(500);
41361d8658bSDupuis, Chad retries--;
41461d8658bSDupuis, Chad }
41561d8658bSDupuis, Chad
41661d8658bSDupuis, Chad if (retries < 1) {
41761d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Exhausted retries waiting for "
41861d8658bSDupuis, Chad "FCF selection.\n");
41961d8658bSDupuis, Chad return;
42061d8658bSDupuis, Chad }
42161d8658bSDupuis, Chad
42261d8658bSDupuis, Chad rval = qedf_send_flogi(qedf);
42361d8658bSDupuis, Chad if (rval)
42461d8658bSDupuis, Chad return;
42561d8658bSDupuis, Chad
42661d8658bSDupuis, Chad /* Wait for FLOGI completion before proceeding with sending ADISCs */
42761d8658bSDupuis, Chad i = wait_for_completion_timeout(&qedf->flogi_compl,
42861d8658bSDupuis, Chad qedf->lport->r_a_tov);
42961d8658bSDupuis, Chad if (i == 0) {
43061d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "FLOGI timed out.\n");
43161d8658bSDupuis, Chad return;
43261d8658bSDupuis, Chad }
43361d8658bSDupuis, Chad
43461d8658bSDupuis, Chad /*
43561d8658bSDupuis, Chad * Call lport->tt.rport_login which will cause libfc to send an
43661d8658bSDupuis, Chad * ADISC since the rport is in state ready.
43761d8658bSDupuis, Chad */
4385797bcc8SHannes Reinecke mutex_lock(&lport->disc.disc_mutex);
4395797bcc8SHannes Reinecke list_for_each_entry_rcu(rdata, &lport->disc.rports, peers) {
44061d8658bSDupuis, Chad if (kref_get_unless_zero(&rdata->kref)) {
4415797bcc8SHannes Reinecke fc_rport_login(rdata);
4425797bcc8SHannes Reinecke kref_put(&rdata->kref, fc_rport_destroy);
44361d8658bSDupuis, Chad }
44461d8658bSDupuis, Chad }
4455797bcc8SHannes Reinecke mutex_unlock(&lport->disc.disc_mutex);
44661d8658bSDupuis, Chad }
44761d8658bSDupuis, Chad
qedf_update_link_speed(struct qedf_ctx * qedf,struct qed_link_output * link)44861d8658bSDupuis, Chad static void qedf_update_link_speed(struct qedf_ctx *qedf,
44961d8658bSDupuis, Chad struct qed_link_output *link)
45061d8658bSDupuis, Chad {
451bdb5d8ecSAlexander Lobakin __ETHTOOL_DECLARE_LINK_MODE_MASK(sup_caps);
45261d8658bSDupuis, Chad struct fc_lport *lport = qedf->lport;
45361d8658bSDupuis, Chad
45461d8658bSDupuis, Chad lport->link_speed = FC_PORTSPEED_UNKNOWN;
45561d8658bSDupuis, Chad lport->link_supported_speeds = FC_PORTSPEED_UNKNOWN;
45661d8658bSDupuis, Chad
45761d8658bSDupuis, Chad /* Set fc_host link speed */
45861d8658bSDupuis, Chad switch (link->speed) {
45961d8658bSDupuis, Chad case 10000:
46061d8658bSDupuis, Chad lport->link_speed = FC_PORTSPEED_10GBIT;
46161d8658bSDupuis, Chad break;
46261d8658bSDupuis, Chad case 25000:
46361d8658bSDupuis, Chad lport->link_speed = FC_PORTSPEED_25GBIT;
46461d8658bSDupuis, Chad break;
46561d8658bSDupuis, Chad case 40000:
46661d8658bSDupuis, Chad lport->link_speed = FC_PORTSPEED_40GBIT;
46761d8658bSDupuis, Chad break;
46861d8658bSDupuis, Chad case 50000:
46961d8658bSDupuis, Chad lport->link_speed = FC_PORTSPEED_50GBIT;
47061d8658bSDupuis, Chad break;
47161d8658bSDupuis, Chad case 100000:
47261d8658bSDupuis, Chad lport->link_speed = FC_PORTSPEED_100GBIT;
47361d8658bSDupuis, Chad break;
474931285e0SSaurav Kashyap case 20000:
475931285e0SSaurav Kashyap lport->link_speed = FC_PORTSPEED_20GBIT;
476931285e0SSaurav Kashyap break;
47761d8658bSDupuis, Chad default:
47861d8658bSDupuis, Chad lport->link_speed = FC_PORTSPEED_UNKNOWN;
47961d8658bSDupuis, Chad break;
48061d8658bSDupuis, Chad }
48161d8658bSDupuis, Chad
48261d8658bSDupuis, Chad /*
48361d8658bSDupuis, Chad * Set supported link speed by querying the supported
48461d8658bSDupuis, Chad * capabilities of the link.
48561d8658bSDupuis, Chad */
486bdb5d8ecSAlexander Lobakin
487bdb5d8ecSAlexander Lobakin phylink_zero(sup_caps);
488bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseT_Full);
489bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseKX4_Full);
490bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseR_FEC);
491bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseCR_Full);
492bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseSR_Full);
493bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseLR_Full);
494bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseLRM_Full);
495bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 10000baseKR_Full);
496bdb5d8ecSAlexander Lobakin
497bdb5d8ecSAlexander Lobakin if (linkmode_intersects(link->supported_caps, sup_caps))
49861d8658bSDupuis, Chad lport->link_supported_speeds |= FC_PORTSPEED_10GBIT;
499bdb5d8ecSAlexander Lobakin
500bdb5d8ecSAlexander Lobakin phylink_zero(sup_caps);
501bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 25000baseKR_Full);
502bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 25000baseCR_Full);
503bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 25000baseSR_Full);
504bdb5d8ecSAlexander Lobakin
505bdb5d8ecSAlexander Lobakin if (linkmode_intersects(link->supported_caps, sup_caps))
50661d8658bSDupuis, Chad lport->link_supported_speeds |= FC_PORTSPEED_25GBIT;
507bdb5d8ecSAlexander Lobakin
508bdb5d8ecSAlexander Lobakin phylink_zero(sup_caps);
509bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 40000baseLR4_Full);
510bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 40000baseKR4_Full);
511bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 40000baseCR4_Full);
512bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 40000baseSR4_Full);
513bdb5d8ecSAlexander Lobakin
514bdb5d8ecSAlexander Lobakin if (linkmode_intersects(link->supported_caps, sup_caps))
51561d8658bSDupuis, Chad lport->link_supported_speeds |= FC_PORTSPEED_40GBIT;
516bdb5d8ecSAlexander Lobakin
517bdb5d8ecSAlexander Lobakin phylink_zero(sup_caps);
518bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 50000baseKR2_Full);
519bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 50000baseCR2_Full);
520bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 50000baseSR2_Full);
521bdb5d8ecSAlexander Lobakin
522bdb5d8ecSAlexander Lobakin if (linkmode_intersects(link->supported_caps, sup_caps))
52361d8658bSDupuis, Chad lport->link_supported_speeds |= FC_PORTSPEED_50GBIT;
524bdb5d8ecSAlexander Lobakin
525bdb5d8ecSAlexander Lobakin phylink_zero(sup_caps);
526bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 100000baseKR4_Full);
527bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 100000baseSR4_Full);
528bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 100000baseCR4_Full);
529bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 100000baseLR4_ER4_Full);
530bdb5d8ecSAlexander Lobakin
531bdb5d8ecSAlexander Lobakin if (linkmode_intersects(link->supported_caps, sup_caps))
53261d8658bSDupuis, Chad lport->link_supported_speeds |= FC_PORTSPEED_100GBIT;
533bdb5d8ecSAlexander Lobakin
534bdb5d8ecSAlexander Lobakin phylink_zero(sup_caps);
535bdb5d8ecSAlexander Lobakin phylink_set(sup_caps, 20000baseKR2_Full);
536bdb5d8ecSAlexander Lobakin
537bdb5d8ecSAlexander Lobakin if (linkmode_intersects(link->supported_caps, sup_caps))
538931285e0SSaurav Kashyap lport->link_supported_speeds |= FC_PORTSPEED_20GBIT;
539bdb5d8ecSAlexander Lobakin
54073578af9SJaved Hasan if (lport->host && lport->host->shost_data)
54173578af9SJaved Hasan fc_host_supported_speeds(lport->host) =
54273578af9SJaved Hasan lport->link_supported_speeds;
54361d8658bSDupuis, Chad }
54461d8658bSDupuis, Chad
qedf_bw_update(void * dev)5456e7c8eeaSSaurav Kashyap static void qedf_bw_update(void *dev)
5466e7c8eeaSSaurav Kashyap {
5476e7c8eeaSSaurav Kashyap struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
5486e7c8eeaSSaurav Kashyap struct qed_link_output link;
5496e7c8eeaSSaurav Kashyap
5506e7c8eeaSSaurav Kashyap /* Get the latest status of the link */
5516e7c8eeaSSaurav Kashyap qed_ops->common->get_link(qedf->cdev, &link);
5526e7c8eeaSSaurav Kashyap
5536e7c8eeaSSaurav Kashyap if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
5546e7c8eeaSSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
5556e7c8eeaSSaurav Kashyap "Ignore link update, driver getting unload.\n");
5566e7c8eeaSSaurav Kashyap return;
5576e7c8eeaSSaurav Kashyap }
5586e7c8eeaSSaurav Kashyap
5596e7c8eeaSSaurav Kashyap if (link.link_up) {
5606e7c8eeaSSaurav Kashyap if (atomic_read(&qedf->link_state) == QEDF_LINK_UP)
5616e7c8eeaSSaurav Kashyap qedf_update_link_speed(qedf, &link);
5626e7c8eeaSSaurav Kashyap else
5636e7c8eeaSSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
5646e7c8eeaSSaurav Kashyap "Ignore bw update, link is down.\n");
5656e7c8eeaSSaurav Kashyap
5666e7c8eeaSSaurav Kashyap } else {
5676e7c8eeaSSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "link_up is not set.\n");
5686e7c8eeaSSaurav Kashyap }
5696e7c8eeaSSaurav Kashyap }
5706e7c8eeaSSaurav Kashyap
qedf_link_update(void * dev,struct qed_link_output * link)57161d8658bSDupuis, Chad static void qedf_link_update(void *dev, struct qed_link_output *link)
57261d8658bSDupuis, Chad {
57361d8658bSDupuis, Chad struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
57461d8658bSDupuis, Chad
57504822626SSaurav Kashyap /*
57604822626SSaurav Kashyap * Prevent race where we're removing the module and we get link update
57704822626SSaurav Kashyap * for qed.
57804822626SSaurav Kashyap */
57904822626SSaurav Kashyap if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
58004822626SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
58104822626SSaurav Kashyap "Ignore link update, driver getting unload.\n");
58204822626SSaurav Kashyap return;
58304822626SSaurav Kashyap }
58404822626SSaurav Kashyap
58561d8658bSDupuis, Chad if (link->link_up) {
5863f9de7f0SChad Dupuis if (atomic_read(&qedf->link_state) == QEDF_LINK_UP) {
5873f9de7f0SChad Dupuis QEDF_INFO((&qedf->dbg_ctx), QEDF_LOG_DISC,
5883f9de7f0SChad Dupuis "Ignoring link up event as link is already up.\n");
5893f9de7f0SChad Dupuis return;
5903f9de7f0SChad Dupuis }
59161d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "LINK UP (%d GB/s).\n",
59261d8658bSDupuis, Chad link->speed / 1000);
59361d8658bSDupuis, Chad
59461d8658bSDupuis, Chad /* Cancel any pending link down work */
59561d8658bSDupuis, Chad cancel_delayed_work(&qedf->link_update);
59661d8658bSDupuis, Chad
59761d8658bSDupuis, Chad atomic_set(&qedf->link_state, QEDF_LINK_UP);
59861d8658bSDupuis, Chad qedf_update_link_speed(qedf, link);
59961d8658bSDupuis, Chad
600ba17d379SChad Dupuis if (atomic_read(&qedf->dcbx) == QEDF_DCBX_DONE ||
601ba17d379SChad Dupuis qedf_dcbx_no_wait) {
602f7e8d57bSChad Dupuis QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
603f7e8d57bSChad Dupuis "DCBx done.\n");
60461d8658bSDupuis, Chad if (atomic_read(&qedf->link_down_tmo_valid) > 0)
60561d8658bSDupuis, Chad queue_delayed_work(qedf->link_update_wq,
60661d8658bSDupuis, Chad &qedf->link_recovery, 0);
60761d8658bSDupuis, Chad else
60861d8658bSDupuis, Chad queue_delayed_work(qedf->link_update_wq,
60961d8658bSDupuis, Chad &qedf->link_update, 0);
61061d8658bSDupuis, Chad atomic_set(&qedf->link_down_tmo_valid, 0);
61161d8658bSDupuis, Chad }
61261d8658bSDupuis, Chad
61361d8658bSDupuis, Chad } else {
61461d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "LINK DOWN.\n");
61561d8658bSDupuis, Chad
61661d8658bSDupuis, Chad atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
61761d8658bSDupuis, Chad atomic_set(&qedf->dcbx, QEDF_DCBX_PENDING);
61861d8658bSDupuis, Chad /*
61961d8658bSDupuis, Chad * Flag that we're waiting for the link to come back up before
62061d8658bSDupuis, Chad * informing the fcoe layer of the event.
62161d8658bSDupuis, Chad */
62261d8658bSDupuis, Chad if (qedf_link_down_tmo > 0) {
62361d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
62461d8658bSDupuis, Chad "Starting link down tmo.\n");
62561d8658bSDupuis, Chad atomic_set(&qedf->link_down_tmo_valid, 1);
62661d8658bSDupuis, Chad }
62761d8658bSDupuis, Chad qedf->vlan_id = 0;
62861d8658bSDupuis, Chad qedf_update_link_speed(qedf, link);
62961d8658bSDupuis, Chad queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
63061d8658bSDupuis, Chad qedf_link_down_tmo * HZ);
63161d8658bSDupuis, Chad }
63261d8658bSDupuis, Chad }
63361d8658bSDupuis, Chad
63461d8658bSDupuis, Chad
qedf_dcbx_handler(void * dev,struct qed_dcbx_get * get,u32 mib_type)63561d8658bSDupuis, Chad static void qedf_dcbx_handler(void *dev, struct qed_dcbx_get *get, u32 mib_type)
63661d8658bSDupuis, Chad {
63761d8658bSDupuis, Chad struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
63884b2ba6eSChad Dupuis u8 tmp_prio;
63961d8658bSDupuis, Chad
64061d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "DCBx event valid=%d enabled=%d fcoe "
64161d8658bSDupuis, Chad "prio=%d.\n", get->operational.valid, get->operational.enabled,
64261d8658bSDupuis, Chad get->operational.app_prio.fcoe);
64361d8658bSDupuis, Chad
64461d8658bSDupuis, Chad if (get->operational.enabled && get->operational.valid) {
64561d8658bSDupuis, Chad /* If DCBX was already negotiated on link up then just exit */
64661d8658bSDupuis, Chad if (atomic_read(&qedf->dcbx) == QEDF_DCBX_DONE) {
64761d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
64861d8658bSDupuis, Chad "DCBX already set on link up.\n");
64961d8658bSDupuis, Chad return;
65061d8658bSDupuis, Chad }
65161d8658bSDupuis, Chad
65261d8658bSDupuis, Chad atomic_set(&qedf->dcbx, QEDF_DCBX_DONE);
65361d8658bSDupuis, Chad
65484b2ba6eSChad Dupuis /*
65584b2ba6eSChad Dupuis * Set the 8021q priority in the following manner:
65684b2ba6eSChad Dupuis *
65784b2ba6eSChad Dupuis * 1. If a modparam is set use that
65884b2ba6eSChad Dupuis * 2. If the value is not between 0..7 use the default
65984b2ba6eSChad Dupuis * 3. Use the priority we get from the DCBX app tag
66084b2ba6eSChad Dupuis */
66184b2ba6eSChad Dupuis tmp_prio = get->operational.app_prio.fcoe;
66284b2ba6eSChad Dupuis if (qedf_default_prio > -1)
66384b2ba6eSChad Dupuis qedf->prio = qedf_default_prio;
6644b062e7cSAustin Kim else if (tmp_prio > 7) {
66584b2ba6eSChad Dupuis QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
66684b2ba6eSChad Dupuis "FIP/FCoE prio %d out of range, setting to %d.\n",
66784b2ba6eSChad Dupuis tmp_prio, QEDF_DEFAULT_PRIO);
66884b2ba6eSChad Dupuis qedf->prio = QEDF_DEFAULT_PRIO;
66984b2ba6eSChad Dupuis } else
67084b2ba6eSChad Dupuis qedf->prio = tmp_prio;
67184b2ba6eSChad Dupuis
672ba17d379SChad Dupuis if (atomic_read(&qedf->link_state) == QEDF_LINK_UP &&
673ba17d379SChad Dupuis !qedf_dcbx_no_wait) {
67461d8658bSDupuis, Chad if (atomic_read(&qedf->link_down_tmo_valid) > 0)
67561d8658bSDupuis, Chad queue_delayed_work(qedf->link_update_wq,
67661d8658bSDupuis, Chad &qedf->link_recovery, 0);
67761d8658bSDupuis, Chad else
67861d8658bSDupuis, Chad queue_delayed_work(qedf->link_update_wq,
67961d8658bSDupuis, Chad &qedf->link_update, 0);
68061d8658bSDupuis, Chad atomic_set(&qedf->link_down_tmo_valid, 0);
68161d8658bSDupuis, Chad }
68261d8658bSDupuis, Chad }
68361d8658bSDupuis, Chad
68461d8658bSDupuis, Chad }
68561d8658bSDupuis, Chad
qedf_get_login_failures(void * cookie)68661d8658bSDupuis, Chad static u32 qedf_get_login_failures(void *cookie)
68761d8658bSDupuis, Chad {
68861d8658bSDupuis, Chad struct qedf_ctx *qedf;
68961d8658bSDupuis, Chad
69061d8658bSDupuis, Chad qedf = (struct qedf_ctx *)cookie;
69161d8658bSDupuis, Chad return qedf->flogi_failed;
69261d8658bSDupuis, Chad }
69361d8658bSDupuis, Chad
69461d8658bSDupuis, Chad static struct qed_fcoe_cb_ops qedf_cb_ops = {
69561d8658bSDupuis, Chad {
69661d8658bSDupuis, Chad .link_update = qedf_link_update,
6976e7c8eeaSSaurav Kashyap .bw_update = qedf_bw_update,
698f6b172f2SChad Dupuis .schedule_recovery_handler = qedf_schedule_recovery_handler,
69961d8658bSDupuis, Chad .dcbx_aen = qedf_dcbx_handler,
7008673daf4SChad Dupuis .get_generic_tlv_data = qedf_get_generic_tlv_data,
701642a0b37SChad Dupuis .get_protocol_tlv_data = qedf_get_protocol_tlv_data,
70255e04991SSaurav Kashyap .schedule_hw_err_handler = qedf_schedule_hw_err_handler,
70361d8658bSDupuis, Chad }
70461d8658bSDupuis, Chad };
70561d8658bSDupuis, Chad
70661d8658bSDupuis, Chad /*
70761d8658bSDupuis, Chad * Various transport templates.
70861d8658bSDupuis, Chad */
70961d8658bSDupuis, Chad
71061d8658bSDupuis, Chad static struct scsi_transport_template *qedf_fc_transport_template;
71161d8658bSDupuis, Chad static struct scsi_transport_template *qedf_fc_vport_transport_template;
71261d8658bSDupuis, Chad
71361d8658bSDupuis, Chad /*
71461d8658bSDupuis, Chad * SCSI EH handlers
71561d8658bSDupuis, Chad */
qedf_eh_abort(struct scsi_cmnd * sc_cmd)71661d8658bSDupuis, Chad static int qedf_eh_abort(struct scsi_cmnd *sc_cmd)
71761d8658bSDupuis, Chad {
71861d8658bSDupuis, Chad struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
71961d8658bSDupuis, Chad struct fc_lport *lport;
72061d8658bSDupuis, Chad struct qedf_ctx *qedf;
72161d8658bSDupuis, Chad struct qedf_ioreq *io_req;
72269ef2c69SSaurav Kashyap struct fc_rport_libfc_priv *rp = rport->dd_data;
72369ef2c69SSaurav Kashyap struct fc_rport_priv *rdata;
72469ef2c69SSaurav Kashyap struct qedf_rport *fcport = NULL;
72561d8658bSDupuis, Chad int rc = FAILED;
72669ef2c69SSaurav Kashyap int wait_count = 100;
72769ef2c69SSaurav Kashyap int refcount = 0;
72861d8658bSDupuis, Chad int rval;
72969ef2c69SSaurav Kashyap int got_ref = 0;
73061d8658bSDupuis, Chad
73161d8658bSDupuis, Chad lport = shost_priv(sc_cmd->device->host);
73261d8658bSDupuis, Chad qedf = (struct qedf_ctx *)lport_priv(lport);
73361d8658bSDupuis, Chad
73469ef2c69SSaurav Kashyap /* rport and tgt are allocated together, so tgt should be non-NULL */
73569ef2c69SSaurav Kashyap fcport = (struct qedf_rport *)&rp[1];
73669ef2c69SSaurav Kashyap rdata = fcport->rdata;
73769ef2c69SSaurav Kashyap if (!rdata || !kref_get_unless_zero(&rdata->kref)) {
73869ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "stale rport, sc_cmd=%p\n", sc_cmd);
73910aff62fSSaurav Kashyap rc = SUCCESS;
74061d8658bSDupuis, Chad goto out;
74161d8658bSDupuis, Chad }
74261d8658bSDupuis, Chad
74361d8658bSDupuis, Chad
744a33e7925SBart Van Assche io_req = qedf_priv(sc_cmd)->io_req;
74561d8658bSDupuis, Chad if (!io_req) {
74669ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
74769ef2c69SSaurav Kashyap "sc_cmd not queued with lld, sc_cmd=%p op=0x%02x, port_id=%06x\n",
74869ef2c69SSaurav Kashyap sc_cmd, sc_cmd->cmnd[0],
74969ef2c69SSaurav Kashyap rdata->ids.port_id);
75061d8658bSDupuis, Chad rc = SUCCESS;
75169ef2c69SSaurav Kashyap goto drop_rdata_kref;
75261d8658bSDupuis, Chad }
75361d8658bSDupuis, Chad
75469ef2c69SSaurav Kashyap rval = kref_get_unless_zero(&io_req->refcount); /* ID: 005 */
75569ef2c69SSaurav Kashyap if (rval)
75669ef2c69SSaurav Kashyap got_ref = 1;
75769ef2c69SSaurav Kashyap
75869ef2c69SSaurav Kashyap /* If we got a valid io_req, confirm it belongs to this sc_cmd. */
75969ef2c69SSaurav Kashyap if (!rval || io_req->sc_cmd != sc_cmd) {
76069ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
76169ef2c69SSaurav Kashyap "Freed/Incorrect io_req, io_req->sc_cmd=%p, sc_cmd=%p, port_id=%06x, bailing out.\n",
76269ef2c69SSaurav Kashyap io_req->sc_cmd, sc_cmd, rdata->ids.port_id);
76369ef2c69SSaurav Kashyap
76469ef2c69SSaurav Kashyap goto drop_rdata_kref;
76569ef2c69SSaurav Kashyap }
76669ef2c69SSaurav Kashyap
76769ef2c69SSaurav Kashyap if (fc_remote_port_chkready(rport)) {
76869ef2c69SSaurav Kashyap refcount = kref_read(&io_req->refcount);
76969ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
77069ef2c69SSaurav Kashyap "rport not ready, io_req=%p, xid=0x%x sc_cmd=%p op=0x%02x, refcount=%d, port_id=%06x\n",
77169ef2c69SSaurav Kashyap io_req, io_req->xid, sc_cmd, sc_cmd->cmnd[0],
77269ef2c69SSaurav Kashyap refcount, rdata->ids.port_id);
77369ef2c69SSaurav Kashyap
77469ef2c69SSaurav Kashyap goto drop_rdata_kref;
77569ef2c69SSaurav Kashyap }
77669ef2c69SSaurav Kashyap
77769ef2c69SSaurav Kashyap rc = fc_block_scsi_eh(sc_cmd);
77869ef2c69SSaurav Kashyap if (rc)
77969ef2c69SSaurav Kashyap goto drop_rdata_kref;
78069ef2c69SSaurav Kashyap
78169ef2c69SSaurav Kashyap if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
78269ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
78369ef2c69SSaurav Kashyap "Connection uploading, xid=0x%x., port_id=%06x\n",
78469ef2c69SSaurav Kashyap io_req->xid, rdata->ids.port_id);
78569ef2c69SSaurav Kashyap while (io_req->sc_cmd && (wait_count != 0)) {
78669ef2c69SSaurav Kashyap msleep(100);
78769ef2c69SSaurav Kashyap wait_count--;
78869ef2c69SSaurav Kashyap }
78969ef2c69SSaurav Kashyap if (wait_count) {
79069ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "ABTS succeeded\n");
79169ef2c69SSaurav Kashyap rc = SUCCESS;
79269ef2c69SSaurav Kashyap } else {
79369ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "ABTS failed\n");
79469ef2c69SSaurav Kashyap rc = FAILED;
79569ef2c69SSaurav Kashyap }
79669ef2c69SSaurav Kashyap goto drop_rdata_kref;
79769ef2c69SSaurav Kashyap }
79869ef2c69SSaurav Kashyap
79969ef2c69SSaurav Kashyap if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
80069ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "link not ready.\n");
80169ef2c69SSaurav Kashyap goto drop_rdata_kref;
80269ef2c69SSaurav Kashyap }
80369ef2c69SSaurav Kashyap
80469ef2c69SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
80569ef2c69SSaurav Kashyap "Aborting io_req=%p sc_cmd=%p xid=0x%x fp_idx=%d, port_id=%06x.\n",
80669ef2c69SSaurav Kashyap io_req, sc_cmd, io_req->xid, io_req->fp_idx,
80769ef2c69SSaurav Kashyap rdata->ids.port_id);
80861d8658bSDupuis, Chad
80961d8658bSDupuis, Chad if (qedf->stop_io_on_error) {
81061d8658bSDupuis, Chad qedf_stop_all_io(qedf);
81161d8658bSDupuis, Chad rc = SUCCESS;
81269ef2c69SSaurav Kashyap goto drop_rdata_kref;
81361d8658bSDupuis, Chad }
81461d8658bSDupuis, Chad
81561d8658bSDupuis, Chad init_completion(&io_req->abts_done);
81661d8658bSDupuis, Chad rval = qedf_initiate_abts(io_req, true);
81761d8658bSDupuis, Chad if (rval) {
81861d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Failed to queue ABTS.\n");
81969ef2c69SSaurav Kashyap /*
82069ef2c69SSaurav Kashyap * If we fail to queue the ABTS then return this command to
82169ef2c69SSaurav Kashyap * the SCSI layer as it will own and free the xid
82269ef2c69SSaurav Kashyap */
82369ef2c69SSaurav Kashyap rc = SUCCESS;
82469ef2c69SSaurav Kashyap qedf_scsi_done(qedf, io_req, DID_ERROR);
82569ef2c69SSaurav Kashyap goto drop_rdata_kref;
82661d8658bSDupuis, Chad }
82761d8658bSDupuis, Chad
82861d8658bSDupuis, Chad wait_for_completion(&io_req->abts_done);
82961d8658bSDupuis, Chad
83061d8658bSDupuis, Chad if (io_req->event == QEDF_IOREQ_EV_ABORT_SUCCESS ||
83161d8658bSDupuis, Chad io_req->event == QEDF_IOREQ_EV_ABORT_FAILED ||
83261d8658bSDupuis, Chad io_req->event == QEDF_IOREQ_EV_CLEANUP_SUCCESS) {
83361d8658bSDupuis, Chad /*
83461d8658bSDupuis, Chad * If we get a reponse to the abort this is success from
83561d8658bSDupuis, Chad * the perspective that all references to the command have
83661d8658bSDupuis, Chad * been removed from the driver and firmware
83761d8658bSDupuis, Chad */
83861d8658bSDupuis, Chad rc = SUCCESS;
83961d8658bSDupuis, Chad } else {
84061d8658bSDupuis, Chad /* If the abort and cleanup failed then return a failure */
84161d8658bSDupuis, Chad rc = FAILED;
84261d8658bSDupuis, Chad }
84361d8658bSDupuis, Chad
84461d8658bSDupuis, Chad if (rc == SUCCESS)
84561d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "ABTS succeeded, xid=0x%x.\n",
84661d8658bSDupuis, Chad io_req->xid);
84761d8658bSDupuis, Chad else
84861d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "ABTS failed, xid=0x%x.\n",
84961d8658bSDupuis, Chad io_req->xid);
85061d8658bSDupuis, Chad
85169ef2c69SSaurav Kashyap drop_rdata_kref:
85269ef2c69SSaurav Kashyap kref_put(&rdata->kref, fc_rport_destroy);
85361d8658bSDupuis, Chad out:
85469ef2c69SSaurav Kashyap if (got_ref)
85569ef2c69SSaurav Kashyap kref_put(&io_req->refcount, qedf_release_cmd);
85661d8658bSDupuis, Chad return rc;
85761d8658bSDupuis, Chad }
85861d8658bSDupuis, Chad
qedf_eh_target_reset(struct scsi_cmnd * sc_cmd)85961d8658bSDupuis, Chad static int qedf_eh_target_reset(struct scsi_cmnd *sc_cmd)
86061d8658bSDupuis, Chad {
86169ef2c69SSaurav Kashyap QEDF_ERR(NULL, "%d:0:%d:%lld: TARGET RESET Issued...",
86269ef2c69SSaurav Kashyap sc_cmd->device->host->host_no, sc_cmd->device->id,
86369ef2c69SSaurav Kashyap sc_cmd->device->lun);
86461d8658bSDupuis, Chad return qedf_initiate_tmf(sc_cmd, FCP_TMF_TGT_RESET);
86561d8658bSDupuis, Chad }
86661d8658bSDupuis, Chad
qedf_eh_device_reset(struct scsi_cmnd * sc_cmd)86761d8658bSDupuis, Chad static int qedf_eh_device_reset(struct scsi_cmnd *sc_cmd)
86861d8658bSDupuis, Chad {
86969ef2c69SSaurav Kashyap QEDF_ERR(NULL, "%d:0:%d:%lld: LUN RESET Issued... ",
87069ef2c69SSaurav Kashyap sc_cmd->device->host->host_no, sc_cmd->device->id,
87169ef2c69SSaurav Kashyap sc_cmd->device->lun);
87261d8658bSDupuis, Chad return qedf_initiate_tmf(sc_cmd, FCP_TMF_LUN_RESET);
87361d8658bSDupuis, Chad }
87461d8658bSDupuis, Chad
qedf_wait_for_upload(struct qedf_ctx * qedf)875a66c6cd2SChad Dupuis bool qedf_wait_for_upload(struct qedf_ctx *qedf)
87661d8658bSDupuis, Chad {
877505420bdSXiaomeng Tong struct qedf_rport *fcport;
8787fa4142dSSaurav Kashyap int wait_cnt = 120;
879a66c6cd2SChad Dupuis
8807fa4142dSSaurav Kashyap while (wait_cnt--) {
88161d8658bSDupuis, Chad if (atomic_read(&qedf->num_offloads))
8827fa4142dSSaurav Kashyap QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
8837fa4142dSSaurav Kashyap "Waiting for all uploads to complete num_offloads = 0x%x.\n",
8847fa4142dSSaurav Kashyap atomic_read(&qedf->num_offloads));
88561d8658bSDupuis, Chad else
886a66c6cd2SChad Dupuis return true;
88761d8658bSDupuis, Chad msleep(500);
88861d8658bSDupuis, Chad }
889a66c6cd2SChad Dupuis
890a66c6cd2SChad Dupuis rcu_read_lock();
891a66c6cd2SChad Dupuis list_for_each_entry_rcu(fcport, &qedf->fcports, peers) {
892505420bdSXiaomeng Tong if (test_bit(QEDF_RPORT_SESSION_READY,
893a66c6cd2SChad Dupuis &fcport->flags)) {
894a66c6cd2SChad Dupuis if (fcport->rdata)
895a66c6cd2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx,
896a66c6cd2SChad Dupuis "Waiting for fcport %p portid=%06x.\n",
897a66c6cd2SChad Dupuis fcport, fcport->rdata->ids.port_id);
898a66c6cd2SChad Dupuis } else {
899a66c6cd2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx,
900a66c6cd2SChad Dupuis "Waiting for fcport %p.\n", fcport);
901a66c6cd2SChad Dupuis }
902a66c6cd2SChad Dupuis }
903505420bdSXiaomeng Tong
904a66c6cd2SChad Dupuis rcu_read_unlock();
905a66c6cd2SChad Dupuis return false;
90661d8658bSDupuis, Chad }
90761d8658bSDupuis, Chad
9085cf446d2SChad Dupuis /* Performs soft reset of qedf_ctx by simulating a link down/up */
qedf_ctx_soft_reset(struct fc_lport * lport)909a66c6cd2SChad Dupuis void qedf_ctx_soft_reset(struct fc_lport *lport)
91061d8658bSDupuis, Chad {
91161d8658bSDupuis, Chad struct qedf_ctx *qedf;
912a66c6cd2SChad Dupuis struct qed_link_output if_link;
91361d8658bSDupuis, Chad
91461d8658bSDupuis, Chad if (lport->vport) {
91564fd4af6SSaurav Kashyap printk_ratelimited("Cannot issue host reset on NPIV port.\n");
9165cf446d2SChad Dupuis return;
91761d8658bSDupuis, Chad }
91861d8658bSDupuis, Chad
9195cf446d2SChad Dupuis qedf = lport_priv(lport);
92061d8658bSDupuis, Chad
921ab0a8299SSaurav Kashyap qedf->flogi_pending = 0;
92261d8658bSDupuis, Chad /* For host reset, essentially do a soft link up/down */
92361d8658bSDupuis, Chad atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
924a66c6cd2SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
925a66c6cd2SChad Dupuis "Queuing link down work.\n");
92661d8658bSDupuis, Chad queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
92761d8658bSDupuis, Chad 0);
928a66c6cd2SChad Dupuis
929a66c6cd2SChad Dupuis if (qedf_wait_for_upload(qedf) == false) {
930a66c6cd2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx, "Could not upload all sessions.\n");
931a66c6cd2SChad Dupuis WARN_ON(atomic_read(&qedf->num_offloads));
932a66c6cd2SChad Dupuis }
933a66c6cd2SChad Dupuis
934a66c6cd2SChad Dupuis /* Before setting link up query physical link state */
935a66c6cd2SChad Dupuis qed_ops->common->get_link(qedf->cdev, &if_link);
936a66c6cd2SChad Dupuis /* Bail if the physical link is not up */
937a66c6cd2SChad Dupuis if (!if_link.link_up) {
938a66c6cd2SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
939a66c6cd2SChad Dupuis "Physical link is not up.\n");
940a66c6cd2SChad Dupuis return;
941a66c6cd2SChad Dupuis }
942a66c6cd2SChad Dupuis /* Flush and wait to make sure link down is processed */
943a66c6cd2SChad Dupuis flush_delayed_work(&qedf->link_update);
944a66c6cd2SChad Dupuis msleep(500);
945a66c6cd2SChad Dupuis
94661d8658bSDupuis, Chad atomic_set(&qedf->link_state, QEDF_LINK_UP);
94761d8658bSDupuis, Chad qedf->vlan_id = 0;
948a66c6cd2SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
949a66c6cd2SChad Dupuis "Queue link up work.\n");
95061d8658bSDupuis, Chad queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
95161d8658bSDupuis, Chad 0);
9525cf446d2SChad Dupuis }
9535cf446d2SChad Dupuis
9545cf446d2SChad Dupuis /* Reset the host by gracefully logging out and then logging back in */
qedf_eh_host_reset(struct scsi_cmnd * sc_cmd)9555cf446d2SChad Dupuis static int qedf_eh_host_reset(struct scsi_cmnd *sc_cmd)
9565cf446d2SChad Dupuis {
9575cf446d2SChad Dupuis struct fc_lport *lport;
9585cf446d2SChad Dupuis struct qedf_ctx *qedf;
9595cf446d2SChad Dupuis
9605cf446d2SChad Dupuis lport = shost_priv(sc_cmd->device->host);
9615cf446d2SChad Dupuis qedf = lport_priv(lport);
9625cf446d2SChad Dupuis
9635cf446d2SChad Dupuis if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN ||
9645cf446d2SChad Dupuis test_bit(QEDF_UNLOADING, &qedf->flags))
9655cf446d2SChad Dupuis return FAILED;
9665cf446d2SChad Dupuis
9675cf446d2SChad Dupuis QEDF_ERR(&(qedf->dbg_ctx), "HOST RESET Issued...");
9685cf446d2SChad Dupuis
9695cf446d2SChad Dupuis qedf_ctx_soft_reset(lport);
97061d8658bSDupuis, Chad
97161d8658bSDupuis, Chad return SUCCESS;
97261d8658bSDupuis, Chad }
97361d8658bSDupuis, Chad
qedf_slave_configure(struct scsi_device * sdev)97461d8658bSDupuis, Chad static int qedf_slave_configure(struct scsi_device *sdev)
97561d8658bSDupuis, Chad {
97661d8658bSDupuis, Chad if (qedf_queue_depth) {
97761d8658bSDupuis, Chad scsi_change_queue_depth(sdev, qedf_queue_depth);
97861d8658bSDupuis, Chad }
97961d8658bSDupuis, Chad
98061d8658bSDupuis, Chad return 0;
98161d8658bSDupuis, Chad }
98261d8658bSDupuis, Chad
983be8532d1SBart Van Assche static const struct scsi_host_template qedf_host_template = {
98461d8658bSDupuis, Chad .module = THIS_MODULE,
98561d8658bSDupuis, Chad .name = QEDF_MODULE_NAME,
98661d8658bSDupuis, Chad .this_id = -1,
987a7746f1eSChad Dupuis .cmd_per_lun = 32,
98861d8658bSDupuis, Chad .max_sectors = 0xffff,
98961d8658bSDupuis, Chad .queuecommand = qedf_queuecommand,
990232cb469SBart Van Assche .shost_groups = qedf_host_groups,
99161d8658bSDupuis, Chad .eh_abort_handler = qedf_eh_abort,
99261d8658bSDupuis, Chad .eh_device_reset_handler = qedf_eh_device_reset, /* lun reset */
99361d8658bSDupuis, Chad .eh_target_reset_handler = qedf_eh_target_reset, /* target reset */
99461d8658bSDupuis, Chad .eh_host_reset_handler = qedf_eh_host_reset,
99561d8658bSDupuis, Chad .slave_configure = qedf_slave_configure,
99661d8658bSDupuis, Chad .dma_boundary = QED_HW_DMA_BOUNDARY,
99761d8658bSDupuis, Chad .sg_tablesize = QEDF_MAX_BDS_PER_CMD,
99861d8658bSDupuis, Chad .can_queue = FCOE_PARAMS_NUM_TASKS,
9996088cfaaSChad Dupuis .change_queue_depth = scsi_change_queue_depth,
1000a33e7925SBart Van Assche .cmd_size = sizeof(struct qedf_cmd_priv),
100161d8658bSDupuis, Chad };
100261d8658bSDupuis, Chad
qedf_get_paged_crc_eof(struct sk_buff * skb,int tlen)100361d8658bSDupuis, Chad static int qedf_get_paged_crc_eof(struct sk_buff *skb, int tlen)
100461d8658bSDupuis, Chad {
100561d8658bSDupuis, Chad int rc;
100661d8658bSDupuis, Chad
100761d8658bSDupuis, Chad spin_lock(&qedf_global_lock);
100861d8658bSDupuis, Chad rc = fcoe_get_paged_crc_eof(skb, tlen, &qedf_global);
100961d8658bSDupuis, Chad spin_unlock(&qedf_global_lock);
101061d8658bSDupuis, Chad
101161d8658bSDupuis, Chad return rc;
101261d8658bSDupuis, Chad }
101361d8658bSDupuis, Chad
qedf_fcport_lookup(struct qedf_ctx * qedf,u32 port_id)101461d8658bSDupuis, Chad static struct qedf_rport *qedf_fcport_lookup(struct qedf_ctx *qedf, u32 port_id)
101561d8658bSDupuis, Chad {
101661d8658bSDupuis, Chad struct qedf_rport *fcport;
101761d8658bSDupuis, Chad struct fc_rport_priv *rdata;
101861d8658bSDupuis, Chad
101961d8658bSDupuis, Chad rcu_read_lock();
102061d8658bSDupuis, Chad list_for_each_entry_rcu(fcport, &qedf->fcports, peers) {
102161d8658bSDupuis, Chad rdata = fcport->rdata;
102261d8658bSDupuis, Chad if (rdata == NULL)
102361d8658bSDupuis, Chad continue;
102461d8658bSDupuis, Chad if (rdata->ids.port_id == port_id) {
102561d8658bSDupuis, Chad rcu_read_unlock();
102661d8658bSDupuis, Chad return fcport;
102761d8658bSDupuis, Chad }
102861d8658bSDupuis, Chad }
102961d8658bSDupuis, Chad rcu_read_unlock();
103061d8658bSDupuis, Chad
103161d8658bSDupuis, Chad /* Return NULL to caller to let them know fcport was not found */
103261d8658bSDupuis, Chad return NULL;
103361d8658bSDupuis, Chad }
103461d8658bSDupuis, Chad
103561d8658bSDupuis, Chad /* Transmits an ELS frame over an offloaded session */
qedf_xmit_l2_frame(struct qedf_rport * fcport,struct fc_frame * fp)103661d8658bSDupuis, Chad static int qedf_xmit_l2_frame(struct qedf_rport *fcport, struct fc_frame *fp)
103761d8658bSDupuis, Chad {
103861d8658bSDupuis, Chad struct fc_frame_header *fh;
103961d8658bSDupuis, Chad int rc = 0;
104061d8658bSDupuis, Chad
104161d8658bSDupuis, Chad fh = fc_frame_header_get(fp);
104261d8658bSDupuis, Chad if ((fh->fh_type == FC_TYPE_ELS) &&
104361d8658bSDupuis, Chad (fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
104461d8658bSDupuis, Chad switch (fc_frame_payload_op(fp)) {
104561d8658bSDupuis, Chad case ELS_ADISC:
104661d8658bSDupuis, Chad qedf_send_adisc(fcport, fp);
104761d8658bSDupuis, Chad rc = 1;
104861d8658bSDupuis, Chad break;
104961d8658bSDupuis, Chad }
105061d8658bSDupuis, Chad }
105161d8658bSDupuis, Chad
105261d8658bSDupuis, Chad return rc;
105361d8658bSDupuis, Chad }
105461d8658bSDupuis, Chad
1055a9d4aeceSLee Jones /*
105661d8658bSDupuis, Chad * qedf_xmit - qedf FCoE frame transmit function
105761d8658bSDupuis, Chad */
qedf_xmit(struct fc_lport * lport,struct fc_frame * fp)105861d8658bSDupuis, Chad static int qedf_xmit(struct fc_lport *lport, struct fc_frame *fp)
105961d8658bSDupuis, Chad {
106061d8658bSDupuis, Chad struct fc_lport *base_lport;
106161d8658bSDupuis, Chad struct qedf_ctx *qedf;
106261d8658bSDupuis, Chad struct ethhdr *eh;
106361d8658bSDupuis, Chad struct fcoe_crc_eof *cp;
106461d8658bSDupuis, Chad struct sk_buff *skb;
106561d8658bSDupuis, Chad struct fc_frame_header *fh;
106661d8658bSDupuis, Chad struct fcoe_hdr *hp;
106761d8658bSDupuis, Chad u8 sof, eof;
106861d8658bSDupuis, Chad u32 crc;
106961d8658bSDupuis, Chad unsigned int hlen, tlen, elen;
107061d8658bSDupuis, Chad int wlen;
107161d8658bSDupuis, Chad struct fc_lport *tmp_lport;
107261d8658bSDupuis, Chad struct fc_lport *vn_port = NULL;
107361d8658bSDupuis, Chad struct qedf_rport *fcport;
107461d8658bSDupuis, Chad int rc;
107561d8658bSDupuis, Chad u16 vlan_tci = 0;
107661d8658bSDupuis, Chad
107761d8658bSDupuis, Chad qedf = (struct qedf_ctx *)lport_priv(lport);
107861d8658bSDupuis, Chad
107961d8658bSDupuis, Chad fh = fc_frame_header_get(fp);
108061d8658bSDupuis, Chad skb = fp_skb(fp);
108161d8658bSDupuis, Chad
108261d8658bSDupuis, Chad /* Filter out traffic to other NPIV ports on the same host */
108361d8658bSDupuis, Chad if (lport->vport)
108461d8658bSDupuis, Chad base_lport = shost_priv(vport_to_shost(lport->vport));
108561d8658bSDupuis, Chad else
108661d8658bSDupuis, Chad base_lport = lport;
108761d8658bSDupuis, Chad
108861d8658bSDupuis, Chad /* Flag if the destination is the base port */
108961d8658bSDupuis, Chad if (base_lport->port_id == ntoh24(fh->fh_d_id)) {
109061d8658bSDupuis, Chad vn_port = base_lport;
109161d8658bSDupuis, Chad } else {
109261d8658bSDupuis, Chad /* Got through the list of vports attached to the base_lport
109361d8658bSDupuis, Chad * and see if we have a match with the destination address.
109461d8658bSDupuis, Chad */
109561d8658bSDupuis, Chad list_for_each_entry(tmp_lport, &base_lport->vports, list) {
109661d8658bSDupuis, Chad if (tmp_lport->port_id == ntoh24(fh->fh_d_id)) {
109761d8658bSDupuis, Chad vn_port = tmp_lport;
109861d8658bSDupuis, Chad break;
109961d8658bSDupuis, Chad }
110061d8658bSDupuis, Chad }
110161d8658bSDupuis, Chad }
110261d8658bSDupuis, Chad if (vn_port && ntoh24(fh->fh_d_id) != FC_FID_FLOGI) {
110361d8658bSDupuis, Chad struct fc_rport_priv *rdata = NULL;
110461d8658bSDupuis, Chad
110561d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
110661d8658bSDupuis, Chad "Dropping FCoE frame to %06x.\n", ntoh24(fh->fh_d_id));
110761d8658bSDupuis, Chad kfree_skb(skb);
110861d8658bSDupuis, Chad rdata = fc_rport_lookup(lport, ntoh24(fh->fh_d_id));
11094262d35cSHannes Reinecke if (rdata) {
111061d8658bSDupuis, Chad rdata->retries = lport->max_rport_retry_count;
11114262d35cSHannes Reinecke kref_put(&rdata->kref, fc_rport_destroy);
11124262d35cSHannes Reinecke }
111361d8658bSDupuis, Chad return -EINVAL;
111461d8658bSDupuis, Chad }
111561d8658bSDupuis, Chad /* End NPIV filtering */
111661d8658bSDupuis, Chad
111761d8658bSDupuis, Chad if (!qedf->ctlr.sel_fcf) {
111861d8658bSDupuis, Chad kfree_skb(skb);
111961d8658bSDupuis, Chad return 0;
112061d8658bSDupuis, Chad }
112161d8658bSDupuis, Chad
112261d8658bSDupuis, Chad if (!test_bit(QEDF_LL2_STARTED, &qedf->flags)) {
112361d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "LL2 not started\n");
112461d8658bSDupuis, Chad kfree_skb(skb);
112561d8658bSDupuis, Chad return 0;
112661d8658bSDupuis, Chad }
112761d8658bSDupuis, Chad
112861d8658bSDupuis, Chad if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
112961d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "qedf link down\n");
113061d8658bSDupuis, Chad kfree_skb(skb);
113161d8658bSDupuis, Chad return 0;
113261d8658bSDupuis, Chad }
113361d8658bSDupuis, Chad
113461d8658bSDupuis, Chad if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
113561d8658bSDupuis, Chad if (fcoe_ctlr_els_send(&qedf->ctlr, lport, skb))
113661d8658bSDupuis, Chad return 0;
113761d8658bSDupuis, Chad }
113861d8658bSDupuis, Chad
113961d8658bSDupuis, Chad /* Check to see if this needs to be sent on an offloaded session */
114061d8658bSDupuis, Chad fcport = qedf_fcport_lookup(qedf, ntoh24(fh->fh_d_id));
114161d8658bSDupuis, Chad
114261d8658bSDupuis, Chad if (fcport && test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
114361d8658bSDupuis, Chad rc = qedf_xmit_l2_frame(fcport, fp);
114461d8658bSDupuis, Chad /*
114561d8658bSDupuis, Chad * If the frame was successfully sent over the middle path
114661d8658bSDupuis, Chad * then do not try to also send it over the LL2 path
114761d8658bSDupuis, Chad */
114861d8658bSDupuis, Chad if (rc)
114961d8658bSDupuis, Chad return 0;
115061d8658bSDupuis, Chad }
115161d8658bSDupuis, Chad
115261d8658bSDupuis, Chad sof = fr_sof(fp);
115361d8658bSDupuis, Chad eof = fr_eof(fp);
115461d8658bSDupuis, Chad
115561d8658bSDupuis, Chad elen = sizeof(struct ethhdr);
115661d8658bSDupuis, Chad hlen = sizeof(struct fcoe_hdr);
115761d8658bSDupuis, Chad tlen = sizeof(struct fcoe_crc_eof);
115861d8658bSDupuis, Chad wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
115961d8658bSDupuis, Chad
116061d8658bSDupuis, Chad skb->ip_summed = CHECKSUM_NONE;
116161d8658bSDupuis, Chad crc = fcoe_fc_crc(fp);
116261d8658bSDupuis, Chad
116361d8658bSDupuis, Chad /* copy port crc and eof to the skb buff */
116461d8658bSDupuis, Chad if (skb_is_nonlinear(skb)) {
116561d8658bSDupuis, Chad skb_frag_t *frag;
116661d8658bSDupuis, Chad
116761d8658bSDupuis, Chad if (qedf_get_paged_crc_eof(skb, tlen)) {
116861d8658bSDupuis, Chad kfree_skb(skb);
116961d8658bSDupuis, Chad return -ENOMEM;
117061d8658bSDupuis, Chad }
117161d8658bSDupuis, Chad frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
1172b54c9d5bSJonathan Lemon cp = kmap_atomic(skb_frag_page(frag)) + skb_frag_off(frag);
117361d8658bSDupuis, Chad } else {
11744df864c1SJohannes Berg cp = skb_put(skb, tlen);
117561d8658bSDupuis, Chad }
117661d8658bSDupuis, Chad
117761d8658bSDupuis, Chad memset(cp, 0, sizeof(*cp));
117861d8658bSDupuis, Chad cp->fcoe_eof = eof;
117961d8658bSDupuis, Chad cp->fcoe_crc32 = cpu_to_le32(~crc);
118061d8658bSDupuis, Chad if (skb_is_nonlinear(skb)) {
118161d8658bSDupuis, Chad kunmap_atomic(cp);
118261d8658bSDupuis, Chad cp = NULL;
118361d8658bSDupuis, Chad }
118461d8658bSDupuis, Chad
118561d8658bSDupuis, Chad
118661d8658bSDupuis, Chad /* adjust skb network/transport offsets to match mac/fcoe/port */
118761d8658bSDupuis, Chad skb_push(skb, elen + hlen);
118861d8658bSDupuis, Chad skb_reset_mac_header(skb);
118961d8658bSDupuis, Chad skb_reset_network_header(skb);
119061d8658bSDupuis, Chad skb->mac_len = elen;
119161d8658bSDupuis, Chad skb->protocol = htons(ETH_P_FCOE);
119261d8658bSDupuis, Chad
1193cf291163SChad Dupuis /*
1194cf291163SChad Dupuis * Add VLAN tag to non-offload FCoE frame based on current stored VLAN
1195cf291163SChad Dupuis * for FIP/FCoE traffic.
1196cf291163SChad Dupuis */
119761d8658bSDupuis, Chad __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), qedf->vlan_id);
119861d8658bSDupuis, Chad
119961d8658bSDupuis, Chad /* fill up mac and fcoe headers */
120061d8658bSDupuis, Chad eh = eth_hdr(skb);
120161d8658bSDupuis, Chad eh->h_proto = htons(ETH_P_FCOE);
120261d8658bSDupuis, Chad if (qedf->ctlr.map_dest)
120361d8658bSDupuis, Chad fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);
120461d8658bSDupuis, Chad else
120561d8658bSDupuis, Chad /* insert GW address */
120661d8658bSDupuis, Chad ether_addr_copy(eh->h_dest, qedf->ctlr.dest_addr);
120761d8658bSDupuis, Chad
120861d8658bSDupuis, Chad /* Set the source MAC address */
1209a3cd42a9SChad Dupuis ether_addr_copy(eh->h_source, qedf->data_src_addr);
121061d8658bSDupuis, Chad
121161d8658bSDupuis, Chad hp = (struct fcoe_hdr *)(eh + 1);
121261d8658bSDupuis, Chad memset(hp, 0, sizeof(*hp));
121361d8658bSDupuis, Chad if (FC_FCOE_VER)
121461d8658bSDupuis, Chad FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
121561d8658bSDupuis, Chad hp->fcoe_sof = sof;
121661d8658bSDupuis, Chad
121761d8658bSDupuis, Chad /*update tx stats */
1218a912460eSSebastian Andrzej Siewior this_cpu_inc(lport->stats->TxFrames);
1219a912460eSSebastian Andrzej Siewior this_cpu_add(lport->stats->TxWords, wlen);
122061d8658bSDupuis, Chad
122161d8658bSDupuis, Chad /* Get VLAN ID from skb for printing purposes */
122261d8658bSDupuis, Chad __vlan_hwaccel_get_tag(skb, &vlan_tci);
122361d8658bSDupuis, Chad
122461d8658bSDupuis, Chad /* send down to lld */
122561d8658bSDupuis, Chad fr_dev(fp) = lport;
122661d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FCoE frame send: "
122761d8658bSDupuis, Chad "src=%06x dest=%06x r_ctl=%x type=%x vlan=%04x.\n",
122861d8658bSDupuis, Chad ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id), fh->fh_r_ctl, fh->fh_type,
122961d8658bSDupuis, Chad vlan_tci);
123061d8658bSDupuis, Chad if (qedf_dump_frames)
123161d8658bSDupuis, Chad print_hex_dump(KERN_WARNING, "fcoe: ", DUMP_PREFIX_OFFSET, 16,
123261d8658bSDupuis, Chad 1, skb->data, skb->len, false);
123319c2b6d8SSaurav Kashyap rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, 0);
123419c2b6d8SSaurav Kashyap if (rc) {
123519c2b6d8SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
123619c2b6d8SSaurav Kashyap kfree_skb(skb);
123719c2b6d8SSaurav Kashyap return rc;
123819c2b6d8SSaurav Kashyap }
123961d8658bSDupuis, Chad
124061d8658bSDupuis, Chad return 0;
124161d8658bSDupuis, Chad }
124261d8658bSDupuis, Chad
qedf_alloc_sq(struct qedf_ctx * qedf,struct qedf_rport * fcport)124361d8658bSDupuis, Chad static int qedf_alloc_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
124461d8658bSDupuis, Chad {
124561d8658bSDupuis, Chad int rval = 0;
124661d8658bSDupuis, Chad u32 *pbl;
124761d8658bSDupuis, Chad dma_addr_t page;
124861d8658bSDupuis, Chad int num_pages;
124961d8658bSDupuis, Chad
125061d8658bSDupuis, Chad /* Calculate appropriate queue and PBL sizes */
125161d8658bSDupuis, Chad fcport->sq_mem_size = SQ_NUM_ENTRIES * sizeof(struct fcoe_wqe);
125261d8658bSDupuis, Chad fcport->sq_mem_size = ALIGN(fcport->sq_mem_size, QEDF_PAGE_SIZE);
125361d8658bSDupuis, Chad fcport->sq_pbl_size = (fcport->sq_mem_size / QEDF_PAGE_SIZE) *
125461d8658bSDupuis, Chad sizeof(void *);
125561d8658bSDupuis, Chad fcport->sq_pbl_size = fcport->sq_pbl_size + QEDF_PAGE_SIZE;
125661d8658bSDupuis, Chad
1257750afb08SLuis Chamberlain fcport->sq = dma_alloc_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
1258750afb08SLuis Chamberlain &fcport->sq_dma, GFP_KERNEL);
125961d8658bSDupuis, Chad if (!fcport->sq) {
126032eebb31SChristophe JAILLET QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue.\n");
126161d8658bSDupuis, Chad rval = 1;
126261d8658bSDupuis, Chad goto out;
126361d8658bSDupuis, Chad }
126461d8658bSDupuis, Chad
1265750afb08SLuis Chamberlain fcport->sq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
1266750afb08SLuis Chamberlain fcport->sq_pbl_size,
1267750afb08SLuis Chamberlain &fcport->sq_pbl_dma, GFP_KERNEL);
126861d8658bSDupuis, Chad if (!fcport->sq_pbl) {
126932eebb31SChristophe JAILLET QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue PBL.\n");
127061d8658bSDupuis, Chad rval = 1;
127161d8658bSDupuis, Chad goto out_free_sq;
127261d8658bSDupuis, Chad }
127361d8658bSDupuis, Chad
127461d8658bSDupuis, Chad /* Create PBL */
127561d8658bSDupuis, Chad num_pages = fcport->sq_mem_size / QEDF_PAGE_SIZE;
127661d8658bSDupuis, Chad page = fcport->sq_dma;
127761d8658bSDupuis, Chad pbl = (u32 *)fcport->sq_pbl;
127861d8658bSDupuis, Chad
127961d8658bSDupuis, Chad while (num_pages--) {
128061d8658bSDupuis, Chad *pbl = U64_LO(page);
128161d8658bSDupuis, Chad pbl++;
128261d8658bSDupuis, Chad *pbl = U64_HI(page);
128361d8658bSDupuis, Chad pbl++;
128461d8658bSDupuis, Chad page += QEDF_PAGE_SIZE;
128561d8658bSDupuis, Chad }
128661d8658bSDupuis, Chad
128761d8658bSDupuis, Chad return rval;
128861d8658bSDupuis, Chad
128961d8658bSDupuis, Chad out_free_sq:
129061d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, fcport->sq_mem_size, fcport->sq,
129161d8658bSDupuis, Chad fcport->sq_dma);
129261d8658bSDupuis, Chad out:
129361d8658bSDupuis, Chad return rval;
129461d8658bSDupuis, Chad }
129561d8658bSDupuis, Chad
qedf_free_sq(struct qedf_ctx * qedf,struct qedf_rport * fcport)129661d8658bSDupuis, Chad static void qedf_free_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
129761d8658bSDupuis, Chad {
129861d8658bSDupuis, Chad if (fcport->sq_pbl)
129961d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, fcport->sq_pbl_size,
130061d8658bSDupuis, Chad fcport->sq_pbl, fcport->sq_pbl_dma);
130161d8658bSDupuis, Chad if (fcport->sq)
130261d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
130361d8658bSDupuis, Chad fcport->sq, fcport->sq_dma);
130461d8658bSDupuis, Chad }
130561d8658bSDupuis, Chad
qedf_offload_connection(struct qedf_ctx * qedf,struct qedf_rport * fcport)130661d8658bSDupuis, Chad static int qedf_offload_connection(struct qedf_ctx *qedf,
130761d8658bSDupuis, Chad struct qedf_rport *fcport)
130861d8658bSDupuis, Chad {
130961d8658bSDupuis, Chad struct qed_fcoe_params_offload conn_info;
131061d8658bSDupuis, Chad u32 port_id;
131161d8658bSDupuis, Chad int rval;
131261d8658bSDupuis, Chad uint16_t total_sqe = (fcport->sq_mem_size / sizeof(struct fcoe_wqe));
131361d8658bSDupuis, Chad
131461d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Offloading connection "
131561d8658bSDupuis, Chad "portid=%06x.\n", fcport->rdata->ids.port_id);
131661d8658bSDupuis, Chad rval = qed_ops->acquire_conn(qedf->cdev, &fcport->handle,
131761d8658bSDupuis, Chad &fcport->fw_cid, &fcport->p_doorbell);
131861d8658bSDupuis, Chad if (rval) {
131961d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "Could not acquire connection "
132061d8658bSDupuis, Chad "for portid=%06x.\n", fcport->rdata->ids.port_id);
132161d8658bSDupuis, Chad rval = 1; /* For some reason qed returns 0 on failure here */
132261d8658bSDupuis, Chad goto out;
132361d8658bSDupuis, Chad }
132461d8658bSDupuis, Chad
132561d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "portid=%06x "
132661d8658bSDupuis, Chad "fw_cid=%08x handle=%d.\n", fcport->rdata->ids.port_id,
132761d8658bSDupuis, Chad fcport->fw_cid, fcport->handle);
132861d8658bSDupuis, Chad
132961d8658bSDupuis, Chad memset(&conn_info, 0, sizeof(struct qed_fcoe_params_offload));
133061d8658bSDupuis, Chad
133161d8658bSDupuis, Chad /* Fill in the offload connection info */
133261d8658bSDupuis, Chad conn_info.sq_pbl_addr = fcport->sq_pbl_dma;
133361d8658bSDupuis, Chad
133461d8658bSDupuis, Chad conn_info.sq_curr_page_addr = (dma_addr_t)(*(u64 *)fcport->sq_pbl);
133561d8658bSDupuis, Chad conn_info.sq_next_page_addr =
133661d8658bSDupuis, Chad (dma_addr_t)(*(u64 *)(fcport->sq_pbl + 8));
133761d8658bSDupuis, Chad
133861d8658bSDupuis, Chad /* Need to use our FCoE MAC for the offload session */
1339a3cd42a9SChad Dupuis ether_addr_copy(conn_info.src_mac, qedf->data_src_addr);
134061d8658bSDupuis, Chad
134161d8658bSDupuis, Chad ether_addr_copy(conn_info.dst_mac, qedf->ctlr.dest_addr);
134261d8658bSDupuis, Chad
134361d8658bSDupuis, Chad conn_info.tx_max_fc_pay_len = fcport->rdata->maxframe_size;
1344f78f8126SJaved Hasan conn_info.e_d_tov_timer_val = qedf->lport->e_d_tov;
134561d8658bSDupuis, Chad conn_info.rec_tov_timer_val = 3; /* I think this is what E3 was */
134661d8658bSDupuis, Chad conn_info.rx_max_fc_pay_len = fcport->rdata->maxframe_size;
134761d8658bSDupuis, Chad
134861d8658bSDupuis, Chad /* Set VLAN data */
134961d8658bSDupuis, Chad conn_info.vlan_tag = qedf->vlan_id <<
135061d8658bSDupuis, Chad FCOE_CONN_OFFLOAD_RAMROD_DATA_VLAN_ID_SHIFT;
135161d8658bSDupuis, Chad conn_info.vlan_tag |=
135284b2ba6eSChad Dupuis qedf->prio << FCOE_CONN_OFFLOAD_RAMROD_DATA_PRIORITY_SHIFT;
135361d8658bSDupuis, Chad conn_info.flags |= (FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_MASK <<
135461d8658bSDupuis, Chad FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_SHIFT);
135561d8658bSDupuis, Chad
135661d8658bSDupuis, Chad /* Set host port source id */
135761d8658bSDupuis, Chad port_id = fc_host_port_id(qedf->lport->host);
135861d8658bSDupuis, Chad fcport->sid = port_id;
135961d8658bSDupuis, Chad conn_info.s_id.addr_hi = (port_id & 0x000000FF);
136061d8658bSDupuis, Chad conn_info.s_id.addr_mid = (port_id & 0x0000FF00) >> 8;
136161d8658bSDupuis, Chad conn_info.s_id.addr_lo = (port_id & 0x00FF0000) >> 16;
136261d8658bSDupuis, Chad
136361d8658bSDupuis, Chad conn_info.max_conc_seqs_c3 = fcport->rdata->max_seq;
136461d8658bSDupuis, Chad
136561d8658bSDupuis, Chad /* Set remote port destination id */
136661d8658bSDupuis, Chad port_id = fcport->rdata->rport->port_id;
136761d8658bSDupuis, Chad conn_info.d_id.addr_hi = (port_id & 0x000000FF);
136861d8658bSDupuis, Chad conn_info.d_id.addr_mid = (port_id & 0x0000FF00) >> 8;
136961d8658bSDupuis, Chad conn_info.d_id.addr_lo = (port_id & 0x00FF0000) >> 16;
137061d8658bSDupuis, Chad
137161d8658bSDupuis, Chad conn_info.def_q_idx = 0; /* Default index for send queue? */
137261d8658bSDupuis, Chad
137361d8658bSDupuis, Chad /* Set FC-TAPE specific flags if needed */
137461d8658bSDupuis, Chad if (fcport->dev_type == QEDF_RPORT_TYPE_TAPE) {
137561d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN,
137661d8658bSDupuis, Chad "Enable CONF, REC for portid=%06x.\n",
137761d8658bSDupuis, Chad fcport->rdata->ids.port_id);
137861d8658bSDupuis, Chad conn_info.flags |= 1 <<
137961d8658bSDupuis, Chad FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONF_REQ_SHIFT;
138061d8658bSDupuis, Chad conn_info.flags |=
138161d8658bSDupuis, Chad ((fcport->rdata->sp_features & FC_SP_FT_SEQC) ? 1 : 0) <<
138261d8658bSDupuis, Chad FCOE_CONN_OFFLOAD_RAMROD_DATA_B_REC_VALID_SHIFT;
138361d8658bSDupuis, Chad }
138461d8658bSDupuis, Chad
138561d8658bSDupuis, Chad rval = qed_ops->offload_conn(qedf->cdev, fcport->handle, &conn_info);
138661d8658bSDupuis, Chad if (rval) {
138761d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "Could not offload connection "
138861d8658bSDupuis, Chad "for portid=%06x.\n", fcport->rdata->ids.port_id);
138961d8658bSDupuis, Chad goto out_free_conn;
139061d8658bSDupuis, Chad } else
139161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Offload "
139261d8658bSDupuis, Chad "succeeded portid=%06x total_sqe=%d.\n",
139361d8658bSDupuis, Chad fcport->rdata->ids.port_id, total_sqe);
139461d8658bSDupuis, Chad
139561d8658bSDupuis, Chad spin_lock_init(&fcport->rport_lock);
139661d8658bSDupuis, Chad atomic_set(&fcport->free_sqes, total_sqe);
139761d8658bSDupuis, Chad return 0;
139861d8658bSDupuis, Chad out_free_conn:
139961d8658bSDupuis, Chad qed_ops->release_conn(qedf->cdev, fcport->handle);
140061d8658bSDupuis, Chad out:
140161d8658bSDupuis, Chad return rval;
140261d8658bSDupuis, Chad }
140361d8658bSDupuis, Chad
140461d8658bSDupuis, Chad #define QEDF_TERM_BUFF_SIZE 10
qedf_upload_connection(struct qedf_ctx * qedf,struct qedf_rport * fcport)140561d8658bSDupuis, Chad static void qedf_upload_connection(struct qedf_ctx *qedf,
140661d8658bSDupuis, Chad struct qedf_rport *fcport)
140761d8658bSDupuis, Chad {
140861d8658bSDupuis, Chad void *term_params;
140961d8658bSDupuis, Chad dma_addr_t term_params_dma;
141061d8658bSDupuis, Chad
141161d8658bSDupuis, Chad /* Term params needs to be a DMA coherent buffer as qed shared the
141261d8658bSDupuis, Chad * physical DMA address with the firmware. The buffer may be used in
141361d8658bSDupuis, Chad * the receive path so we may eventually have to move this.
141461d8658bSDupuis, Chad */
141561d8658bSDupuis, Chad term_params = dma_alloc_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE,
141661d8658bSDupuis, Chad &term_params_dma, GFP_KERNEL);
1417aa7069d8SJiasheng Jiang if (!term_params)
1418aa7069d8SJiasheng Jiang return;
141961d8658bSDupuis, Chad
142061d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Uploading connection "
142161d8658bSDupuis, Chad "port_id=%06x.\n", fcport->rdata->ids.port_id);
142261d8658bSDupuis, Chad
142361d8658bSDupuis, Chad qed_ops->destroy_conn(qedf->cdev, fcport->handle, term_params_dma);
142461d8658bSDupuis, Chad qed_ops->release_conn(qedf->cdev, fcport->handle);
142561d8658bSDupuis, Chad
142661d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE, term_params,
142761d8658bSDupuis, Chad term_params_dma);
142861d8658bSDupuis, Chad }
142961d8658bSDupuis, Chad
qedf_cleanup_fcport(struct qedf_ctx * qedf,struct qedf_rport * fcport)143061d8658bSDupuis, Chad static void qedf_cleanup_fcport(struct qedf_ctx *qedf,
143161d8658bSDupuis, Chad struct qedf_rport *fcport)
143261d8658bSDupuis, Chad {
143356efc304SHannes Reinecke struct fc_rport_priv *rdata = fcport->rdata;
143456efc304SHannes Reinecke
143561d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Cleaning up portid=%06x.\n",
143661d8658bSDupuis, Chad fcport->rdata->ids.port_id);
143761d8658bSDupuis, Chad
143861d8658bSDupuis, Chad /* Flush any remaining i/o's before we upload the connection */
143961d8658bSDupuis, Chad qedf_flush_active_ios(fcport, -1);
144061d8658bSDupuis, Chad
144161d8658bSDupuis, Chad if (test_and_clear_bit(QEDF_RPORT_SESSION_READY, &fcport->flags))
144261d8658bSDupuis, Chad qedf_upload_connection(qedf, fcport);
144361d8658bSDupuis, Chad qedf_free_sq(qedf, fcport);
144461d8658bSDupuis, Chad fcport->rdata = NULL;
144561d8658bSDupuis, Chad fcport->qedf = NULL;
144656efc304SHannes Reinecke kref_put(&rdata->kref, fc_rport_destroy);
144761d8658bSDupuis, Chad }
144861d8658bSDupuis, Chad
1449a9d4aeceSLee Jones /*
145061d8658bSDupuis, Chad * This event_callback is called after successful completion of libfc
145161d8658bSDupuis, Chad * initiated target login. qedf can proceed with initiating the session
145261d8658bSDupuis, Chad * establishment.
145361d8658bSDupuis, Chad */
qedf_rport_event_handler(struct fc_lport * lport,struct fc_rport_priv * rdata,enum fc_rport_event event)145461d8658bSDupuis, Chad static void qedf_rport_event_handler(struct fc_lport *lport,
145561d8658bSDupuis, Chad struct fc_rport_priv *rdata,
145661d8658bSDupuis, Chad enum fc_rport_event event)
145761d8658bSDupuis, Chad {
145861d8658bSDupuis, Chad struct qedf_ctx *qedf = lport_priv(lport);
145961d8658bSDupuis, Chad struct fc_rport *rport = rdata->rport;
146061d8658bSDupuis, Chad struct fc_rport_libfc_priv *rp;
146161d8658bSDupuis, Chad struct qedf_rport *fcport;
146261d8658bSDupuis, Chad u32 port_id;
146361d8658bSDupuis, Chad int rval;
146461d8658bSDupuis, Chad unsigned long flags;
146561d8658bSDupuis, Chad
146661d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "event = %d, "
146761d8658bSDupuis, Chad "port_id = 0x%x\n", event, rdata->ids.port_id);
146861d8658bSDupuis, Chad
146961d8658bSDupuis, Chad switch (event) {
147061d8658bSDupuis, Chad case RPORT_EV_READY:
147161d8658bSDupuis, Chad if (!rport) {
147261d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "rport is NULL.\n");
147361d8658bSDupuis, Chad break;
147461d8658bSDupuis, Chad }
147561d8658bSDupuis, Chad
147661d8658bSDupuis, Chad rp = rport->dd_data;
147761d8658bSDupuis, Chad fcport = (struct qedf_rport *)&rp[1];
147861d8658bSDupuis, Chad fcport->qedf = qedf;
147961d8658bSDupuis, Chad
148061d8658bSDupuis, Chad if (atomic_read(&qedf->num_offloads) >= QEDF_MAX_SESSIONS) {
148161d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Not offloading "
148261d8658bSDupuis, Chad "portid=0x%x as max number of offloaded sessions "
148361d8658bSDupuis, Chad "reached.\n", rdata->ids.port_id);
148461d8658bSDupuis, Chad return;
148561d8658bSDupuis, Chad }
148661d8658bSDupuis, Chad
148761d8658bSDupuis, Chad /*
148861d8658bSDupuis, Chad * Don't try to offload the session again. Can happen when we
148961d8658bSDupuis, Chad * get an ADISC
149061d8658bSDupuis, Chad */
149161d8658bSDupuis, Chad if (test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
149261d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "Session already "
149361d8658bSDupuis, Chad "offloaded, portid=0x%x.\n",
149461d8658bSDupuis, Chad rdata->ids.port_id);
149561d8658bSDupuis, Chad return;
149661d8658bSDupuis, Chad }
149761d8658bSDupuis, Chad
149861d8658bSDupuis, Chad if (rport->port_id == FC_FID_DIR_SERV) {
149961d8658bSDupuis, Chad /*
150061d8658bSDupuis, Chad * qedf_rport structure doesn't exist for
150161d8658bSDupuis, Chad * directory server.
150261d8658bSDupuis, Chad * We should not come here, as lport will
150361d8658bSDupuis, Chad * take care of fabric login
150461d8658bSDupuis, Chad */
150561d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "rport struct does not "
150661d8658bSDupuis, Chad "exist for dir server port_id=%x\n",
150761d8658bSDupuis, Chad rdata->ids.port_id);
150861d8658bSDupuis, Chad break;
150961d8658bSDupuis, Chad }
151061d8658bSDupuis, Chad
151161d8658bSDupuis, Chad if (rdata->spp_type != FC_TYPE_FCP) {
151261d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1513acef2690SColin Ian King "Not offloading since spp type isn't FCP\n");
151461d8658bSDupuis, Chad break;
151561d8658bSDupuis, Chad }
151661d8658bSDupuis, Chad if (!(rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET)) {
151761d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
151861d8658bSDupuis, Chad "Not FCP target so not offloading\n");
151961d8658bSDupuis, Chad break;
152061d8658bSDupuis, Chad }
152161d8658bSDupuis, Chad
152256efc304SHannes Reinecke /* Initial reference held on entry, so this can't fail */
152356efc304SHannes Reinecke kref_get(&rdata->kref);
152461d8658bSDupuis, Chad fcport->rdata = rdata;
152561d8658bSDupuis, Chad fcport->rport = rport;
152661d8658bSDupuis, Chad
152761d8658bSDupuis, Chad rval = qedf_alloc_sq(qedf, fcport);
152861d8658bSDupuis, Chad if (rval) {
152961d8658bSDupuis, Chad qedf_cleanup_fcport(qedf, fcport);
153061d8658bSDupuis, Chad break;
153161d8658bSDupuis, Chad }
153261d8658bSDupuis, Chad
153361d8658bSDupuis, Chad /* Set device type */
153461d8658bSDupuis, Chad if (rdata->flags & FC_RP_FLAGS_RETRY &&
153561d8658bSDupuis, Chad rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET &&
153661d8658bSDupuis, Chad !(rdata->ids.roles & FC_RPORT_ROLE_FCP_INITIATOR)) {
153761d8658bSDupuis, Chad fcport->dev_type = QEDF_RPORT_TYPE_TAPE;
153861d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
153961d8658bSDupuis, Chad "portid=%06x is a TAPE device.\n",
154061d8658bSDupuis, Chad rdata->ids.port_id);
154161d8658bSDupuis, Chad } else {
154261d8658bSDupuis, Chad fcport->dev_type = QEDF_RPORT_TYPE_DISK;
154361d8658bSDupuis, Chad }
154461d8658bSDupuis, Chad
154561d8658bSDupuis, Chad rval = qedf_offload_connection(qedf, fcport);
154661d8658bSDupuis, Chad if (rval) {
154761d8658bSDupuis, Chad qedf_cleanup_fcport(qedf, fcport);
154861d8658bSDupuis, Chad break;
154961d8658bSDupuis, Chad }
155061d8658bSDupuis, Chad
155161d8658bSDupuis, Chad /* Add fcport to list of qedf_ctx list of offloaded ports */
155261d8658bSDupuis, Chad spin_lock_irqsave(&qedf->hba_lock, flags);
155361d8658bSDupuis, Chad list_add_rcu(&fcport->peers, &qedf->fcports);
155461d8658bSDupuis, Chad spin_unlock_irqrestore(&qedf->hba_lock, flags);
155561d8658bSDupuis, Chad
155661d8658bSDupuis, Chad /*
155761d8658bSDupuis, Chad * Set the session ready bit to let everyone know that this
155861d8658bSDupuis, Chad * connection is ready for I/O
155961d8658bSDupuis, Chad */
156061d8658bSDupuis, Chad set_bit(QEDF_RPORT_SESSION_READY, &fcport->flags);
156161d8658bSDupuis, Chad atomic_inc(&qedf->num_offloads);
156261d8658bSDupuis, Chad
156361d8658bSDupuis, Chad break;
156461d8658bSDupuis, Chad case RPORT_EV_LOGO:
156561d8658bSDupuis, Chad case RPORT_EV_FAILED:
156661d8658bSDupuis, Chad case RPORT_EV_STOP:
156761d8658bSDupuis, Chad port_id = rdata->ids.port_id;
156861d8658bSDupuis, Chad if (port_id == FC_FID_DIR_SERV)
156961d8658bSDupuis, Chad break;
157061d8658bSDupuis, Chad
1571a521bbc3SSaurav Kashyap if (rdata->spp_type != FC_TYPE_FCP) {
1572a521bbc3SSaurav Kashyap QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1573a521bbc3SSaurav Kashyap "No action since spp type isn't FCP\n");
1574a521bbc3SSaurav Kashyap break;
1575a521bbc3SSaurav Kashyap }
1576a521bbc3SSaurav Kashyap if (!(rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET)) {
1577a521bbc3SSaurav Kashyap QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1578a521bbc3SSaurav Kashyap "Not FCP target so no action\n");
1579a521bbc3SSaurav Kashyap break;
1580a521bbc3SSaurav Kashyap }
1581a521bbc3SSaurav Kashyap
158261d8658bSDupuis, Chad if (!rport) {
158361d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
158461d8658bSDupuis, Chad "port_id=%x - rport notcreated Yet!!\n", port_id);
158561d8658bSDupuis, Chad break;
158661d8658bSDupuis, Chad }
158761d8658bSDupuis, Chad rp = rport->dd_data;
158861d8658bSDupuis, Chad /*
158961d8658bSDupuis, Chad * Perform session upload. Note that rdata->peers is already
159061d8658bSDupuis, Chad * removed from disc->rports list before we get this event.
159161d8658bSDupuis, Chad */
159261d8658bSDupuis, Chad fcport = (struct qedf_rport *)&rp[1];
159361d8658bSDupuis, Chad
159478a8ab3cSHannes Reinecke spin_lock_irqsave(&fcport->rport_lock, flags);
159561d8658bSDupuis, Chad /* Only free this fcport if it is offloaded already */
15965d5e5565SShyam Sundar if (test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags) &&
15975d5e5565SShyam Sundar !test_bit(QEDF_RPORT_UPLOADING_CONNECTION,
15985d5e5565SShyam Sundar &fcport->flags)) {
15995d5e5565SShyam Sundar set_bit(QEDF_RPORT_UPLOADING_CONNECTION,
16005d5e5565SShyam Sundar &fcport->flags);
160178a8ab3cSHannes Reinecke spin_unlock_irqrestore(&fcport->rport_lock, flags);
160261d8658bSDupuis, Chad qedf_cleanup_fcport(qedf, fcport);
160361d8658bSDupuis, Chad /*
160461d8658bSDupuis, Chad * Remove fcport to list of qedf_ctx list of offloaded
160561d8658bSDupuis, Chad * ports
160661d8658bSDupuis, Chad */
160761d8658bSDupuis, Chad spin_lock_irqsave(&qedf->hba_lock, flags);
160861d8658bSDupuis, Chad list_del_rcu(&fcport->peers);
160961d8658bSDupuis, Chad spin_unlock_irqrestore(&qedf->hba_lock, flags);
161061d8658bSDupuis, Chad
161161d8658bSDupuis, Chad clear_bit(QEDF_RPORT_UPLOADING_CONNECTION,
161261d8658bSDupuis, Chad &fcport->flags);
161361d8658bSDupuis, Chad atomic_dec(&qedf->num_offloads);
161478a8ab3cSHannes Reinecke } else {
161578a8ab3cSHannes Reinecke spin_unlock_irqrestore(&fcport->rport_lock, flags);
161661d8658bSDupuis, Chad }
161761d8658bSDupuis, Chad break;
161861d8658bSDupuis, Chad
161961d8658bSDupuis, Chad case RPORT_EV_NONE:
162061d8658bSDupuis, Chad break;
162161d8658bSDupuis, Chad }
162261d8658bSDupuis, Chad }
162361d8658bSDupuis, Chad
qedf_abort_io(struct fc_lport * lport)162461d8658bSDupuis, Chad static void qedf_abort_io(struct fc_lport *lport)
162561d8658bSDupuis, Chad {
162661d8658bSDupuis, Chad /* NO-OP but need to fill in the template */
162761d8658bSDupuis, Chad }
162861d8658bSDupuis, Chad
qedf_fcp_cleanup(struct fc_lport * lport)162961d8658bSDupuis, Chad static void qedf_fcp_cleanup(struct fc_lport *lport)
163061d8658bSDupuis, Chad {
163161d8658bSDupuis, Chad /*
163261d8658bSDupuis, Chad * NO-OP but need to fill in template to prevent a NULL
163361d8658bSDupuis, Chad * function pointer dereference during link down. I/Os
163461d8658bSDupuis, Chad * will be flushed when port is uploaded.
163561d8658bSDupuis, Chad */
163661d8658bSDupuis, Chad }
163761d8658bSDupuis, Chad
163861d8658bSDupuis, Chad static struct libfc_function_template qedf_lport_template = {
163961d8658bSDupuis, Chad .frame_send = qedf_xmit,
164061d8658bSDupuis, Chad .fcp_abort_io = qedf_abort_io,
164161d8658bSDupuis, Chad .fcp_cleanup = qedf_fcp_cleanup,
164261d8658bSDupuis, Chad .rport_event_callback = qedf_rport_event_handler,
164361d8658bSDupuis, Chad .elsct_send = qedf_elsct_send,
164461d8658bSDupuis, Chad };
164561d8658bSDupuis, Chad
qedf_fcoe_ctlr_setup(struct qedf_ctx * qedf)164661d8658bSDupuis, Chad static void qedf_fcoe_ctlr_setup(struct qedf_ctx *qedf)
164761d8658bSDupuis, Chad {
16488beb90aaSSedat Dilek fcoe_ctlr_init(&qedf->ctlr, FIP_MODE_AUTO);
164961d8658bSDupuis, Chad
165061d8658bSDupuis, Chad qedf->ctlr.send = qedf_fip_send;
165161d8658bSDupuis, Chad qedf->ctlr.get_src_addr = qedf_get_src_mac;
165261d8658bSDupuis, Chad ether_addr_copy(qedf->ctlr.ctl_src_addr, qedf->mac);
165361d8658bSDupuis, Chad }
165461d8658bSDupuis, Chad
qedf_setup_fdmi(struct qedf_ctx * qedf)16555185b328SChad Dupuis static void qedf_setup_fdmi(struct qedf_ctx *qedf)
16565185b328SChad Dupuis {
16575185b328SChad Dupuis struct fc_lport *lport = qedf->lport;
165841715c62SJaved Hasan u8 buf[8];
165941715c62SJaved Hasan int pos;
166041715c62SJaved Hasan uint32_t i;
16615185b328SChad Dupuis
16625185b328SChad Dupuis /*
166341715c62SJaved Hasan * fdmi_enabled needs to be set for libfc
166441715c62SJaved Hasan * to execute FDMI registration
16655185b328SChad Dupuis */
16665185b328SChad Dupuis lport->fdmi_enabled = 1;
16675185b328SChad Dupuis
16685185b328SChad Dupuis /*
16695185b328SChad Dupuis * Setup the necessary fc_host attributes to that will be used to fill
16705185b328SChad Dupuis * in the FDMI information.
16715185b328SChad Dupuis */
16725185b328SChad Dupuis
16735185b328SChad Dupuis /* Get the PCI-e Device Serial Number Capability */
167441715c62SJaved Hasan pos = pci_find_ext_capability(qedf->pdev, PCI_EXT_CAP_ID_DSN);
167541715c62SJaved Hasan if (pos) {
167641715c62SJaved Hasan pos += 4;
167741715c62SJaved Hasan for (i = 0; i < 8; i++)
167841715c62SJaved Hasan pci_read_config_byte(qedf->pdev, pos + i, &buf[i]);
16795185b328SChad Dupuis
168041715c62SJaved Hasan snprintf(fc_host_serial_number(lport->host),
168141715c62SJaved Hasan FC_SERIAL_NUMBER_SIZE,
168241715c62SJaved Hasan "%02X%02X%02X%02X%02X%02X%02X%02X",
168341715c62SJaved Hasan buf[7], buf[6], buf[5], buf[4],
168441715c62SJaved Hasan buf[3], buf[2], buf[1], buf[0]);
168541715c62SJaved Hasan } else
168641715c62SJaved Hasan snprintf(fc_host_serial_number(lport->host),
168741715c62SJaved Hasan FC_SERIAL_NUMBER_SIZE, "Unknown");
16885185b328SChad Dupuis
168941715c62SJaved Hasan snprintf(fc_host_manufacturer(lport->host),
169041715c62SJaved Hasan FC_SERIAL_NUMBER_SIZE, "%s", "Marvell Semiconductor Inc.");
16915185b328SChad Dupuis
169241715c62SJaved Hasan if (qedf->pdev->device == QL45xxx) {
169341715c62SJaved Hasan snprintf(fc_host_model(lport->host),
169441715c62SJaved Hasan FC_SYMBOLIC_NAME_SIZE, "%s", "QL45xxx");
16955185b328SChad Dupuis
169641715c62SJaved Hasan snprintf(fc_host_model_description(lport->host),
169741715c62SJaved Hasan FC_SYMBOLIC_NAME_SIZE, "%s",
169841715c62SJaved Hasan "Marvell FastLinQ QL45xxx FCoE Adapter");
169941715c62SJaved Hasan }
17005185b328SChad Dupuis
170141715c62SJaved Hasan if (qedf->pdev->device == QL41xxx) {
170241715c62SJaved Hasan snprintf(fc_host_model(lport->host),
170341715c62SJaved Hasan FC_SYMBOLIC_NAME_SIZE, "%s", "QL41xxx");
17045185b328SChad Dupuis
170541715c62SJaved Hasan snprintf(fc_host_model_description(lport->host),
170641715c62SJaved Hasan FC_SYMBOLIC_NAME_SIZE, "%s",
170741715c62SJaved Hasan "Marvell FastLinQ QL41xxx FCoE Adapter");
170841715c62SJaved Hasan }
170941715c62SJaved Hasan
171041715c62SJaved Hasan snprintf(fc_host_hardware_version(lport->host),
171141715c62SJaved Hasan FC_VERSION_STRING_SIZE, "Rev %d", qedf->pdev->revision);
171241715c62SJaved Hasan
171341715c62SJaved Hasan snprintf(fc_host_driver_version(lport->host),
171441715c62SJaved Hasan FC_VERSION_STRING_SIZE, "%s", QEDF_VERSION);
171541715c62SJaved Hasan
171641715c62SJaved Hasan snprintf(fc_host_firmware_version(lport->host),
171741715c62SJaved Hasan FC_VERSION_STRING_SIZE, "%d.%d.%d.%d",
171841715c62SJaved Hasan FW_MAJOR_VERSION, FW_MINOR_VERSION, FW_REVISION_VERSION,
171941715c62SJaved Hasan FW_ENGINEERING_VERSION);
172041715c62SJaved Hasan
1721adb98ec7SJaved Hasan snprintf(fc_host_vendor_identifier(lport->host),
1722adb98ec7SJaved Hasan FC_VENDOR_IDENTIFIER, "%s", "Marvell");
1723adb98ec7SJaved Hasan
17245185b328SChad Dupuis }
17255185b328SChad Dupuis
qedf_lport_setup(struct qedf_ctx * qedf)172661d8658bSDupuis, Chad static int qedf_lport_setup(struct qedf_ctx *qedf)
172761d8658bSDupuis, Chad {
172861d8658bSDupuis, Chad struct fc_lport *lport = qedf->lport;
172961d8658bSDupuis, Chad
173061d8658bSDupuis, Chad lport->link_up = 0;
173161d8658bSDupuis, Chad lport->max_retry_count = QEDF_FLOGI_RETRY_CNT;
173261d8658bSDupuis, Chad lport->max_rport_retry_count = QEDF_RPORT_RETRY_CNT;
173361d8658bSDupuis, Chad lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
173461d8658bSDupuis, Chad FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
173561d8658bSDupuis, Chad lport->boot_time = jiffies;
173661d8658bSDupuis, Chad lport->e_d_tov = 2 * 1000;
173761d8658bSDupuis, Chad lport->r_a_tov = 10 * 1000;
173861d8658bSDupuis, Chad
173961d8658bSDupuis, Chad /* Set NPIV support */
174061d8658bSDupuis, Chad lport->does_npiv = 1;
174161d8658bSDupuis, Chad fc_host_max_npiv_vports(lport->host) = QEDF_MAX_NPIV;
174261d8658bSDupuis, Chad
174361d8658bSDupuis, Chad fc_set_wwnn(lport, qedf->wwnn);
174461d8658bSDupuis, Chad fc_set_wwpn(lport, qedf->wwpn);
174561d8658bSDupuis, Chad
1746f4eecabeSSaurav Kashyap if (fcoe_libfc_config(lport, &qedf->ctlr, &qedf_lport_template, 0)) {
1747f4eecabeSSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
1748f4eecabeSSaurav Kashyap "fcoe_libfc_config failed.\n");
1749f4eecabeSSaurav Kashyap return -ENOMEM;
1750f4eecabeSSaurav Kashyap }
175161d8658bSDupuis, Chad
175261d8658bSDupuis, Chad /* Allocate the exchange manager */
1753650ce64cSChad Dupuis fc_exch_mgr_alloc(lport, FC_CLASS_3, FCOE_PARAMS_NUM_TASKS,
1754650ce64cSChad Dupuis 0xfffe, NULL);
175561d8658bSDupuis, Chad
175661d8658bSDupuis, Chad if (fc_lport_init_stats(lport))
175761d8658bSDupuis, Chad return -ENOMEM;
175861d8658bSDupuis, Chad
175961d8658bSDupuis, Chad /* Finish lport config */
176061d8658bSDupuis, Chad fc_lport_config(lport);
176161d8658bSDupuis, Chad
176261d8658bSDupuis, Chad /* Set max frame size */
176361d8658bSDupuis, Chad fc_set_mfs(lport, QEDF_MFS);
176461d8658bSDupuis, Chad fc_host_maxframe_size(lport->host) = lport->mfs;
176561d8658bSDupuis, Chad
176661d8658bSDupuis, Chad /* Set default dev_loss_tmo based on module parameter */
176761d8658bSDupuis, Chad fc_host_dev_loss_tmo(lport->host) = qedf_dev_loss_tmo;
176861d8658bSDupuis, Chad
176961d8658bSDupuis, Chad /* Set symbolic node name */
177041715c62SJaved Hasan if (qedf->pdev->device == QL45xxx)
177161d8658bSDupuis, Chad snprintf(fc_host_symbolic_name(lport->host), 256,
177241715c62SJaved Hasan "Marvell FastLinQ 45xxx FCoE v%s", QEDF_VERSION);
177341715c62SJaved Hasan
177441715c62SJaved Hasan if (qedf->pdev->device == QL41xxx)
177541715c62SJaved Hasan snprintf(fc_host_symbolic_name(lport->host), 256,
177641715c62SJaved Hasan "Marvell FastLinQ 41xxx FCoE v%s", QEDF_VERSION);
177761d8658bSDupuis, Chad
17785185b328SChad Dupuis qedf_setup_fdmi(qedf);
17795185b328SChad Dupuis
178061d8658bSDupuis, Chad return 0;
178161d8658bSDupuis, Chad }
178261d8658bSDupuis, Chad
178361d8658bSDupuis, Chad /*
178461d8658bSDupuis, Chad * NPIV functions
178561d8658bSDupuis, Chad */
178661d8658bSDupuis, Chad
qedf_vport_libfc_config(struct fc_vport * vport,struct fc_lport * lport)178761d8658bSDupuis, Chad static int qedf_vport_libfc_config(struct fc_vport *vport,
178861d8658bSDupuis, Chad struct fc_lport *lport)
178961d8658bSDupuis, Chad {
179061d8658bSDupuis, Chad lport->link_up = 0;
179161d8658bSDupuis, Chad lport->qfull = 0;
179261d8658bSDupuis, Chad lport->max_retry_count = QEDF_FLOGI_RETRY_CNT;
179361d8658bSDupuis, Chad lport->max_rport_retry_count = QEDF_RPORT_RETRY_CNT;
179461d8658bSDupuis, Chad lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
179561d8658bSDupuis, Chad FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
179661d8658bSDupuis, Chad lport->boot_time = jiffies;
179761d8658bSDupuis, Chad lport->e_d_tov = 2 * 1000;
179861d8658bSDupuis, Chad lport->r_a_tov = 10 * 1000;
179961d8658bSDupuis, Chad lport->does_npiv = 1; /* Temporary until we add NPIV support */
180061d8658bSDupuis, Chad
180161d8658bSDupuis, Chad /* Allocate stats for vport */
180261d8658bSDupuis, Chad if (fc_lport_init_stats(lport))
180361d8658bSDupuis, Chad return -ENOMEM;
180461d8658bSDupuis, Chad
180561d8658bSDupuis, Chad /* Finish lport config */
180661d8658bSDupuis, Chad fc_lport_config(lport);
180761d8658bSDupuis, Chad
180861d8658bSDupuis, Chad /* offload related configuration */
180961d8658bSDupuis, Chad lport->crc_offload = 0;
181061d8658bSDupuis, Chad lport->seq_offload = 0;
181161d8658bSDupuis, Chad lport->lro_enabled = 0;
181261d8658bSDupuis, Chad lport->lro_xid = 0;
181361d8658bSDupuis, Chad lport->lso_max = 0;
181461d8658bSDupuis, Chad
181561d8658bSDupuis, Chad return 0;
181661d8658bSDupuis, Chad }
181761d8658bSDupuis, Chad
qedf_vport_create(struct fc_vport * vport,bool disabled)181861d8658bSDupuis, Chad static int qedf_vport_create(struct fc_vport *vport, bool disabled)
181961d8658bSDupuis, Chad {
182061d8658bSDupuis, Chad struct Scsi_Host *shost = vport_to_shost(vport);
182161d8658bSDupuis, Chad struct fc_lport *n_port = shost_priv(shost);
182261d8658bSDupuis, Chad struct fc_lport *vn_port;
182361d8658bSDupuis, Chad struct qedf_ctx *base_qedf = lport_priv(n_port);
182461d8658bSDupuis, Chad struct qedf_ctx *vport_qedf;
182561d8658bSDupuis, Chad
182661d8658bSDupuis, Chad char buf[32];
182761d8658bSDupuis, Chad int rc = 0;
182861d8658bSDupuis, Chad
182961d8658bSDupuis, Chad rc = fcoe_validate_vport_create(vport);
183061d8658bSDupuis, Chad if (rc) {
183161d8658bSDupuis, Chad fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
183261d8658bSDupuis, Chad QEDF_WARN(&(base_qedf->dbg_ctx), "Failed to create vport, "
183361d8658bSDupuis, Chad "WWPN (0x%s) already exists.\n", buf);
183479c932cdSDaniel Wagner return rc;
183561d8658bSDupuis, Chad }
183661d8658bSDupuis, Chad
183761d8658bSDupuis, Chad if (atomic_read(&base_qedf->link_state) != QEDF_LINK_UP) {
183861d8658bSDupuis, Chad QEDF_WARN(&(base_qedf->dbg_ctx), "Cannot create vport "
183961d8658bSDupuis, Chad "because link is not up.\n");
184079c932cdSDaniel Wagner return -EIO;
184161d8658bSDupuis, Chad }
184261d8658bSDupuis, Chad
184361d8658bSDupuis, Chad vn_port = libfc_vport_create(vport, sizeof(struct qedf_ctx));
184461d8658bSDupuis, Chad if (!vn_port) {
184561d8658bSDupuis, Chad QEDF_WARN(&(base_qedf->dbg_ctx), "Could not create lport "
184661d8658bSDupuis, Chad "for vport.\n");
184779c932cdSDaniel Wagner return -ENOMEM;
184861d8658bSDupuis, Chad }
184961d8658bSDupuis, Chad
185061d8658bSDupuis, Chad fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
185161d8658bSDupuis, Chad QEDF_ERR(&(base_qedf->dbg_ctx), "Creating NPIV port, WWPN=%s.\n",
185261d8658bSDupuis, Chad buf);
185361d8658bSDupuis, Chad
185461d8658bSDupuis, Chad /* Copy some fields from base_qedf */
185561d8658bSDupuis, Chad vport_qedf = lport_priv(vn_port);
185661d8658bSDupuis, Chad memcpy(vport_qedf, base_qedf, sizeof(struct qedf_ctx));
185761d8658bSDupuis, Chad
185861d8658bSDupuis, Chad /* Set qedf data specific to this vport */
185961d8658bSDupuis, Chad vport_qedf->lport = vn_port;
186061d8658bSDupuis, Chad /* Use same hba_lock as base_qedf */
186161d8658bSDupuis, Chad vport_qedf->hba_lock = base_qedf->hba_lock;
186261d8658bSDupuis, Chad vport_qedf->pdev = base_qedf->pdev;
186361d8658bSDupuis, Chad vport_qedf->cmd_mgr = base_qedf->cmd_mgr;
186461d8658bSDupuis, Chad init_completion(&vport_qedf->flogi_compl);
186561d8658bSDupuis, Chad INIT_LIST_HEAD(&vport_qedf->fcports);
1866b70a99fdSSaurav Kashyap INIT_DELAYED_WORK(&vport_qedf->stag_work, qedf_stag_change_work);
186761d8658bSDupuis, Chad
186861d8658bSDupuis, Chad rc = qedf_vport_libfc_config(vport, vn_port);
186961d8658bSDupuis, Chad if (rc) {
187061d8658bSDupuis, Chad QEDF_ERR(&(base_qedf->dbg_ctx), "Could not allocate memory "
187161d8658bSDupuis, Chad "for lport stats.\n");
187279c932cdSDaniel Wagner goto err;
187361d8658bSDupuis, Chad }
187461d8658bSDupuis, Chad
187561d8658bSDupuis, Chad fc_set_wwnn(vn_port, vport->node_name);
187661d8658bSDupuis, Chad fc_set_wwpn(vn_port, vport->port_name);
187761d8658bSDupuis, Chad vport_qedf->wwnn = vn_port->wwnn;
187861d8658bSDupuis, Chad vport_qedf->wwpn = vn_port->wwpn;
187961d8658bSDupuis, Chad
188061d8658bSDupuis, Chad vn_port->host->transportt = qedf_fc_vport_transport_template;
1881650ce64cSChad Dupuis vn_port->host->can_queue = FCOE_PARAMS_NUM_TASKS;
188261d8658bSDupuis, Chad vn_port->host->max_lun = qedf_max_lun;
188361d8658bSDupuis, Chad vn_port->host->sg_tablesize = QEDF_MAX_BDS_PER_CMD;
188461d8658bSDupuis, Chad vn_port->host->max_cmd_len = QEDF_MAX_CDB_LEN;
18851b67f3d7SSaurav Kashyap vn_port->host->max_id = QEDF_MAX_SESSIONS;
188661d8658bSDupuis, Chad
188761d8658bSDupuis, Chad rc = scsi_add_host(vn_port->host, &vport->dev);
188861d8658bSDupuis, Chad if (rc) {
18891e1ff604SSaurav Kashyap QEDF_WARN(&base_qedf->dbg_ctx,
18901e1ff604SSaurav Kashyap "Error adding Scsi_Host rc=0x%x.\n", rc);
189179c932cdSDaniel Wagner goto err;
189261d8658bSDupuis, Chad }
189361d8658bSDupuis, Chad
189461d8658bSDupuis, Chad /* Set default dev_loss_tmo based on module parameter */
189561d8658bSDupuis, Chad fc_host_dev_loss_tmo(vn_port->host) = qedf_dev_loss_tmo;
189661d8658bSDupuis, Chad
189761d8658bSDupuis, Chad /* Init libfc stuffs */
189861d8658bSDupuis, Chad memcpy(&vn_port->tt, &qedf_lport_template,
189961d8658bSDupuis, Chad sizeof(qedf_lport_template));
190061d8658bSDupuis, Chad fc_exch_init(vn_port);
190161d8658bSDupuis, Chad fc_elsct_init(vn_port);
190261d8658bSDupuis, Chad fc_lport_init(vn_port);
190361d8658bSDupuis, Chad fc_disc_init(vn_port);
190461d8658bSDupuis, Chad fc_disc_config(vn_port, vn_port);
190561d8658bSDupuis, Chad
190661d8658bSDupuis, Chad
190761d8658bSDupuis, Chad /* Allocate the exchange manager */
190861d8658bSDupuis, Chad shost = vport_to_shost(vport);
190961d8658bSDupuis, Chad n_port = shost_priv(shost);
191061d8658bSDupuis, Chad fc_exch_mgr_list_clone(n_port, vn_port);
191161d8658bSDupuis, Chad
191261d8658bSDupuis, Chad /* Set max frame size */
191361d8658bSDupuis, Chad fc_set_mfs(vn_port, QEDF_MFS);
191461d8658bSDupuis, Chad
191561d8658bSDupuis, Chad fc_host_port_type(vn_port->host) = FC_PORTTYPE_UNKNOWN;
191661d8658bSDupuis, Chad
191761d8658bSDupuis, Chad if (disabled) {
191861d8658bSDupuis, Chad fc_vport_set_state(vport, FC_VPORT_DISABLED);
191961d8658bSDupuis, Chad } else {
192061d8658bSDupuis, Chad vn_port->boot_time = jiffies;
192161d8658bSDupuis, Chad fc_fabric_login(vn_port);
192261d8658bSDupuis, Chad fc_vport_setlink(vn_port);
192361d8658bSDupuis, Chad }
192461d8658bSDupuis, Chad
1925592642e6SSaurav Kashyap /* Set symbolic node name */
1926592642e6SSaurav Kashyap if (base_qedf->pdev->device == QL45xxx)
1927592642e6SSaurav Kashyap snprintf(fc_host_symbolic_name(vn_port->host), 256,
1928592642e6SSaurav Kashyap "Marvell FastLinQ 45xxx FCoE v%s", QEDF_VERSION);
1929592642e6SSaurav Kashyap
1930592642e6SSaurav Kashyap if (base_qedf->pdev->device == QL41xxx)
1931592642e6SSaurav Kashyap snprintf(fc_host_symbolic_name(vn_port->host), 256,
1932592642e6SSaurav Kashyap "Marvell FastLinQ 41xxx FCoE v%s", QEDF_VERSION);
1933592642e6SSaurav Kashyap
1934592642e6SSaurav Kashyap /* Set supported speed */
1935592642e6SSaurav Kashyap fc_host_supported_speeds(vn_port->host) = n_port->link_supported_speeds;
1936592642e6SSaurav Kashyap
1937592642e6SSaurav Kashyap /* Set speed */
1938592642e6SSaurav Kashyap vn_port->link_speed = n_port->link_speed;
1939592642e6SSaurav Kashyap
1940592642e6SSaurav Kashyap /* Set port type */
1941592642e6SSaurav Kashyap fc_host_port_type(vn_port->host) = FC_PORTTYPE_NPIV;
1942592642e6SSaurav Kashyap
1943592642e6SSaurav Kashyap /* Set maxframe size */
1944592642e6SSaurav Kashyap fc_host_maxframe_size(vn_port->host) = n_port->mfs;
1945592642e6SSaurav Kashyap
194661d8658bSDupuis, Chad QEDF_INFO(&(base_qedf->dbg_ctx), QEDF_LOG_NPIV, "vn_port=%p.\n",
194761d8658bSDupuis, Chad vn_port);
194861d8658bSDupuis, Chad
194961d8658bSDupuis, Chad /* Set up debug context for vport */
195061d8658bSDupuis, Chad vport_qedf->dbg_ctx.host_no = vn_port->host->host_no;
195161d8658bSDupuis, Chad vport_qedf->dbg_ctx.pdev = base_qedf->pdev;
195261d8658bSDupuis, Chad
195379c932cdSDaniel Wagner return 0;
195479c932cdSDaniel Wagner
195579c932cdSDaniel Wagner err:
195661d8658bSDupuis, Chad scsi_host_put(vn_port->host);
195761d8658bSDupuis, Chad return rc;
195861d8658bSDupuis, Chad }
195961d8658bSDupuis, Chad
qedf_vport_destroy(struct fc_vport * vport)196061d8658bSDupuis, Chad static int qedf_vport_destroy(struct fc_vport *vport)
196161d8658bSDupuis, Chad {
196261d8658bSDupuis, Chad struct Scsi_Host *shost = vport_to_shost(vport);
196361d8658bSDupuis, Chad struct fc_lport *n_port = shost_priv(shost);
196461d8658bSDupuis, Chad struct fc_lport *vn_port = vport->dd_data;
19654f4616ceSChad Dupuis struct qedf_ctx *qedf = lport_priv(vn_port);
19664f4616ceSChad Dupuis
19674f4616ceSChad Dupuis if (!qedf) {
19684f4616ceSChad Dupuis QEDF_ERR(NULL, "qedf is NULL.\n");
19694f4616ceSChad Dupuis goto out;
19704f4616ceSChad Dupuis }
19714f4616ceSChad Dupuis
19724f4616ceSChad Dupuis /* Set unloading bit on vport qedf_ctx to prevent more I/O */
19734f4616ceSChad Dupuis set_bit(QEDF_UNLOADING, &qedf->flags);
197461d8658bSDupuis, Chad
197561d8658bSDupuis, Chad mutex_lock(&n_port->lp_mutex);
197661d8658bSDupuis, Chad list_del(&vn_port->list);
197761d8658bSDupuis, Chad mutex_unlock(&n_port->lp_mutex);
197861d8658bSDupuis, Chad
197961d8658bSDupuis, Chad fc_fabric_logoff(vn_port);
198061d8658bSDupuis, Chad fc_lport_destroy(vn_port);
198161d8658bSDupuis, Chad
198261d8658bSDupuis, Chad /* Detach from scsi-ml */
198361d8658bSDupuis, Chad fc_remove_host(vn_port->host);
198461d8658bSDupuis, Chad scsi_remove_host(vn_port->host);
198561d8658bSDupuis, Chad
198661d8658bSDupuis, Chad /*
198761d8658bSDupuis, Chad * Only try to release the exchange manager if the vn_port
198861d8658bSDupuis, Chad * configuration is complete.
198961d8658bSDupuis, Chad */
199061d8658bSDupuis, Chad if (vn_port->state == LPORT_ST_READY)
199161d8658bSDupuis, Chad fc_exch_mgr_free(vn_port);
199261d8658bSDupuis, Chad
199361d8658bSDupuis, Chad /* Free memory used by statistical counters */
199461d8658bSDupuis, Chad fc_lport_free_stats(vn_port);
199561d8658bSDupuis, Chad
199661d8658bSDupuis, Chad /* Release Scsi_Host */
199761d8658bSDupuis, Chad scsi_host_put(vn_port->host);
199861d8658bSDupuis, Chad
19994f4616ceSChad Dupuis out:
200061d8658bSDupuis, Chad return 0;
200161d8658bSDupuis, Chad }
200261d8658bSDupuis, Chad
qedf_vport_disable(struct fc_vport * vport,bool disable)200361d8658bSDupuis, Chad static int qedf_vport_disable(struct fc_vport *vport, bool disable)
200461d8658bSDupuis, Chad {
200561d8658bSDupuis, Chad struct fc_lport *lport = vport->dd_data;
200661d8658bSDupuis, Chad
200761d8658bSDupuis, Chad if (disable) {
200861d8658bSDupuis, Chad fc_vport_set_state(vport, FC_VPORT_DISABLED);
200961d8658bSDupuis, Chad fc_fabric_logoff(lport);
201061d8658bSDupuis, Chad } else {
201161d8658bSDupuis, Chad lport->boot_time = jiffies;
201261d8658bSDupuis, Chad fc_fabric_login(lport);
201361d8658bSDupuis, Chad fc_vport_setlink(lport);
201461d8658bSDupuis, Chad }
201561d8658bSDupuis, Chad return 0;
201661d8658bSDupuis, Chad }
201761d8658bSDupuis, Chad
201861d8658bSDupuis, Chad /*
201961d8658bSDupuis, Chad * During removal we need to wait for all the vports associated with a port
202061d8658bSDupuis, Chad * to be destroyed so we avoid a race condition where libfc is still trying
202161d8658bSDupuis, Chad * to reap vports while the driver remove function has already reaped the
202261d8658bSDupuis, Chad * driver contexts associated with the physical port.
202361d8658bSDupuis, Chad */
qedf_wait_for_vport_destroy(struct qedf_ctx * qedf)202461d8658bSDupuis, Chad static void qedf_wait_for_vport_destroy(struct qedf_ctx *qedf)
202561d8658bSDupuis, Chad {
202661d8658bSDupuis, Chad struct fc_host_attrs *fc_host = shost_to_fc_host(qedf->lport->host);
202761d8658bSDupuis, Chad
202861d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_NPIV,
202961d8658bSDupuis, Chad "Entered.\n");
203061d8658bSDupuis, Chad while (fc_host->npiv_vports_inuse > 0) {
203161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_NPIV,
203261d8658bSDupuis, Chad "Waiting for all vports to be reaped.\n");
203361d8658bSDupuis, Chad msleep(1000);
203461d8658bSDupuis, Chad }
203561d8658bSDupuis, Chad }
203661d8658bSDupuis, Chad
203761d8658bSDupuis, Chad /**
203861d8658bSDupuis, Chad * qedf_fcoe_reset - Resets the fcoe
203961d8658bSDupuis, Chad *
204061d8658bSDupuis, Chad * @shost: shost the reset is from
204161d8658bSDupuis, Chad *
204261d8658bSDupuis, Chad * Returns: always 0
204361d8658bSDupuis, Chad */
qedf_fcoe_reset(struct Scsi_Host * shost)204461d8658bSDupuis, Chad static int qedf_fcoe_reset(struct Scsi_Host *shost)
204561d8658bSDupuis, Chad {
204661d8658bSDupuis, Chad struct fc_lport *lport = shost_priv(shost);
204761d8658bSDupuis, Chad
20485cf446d2SChad Dupuis qedf_ctx_soft_reset(lport);
204961d8658bSDupuis, Chad return 0;
205061d8658bSDupuis, Chad }
205161d8658bSDupuis, Chad
qedf_get_host_port_id(struct Scsi_Host * shost)2052c3dde2f3SDaniel Wagner static void qedf_get_host_port_id(struct Scsi_Host *shost)
2053c3dde2f3SDaniel Wagner {
2054c3dde2f3SDaniel Wagner struct fc_lport *lport = shost_priv(shost);
2055c3dde2f3SDaniel Wagner
2056c3dde2f3SDaniel Wagner fc_host_port_id(shost) = lport->port_id;
2057c3dde2f3SDaniel Wagner }
2058c3dde2f3SDaniel Wagner
qedf_fc_get_host_stats(struct Scsi_Host * shost)205961d8658bSDupuis, Chad static struct fc_host_statistics *qedf_fc_get_host_stats(struct Scsi_Host
206061d8658bSDupuis, Chad *shost)
206161d8658bSDupuis, Chad {
206261d8658bSDupuis, Chad struct fc_host_statistics *qedf_stats;
206361d8658bSDupuis, Chad struct fc_lport *lport = shost_priv(shost);
206461d8658bSDupuis, Chad struct qedf_ctx *qedf = lport_priv(lport);
206561d8658bSDupuis, Chad struct qed_fcoe_stats *fw_fcoe_stats;
206661d8658bSDupuis, Chad
206761d8658bSDupuis, Chad qedf_stats = fc_get_host_stats(shost);
206861d8658bSDupuis, Chad
206961d8658bSDupuis, Chad /* We don't collect offload stats for specific NPIV ports */
207061d8658bSDupuis, Chad if (lport->vport)
207161d8658bSDupuis, Chad goto out;
207261d8658bSDupuis, Chad
207361d8658bSDupuis, Chad fw_fcoe_stats = kmalloc(sizeof(struct qed_fcoe_stats), GFP_KERNEL);
207461d8658bSDupuis, Chad if (!fw_fcoe_stats) {
207561d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate memory for "
207661d8658bSDupuis, Chad "fw_fcoe_stats.\n");
207761d8658bSDupuis, Chad goto out;
207861d8658bSDupuis, Chad }
207961d8658bSDupuis, Chad
2080642a0b37SChad Dupuis mutex_lock(&qedf->stats_mutex);
2081642a0b37SChad Dupuis
208261d8658bSDupuis, Chad /* Query firmware for offload stats */
208361d8658bSDupuis, Chad qed_ops->get_stats(qedf->cdev, fw_fcoe_stats);
208461d8658bSDupuis, Chad
208561d8658bSDupuis, Chad /*
208661d8658bSDupuis, Chad * The expectation is that we add our offload stats to the stats
208761d8658bSDupuis, Chad * being maintained by libfc each time the fc_get_host_status callback
208861d8658bSDupuis, Chad * is invoked. The additions are not carried over for each call to
208961d8658bSDupuis, Chad * the fc_get_host_stats callback.
209061d8658bSDupuis, Chad */
209161d8658bSDupuis, Chad qedf_stats->tx_frames += fw_fcoe_stats->fcoe_tx_data_pkt_cnt +
209261d8658bSDupuis, Chad fw_fcoe_stats->fcoe_tx_xfer_pkt_cnt +
209361d8658bSDupuis, Chad fw_fcoe_stats->fcoe_tx_other_pkt_cnt;
209461d8658bSDupuis, Chad qedf_stats->rx_frames += fw_fcoe_stats->fcoe_rx_data_pkt_cnt +
209561d8658bSDupuis, Chad fw_fcoe_stats->fcoe_rx_xfer_pkt_cnt +
209661d8658bSDupuis, Chad fw_fcoe_stats->fcoe_rx_other_pkt_cnt;
209761d8658bSDupuis, Chad qedf_stats->fcp_input_megabytes +=
209861d8658bSDupuis, Chad do_div(fw_fcoe_stats->fcoe_rx_byte_cnt, 1000000);
209961d8658bSDupuis, Chad qedf_stats->fcp_output_megabytes +=
210061d8658bSDupuis, Chad do_div(fw_fcoe_stats->fcoe_tx_byte_cnt, 1000000);
210161d8658bSDupuis, Chad qedf_stats->rx_words += fw_fcoe_stats->fcoe_rx_byte_cnt / 4;
210261d8658bSDupuis, Chad qedf_stats->tx_words += fw_fcoe_stats->fcoe_tx_byte_cnt / 4;
210361d8658bSDupuis, Chad qedf_stats->invalid_crc_count +=
210461d8658bSDupuis, Chad fw_fcoe_stats->fcoe_silent_drop_pkt_crc_error_cnt;
210561d8658bSDupuis, Chad qedf_stats->dumped_frames =
210661d8658bSDupuis, Chad fw_fcoe_stats->fcoe_silent_drop_total_pkt_cnt;
210761d8658bSDupuis, Chad qedf_stats->error_frames +=
210861d8658bSDupuis, Chad fw_fcoe_stats->fcoe_silent_drop_total_pkt_cnt;
210961d8658bSDupuis, Chad qedf_stats->fcp_input_requests += qedf->input_requests;
211061d8658bSDupuis, Chad qedf_stats->fcp_output_requests += qedf->output_requests;
211161d8658bSDupuis, Chad qedf_stats->fcp_control_requests += qedf->control_requests;
211261d8658bSDupuis, Chad qedf_stats->fcp_packet_aborts += qedf->packet_aborts;
211361d8658bSDupuis, Chad qedf_stats->fcp_frame_alloc_failures += qedf->alloc_failures;
211461d8658bSDupuis, Chad
2115642a0b37SChad Dupuis mutex_unlock(&qedf->stats_mutex);
211661d8658bSDupuis, Chad kfree(fw_fcoe_stats);
211761d8658bSDupuis, Chad out:
211861d8658bSDupuis, Chad return qedf_stats;
211961d8658bSDupuis, Chad }
212061d8658bSDupuis, Chad
212161d8658bSDupuis, Chad static struct fc_function_template qedf_fc_transport_fn = {
212261d8658bSDupuis, Chad .show_host_node_name = 1,
212361d8658bSDupuis, Chad .show_host_port_name = 1,
212461d8658bSDupuis, Chad .show_host_supported_classes = 1,
212561d8658bSDupuis, Chad .show_host_supported_fc4s = 1,
212661d8658bSDupuis, Chad .show_host_active_fc4s = 1,
212761d8658bSDupuis, Chad .show_host_maxframe_size = 1,
212861d8658bSDupuis, Chad
2129c3dde2f3SDaniel Wagner .get_host_port_id = qedf_get_host_port_id,
213061d8658bSDupuis, Chad .show_host_port_id = 1,
213161d8658bSDupuis, Chad .show_host_supported_speeds = 1,
213261d8658bSDupuis, Chad .get_host_speed = fc_get_host_speed,
213361d8658bSDupuis, Chad .show_host_speed = 1,
213461d8658bSDupuis, Chad .show_host_port_type = 1,
213561d8658bSDupuis, Chad .get_host_port_state = fc_get_host_port_state,
213661d8658bSDupuis, Chad .show_host_port_state = 1,
213761d8658bSDupuis, Chad .show_host_symbolic_name = 1,
213861d8658bSDupuis, Chad
213961d8658bSDupuis, Chad /*
214061d8658bSDupuis, Chad * Tell FC transport to allocate enough space to store the backpointer
214161d8658bSDupuis, Chad * for the associate qedf_rport struct.
214261d8658bSDupuis, Chad */
214361d8658bSDupuis, Chad .dd_fcrport_size = (sizeof(struct fc_rport_libfc_priv) +
214461d8658bSDupuis, Chad sizeof(struct qedf_rport)),
214561d8658bSDupuis, Chad .show_rport_maxframe_size = 1,
214661d8658bSDupuis, Chad .show_rport_supported_classes = 1,
214761d8658bSDupuis, Chad .show_host_fabric_name = 1,
214861d8658bSDupuis, Chad .show_starget_node_name = 1,
214961d8658bSDupuis, Chad .show_starget_port_name = 1,
215061d8658bSDupuis, Chad .show_starget_port_id = 1,
215161d8658bSDupuis, Chad .set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
215261d8658bSDupuis, Chad .show_rport_dev_loss_tmo = 1,
215361d8658bSDupuis, Chad .get_fc_host_stats = qedf_fc_get_host_stats,
215461d8658bSDupuis, Chad .issue_fc_host_lip = qedf_fcoe_reset,
215561d8658bSDupuis, Chad .vport_create = qedf_vport_create,
215661d8658bSDupuis, Chad .vport_delete = qedf_vport_destroy,
215761d8658bSDupuis, Chad .vport_disable = qedf_vport_disable,
215861d8658bSDupuis, Chad .bsg_request = fc_lport_bsg_request,
215961d8658bSDupuis, Chad };
216061d8658bSDupuis, Chad
216161d8658bSDupuis, Chad static struct fc_function_template qedf_fc_vport_transport_fn = {
216261d8658bSDupuis, Chad .show_host_node_name = 1,
216361d8658bSDupuis, Chad .show_host_port_name = 1,
216461d8658bSDupuis, Chad .show_host_supported_classes = 1,
216561d8658bSDupuis, Chad .show_host_supported_fc4s = 1,
216661d8658bSDupuis, Chad .show_host_active_fc4s = 1,
216761d8658bSDupuis, Chad .show_host_maxframe_size = 1,
216861d8658bSDupuis, Chad .show_host_port_id = 1,
216961d8658bSDupuis, Chad .show_host_supported_speeds = 1,
217061d8658bSDupuis, Chad .get_host_speed = fc_get_host_speed,
217161d8658bSDupuis, Chad .show_host_speed = 1,
217261d8658bSDupuis, Chad .show_host_port_type = 1,
217361d8658bSDupuis, Chad .get_host_port_state = fc_get_host_port_state,
217461d8658bSDupuis, Chad .show_host_port_state = 1,
217561d8658bSDupuis, Chad .show_host_symbolic_name = 1,
217661d8658bSDupuis, Chad .dd_fcrport_size = (sizeof(struct fc_rport_libfc_priv) +
217761d8658bSDupuis, Chad sizeof(struct qedf_rport)),
217861d8658bSDupuis, Chad .show_rport_maxframe_size = 1,
217961d8658bSDupuis, Chad .show_rport_supported_classes = 1,
218061d8658bSDupuis, Chad .show_host_fabric_name = 1,
218161d8658bSDupuis, Chad .show_starget_node_name = 1,
218261d8658bSDupuis, Chad .show_starget_port_name = 1,
218361d8658bSDupuis, Chad .show_starget_port_id = 1,
218461d8658bSDupuis, Chad .set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
218561d8658bSDupuis, Chad .show_rport_dev_loss_tmo = 1,
218661d8658bSDupuis, Chad .get_fc_host_stats = fc_get_host_stats,
218761d8658bSDupuis, Chad .issue_fc_host_lip = qedf_fcoe_reset,
218861d8658bSDupuis, Chad .bsg_request = fc_lport_bsg_request,
218961d8658bSDupuis, Chad };
219061d8658bSDupuis, Chad
qedf_fp_has_work(struct qedf_fastpath * fp)219161d8658bSDupuis, Chad static bool qedf_fp_has_work(struct qedf_fastpath *fp)
219261d8658bSDupuis, Chad {
219361d8658bSDupuis, Chad struct qedf_ctx *qedf = fp->qedf;
219461d8658bSDupuis, Chad struct global_queue *que;
219561d8658bSDupuis, Chad struct qed_sb_info *sb_info = fp->sb_info;
2196fb09a1edSShai Malin struct status_block *sb = sb_info->sb_virt;
219761d8658bSDupuis, Chad u16 prod_idx;
219861d8658bSDupuis, Chad
219961d8658bSDupuis, Chad /* Get the pointer to the global CQ this completion is on */
220061d8658bSDupuis, Chad que = qedf->global_queues[fp->sb_id];
220161d8658bSDupuis, Chad
220261d8658bSDupuis, Chad /* Be sure all responses have been written to PI */
220361d8658bSDupuis, Chad rmb();
220461d8658bSDupuis, Chad
220561d8658bSDupuis, Chad /* Get the current firmware producer index */
220661d8658bSDupuis, Chad prod_idx = sb->pi_array[QEDF_FCOE_PARAMS_GL_RQ_PI];
220761d8658bSDupuis, Chad
220861d8658bSDupuis, Chad return (que->cq_prod_idx != prod_idx);
220961d8658bSDupuis, Chad }
221061d8658bSDupuis, Chad
221161d8658bSDupuis, Chad /*
221261d8658bSDupuis, Chad * Interrupt handler code.
221361d8658bSDupuis, Chad */
221461d8658bSDupuis, Chad
221561d8658bSDupuis, Chad /* Process completion queue and copy CQE contents for deferred processesing
221661d8658bSDupuis, Chad *
221761d8658bSDupuis, Chad * Return true if we should wake the I/O thread, false if not.
221861d8658bSDupuis, Chad */
qedf_process_completions(struct qedf_fastpath * fp)221961d8658bSDupuis, Chad static bool qedf_process_completions(struct qedf_fastpath *fp)
222061d8658bSDupuis, Chad {
222161d8658bSDupuis, Chad struct qedf_ctx *qedf = fp->qedf;
222261d8658bSDupuis, Chad struct qed_sb_info *sb_info = fp->sb_info;
2223fb09a1edSShai Malin struct status_block *sb = sb_info->sb_virt;
222461d8658bSDupuis, Chad struct global_queue *que;
222561d8658bSDupuis, Chad u16 prod_idx;
222661d8658bSDupuis, Chad struct fcoe_cqe *cqe;
222761d8658bSDupuis, Chad struct qedf_io_work *io_work;
222861d8658bSDupuis, Chad unsigned int cpu;
222961d8658bSDupuis, Chad struct qedf_ioreq *io_req = NULL;
223061d8658bSDupuis, Chad u16 xid;
223161d8658bSDupuis, Chad u16 new_cqes;
223261d8658bSDupuis, Chad u32 comp_type;
223361d8658bSDupuis, Chad
223461d8658bSDupuis, Chad /* Get the current firmware producer index */
223561d8658bSDupuis, Chad prod_idx = sb->pi_array[QEDF_FCOE_PARAMS_GL_RQ_PI];
223661d8658bSDupuis, Chad
223761d8658bSDupuis, Chad /* Get the pointer to the global CQ this completion is on */
223861d8658bSDupuis, Chad que = qedf->global_queues[fp->sb_id];
223961d8658bSDupuis, Chad
224061d8658bSDupuis, Chad /* Calculate the amount of new elements since last processing */
224161d8658bSDupuis, Chad new_cqes = (prod_idx >= que->cq_prod_idx) ?
224261d8658bSDupuis, Chad (prod_idx - que->cq_prod_idx) :
224361d8658bSDupuis, Chad 0x10000 - que->cq_prod_idx + prod_idx;
224461d8658bSDupuis, Chad
224561d8658bSDupuis, Chad /* Save producer index */
224661d8658bSDupuis, Chad que->cq_prod_idx = prod_idx;
224761d8658bSDupuis, Chad
224861d8658bSDupuis, Chad while (new_cqes) {
224961d8658bSDupuis, Chad fp->completions++;
225061d8658bSDupuis, Chad cqe = &que->cq[que->cq_cons_idx];
225161d8658bSDupuis, Chad
225261d8658bSDupuis, Chad comp_type = (cqe->cqe_data >> FCOE_CQE_CQE_TYPE_SHIFT) &
225361d8658bSDupuis, Chad FCOE_CQE_CQE_TYPE_MASK;
225461d8658bSDupuis, Chad
225561d8658bSDupuis, Chad /*
225661d8658bSDupuis, Chad * Process unsolicited CQEs directly in the interrupt handler
225761d8658bSDupuis, Chad * sine we need the fastpath ID
225861d8658bSDupuis, Chad */
225961d8658bSDupuis, Chad if (comp_type == FCOE_UNSOLIC_CQE_TYPE) {
226061d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_UNSOL,
226161d8658bSDupuis, Chad "Unsolicated CQE.\n");
226261d8658bSDupuis, Chad qedf_process_unsol_compl(qedf, fp->sb_id, cqe);
226361d8658bSDupuis, Chad /*
226461d8658bSDupuis, Chad * Don't add a work list item. Increment consumer
226561d8658bSDupuis, Chad * consumer index and move on.
226661d8658bSDupuis, Chad */
226761d8658bSDupuis, Chad goto inc_idx;
226861d8658bSDupuis, Chad }
226961d8658bSDupuis, Chad
227061d8658bSDupuis, Chad xid = cqe->cqe_data & FCOE_CQE_TASK_ID_MASK;
227161d8658bSDupuis, Chad io_req = &qedf->cmd_mgr->cmds[xid];
227261d8658bSDupuis, Chad
227361d8658bSDupuis, Chad /*
227461d8658bSDupuis, Chad * Figure out which percpu thread we should queue this I/O
227561d8658bSDupuis, Chad * on.
227661d8658bSDupuis, Chad */
227761d8658bSDupuis, Chad if (!io_req)
227861d8658bSDupuis, Chad /* If there is not io_req assocated with this CQE
227961d8658bSDupuis, Chad * just queue it on CPU 0
228061d8658bSDupuis, Chad */
228161d8658bSDupuis, Chad cpu = 0;
228261d8658bSDupuis, Chad else {
228361d8658bSDupuis, Chad cpu = io_req->cpu;
228461d8658bSDupuis, Chad io_req->int_cpu = smp_processor_id();
228561d8658bSDupuis, Chad }
228661d8658bSDupuis, Chad
228761d8658bSDupuis, Chad io_work = mempool_alloc(qedf->io_mempool, GFP_ATOMIC);
228861d8658bSDupuis, Chad if (!io_work) {
228961d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate "
229061d8658bSDupuis, Chad "work for I/O completion.\n");
229161d8658bSDupuis, Chad continue;
229261d8658bSDupuis, Chad }
229361d8658bSDupuis, Chad memset(io_work, 0, sizeof(struct qedf_io_work));
229461d8658bSDupuis, Chad
229561d8658bSDupuis, Chad INIT_WORK(&io_work->work, qedf_fp_io_handler);
229661d8658bSDupuis, Chad
229761d8658bSDupuis, Chad /* Copy contents of CQE for deferred processing */
229861d8658bSDupuis, Chad memcpy(&io_work->cqe, cqe, sizeof(struct fcoe_cqe));
229961d8658bSDupuis, Chad
230061d8658bSDupuis, Chad io_work->qedf = fp->qedf;
230161d8658bSDupuis, Chad io_work->fp = NULL; /* Only used for unsolicited frames */
230261d8658bSDupuis, Chad
230361d8658bSDupuis, Chad queue_work_on(cpu, qedf_io_wq, &io_work->work);
230461d8658bSDupuis, Chad
230561d8658bSDupuis, Chad inc_idx:
230661d8658bSDupuis, Chad que->cq_cons_idx++;
230761d8658bSDupuis, Chad if (que->cq_cons_idx == fp->cq_num_entries)
230861d8658bSDupuis, Chad que->cq_cons_idx = 0;
230961d8658bSDupuis, Chad new_cqes--;
231061d8658bSDupuis, Chad }
231161d8658bSDupuis, Chad
231261d8658bSDupuis, Chad return true;
231361d8658bSDupuis, Chad }
231461d8658bSDupuis, Chad
231561d8658bSDupuis, Chad
231661d8658bSDupuis, Chad /* MSI-X fastpath handler code */
qedf_msix_handler(int irq,void * dev_id)231761d8658bSDupuis, Chad static irqreturn_t qedf_msix_handler(int irq, void *dev_id)
231861d8658bSDupuis, Chad {
231961d8658bSDupuis, Chad struct qedf_fastpath *fp = dev_id;
232061d8658bSDupuis, Chad
232161d8658bSDupuis, Chad if (!fp) {
232261d8658bSDupuis, Chad QEDF_ERR(NULL, "fp is null.\n");
232361d8658bSDupuis, Chad return IRQ_HANDLED;
232461d8658bSDupuis, Chad }
232561d8658bSDupuis, Chad if (!fp->sb_info) {
232661d8658bSDupuis, Chad QEDF_ERR(NULL, "fp->sb_info in null.");
232761d8658bSDupuis, Chad return IRQ_HANDLED;
232861d8658bSDupuis, Chad }
232961d8658bSDupuis, Chad
233061d8658bSDupuis, Chad /*
233161d8658bSDupuis, Chad * Disable interrupts for this status block while we process new
233261d8658bSDupuis, Chad * completions
233361d8658bSDupuis, Chad */
233461d8658bSDupuis, Chad qed_sb_ack(fp->sb_info, IGU_INT_DISABLE, 0 /*do not update*/);
233561d8658bSDupuis, Chad
233661d8658bSDupuis, Chad while (1) {
233761d8658bSDupuis, Chad qedf_process_completions(fp);
233861d8658bSDupuis, Chad
233961d8658bSDupuis, Chad if (qedf_fp_has_work(fp) == 0) {
234061d8658bSDupuis, Chad /* Update the sb information */
234161d8658bSDupuis, Chad qed_sb_update_sb_idx(fp->sb_info);
234261d8658bSDupuis, Chad
234361d8658bSDupuis, Chad /* Check for more work */
234461d8658bSDupuis, Chad rmb();
234561d8658bSDupuis, Chad
234661d8658bSDupuis, Chad if (qedf_fp_has_work(fp) == 0) {
234761d8658bSDupuis, Chad /* Re-enable interrupts */
234861d8658bSDupuis, Chad qed_sb_ack(fp->sb_info, IGU_INT_ENABLE, 1);
234961d8658bSDupuis, Chad return IRQ_HANDLED;
235061d8658bSDupuis, Chad }
235161d8658bSDupuis, Chad }
235261d8658bSDupuis, Chad }
235361d8658bSDupuis, Chad
235461d8658bSDupuis, Chad /* Do we ever want to break out of above loop? */
235561d8658bSDupuis, Chad return IRQ_HANDLED;
235661d8658bSDupuis, Chad }
235761d8658bSDupuis, Chad
235861d8658bSDupuis, Chad /* simd handler for MSI/INTa */
qedf_simd_int_handler(void * cookie)235961d8658bSDupuis, Chad static void qedf_simd_int_handler(void *cookie)
236061d8658bSDupuis, Chad {
236161d8658bSDupuis, Chad /* Cookie is qedf_ctx struct */
236261d8658bSDupuis, Chad struct qedf_ctx *qedf = (struct qedf_ctx *)cookie;
236361d8658bSDupuis, Chad
236461d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "qedf=%p.\n", qedf);
236561d8658bSDupuis, Chad }
236661d8658bSDupuis, Chad
236761d8658bSDupuis, Chad #define QEDF_SIMD_HANDLER_NUM 0
qedf_sync_free_irqs(struct qedf_ctx * qedf)236861d8658bSDupuis, Chad static void qedf_sync_free_irqs(struct qedf_ctx *qedf)
236961d8658bSDupuis, Chad {
237061d8658bSDupuis, Chad int i;
2371a9b02c61SChad Dupuis u16 vector_idx = 0;
2372a9b02c61SChad Dupuis u32 vector;
237361d8658bSDupuis, Chad
237461d8658bSDupuis, Chad if (qedf->int_info.msix_cnt) {
237561d8658bSDupuis, Chad for (i = 0; i < qedf->int_info.used_cnt; i++) {
2376a9b02c61SChad Dupuis vector_idx = i * qedf->dev_info.common.num_hwfns +
2377a9b02c61SChad Dupuis qed_ops->common->get_affin_hwfn_idx(qedf->cdev);
2378a9b02c61SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
2379a9b02c61SChad Dupuis "Freeing IRQ #%d vector_idx=%d.\n",
2380a9b02c61SChad Dupuis i, vector_idx);
2381a9b02c61SChad Dupuis vector = qedf->int_info.msix[vector_idx].vector;
2382a9b02c61SChad Dupuis synchronize_irq(vector);
2383a9b02c61SChad Dupuis irq_set_affinity_hint(vector, NULL);
2384a9b02c61SChad Dupuis irq_set_affinity_notifier(vector, NULL);
2385a9b02c61SChad Dupuis free_irq(vector, &qedf->fp_array[i]);
238661d8658bSDupuis, Chad }
238761d8658bSDupuis, Chad } else
238861d8658bSDupuis, Chad qed_ops->common->simd_handler_clean(qedf->cdev,
238961d8658bSDupuis, Chad QEDF_SIMD_HANDLER_NUM);
239061d8658bSDupuis, Chad
239161d8658bSDupuis, Chad qedf->int_info.used_cnt = 0;
239261d8658bSDupuis, Chad qed_ops->common->set_fp_int(qedf->cdev, 0);
239361d8658bSDupuis, Chad }
239461d8658bSDupuis, Chad
qedf_request_msix_irq(struct qedf_ctx * qedf)239561d8658bSDupuis, Chad static int qedf_request_msix_irq(struct qedf_ctx *qedf)
239661d8658bSDupuis, Chad {
239761d8658bSDupuis, Chad int i, rc, cpu;
2398a9b02c61SChad Dupuis u16 vector_idx = 0;
2399a9b02c61SChad Dupuis u32 vector;
240061d8658bSDupuis, Chad
240161d8658bSDupuis, Chad cpu = cpumask_first(cpu_online_mask);
240261d8658bSDupuis, Chad for (i = 0; i < qedf->num_queues; i++) {
2403a9b02c61SChad Dupuis vector_idx = i * qedf->dev_info.common.num_hwfns +
2404a9b02c61SChad Dupuis qed_ops->common->get_affin_hwfn_idx(qedf->cdev);
2405a9b02c61SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
2406a9b02c61SChad Dupuis "Requesting IRQ #%d vector_idx=%d.\n",
2407a9b02c61SChad Dupuis i, vector_idx);
2408a9b02c61SChad Dupuis vector = qedf->int_info.msix[vector_idx].vector;
2409a9b02c61SChad Dupuis rc = request_irq(vector, qedf_msix_handler, 0, "qedf",
2410a9b02c61SChad Dupuis &qedf->fp_array[i]);
241161d8658bSDupuis, Chad
241261d8658bSDupuis, Chad if (rc) {
241361d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "request_irq failed.\n");
241461d8658bSDupuis, Chad qedf_sync_free_irqs(qedf);
241561d8658bSDupuis, Chad return rc;
241661d8658bSDupuis, Chad }
241761d8658bSDupuis, Chad
241861d8658bSDupuis, Chad qedf->int_info.used_cnt++;
2419a9b02c61SChad Dupuis rc = irq_set_affinity_hint(vector, get_cpu_mask(cpu));
242061d8658bSDupuis, Chad cpu = cpumask_next(cpu, cpu_online_mask);
242161d8658bSDupuis, Chad }
242261d8658bSDupuis, Chad
242361d8658bSDupuis, Chad return 0;
242461d8658bSDupuis, Chad }
242561d8658bSDupuis, Chad
qedf_setup_int(struct qedf_ctx * qedf)242661d8658bSDupuis, Chad static int qedf_setup_int(struct qedf_ctx *qedf)
242761d8658bSDupuis, Chad {
242861d8658bSDupuis, Chad int rc = 0;
242961d8658bSDupuis, Chad
243061d8658bSDupuis, Chad /*
243161d8658bSDupuis, Chad * Learn interrupt configuration
243261d8658bSDupuis, Chad */
243361d8658bSDupuis, Chad rc = qed_ops->common->set_fp_int(qedf->cdev, num_online_cpus());
2434914fff10SChad Dupuis if (rc <= 0)
2435914fff10SChad Dupuis return 0;
243661d8658bSDupuis, Chad
243761d8658bSDupuis, Chad rc = qed_ops->common->get_fp_int(qedf->cdev, &qedf->int_info);
243861d8658bSDupuis, Chad if (rc)
243961d8658bSDupuis, Chad return 0;
244061d8658bSDupuis, Chad
244161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Number of msix_cnt = "
244261d8658bSDupuis, Chad "0x%x num of cpus = 0x%x\n", qedf->int_info.msix_cnt,
244361d8658bSDupuis, Chad num_online_cpus());
244461d8658bSDupuis, Chad
244561d8658bSDupuis, Chad if (qedf->int_info.msix_cnt)
244661d8658bSDupuis, Chad return qedf_request_msix_irq(qedf);
244761d8658bSDupuis, Chad
244861d8658bSDupuis, Chad qed_ops->common->simd_handler_config(qedf->cdev, &qedf,
244961d8658bSDupuis, Chad QEDF_SIMD_HANDLER_NUM, qedf_simd_int_handler);
245061d8658bSDupuis, Chad qedf->int_info.used_cnt = 1;
245161d8658bSDupuis, Chad
2452078d7199SChad Dupuis QEDF_ERR(&qedf->dbg_ctx,
2453078d7199SChad Dupuis "Cannot load driver due to a lack of MSI-X vectors.\n");
245496673e1eSChad Dupuis return -EINVAL;
245561d8658bSDupuis, Chad }
245661d8658bSDupuis, Chad
245761d8658bSDupuis, Chad /* Main function for libfc frame reception */
qedf_recv_frame(struct qedf_ctx * qedf,struct sk_buff * skb)245861d8658bSDupuis, Chad static void qedf_recv_frame(struct qedf_ctx *qedf,
245961d8658bSDupuis, Chad struct sk_buff *skb)
246061d8658bSDupuis, Chad {
246161d8658bSDupuis, Chad u32 fr_len;
246261d8658bSDupuis, Chad struct fc_lport *lport;
246361d8658bSDupuis, Chad struct fc_frame_header *fh;
246461d8658bSDupuis, Chad struct fcoe_crc_eof crc_eof;
246561d8658bSDupuis, Chad struct fc_frame *fp;
246661d8658bSDupuis, Chad u8 *mac = NULL;
246761d8658bSDupuis, Chad u8 *dest_mac = NULL;
246861d8658bSDupuis, Chad struct fcoe_hdr *hp;
246961d8658bSDupuis, Chad struct qedf_rport *fcport;
2470384d5a9bSChad Dupuis struct fc_lport *vn_port;
2471384d5a9bSChad Dupuis u32 f_ctl;
247261d8658bSDupuis, Chad
247361d8658bSDupuis, Chad lport = qedf->lport;
247461d8658bSDupuis, Chad if (lport == NULL || lport->state == LPORT_ST_DISABLED) {
247561d8658bSDupuis, Chad QEDF_WARN(NULL, "Invalid lport struct or lport disabled.\n");
247661d8658bSDupuis, Chad kfree_skb(skb);
247761d8658bSDupuis, Chad return;
247861d8658bSDupuis, Chad }
247961d8658bSDupuis, Chad
248061d8658bSDupuis, Chad if (skb_is_nonlinear(skb))
248161d8658bSDupuis, Chad skb_linearize(skb);
248261d8658bSDupuis, Chad mac = eth_hdr(skb)->h_source;
248361d8658bSDupuis, Chad dest_mac = eth_hdr(skb)->h_dest;
248461d8658bSDupuis, Chad
248561d8658bSDupuis, Chad /* Pull the header */
248661d8658bSDupuis, Chad hp = (struct fcoe_hdr *)skb->data;
248761d8658bSDupuis, Chad fh = (struct fc_frame_header *) skb_transport_header(skb);
248861d8658bSDupuis, Chad skb_pull(skb, sizeof(struct fcoe_hdr));
248961d8658bSDupuis, Chad fr_len = skb->len - sizeof(struct fcoe_crc_eof);
249061d8658bSDupuis, Chad
249161d8658bSDupuis, Chad fp = (struct fc_frame *)skb;
249261d8658bSDupuis, Chad fc_frame_init(fp);
249361d8658bSDupuis, Chad fr_dev(fp) = lport;
249461d8658bSDupuis, Chad fr_sof(fp) = hp->fcoe_sof;
249561d8658bSDupuis, Chad if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof))) {
2496e82e6ff7SSaurav Kashyap QEDF_INFO(NULL, QEDF_LOG_LL2, "skb_copy_bits failed.\n");
249761d8658bSDupuis, Chad kfree_skb(skb);
249861d8658bSDupuis, Chad return;
249961d8658bSDupuis, Chad }
250061d8658bSDupuis, Chad fr_eof(fp) = crc_eof.fcoe_eof;
250161d8658bSDupuis, Chad fr_crc(fp) = crc_eof.fcoe_crc32;
250261d8658bSDupuis, Chad if (pskb_trim(skb, fr_len)) {
2503e82e6ff7SSaurav Kashyap QEDF_INFO(NULL, QEDF_LOG_LL2, "pskb_trim failed.\n");
250461d8658bSDupuis, Chad kfree_skb(skb);
250561d8658bSDupuis, Chad return;
250661d8658bSDupuis, Chad }
250761d8658bSDupuis, Chad
250861d8658bSDupuis, Chad fh = fc_frame_header_get(fp);
250961d8658bSDupuis, Chad
2510384d5a9bSChad Dupuis /*
2511384d5a9bSChad Dupuis * Invalid frame filters.
2512384d5a9bSChad Dupuis */
2513384d5a9bSChad Dupuis
251461d8658bSDupuis, Chad if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA &&
251561d8658bSDupuis, Chad fh->fh_type == FC_TYPE_FCP) {
251661d8658bSDupuis, Chad /* Drop FCP data. We dont this in L2 path */
251761d8658bSDupuis, Chad kfree_skb(skb);
251861d8658bSDupuis, Chad return;
251961d8658bSDupuis, Chad }
252061d8658bSDupuis, Chad if (fh->fh_r_ctl == FC_RCTL_ELS_REQ &&
252161d8658bSDupuis, Chad fh->fh_type == FC_TYPE_ELS) {
252261d8658bSDupuis, Chad switch (fc_frame_payload_op(fp)) {
252361d8658bSDupuis, Chad case ELS_LOGO:
252461d8658bSDupuis, Chad if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI) {
252561d8658bSDupuis, Chad /* drop non-FIP LOGO */
252661d8658bSDupuis, Chad kfree_skb(skb);
252761d8658bSDupuis, Chad return;
252861d8658bSDupuis, Chad }
252961d8658bSDupuis, Chad break;
253061d8658bSDupuis, Chad }
253161d8658bSDupuis, Chad }
253261d8658bSDupuis, Chad
253361d8658bSDupuis, Chad if (fh->fh_r_ctl == FC_RCTL_BA_ABTS) {
253461d8658bSDupuis, Chad /* Drop incoming ABTS */
253561d8658bSDupuis, Chad kfree_skb(skb);
253661d8658bSDupuis, Chad return;
253761d8658bSDupuis, Chad }
253861d8658bSDupuis, Chad
2539384d5a9bSChad Dupuis if (ntoh24(&dest_mac[3]) != ntoh24(fh->fh_d_id)) {
2540f7e8d57bSChad Dupuis QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2541f7e8d57bSChad Dupuis "FC frame d_id mismatch with MAC %pM.\n", dest_mac);
2542f32803bbSChad Dupuis kfree_skb(skb);
2543384d5a9bSChad Dupuis return;
2544384d5a9bSChad Dupuis }
2545384d5a9bSChad Dupuis
2546384d5a9bSChad Dupuis if (qedf->ctlr.state) {
2547384d5a9bSChad Dupuis if (!ether_addr_equal(mac, qedf->ctlr.dest_addr)) {
2548f7e8d57bSChad Dupuis QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2549f7e8d57bSChad Dupuis "Wrong source address: mac:%pM dest_addr:%pM.\n",
2550384d5a9bSChad Dupuis mac, qedf->ctlr.dest_addr);
2551384d5a9bSChad Dupuis kfree_skb(skb);
2552384d5a9bSChad Dupuis return;
2553384d5a9bSChad Dupuis }
2554384d5a9bSChad Dupuis }
2555384d5a9bSChad Dupuis
2556384d5a9bSChad Dupuis vn_port = fc_vport_id_lookup(lport, ntoh24(fh->fh_d_id));
2557384d5a9bSChad Dupuis
2558384d5a9bSChad Dupuis /*
2559384d5a9bSChad Dupuis * If the destination ID from the frame header does not match what we
2560384d5a9bSChad Dupuis * have on record for lport and the search for a NPIV port came up
2561384d5a9bSChad Dupuis * empty then this is not addressed to our port so simply drop it.
2562384d5a9bSChad Dupuis */
2563384d5a9bSChad Dupuis if (lport->port_id != ntoh24(fh->fh_d_id) && !vn_port) {
2564e82e6ff7SSaurav Kashyap QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2565e82e6ff7SSaurav Kashyap "Dropping frame due to destination mismatch: lport->port_id=0x%x fh->d_id=0x%x.\n",
2566384d5a9bSChad Dupuis lport->port_id, ntoh24(fh->fh_d_id));
2567384d5a9bSChad Dupuis kfree_skb(skb);
2568384d5a9bSChad Dupuis return;
2569384d5a9bSChad Dupuis }
2570384d5a9bSChad Dupuis
2571384d5a9bSChad Dupuis f_ctl = ntoh24(fh->fh_f_ctl);
2572384d5a9bSChad Dupuis if ((fh->fh_type == FC_TYPE_BLS) && (f_ctl & FC_FC_SEQ_CTX) &&
2573384d5a9bSChad Dupuis (f_ctl & FC_FC_EX_CTX)) {
2574384d5a9bSChad Dupuis /* Drop incoming ABTS response that has both SEQ/EX CTX set */
2575e82e6ff7SSaurav Kashyap QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2576e82e6ff7SSaurav Kashyap "Dropping ABTS response as both SEQ/EX CTX set.\n");
2577384d5a9bSChad Dupuis kfree_skb(skb);
2578384d5a9bSChad Dupuis return;
2579384d5a9bSChad Dupuis }
2580384d5a9bSChad Dupuis
258161d8658bSDupuis, Chad /*
258261d8658bSDupuis, Chad * If a connection is uploading, drop incoming FCoE frames as there
258361d8658bSDupuis, Chad * is a small window where we could try to return a frame while libfc
258461d8658bSDupuis, Chad * is trying to clean things up.
258561d8658bSDupuis, Chad */
258661d8658bSDupuis, Chad
258761d8658bSDupuis, Chad /* Get fcport associated with d_id if it exists */
258861d8658bSDupuis, Chad fcport = qedf_fcport_lookup(qedf, ntoh24(fh->fh_d_id));
258961d8658bSDupuis, Chad
259061d8658bSDupuis, Chad if (fcport && test_bit(QEDF_RPORT_UPLOADING_CONNECTION,
259161d8658bSDupuis, Chad &fcport->flags)) {
259261d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
259361d8658bSDupuis, Chad "Connection uploading, dropping fp=%p.\n", fp);
259461d8658bSDupuis, Chad kfree_skb(skb);
259561d8658bSDupuis, Chad return;
259661d8658bSDupuis, Chad }
259761d8658bSDupuis, Chad
259861d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FCoE frame receive: "
259961d8658bSDupuis, Chad "skb=%p fp=%p src=%06x dest=%06x r_ctl=%x fh_type=%x.\n", skb, fp,
260061d8658bSDupuis, Chad ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id), fh->fh_r_ctl,
260161d8658bSDupuis, Chad fh->fh_type);
260261d8658bSDupuis, Chad if (qedf_dump_frames)
260361d8658bSDupuis, Chad print_hex_dump(KERN_WARNING, "fcoe: ", DUMP_PREFIX_OFFSET, 16,
260461d8658bSDupuis, Chad 1, skb->data, skb->len, false);
260561d8658bSDupuis, Chad fc_exch_recv(lport, fp);
260661d8658bSDupuis, Chad }
260761d8658bSDupuis, Chad
qedf_ll2_process_skb(struct work_struct * work)260861d8658bSDupuis, Chad static void qedf_ll2_process_skb(struct work_struct *work)
260961d8658bSDupuis, Chad {
261061d8658bSDupuis, Chad struct qedf_skb_work *skb_work =
261161d8658bSDupuis, Chad container_of(work, struct qedf_skb_work, work);
261261d8658bSDupuis, Chad struct qedf_ctx *qedf = skb_work->qedf;
261361d8658bSDupuis, Chad struct sk_buff *skb = skb_work->skb;
261461d8658bSDupuis, Chad struct ethhdr *eh;
261561d8658bSDupuis, Chad
261661d8658bSDupuis, Chad if (!qedf) {
261761d8658bSDupuis, Chad QEDF_ERR(NULL, "qedf is NULL\n");
261861d8658bSDupuis, Chad goto err_out;
261961d8658bSDupuis, Chad }
262061d8658bSDupuis, Chad
262161d8658bSDupuis, Chad eh = (struct ethhdr *)skb->data;
262261d8658bSDupuis, Chad
262361d8658bSDupuis, Chad /* Undo VLAN encapsulation */
262461d8658bSDupuis, Chad if (eh->h_proto == htons(ETH_P_8021Q)) {
262561d8658bSDupuis, Chad memmove((u8 *)eh + VLAN_HLEN, eh, ETH_ALEN * 2);
2626af72868bSJohannes Berg eh = skb_pull(skb, VLAN_HLEN);
262761d8658bSDupuis, Chad skb_reset_mac_header(skb);
262861d8658bSDupuis, Chad }
262961d8658bSDupuis, Chad
263061d8658bSDupuis, Chad /*
263161d8658bSDupuis, Chad * Process either a FIP frame or FCoE frame based on the
263261d8658bSDupuis, Chad * protocol value. If it's not either just drop the
263361d8658bSDupuis, Chad * frame.
263461d8658bSDupuis, Chad */
263561d8658bSDupuis, Chad if (eh->h_proto == htons(ETH_P_FIP)) {
263661d8658bSDupuis, Chad qedf_fip_recv(qedf, skb);
263761d8658bSDupuis, Chad goto out;
263861d8658bSDupuis, Chad } else if (eh->h_proto == htons(ETH_P_FCOE)) {
263961d8658bSDupuis, Chad __skb_pull(skb, ETH_HLEN);
264061d8658bSDupuis, Chad qedf_recv_frame(qedf, skb);
264161d8658bSDupuis, Chad goto out;
264261d8658bSDupuis, Chad } else
264361d8658bSDupuis, Chad goto err_out;
264461d8658bSDupuis, Chad
264561d8658bSDupuis, Chad err_out:
264661d8658bSDupuis, Chad kfree_skb(skb);
264761d8658bSDupuis, Chad out:
264861d8658bSDupuis, Chad kfree(skb_work);
264961d8658bSDupuis, Chad return;
265061d8658bSDupuis, Chad }
265161d8658bSDupuis, Chad
qedf_ll2_rx(void * cookie,struct sk_buff * skb,u32 arg1,u32 arg2)265261d8658bSDupuis, Chad static int qedf_ll2_rx(void *cookie, struct sk_buff *skb,
265361d8658bSDupuis, Chad u32 arg1, u32 arg2)
265461d8658bSDupuis, Chad {
265561d8658bSDupuis, Chad struct qedf_ctx *qedf = (struct qedf_ctx *)cookie;
265661d8658bSDupuis, Chad struct qedf_skb_work *skb_work;
265761d8658bSDupuis, Chad
265876dbf4ffSSaurav Kashyap if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
265976dbf4ffSSaurav Kashyap QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
266076dbf4ffSSaurav Kashyap "Dropping frame as link state is down.\n");
266176dbf4ffSSaurav Kashyap kfree_skb(skb);
266276dbf4ffSSaurav Kashyap return 0;
266376dbf4ffSSaurav Kashyap }
266476dbf4ffSSaurav Kashyap
266561d8658bSDupuis, Chad skb_work = kzalloc(sizeof(struct qedf_skb_work), GFP_ATOMIC);
266661d8658bSDupuis, Chad if (!skb_work) {
266761d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate skb_work so "
266861d8658bSDupuis, Chad "dropping frame.\n");
266961d8658bSDupuis, Chad kfree_skb(skb);
267061d8658bSDupuis, Chad return 0;
267161d8658bSDupuis, Chad }
267261d8658bSDupuis, Chad
267361d8658bSDupuis, Chad INIT_WORK(&skb_work->work, qedf_ll2_process_skb);
267461d8658bSDupuis, Chad skb_work->skb = skb;
267561d8658bSDupuis, Chad skb_work->qedf = qedf;
267661d8658bSDupuis, Chad queue_work(qedf->ll2_recv_wq, &skb_work->work);
267761d8658bSDupuis, Chad
267861d8658bSDupuis, Chad return 0;
267961d8658bSDupuis, Chad }
268061d8658bSDupuis, Chad
268161d8658bSDupuis, Chad static struct qed_ll2_cb_ops qedf_ll2_cb_ops = {
268261d8658bSDupuis, Chad .rx_cb = qedf_ll2_rx,
268361d8658bSDupuis, Chad .tx_cb = NULL,
268461d8658bSDupuis, Chad };
268561d8658bSDupuis, Chad
268661d8658bSDupuis, Chad /* Main thread to process I/O completions */
qedf_fp_io_handler(struct work_struct * work)268761d8658bSDupuis, Chad void qedf_fp_io_handler(struct work_struct *work)
268861d8658bSDupuis, Chad {
268961d8658bSDupuis, Chad struct qedf_io_work *io_work =
269061d8658bSDupuis, Chad container_of(work, struct qedf_io_work, work);
269161d8658bSDupuis, Chad u32 comp_type;
269261d8658bSDupuis, Chad
269361d8658bSDupuis, Chad /*
269461d8658bSDupuis, Chad * Deferred part of unsolicited CQE sends
269561d8658bSDupuis, Chad * frame to libfc.
269661d8658bSDupuis, Chad */
269761d8658bSDupuis, Chad comp_type = (io_work->cqe.cqe_data >>
269861d8658bSDupuis, Chad FCOE_CQE_CQE_TYPE_SHIFT) &
269961d8658bSDupuis, Chad FCOE_CQE_CQE_TYPE_MASK;
270061d8658bSDupuis, Chad if (comp_type == FCOE_UNSOLIC_CQE_TYPE &&
270161d8658bSDupuis, Chad io_work->fp)
270261d8658bSDupuis, Chad fc_exch_recv(io_work->qedf->lport, io_work->fp);
270361d8658bSDupuis, Chad else
270461d8658bSDupuis, Chad qedf_process_cqe(io_work->qedf, &io_work->cqe);
270561d8658bSDupuis, Chad
270661d8658bSDupuis, Chad kfree(io_work);
270761d8658bSDupuis, Chad }
270861d8658bSDupuis, Chad
qedf_alloc_and_init_sb(struct qedf_ctx * qedf,struct qed_sb_info * sb_info,u16 sb_id)270961d8658bSDupuis, Chad static int qedf_alloc_and_init_sb(struct qedf_ctx *qedf,
271061d8658bSDupuis, Chad struct qed_sb_info *sb_info, u16 sb_id)
271161d8658bSDupuis, Chad {
2712fb09a1edSShai Malin struct status_block *sb_virt;
271361d8658bSDupuis, Chad dma_addr_t sb_phys;
271461d8658bSDupuis, Chad int ret;
271561d8658bSDupuis, Chad
271661d8658bSDupuis, Chad sb_virt = dma_alloc_coherent(&qedf->pdev->dev,
2717fb09a1edSShai Malin sizeof(struct status_block), &sb_phys, GFP_KERNEL);
271861d8658bSDupuis, Chad
271961d8658bSDupuis, Chad if (!sb_virt) {
2720e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
2721e82e6ff7SSaurav Kashyap "Status block allocation failed for id = %d.\n",
2722e82e6ff7SSaurav Kashyap sb_id);
272361d8658bSDupuis, Chad return -ENOMEM;
272461d8658bSDupuis, Chad }
272561d8658bSDupuis, Chad
272661d8658bSDupuis, Chad ret = qed_ops->common->sb_init(qedf->cdev, sb_info, sb_virt, sb_phys,
272761d8658bSDupuis, Chad sb_id, QED_SB_TYPE_STORAGE);
272861d8658bSDupuis, Chad
272961d8658bSDupuis, Chad if (ret) {
2730e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
2731e82e6ff7SSaurav Kashyap "Status block initialization failed (0x%x) for id = %d.\n",
2732e82e6ff7SSaurav Kashyap ret, sb_id);
273361d8658bSDupuis, Chad return ret;
273461d8658bSDupuis, Chad }
273561d8658bSDupuis, Chad
273661d8658bSDupuis, Chad return 0;
273761d8658bSDupuis, Chad }
273861d8658bSDupuis, Chad
qedf_free_sb(struct qedf_ctx * qedf,struct qed_sb_info * sb_info)273961d8658bSDupuis, Chad static void qedf_free_sb(struct qedf_ctx *qedf, struct qed_sb_info *sb_info)
274061d8658bSDupuis, Chad {
274161d8658bSDupuis, Chad if (sb_info->sb_virt)
274261d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, sizeof(*sb_info->sb_virt),
274361d8658bSDupuis, Chad (void *)sb_info->sb_virt, sb_info->sb_phys);
274461d8658bSDupuis, Chad }
274561d8658bSDupuis, Chad
qedf_destroy_sb(struct qedf_ctx * qedf)274661d8658bSDupuis, Chad static void qedf_destroy_sb(struct qedf_ctx *qedf)
274761d8658bSDupuis, Chad {
274861d8658bSDupuis, Chad int id;
274961d8658bSDupuis, Chad struct qedf_fastpath *fp = NULL;
275061d8658bSDupuis, Chad
275161d8658bSDupuis, Chad for (id = 0; id < qedf->num_queues; id++) {
275261d8658bSDupuis, Chad fp = &(qedf->fp_array[id]);
275361d8658bSDupuis, Chad if (fp->sb_id == QEDF_SB_ID_NULL)
275461d8658bSDupuis, Chad break;
275561d8658bSDupuis, Chad qedf_free_sb(qedf, fp->sb_info);
275661d8658bSDupuis, Chad kfree(fp->sb_info);
275761d8658bSDupuis, Chad }
275861d8658bSDupuis, Chad kfree(qedf->fp_array);
275961d8658bSDupuis, Chad }
276061d8658bSDupuis, Chad
qedf_prepare_sb(struct qedf_ctx * qedf)276161d8658bSDupuis, Chad static int qedf_prepare_sb(struct qedf_ctx *qedf)
276261d8658bSDupuis, Chad {
276361d8658bSDupuis, Chad int id;
276461d8658bSDupuis, Chad struct qedf_fastpath *fp;
276561d8658bSDupuis, Chad int ret;
276661d8658bSDupuis, Chad
276761d8658bSDupuis, Chad qedf->fp_array =
276861d8658bSDupuis, Chad kcalloc(qedf->num_queues, sizeof(struct qedf_fastpath),
276961d8658bSDupuis, Chad GFP_KERNEL);
277061d8658bSDupuis, Chad
277161d8658bSDupuis, Chad if (!qedf->fp_array) {
277261d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "fastpath array allocation "
277361d8658bSDupuis, Chad "failed.\n");
277461d8658bSDupuis, Chad return -ENOMEM;
277561d8658bSDupuis, Chad }
277661d8658bSDupuis, Chad
277761d8658bSDupuis, Chad for (id = 0; id < qedf->num_queues; id++) {
277861d8658bSDupuis, Chad fp = &(qedf->fp_array[id]);
277961d8658bSDupuis, Chad fp->sb_id = QEDF_SB_ID_NULL;
278061d8658bSDupuis, Chad fp->sb_info = kcalloc(1, sizeof(*fp->sb_info), GFP_KERNEL);
278161d8658bSDupuis, Chad if (!fp->sb_info) {
278261d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "SB info struct "
278361d8658bSDupuis, Chad "allocation failed.\n");
278461d8658bSDupuis, Chad goto err;
278561d8658bSDupuis, Chad }
278661d8658bSDupuis, Chad ret = qedf_alloc_and_init_sb(qedf, fp->sb_info, id);
278761d8658bSDupuis, Chad if (ret) {
278861d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "SB allocation and "
278961d8658bSDupuis, Chad "initialization failed.\n");
279061d8658bSDupuis, Chad goto err;
279161d8658bSDupuis, Chad }
279261d8658bSDupuis, Chad fp->sb_id = id;
279361d8658bSDupuis, Chad fp->qedf = qedf;
279461d8658bSDupuis, Chad fp->cq_num_entries =
279561d8658bSDupuis, Chad qedf->global_queues[id]->cq_mem_size /
279661d8658bSDupuis, Chad sizeof(struct fcoe_cqe);
279761d8658bSDupuis, Chad }
279861d8658bSDupuis, Chad err:
279961d8658bSDupuis, Chad return 0;
280061d8658bSDupuis, Chad }
280161d8658bSDupuis, Chad
qedf_process_cqe(struct qedf_ctx * qedf,struct fcoe_cqe * cqe)280261d8658bSDupuis, Chad void qedf_process_cqe(struct qedf_ctx *qedf, struct fcoe_cqe *cqe)
280361d8658bSDupuis, Chad {
280461d8658bSDupuis, Chad u16 xid;
280561d8658bSDupuis, Chad struct qedf_ioreq *io_req;
280661d8658bSDupuis, Chad struct qedf_rport *fcport;
280761d8658bSDupuis, Chad u32 comp_type;
2808*7df0b260SJaved Hasan u8 io_comp_type;
2809*7df0b260SJaved Hasan unsigned long flags;
281061d8658bSDupuis, Chad
281161d8658bSDupuis, Chad comp_type = (cqe->cqe_data >> FCOE_CQE_CQE_TYPE_SHIFT) &
281261d8658bSDupuis, Chad FCOE_CQE_CQE_TYPE_MASK;
281361d8658bSDupuis, Chad
281461d8658bSDupuis, Chad xid = cqe->cqe_data & FCOE_CQE_TASK_ID_MASK;
281561d8658bSDupuis, Chad io_req = &qedf->cmd_mgr->cmds[xid];
281661d8658bSDupuis, Chad
281761d8658bSDupuis, Chad /* Completion not for a valid I/O anymore so just return */
2818e82e6ff7SSaurav Kashyap if (!io_req) {
2819e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
2820e82e6ff7SSaurav Kashyap "io_req is NULL for xid=0x%x.\n", xid);
282161d8658bSDupuis, Chad return;
2822e82e6ff7SSaurav Kashyap }
282361d8658bSDupuis, Chad
282461d8658bSDupuis, Chad fcport = io_req->fcport;
282561d8658bSDupuis, Chad
282661d8658bSDupuis, Chad if (fcport == NULL) {
2827e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
2828e82e6ff7SSaurav Kashyap "fcport is NULL for xid=0x%x io_req=%p.\n",
2829e82e6ff7SSaurav Kashyap xid, io_req);
283061d8658bSDupuis, Chad return;
283161d8658bSDupuis, Chad }
283261d8658bSDupuis, Chad
283361d8658bSDupuis, Chad /*
283461d8658bSDupuis, Chad * Check that fcport is offloaded. If it isn't then the spinlock
283561d8658bSDupuis, Chad * isn't valid and shouldn't be taken. We should just return.
283661d8658bSDupuis, Chad */
283761d8658bSDupuis, Chad if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
2838e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
2839e82e6ff7SSaurav Kashyap "Session not offloaded yet, fcport = %p.\n", fcport);
284061d8658bSDupuis, Chad return;
284161d8658bSDupuis, Chad }
284261d8658bSDupuis, Chad
2843*7df0b260SJaved Hasan spin_lock_irqsave(&fcport->rport_lock, flags);
2844*7df0b260SJaved Hasan io_comp_type = io_req->cmd_type;
2845*7df0b260SJaved Hasan spin_unlock_irqrestore(&fcport->rport_lock, flags);
284661d8658bSDupuis, Chad
284761d8658bSDupuis, Chad switch (comp_type) {
284861d8658bSDupuis, Chad case FCOE_GOOD_COMPLETION_CQE_TYPE:
284961d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
2850*7df0b260SJaved Hasan switch (io_comp_type) {
285161d8658bSDupuis, Chad case QEDF_SCSI_CMD:
285261d8658bSDupuis, Chad qedf_scsi_completion(qedf, cqe, io_req);
285361d8658bSDupuis, Chad break;
285461d8658bSDupuis, Chad case QEDF_ELS:
285561d8658bSDupuis, Chad qedf_process_els_compl(qedf, cqe, io_req);
285661d8658bSDupuis, Chad break;
285761d8658bSDupuis, Chad case QEDF_TASK_MGMT_CMD:
285861d8658bSDupuis, Chad qedf_process_tmf_compl(qedf, cqe, io_req);
285961d8658bSDupuis, Chad break;
286061d8658bSDupuis, Chad case QEDF_SEQ_CLEANUP:
286161d8658bSDupuis, Chad qedf_process_seq_cleanup_compl(qedf, cqe, io_req);
286261d8658bSDupuis, Chad break;
286361d8658bSDupuis, Chad }
286461d8658bSDupuis, Chad break;
286561d8658bSDupuis, Chad case FCOE_ERROR_DETECTION_CQE_TYPE:
286661d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
286761d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
286861d8658bSDupuis, Chad "Error detect CQE.\n");
286961d8658bSDupuis, Chad qedf_process_error_detect(qedf, cqe, io_req);
287061d8658bSDupuis, Chad break;
287161d8658bSDupuis, Chad case FCOE_EXCH_CLEANUP_CQE_TYPE:
287261d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
287361d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
287461d8658bSDupuis, Chad "Cleanup CQE.\n");
287561d8658bSDupuis, Chad qedf_process_cleanup_compl(qedf, cqe, io_req);
287661d8658bSDupuis, Chad break;
287761d8658bSDupuis, Chad case FCOE_ABTS_CQE_TYPE:
287861d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
287961d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
288061d8658bSDupuis, Chad "Abort CQE.\n");
288161d8658bSDupuis, Chad qedf_process_abts_compl(qedf, cqe, io_req);
288261d8658bSDupuis, Chad break;
288361d8658bSDupuis, Chad case FCOE_DUMMY_CQE_TYPE:
288461d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
288561d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
288661d8658bSDupuis, Chad "Dummy CQE.\n");
288761d8658bSDupuis, Chad break;
288861d8658bSDupuis, Chad case FCOE_LOCAL_COMP_CQE_TYPE:
288961d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
289061d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
289161d8658bSDupuis, Chad "Local completion CQE.\n");
289261d8658bSDupuis, Chad break;
289361d8658bSDupuis, Chad case FCOE_WARNING_CQE_TYPE:
289461d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
289561d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
289661d8658bSDupuis, Chad "Warning CQE.\n");
289761d8658bSDupuis, Chad qedf_process_warning_compl(qedf, cqe, io_req);
289861d8658bSDupuis, Chad break;
289961d8658bSDupuis, Chad case MAX_FCOE_CQE_TYPE:
290061d8658bSDupuis, Chad atomic_inc(&fcport->free_sqes);
290161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
290261d8658bSDupuis, Chad "Max FCoE CQE.\n");
290361d8658bSDupuis, Chad break;
290461d8658bSDupuis, Chad default:
290561d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
290661d8658bSDupuis, Chad "Default CQE.\n");
290761d8658bSDupuis, Chad break;
290861d8658bSDupuis, Chad }
290961d8658bSDupuis, Chad }
291061d8658bSDupuis, Chad
qedf_free_bdq(struct qedf_ctx * qedf)291161d8658bSDupuis, Chad static void qedf_free_bdq(struct qedf_ctx *qedf)
291261d8658bSDupuis, Chad {
291361d8658bSDupuis, Chad int i;
291461d8658bSDupuis, Chad
291561d8658bSDupuis, Chad if (qedf->bdq_pbl_list)
291661d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, QEDF_PAGE_SIZE,
291761d8658bSDupuis, Chad qedf->bdq_pbl_list, qedf->bdq_pbl_list_dma);
291861d8658bSDupuis, Chad
291961d8658bSDupuis, Chad if (qedf->bdq_pbl)
292061d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, qedf->bdq_pbl_mem_size,
292161d8658bSDupuis, Chad qedf->bdq_pbl, qedf->bdq_pbl_dma);
292261d8658bSDupuis, Chad
292361d8658bSDupuis, Chad for (i = 0; i < QEDF_BDQ_SIZE; i++) {
292461d8658bSDupuis, Chad if (qedf->bdq[i].buf_addr) {
292561d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, QEDF_BDQ_BUF_SIZE,
292661d8658bSDupuis, Chad qedf->bdq[i].buf_addr, qedf->bdq[i].buf_dma);
292761d8658bSDupuis, Chad }
292861d8658bSDupuis, Chad }
292961d8658bSDupuis, Chad }
293061d8658bSDupuis, Chad
qedf_free_global_queues(struct qedf_ctx * qedf)293161d8658bSDupuis, Chad static void qedf_free_global_queues(struct qedf_ctx *qedf)
293261d8658bSDupuis, Chad {
293361d8658bSDupuis, Chad int i;
293461d8658bSDupuis, Chad struct global_queue **gl = qedf->global_queues;
293561d8658bSDupuis, Chad
293661d8658bSDupuis, Chad for (i = 0; i < qedf->num_queues; i++) {
293761d8658bSDupuis, Chad if (!gl[i])
293861d8658bSDupuis, Chad continue;
293961d8658bSDupuis, Chad
294061d8658bSDupuis, Chad if (gl[i]->cq)
294161d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev,
294261d8658bSDupuis, Chad gl[i]->cq_mem_size, gl[i]->cq, gl[i]->cq_dma);
294361d8658bSDupuis, Chad if (gl[i]->cq_pbl)
294461d8658bSDupuis, Chad dma_free_coherent(&qedf->pdev->dev, gl[i]->cq_pbl_size,
294561d8658bSDupuis, Chad gl[i]->cq_pbl, gl[i]->cq_pbl_dma);
294661d8658bSDupuis, Chad
294761d8658bSDupuis, Chad kfree(gl[i]);
294861d8658bSDupuis, Chad }
294961d8658bSDupuis, Chad
295061d8658bSDupuis, Chad qedf_free_bdq(qedf);
295161d8658bSDupuis, Chad }
295261d8658bSDupuis, Chad
qedf_alloc_bdq(struct qedf_ctx * qedf)295361d8658bSDupuis, Chad static int qedf_alloc_bdq(struct qedf_ctx *qedf)
295461d8658bSDupuis, Chad {
295561d8658bSDupuis, Chad int i;
295661d8658bSDupuis, Chad struct scsi_bd *pbl;
295761d8658bSDupuis, Chad u64 *list;
295861d8658bSDupuis, Chad
295961d8658bSDupuis, Chad /* Alloc dma memory for BDQ buffers */
296061d8658bSDupuis, Chad for (i = 0; i < QEDF_BDQ_SIZE; i++) {
296161d8658bSDupuis, Chad qedf->bdq[i].buf_addr = dma_alloc_coherent(&qedf->pdev->dev,
296261d8658bSDupuis, Chad QEDF_BDQ_BUF_SIZE, &qedf->bdq[i].buf_dma, GFP_KERNEL);
296361d8658bSDupuis, Chad if (!qedf->bdq[i].buf_addr) {
296461d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate BDQ "
296561d8658bSDupuis, Chad "buffer %d.\n", i);
296661d8658bSDupuis, Chad return -ENOMEM;
296761d8658bSDupuis, Chad }
296861d8658bSDupuis, Chad }
296961d8658bSDupuis, Chad
297061d8658bSDupuis, Chad /* Alloc dma memory for BDQ page buffer list */
297161d8658bSDupuis, Chad qedf->bdq_pbl_mem_size =
297261d8658bSDupuis, Chad QEDF_BDQ_SIZE * sizeof(struct scsi_bd);
297361d8658bSDupuis, Chad qedf->bdq_pbl_mem_size =
297461d8658bSDupuis, Chad ALIGN(qedf->bdq_pbl_mem_size, QEDF_PAGE_SIZE);
297561d8658bSDupuis, Chad
297661d8658bSDupuis, Chad qedf->bdq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
297761d8658bSDupuis, Chad qedf->bdq_pbl_mem_size, &qedf->bdq_pbl_dma, GFP_KERNEL);
297861d8658bSDupuis, Chad if (!qedf->bdq_pbl) {
297961d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate BDQ PBL.\n");
298061d8658bSDupuis, Chad return -ENOMEM;
298161d8658bSDupuis, Chad }
298261d8658bSDupuis, Chad
298361d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
2984fd2b18b4SJoe Perches "BDQ PBL addr=0x%p dma=%pad\n",
2985fd2b18b4SJoe Perches qedf->bdq_pbl, &qedf->bdq_pbl_dma);
298661d8658bSDupuis, Chad
298761d8658bSDupuis, Chad /*
298861d8658bSDupuis, Chad * Populate BDQ PBL with physical and virtual address of individual
298961d8658bSDupuis, Chad * BDQ buffers
299061d8658bSDupuis, Chad */
299161d8658bSDupuis, Chad pbl = (struct scsi_bd *)qedf->bdq_pbl;
299261d8658bSDupuis, Chad for (i = 0; i < QEDF_BDQ_SIZE; i++) {
299361d8658bSDupuis, Chad pbl->address.hi = cpu_to_le32(U64_HI(qedf->bdq[i].buf_dma));
299461d8658bSDupuis, Chad pbl->address.lo = cpu_to_le32(U64_LO(qedf->bdq[i].buf_dma));
2995da090917STomer Tayar pbl->opaque.fcoe_opaque.hi = 0;
299661d8658bSDupuis, Chad /* Opaque lo data is an index into the BDQ array */
2997da090917STomer Tayar pbl->opaque.fcoe_opaque.lo = cpu_to_le32(i);
299861d8658bSDupuis, Chad pbl++;
299961d8658bSDupuis, Chad }
300061d8658bSDupuis, Chad
300161d8658bSDupuis, Chad /* Allocate list of PBL pages */
3002750afb08SLuis Chamberlain qedf->bdq_pbl_list = dma_alloc_coherent(&qedf->pdev->dev,
3003750afb08SLuis Chamberlain QEDF_PAGE_SIZE,
3004750afb08SLuis Chamberlain &qedf->bdq_pbl_list_dma,
3005750afb08SLuis Chamberlain GFP_KERNEL);
300661d8658bSDupuis, Chad if (!qedf->bdq_pbl_list) {
300732eebb31SChristophe JAILLET QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate list of PBL pages.\n");
300861d8658bSDupuis, Chad return -ENOMEM;
300961d8658bSDupuis, Chad }
301061d8658bSDupuis, Chad
301161d8658bSDupuis, Chad /*
301261d8658bSDupuis, Chad * Now populate PBL list with pages that contain pointers to the
301361d8658bSDupuis, Chad * individual buffers.
301461d8658bSDupuis, Chad */
301561d8658bSDupuis, Chad qedf->bdq_pbl_list_num_entries = qedf->bdq_pbl_mem_size /
301661d8658bSDupuis, Chad QEDF_PAGE_SIZE;
301761d8658bSDupuis, Chad list = (u64 *)qedf->bdq_pbl_list;
301861d8658bSDupuis, Chad for (i = 0; i < qedf->bdq_pbl_list_num_entries; i++) {
301961d8658bSDupuis, Chad *list = qedf->bdq_pbl_dma;
302061d8658bSDupuis, Chad list++;
302161d8658bSDupuis, Chad }
302261d8658bSDupuis, Chad
302361d8658bSDupuis, Chad return 0;
302461d8658bSDupuis, Chad }
302561d8658bSDupuis, Chad
qedf_alloc_global_queues(struct qedf_ctx * qedf)302661d8658bSDupuis, Chad static int qedf_alloc_global_queues(struct qedf_ctx *qedf)
302761d8658bSDupuis, Chad {
302861d8658bSDupuis, Chad u32 *list;
302961d8658bSDupuis, Chad int i;
3030ccc89737SDan Carpenter int status;
303161d8658bSDupuis, Chad u32 *pbl;
303261d8658bSDupuis, Chad dma_addr_t page;
303361d8658bSDupuis, Chad int num_pages;
303461d8658bSDupuis, Chad
303561d8658bSDupuis, Chad /* Allocate and map CQs, RQs */
303661d8658bSDupuis, Chad /*
303761d8658bSDupuis, Chad * Number of global queues (CQ / RQ). This should
303861d8658bSDupuis, Chad * be <= number of available MSIX vectors for the PF
303961d8658bSDupuis, Chad */
304061d8658bSDupuis, Chad if (!qedf->num_queues) {
304161d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "No MSI-X vectors available!\n");
3042ccc89737SDan Carpenter return -ENOMEM;
304361d8658bSDupuis, Chad }
304461d8658bSDupuis, Chad
304561d8658bSDupuis, Chad /*
304661d8658bSDupuis, Chad * Make sure we allocated the PBL that will contain the physical
304761d8658bSDupuis, Chad * addresses of our queues
304861d8658bSDupuis, Chad */
304961d8658bSDupuis, Chad if (!qedf->p_cpuq) {
3050e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "p_cpuq is NULL.\n");
3051f025312bSJinhong Zhu return -EINVAL;
305261d8658bSDupuis, Chad }
305361d8658bSDupuis, Chad
305461d8658bSDupuis, Chad qedf->global_queues = kzalloc((sizeof(struct global_queue *)
305561d8658bSDupuis, Chad * qedf->num_queues), GFP_KERNEL);
305661d8658bSDupuis, Chad if (!qedf->global_queues) {
305761d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Unable to allocate global "
305861d8658bSDupuis, Chad "queues array ptr memory\n");
305961d8658bSDupuis, Chad return -ENOMEM;
306061d8658bSDupuis, Chad }
306161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
306261d8658bSDupuis, Chad "qedf->global_queues=%p.\n", qedf->global_queues);
306361d8658bSDupuis, Chad
306461d8658bSDupuis, Chad /* Allocate DMA coherent buffers for BDQ */
3065ccc89737SDan Carpenter status = qedf_alloc_bdq(qedf);
3066ccc89737SDan Carpenter if (status) {
3067e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "Unable to allocate bdq.\n");
306861d8658bSDupuis, Chad goto mem_alloc_failure;
3069e82e6ff7SSaurav Kashyap }
307061d8658bSDupuis, Chad
307161d8658bSDupuis, Chad /* Allocate a CQ and an associated PBL for each MSI-X vector */
307261d8658bSDupuis, Chad for (i = 0; i < qedf->num_queues; i++) {
307361d8658bSDupuis, Chad qedf->global_queues[i] = kzalloc(sizeof(struct global_queue),
307461d8658bSDupuis, Chad GFP_KERNEL);
307561d8658bSDupuis, Chad if (!qedf->global_queues[i]) {
30763a240b21SChristophe JAILLET QEDF_WARN(&(qedf->dbg_ctx), "Unable to allocate "
307761d8658bSDupuis, Chad "global queue %d.\n", i);
30783a240b21SChristophe JAILLET status = -ENOMEM;
307961d8658bSDupuis, Chad goto mem_alloc_failure;
308061d8658bSDupuis, Chad }
308161d8658bSDupuis, Chad
308261d8658bSDupuis, Chad qedf->global_queues[i]->cq_mem_size =
308361d8658bSDupuis, Chad FCOE_PARAMS_CQ_NUM_ENTRIES * sizeof(struct fcoe_cqe);
308461d8658bSDupuis, Chad qedf->global_queues[i]->cq_mem_size =
308561d8658bSDupuis, Chad ALIGN(qedf->global_queues[i]->cq_mem_size, QEDF_PAGE_SIZE);
308661d8658bSDupuis, Chad
308761d8658bSDupuis, Chad qedf->global_queues[i]->cq_pbl_size =
308861d8658bSDupuis, Chad (qedf->global_queues[i]->cq_mem_size /
308961d8658bSDupuis, Chad PAGE_SIZE) * sizeof(void *);
309061d8658bSDupuis, Chad qedf->global_queues[i]->cq_pbl_size =
309161d8658bSDupuis, Chad ALIGN(qedf->global_queues[i]->cq_pbl_size, QEDF_PAGE_SIZE);
309261d8658bSDupuis, Chad
309361d8658bSDupuis, Chad qedf->global_queues[i]->cq =
3094750afb08SLuis Chamberlain dma_alloc_coherent(&qedf->pdev->dev,
309561d8658bSDupuis, Chad qedf->global_queues[i]->cq_mem_size,
3096750afb08SLuis Chamberlain &qedf->global_queues[i]->cq_dma,
3097750afb08SLuis Chamberlain GFP_KERNEL);
309861d8658bSDupuis, Chad
309961d8658bSDupuis, Chad if (!qedf->global_queues[i]->cq) {
310032eebb31SChristophe JAILLET QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq.\n");
310161d8658bSDupuis, Chad status = -ENOMEM;
310261d8658bSDupuis, Chad goto mem_alloc_failure;
310361d8658bSDupuis, Chad }
310461d8658bSDupuis, Chad
310561d8658bSDupuis, Chad qedf->global_queues[i]->cq_pbl =
3106750afb08SLuis Chamberlain dma_alloc_coherent(&qedf->pdev->dev,
310761d8658bSDupuis, Chad qedf->global_queues[i]->cq_pbl_size,
3108750afb08SLuis Chamberlain &qedf->global_queues[i]->cq_pbl_dma,
3109750afb08SLuis Chamberlain GFP_KERNEL);
311061d8658bSDupuis, Chad
311161d8658bSDupuis, Chad if (!qedf->global_queues[i]->cq_pbl) {
311232eebb31SChristophe JAILLET QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq PBL.\n");
311361d8658bSDupuis, Chad status = -ENOMEM;
311461d8658bSDupuis, Chad goto mem_alloc_failure;
311561d8658bSDupuis, Chad }
311661d8658bSDupuis, Chad
311761d8658bSDupuis, Chad /* Create PBL */
311861d8658bSDupuis, Chad num_pages = qedf->global_queues[i]->cq_mem_size /
311961d8658bSDupuis, Chad QEDF_PAGE_SIZE;
312061d8658bSDupuis, Chad page = qedf->global_queues[i]->cq_dma;
312161d8658bSDupuis, Chad pbl = (u32 *)qedf->global_queues[i]->cq_pbl;
312261d8658bSDupuis, Chad
312361d8658bSDupuis, Chad while (num_pages--) {
312461d8658bSDupuis, Chad *pbl = U64_LO(page);
312561d8658bSDupuis, Chad pbl++;
312661d8658bSDupuis, Chad *pbl = U64_HI(page);
312761d8658bSDupuis, Chad pbl++;
312861d8658bSDupuis, Chad page += QEDF_PAGE_SIZE;
312961d8658bSDupuis, Chad }
313061d8658bSDupuis, Chad /* Set the initial consumer index for cq */
313161d8658bSDupuis, Chad qedf->global_queues[i]->cq_cons_idx = 0;
313261d8658bSDupuis, Chad }
313361d8658bSDupuis, Chad
313461d8658bSDupuis, Chad list = (u32 *)qedf->p_cpuq;
313561d8658bSDupuis, Chad
313661d8658bSDupuis, Chad /*
313761d8658bSDupuis, Chad * The list is built as follows: CQ#0 PBL pointer, RQ#0 PBL pointer,
313861d8658bSDupuis, Chad * CQ#1 PBL pointer, RQ#1 PBL pointer, etc. Each PBL pointer points
313961d8658bSDupuis, Chad * to the physical address which contains an array of pointers to
314061d8658bSDupuis, Chad * the physical addresses of the specific queue pages.
314161d8658bSDupuis, Chad */
314261d8658bSDupuis, Chad for (i = 0; i < qedf->num_queues; i++) {
314361d8658bSDupuis, Chad *list = U64_LO(qedf->global_queues[i]->cq_pbl_dma);
314461d8658bSDupuis, Chad list++;
314561d8658bSDupuis, Chad *list = U64_HI(qedf->global_queues[i]->cq_pbl_dma);
314661d8658bSDupuis, Chad list++;
314761d8658bSDupuis, Chad *list = U64_LO(0);
314861d8658bSDupuis, Chad list++;
314961d8658bSDupuis, Chad *list = U64_HI(0);
315061d8658bSDupuis, Chad list++;
315161d8658bSDupuis, Chad }
315261d8658bSDupuis, Chad
315361d8658bSDupuis, Chad return 0;
315461d8658bSDupuis, Chad
315561d8658bSDupuis, Chad mem_alloc_failure:
315661d8658bSDupuis, Chad qedf_free_global_queues(qedf);
315761d8658bSDupuis, Chad return status;
315861d8658bSDupuis, Chad }
315961d8658bSDupuis, Chad
qedf_set_fcoe_pf_param(struct qedf_ctx * qedf)316061d8658bSDupuis, Chad static int qedf_set_fcoe_pf_param(struct qedf_ctx *qedf)
316161d8658bSDupuis, Chad {
316261d8658bSDupuis, Chad u8 sq_num_pbl_pages;
316361d8658bSDupuis, Chad u32 sq_mem_size;
316461d8658bSDupuis, Chad u32 cq_mem_size;
316561d8658bSDupuis, Chad u32 cq_num_entries;
316661d8658bSDupuis, Chad int rval;
316761d8658bSDupuis, Chad
316861d8658bSDupuis, Chad /*
316961d8658bSDupuis, Chad * The number of completion queues/fastpath interrupts/status blocks
317061d8658bSDupuis, Chad * we allocation is the minimum off:
317161d8658bSDupuis, Chad *
317261d8658bSDupuis, Chad * Number of CPUs
3173722477c4SThomas Bogendoerfer * Number allocated by qed for our PCI function
317461d8658bSDupuis, Chad */
3175722477c4SThomas Bogendoerfer qedf->num_queues = MIN_NUM_CPUS_MSIX(qedf);
317661d8658bSDupuis, Chad
317761d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Number of CQs is %d.\n",
317861d8658bSDupuis, Chad qedf->num_queues);
317961d8658bSDupuis, Chad
3180332d84f7SChristoph Hellwig qedf->p_cpuq = dma_alloc_coherent(&qedf->pdev->dev,
318161d8658bSDupuis, Chad qedf->num_queues * sizeof(struct qedf_glbl_q_params),
3182332d84f7SChristoph Hellwig &qedf->hw_p_cpuq, GFP_KERNEL);
318361d8658bSDupuis, Chad
318461d8658bSDupuis, Chad if (!qedf->p_cpuq) {
3185332d84f7SChristoph Hellwig QEDF_ERR(&(qedf->dbg_ctx), "dma_alloc_coherent failed.\n");
318661d8658bSDupuis, Chad return 1;
318761d8658bSDupuis, Chad }
318861d8658bSDupuis, Chad
318961d8658bSDupuis, Chad rval = qedf_alloc_global_queues(qedf);
319061d8658bSDupuis, Chad if (rval) {
319161d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Global queue allocation "
319261d8658bSDupuis, Chad "failed.\n");
319361d8658bSDupuis, Chad return 1;
319461d8658bSDupuis, Chad }
319561d8658bSDupuis, Chad
319661d8658bSDupuis, Chad /* Calculate SQ PBL size in the same manner as in qedf_sq_alloc() */
319761d8658bSDupuis, Chad sq_mem_size = SQ_NUM_ENTRIES * sizeof(struct fcoe_wqe);
319861d8658bSDupuis, Chad sq_mem_size = ALIGN(sq_mem_size, QEDF_PAGE_SIZE);
319961d8658bSDupuis, Chad sq_num_pbl_pages = (sq_mem_size / QEDF_PAGE_SIZE);
320061d8658bSDupuis, Chad
320161d8658bSDupuis, Chad /* Calculate CQ num entries */
320261d8658bSDupuis, Chad cq_mem_size = FCOE_PARAMS_CQ_NUM_ENTRIES * sizeof(struct fcoe_cqe);
320361d8658bSDupuis, Chad cq_mem_size = ALIGN(cq_mem_size, QEDF_PAGE_SIZE);
320461d8658bSDupuis, Chad cq_num_entries = cq_mem_size / sizeof(struct fcoe_cqe);
320561d8658bSDupuis, Chad
320632eebb31SChristophe JAILLET memset(&(qedf->pf_params), 0, sizeof(qedf->pf_params));
320761d8658bSDupuis, Chad
320861d8658bSDupuis, Chad /* Setup the value for fcoe PF */
320961d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.num_cons = QEDF_MAX_SESSIONS;
321061d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.num_tasks = FCOE_PARAMS_NUM_TASKS;
321161d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.glbl_q_params_addr =
321261d8658bSDupuis, Chad (u64)qedf->hw_p_cpuq;
321361d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.sq_num_pbl_pages = sq_num_pbl_pages;
321461d8658bSDupuis, Chad
321561d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.rq_buffer_log_size = 0;
321661d8658bSDupuis, Chad
321761d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.cq_num_entries = cq_num_entries;
321861d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.num_cqs = qedf->num_queues;
321961d8658bSDupuis, Chad
322061d8658bSDupuis, Chad /* log_page_size: 12 for 4KB pages */
322161d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.log_page_size = ilog2(QEDF_PAGE_SIZE);
322261d8658bSDupuis, Chad
322361d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.mtu = 9000;
322461d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.gl_rq_pi = QEDF_FCOE_PARAMS_GL_RQ_PI;
322561d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.gl_cmd_pi = QEDF_FCOE_PARAMS_GL_CMD_PI;
322661d8658bSDupuis, Chad
322761d8658bSDupuis, Chad /* BDQ address and size */
322861d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.bdq_pbl_base_addr[0] =
322961d8658bSDupuis, Chad qedf->bdq_pbl_list_dma;
323061d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.bdq_pbl_num_entries[0] =
323161d8658bSDupuis, Chad qedf->bdq_pbl_list_num_entries;
323261d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.rq_buffer_size = QEDF_BDQ_BUF_SIZE;
323361d8658bSDupuis, Chad
323461d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
323561d8658bSDupuis, Chad "bdq_list=%p bdq_pbl_list_dma=%llx bdq_pbl_list_entries=%d.\n",
323661d8658bSDupuis, Chad qedf->bdq_pbl_list,
323761d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.bdq_pbl_base_addr[0],
323861d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.bdq_pbl_num_entries[0]);
323961d8658bSDupuis, Chad
324061d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
324161d8658bSDupuis, Chad "cq_num_entries=%d.\n",
324261d8658bSDupuis, Chad qedf->pf_params.fcoe_pf_params.cq_num_entries);
324361d8658bSDupuis, Chad
324461d8658bSDupuis, Chad return 0;
324561d8658bSDupuis, Chad }
324661d8658bSDupuis, Chad
324761d8658bSDupuis, Chad /* Free DMA coherent memory for array of queue pointers we pass to qed */
qedf_free_fcoe_pf_param(struct qedf_ctx * qedf)324861d8658bSDupuis, Chad static void qedf_free_fcoe_pf_param(struct qedf_ctx *qedf)
324961d8658bSDupuis, Chad {
325061d8658bSDupuis, Chad size_t size = 0;
325161d8658bSDupuis, Chad
325261d8658bSDupuis, Chad if (qedf->p_cpuq) {
325361d8658bSDupuis, Chad size = qedf->num_queues * sizeof(struct qedf_glbl_q_params);
3254332d84f7SChristoph Hellwig dma_free_coherent(&qedf->pdev->dev, size, qedf->p_cpuq,
325561d8658bSDupuis, Chad qedf->hw_p_cpuq);
325661d8658bSDupuis, Chad }
325761d8658bSDupuis, Chad
325861d8658bSDupuis, Chad qedf_free_global_queues(qedf);
325961d8658bSDupuis, Chad
326061d8658bSDupuis, Chad kfree(qedf->global_queues);
326161d8658bSDupuis, Chad }
326261d8658bSDupuis, Chad
326361d8658bSDupuis, Chad /*
326461d8658bSDupuis, Chad * PCI driver functions
326561d8658bSDupuis, Chad */
326661d8658bSDupuis, Chad
326761d8658bSDupuis, Chad static const struct pci_device_id qedf_pci_tbl[] = {
326861d8658bSDupuis, Chad { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, 0x165c) },
326961d8658bSDupuis, Chad { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, 0x8080) },
327061d8658bSDupuis, Chad {0}
327161d8658bSDupuis, Chad };
327261d8658bSDupuis, Chad MODULE_DEVICE_TABLE(pci, qedf_pci_tbl);
327361d8658bSDupuis, Chad
327461d8658bSDupuis, Chad static struct pci_driver qedf_pci_driver = {
327561d8658bSDupuis, Chad .name = QEDF_MODULE_NAME,
327661d8658bSDupuis, Chad .id_table = qedf_pci_tbl,
327761d8658bSDupuis, Chad .probe = qedf_probe,
327861d8658bSDupuis, Chad .remove = qedf_remove,
327931696204SSaurav Kashyap .shutdown = qedf_shutdown,
3280ef222f55SNilesh Javali .suspend = qedf_suspend,
328161d8658bSDupuis, Chad };
328261d8658bSDupuis, Chad
__qedf_probe(struct pci_dev * pdev,int mode)328361d8658bSDupuis, Chad static int __qedf_probe(struct pci_dev *pdev, int mode)
328461d8658bSDupuis, Chad {
328561d8658bSDupuis, Chad int rc = -EINVAL;
328661d8658bSDupuis, Chad struct fc_lport *lport;
3287ad40f525SChad Dupuis struct qedf_ctx *qedf = NULL;
328861d8658bSDupuis, Chad struct Scsi_Host *host;
328961d8658bSDupuis, Chad bool is_vf = false;
329061d8658bSDupuis, Chad struct qed_ll2_params params;
329161d8658bSDupuis, Chad char host_buf[20];
329261d8658bSDupuis, Chad struct qed_link_params link_params;
329361d8658bSDupuis, Chad int status;
329461d8658bSDupuis, Chad void *task_start, *task_end;
329561d8658bSDupuis, Chad struct qed_slowpath_params slowpath_params;
329661d8658bSDupuis, Chad struct qed_probe_params qed_params;
3297988100a7SSaurav Kashyap u16 retry_cnt = 10;
329861d8658bSDupuis, Chad
329961d8658bSDupuis, Chad /*
330061d8658bSDupuis, Chad * When doing error recovery we didn't reap the lport so don't try
330161d8658bSDupuis, Chad * to reallocate it.
330261d8658bSDupuis, Chad */
3303988100a7SSaurav Kashyap retry_probe:
3304988100a7SSaurav Kashyap if (mode == QEDF_MODE_RECOVERY)
3305988100a7SSaurav Kashyap msleep(2000);
3306988100a7SSaurav Kashyap
330761d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
330861d8658bSDupuis, Chad lport = libfc_host_alloc(&qedf_host_template,
330961d8658bSDupuis, Chad sizeof(struct qedf_ctx));
331061d8658bSDupuis, Chad
331161d8658bSDupuis, Chad if (!lport) {
331261d8658bSDupuis, Chad QEDF_ERR(NULL, "Could not allocate lport.\n");
331361d8658bSDupuis, Chad rc = -ENOMEM;
331461d8658bSDupuis, Chad goto err0;
331561d8658bSDupuis, Chad }
331661d8658bSDupuis, Chad
33170cbd0075SChad Dupuis fc_disc_init(lport);
33180cbd0075SChad Dupuis
331961d8658bSDupuis, Chad /* Initialize qedf_ctx */
332061d8658bSDupuis, Chad qedf = lport_priv(lport);
3321ad40f525SChad Dupuis set_bit(QEDF_PROBING, &qedf->flags);
332261d8658bSDupuis, Chad qedf->lport = lport;
332361d8658bSDupuis, Chad qedf->ctlr.lp = lport;
332461d8658bSDupuis, Chad qedf->pdev = pdev;
332561d8658bSDupuis, Chad qedf->dbg_ctx.pdev = pdev;
332661d8658bSDupuis, Chad qedf->dbg_ctx.host_no = lport->host->host_no;
332761d8658bSDupuis, Chad spin_lock_init(&qedf->hba_lock);
332861d8658bSDupuis, Chad INIT_LIST_HEAD(&qedf->fcports);
332961d8658bSDupuis, Chad qedf->curr_conn_id = QEDF_MAX_SESSIONS - 1;
333061d8658bSDupuis, Chad atomic_set(&qedf->num_offloads, 0);
333161d8658bSDupuis, Chad qedf->stop_io_on_error = false;
333261d8658bSDupuis, Chad pci_set_drvdata(pdev, qedf);
33338eaf7dfcSChad Dupuis init_completion(&qedf->fipvlan_compl);
3334642a0b37SChad Dupuis mutex_init(&qedf->stats_mutex);
333569ef2c69SSaurav Kashyap mutex_init(&qedf->flush_mutex);
3336ab0a8299SSaurav Kashyap qedf->flogi_pending = 0;
333761d8658bSDupuis, Chad
333861d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_INFO,
333961d8658bSDupuis, Chad "QLogic FastLinQ FCoE Module qedf %s, "
334061d8658bSDupuis, Chad "FW %d.%d.%d.%d\n", QEDF_VERSION,
334161d8658bSDupuis, Chad FW_MAJOR_VERSION, FW_MINOR_VERSION, FW_REVISION_VERSION,
334261d8658bSDupuis, Chad FW_ENGINEERING_VERSION);
334361d8658bSDupuis, Chad } else {
334461d8658bSDupuis, Chad /* Init pointers during recovery */
334561d8658bSDupuis, Chad qedf = pci_get_drvdata(pdev);
3346ad40f525SChad Dupuis set_bit(QEDF_PROBING, &qedf->flags);
334761d8658bSDupuis, Chad lport = qedf->lport;
334861d8658bSDupuis, Chad }
334961d8658bSDupuis, Chad
3350ad40f525SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Probe started.\n");
3351ad40f525SChad Dupuis
335261d8658bSDupuis, Chad host = lport->host;
335361d8658bSDupuis, Chad
335461d8658bSDupuis, Chad /* Allocate mempool for qedf_io_work structs */
335561d8658bSDupuis, Chad qedf->io_mempool = mempool_create_slab_pool(QEDF_IO_WORK_MIN,
335661d8658bSDupuis, Chad qedf_io_work_cache);
335761d8658bSDupuis, Chad if (qedf->io_mempool == NULL) {
335861d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "qedf->io_mempool is NULL.\n");
335961d8658bSDupuis, Chad goto err1;
336061d8658bSDupuis, Chad }
336161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_INFO, "qedf->io_mempool=%p.\n",
336261d8658bSDupuis, Chad qedf->io_mempool);
336361d8658bSDupuis, Chad
336461d8658bSDupuis, Chad sprintf(host_buf, "qedf_%u_link",
336561d8658bSDupuis, Chad qedf->lport->host->host_no);
3366428ca642SChad Dupuis qedf->link_update_wq = create_workqueue(host_buf);
336761d8658bSDupuis, Chad INIT_DELAYED_WORK(&qedf->link_update, qedf_handle_link_update);
336861d8658bSDupuis, Chad INIT_DELAYED_WORK(&qedf->link_recovery, qedf_link_recovery);
33694b9b7fabSChad Dupuis INIT_DELAYED_WORK(&qedf->grcdump_work, qedf_wq_grcdump);
3370ab0a8299SSaurav Kashyap INIT_DELAYED_WORK(&qedf->stag_work, qedf_stag_change_work);
337161d8658bSDupuis, Chad qedf->fipvlan_retries = qedf_fipvlan_retries;
337284b2ba6eSChad Dupuis /* Set a default prio in case DCBX doesn't converge */
337365b7becaSChad Dupuis if (qedf_default_prio > -1) {
337465b7becaSChad Dupuis /*
337565b7becaSChad Dupuis * This is the case where we pass a modparam in so we want to
337665b7becaSChad Dupuis * honor it even if dcbx doesn't converge.
337765b7becaSChad Dupuis */
337865b7becaSChad Dupuis qedf->prio = qedf_default_prio;
337965b7becaSChad Dupuis } else
338084b2ba6eSChad Dupuis qedf->prio = QEDF_DEFAULT_PRIO;
338161d8658bSDupuis, Chad
338261d8658bSDupuis, Chad /*
338361d8658bSDupuis, Chad * Common probe. Takes care of basic hardware init and pci_*
338461d8658bSDupuis, Chad * functions.
338561d8658bSDupuis, Chad */
338661d8658bSDupuis, Chad memset(&qed_params, 0, sizeof(qed_params));
338761d8658bSDupuis, Chad qed_params.protocol = QED_PROTOCOL_FCOE;
338861d8658bSDupuis, Chad qed_params.dp_module = qedf_dp_module;
338961d8658bSDupuis, Chad qed_params.dp_level = qedf_dp_level;
339061d8658bSDupuis, Chad qed_params.is_vf = is_vf;
339161d8658bSDupuis, Chad qedf->cdev = qed_ops->common->probe(pdev, &qed_params);
339261d8658bSDupuis, Chad if (!qedf->cdev) {
3393988100a7SSaurav Kashyap if ((mode == QEDF_MODE_RECOVERY) && retry_cnt) {
3394988100a7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx,
3395988100a7SSaurav Kashyap "Retry %d initialize hardware\n", retry_cnt);
3396988100a7SSaurav Kashyap retry_cnt--;
3397988100a7SSaurav Kashyap goto retry_probe;
3398988100a7SSaurav Kashyap }
3399e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "common probe failed.\n");
340061d8658bSDupuis, Chad rc = -ENODEV;
340161d8658bSDupuis, Chad goto err1;
340261d8658bSDupuis, Chad }
340361d8658bSDupuis, Chad
3404722477c4SThomas Bogendoerfer /* Learn information crucial for qedf to progress */
3405722477c4SThomas Bogendoerfer rc = qed_ops->fill_dev_info(qedf->cdev, &qedf->dev_info);
3406722477c4SThomas Bogendoerfer if (rc) {
3407722477c4SThomas Bogendoerfer QEDF_ERR(&(qedf->dbg_ctx), "Failed to dev info.\n");
3408722477c4SThomas Bogendoerfer goto err1;
3409722477c4SThomas Bogendoerfer }
3410722477c4SThomas Bogendoerfer
3411a9b02c61SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
3412a9b02c61SChad Dupuis "dev_info: num_hwfns=%d affin_hwfn_idx=%d.\n",
3413a9b02c61SChad Dupuis qedf->dev_info.common.num_hwfns,
3414a9b02c61SChad Dupuis qed_ops->common->get_affin_hwfn_idx(qedf->cdev));
3415a9b02c61SChad Dupuis
341661d8658bSDupuis, Chad /* queue allocation code should come here
341761d8658bSDupuis, Chad * order should be
341861d8658bSDupuis, Chad * slowpath_start
341961d8658bSDupuis, Chad * status block allocation
342061d8658bSDupuis, Chad * interrupt registration (to get min number of queues)
342161d8658bSDupuis, Chad * set_fcoe_pf_param
342261d8658bSDupuis, Chad * qed_sp_fcoe_func_start
342361d8658bSDupuis, Chad */
342461d8658bSDupuis, Chad rc = qedf_set_fcoe_pf_param(qedf);
342561d8658bSDupuis, Chad if (rc) {
342661d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Cannot set fcoe pf param.\n");
342761d8658bSDupuis, Chad goto err2;
342861d8658bSDupuis, Chad }
342961d8658bSDupuis, Chad qed_ops->common->update_pf_params(qedf->cdev, &qedf->pf_params);
343061d8658bSDupuis, Chad
34317109cb51SSaurav Kashyap /* Learn information crucial for qedf to progress */
34327109cb51SSaurav Kashyap rc = qed_ops->fill_dev_info(qedf->cdev, &qedf->dev_info);
34337109cb51SSaurav Kashyap if (rc) {
34347109cb51SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "Failed to fill dev info.\n");
34357109cb51SSaurav Kashyap goto err2;
34367109cb51SSaurav Kashyap }
34377109cb51SSaurav Kashyap
34384aab946fSJaved Hasan if (mode != QEDF_MODE_RECOVERY) {
34394aab946fSJaved Hasan qedf->devlink = qed_ops->common->devlink_register(qedf->cdev);
34404aab946fSJaved Hasan if (IS_ERR(qedf->devlink)) {
34414aab946fSJaved Hasan QEDF_ERR(&qedf->dbg_ctx, "Cannot register devlink\n");
3442e6a54d6fSLeon Romanovsky rc = PTR_ERR(qedf->devlink);
34434aab946fSJaved Hasan qedf->devlink = NULL;
3444e6a54d6fSLeon Romanovsky goto err2;
34454aab946fSJaved Hasan }
34464aab946fSJaved Hasan }
34474aab946fSJaved Hasan
344861d8658bSDupuis, Chad /* Record BDQ producer doorbell addresses */
344961d8658bSDupuis, Chad qedf->bdq_primary_prod = qedf->dev_info.primary_dbq_rq_addr;
345061d8658bSDupuis, Chad qedf->bdq_secondary_prod = qedf->dev_info.secondary_bdq_rq_addr;
345161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
345261d8658bSDupuis, Chad "BDQ primary_prod=%p secondary_prod=%p.\n", qedf->bdq_primary_prod,
345361d8658bSDupuis, Chad qedf->bdq_secondary_prod);
345461d8658bSDupuis, Chad
345561d8658bSDupuis, Chad qed_ops->register_ops(qedf->cdev, &qedf_cb_ops, qedf);
345661d8658bSDupuis, Chad
345761d8658bSDupuis, Chad rc = qedf_prepare_sb(qedf);
345861d8658bSDupuis, Chad if (rc) {
345961d8658bSDupuis, Chad
346061d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Cannot start slowpath.\n");
346161d8658bSDupuis, Chad goto err2;
346261d8658bSDupuis, Chad }
346361d8658bSDupuis, Chad
346461d8658bSDupuis, Chad /* Start the Slowpath-process */
346561d8658bSDupuis, Chad slowpath_params.int_mode = QED_INT_MODE_MSIX;
346661d8658bSDupuis, Chad slowpath_params.drv_major = QEDF_DRIVER_MAJOR_VER;
346761d8658bSDupuis, Chad slowpath_params.drv_minor = QEDF_DRIVER_MINOR_VER;
346861d8658bSDupuis, Chad slowpath_params.drv_rev = QEDF_DRIVER_REV_VER;
346961d8658bSDupuis, Chad slowpath_params.drv_eng = QEDF_DRIVER_ENG_VER;
3470cd22874fSKees Cook strncpy(slowpath_params.name, "qedf", QED_DRV_VER_STR_SIZE);
347161d8658bSDupuis, Chad rc = qed_ops->common->slowpath_start(qedf->cdev, &slowpath_params);
347261d8658bSDupuis, Chad if (rc) {
347361d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Cannot start slowpath.\n");
347461d8658bSDupuis, Chad goto err2;
347561d8658bSDupuis, Chad }
347661d8658bSDupuis, Chad
347761d8658bSDupuis, Chad /*
347861d8658bSDupuis, Chad * update_pf_params needs to be called before and after slowpath
347961d8658bSDupuis, Chad * start
348061d8658bSDupuis, Chad */
348161d8658bSDupuis, Chad qed_ops->common->update_pf_params(qedf->cdev, &qedf->pf_params);
348261d8658bSDupuis, Chad
348361d8658bSDupuis, Chad /* Setup interrupts */
348461d8658bSDupuis, Chad rc = qedf_setup_int(qedf);
3485e82e6ff7SSaurav Kashyap if (rc) {
3486e82e6ff7SSaurav Kashyap QEDF_ERR(&qedf->dbg_ctx, "Setup interrupts failed.\n");
348761d8658bSDupuis, Chad goto err3;
3488e82e6ff7SSaurav Kashyap }
348961d8658bSDupuis, Chad
349061d8658bSDupuis, Chad rc = qed_ops->start(qedf->cdev, &qedf->tasks);
349161d8658bSDupuis, Chad if (rc) {
349261d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Cannot start FCoE function.\n");
349361d8658bSDupuis, Chad goto err4;
349461d8658bSDupuis, Chad }
349561d8658bSDupuis, Chad task_start = qedf_get_task_mem(&qedf->tasks, 0);
349661d8658bSDupuis, Chad task_end = qedf_get_task_mem(&qedf->tasks, MAX_TID_BLOCKS_FCOE - 1);
349761d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Task context start=%p, "
349861d8658bSDupuis, Chad "end=%p block_size=%u.\n", task_start, task_end,
349961d8658bSDupuis, Chad qedf->tasks.size);
350061d8658bSDupuis, Chad
350161d8658bSDupuis, Chad /*
350261d8658bSDupuis, Chad * We need to write the number of BDs in the BDQ we've preallocated so
350361d8658bSDupuis, Chad * the f/w will do a prefetch and we'll get an unsolicited CQE when a
350461d8658bSDupuis, Chad * packet arrives.
350561d8658bSDupuis, Chad */
350661d8658bSDupuis, Chad qedf->bdq_prod_idx = QEDF_BDQ_SIZE;
350761d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
350861d8658bSDupuis, Chad "Writing %d to primary and secondary BDQ doorbell registers.\n",
350961d8658bSDupuis, Chad qedf->bdq_prod_idx);
351061d8658bSDupuis, Chad writew(qedf->bdq_prod_idx, qedf->bdq_primary_prod);
3511c6e2f4bdSLee Jones readw(qedf->bdq_primary_prod);
351261d8658bSDupuis, Chad writew(qedf->bdq_prod_idx, qedf->bdq_secondary_prod);
3513c6e2f4bdSLee Jones readw(qedf->bdq_secondary_prod);
351461d8658bSDupuis, Chad
351561d8658bSDupuis, Chad qed_ops->common->set_power_state(qedf->cdev, PCI_D0);
351661d8658bSDupuis, Chad
351761d8658bSDupuis, Chad /* Now that the dev_info struct has been filled in set the MAC
351861d8658bSDupuis, Chad * address
351961d8658bSDupuis, Chad */
352061d8658bSDupuis, Chad ether_addr_copy(qedf->mac, qedf->dev_info.common.hw_mac);
352161d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "MAC address is %pM.\n",
352261d8658bSDupuis, Chad qedf->mac);
352361d8658bSDupuis, Chad
352401fd76a7SChad Dupuis /*
352501fd76a7SChad Dupuis * Set the WWNN and WWPN in the following way:
352601fd76a7SChad Dupuis *
352701fd76a7SChad Dupuis * If the info we get from qed is non-zero then use that to set the
352801fd76a7SChad Dupuis * WWPN and WWNN. Otherwise fall back to use fcoe_wwn_from_mac() based
352901fd76a7SChad Dupuis * on the MAC address.
353001fd76a7SChad Dupuis */
353101fd76a7SChad Dupuis if (qedf->dev_info.wwnn != 0 && qedf->dev_info.wwpn != 0) {
353201fd76a7SChad Dupuis QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
353301fd76a7SChad Dupuis "Setting WWPN and WWNN from qed dev_info.\n");
353401fd76a7SChad Dupuis qedf->wwnn = qedf->dev_info.wwnn;
353501fd76a7SChad Dupuis qedf->wwpn = qedf->dev_info.wwpn;
353601fd76a7SChad Dupuis } else {
353701fd76a7SChad Dupuis QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
353801fd76a7SChad Dupuis "Setting WWPN and WWNN using fcoe_wwn_from_mac().\n");
353961d8658bSDupuis, Chad qedf->wwnn = fcoe_wwn_from_mac(qedf->mac, 1, 0);
354061d8658bSDupuis, Chad qedf->wwpn = fcoe_wwn_from_mac(qedf->mac, 2, 0);
354101fd76a7SChad Dupuis }
354261d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "WWNN=%016llx "
354361d8658bSDupuis, Chad "WWPN=%016llx.\n", qedf->wwnn, qedf->wwpn);
354461d8658bSDupuis, Chad
354561d8658bSDupuis, Chad sprintf(host_buf, "host_%d", host->host_no);
3546712c3cbfSMintz, Yuval qed_ops->common->set_name(qedf->cdev, host_buf);
354761d8658bSDupuis, Chad
354861d8658bSDupuis, Chad /* Allocate cmd mgr */
354961d8658bSDupuis, Chad qedf->cmd_mgr = qedf_cmd_mgr_alloc(qedf);
355061d8658bSDupuis, Chad if (!qedf->cmd_mgr) {
355161d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Failed to allocate cmd mgr.\n");
3552e89cabf2SWei Yongjun rc = -ENOMEM;
355361d8658bSDupuis, Chad goto err5;
355461d8658bSDupuis, Chad }
355561d8658bSDupuis, Chad
355661d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
355761d8658bSDupuis, Chad host->transportt = qedf_fc_transport_template;
355861d8658bSDupuis, Chad host->max_lun = qedf_max_lun;
355961d8658bSDupuis, Chad host->max_cmd_len = QEDF_MAX_CDB_LEN;
35601b67f3d7SSaurav Kashyap host->max_id = QEDF_MAX_SESSIONS;
3561650ce64cSChad Dupuis host->can_queue = FCOE_PARAMS_NUM_TASKS;
356261d8658bSDupuis, Chad rc = scsi_add_host(host, &pdev->dev);
3563249b148fSSaurav Kashyap if (rc) {
3564249b148fSSaurav Kashyap QEDF_WARN(&qedf->dbg_ctx,
35651e1ff604SSaurav Kashyap "Error adding Scsi_Host rc=0x%x.\n", rc);
356661d8658bSDupuis, Chad goto err6;
356761d8658bSDupuis, Chad }
3568249b148fSSaurav Kashyap }
356961d8658bSDupuis, Chad
357061d8658bSDupuis, Chad memset(¶ms, 0, sizeof(params));
3571f6d63678SSaurav Kashyap params.mtu = QEDF_LL2_BUF_SIZE;
357261d8658bSDupuis, Chad ether_addr_copy(params.ll2_mac_address, qedf->mac);
357361d8658bSDupuis, Chad
357461d8658bSDupuis, Chad /* Start LL2 processing thread */
357561d8658bSDupuis, Chad snprintf(host_buf, 20, "qedf_%d_ll2", host->host_no);
357661d8658bSDupuis, Chad qedf->ll2_recv_wq =
3577428ca642SChad Dupuis create_workqueue(host_buf);
357861d8658bSDupuis, Chad if (!qedf->ll2_recv_wq) {
357961d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Failed to LL2 workqueue.\n");
3580e89cabf2SWei Yongjun rc = -ENOMEM;
358161d8658bSDupuis, Chad goto err7;
358261d8658bSDupuis, Chad }
358361d8658bSDupuis, Chad
358461d8658bSDupuis, Chad #ifdef CONFIG_DEBUG_FS
3585d9ea463aSArnd Bergmann qedf_dbg_host_init(&(qedf->dbg_ctx), qedf_debugfs_ops,
3586d9ea463aSArnd Bergmann qedf_dbg_fops);
358761d8658bSDupuis, Chad #endif
358861d8658bSDupuis, Chad
358961d8658bSDupuis, Chad /* Start LL2 */
359061d8658bSDupuis, Chad qed_ops->ll2->register_cb_ops(qedf->cdev, &qedf_ll2_cb_ops, qedf);
359161d8658bSDupuis, Chad rc = qed_ops->ll2->start(qedf->cdev, ¶ms);
359261d8658bSDupuis, Chad if (rc) {
359361d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Could not start Light L2.\n");
359461d8658bSDupuis, Chad goto err7;
359561d8658bSDupuis, Chad }
359661d8658bSDupuis, Chad set_bit(QEDF_LL2_STARTED, &qedf->flags);
359761d8658bSDupuis, Chad
3598cf291163SChad Dupuis /* Set initial FIP/FCoE VLAN to NULL */
359961d8658bSDupuis, Chad qedf->vlan_id = 0;
360061d8658bSDupuis, Chad
360161d8658bSDupuis, Chad /*
360261d8658bSDupuis, Chad * No need to setup fcoe_ctlr or fc_lport objects during recovery since
360361d8658bSDupuis, Chad * they were not reaped during the unload process.
360461d8658bSDupuis, Chad */
360561d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
360661d8658bSDupuis, Chad /* Setup imbedded fcoe controller */
360761d8658bSDupuis, Chad qedf_fcoe_ctlr_setup(qedf);
360861d8658bSDupuis, Chad
360961d8658bSDupuis, Chad /* Setup lport */
361061d8658bSDupuis, Chad rc = qedf_lport_setup(qedf);
361161d8658bSDupuis, Chad if (rc) {
361261d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx),
361361d8658bSDupuis, Chad "qedf_lport_setup failed.\n");
361461d8658bSDupuis, Chad goto err7;
361561d8658bSDupuis, Chad }
361661d8658bSDupuis, Chad }
361761d8658bSDupuis, Chad
361861d8658bSDupuis, Chad sprintf(host_buf, "qedf_%u_timer", qedf->lport->host->host_no);
361961d8658bSDupuis, Chad qedf->timer_work_queue =
3620428ca642SChad Dupuis create_workqueue(host_buf);
362161d8658bSDupuis, Chad if (!qedf->timer_work_queue) {
362261d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx), "Failed to start timer "
362361d8658bSDupuis, Chad "workqueue.\n");
3624e89cabf2SWei Yongjun rc = -ENOMEM;
362561d8658bSDupuis, Chad goto err7;
362661d8658bSDupuis, Chad }
362761d8658bSDupuis, Chad
362861d8658bSDupuis, Chad /* DPC workqueue is not reaped during recovery unload */
362961d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
363061d8658bSDupuis, Chad sprintf(host_buf, "qedf_%u_dpc",
363161d8658bSDupuis, Chad qedf->lport->host->host_no);
3632428ca642SChad Dupuis qedf->dpc_wq = create_workqueue(host_buf);
363361d8658bSDupuis, Chad }
3634f6b172f2SChad Dupuis INIT_DELAYED_WORK(&qedf->recovery_work, qedf_recovery_handler);
363561d8658bSDupuis, Chad
363661d8658bSDupuis, Chad /*
363761d8658bSDupuis, Chad * GRC dump and sysfs parameters are not reaped during the recovery
363861d8658bSDupuis, Chad * unload process.
363961d8658bSDupuis, Chad */
364061d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
36414b9b7fabSChad Dupuis qedf->grcdump_size =
36424b9b7fabSChad Dupuis qed_ops->common->dbg_all_data_size(qedf->cdev);
364361d8658bSDupuis, Chad if (qedf->grcdump_size) {
364461d8658bSDupuis, Chad rc = qedf_alloc_grc_dump_buf(&qedf->grcdump,
364561d8658bSDupuis, Chad qedf->grcdump_size);
364661d8658bSDupuis, Chad if (rc) {
364761d8658bSDupuis, Chad QEDF_ERR(&(qedf->dbg_ctx),
364861d8658bSDupuis, Chad "GRC Dump buffer alloc failed.\n");
364961d8658bSDupuis, Chad qedf->grcdump = NULL;
365061d8658bSDupuis, Chad }
365161d8658bSDupuis, Chad
365261d8658bSDupuis, Chad QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
365361d8658bSDupuis, Chad "grcdump: addr=%p, size=%u.\n",
365461d8658bSDupuis, Chad qedf->grcdump, qedf->grcdump_size);
365561d8658bSDupuis, Chad }
365661d8658bSDupuis, Chad qedf_create_sysfs_ctx_attr(qedf);
365761d8658bSDupuis, Chad
365861d8658bSDupuis, Chad /* Initialize I/O tracing for this adapter */
365961d8658bSDupuis, Chad spin_lock_init(&qedf->io_trace_lock);
366061d8658bSDupuis, Chad qedf->io_trace_idx = 0;
366161d8658bSDupuis, Chad }
366261d8658bSDupuis, Chad
366361d8658bSDupuis, Chad init_completion(&qedf->flogi_compl);
366461d8658bSDupuis, Chad
36656ac17475SSaurav Kashyap status = qed_ops->common->update_drv_state(qedf->cdev, true);
36666ac17475SSaurav Kashyap if (status)
36676ac17475SSaurav Kashyap QEDF_ERR(&(qedf->dbg_ctx),
36686ac17475SSaurav Kashyap "Failed to send drv state to MFW.\n");
36696ac17475SSaurav Kashyap
367061d8658bSDupuis, Chad memset(&link_params, 0, sizeof(struct qed_link_params));
367161d8658bSDupuis, Chad link_params.link_up = true;
367261d8658bSDupuis, Chad status = qed_ops->common->set_link(qedf->cdev, &link_params);
367361d8658bSDupuis, Chad if (status)
367461d8658bSDupuis, Chad QEDF_WARN(&(qedf->dbg_ctx), "set_link failed.\n");
367561d8658bSDupuis, Chad
367661d8658bSDupuis, Chad /* Start/restart discovery */
367761d8658bSDupuis, Chad if (mode == QEDF_MODE_RECOVERY)
367861d8658bSDupuis, Chad fcoe_ctlr_link_up(&qedf->ctlr);
367961d8658bSDupuis, Chad else
368061d8658bSDupuis, Chad fc_fabric_login(lport);
368161d8658bSDupuis, Chad
3682ad40f525SChad Dupuis QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Probe done.\n");
3683ad40f525SChad Dupuis
3684ad40f525SChad Dupuis clear_bit(QEDF_PROBING, &qedf->flags);
3685ad40f525SChad Dupuis
368661d8658bSDupuis, Chad /* All good */
368761d8658bSDupuis, Chad return 0;
368861d8658bSDupuis, Chad
368961d8658bSDupuis, Chad err7:
369061d8658bSDupuis, Chad if (qedf->ll2_recv_wq)
369161d8658bSDupuis, Chad destroy_workqueue(qedf->ll2_recv_wq);
369261d8658bSDupuis, Chad fc_remove_host(qedf->lport->host);
369361d8658bSDupuis, Chad scsi_remove_host(qedf->lport->host);
369461d8658bSDupuis, Chad #ifdef CONFIG_DEBUG_FS
369561d8658bSDupuis, Chad qedf_dbg_host_exit(&(qedf->dbg_ctx));
369661d8658bSDupuis, Chad #endif
369761d8658bSDupuis, Chad err6:
369861d8658bSDupuis, Chad qedf_cmd_mgr_free(qedf->cmd_mgr);
369961d8658bSDupuis, Chad err5:
370061d8658bSDupuis, Chad qed_ops->stop(qedf->cdev);
370161d8658bSDupuis, Chad err4:
370261d8658bSDupuis, Chad qedf_free_fcoe_pf_param(qedf);
370361d8658bSDupuis, Chad qedf_sync_free_irqs(qedf);
370461d8658bSDupuis, Chad err3:
370561d8658bSDupuis, Chad qed_ops->common->slowpath_stop(qedf->cdev);
370661d8658bSDupuis, Chad err2:
370761d8658bSDupuis, Chad qed_ops->common->remove(qedf->cdev);
370861d8658bSDupuis, Chad err1:
370961d8658bSDupuis, Chad scsi_host_put(lport->host);
371061d8658bSDupuis, Chad err0:
371161d8658bSDupuis, Chad return rc;
371261d8658bSDupuis, Chad }
371361d8658bSDupuis, Chad
qedf_probe(struct pci_dev * pdev,const struct pci_device_id * id)371461d8658bSDupuis, Chad static int qedf_probe(struct pci_dev *pdev, const struct pci_device_id *id)
371561d8658bSDupuis, Chad {
371661d8658bSDupuis, Chad return __qedf_probe(pdev, QEDF_MODE_NORMAL);
371761d8658bSDupuis, Chad }
371861d8658bSDupuis, Chad
__qedf_remove(struct pci_dev * pdev,int mode)371961d8658bSDupuis, Chad static void __qedf_remove(struct pci_dev *pdev, int mode)
372061d8658bSDupuis, Chad {
372161d8658bSDupuis, Chad struct qedf_ctx *qedf;
37226ac17475SSaurav Kashyap int rc;
372361d8658bSDupuis, Chad
372461d8658bSDupuis, Chad if (!pdev) {
372561d8658bSDupuis, Chad QEDF_ERR(NULL, "pdev is NULL.\n");
372661d8658bSDupuis, Chad return;
372761d8658bSDupuis, Chad }
372861d8658bSDupuis, Chad
372961d8658bSDupuis, Chad qedf = pci_get_drvdata(pdev);
373061d8658bSDupuis, Chad
373161d8658bSDupuis, Chad /*
373261d8658bSDupuis, Chad * Prevent race where we're in board disable work and then try to
373361d8658bSDupuis, Chad * rmmod the module.
373461d8658bSDupuis, Chad */
373561d8658bSDupuis, Chad if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
373661d8658bSDupuis, Chad QEDF_ERR(&qedf->dbg_ctx, "Already removing PCI function.\n");
373761d8658bSDupuis, Chad return;
373861d8658bSDupuis, Chad }
373961d8658bSDupuis, Chad
374061d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY)
374161d8658bSDupuis, Chad set_bit(QEDF_UNLOADING, &qedf->flags);
374261d8658bSDupuis, Chad
374361d8658bSDupuis, Chad /* Logoff the fabric to upload all connections */
374461d8658bSDupuis, Chad if (mode == QEDF_MODE_RECOVERY)
374561d8658bSDupuis, Chad fcoe_ctlr_link_down(&qedf->ctlr);
374661d8658bSDupuis, Chad else
374761d8658bSDupuis, Chad fc_fabric_logoff(qedf->lport);
3748a66c6cd2SChad Dupuis
3749ac341c2dSYANG LI if (!qedf_wait_for_upload(qedf))
3750a66c6cd2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx, "Could not upload all sessions.\n");
375161d8658bSDupuis, Chad
375261d8658bSDupuis, Chad #ifdef CONFIG_DEBUG_FS
375361d8658bSDupuis, Chad qedf_dbg_host_exit(&(qedf->dbg_ctx));
375461d8658bSDupuis, Chad #endif
375561d8658bSDupuis, Chad
375661d8658bSDupuis, Chad /* Stop any link update handling */
375761d8658bSDupuis, Chad cancel_delayed_work_sync(&qedf->link_update);
375861d8658bSDupuis, Chad destroy_workqueue(qedf->link_update_wq);
375961d8658bSDupuis, Chad qedf->link_update_wq = NULL;
376061d8658bSDupuis, Chad
376161d8658bSDupuis, Chad if (qedf->timer_work_queue)
376261d8658bSDupuis, Chad destroy_workqueue(qedf->timer_work_queue);
376361d8658bSDupuis, Chad
376461d8658bSDupuis, Chad /* Stop Light L2 */
376561d8658bSDupuis, Chad clear_bit(QEDF_LL2_STARTED, &qedf->flags);
376661d8658bSDupuis, Chad qed_ops->ll2->stop(qedf->cdev);
376761d8658bSDupuis, Chad if (qedf->ll2_recv_wq)
376861d8658bSDupuis, Chad destroy_workqueue(qedf->ll2_recv_wq);
376961d8658bSDupuis, Chad
377061d8658bSDupuis, Chad /* Stop fastpath */
377161d8658bSDupuis, Chad qedf_sync_free_irqs(qedf);
377261d8658bSDupuis, Chad qedf_destroy_sb(qedf);
377361d8658bSDupuis, Chad
377461d8658bSDupuis, Chad /*
377561d8658bSDupuis, Chad * During recovery don't destroy OS constructs that represent the
377661d8658bSDupuis, Chad * physical port.
377761d8658bSDupuis, Chad */
377861d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
377961d8658bSDupuis, Chad qedf_free_grc_dump_buf(&qedf->grcdump);
378061d8658bSDupuis, Chad qedf_remove_sysfs_ctx_attr(qedf);
378161d8658bSDupuis, Chad
378261d8658bSDupuis, Chad /* Remove all SCSI/libfc/libfcoe structures */
378361d8658bSDupuis, Chad fcoe_ctlr_destroy(&qedf->ctlr);
378461d8658bSDupuis, Chad fc_lport_destroy(qedf->lport);
378561d8658bSDupuis, Chad fc_remove_host(qedf->lport->host);
378661d8658bSDupuis, Chad scsi_remove_host(qedf->lport->host);
378761d8658bSDupuis, Chad }
378861d8658bSDupuis, Chad
378961d8658bSDupuis, Chad qedf_cmd_mgr_free(qedf->cmd_mgr);
379061d8658bSDupuis, Chad
379161d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
379261d8658bSDupuis, Chad fc_exch_mgr_free(qedf->lport);
379361d8658bSDupuis, Chad fc_lport_free_stats(qedf->lport);
379461d8658bSDupuis, Chad
379561d8658bSDupuis, Chad /* Wait for all vports to be reaped */
379661d8658bSDupuis, Chad qedf_wait_for_vport_destroy(qedf);
379761d8658bSDupuis, Chad }
379861d8658bSDupuis, Chad
379961d8658bSDupuis, Chad /*
380061d8658bSDupuis, Chad * Now that all connections have been uploaded we can stop the
380161d8658bSDupuis, Chad * rest of the qed operations
380261d8658bSDupuis, Chad */
380361d8658bSDupuis, Chad qed_ops->stop(qedf->cdev);
380461d8658bSDupuis, Chad
380561d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
380661d8658bSDupuis, Chad if (qedf->dpc_wq) {
380761d8658bSDupuis, Chad /* Stop general DPC handling */
380861d8658bSDupuis, Chad destroy_workqueue(qedf->dpc_wq);
380961d8658bSDupuis, Chad qedf->dpc_wq = NULL;
381061d8658bSDupuis, Chad }
381161d8658bSDupuis, Chad }
381261d8658bSDupuis, Chad
381361d8658bSDupuis, Chad /* Final shutdown for the board */
381461d8658bSDupuis, Chad qedf_free_fcoe_pf_param(qedf);
381561d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY) {
381661d8658bSDupuis, Chad qed_ops->common->set_power_state(qedf->cdev, PCI_D0);
381761d8658bSDupuis, Chad pci_set_drvdata(pdev, NULL);
381861d8658bSDupuis, Chad }
38196ac17475SSaurav Kashyap
38206ac17475SSaurav Kashyap rc = qed_ops->common->update_drv_state(qedf->cdev, false);
38216ac17475SSaurav Kashyap if (rc)
38226ac17475SSaurav Kashyap QEDF_ERR(&(qedf->dbg_ctx),
38236ac17475SSaurav Kashyap "Failed to send drv state to MFW.\n");
38246ac17475SSaurav Kashyap
38254aab946fSJaved Hasan if (mode != QEDF_MODE_RECOVERY && qedf->devlink) {
38264aab946fSJaved Hasan qed_ops->common->devlink_unregister(qedf->devlink);
38274aab946fSJaved Hasan qedf->devlink = NULL;
38284aab946fSJaved Hasan }
38294aab946fSJaved Hasan
383061d8658bSDupuis, Chad qed_ops->common->slowpath_stop(qedf->cdev);
383161d8658bSDupuis, Chad qed_ops->common->remove(qedf->cdev);
383261d8658bSDupuis, Chad
383361d8658bSDupuis, Chad mempool_destroy(qedf->io_mempool);
383461d8658bSDupuis, Chad
383561d8658bSDupuis, Chad /* Only reap the Scsi_host on a real removal */
383661d8658bSDupuis, Chad if (mode != QEDF_MODE_RECOVERY)
383761d8658bSDupuis, Chad scsi_host_put(qedf->lport->host);
383861d8658bSDupuis, Chad }
383961d8658bSDupuis, Chad
qedf_remove(struct pci_dev * pdev)384061d8658bSDupuis, Chad static void qedf_remove(struct pci_dev *pdev)
384161d8658bSDupuis, Chad {
384261d8658bSDupuis, Chad /* Check to make sure this function wasn't already disabled */
384361d8658bSDupuis, Chad if (!atomic_read(&pdev->enable_cnt))
384461d8658bSDupuis, Chad return;
384561d8658bSDupuis, Chad
384661d8658bSDupuis, Chad __qedf_remove(pdev, QEDF_MODE_NORMAL);
384761d8658bSDupuis, Chad }
384861d8658bSDupuis, Chad
qedf_wq_grcdump(struct work_struct * work)38494b9b7fabSChad Dupuis void qedf_wq_grcdump(struct work_struct *work)
38504b9b7fabSChad Dupuis {
38514b9b7fabSChad Dupuis struct qedf_ctx *qedf =
38524b9b7fabSChad Dupuis container_of(work, struct qedf_ctx, grcdump_work.work);
38534b9b7fabSChad Dupuis
38544b9b7fabSChad Dupuis QEDF_ERR(&(qedf->dbg_ctx), "Collecting GRC dump.\n");
38554b9b7fabSChad Dupuis qedf_capture_grc_dump(qedf);
38564b9b7fabSChad Dupuis }
38574b9b7fabSChad Dupuis
qedf_schedule_hw_err_handler(void * dev,enum qed_hw_err_type err_type)385855e04991SSaurav Kashyap void qedf_schedule_hw_err_handler(void *dev, enum qed_hw_err_type err_type)
385955e04991SSaurav Kashyap {
386055e04991SSaurav Kashyap struct qedf_ctx *qedf = dev;
386155e04991SSaurav Kashyap
386255e04991SSaurav Kashyap QEDF_ERR(&(qedf->dbg_ctx),
386355e04991SSaurav Kashyap "Hardware error handler scheduled, event=%d.\n",
386455e04991SSaurav Kashyap err_type);
386555e04991SSaurav Kashyap
386655e04991SSaurav Kashyap if (test_bit(QEDF_IN_RECOVERY, &qedf->flags)) {
386755e04991SSaurav Kashyap QEDF_ERR(&(qedf->dbg_ctx),
386855e04991SSaurav Kashyap "Already in recovery, not scheduling board disable work.\n");
386955e04991SSaurav Kashyap return;
387055e04991SSaurav Kashyap }
387155e04991SSaurav Kashyap
387255e04991SSaurav Kashyap switch (err_type) {
387355e04991SSaurav Kashyap case QED_HW_ERR_FAN_FAIL:
387455e04991SSaurav Kashyap schedule_delayed_work(&qedf->board_disable_work, 0);
387555e04991SSaurav Kashyap break;
387655e04991SSaurav Kashyap case QED_HW_ERR_MFW_RESP_FAIL:
387755e04991SSaurav Kashyap case QED_HW_ERR_HW_ATTN:
387855e04991SSaurav Kashyap case QED_HW_ERR_DMAE_FAIL:
387955e04991SSaurav Kashyap case QED_HW_ERR_FW_ASSERT:
388055e04991SSaurav Kashyap /* Prevent HW attentions from being reasserted */
388155e04991SSaurav Kashyap qed_ops->common->attn_clr_enable(qedf->cdev, true);
388255e04991SSaurav Kashyap break;
388355e04991SSaurav Kashyap case QED_HW_ERR_RAMROD_FAIL:
388455e04991SSaurav Kashyap /* Prevent HW attentions from being reasserted */
388555e04991SSaurav Kashyap qed_ops->common->attn_clr_enable(qedf->cdev, true);
388655e04991SSaurav Kashyap
38879d6f87c2SJaved Hasan if (qedf_enable_recovery && qedf->devlink)
38889d6f87c2SJaved Hasan qed_ops->common->report_fatal_error(qedf->devlink,
38899d6f87c2SJaved Hasan err_type);
389055e04991SSaurav Kashyap
389155e04991SSaurav Kashyap break;
389255e04991SSaurav Kashyap default:
389355e04991SSaurav Kashyap break;
389455e04991SSaurav Kashyap }
389555e04991SSaurav Kashyap }
389655e04991SSaurav Kashyap
389761d8658bSDupuis, Chad /*
3898642a0b37SChad Dupuis * Protocol TLV handler
3899642a0b37SChad Dupuis */
qedf_get_protocol_tlv_data(void * dev,void * data)3900642a0b37SChad Dupuis void qedf_get_protocol_tlv_data(void *dev, void *data)
3901642a0b37SChad Dupuis {
3902642a0b37SChad Dupuis struct qedf_ctx *qedf = dev;
3903642a0b37SChad Dupuis struct qed_mfw_tlv_fcoe *fcoe = data;
3904ad40f525SChad Dupuis struct fc_lport *lport;
3905ad40f525SChad Dupuis struct Scsi_Host *host;
3906ad40f525SChad Dupuis struct fc_host_attrs *fc_host;
3907642a0b37SChad Dupuis struct fc_host_statistics *hst;
3908642a0b37SChad Dupuis
3909ad40f525SChad Dupuis if (!qedf) {
3910ad40f525SChad Dupuis QEDF_ERR(NULL, "qedf is null.\n");
3911ad40f525SChad Dupuis return;
3912ad40f525SChad Dupuis }
3913ad40f525SChad Dupuis
3914ad40f525SChad Dupuis if (test_bit(QEDF_PROBING, &qedf->flags)) {
3915ad40f525SChad Dupuis QEDF_ERR(&qedf->dbg_ctx, "Function is still probing.\n");
3916ad40f525SChad Dupuis return;
3917ad40f525SChad Dupuis }
3918ad40f525SChad Dupuis
3919ad40f525SChad Dupuis lport = qedf->lport;
3920ad40f525SChad Dupuis host = lport->host;
3921ad40f525SChad Dupuis fc_host = shost_to_fc_host(host);
3922ad40f525SChad Dupuis
3923642a0b37SChad Dupuis /* Force a refresh of the fc_host stats including offload stats */
3924642a0b37SChad Dupuis hst = qedf_fc_get_host_stats(host);
3925642a0b37SChad Dupuis
3926642a0b37SChad Dupuis fcoe->qos_pri_set = true;
3927642a0b37SChad Dupuis fcoe->qos_pri = 3; /* Hard coded to 3 in driver */
3928642a0b37SChad Dupuis
3929642a0b37SChad Dupuis fcoe->ra_tov_set = true;
3930642a0b37SChad Dupuis fcoe->ra_tov = lport->r_a_tov;
3931642a0b37SChad Dupuis
3932642a0b37SChad Dupuis fcoe->ed_tov_set = true;
3933642a0b37SChad Dupuis fcoe->ed_tov = lport->e_d_tov;
3934642a0b37SChad Dupuis
3935642a0b37SChad Dupuis fcoe->npiv_state_set = true;
3936642a0b37SChad Dupuis fcoe->npiv_state = 1; /* NPIV always enabled */
3937642a0b37SChad Dupuis
3938642a0b37SChad Dupuis fcoe->num_npiv_ids_set = true;
3939642a0b37SChad Dupuis fcoe->num_npiv_ids = fc_host->npiv_vports_inuse;
3940642a0b37SChad Dupuis
3941642a0b37SChad Dupuis /* Certain attributes we only want to set if we've selected an FCF */
3942642a0b37SChad Dupuis if (qedf->ctlr.sel_fcf) {
3943642a0b37SChad Dupuis fcoe->switch_name_set = true;
3944642a0b37SChad Dupuis u64_to_wwn(qedf->ctlr.sel_fcf->switch_name, fcoe->switch_name);
3945642a0b37SChad Dupuis }
3946642a0b37SChad Dupuis
3947642a0b37SChad Dupuis fcoe->port_state_set = true;
3948642a0b37SChad Dupuis /* For qedf we're either link down or fabric attach */
3949642a0b37SChad Dupuis if (lport->link_up)
3950642a0b37SChad Dupuis fcoe->port_state = QED_MFW_TLV_PORT_STATE_FABRIC;
3951642a0b37SChad Dupuis else
3952642a0b37SChad Dupuis fcoe->port_state = QED_MFW_TLV_PORT_STATE_OFFLINE;
3953642a0b37SChad Dupuis
3954642a0b37SChad Dupuis fcoe->link_failures_set = true;
3955642a0b37SChad Dupuis fcoe->link_failures = (u16)hst->link_failure_count;
3956642a0b37SChad Dupuis
3957642a0b37SChad Dupuis fcoe->fcoe_txq_depth_set = true;
3958642a0b37SChad Dupuis fcoe->fcoe_rxq_depth_set = true;
3959642a0b37SChad Dupuis fcoe->fcoe_rxq_depth = FCOE_PARAMS_NUM_TASKS;
3960642a0b37SChad Dupuis fcoe->fcoe_txq_depth = FCOE_PARAMS_NUM_TASKS;
3961642a0b37SChad Dupuis
3962642a0b37SChad Dupuis fcoe->fcoe_rx_frames_set = true;
3963642a0b37SChad Dupuis fcoe->fcoe_rx_frames = hst->rx_frames;
3964642a0b37SChad Dupuis
3965642a0b37SChad Dupuis fcoe->fcoe_tx_frames_set = true;
3966642a0b37SChad Dupuis fcoe->fcoe_tx_frames = hst->tx_frames;
3967642a0b37SChad Dupuis
3968642a0b37SChad Dupuis fcoe->fcoe_rx_bytes_set = true;
3969642a0b37SChad Dupuis fcoe->fcoe_rx_bytes = hst->fcp_input_megabytes * 1000000;
3970642a0b37SChad Dupuis
3971642a0b37SChad Dupuis fcoe->fcoe_tx_bytes_set = true;
3972642a0b37SChad Dupuis fcoe->fcoe_tx_bytes = hst->fcp_output_megabytes * 1000000;
3973642a0b37SChad Dupuis
3974642a0b37SChad Dupuis fcoe->crc_count_set = true;
3975642a0b37SChad Dupuis fcoe->crc_count = hst->invalid_crc_count;
3976642a0b37SChad Dupuis
3977642a0b37SChad Dupuis fcoe->tx_abts_set = true;
3978642a0b37SChad Dupuis fcoe->tx_abts = hst->fcp_packet_aborts;
3979642a0b37SChad Dupuis
3980642a0b37SChad Dupuis fcoe->tx_lun_rst_set = true;
3981642a0b37SChad Dupuis fcoe->tx_lun_rst = qedf->lun_resets;
3982642a0b37SChad Dupuis
3983642a0b37SChad Dupuis fcoe->abort_task_sets_set = true;
3984642a0b37SChad Dupuis fcoe->abort_task_sets = qedf->packet_aborts;
3985642a0b37SChad Dupuis
3986642a0b37SChad Dupuis fcoe->scsi_busy_set = true;
3987642a0b37SChad Dupuis fcoe->scsi_busy = qedf->busy;
3988642a0b37SChad Dupuis
3989642a0b37SChad Dupuis fcoe->scsi_tsk_full_set = true;
3990642a0b37SChad Dupuis fcoe->scsi_tsk_full = qedf->task_set_fulls;
3991642a0b37SChad Dupuis }
3992642a0b37SChad Dupuis
3993ab0a8299SSaurav Kashyap /* Deferred work function to perform soft context reset on STAG change */
qedf_stag_change_work(struct work_struct * work)3994ab0a8299SSaurav Kashyap void qedf_stag_change_work(struct work_struct *work)
3995ab0a8299SSaurav Kashyap {
3996ab0a8299SSaurav Kashyap struct qedf_ctx *qedf =
3997ab0a8299SSaurav Kashyap container_of(work, struct qedf_ctx, stag_work.work);
3998ab0a8299SSaurav Kashyap
399964fd4af6SSaurav Kashyap printk_ratelimited("[%s]:[%s:%d]:%d: Performing software context reset.",
400064fd4af6SSaurav Kashyap dev_name(&qedf->pdev->dev), __func__, __LINE__,
400164fd4af6SSaurav Kashyap qedf->dbg_ctx.host_no);
4002ab0a8299SSaurav Kashyap qedf_ctx_soft_reset(qedf->lport);
4003ab0a8299SSaurav Kashyap }
4004ab0a8299SSaurav Kashyap
qedf_shutdown(struct pci_dev * pdev)400531696204SSaurav Kashyap static void qedf_shutdown(struct pci_dev *pdev)
400631696204SSaurav Kashyap {
400731696204SSaurav Kashyap __qedf_remove(pdev, QEDF_MODE_NORMAL);
400831696204SSaurav Kashyap }
400931696204SSaurav Kashyap
qedf_suspend(struct pci_dev * pdev,pm_message_t state)4010ef222f55SNilesh Javali static int qedf_suspend(struct pci_dev *pdev, pm_message_t state)
4011ef222f55SNilesh Javali {
4012ef222f55SNilesh Javali struct qedf_ctx *qedf;
4013ef222f55SNilesh Javali
4014ef222f55SNilesh Javali if (!pdev) {
4015ef222f55SNilesh Javali QEDF_ERR(NULL, "pdev is NULL.\n");
4016ef222f55SNilesh Javali return -ENODEV;
4017ef222f55SNilesh Javali }
4018ef222f55SNilesh Javali
4019ef222f55SNilesh Javali qedf = pci_get_drvdata(pdev);
4020ef222f55SNilesh Javali
4021ef222f55SNilesh Javali QEDF_ERR(&qedf->dbg_ctx, "%s: Device does not support suspend operation\n", __func__);
4022ef222f55SNilesh Javali
4023ef222f55SNilesh Javali return -EPERM;
4024ef222f55SNilesh Javali }
4025ef222f55SNilesh Javali
4026f6b172f2SChad Dupuis /*
4027f6b172f2SChad Dupuis * Recovery handler code
4028f6b172f2SChad Dupuis */
qedf_schedule_recovery_handler(void * dev)4029f6b172f2SChad Dupuis static void qedf_schedule_recovery_handler(void *dev)
4030f6b172f2SChad Dupuis {
4031f6b172f2SChad Dupuis struct qedf_ctx *qedf = dev;
4032f6b172f2SChad Dupuis
4033f6b172f2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx, "Recovery handler scheduled.\n");
4034f6b172f2SChad Dupuis schedule_delayed_work(&qedf->recovery_work, 0);
4035f6b172f2SChad Dupuis }
4036f6b172f2SChad Dupuis
qedf_recovery_handler(struct work_struct * work)4037f6b172f2SChad Dupuis static void qedf_recovery_handler(struct work_struct *work)
4038f6b172f2SChad Dupuis {
4039f6b172f2SChad Dupuis struct qedf_ctx *qedf =
4040f6b172f2SChad Dupuis container_of(work, struct qedf_ctx, recovery_work.work);
4041f6b172f2SChad Dupuis
4042f6b172f2SChad Dupuis if (test_and_set_bit(QEDF_IN_RECOVERY, &qedf->flags))
4043f6b172f2SChad Dupuis return;
4044f6b172f2SChad Dupuis
4045f6b172f2SChad Dupuis /*
4046f6b172f2SChad Dupuis * Call common_ops->recovery_prolog to allow the MFW to quiesce
4047f6b172f2SChad Dupuis * any PCI transactions.
4048f6b172f2SChad Dupuis */
4049f6b172f2SChad Dupuis qed_ops->common->recovery_prolog(qedf->cdev);
4050f6b172f2SChad Dupuis
4051f6b172f2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx, "Recovery work start.\n");
4052f6b172f2SChad Dupuis __qedf_remove(qedf->pdev, QEDF_MODE_RECOVERY);
4053f6b172f2SChad Dupuis /*
4054f6b172f2SChad Dupuis * Reset link and dcbx to down state since we will not get a link down
4055f6b172f2SChad Dupuis * event from the MFW but calling __qedf_remove will essentially be a
4056f6b172f2SChad Dupuis * link down event.
4057f6b172f2SChad Dupuis */
4058f6b172f2SChad Dupuis atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
4059f6b172f2SChad Dupuis atomic_set(&qedf->dcbx, QEDF_DCBX_PENDING);
4060f6b172f2SChad Dupuis __qedf_probe(qedf->pdev, QEDF_MODE_RECOVERY);
4061f6b172f2SChad Dupuis clear_bit(QEDF_IN_RECOVERY, &qedf->flags);
4062f6b172f2SChad Dupuis QEDF_ERR(&qedf->dbg_ctx, "Recovery work complete.\n");
4063f6b172f2SChad Dupuis }
4064f6b172f2SChad Dupuis
40658673daf4SChad Dupuis /* Generic TLV data callback */
qedf_get_generic_tlv_data(void * dev,struct qed_generic_tlvs * data)40668673daf4SChad Dupuis void qedf_get_generic_tlv_data(void *dev, struct qed_generic_tlvs *data)
40678673daf4SChad Dupuis {
40688673daf4SChad Dupuis struct qedf_ctx *qedf;
40698673daf4SChad Dupuis
40708673daf4SChad Dupuis if (!dev) {
40718673daf4SChad Dupuis QEDF_INFO(NULL, QEDF_LOG_EVT,
40728673daf4SChad Dupuis "dev is NULL so ignoring get_generic_tlv_data request.\n");
40738673daf4SChad Dupuis return;
40748673daf4SChad Dupuis }
40758673daf4SChad Dupuis qedf = (struct qedf_ctx *)dev;
40768673daf4SChad Dupuis
40778673daf4SChad Dupuis memset(data, 0, sizeof(struct qed_generic_tlvs));
40788673daf4SChad Dupuis ether_addr_copy(data->mac[0], qedf->mac);
40798673daf4SChad Dupuis }
40808673daf4SChad Dupuis
4081642a0b37SChad Dupuis /*
408261d8658bSDupuis, Chad * Module Init/Remove
408361d8658bSDupuis, Chad */
408461d8658bSDupuis, Chad
qedf_init(void)408561d8658bSDupuis, Chad static int __init qedf_init(void)
408661d8658bSDupuis, Chad {
408761d8658bSDupuis, Chad int ret;
408861d8658bSDupuis, Chad
408961d8658bSDupuis, Chad /* If debug=1 passed, set the default log mask */
409061d8658bSDupuis, Chad if (qedf_debug == QEDF_LOG_DEFAULT)
409161d8658bSDupuis, Chad qedf_debug = QEDF_DEFAULT_LOG_MASK;
409261d8658bSDupuis, Chad
409384b2ba6eSChad Dupuis /*
409484b2ba6eSChad Dupuis * Check that default prio for FIP/FCoE traffic is between 0..7 if a
409584b2ba6eSChad Dupuis * value has been set
409684b2ba6eSChad Dupuis */
409784b2ba6eSChad Dupuis if (qedf_default_prio > -1)
4098a93755cfSChad Dupuis if (qedf_default_prio > 7) {
4099a93755cfSChad Dupuis qedf_default_prio = QEDF_DEFAULT_PRIO;
4100a93755cfSChad Dupuis QEDF_ERR(NULL, "FCoE/FIP priority out of range, resetting to %d.\n",
4101a93755cfSChad Dupuis QEDF_DEFAULT_PRIO);
4102a93755cfSChad Dupuis }
4103a93755cfSChad Dupuis
410461d8658bSDupuis, Chad /* Print driver banner */
410561d8658bSDupuis, Chad QEDF_INFO(NULL, QEDF_LOG_INFO, "%s v%s.\n", QEDF_DESCR,
410661d8658bSDupuis, Chad QEDF_VERSION);
410761d8658bSDupuis, Chad
410861d8658bSDupuis, Chad /* Create kmem_cache for qedf_io_work structs */
410961d8658bSDupuis, Chad qedf_io_work_cache = kmem_cache_create("qedf_io_work_cache",
411061d8658bSDupuis, Chad sizeof(struct qedf_io_work), 0, SLAB_HWCACHE_ALIGN, NULL);
411161d8658bSDupuis, Chad if (qedf_io_work_cache == NULL) {
411261d8658bSDupuis, Chad QEDF_ERR(NULL, "qedf_io_work_cache is NULL.\n");
411361d8658bSDupuis, Chad goto err1;
411461d8658bSDupuis, Chad }
411561d8658bSDupuis, Chad QEDF_INFO(NULL, QEDF_LOG_DISC, "qedf_io_work_cache=%p.\n",
411661d8658bSDupuis, Chad qedf_io_work_cache);
411761d8658bSDupuis, Chad
411861d8658bSDupuis, Chad qed_ops = qed_get_fcoe_ops();
411961d8658bSDupuis, Chad if (!qed_ops) {
412061d8658bSDupuis, Chad QEDF_ERR(NULL, "Failed to get qed fcoe operations\n");
412161d8658bSDupuis, Chad goto err1;
412261d8658bSDupuis, Chad }
412361d8658bSDupuis, Chad
412461d8658bSDupuis, Chad #ifdef CONFIG_DEBUG_FS
412561d8658bSDupuis, Chad qedf_dbg_init("qedf");
412661d8658bSDupuis, Chad #endif
412761d8658bSDupuis, Chad
412861d8658bSDupuis, Chad qedf_fc_transport_template =
412961d8658bSDupuis, Chad fc_attach_transport(&qedf_fc_transport_fn);
413061d8658bSDupuis, Chad if (!qedf_fc_transport_template) {
413161d8658bSDupuis, Chad QEDF_ERR(NULL, "Could not register with FC transport\n");
413261d8658bSDupuis, Chad goto err2;
413361d8658bSDupuis, Chad }
413461d8658bSDupuis, Chad
413561d8658bSDupuis, Chad qedf_fc_vport_transport_template =
413661d8658bSDupuis, Chad fc_attach_transport(&qedf_fc_vport_transport_fn);
413761d8658bSDupuis, Chad if (!qedf_fc_vport_transport_template) {
413861d8658bSDupuis, Chad QEDF_ERR(NULL, "Could not register vport template with FC "
413961d8658bSDupuis, Chad "transport\n");
414061d8658bSDupuis, Chad goto err3;
414161d8658bSDupuis, Chad }
414261d8658bSDupuis, Chad
414361d8658bSDupuis, Chad qedf_io_wq = create_workqueue("qedf_io_wq");
414461d8658bSDupuis, Chad if (!qedf_io_wq) {
414561d8658bSDupuis, Chad QEDF_ERR(NULL, "Could not create qedf_io_wq.\n");
414661d8658bSDupuis, Chad goto err4;
414761d8658bSDupuis, Chad }
414861d8658bSDupuis, Chad
414961d8658bSDupuis, Chad qedf_cb_ops.get_login_failures = qedf_get_login_failures;
415061d8658bSDupuis, Chad
415161d8658bSDupuis, Chad ret = pci_register_driver(&qedf_pci_driver);
415261d8658bSDupuis, Chad if (ret) {
415361d8658bSDupuis, Chad QEDF_ERR(NULL, "Failed to register driver\n");
415461d8658bSDupuis, Chad goto err5;
415561d8658bSDupuis, Chad }
415661d8658bSDupuis, Chad
415761d8658bSDupuis, Chad return 0;
415861d8658bSDupuis, Chad
415961d8658bSDupuis, Chad err5:
416061d8658bSDupuis, Chad destroy_workqueue(qedf_io_wq);
416161d8658bSDupuis, Chad err4:
416261d8658bSDupuis, Chad fc_release_transport(qedf_fc_vport_transport_template);
416361d8658bSDupuis, Chad err3:
416461d8658bSDupuis, Chad fc_release_transport(qedf_fc_transport_template);
416561d8658bSDupuis, Chad err2:
416661d8658bSDupuis, Chad #ifdef CONFIG_DEBUG_FS
416761d8658bSDupuis, Chad qedf_dbg_exit();
416861d8658bSDupuis, Chad #endif
416961d8658bSDupuis, Chad qed_put_fcoe_ops();
417061d8658bSDupuis, Chad err1:
417161d8658bSDupuis, Chad return -EINVAL;
417261d8658bSDupuis, Chad }
417361d8658bSDupuis, Chad
qedf_cleanup(void)417461d8658bSDupuis, Chad static void __exit qedf_cleanup(void)
417561d8658bSDupuis, Chad {
417661d8658bSDupuis, Chad pci_unregister_driver(&qedf_pci_driver);
417761d8658bSDupuis, Chad
417861d8658bSDupuis, Chad destroy_workqueue(qedf_io_wq);
417961d8658bSDupuis, Chad
418061d8658bSDupuis, Chad fc_release_transport(qedf_fc_vport_transport_template);
418161d8658bSDupuis, Chad fc_release_transport(qedf_fc_transport_template);
418261d8658bSDupuis, Chad #ifdef CONFIG_DEBUG_FS
418361d8658bSDupuis, Chad qedf_dbg_exit();
418461d8658bSDupuis, Chad #endif
418561d8658bSDupuis, Chad qed_put_fcoe_ops();
418661d8658bSDupuis, Chad
418761d8658bSDupuis, Chad kmem_cache_destroy(qedf_io_work_cache);
418861d8658bSDupuis, Chad }
418961d8658bSDupuis, Chad
419061d8658bSDupuis, Chad MODULE_LICENSE("GPL");
4191ec6350b8SNilesh Javali MODULE_DESCRIPTION("QLogic FastLinQ 4xxxx FCoE Module");
419261d8658bSDupuis, Chad MODULE_AUTHOR("QLogic Corporation");
419361d8658bSDupuis, Chad MODULE_VERSION(QEDF_VERSION);
419461d8658bSDupuis, Chad module_init(qedf_init);
419561d8658bSDupuis, Chad module_exit(qedf_cleanup);
4196