1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2008 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/blkdev.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
26 #include <scsi/scsi_device.h>
27 #include <scsi/scsi_transport_fc.h>
29 #include <scsi/scsi.h>
33 #include "lpfc_disc.h"
34 #include "lpfc_scsi.h"
36 #include "lpfc_logmsg.h"
37 #include "lpfc_crtn.h"
38 #include "lpfc_compat.h"
41 * lpfc_dump_mem: Prepare a mailbox command for retrieving HBA's VPD memory.
42 * @phba: pointer to lpfc hba data structure.
43 * @pmb: pointer to the driver internal queue element for mailbox command.
44 * @offset: offset for dumping VPD memory mailbox command.
46 * The dump mailbox command provides a method for the device driver to obtain
47 * various types of information from the HBA device.
49 * This routine prepares the mailbox command for dumping HBA Vital Product
50 * Data (VPD) memory. This mailbox command is to be used for retrieving a
51 * portion (DMP_RSP_SIZE bytes) of a HBA's VPD from the HBA at an address
52 * offset specified by the offset parameter.
55 lpfc_dump_mem(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
, uint16_t offset
)
63 /* Setup to dump VPD region */
64 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
65 mb
->mbxCommand
= MBX_DUMP_MEMORY
;
67 mb
->un
.varDmp
.type
= DMP_NV_PARAMS
;
68 mb
->un
.varDmp
.entry_index
= offset
;
69 mb
->un
.varDmp
.region_id
= DMP_REGION_VPD
;
70 mb
->un
.varDmp
.word_cnt
= (DMP_RSP_SIZE
/ sizeof (uint32_t));
72 mb
->un
.varDmp
.resp_offset
= 0;
74 mb
->mbxOwner
= OWN_HOST
;
79 * lpfc_read_nv: Prepare a mailbox command for reading HBA's NVRAM param.
80 * @phba: pointer to lpfc hba data structure.
81 * @pmb: pointer to the driver internal queue element for mailbox command.
83 * The read NVRAM mailbox command returns the HBA's non-volatile parameters
84 * that are used as defaults when the Fibre Channel link is brought on-line.
86 * This routine prepares the mailbox command for reading information stored
87 * in the HBA's NVRAM. Specifically, the HBA's WWNN and WWPN.
90 lpfc_read_nv(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
95 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
96 mb
->mbxCommand
= MBX_READ_NV
;
97 mb
->mbxOwner
= OWN_HOST
;
102 * lpfc_config_async: Prepare a mailbox command for enabling HBA async event.
103 * @phba: pointer to lpfc hba data structure.
104 * @pmb: pointer to the driver internal queue element for mailbox command.
105 * @ring: ring number for the asynchronous event to be configured.
107 * The asynchronous event enable mailbox command is used to enable the
108 * asynchronous event posting via the ASYNC_STATUS_CN IOCB response and
109 * specifies the default ring to which events are posted.
111 * This routine prepares the mailbox command for enabling HBA asynchronous
112 * event support on a IOCB ring.
115 lpfc_config_async(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
,
121 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
122 mb
->mbxCommand
= MBX_ASYNCEVT_ENABLE
;
123 mb
->un
.varCfgAsyncEvent
.ring
= ring
;
124 mb
->mbxOwner
= OWN_HOST
;
129 * lpfc_heart_beat: Prepare a mailbox command for heart beat.
130 * @phba: pointer to lpfc hba data structure.
131 * @pmb: pointer to the driver internal queue element for mailbox command.
133 * The heart beat mailbox command is used to detect an unresponsive HBA, which
134 * is defined as any device where no error attention is sent and both mailbox
135 * and rings are not processed.
137 * This routine prepares the mailbox command for issuing a heart beat in the
138 * form of mailbox command to the HBA. The timely completion of the heart
139 * beat mailbox command indicates the health of the HBA.
142 lpfc_heart_beat(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
147 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
148 mb
->mbxCommand
= MBX_HEARTBEAT
;
149 mb
->mbxOwner
= OWN_HOST
;
154 * lpfc_read_la: Prepare a mailbox command for reading HBA link attention.
155 * @phba: pointer to lpfc hba data structure.
156 * @pmb: pointer to the driver internal queue element for mailbox command.
157 * @mp: DMA buffer memory for reading the link attention information into.
159 * The read link attention mailbox command is issued to read the Link Event
160 * Attention information indicated by the HBA port when the Link Event bit
161 * of the Host Attention (HSTATT) register is set to 1. A Link Event
162 * Attention occurs based on an exception detected at the Fibre Channel link
165 * This routine prepares the mailbox command for reading HBA link attention
166 * information. A DMA memory has been set aside and address passed to the
167 * HBA through @mp for the HBA to DMA link attention information into the
168 * memory as part of the execution of the mailbox command.
171 * 0 - Success (currently always return 0)
174 lpfc_read_la(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
, struct lpfc_dmabuf
*mp
)
177 struct lpfc_sli
*psli
;
181 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
183 INIT_LIST_HEAD(&mp
->list
);
184 mb
->mbxCommand
= MBX_READ_LA64
;
185 mb
->un
.varReadLA
.un
.lilpBde64
.tus
.f
.bdeSize
= 128;
186 mb
->un
.varReadLA
.un
.lilpBde64
.addrHigh
= putPaddrHigh(mp
->phys
);
187 mb
->un
.varReadLA
.un
.lilpBde64
.addrLow
= putPaddrLow(mp
->phys
);
189 /* Save address for later completion and set the owner to host so that
190 * the FW knows this mailbox is available for processing.
192 pmb
->context1
= (uint8_t *) mp
;
193 mb
->mbxOwner
= OWN_HOST
;
198 * lpfc_clear_la: Prepare a mailbox command for clearing HBA link attention.
199 * @phba: pointer to lpfc hba data structure.
200 * @pmb: pointer to the driver internal queue element for mailbox command.
202 * The clear link attention mailbox command is issued to clear the link event
203 * attention condition indicated by the Link Event bit of the Host Attention
204 * (HSTATT) register. The link event attention condition is cleared only if
205 * the event tag specified matches that of the current link event counter.
206 * The current event tag is read using the read link attention event mailbox
209 * This routine prepares the mailbox command for clearing HBA link attention
213 lpfc_clear_la(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
218 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
220 mb
->un
.varClearLA
.eventTag
= phba
->fc_eventTag
;
221 mb
->mbxCommand
= MBX_CLEAR_LA
;
222 mb
->mbxOwner
= OWN_HOST
;
227 * lpfc_config_link: Prepare a mailbox command for configuring link on a HBA.
228 * @phba: pointer to lpfc hba data structure.
229 * @pmb: pointer to the driver internal queue element for mailbox command.
231 * The configure link mailbox command is used before the initialize link
232 * mailbox command to override default value and to configure link-oriented
233 * parameters such as DID address and various timers. Typically, this
234 * command would be used after an F_Port login to set the returned DID address
235 * and the fabric timeout values. This command is not valid before a configure
236 * port command has configured the HBA port.
238 * This routine prepares the mailbox command for configuring link on a HBA.
241 lpfc_config_link(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
243 struct lpfc_vport
*vport
= phba
->pport
;
244 MAILBOX_t
*mb
= &pmb
->mb
;
245 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
248 * SLI-2, Coalescing Response Feature.
250 if (phba
->cfg_cr_delay
) {
251 mb
->un
.varCfgLnk
.cr
= 1;
252 mb
->un
.varCfgLnk
.ci
= 1;
253 mb
->un
.varCfgLnk
.cr_delay
= phba
->cfg_cr_delay
;
254 mb
->un
.varCfgLnk
.cr_count
= phba
->cfg_cr_count
;
257 mb
->un
.varCfgLnk
.myId
= vport
->fc_myDID
;
258 mb
->un
.varCfgLnk
.edtov
= phba
->fc_edtov
;
259 mb
->un
.varCfgLnk
.arbtov
= phba
->fc_arbtov
;
260 mb
->un
.varCfgLnk
.ratov
= phba
->fc_ratov
;
261 mb
->un
.varCfgLnk
.rttov
= phba
->fc_rttov
;
262 mb
->un
.varCfgLnk
.altov
= phba
->fc_altov
;
263 mb
->un
.varCfgLnk
.crtov
= phba
->fc_crtov
;
264 mb
->un
.varCfgLnk
.citov
= phba
->fc_citov
;
267 mb
->un
.varCfgLnk
.ack0_enable
= 1;
269 mb
->mbxCommand
= MBX_CONFIG_LINK
;
270 mb
->mbxOwner
= OWN_HOST
;
275 * lpfc_config_msi: Prepare a mailbox command for configuring msi-x.
276 * @phba: pointer to lpfc hba data structure.
277 * @pmb: pointer to the driver internal queue element for mailbox command.
279 * The configure MSI-X mailbox command is used to configure the HBA's SLI-3
280 * MSI-X multi-message interrupt vector association to interrupt attention
288 lpfc_config_msi(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmb
)
290 MAILBOX_t
*mb
= &pmb
->mb
;
291 uint32_t attentionConditions
[2];
294 if (phba
->cfg_use_msi
!= 2) {
295 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
296 "0475 Not configured for supporting MSI-X "
297 "cfg_use_msi: 0x%x\n", phba
->cfg_use_msi
);
301 if (phba
->sli_rev
< 3) {
302 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
303 "0476 HBA not supporting SLI-3 or later "
304 "SLI Revision: 0x%x\n", phba
->sli_rev
);
308 /* Clear mailbox command fields */
309 memset(pmb
, 0, sizeof(LPFC_MBOXQ_t
));
312 * SLI-3, Message Signaled Interrupt Fearure.
315 /* Multi-message attention configuration */
316 attentionConditions
[0] = (HA_R0ATT
| HA_R1ATT
| HA_R2ATT
| HA_ERATT
|
318 attentionConditions
[1] = 0;
320 mb
->un
.varCfgMSI
.attentionConditions
[0] = attentionConditions
[0];
321 mb
->un
.varCfgMSI
.attentionConditions
[1] = attentionConditions
[1];
324 * Set up message number to HA bit association
326 #ifdef __BIG_ENDIAN_BITFIELD
328 mb
->un
.varCfgMSI
.messageNumberByHA
[HA_R0_POS
] = 1;
329 /* RA1 (Other Protocol Extra Ring) */
330 mb
->un
.varCfgMSI
.messageNumberByHA
[HA_R1_POS
] = 1;
331 #else /* __LITTLE_ENDIAN_BITFIELD */
333 mb
->un
.varCfgMSI
.messageNumberByHA
[HA_R0_POS
^3] = 1;
334 /* RA1 (Other Protocol Extra Ring) */
335 mb
->un
.varCfgMSI
.messageNumberByHA
[HA_R1_POS
^3] = 1;
337 /* Multi-message interrupt autoclear configuration*/
338 mb
->un
.varCfgMSI
.autoClearHA
[0] = attentionConditions
[0];
339 mb
->un
.varCfgMSI
.autoClearHA
[1] = attentionConditions
[1];
341 /* For now, HBA autoclear does not work reliably, disable it */
342 mb
->un
.varCfgMSI
.autoClearHA
[0] = 0;
343 mb
->un
.varCfgMSI
.autoClearHA
[1] = 0;
345 /* Set command and owner bit */
346 mb
->mbxCommand
= MBX_CONFIG_MSI
;
347 mb
->mbxOwner
= OWN_HOST
;
353 * lpfc_init_link: Prepare a mailbox command for initialize link on a HBA.
354 * @phba: pointer to lpfc hba data structure.
355 * @pmb: pointer to the driver internal queue element for mailbox command.
356 * @topology: the link topology for the link to be initialized to.
357 * @linkspeed: the link speed for the link to be initialized to.
359 * The initialize link mailbox command is used to initialize the Fibre
360 * Channel link. This command must follow a configure port command that
361 * establishes the mode of operation.
363 * This routine prepares the mailbox command for initializing link on a HBA
364 * with the specified link topology and speed.
367 lpfc_init_link(struct lpfc_hba
* phba
,
368 LPFC_MBOXQ_t
* pmb
, uint32_t topology
, uint32_t linkspeed
)
371 struct lpfc_sli
*psli
;
375 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
379 case FLAGS_TOPOLOGY_MODE_LOOP_PT
:
380 mb
->un
.varInitLnk
.link_flags
= FLAGS_TOPOLOGY_MODE_LOOP
;
381 mb
->un
.varInitLnk
.link_flags
|= FLAGS_TOPOLOGY_FAILOVER
;
383 case FLAGS_TOPOLOGY_MODE_PT_PT
:
384 mb
->un
.varInitLnk
.link_flags
= FLAGS_TOPOLOGY_MODE_PT_PT
;
386 case FLAGS_TOPOLOGY_MODE_LOOP
:
387 mb
->un
.varInitLnk
.link_flags
= FLAGS_TOPOLOGY_MODE_LOOP
;
389 case FLAGS_TOPOLOGY_MODE_PT_LOOP
:
390 mb
->un
.varInitLnk
.link_flags
= FLAGS_TOPOLOGY_MODE_PT_PT
;
391 mb
->un
.varInitLnk
.link_flags
|= FLAGS_TOPOLOGY_FAILOVER
;
394 mb
->un
.varInitLnk
.link_flags
= FLAGS_LOCAL_LB
;
398 /* Enable asynchronous ABTS responses from firmware */
399 mb
->un
.varInitLnk
.link_flags
|= FLAGS_IMED_ABORT
;
402 * Setting up the link speed
405 if (vpd
->rev
.feaLevelHigh
>= 0x02){
411 mb
->un
.varInitLnk
.link_flags
|=
413 mb
->un
.varInitLnk
.link_speed
= linkspeed
;
415 case LINK_SPEED_AUTO
:
417 mb
->un
.varInitLnk
.link_speed
=
424 mb
->un
.varInitLnk
.link_speed
= LINK_SPEED_AUTO
;
426 mb
->mbxCommand
= (volatile uint8_t)MBX_INIT_LINK
;
427 mb
->mbxOwner
= OWN_HOST
;
428 mb
->un
.varInitLnk
.fabric_AL_PA
= phba
->fc_pref_ALPA
;
433 * lpfc_read_sparam: Prepare a mailbox command for reading HBA parameters.
434 * @phba: pointer to lpfc hba data structure.
435 * @pmb: pointer to the driver internal queue element for mailbox command.
436 * @vpi: virtual N_Port identifier.
438 * The read service parameter mailbox command is used to read the HBA port
439 * service parameters. The service parameters are read into the buffer
440 * specified directly by a BDE in the mailbox command. These service
441 * parameters may then be used to build the payload of an N_Port/F_POrt
442 * login request and reply (LOGI/ACC).
444 * This routine prepares the mailbox command for reading HBA port service
445 * parameters. The DMA memory is allocated in this function and the addresses
446 * are populated into the mailbox command for the HBA to DMA the service
451 * 1 - DMA memory allocation failed
454 lpfc_read_sparam(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmb
, int vpi
)
456 struct lpfc_dmabuf
*mp
;
458 struct lpfc_sli
*psli
;
462 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
464 mb
->mbxOwner
= OWN_HOST
;
466 /* Get a buffer to hold the HBAs Service Parameters */
468 mp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
470 mp
->virt
= lpfc_mbuf_alloc(phba
, 0, &mp
->phys
);
471 if (!mp
|| !mp
->virt
) {
473 mb
->mbxCommand
= MBX_READ_SPARM64
;
474 /* READ_SPARAM: no buffers */
475 lpfc_printf_log(phba
, KERN_WARNING
, LOG_MBOX
,
476 "0301 READ_SPARAM: no buffers\n");
479 INIT_LIST_HEAD(&mp
->list
);
480 mb
->mbxCommand
= MBX_READ_SPARM64
;
481 mb
->un
.varRdSparm
.un
.sp64
.tus
.f
.bdeSize
= sizeof (struct serv_parm
);
482 mb
->un
.varRdSparm
.un
.sp64
.addrHigh
= putPaddrHigh(mp
->phys
);
483 mb
->un
.varRdSparm
.un
.sp64
.addrLow
= putPaddrLow(mp
->phys
);
484 mb
->un
.varRdSparm
.vpi
= vpi
;
486 /* save address for completion */
493 * lpfc_unreg_did: Prepare a mailbox command for unregistering DID.
494 * @phba: pointer to lpfc hba data structure.
495 * @vpi: virtual N_Port identifier.
496 * @did: remote port identifier.
497 * @pmb: pointer to the driver internal queue element for mailbox command.
499 * The unregister DID mailbox command is used to unregister an N_Port/F_Port
500 * login for an unknown RPI by specifying the DID of a remote port. This
501 * command frees an RPI context in the HBA port. This has the effect of
502 * performing an implicit N_Port/F_Port logout.
504 * This routine prepares the mailbox command for unregistering a remote
505 * N_Port/F_Port (DID) login.
508 lpfc_unreg_did(struct lpfc_hba
* phba
, uint16_t vpi
, uint32_t did
,
514 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
516 mb
->un
.varUnregDID
.did
= did
;
517 mb
->un
.varUnregDID
.vpi
= vpi
;
519 mb
->mbxCommand
= MBX_UNREG_D_ID
;
520 mb
->mbxOwner
= OWN_HOST
;
525 * lpfc_read_config: Prepare a mailbox command for reading HBA configuration.
526 * @phba: pointer to lpfc hba data structure.
527 * @pmb: pointer to the driver internal queue element for mailbox command.
529 * The read configuration mailbox command is used to read the HBA port
530 * configuration parameters. This mailbox command provides a method for
531 * seeing any parameters that may have changed via various configuration
534 * This routine prepares the mailbox command for reading out HBA configuration
538 lpfc_read_config(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
543 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
545 mb
->mbxCommand
= MBX_READ_CONFIG
;
546 mb
->mbxOwner
= OWN_HOST
;
551 * lpfc_read_lnk_stat: Prepare a mailbox command for reading HBA link stats.
552 * @phba: pointer to lpfc hba data structure.
553 * @pmb: pointer to the driver internal queue element for mailbox command.
555 * The read link status mailbox command is used to read the link status from
556 * the HBA. Link status includes all link-related error counters. These
557 * counters are maintained by the HBA and originated in the link hardware
558 * unit. Note that all of these counters wrap.
560 * This routine prepares the mailbox command for reading out HBA link status.
563 lpfc_read_lnk_stat(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
568 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
570 mb
->mbxCommand
= MBX_READ_LNK_STAT
;
571 mb
->mbxOwner
= OWN_HOST
;
576 * lpfc_reg_login: Prepare a mailbox command for registering remote login.
577 * @phba: pointer to lpfc hba data structure.
578 * @vpi: virtual N_Port identifier.
579 * @did: remote port identifier.
580 * @param: pointer to memory holding the server parameters.
581 * @pmb: pointer to the driver internal queue element for mailbox command.
582 * @flag: action flag to be passed back for the complete function.
584 * The registration login mailbox command is used to register an N_Port or
585 * F_Port login. This registration allows the HBA to cache the remote N_Port
586 * service parameters internally and thereby make the appropriate FC-2
587 * decisions. The remote port service parameters are handed off by the driver
588 * to the HBA using a descriptor entry that directly identifies a buffer in
589 * host memory. In exchange, the HBA returns an RPI identifier.
591 * This routine prepares the mailbox command for registering remote port login.
592 * The function allocates DMA buffer for passing the service parameters to the
593 * HBA with the mailbox command.
597 * 1 - DMA memory allocation failed
600 lpfc_reg_login(struct lpfc_hba
*phba
, uint16_t vpi
, uint32_t did
,
601 uint8_t *param
, LPFC_MBOXQ_t
*pmb
, uint32_t flag
)
603 MAILBOX_t
*mb
= &pmb
->mb
;
605 struct lpfc_dmabuf
*mp
;
607 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
609 mb
->un
.varRegLogin
.rpi
= 0;
610 mb
->un
.varRegLogin
.vpi
= vpi
;
611 mb
->un
.varRegLogin
.did
= did
;
612 mb
->un
.varWords
[30] = flag
; /* Set flag to issue action on cmpl */
614 mb
->mbxOwner
= OWN_HOST
;
616 /* Get a buffer to hold NPorts Service Parameters */
617 mp
= kmalloc(sizeof (struct lpfc_dmabuf
), GFP_KERNEL
);
619 mp
->virt
= lpfc_mbuf_alloc(phba
, 0, &mp
->phys
);
620 if (!mp
|| !mp
->virt
) {
622 mb
->mbxCommand
= MBX_REG_LOGIN64
;
623 /* REG_LOGIN: no buffers */
624 lpfc_printf_log(phba
, KERN_WARNING
, LOG_MBOX
,
625 "0302 REG_LOGIN: no buffers, VPI:%d DID:x%x, "
626 "flag x%x\n", vpi
, did
, flag
);
629 INIT_LIST_HEAD(&mp
->list
);
632 /* Copy param's into a new buffer */
633 memcpy(sparam
, param
, sizeof (struct serv_parm
));
635 /* save address for completion */
636 pmb
->context1
= (uint8_t *) mp
;
638 mb
->mbxCommand
= MBX_REG_LOGIN64
;
639 mb
->un
.varRegLogin
.un
.sp64
.tus
.f
.bdeSize
= sizeof (struct serv_parm
);
640 mb
->un
.varRegLogin
.un
.sp64
.addrHigh
= putPaddrHigh(mp
->phys
);
641 mb
->un
.varRegLogin
.un
.sp64
.addrLow
= putPaddrLow(mp
->phys
);
647 * lpfc_unreg_login: Prepare a mailbox command for unregistering remote login.
648 * @phba: pointer to lpfc hba data structure.
649 * @vpi: virtual N_Port identifier.
650 * @rpi: remote port identifier
651 * @pmb: pointer to the driver internal queue element for mailbox command.
653 * The unregistration login mailbox command is used to unregister an N_Port
654 * or F_Port login. This command frees an RPI context in the HBA. It has the
655 * effect of performing an implicit N_Port/F_Port logout.
657 * This routine prepares the mailbox command for unregistering remote port
661 lpfc_unreg_login(struct lpfc_hba
*phba
, uint16_t vpi
, uint32_t rpi
,
667 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
669 mb
->un
.varUnregLogin
.rpi
= (uint16_t) rpi
;
670 mb
->un
.varUnregLogin
.rsvd1
= 0;
671 mb
->un
.varUnregLogin
.vpi
= vpi
;
673 mb
->mbxCommand
= MBX_UNREG_LOGIN
;
674 mb
->mbxOwner
= OWN_HOST
;
679 * lpfc_reg_vpi: Prepare a mailbox command for registering vport identifier.
680 * @phba: pointer to lpfc hba data structure.
681 * @vpi: virtual N_Port identifier.
682 * @sid: Fibre Channel S_ID (N_Port_ID assigned to a virtual N_Port).
683 * @pmb: pointer to the driver internal queue element for mailbox command.
685 * The registration vport identifier mailbox command is used to activate a
686 * virtual N_Port after it has acquired an N_Port_ID. The HBA validates the
687 * N_Port_ID against the information in the selected virtual N_Port context
688 * block and marks it active to allow normal processing of IOCB commands and
689 * received unsolicited exchanges.
691 * This routine prepares the mailbox command for registering a virtual N_Port.
694 lpfc_reg_vpi(struct lpfc_hba
*phba
, uint16_t vpi
, uint32_t sid
,
697 MAILBOX_t
*mb
= &pmb
->mb
;
699 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
701 mb
->un
.varRegVpi
.vpi
= vpi
;
702 mb
->un
.varRegVpi
.sid
= sid
;
704 mb
->mbxCommand
= MBX_REG_VPI
;
705 mb
->mbxOwner
= OWN_HOST
;
711 * lpfc_unreg_vpi: Prepare a mailbox command for unregistering vport id.
712 * @phba: pointer to lpfc hba data structure.
713 * @vpi: virtual N_Port identifier.
714 * @pmb: pointer to the driver internal queue element for mailbox command.
716 * The unregistration vport identifier mailbox command is used to inactivate
717 * a virtual N_Port. The driver must have logged out and unregistered all
718 * remote N_Ports to abort any activity on the virtual N_Port. The HBA will
719 * unregisters any default RPIs associated with the specified vpi, aborting
720 * any active exchanges. The HBA will post the mailbox response after making
721 * the virtual N_Port inactive.
723 * This routine prepares the mailbox command for unregistering a virtual
727 lpfc_unreg_vpi(struct lpfc_hba
*phba
, uint16_t vpi
, LPFC_MBOXQ_t
*pmb
)
729 MAILBOX_t
*mb
= &pmb
->mb
;
730 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
732 mb
->un
.varUnregVpi
.vpi
= vpi
;
734 mb
->mbxCommand
= MBX_UNREG_VPI
;
735 mb
->mbxOwner
= OWN_HOST
;
741 * lpfc_config_pcb_setup: Set up IOCB rings in the Port Control Block (PCB)
742 * @phba: pointer to lpfc hba data structure.
744 * This routine sets up and initializes the IOCB rings in the Port Control
748 lpfc_config_pcb_setup(struct lpfc_hba
* phba
)
750 struct lpfc_sli
*psli
= &phba
->sli
;
751 struct lpfc_sli_ring
*pring
;
752 PCB_t
*pcbp
= phba
->pcb
;
753 dma_addr_t pdma_addr
;
755 uint32_t iocbCnt
= 0;
758 pcbp
->maxRing
= (psli
->num_rings
- 1);
760 for (i
= 0; i
< psli
->num_rings
; i
++) {
761 pring
= &psli
->ring
[i
];
763 pring
->sizeCiocb
= phba
->sli_rev
== 3 ? SLI3_IOCB_CMD_SIZE
:
765 pring
->sizeRiocb
= phba
->sli_rev
== 3 ? SLI3_IOCB_RSP_SIZE
:
767 /* A ring MUST have both cmd and rsp entries defined to be
769 if ((pring
->numCiocb
== 0) || (pring
->numRiocb
== 0)) {
770 pcbp
->rdsc
[i
].cmdEntries
= 0;
771 pcbp
->rdsc
[i
].rspEntries
= 0;
772 pcbp
->rdsc
[i
].cmdAddrHigh
= 0;
773 pcbp
->rdsc
[i
].rspAddrHigh
= 0;
774 pcbp
->rdsc
[i
].cmdAddrLow
= 0;
775 pcbp
->rdsc
[i
].rspAddrLow
= 0;
776 pring
->cmdringaddr
= NULL
;
777 pring
->rspringaddr
= NULL
;
780 /* Command ring setup for ring */
781 pring
->cmdringaddr
= (void *)&phba
->IOCBs
[iocbCnt
];
782 pcbp
->rdsc
[i
].cmdEntries
= pring
->numCiocb
;
784 offset
= (uint8_t *) &phba
->IOCBs
[iocbCnt
] -
785 (uint8_t *) phba
->slim2p
.virt
;
786 pdma_addr
= phba
->slim2p
.phys
+ offset
;
787 pcbp
->rdsc
[i
].cmdAddrHigh
= putPaddrHigh(pdma_addr
);
788 pcbp
->rdsc
[i
].cmdAddrLow
= putPaddrLow(pdma_addr
);
789 iocbCnt
+= pring
->numCiocb
;
791 /* Response ring setup for ring */
792 pring
->rspringaddr
= (void *) &phba
->IOCBs
[iocbCnt
];
794 pcbp
->rdsc
[i
].rspEntries
= pring
->numRiocb
;
795 offset
= (uint8_t *)&phba
->IOCBs
[iocbCnt
] -
796 (uint8_t *)phba
->slim2p
.virt
;
797 pdma_addr
= phba
->slim2p
.phys
+ offset
;
798 pcbp
->rdsc
[i
].rspAddrHigh
= putPaddrHigh(pdma_addr
);
799 pcbp
->rdsc
[i
].rspAddrLow
= putPaddrLow(pdma_addr
);
800 iocbCnt
+= pring
->numRiocb
;
805 * lpfc_read_rev: Prepare a mailbox command for reading HBA revision.
806 * @phba: pointer to lpfc hba data structure.
807 * @pmb: pointer to the driver internal queue element for mailbox command.
809 * The read revision mailbox command is used to read the revision levels of
810 * the HBA components. These components include hardware units, resident
811 * firmware, and available firmware. HBAs that supports SLI-3 mode of
812 * operation provide different response information depending on the version
813 * requested by the driver.
815 * This routine prepares the mailbox command for reading HBA revision
819 lpfc_read_rev(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
821 MAILBOX_t
*mb
= &pmb
->mb
;
822 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
823 mb
->un
.varRdRev
.cv
= 1;
824 mb
->un
.varRdRev
.v3req
= 1; /* Request SLI3 info */
825 mb
->mbxCommand
= MBX_READ_REV
;
826 mb
->mbxOwner
= OWN_HOST
;
831 * lpfc_build_hbq_profile2: Set up the HBQ Selection Profile 2.
832 * @hbqmb: pointer to the HBQ configuration data structure in mailbox command.
833 * @hbq_desc: pointer to the HBQ selection profile descriptor.
835 * The Host Buffer Queue (HBQ) Selection Profile 2 specifies that the HBA
836 * tests the incoming frames' R_CTL/TYPE fields with works 10:15 and performs
837 * the Sequence Length Test using the fields in the Selection Profile 2
838 * extension in words 20:31.
841 lpfc_build_hbq_profile2(struct config_hbq_var
*hbqmb
,
842 struct lpfc_hbq_init
*hbq_desc
)
844 hbqmb
->profiles
.profile2
.seqlenbcnt
= hbq_desc
->seqlenbcnt
;
845 hbqmb
->profiles
.profile2
.maxlen
= hbq_desc
->maxlen
;
846 hbqmb
->profiles
.profile2
.seqlenoff
= hbq_desc
->seqlenoff
;
850 * lpfc_build_hbq_profile3: Set up the HBQ Selection Profile 3.
851 * @hbqmb: pointer to the HBQ configuration data structure in mailbox command.
852 * @hbq_desc: pointer to the HBQ selection profile descriptor.
854 * The Host Buffer Queue (HBQ) Selection Profile 3 specifies that the HBA
855 * tests the incoming frame's R_CTL/TYPE fields with words 10:15 and performs
856 * the Sequence Length Test and Byte Field Test using the fields in the
857 * Selection Profile 3 extension in words 20:31.
860 lpfc_build_hbq_profile3(struct config_hbq_var
*hbqmb
,
861 struct lpfc_hbq_init
*hbq_desc
)
863 hbqmb
->profiles
.profile3
.seqlenbcnt
= hbq_desc
->seqlenbcnt
;
864 hbqmb
->profiles
.profile3
.maxlen
= hbq_desc
->maxlen
;
865 hbqmb
->profiles
.profile3
.cmdcodeoff
= hbq_desc
->cmdcodeoff
;
866 hbqmb
->profiles
.profile3
.seqlenoff
= hbq_desc
->seqlenoff
;
867 memcpy(&hbqmb
->profiles
.profile3
.cmdmatch
, hbq_desc
->cmdmatch
,
868 sizeof(hbqmb
->profiles
.profile3
.cmdmatch
));
872 * lpfc_build_hbq_profile5: Set up the HBQ Selection Profile 5.
873 * @hbqmb: pointer to the HBQ configuration data structure in mailbox command.
874 * @hbq_desc: pointer to the HBQ selection profile descriptor.
876 * The Host Buffer Queue (HBQ) Selection Profile 5 specifies a header HBQ. The
877 * HBA tests the initial frame of an incoming sequence using the frame's
878 * R_CTL/TYPE fields with words 10:15 and performs the Sequence Length Test
879 * and Byte Field Test using the fields in the Selection Profile 5 extension
883 lpfc_build_hbq_profile5(struct config_hbq_var
*hbqmb
,
884 struct lpfc_hbq_init
*hbq_desc
)
886 hbqmb
->profiles
.profile5
.seqlenbcnt
= hbq_desc
->seqlenbcnt
;
887 hbqmb
->profiles
.profile5
.maxlen
= hbq_desc
->maxlen
;
888 hbqmb
->profiles
.profile5
.cmdcodeoff
= hbq_desc
->cmdcodeoff
;
889 hbqmb
->profiles
.profile5
.seqlenoff
= hbq_desc
->seqlenoff
;
890 memcpy(&hbqmb
->profiles
.profile5
.cmdmatch
, hbq_desc
->cmdmatch
,
891 sizeof(hbqmb
->profiles
.profile5
.cmdmatch
));
895 * lpfc_config_hbq: Prepare a mailbox command for configuring an HBQ.
896 * @phba: pointer to lpfc hba data structure.
897 * @id: HBQ identifier.
898 * @hbq_desc: pointer to the HBA descriptor data structure.
899 * @hbq_entry_index: index of the HBQ entry data structures.
900 * @pmb: pointer to the driver internal queue element for mailbox command.
902 * The configure HBQ (Host Buffer Queue) mailbox command is used to configure
903 * an HBQ. The configuration binds events that require buffers to a particular
904 * ring and HBQ based on a selection profile.
906 * This routine prepares the mailbox command for configuring an HBQ.
909 lpfc_config_hbq(struct lpfc_hba
*phba
, uint32_t id
,
910 struct lpfc_hbq_init
*hbq_desc
,
911 uint32_t hbq_entry_index
, LPFC_MBOXQ_t
*pmb
)
914 MAILBOX_t
*mb
= &pmb
->mb
;
915 struct config_hbq_var
*hbqmb
= &mb
->un
.varCfgHbq
;
917 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
919 hbqmb
->entry_count
= hbq_desc
->entry_count
; /* # entries in HBQ */
920 hbqmb
->recvNotify
= hbq_desc
->rn
; /* Receive
922 hbqmb
->numMask
= hbq_desc
->mask_count
; /* # R_CTL/TYPE masks
924 hbqmb
->profile
= hbq_desc
->profile
; /* Selection profile:
927 hbqmb
->ringMask
= hbq_desc
->ring_mask
; /* Binds HBQ to a ring
930 hbqmb
->headerLen
= hbq_desc
->headerLen
; /* 0 if not profile 4
932 hbqmb
->logEntry
= hbq_desc
->logEntry
; /* Set to 1 if this
936 hbqmb
->hbqaddrLow
= putPaddrLow(phba
->hbqslimp
.phys
) +
937 hbq_entry_index
* sizeof(struct lpfc_hbq_entry
);
938 hbqmb
->hbqaddrHigh
= putPaddrHigh(phba
->hbqslimp
.phys
);
940 mb
->mbxCommand
= MBX_CONFIG_HBQ
;
941 mb
->mbxOwner
= OWN_HOST
;
943 /* Copy info for profiles 2,3,5. Other
944 * profiles this area is reserved
946 if (hbq_desc
->profile
== 2)
947 lpfc_build_hbq_profile2(hbqmb
, hbq_desc
);
948 else if (hbq_desc
->profile
== 3)
949 lpfc_build_hbq_profile3(hbqmb
, hbq_desc
);
950 else if (hbq_desc
->profile
== 5)
951 lpfc_build_hbq_profile5(hbqmb
, hbq_desc
);
953 /* Return if no rctl / type masks for this HBQ */
954 if (!hbq_desc
->mask_count
)
957 /* Otherwise we setup specific rctl / type masks for this HBQ */
958 for (i
= 0; i
< hbq_desc
->mask_count
; i
++) {
959 hbqmb
->hbqMasks
[i
].tmatch
= hbq_desc
->hbqMasks
[i
].tmatch
;
960 hbqmb
->hbqMasks
[i
].tmask
= hbq_desc
->hbqMasks
[i
].tmask
;
961 hbqmb
->hbqMasks
[i
].rctlmatch
= hbq_desc
->hbqMasks
[i
].rctlmatch
;
962 hbqmb
->hbqMasks
[i
].rctlmask
= hbq_desc
->hbqMasks
[i
].rctlmask
;
969 * lpfc_config_ring: Prepare a mailbox command for configuring an IOCB ring.
970 * @phba: pointer to lpfc hba data structure.
972 * @pmb: pointer to the driver internal queue element for mailbox command.
974 * The configure ring mailbox command is used to configure an IOCB ring. This
975 * configuration binds from one to six of HBA RC_CTL/TYPE mask entries to the
976 * ring. This is used to map incoming sequences to a particular ring whose
977 * RC_CTL/TYPE mask entry matches that of the sequence. The driver should not
978 * attempt to configure a ring whose number is greater than the number
979 * specified in the Port Control Block (PCB). It is an error to issue the
980 * configure ring command more than once with the same ring number. The HBA
981 * returns an error if the driver attempts this.
983 * This routine prepares the mailbox command for configuring IOCB ring.
986 lpfc_config_ring(struct lpfc_hba
* phba
, int ring
, LPFC_MBOXQ_t
* pmb
)
989 MAILBOX_t
*mb
= &pmb
->mb
;
990 struct lpfc_sli
*psli
;
991 struct lpfc_sli_ring
*pring
;
993 memset(pmb
, 0, sizeof (LPFC_MBOXQ_t
));
995 mb
->un
.varCfgRing
.ring
= ring
;
996 mb
->un
.varCfgRing
.maxOrigXchg
= 0;
997 mb
->un
.varCfgRing
.maxRespXchg
= 0;
998 mb
->un
.varCfgRing
.recvNotify
= 1;
1001 pring
= &psli
->ring
[ring
];
1002 mb
->un
.varCfgRing
.numMask
= pring
->num_mask
;
1003 mb
->mbxCommand
= MBX_CONFIG_RING
;
1004 mb
->mbxOwner
= OWN_HOST
;
1006 /* Is this ring configured for a specific profile */
1007 if (pring
->prt
[0].profile
) {
1008 mb
->un
.varCfgRing
.profile
= pring
->prt
[0].profile
;
1012 /* Otherwise we setup specific rctl / type masks for this ring */
1013 for (i
= 0; i
< pring
->num_mask
; i
++) {
1014 mb
->un
.varCfgRing
.rrRegs
[i
].rval
= pring
->prt
[i
].rctl
;
1015 if (mb
->un
.varCfgRing
.rrRegs
[i
].rval
!= FC_ELS_REQ
)
1016 mb
->un
.varCfgRing
.rrRegs
[i
].rmask
= 0xff;
1018 mb
->un
.varCfgRing
.rrRegs
[i
].rmask
= 0xfe;
1019 mb
->un
.varCfgRing
.rrRegs
[i
].tval
= pring
->prt
[i
].type
;
1020 mb
->un
.varCfgRing
.rrRegs
[i
].tmask
= 0xff;
1027 * lpfc_config_port: Prepare a mailbox command for configuring port.
1028 * @phba: pointer to lpfc hba data structure.
1029 * @pmb: pointer to the driver internal queue element for mailbox command.
1031 * The configure port mailbox command is used to identify the Port Control
1032 * Block (PCB) in the driver memory. After this command is issued, the
1033 * driver must not access the mailbox in the HBA without first resetting
1034 * the HBA. The HBA may copy the PCB information to internal storage for
1035 * subsequent use; the driver can not change the PCB information unless it
1038 * This routine prepares the mailbox command for configuring port.
1041 lpfc_config_port(struct lpfc_hba
*phba
, LPFC_MBOXQ_t
*pmb
)
1043 MAILBOX_t __iomem
*mb_slim
= (MAILBOX_t __iomem
*) phba
->MBslimaddr
;
1044 MAILBOX_t
*mb
= &pmb
->mb
;
1045 dma_addr_t pdma_addr
;
1046 uint32_t bar_low
, bar_high
;
1048 struct lpfc_hgp hgp
;
1050 uint32_t pgp_offset
;
1052 memset(pmb
, 0, sizeof(LPFC_MBOXQ_t
));
1053 mb
->mbxCommand
= MBX_CONFIG_PORT
;
1054 mb
->mbxOwner
= OWN_HOST
;
1056 mb
->un
.varCfgPort
.pcbLen
= sizeof(PCB_t
);
1058 offset
= (uint8_t *)phba
->pcb
- (uint8_t *)phba
->slim2p
.virt
;
1059 pdma_addr
= phba
->slim2p
.phys
+ offset
;
1060 mb
->un
.varCfgPort
.pcbLow
= putPaddrLow(pdma_addr
);
1061 mb
->un
.varCfgPort
.pcbHigh
= putPaddrHigh(pdma_addr
);
1063 /* If HBA supports SLI=3 ask for it */
1065 if (phba
->sli_rev
== 3 && phba
->vpd
.sli3Feat
.cerbm
) {
1066 mb
->un
.varCfgPort
.cerbm
= 1; /* Request HBQs */
1067 mb
->un
.varCfgPort
.ccrp
= 1; /* Command Ring Polling */
1068 mb
->un
.varCfgPort
.cinb
= 1; /* Interrupt Notification Block */
1069 mb
->un
.varCfgPort
.max_hbq
= lpfc_sli_hbq_count();
1070 if (phba
->max_vpi
&& phba
->cfg_enable_npiv
&&
1071 phba
->vpd
.sli3Feat
.cmv
) {
1072 mb
->un
.varCfgPort
.max_vpi
= phba
->max_vpi
;
1073 mb
->un
.varCfgPort
.cmv
= 1;
1075 mb
->un
.varCfgPort
.max_vpi
= phba
->max_vpi
= 0;
1078 mb
->un
.varCfgPort
.sli_mode
= phba
->sli_rev
;
1081 phba
->pcb
->type
= TYPE_NATIVE_SLI2
;
1082 phba
->pcb
->feature
= FEATURE_INITIAL_SLI2
;
1084 /* Setup Mailbox pointers */
1085 phba
->pcb
->mailBoxSize
= sizeof(MAILBOX_t
);
1086 offset
= (uint8_t *)phba
->mbox
- (uint8_t *)phba
->slim2p
.virt
;
1087 pdma_addr
= phba
->slim2p
.phys
+ offset
;
1088 phba
->pcb
->mbAddrHigh
= putPaddrHigh(pdma_addr
);
1089 phba
->pcb
->mbAddrLow
= putPaddrLow(pdma_addr
);
1092 * Setup Host Group ring pointer.
1094 * For efficiency reasons, the ring get/put pointers can be
1095 * placed in adapter memory (SLIM) rather than in host memory.
1096 * This allows firmware to avoid PCI reads/writes when updating
1097 * and checking pointers.
1099 * The firmware recognizes the use of SLIM memory by comparing
1100 * the address of the get/put pointers structure with that of
1101 * the SLIM BAR (BAR0).
1103 * Caution: be sure to use the PCI config space value of BAR0/BAR1
1104 * (the hardware's view of the base address), not the OS's
1105 * value of pci_resource_start() as the OS value may be a cookie
1106 * for ioremap/iomap.
1110 pci_read_config_dword(phba
->pcidev
, PCI_BASE_ADDRESS_0
, &bar_low
);
1111 pci_read_config_dword(phba
->pcidev
, PCI_BASE_ADDRESS_1
, &bar_high
);
1114 * Set up HGP - Port Memory
1116 * The port expects the host get/put pointers to reside in memory
1117 * following the "non-diagnostic" mode mailbox (32 words, 0x80 bytes)
1118 * area of SLIM. In SLI-2 mode, there's an additional 16 reserved
1119 * words (0x40 bytes). This area is not reserved if HBQs are
1120 * configured in SLI-3.
1122 * CR0Put - SLI2(no HBQs) = 0xc0, With HBQs = 0x80
1131 * Reserved 0xa0-0xbf
1132 * If HBQs configured:
1133 * HBQ 0 Put ptr 0xc0
1134 * HBQ 1 Put ptr 0xc4
1135 * HBQ 2 Put ptr 0xc8
1137 * HBQ(M-1)Put Pointer 0xc0+(M-1)*4
1141 if (phba
->sli_rev
== 3) {
1142 phba
->host_gp
= &mb_slim
->us
.s3
.host
[0];
1143 phba
->hbq_put
= &mb_slim
->us
.s3
.hbq_put
[0];
1145 phba
->host_gp
= &mb_slim
->us
.s2
.host
[0];
1146 phba
->hbq_put
= NULL
;
1149 /* mask off BAR0's flag bits 0 - 3 */
1150 phba
->pcb
->hgpAddrLow
= (bar_low
& PCI_BASE_ADDRESS_MEM_MASK
) +
1151 (void __iomem
*)phba
->host_gp
-
1152 (void __iomem
*)phba
->MBslimaddr
;
1153 if (bar_low
& PCI_BASE_ADDRESS_MEM_TYPE_64
)
1154 phba
->pcb
->hgpAddrHigh
= bar_high
;
1156 phba
->pcb
->hgpAddrHigh
= 0;
1157 /* write HGP data to SLIM at the required longword offset */
1158 memset(&hgp
, 0, sizeof(struct lpfc_hgp
));
1160 for (i
=0; i
< phba
->sli
.num_rings
; i
++) {
1161 lpfc_memcpy_to_slim(phba
->host_gp
+ i
, &hgp
,
1162 sizeof(*phba
->host_gp
));
1165 /* Setup Port Group ring pointer */
1166 if (phba
->sli3_options
& LPFC_SLI3_INB_ENABLED
) {
1167 pgp_offset
= offsetof(struct lpfc_sli2_slim
,
1168 mbx
.us
.s3_inb_pgp
.port
);
1169 phba
->hbq_get
= phba
->mbox
->us
.s3_inb_pgp
.hbq_get
;
1170 } else if (phba
->sli_rev
== 3) {
1171 pgp_offset
= offsetof(struct lpfc_sli2_slim
,
1172 mbx
.us
.s3_pgp
.port
);
1173 phba
->hbq_get
= phba
->mbox
->us
.s3_pgp
.hbq_get
;
1175 pgp_offset
= offsetof(struct lpfc_sli2_slim
, mbx
.us
.s2
.port
);
1176 pdma_addr
= phba
->slim2p
.phys
+ pgp_offset
;
1177 phba
->pcb
->pgpAddrHigh
= putPaddrHigh(pdma_addr
);
1178 phba
->pcb
->pgpAddrLow
= putPaddrLow(pdma_addr
);
1180 /* Use callback routine to setp rings in the pcb */
1181 lpfc_config_pcb_setup(phba
);
1183 /* special handling for LC HBAs */
1184 if (lpfc_is_LC_HBA(phba
->pcidev
->device
)) {
1185 uint32_t hbainit
[5];
1187 lpfc_hba_init(phba
, hbainit
);
1189 memcpy(&mb
->un
.varCfgPort
.hbainit
, hbainit
, 20);
1192 /* Swap PCB if needed */
1193 lpfc_sli_pcimem_bcopy(phba
->pcb
, phba
->pcb
, sizeof(PCB_t
));
1197 * lpfc_kill_board: Prepare a mailbox command for killing board.
1198 * @phba: pointer to lpfc hba data structure.
1199 * @pmb: pointer to the driver internal queue element for mailbox command.
1201 * The kill board mailbox command is used to tell firmware to perform a
1202 * graceful shutdown of a channel on a specified board to prepare for reset.
1203 * When the kill board mailbox command is received, the ER3 bit is set to 1
1204 * in the Host Status register and the ER Attention bit is set to 1 in the
1205 * Host Attention register of the HBA function that received the kill board
1208 * This routine prepares the mailbox command for killing the board in
1209 * preparation for a graceful shutdown.
1212 lpfc_kill_board(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* pmb
)
1214 MAILBOX_t
*mb
= &pmb
->mb
;
1216 memset(pmb
, 0, sizeof(LPFC_MBOXQ_t
));
1217 mb
->mbxCommand
= MBX_KILL_BOARD
;
1218 mb
->mbxOwner
= OWN_HOST
;
1223 * lpfc_mbox_put: Put a mailbox cmd into the tail of driver's mailbox queue.
1224 * @phba: pointer to lpfc hba data structure.
1225 * @mbq: pointer to the driver internal queue element for mailbox command.
1227 * Driver maintains a internal mailbox command queue implemented as a linked
1228 * list. When a mailbox command is issued, it shall be put into the mailbox
1229 * command queue such that they shall be processed orderly as HBA can process
1230 * one mailbox command at a time.
1233 lpfc_mbox_put(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* mbq
)
1235 struct lpfc_sli
*psli
;
1239 list_add_tail(&mbq
->list
, &psli
->mboxq
);
1247 * lpfc_mbox_get: Remove a mailbox cmd from the head of driver's mailbox queue.
1248 * @phba: pointer to lpfc hba data structure.
1250 * Driver maintains a internal mailbox command queue implemented as a linked
1251 * list. When a mailbox command is issued, it shall be put into the mailbox
1252 * command queue such that they shall be processed orderly as HBA can process
1253 * one mailbox command at a time. After HBA finished processing a mailbox
1254 * command, the driver will remove a pending mailbox command from the head of
1255 * the mailbox command queue and send to the HBA for processing.
1258 * pointer to the driver internal queue element for mailbox command.
1261 lpfc_mbox_get(struct lpfc_hba
* phba
)
1263 LPFC_MBOXQ_t
*mbq
= NULL
;
1264 struct lpfc_sli
*psli
= &phba
->sli
;
1266 list_remove_head((&psli
->mboxq
), mbq
, LPFC_MBOXQ_t
, list
);
1274 * lpfc_mbox_cmpl_put: Put mailbox command into mailbox command complete list.
1275 * @phba: pointer to lpfc hba data structure.
1276 * @mbq: pointer to the driver internal queue element for mailbox command.
1278 * This routine put the completed mailbox command into the mailbox command
1279 * complete list. This routine is called from driver interrupt handler
1280 * context.The mailbox complete list is used by the driver worker thread
1281 * to process mailbox complete callback functions outside the driver interrupt
1285 lpfc_mbox_cmpl_put(struct lpfc_hba
* phba
, LPFC_MBOXQ_t
* mbq
)
1287 /* This function expects to be called from interrupt context */
1288 spin_lock(&phba
->hbalock
);
1289 list_add_tail(&mbq
->list
, &phba
->sli
.mboxq_cmpl
);
1290 spin_unlock(&phba
->hbalock
);
1295 * lpfc_mbox_tmo_val: Retrieve mailbox command timeout value.
1296 * @phba: pointer to lpfc hba data structure.
1297 * @cmd: mailbox command code.
1299 * This routine retrieves the proper timeout value according to the mailbox
1303 * Timeout value to be used for the given mailbox command
1306 lpfc_mbox_tmo_val(struct lpfc_hba
*phba
, int cmd
)
1309 case MBX_WRITE_NV
: /* 0x03 */
1310 case MBX_UPDATE_CFG
: /* 0x1B */
1311 case MBX_DOWN_LOAD
: /* 0x1C */
1312 case MBX_DEL_LD_ENTRY
: /* 0x1D */
1313 case MBX_LOAD_AREA
: /* 0x81 */
1314 case MBX_WRITE_WWN
: /* 0x98 */
1315 case MBX_LOAD_EXP_ROM
: /* 0x9C */
1316 return LPFC_MBOX_TMO_FLASH_CMD
;
1318 return LPFC_MBOX_TMO
;