1 From: Jamie Wellnitz <jamie.wellnitz@emulex.com>
2 Subject: Update lpfc to 8.2.8.3
5 This patch updates the SLES 11 inbox lpfc driver to 8.2.8.3 which has several
6 changes, mainly bugfixes:
8 * Changed version number to 8.2.8.3
9 * Resolved uninitialized node access (CR 83287)
10 * Fixed failing ioctl commands (CR 83850)
11 * Cosmetic coding style clean up
12 * Fix echotest failure when NPIV is enabled (CR 75009)
13 * Fixed Port busy events
14 * Back out slow vports fix (CR 83103)
15 * Added a vendor unique RSCN event to send entire payload to mgmt application
16 * Fixed internal loopback Hornet hardware (CR 83323)
17 * Fixed sysfs write handler for mailbox interface (CR 83674)
18 * Implement driver support for Power Management Suspend/Resume operations (CR
20 * Changed version number to 8.2.8.2
21 * Added data structures required for new events.
22 * Streamlined interrupt enable/disable logic into helper routines
23 * Fixed incorrect decrement of cmd_pending count. (CR 83286)
24 * Fixed internal and external loopback on Hornet. (CR 83323)
25 * Removed unnecessary sleeps during HBA initialization. (CR 82846)
26 * Fixed RSCN address format not handled properly. (CR 82252)
27 * Fixed unload driver with vports locks up driver (CR 83334)
28 * Avoid polling HBA Error Attention when HBA's PCI channel is offline
30 Signed-off-by: Jamie Wellnitz <jamie.wellnitz@emulex.com>
31 Signed-off-by: Hannes Reinecke <hare@suse.de>
33 diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
34 index 273aa4f..8e94902 100644
35 --- a/drivers/scsi/lpfc/lpfc_attr.c
36 +++ b/drivers/scsi/lpfc/lpfc_attr.c
37 @@ -3531,9 +3531,6 @@ sysfs_mbox_write(struct kobject *kobj, struct bin_attribute *bin_attr,
41 - if ((count + off) > MAILBOX_CMD_SIZE)
44 if (off % 4 || count % 4 || (unsigned long)buf % 4)
47 diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
48 index 0c90479..a93c555 100644
49 --- a/drivers/scsi/lpfc/lpfc_crtn.h
50 +++ b/drivers/scsi/lpfc/lpfc_crtn.h
51 @@ -323,11 +323,10 @@ void lpfc_fabric_abort_nport(struct lpfc_nodelist *);
52 void lpfc_fabric_abort_hba(struct lpfc_hba *);
53 void lpfc_fabric_block_timeout(unsigned long);
54 void lpfc_unblock_fabric_iocbs(struct lpfc_hba *);
55 -void lpfc_adjust_queue_depth(struct lpfc_hba *);
56 +void lpfc_rampdown_queue_depth(struct lpfc_hba *);
57 void lpfc_ramp_down_queue_handler(struct lpfc_hba *);
58 void lpfc_ramp_up_queue_handler(struct lpfc_hba *);
59 void lpfc_scsi_dev_block(struct lpfc_hba *);
60 -void lpfc_scsi_dev_rescan(struct lpfc_hba *);
63 lpfc_send_els_failure_event(struct lpfc_hba *, struct lpfc_iocbq *,
64 diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
65 index bce59ec..a95815e 100644
66 --- a/drivers/scsi/lpfc/lpfc_els.c
67 +++ b/drivers/scsi/lpfc/lpfc_els.c
68 @@ -224,7 +224,11 @@ lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
69 /* For ELS_REQUEST64_CR, use the VPI by default */
70 icmd->ulpContext = vport->vpi;
73 + /* The CT field must be 0=INVALID_RPI for the ECHO cmd */
74 + if (elscmd == ELS_CMD_ECHO)
75 + icmd->ulpCt_l = 0; /* context = invalid RPI */
77 + icmd->ulpCt_l = 1; /* context = VPI */
80 bpl = (struct ulp_bde64 *) pbuflist->virt;
81 @@ -2504,6 +2508,15 @@ lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
82 case IOSTAT_LOCAL_REJECT:
83 switch ((irsp->un.ulpWord[4] & 0xff)) {
84 case IOERR_LOOP_OPEN_FAILURE:
85 + if (cmd == ELS_CMD_FLOGI) {
86 + if (PCI_DEVICE_ID_HORNET ==
87 + phba->pcidev->device) {
88 + phba->fc_topology = TOPOLOGY_LOOP;
89 + phba->pport->fc_myDID = 0;
90 + phba->alpa_map[0] = 0;
91 + phba->alpa_map[1] = 0;
94 if (cmd == ELS_CMD_PLOGI && cmdiocb->retry == 0)
97 @@ -3870,27 +3883,21 @@ lpfc_rscn_payload_check(struct lpfc_vport *vport, uint32_t did)
99 rscn_did.un.word = be32_to_cpu(*lp++);
100 payload_len -= sizeof(uint32_t);
101 - switch (rscn_did.un.b.resv) {
102 - case 0: /* Single N_Port ID effected */
103 + switch (rscn_did.un.b.resv & RSCN_ADDRESS_FORMAT_MASK) {
104 + case RSCN_ADDRESS_FORMAT_PORT:
105 if (ns_did.un.word == rscn_did.un.word)
108 - case 1: /* Whole N_Port Area effected */
109 + case RSCN_ADDRESS_FORMAT_AREA:
110 if ((ns_did.un.b.domain == rscn_did.un.b.domain)
111 && (ns_did.un.b.area == rscn_did.un.b.area))
114 - case 2: /* Whole N_Port Domain effected */
115 + case RSCN_ADDRESS_FORMAT_DOMAIN:
116 if (ns_did.un.b.domain == rscn_did.un.b.domain)
120 - /* Unknown Identifier in RSCN node */
121 - lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
122 - "0217 Unknown Identifier in "
123 - "RSCN payload Data: x%x\n",
125 - case 3: /* Whole Fabric effected */
126 + case RSCN_ADDRESS_FORMAT_FABRIC:
130 @@ -3934,6 +3941,49 @@ lpfc_rscn_recovery_check(struct lpfc_vport *vport)
134 + * lpfc_send_rscn_event: Send an RSCN event to management application.
135 + * @vport: pointer to a host virtual N_Port data structure.
136 + * @cmdiocb: pointer to lpfc command iocb data structure.
138 + * lpfc_send_rscn_event sends an RSCN netlink event to management
142 +lpfc_send_rscn_event(struct lpfc_vport *vport,
143 + struct lpfc_iocbq *cmdiocb)
145 + struct lpfc_dmabuf *pcmd;
146 + struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
147 + uint32_t *payload_ptr;
148 + uint32_t payload_len;
149 + struct lpfc_rscn_event_header *rscn_event_data;
151 + pcmd = (struct lpfc_dmabuf *) cmdiocb->context2;
152 + payload_ptr = (uint32_t *) pcmd->virt;
153 + payload_len = be32_to_cpu(*payload_ptr & ~ELS_CMD_MASK);
155 + rscn_event_data = kmalloc(sizeof(struct lpfc_rscn_event_header) +
156 + payload_len, GFP_KERNEL);
157 + if (!rscn_event_data) {
158 + lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
159 + "0147 Failed to allocate memory for RSCN event\n");
162 + rscn_event_data->event_type = FC_REG_RSCN_EVENT;
163 + rscn_event_data->payload_length = payload_len;
164 + memcpy(rscn_event_data->rscn_payload, payload_ptr,
167 + fc_host_post_vendor_event(shost,
168 + fc_get_event_number(),
169 + sizeof(struct lpfc_els_event_header) + payload_len,
170 + (char *)rscn_event_data,
171 + LPFC_NL_VENDOR_ID);
173 + kfree(rscn_event_data);
177 * lpfc_els_rcv_rscn: Process an unsolicited rscn iocb.
178 * @vport: pointer to a host virtual N_Port data structure.
179 * @cmdiocb: pointer to lpfc command iocb data structure.
180 @@ -3980,6 +4030,10 @@ lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
181 "0214 RSCN received Data: x%x x%x x%x x%x\n",
182 vport->fc_flag, payload_len, *lp,
183 vport->fc_rscn_id_cnt);
185 + /* Send an RSCN event to the management application */
186 + lpfc_send_rscn_event(vport, cmdiocb);
188 for (i = 0; i < payload_len/sizeof(uint32_t); i++)
189 fc_host_post_event(shost, fc_get_event_number(),
190 FCH_EVT_RSCN, lp[i]);
191 @@ -5532,7 +5586,7 @@ lpfc_send_els_failure_event(struct lpfc_hba *phba,
192 fc_get_event_number(),
194 (char *)&lsrjt_event,
195 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
196 + LPFC_NL_VENDOR_ID);
199 if ((rspiocbp->iocb.ulpStatus == IOSTAT_NPORT_BSY) ||
200 @@ -5550,7 +5604,7 @@ lpfc_send_els_failure_event(struct lpfc_hba *phba,
201 fc_get_event_number(),
202 sizeof(fabric_event),
203 (char *)&fabric_event,
204 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
205 + LPFC_NL_VENDOR_ID);
209 @@ -5568,32 +5622,68 @@ lpfc_send_els_failure_event(struct lpfc_hba *phba,
211 lpfc_send_els_event(struct lpfc_vport *vport,
212 struct lpfc_nodelist *ndlp,
216 - struct lpfc_els_event_header els_data;
217 + struct lpfc_els_event_header *els_data = NULL;
218 + struct lpfc_logo_event *logo_data = NULL;
219 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
221 - els_data.event_type = FC_REG_ELS_EVENT;
223 + if (*payload == ELS_CMD_LOGO) {
224 + logo_data = kmalloc(sizeof(struct lpfc_logo_event), GFP_KERNEL);
226 + lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
227 + "0148 Failed to allocate memory "
228 + "for LOGO event\n");
231 + els_data = &logo_data->header;
233 + els_data = kmalloc(sizeof(struct lpfc_els_event_header),
236 + lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
237 + "0149 Failed to allocate memory "
238 + "for ELS event\n");
242 + els_data->event_type = FC_REG_ELS_EVENT;
243 + switch (*payload) {
245 - els_data.subcategory = LPFC_EVENT_PLOGI_RCV;
246 + els_data->subcategory = LPFC_EVENT_PLOGI_RCV;
249 - els_data.subcategory = LPFC_EVENT_PRLO_RCV;
250 + els_data->subcategory = LPFC_EVENT_PRLO_RCV;
253 - els_data.subcategory = LPFC_EVENT_ADISC_RCV;
254 + els_data->subcategory = LPFC_EVENT_ADISC_RCV;
257 + els_data->subcategory = LPFC_EVENT_LOGO_RCV;
258 + /* Copy the WWPN in the LOGO payload */
259 + memcpy(logo_data->logo_wwpn, &payload[2],
260 + sizeof(struct lpfc_name));
265 - memcpy(els_data.wwpn, &ndlp->nlp_portname, sizeof(struct lpfc_name));
266 - memcpy(els_data.wwnn, &ndlp->nlp_nodename, sizeof(struct lpfc_name));
267 - fc_host_post_vendor_event(shost,
268 - fc_get_event_number(),
271 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
272 + memcpy(els_data->wwpn, &ndlp->nlp_portname, sizeof(struct lpfc_name));
273 + memcpy(els_data->wwnn, &ndlp->nlp_nodename, sizeof(struct lpfc_name));
274 + if (*payload == ELS_CMD_LOGO) {
275 + fc_host_post_vendor_event(shost,
276 + fc_get_event_number(),
277 + sizeof(struct lpfc_logo_event),
279 + LPFC_NL_VENDOR_ID);
282 + fc_host_post_vendor_event(shost,
283 + fc_get_event_number(),
284 + sizeof(struct lpfc_els_event_header),
286 + LPFC_NL_VENDOR_ID);
292 @@ -5700,7 +5790,7 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
293 phba->fc_stat.elsRcvPLOGI++;
294 ndlp = lpfc_plogi_confirm_nport(phba, payload, ndlp);
296 - lpfc_send_els_event(vport, ndlp, cmd);
297 + lpfc_send_els_event(vport, ndlp, payload);
298 if (vport->port_state < LPFC_DISC_AUTH) {
299 if (!(phba->pport->fc_flag & FC_PT2PT) ||
300 (phba->pport->fc_flag & FC_PT2PT_PLOGI)) {
301 @@ -5738,6 +5828,7 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
302 did, vport->port_state, ndlp->nlp_flag);
304 phba->fc_stat.elsRcvLOGO++;
305 + lpfc_send_els_event(vport, ndlp, payload);
306 if (vport->port_state < LPFC_DISC_AUTH) {
307 rjt_err = LSRJT_UNABLE_TPC;
309 @@ -5750,7 +5841,7 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
310 did, vport->port_state, ndlp->nlp_flag);
312 phba->fc_stat.elsRcvPRLO++;
313 - lpfc_send_els_event(vport, ndlp, cmd);
314 + lpfc_send_els_event(vport, ndlp, payload);
315 if (vport->port_state < LPFC_DISC_AUTH) {
316 rjt_err = LSRJT_UNABLE_TPC;
318 @@ -5768,7 +5859,7 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
319 "RCV ADISC: did:x%x/ste:x%x flg:x%x",
320 did, vport->port_state, ndlp->nlp_flag);
322 - lpfc_send_els_event(vport, ndlp, cmd);
323 + lpfc_send_els_event(vport, ndlp, payload);
324 phba->fc_stat.elsRcvADISC++;
325 if (vport->port_state < LPFC_DISC_AUTH) {
326 rjt_err = LSRJT_UNABLE_TPC;
327 diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
328 index 3d825ff..502a9a5 100644
329 --- a/drivers/scsi/lpfc/lpfc_hbadisc.c
330 +++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
331 @@ -391,7 +391,7 @@ lpfc_send_fastpath_evt(struct lpfc_hba *phba,
332 evt_data_size = sizeof(fast_evt_data->un.
334 } else if ((evt_sub_category == LPFC_EVENT_FABRIC_BUSY) ||
335 - (evt_sub_category == IOSTAT_NPORT_BSY)) {
336 + (evt_sub_category == LPFC_EVENT_PORT_BUSY)) {
337 evt_data = (char *) &fast_evt_data->un.fabric_evt;
338 evt_data_size = sizeof(fast_evt_data->un.fabric_evt);
340 @@ -428,7 +428,7 @@ lpfc_send_fastpath_evt(struct lpfc_hba *phba,
341 fc_get_event_number(),
344 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
345 + LPFC_NL_VENDOR_ID);
347 lpfc_free_fast_evt(phba, fast_evt_data);
349 @@ -635,20 +635,25 @@ lpfc_do_work(void *p)
350 set_user_nice(current, -20);
351 phba->data_flags = 0;
354 + while (!kthread_should_stop()) {
355 /* wait and check worker queue activities */
356 rc = wait_event_interruptible(phba->work_waitq,
357 (test_and_clear_bit(LPFC_DATA_READY,
359 || kthread_should_stop()));
362 - if (kthread_should_stop())
363 + /* Signal wakeup shall terminate the worker thread */
365 + lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
366 + "0433 Wakeup on signal: rc=x%x\n", rc);
370 /* Attend pending lpfc data processing */
371 lpfc_work_done(phba);
373 + phba->worker_thread = NULL;
374 + lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
375 + "0432 Worker thread stopped.\n");
379 @@ -1895,6 +1900,36 @@ lpfc_disable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
380 lpfc_nlp_state_cleanup(vport, ndlp, ndlp->nlp_state,
381 NLP_STE_UNUSED_NODE);
384 + * lpfc_initialize_node: Initialize all fields of node object.
385 + * @vport: Pointer to Virtual Port object.
386 + * @ndlp: Pointer to FC node object.
387 + * @did: FC_ID of the node.
388 + * This function is always called when node object need to
389 + * be initialized. It initializes all the fields of the node
393 +lpfc_initialize_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
396 + INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
397 + INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
398 + INIT_LIST_HEAD(&ndlp->els_reauth_evt.evt_listp);
399 + init_timer(&ndlp->nlp_delayfunc);
400 + ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
401 + ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
402 + init_timer(&ndlp->nlp_reauth_tmr);
403 + ndlp->nlp_reauth_tmr.function = lpfc_reauth_node;
404 + ndlp->nlp_reauth_tmr.data = (unsigned long)ndlp;
405 + ndlp->nlp_DID = did;
406 + ndlp->vport = vport;
407 + ndlp->nlp_sid = NLP_NO_SID;
408 + kref_init(&ndlp->kref);
409 + NLP_INT_NODE_ACT(ndlp);
410 + atomic_set(&ndlp->cmd_pending, 0);
411 + ndlp->cmd_qdepth = LPFC_MAX_TGT_QDEPTH;
414 struct lpfc_nodelist *
415 lpfc_enable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
416 @@ -1935,21 +1970,7 @@ lpfc_enable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
417 /* re-initialize ndlp except of ndlp linked list pointer */
418 memset((((char *)ndlp) + sizeof (struct list_head)), 0,
419 sizeof (struct lpfc_nodelist) - sizeof (struct list_head));
420 - INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
421 - INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
422 - INIT_LIST_HEAD(&ndlp->els_reauth_evt.evt_listp);
423 - init_timer(&ndlp->nlp_delayfunc);
424 - ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
425 - ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
426 - init_timer(&ndlp->nlp_reauth_tmr);
427 - ndlp->nlp_reauth_tmr.function = lpfc_reauth_node;
428 - ndlp->nlp_reauth_tmr.data = (unsigned long)ndlp;
429 - ndlp->nlp_DID = did;
430 - ndlp->vport = vport;
431 - ndlp->nlp_sid = NLP_NO_SID;
432 - /* ndlp management re-initialize */
433 - kref_init(&ndlp->kref);
434 - NLP_INT_NODE_ACT(ndlp);
435 + lpfc_initialize_node(vport, ndlp, did);
437 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
439 @@ -2561,7 +2582,8 @@ lpfc_disc_list_loopmap(struct lpfc_vport *vport)
440 alpa = lpfcAlpaArray[index];
441 if ((vport->fc_myDID & 0xff) == alpa)
443 - lpfc_setup_disc_node(vport, alpa);
444 + if (!(phba->link_flag & LS_LOOPBACK_MODE))
445 + lpfc_setup_disc_node(vport, alpa);
449 @@ -3204,23 +3226,8 @@ lpfc_nlp_init(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
452 memset(ndlp, 0, sizeof (struct lpfc_nodelist));
453 - INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
454 - INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
455 - INIT_LIST_HEAD(&ndlp->els_reauth_evt.evt_listp);
456 - init_timer(&ndlp->nlp_delayfunc);
457 - ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
458 - ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
459 - init_timer(&ndlp->nlp_reauth_tmr);
460 - ndlp->nlp_reauth_tmr.function = lpfc_reauth_node;
461 - ndlp->nlp_reauth_tmr.data = (unsigned long)ndlp;
462 - ndlp->nlp_DID = did;
463 - ndlp->vport = vport;
464 - ndlp->nlp_sid = NLP_NO_SID;
465 + lpfc_initialize_node(vport, ndlp, did);
466 INIT_LIST_HEAD(&ndlp->nlp_listp);
467 - kref_init(&ndlp->kref);
468 - NLP_INT_NODE_ACT(ndlp);
469 - atomic_set(&ndlp->cmd_pending, 0);
470 - ndlp->cmd_qdepth = LPFC_MAX_TGT_QDEPTH;
472 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
473 "node init: did:x%x",
474 diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
475 index 9fc50ef..90d0c5a 100644
476 --- a/drivers/scsi/lpfc/lpfc_hw.h
477 +++ b/drivers/scsi/lpfc/lpfc_hw.h
480 #define BUF_SZ_4K 4096
482 +/* vendor ID used in SCSI netlink calls */
483 +#define LPFC_NL_VENDOR_ID (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX)
485 /* Common Transport structures and definitions */
488 @@ -891,6 +894,12 @@ typedef struct _D_ID { /* Structure is in Big Endian format */
492 +#define RSCN_ADDRESS_FORMAT_PORT 0x0
493 +#define RSCN_ADDRESS_FORMAT_AREA 0x1
494 +#define RSCN_ADDRESS_FORMAT_DOMAIN 0x2
495 +#define RSCN_ADDRESS_FORMAT_FABRIC 0x3
496 +#define RSCN_ADDRESS_FORMAT_MASK 0x3
499 * Structure to define all ELS Payload types
501 diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
502 index c19c631..c0ea4fc 100644
503 --- a/drivers/scsi/lpfc/lpfc_init.c
504 +++ b/drivers/scsi/lpfc/lpfc_init.c
505 @@ -879,8 +879,7 @@ lpfc_handle_eratt(struct lpfc_hba *phba)
506 fc_host_post_vendor_event(shost, fc_get_event_number(),
508 (char *) &board_event,
509 - SCSI_NL_VID_TYPE_PCI
510 - | PCI_VENDOR_ID_EMULEX);
511 + LPFC_NL_VENDOR_ID);
513 if (phba->work_hs & HS_FFER6) {
514 /* Re-establishing Link */
515 @@ -2383,6 +2382,98 @@ lpfc_disable_msix(struct lpfc_hba *phba)
519 + * lpfc_enable_intr: Enable device interrupt.
520 + * @phba: pointer to lpfc hba data structure.
522 + * This routine is invoked to enable device interrupt and associate driver's
523 + * interrupt handler(s) to interrupt vector(s). Depends on the interrupt
524 + * mode configured to the driver, the driver will try to fallback from the
525 + * configured interrupt mode to an interrupt mode which is supported by the
526 + * platform, kernel, and device in the order of: MSI-X -> MSI -> IRQ.
530 + * other values - error
533 +lpfc_enable_intr(struct lpfc_hba *phba)
537 + /* Starting point of configuring interrupt method */
538 + phba->intr_type = NONE;
540 + if (phba->cfg_use_msi == 2) {
541 + /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
542 + retval = lpfc_sli_config_port(phba, 3);
544 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
545 + "0478 Firmware not capable of SLI 3 mode.\n");
547 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
548 + "0479 Firmware capable of SLI 3 mode.\n");
549 + /* Now, try to enable MSI-X interrupt mode */
550 + retval = lpfc_enable_msix(phba);
552 + phba->intr_type = MSIX;
553 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
554 + "0480 enable MSI-X mode.\n");
559 + /* Fallback to MSI if MSI-X initialization failed */
560 + if (phba->cfg_use_msi >= 1 && phba->intr_type == NONE) {
561 + retval = pci_enable_msi(phba->pcidev);
563 + phba->intr_type = MSI;
564 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
565 + "0481 enable MSI mode.\n");
567 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
568 + "0470 enable IRQ mode.\n");
571 + /* MSI-X is the only case the doesn't need to call request_irq */
572 + if (phba->intr_type != MSIX) {
573 + retval = request_irq(phba->pcidev->irq, lpfc_intr_handler,
574 + IRQF_SHARED, LPFC_DRIVER_NAME, phba);
576 + if (phba->intr_type == MSI)
577 + pci_disable_msi(phba->pcidev);
578 + lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
579 + "0471 Enable interrupt handler "
581 + } else if (phba->intr_type != MSI)
582 + phba->intr_type = INTx;
589 + * lpfc_disable_intr: Disable device interrupt.
590 + * @phba: pointer to lpfc hba data structure.
592 + * This routine is invoked to disable device interrupt and disassociate the
593 + * driver's interrupt handler(s) from interrupt vector(s). Depending on the
594 + * interrupt mode, the driver will release the interrupt vector(s) for the
595 + * message signaled interrupt.
598 +lpfc_disable_intr(struct lpfc_hba *phba)
600 + if (phba->intr_type == MSIX)
601 + lpfc_disable_msix(phba);
603 + free_irq(phba->pcidev->irq, phba);
604 + if (phba->intr_type == MSI)
605 + pci_disable_msi(phba->pcidev);
611 * lpfc_pci_probe_one: lpfc PCI probe func to register device to PCI subsystem.
612 * @pdev: pointer to PCI device
613 * @pid: pointer to PCI device identifier
614 @@ -2634,7 +2725,6 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
615 lpfc_debugfs_initialize(vport);
617 pci_set_drvdata(pdev, shost);
618 - phba->intr_type = NONE;
620 phba->MBslimaddr = phba->slim_memmap_p;
621 phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
622 @@ -2643,48 +2733,11 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
623 phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
625 /* Configure and enable interrupt */
626 - if (phba->cfg_use_msi == 2) {
627 - /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
628 - error = lpfc_sli_config_port(phba, 3);
630 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
631 - "0427 Firmware not capable of SLI 3 mode.\n");
633 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
634 - "0426 Firmware capable of SLI 3 mode.\n");
635 - /* Now, try to enable MSI-X interrupt mode */
636 - error = lpfc_enable_msix(phba);
638 - phba->intr_type = MSIX;
639 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
640 - "0430 enable MSI-X mode.\n");
645 - /* Fallback to MSI if MSI-X initialization failed */
646 - if (phba->cfg_use_msi >= 1 && phba->intr_type == NONE) {
647 - retval = pci_enable_msi(phba->pcidev);
649 - phba->intr_type = MSI;
650 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
651 - "0473 enable MSI mode.\n");
653 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
654 - "0452 enable IRQ mode.\n");
657 - /* MSI-X is the only case the doesn't need to call request_irq */
658 - if (phba->intr_type != MSIX) {
659 - retval = request_irq(phba->pcidev->irq, lpfc_intr_handler,
660 - IRQF_SHARED, LPFC_DRIVER_NAME, phba);
662 - lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0451 Enable "
663 - "interrupt handler failed\n");
665 - goto out_disable_msi;
666 - } else if (phba->intr_type != MSI)
667 - phba->intr_type = INTx;
668 + error = lpfc_enable_intr(phba);
670 + lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
671 + "0426 Failed to enable interrupt.\n");
672 + goto out_destroy_port;
675 phba->dfc_host = lpfcdfc_host_add(pdev, shost, phba);
676 @@ -2731,7 +2784,7 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
677 fc_host_post_vendor_event(shost, fc_get_event_number(),
678 sizeof(adapter_event),
679 (char *) &adapter_event,
680 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
681 + LPFC_NL_VENDOR_ID);
683 scsi_scan_host(shost);
685 @@ -2747,15 +2800,8 @@ out_free_irq:
686 lpfcdfc_host_del(phba->dfc_host);
687 lpfc_stop_phba_timers(phba);
688 phba->pport->work_port_events = 0;
690 - if (phba->intr_type == MSIX)
691 - lpfc_disable_msix(phba);
693 - free_irq(phba->pcidev->irq, phba);
696 - if (phba->intr_type == MSI)
697 - pci_disable_msi(phba->pcidev);
698 + lpfc_disable_intr(phba);
702 kthread_stop(phba->worker_thread);
703 @@ -2796,7 +2842,7 @@ out:
704 * @pdev: pointer to PCI device
706 * This routine is to be registered to the kernel's PCI subsystem. When an
707 - * Emulex HBA is removed from PCI bus. It perform all the necessary cleanup
708 + * Emulex HBA is removed from PCI bus, it performs all the necessary cleanup
709 * for the HBA device to be removed from the PCI subsystem properly.
711 static void __devexit
712 @@ -2804,12 +2850,11 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
714 struct Scsi_Host *shost = pci_get_drvdata(pdev);
715 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
716 + struct lpfc_vport **vports;
717 struct lpfc_hba *phba = vport->phba;
719 int bars = pci_select_bars(pdev, IORESOURCE_MEM);
721 - /* In case PCI channel permanently disabled, rescan SCSI devices */
722 - if (pdev->error_state == pci_channel_io_perm_failure)
723 - lpfc_scsi_dev_rescan(phba);
724 lpfcdfc_host_del(phba->dfc_host);
725 phba->dfc_host = NULL;
727 @@ -2822,6 +2867,14 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
729 kthread_stop(phba->worker_thread);
731 + /* Release all the vports against this physical port */
732 + vports = lpfc_create_vport_work_array(phba);
733 + if (vports != NULL)
734 + for (i = 1; i <= phba->max_vpi && vports[i] != NULL; i++)
735 + fc_vport_terminate(vports[i]->fc_vport);
736 + lpfc_destroy_vport_work_array(phba, vports);
738 + /* Remove FC host and then SCSI host with the physical port */
739 fc_remove_host(shost);
740 scsi_remove_host(shost);
742 @@ -2841,13 +2894,8 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
744 lpfc_debugfs_terminate(vport);
746 - if (phba->intr_type == MSIX)
747 - lpfc_disable_msix(phba);
749 - free_irq(phba->pcidev->irq, phba);
750 - if (phba->intr_type == MSI)
751 - pci_disable_msi(phba->pcidev);
753 + /* Disable interrupt */
754 + lpfc_disable_intr(phba);
756 pci_set_drvdata(pdev, NULL);
757 scsi_host_put(shost);
758 @@ -2879,6 +2927,111 @@ lpfc_pci_remove_one(struct pci_dev *pdev)
762 + * lpfc_pci_suspend_one: lpfc PCI func to suspend device for power management.
763 + * @pdev: pointer to PCI device
764 + * @msg: power management message
766 + * This routine is to be registered to the kernel's PCI subsystem to support
767 + * system Power Management (PM). When PM invokes this method, it quiesces the
768 + * device by stopping the driver's worker thread for the device, turning off
769 + * device's interrupt and DMA, and bring the device offline. Note that as the
770 + * driver implements the minimum PM requirements to a power-aware driver's PM
771 + * support for suspend/resume -- all the possible PM messages (SUSPEND,
772 + * HIBERNATE, FREEZE) to the suspend() method call will be treated as SUSPEND
773 + * and the driver will fully reinitialize its device during resume() method
774 + * call, the driver will set device to PCI_D3hot state in PCI config space
775 + * instead of setting it according to the @msg provided by the PM.
778 + * 0 - driver suspended the device
782 +lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg)
784 + struct Scsi_Host *shost = pci_get_drvdata(pdev);
785 + struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
787 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
788 + "0473 PCI device Power Management suspend.\n");
790 + /* Bring down the device */
791 + lpfc_offline_prep(phba);
792 + lpfc_offline(phba);
793 + kthread_stop(phba->worker_thread);
795 + /* Disable interrupt from device */
796 + lpfc_disable_intr(phba);
798 + /* Save device state to PCI config space */
799 + pci_save_state(pdev);
800 + pci_set_power_state(pdev, PCI_D3hot);
806 + * lpfc_pci_resume_one: lpfc PCI func to resume device for power management.
807 + * @pdev: pointer to PCI device
809 + * This routine is to be registered to the kernel's PCI subsystem to support
810 + * system Power Management (PM). When PM invokes this method, it restores
811 + * the device's PCI config space state and fully reinitializes the device
812 + * and brings it online. Note that as the driver implements the minimum PM
813 + * requirements to a power-aware driver's PM for suspend/resume -- all
814 + * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend()
815 + * method call will be treated as SUSPEND and the driver will fully
816 + * reinitialize its device during resume() method call, the device will be
817 + * set to PCI_D0 directly in PCI config space before restoring the state.
820 + * 0 - driver suspended the device
824 +lpfc_pci_resume_one(struct pci_dev *pdev)
826 + struct Scsi_Host *shost = pci_get_drvdata(pdev);
827 + struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
830 + lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
831 + "0452 PCI device Power Management resume.\n");
833 + /* Restore device state from PCI config space */
834 + pci_set_power_state(pdev, PCI_D0);
835 + pci_restore_state(pdev);
836 + if (pdev->is_busmaster)
837 + pci_set_master(pdev);
839 + /* Startup the kernel thread for this host adapter. */
840 + phba->worker_thread = kthread_run(lpfc_do_work, phba,
841 + "lpfc_worker_%d", phba->brd_no);
842 + if (IS_ERR(phba->worker_thread)) {
843 + error = PTR_ERR(phba->worker_thread);
844 + lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
845 + "0434 PM resume failed to start worker "
846 + "thread: error=x%x.\n", error);
850 + /* Enable interrupt from device */
851 + error = lpfc_enable_intr(phba);
853 + lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
854 + "0430 PM resume Failed to enable interrupt: "
855 + "error=x%x.\n", error);
859 + /* Restart HBA and bring it online */
860 + lpfc_sli_brdrestart(phba);
867 * lpfc_io_error_detected: Driver method for handling PCI I/O error detected.
868 * @pdev: pointer to PCI device.
869 * @state: the current PCI connection state.
870 @@ -2921,13 +3074,8 @@ static pci_ers_result_t lpfc_io_error_detected(struct pci_dev *pdev,
871 pring = &psli->ring[psli->fcp_ring];
872 lpfc_sli_abort_iocb_ring(phba, pring);
874 - if (phba->intr_type == MSIX)
875 - lpfc_disable_msix(phba);
877 - free_irq(phba->pcidev->irq, phba);
878 - if (phba->intr_type == MSI)
879 - pci_disable_msi(phba->pcidev);
881 + /* Disable interrupt */
882 + lpfc_disable_intr(phba);
884 /* Request a slot reset. */
885 return PCI_ERS_RESULT_NEED_RESET;
886 @@ -2955,7 +3103,7 @@ static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev)
887 struct Scsi_Host *shost = pci_get_drvdata(pdev);
888 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
889 struct lpfc_sli *psli = &phba->sli;
893 dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n");
894 if (pci_enable_device_mem(pdev)) {
895 @@ -2971,48 +3119,12 @@ static pci_ers_result_t lpfc_io_slot_reset(struct pci_dev *pdev)
896 spin_unlock_irq(&phba->hbalock);
898 /* Enable configured interrupt method */
899 - phba->intr_type = NONE;
900 - if (phba->cfg_use_msi == 2) {
901 - /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */
902 - error = lpfc_sli_config_port(phba, 3);
904 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
905 - "0478 Firmware not capable of SLI 3 mode.\n");
907 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
908 - "0479 Firmware capable of SLI 3 mode.\n");
909 - /* Now, try to enable MSI-X interrupt mode */
910 - error = lpfc_enable_msix(phba);
912 - phba->intr_type = MSIX;
913 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
914 - "0480 enable MSI-X mode.\n");
919 - /* Fallback to MSI if MSI-X initialization failed */
920 - if (phba->cfg_use_msi >= 1 && phba->intr_type == NONE) {
921 - retval = pci_enable_msi(phba->pcidev);
923 - phba->intr_type = MSI;
924 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
925 - "0481 enable MSI mode.\n");
927 - lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
928 - "0470 enable IRQ mode.\n");
931 - /* MSI-X is the only case the doesn't need to call request_irq */
932 - if (phba->intr_type != MSIX) {
933 - retval = request_irq(phba->pcidev->irq, lpfc_intr_handler,
934 - IRQF_SHARED, LPFC_DRIVER_NAME, phba);
936 - lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
937 - "0471 Enable interrupt handler "
939 - } else if (phba->intr_type != MSI)
940 - phba->intr_type = INTx;
941 + error = lpfc_enable_intr(phba);
943 + lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
944 + "0427 Cannot re-enable interrupt after "
946 + return PCI_ERS_RESULT_DISCONNECT;
949 /* Take device offline; this will perform cleanup */
950 @@ -3130,6 +3242,8 @@ static struct pci_driver lpfc_driver = {
951 .id_table = lpfc_id_table,
952 .probe = lpfc_pci_probe_one,
953 .remove = __devexit_p(lpfc_pci_remove_one),
954 + .suspend = lpfc_pci_suspend_one,
955 + .resume = lpfc_pci_resume_one,
956 .err_handler = &lpfc_err_handler,
959 diff --git a/drivers/scsi/lpfc/lpfc_ioctl.c b/drivers/scsi/lpfc/lpfc_ioctl.c
960 index 242bed3..e80d157 100644
961 --- a/drivers/scsi/lpfc/lpfc_ioctl.c
962 +++ b/drivers/scsi/lpfc/lpfc_ioctl.c
963 @@ -828,10 +828,10 @@ lpfc_ioctl_send_mgmt_cmd(struct lpfc_hba * phba,
966 send_mgmt_cmd_free_outdmp:
967 - spin_lock_irq(shost->host_lock);
968 dfc_cmd_data_free(phba, outdmp);
969 send_mgmt_cmd_free_indmp:
970 dfc_cmd_data_free(phba, indmp);
971 + spin_lock_irq(shost->host_lock);
972 send_mgmt_cmd_free_bmpvirt:
973 lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
974 send_mgmt_cmd_free_bmp:
975 @@ -2069,14 +2069,14 @@ __dfc_cmd_data_alloc(struct lpfc_hba * phba,
980 + bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
981 pci_dma_sync_single_for_device(phba->pcidev,
982 dmp->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
986 memset((uint8_t *)dmp->dma.virt, 0, cnt);
987 - bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
989 + bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
991 /* build buffer ptr list for IOCB */
992 bpl->addrLow = le32_to_cpu(putPaddrLow(dmp->dma.phys));
993 bpl->addrHigh = le32_to_cpu(putPaddrHigh(dmp->dma.phys));
994 diff --git a/drivers/scsi/lpfc/lpfc_menlo.c b/drivers/scsi/lpfc/lpfc_menlo.c
995 index 60d3df8..aa36c16 100644
996 --- a/drivers/scsi/lpfc/lpfc_menlo.c
997 +++ b/drivers/scsi/lpfc/lpfc_menlo.c
999 #include "lpfc_vport.h"
1001 #define MENLO_CMD_FW_DOWNLOAD 0x00000002
1002 +#define MENLO_CMD_LOOPBACK 0x00000014
1004 static void lpfc_menlo_iocb_timeout_cmpl(struct lpfc_hba *,
1005 struct lpfc_iocbq *, struct lpfc_iocbq *);
1006 @@ -686,6 +687,16 @@ lpfc_menlo_write(struct lpfc_hba *phba,
1008 memcpy((uint8_t *) mlast->dma.virt, buf, count);
1010 + if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_LOOPBACK) {
1012 + tmpptr = (uint32_t *)mlast->dma.virt;
1014 + phba->link_flag |= LS_LOOPBACK_MODE;
1016 + phba->link_flag &= ~LS_LOOPBACK_MODE;
1020 if (sysfs_menlo->cmdhdr.cmd == MENLO_CMD_FW_DOWNLOAD
1021 && genreq->offset < hdr_offset) {
1022 if (sysfs_menlo->cr.indmp
1023 diff --git a/drivers/scsi/lpfc/lpfc_nl.h b/drivers/scsi/lpfc/lpfc_nl.h
1024 index 1accb5a..991ad53 100644
1025 --- a/drivers/scsi/lpfc/lpfc_nl.h
1026 +++ b/drivers/scsi/lpfc/lpfc_nl.h
1028 * The payload sent via the fc transport is one-way driver->application.
1031 +/* RSCN event header */
1032 +struct lpfc_rscn_event_header {
1033 + uint32_t event_type;
1034 + uint32_t payload_length; /* RSCN data length in bytes */
1035 + uint32_t rscn_payload[];
1038 /* els event header */
1039 struct lpfc_els_event_header {
1040 uint32_t event_type;
1041 @@ -65,6 +72,7 @@ struct lpfc_els_event_header {
1042 #define LPFC_EVENT_PRLO_RCV 0x02
1043 #define LPFC_EVENT_ADISC_RCV 0x04
1044 #define LPFC_EVENT_LSRJT_RCV 0x08
1045 +#define LPFC_EVENT_LOGO_RCV 0x10
1047 /* special els lsrjt event */
1048 struct lpfc_lsrjt_event {
1049 @@ -74,6 +82,11 @@ struct lpfc_lsrjt_event {
1050 uint32_t explanation;
1053 +/* special els logo event */
1054 +struct lpfc_logo_event {
1055 + struct lpfc_els_event_header header;
1056 + uint8_t logo_wwpn[8];
1059 /* fabric event header */
1060 struct lpfc_fabric_event_header {
1061 @@ -125,6 +138,7 @@ struct lpfc_scsi_varqueuedepth_event {
1062 /* special case scsi check condition event */
1063 struct lpfc_scsi_check_condition_event {
1064 struct lpfc_scsi_event_header scsi_event;
1069 diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
1070 index a116875..a7ea952 100644
1071 --- a/drivers/scsi/lpfc/lpfc_scsi.c
1072 +++ b/drivers/scsi/lpfc/lpfc_scsi.c
1073 @@ -147,12 +147,19 @@ lpfc_send_sdev_queuedepth_change_event(struct lpfc_hba *phba,
1078 - * This function is called with no lock held when there is a resource
1079 - * error in driver or in firmware.
1082 + * lpfc_rampdown_queue_depth: Post RAMP_DOWN_QUEUE event to worker thread.
1083 + * @phba: The Hba for which this call is being executed.
1085 + * This routine is called when there is resource error in driver or firmware.
1086 + * This routine posts WORKER_RAMP_DOWN_QUEUE event for @phba. This routine
1087 + * posts at most 1 event each second. This routine wakes up worker thread of
1088 + * @phba to process WORKER_RAM_DOWN_EVENT event.
1090 + * This routine should be called with no lock held.
1093 -lpfc_adjust_queue_depth(struct lpfc_hba *phba)
1094 +lpfc_rampdown_queue_depth(struct lpfc_hba *phba)
1096 unsigned long flags;
1097 uint32_t evt_posted;
1098 @@ -335,22 +342,6 @@ lpfc_scsi_dev_block(struct lpfc_hba *phba)
1099 lpfc_destroy_vport_work_array(phba, vports);
1103 -lpfc_scsi_dev_rescan(struct lpfc_hba *phba)
1105 - struct lpfc_vport **vports;
1106 - struct Scsi_Host *shost;
1109 - vports = lpfc_create_vport_work_array(phba);
1110 - if (vports != NULL)
1111 - for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
1112 - shost = lpfc_shost_from_vport(vports[i]);
1113 - scsi_scan_host(shost);
1115 - lpfc_destroy_vport_work_array(phba, vports);
1119 * This routine allocates a scsi buffer, which contains all the necessary
1120 * information needed to initiate a SCSI I/O. The non-DMAable buffer region
1121 @@ -861,7 +852,8 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
1123 lpfc_cmd->result = pIocbOut->iocb.un.ulpWord[4];
1124 lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
1125 - atomic_dec(&pnode->cmd_pending);
1126 + if (pnode && NLP_CHK_NODE_ACT(pnode))
1127 + atomic_dec(&pnode->cmd_pending);
1129 if (lpfc_cmd->status) {
1130 if (lpfc_cmd->status == IOSTAT_LOCAL_REJECT &&
1131 @@ -951,23 +943,31 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
1132 time_after(jiffies, lpfc_cmd->start_time +
1133 msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) {
1134 spin_lock_irqsave(sdev->host->host_lock, flags);
1135 - if ((pnode->cmd_qdepth > atomic_read(&pnode->cmd_pending) &&
1136 - (atomic_read(&pnode->cmd_pending) > LPFC_MIN_TGT_QDEPTH) &&
1137 - ((cmd->cmnd[0] == READ_10) || (cmd->cmnd[0] == WRITE_10))))
1138 - pnode->cmd_qdepth = atomic_read(&pnode->cmd_pending);
1140 - pnode->last_change_time = jiffies;
1141 + if (pnode && NLP_CHK_NODE_ACT(pnode)) {
1142 + if (pnode->cmd_qdepth >
1143 + atomic_read(&pnode->cmd_pending) &&
1144 + (atomic_read(&pnode->cmd_pending) >
1145 + LPFC_MIN_TGT_QDEPTH) &&
1146 + ((cmd->cmnd[0] == READ_10) ||
1147 + (cmd->cmnd[0] == WRITE_10)))
1148 + pnode->cmd_qdepth =
1149 + atomic_read(&pnode->cmd_pending);
1151 + pnode->last_change_time = jiffies;
1153 spin_unlock_irqrestore(sdev->host->host_lock, flags);
1154 - } else if ((pnode->cmd_qdepth < LPFC_MAX_TGT_QDEPTH) &&
1155 + } else if (pnode && NLP_CHK_NODE_ACT(pnode)) {
1156 + if ((pnode->cmd_qdepth < LPFC_MAX_TGT_QDEPTH) &&
1157 time_after(jiffies, pnode->last_change_time +
1158 - msecs_to_jiffies(LPFC_TGTQ_INTERVAL))) {
1159 - spin_lock_irqsave(sdev->host->host_lock, flags);
1160 - pnode->cmd_qdepth += pnode->cmd_qdepth *
1161 - LPFC_TGTQ_RAMPUP_PCENT / 100;
1162 - if (pnode->cmd_qdepth > LPFC_MAX_TGT_QDEPTH)
1163 - pnode->cmd_qdepth = LPFC_MAX_TGT_QDEPTH;
1164 - pnode->last_change_time = jiffies;
1165 - spin_unlock_irqrestore(sdev->host->host_lock, flags);
1166 + msecs_to_jiffies(LPFC_TGTQ_INTERVAL))) {
1167 + spin_lock_irqsave(sdev->host->host_lock, flags);
1168 + pnode->cmd_qdepth += pnode->cmd_qdepth *
1169 + LPFC_TGTQ_RAMPUP_PCENT / 100;
1170 + if (pnode->cmd_qdepth > LPFC_MAX_TGT_QDEPTH)
1171 + pnode->cmd_qdepth = LPFC_MAX_TGT_QDEPTH;
1172 + pnode->last_change_time = jiffies;
1173 + spin_unlock_irqrestore(sdev->host->host_lock, flags);
1177 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
1178 @@ -1363,13 +1363,13 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
1179 cmnd->result = ScsiResult(DID_TRANSPORT_DISRUPTED, 0);
1180 goto out_fail_command;
1183 - if (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth)
1184 + if (vport->cfg_max_scsicmpl_time &&
1185 + (atomic_read(&ndlp->cmd_pending) >= ndlp->cmd_qdepth))
1188 lpfc_cmd = lpfc_get_scsi_buf(phba);
1189 if (lpfc_cmd == NULL) {
1190 - lpfc_adjust_queue_depth(phba);
1191 + lpfc_rampdown_queue_depth(phba);
1193 lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
1194 "0707 driver's buffer pool is empty, "
1195 @@ -1397,9 +1397,10 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
1196 atomic_inc(&ndlp->cmd_pending);
1197 err = lpfc_sli_issue_iocb(phba, &phba->sli.ring[psli->fcp_ring],
1198 &lpfc_cmd->cur_iocbq, SLI_IOCB_RET_IOCB);
1201 + atomic_dec(&ndlp->cmd_pending);
1202 goto out_host_busy_free_buf;
1205 if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
1206 lpfc_sli_poll_fcp_ring(phba);
1207 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
1208 @@ -1409,7 +1410,6 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
1211 out_host_busy_free_buf:
1212 - atomic_dec(&ndlp->cmd_pending);
1213 lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
1214 lpfc_release_scsi_buf(phba, lpfc_cmd);
1216 @@ -1575,7 +1575,7 @@ lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
1217 fc_get_event_number(),
1219 (char *)&scsi_event,
1220 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1221 + LPFC_NL_VENDOR_ID);
1223 if (!rdata || pnode->nlp_state != NLP_STE_MAPPED_NODE) {
1224 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
1225 @@ -1672,7 +1672,7 @@ lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
1226 fc_get_event_number(),
1228 (char *)&scsi_event,
1229 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1230 + LPFC_NL_VENDOR_ID);
1232 lpfc_block_error_handler(cmnd);
1234 diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
1235 index d4341df..ac78493 100644
1236 --- a/drivers/scsi/lpfc/lpfc_sli.c
1237 +++ b/drivers/scsi/lpfc/lpfc_sli.c
1238 @@ -1985,7 +1985,7 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
1239 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1240 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
1241 spin_unlock_irqrestore(&phba->hbalock, iflag);
1242 - lpfc_adjust_queue_depth(phba);
1243 + lpfc_rampdown_queue_depth(phba);
1244 spin_lock_irqsave(&phba->hbalock, iflag);
1247 @@ -2228,7 +2228,7 @@ lpfc_sli_handle_slow_ring_event(struct lpfc_hba *phba,
1248 if ((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
1249 (irsp->un.ulpWord[4] == IOERR_NO_RESOURCES)) {
1250 spin_unlock_irqrestore(&phba->hbalock, iflag);
1251 - lpfc_adjust_queue_depth(phba);
1252 + lpfc_rampdown_queue_depth(phba);
1253 spin_lock_irqsave(&phba->hbalock, iflag);
1256 @@ -2793,7 +2793,6 @@ lpfc_sli_brdrestart(struct lpfc_hba *phba)
1259 struct lpfc_sli *psli;
1260 - uint16_t skip_post;
1261 volatile uint32_t word0;
1262 void __iomem *to_slim;
1264 @@ -2818,13 +2817,10 @@ lpfc_sli_brdrestart(struct lpfc_hba *phba)
1265 readl(to_slim); /* flush */
1267 /* Only skip post after fc_ffinit is completed */
1268 - if (phba->pport->port_state) {
1270 + if (phba->pport->port_state)
1271 word0 = 1; /* This is really setting up word1 */
1275 word0 = 0; /* This is really setting up word1 */
1277 to_slim = phba->MBslimaddr + sizeof (uint32_t);
1278 writel(*(uint32_t *) mb, to_slim);
1279 readl(to_slim); /* flush */
1280 @@ -2838,10 +2834,8 @@ lpfc_sli_brdrestart(struct lpfc_hba *phba)
1281 memset(&psli->lnk_stat_offsets, 0, sizeof(psli->lnk_stat_offsets));
1282 psli->stats_start = get_seconds();
1288 + /* Give the INITFF and Post time to settle. */
1291 lpfc_hba_down_post(phba);
1293 @@ -3087,7 +3081,6 @@ lpfc_sli_config_port(struct lpfc_hba *phba, int sli_mode)
1294 spin_unlock_irq(&phba->hbalock);
1295 phba->pport->port_state = LPFC_VPORT_UNKNOWN;
1296 lpfc_sli_brdrestart(phba);
1298 rc = lpfc_sli_chipset_init(phba);
1301 @@ -4041,7 +4034,7 @@ lpfc_sli_async_event_handler(struct lpfc_hba * phba,
1302 shost = lpfc_shost_from_vport(phba->pport);
1303 fc_host_post_vendor_event(shost, fc_get_event_number(),
1304 sizeof(temp_event_data), (char *) &temp_event_data,
1305 - SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX);
1306 + LPFC_NL_VENDOR_ID);
1310 @@ -5220,6 +5213,10 @@ lpfc_sli_check_eratt(struct lpfc_hba *phba)
1314 + /* If PCI channel is offline, don't process it */
1315 + if (unlikely(pci_channel_offline(phba->pcidev)))
1318 /* If somebody is waiting to handle an eratt, don't process it
1319 * here. The brdkill function will do this.
1321 diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
1322 index 899a337..a42cef2 100644
1323 --- a/drivers/scsi/lpfc/lpfc_version.h
1324 +++ b/drivers/scsi/lpfc/lpfc_version.h
1326 * included with this package. *
1327 *******************************************************************/
1329 -#define LPFC_DRIVER_VERSION "8.2.8.1"
1330 +#define LPFC_DRIVER_VERSION "8.2.8.3"
1332 #define LPFC_DRIVER_NAME "lpfc"
1333 #define LPFC_SP_DRIVER_HANDLER_NAME "lpfc:sp"
1334 diff --git a/drivers/scsi/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c
1335 index 8761840..c3a3f6e 100644
1336 --- a/drivers/scsi/lpfc/lpfc_vport.c
1337 +++ b/drivers/scsi/lpfc/lpfc_vport.c
1338 @@ -605,6 +605,8 @@ lpfc_vport_delete(struct fc_vport *fc_vport)
1339 spin_unlock_irq(&phba->hbalock);
1340 kfree(vport->vname);
1341 lpfc_debugfs_terminate(vport);
1343 + /* Remove FC host and then SCSI host with the vport */
1344 fc_remove_host(lpfc_shost_from_vport(vport));
1345 scsi_remove_host(lpfc_shost_from_vport(vport));
1347 @@ -689,8 +691,6 @@ lpfc_vport_delete(struct fc_vport *fc_vport)
1349 vport->unreg_vpi_cmpl = VPORT_INVAL;
1350 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
1351 - if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
1353 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
1354 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
1355 timeout = schedule_timeout(timeout);