| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1 | /******************************************************************* |
| 2 | * This file is part of the Emulex Linux Device Driver for * |
James.Smart@Emulex.Com | c44ce17 | 2005-06-25 10:34:39 -0400 | [diff] [blame] | 3 | * Fibre Channel Host Bus Adapters. * |
James Smart | d8e93df | 2009-05-22 14:53:05 -0400 | [diff] [blame] | 4 | * Copyright (C) 2004-2009 Emulex. All rights reserved. * |
James.Smart@Emulex.Com | c44ce17 | 2005-06-25 10:34:39 -0400 | [diff] [blame] | 5 | * EMULEX and SLI are trademarks of Emulex. * |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 6 | * www.emulex.com * |
James.Smart@Emulex.Com | c44ce17 | 2005-06-25 10:34:39 -0400 | [diff] [blame] | 7 | * Portions Copyright (C) 2004-2005 Christoph Hellwig * |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 8 | * * |
| 9 | * This program is free software; you can redistribute it and/or * |
James.Smart@Emulex.Com | c44ce17 | 2005-06-25 10:34:39 -0400 | [diff] [blame] | 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. * |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 20 | *******************************************************************/ |
| 21 | |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 22 | #include <linux/blkdev.h> |
| 23 | #include <linux/pci.h> |
| 24 | #include <linux/interrupt.h> |
| 25 | |
James.Smart@Emulex.Com | f888ba3 | 2005-08-10 15:03:01 -0400 | [diff] [blame] | 26 | #include <scsi/scsi_device.h> |
| 27 | #include <scsi/scsi_transport_fc.h> |
| 28 | |
James.Smart@Emulex.Com | 9188652 | 2005-08-10 15:03:09 -0400 | [diff] [blame] | 29 | #include <scsi/scsi.h> |
| 30 | |
James Smart | da0436e | 2009-05-22 14:51:39 -0400 | [diff] [blame] | 31 | #include "lpfc_hw4.h" |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 32 | #include "lpfc_hw.h" |
| 33 | #include "lpfc_sli.h" |
James Smart | da0436e | 2009-05-22 14:51:39 -0400 | [diff] [blame] | 34 | #include "lpfc_sli4.h" |
James Smart | ea2151b | 2008-09-07 11:52:10 -0400 | [diff] [blame] | 35 | #include "lpfc_nl.h" |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 36 | #include "lpfc_disc.h" |
| 37 | #include "lpfc_scsi.h" |
| 38 | #include "lpfc.h" |
| 39 | #include "lpfc_logmsg.h" |
| 40 | #include "lpfc_crtn.h" |
| 41 | #include "lpfc_compat.h" |
| 42 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 43 | /** |
James Smart | 21e9a0a | 2009-05-22 14:53:21 -0400 | [diff] [blame] | 44 | * lpfc_dump_static_vport - Dump HBA's static vport information. |
| 45 | * @phba: pointer to lpfc hba data structure. |
| 46 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 47 | * @offset: offset for dumping vport info. |
| 48 | * |
| 49 | * The dump mailbox command provides a method for the device driver to obtain |
| 50 | * various types of information from the HBA device. |
| 51 | * |
| 52 | * This routine prepares the mailbox command for dumping list of static |
| 53 | * vports to be created. |
| 54 | **/ |
James Smart | 1c6834a | 2009-07-19 10:01:26 -0400 | [diff] [blame] | 55 | int |
James Smart | 21e9a0a | 2009-05-22 14:53:21 -0400 | [diff] [blame] | 56 | lpfc_dump_static_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb, |
| 57 | uint16_t offset) |
| 58 | { |
| 59 | MAILBOX_t *mb; |
James Smart | 1c6834a | 2009-07-19 10:01:26 -0400 | [diff] [blame] | 60 | struct lpfc_dmabuf *mp; |
James Smart | 21e9a0a | 2009-05-22 14:53:21 -0400 | [diff] [blame] | 61 | |
| 62 | mb = &pmb->u.mb; |
James Smart | 21e9a0a | 2009-05-22 14:53:21 -0400 | [diff] [blame] | 63 | |
| 64 | /* Setup to dump vport info region */ |
| 65 | memset(pmb, 0, sizeof(LPFC_MBOXQ_t)); |
| 66 | mb->mbxCommand = MBX_DUMP_MEMORY; |
James Smart | 21e9a0a | 2009-05-22 14:53:21 -0400 | [diff] [blame] | 67 | mb->un.varDmp.type = DMP_NV_PARAMS; |
| 68 | mb->un.varDmp.entry_index = offset; |
| 69 | mb->un.varDmp.region_id = DMP_REGION_VPORT; |
James Smart | 21e9a0a | 2009-05-22 14:53:21 -0400 | [diff] [blame] | 70 | mb->mbxOwner = OWN_HOST; |
| 71 | |
James Smart | 1c6834a | 2009-07-19 10:01:26 -0400 | [diff] [blame] | 72 | /* For SLI3 HBAs data is embedded in mailbox */ |
| 73 | if (phba->sli_rev != LPFC_SLI_REV4) { |
| 74 | mb->un.varDmp.cv = 1; |
| 75 | mb->un.varDmp.word_cnt = DMP_RSP_SIZE/sizeof(uint32_t); |
| 76 | return 0; |
| 77 | } |
| 78 | |
| 79 | /* For SLI4 HBAs driver need to allocate memory */ |
| 80 | mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); |
| 81 | if (mp) |
| 82 | mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); |
| 83 | |
| 84 | if (!mp || !mp->virt) { |
| 85 | kfree(mp); |
| 86 | lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, |
| 87 | "2605 lpfc_dump_static_vport: memory" |
| 88 | " allocation failed\n"); |
| 89 | return 1; |
| 90 | } |
| 91 | memset(mp->virt, 0, LPFC_BPL_SIZE); |
| 92 | INIT_LIST_HEAD(&mp->list); |
| 93 | /* save address for completion */ |
| 94 | pmb->context2 = (uint8_t *) mp; |
| 95 | mb->un.varWords[3] = putPaddrLow(mp->phys); |
| 96 | mb->un.varWords[4] = putPaddrHigh(mp->phys); |
| 97 | mb->un.varDmp.sli4_length = sizeof(struct static_vport_info); |
| 98 | |
| 99 | return 0; |
James Smart | 21e9a0a | 2009-05-22 14:53:21 -0400 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | /** |
James Smart | a0c87cb | 2009-07-19 10:01:10 -0400 | [diff] [blame] | 103 | * lpfc_down_link - Bring down HBAs link. |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 104 | * @phba: pointer to lpfc hba data structure. |
| 105 | * @pmb: pointer to the driver internal queue element for mailbox command. |
James Smart | a0c87cb | 2009-07-19 10:01:10 -0400 | [diff] [blame] | 106 | * |
| 107 | * This routine prepares a mailbox command to bring down HBA link. |
| 108 | **/ |
| 109 | void |
| 110 | lpfc_down_link(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) |
| 111 | { |
| 112 | MAILBOX_t *mb; |
| 113 | memset(pmb, 0, sizeof(LPFC_MBOXQ_t)); |
| 114 | mb = &pmb->u.mb; |
| 115 | mb->mbxCommand = MBX_DOWN_LINK; |
| 116 | mb->mbxOwner = OWN_HOST; |
| 117 | } |
| 118 | |
| 119 | /** |
| 120 | * lpfc_dump_mem - Prepare a mailbox command for reading a region. |
| 121 | * @phba: pointer to lpfc hba data structure. |
| 122 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 123 | * @offset: offset into the region. |
| 124 | * @region_id: config region id. |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 125 | * |
| 126 | * The dump mailbox command provides a method for the device driver to obtain |
| 127 | * various types of information from the HBA device. |
| 128 | * |
James Smart | a0c87cb | 2009-07-19 10:01:10 -0400 | [diff] [blame] | 129 | * This routine prepares the mailbox command for dumping HBA's config region. |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 130 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 131 | void |
James Smart | a0c87cb | 2009-07-19 10:01:10 -0400 | [diff] [blame] | 132 | lpfc_dump_mem(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb, uint16_t offset, |
| 133 | uint16_t region_id) |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 134 | { |
| 135 | MAILBOX_t *mb; |
| 136 | void *ctx; |
| 137 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 138 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 139 | ctx = pmb->context2; |
| 140 | |
| 141 | /* Setup to dump VPD region */ |
| 142 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 143 | mb->mbxCommand = MBX_DUMP_MEMORY; |
| 144 | mb->un.varDmp.cv = 1; |
| 145 | mb->un.varDmp.type = DMP_NV_PARAMS; |
| 146 | mb->un.varDmp.entry_index = offset; |
James Smart | a0c87cb | 2009-07-19 10:01:10 -0400 | [diff] [blame] | 147 | mb->un.varDmp.region_id = region_id; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 148 | mb->un.varDmp.word_cnt = (DMP_RSP_SIZE / sizeof (uint32_t)); |
| 149 | mb->un.varDmp.co = 0; |
| 150 | mb->un.varDmp.resp_offset = 0; |
| 151 | pmb->context2 = ctx; |
| 152 | mb->mbxOwner = OWN_HOST; |
| 153 | return; |
| 154 | } |
| 155 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 156 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 157 | * lpfc_dump_wakeup_param - Prepare mailbox command for retrieving wakeup params |
James Smart | 9720748 | 2008-12-04 22:39:19 -0500 | [diff] [blame] | 158 | * @phba: pointer to lpfc hba data structure. |
| 159 | * @pmb: pointer to the driver internal queue element for mailbox command. |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 160 | * |
James Smart | 9720748 | 2008-12-04 22:39:19 -0500 | [diff] [blame] | 161 | * This function create a dump memory mailbox command to dump wake up |
| 162 | * parameters. |
| 163 | */ |
| 164 | void |
| 165 | lpfc_dump_wakeup_param(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) |
| 166 | { |
| 167 | MAILBOX_t *mb; |
| 168 | void *ctx; |
| 169 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 170 | mb = &pmb->u.mb; |
James Smart | 9720748 | 2008-12-04 22:39:19 -0500 | [diff] [blame] | 171 | /* Save context so that we can restore after memset */ |
| 172 | ctx = pmb->context2; |
| 173 | |
| 174 | /* Setup to dump VPD region */ |
| 175 | memset(pmb, 0, sizeof(LPFC_MBOXQ_t)); |
| 176 | mb->mbxCommand = MBX_DUMP_MEMORY; |
| 177 | mb->mbxOwner = OWN_HOST; |
| 178 | mb->un.varDmp.cv = 1; |
| 179 | mb->un.varDmp.type = DMP_NV_PARAMS; |
| 180 | mb->un.varDmp.entry_index = 0; |
| 181 | mb->un.varDmp.region_id = WAKE_UP_PARMS_REGION_ID; |
| 182 | mb->un.varDmp.word_cnt = WAKE_UP_PARMS_WORD_SIZE; |
| 183 | mb->un.varDmp.co = 0; |
| 184 | mb->un.varDmp.resp_offset = 0; |
| 185 | pmb->context2 = ctx; |
| 186 | return; |
| 187 | } |
| 188 | |
| 189 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 190 | * lpfc_read_nv - Prepare a mailbox command for reading HBA's NVRAM param |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 191 | * @phba: pointer to lpfc hba data structure. |
| 192 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 193 | * |
| 194 | * The read NVRAM mailbox command returns the HBA's non-volatile parameters |
| 195 | * that are used as defaults when the Fibre Channel link is brought on-line. |
| 196 | * |
| 197 | * This routine prepares the mailbox command for reading information stored |
| 198 | * in the HBA's NVRAM. Specifically, the HBA's WWNN and WWPN. |
| 199 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 200 | void |
| 201 | lpfc_read_nv(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 202 | { |
| 203 | MAILBOX_t *mb; |
| 204 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 205 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 206 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 207 | mb->mbxCommand = MBX_READ_NV; |
| 208 | mb->mbxOwner = OWN_HOST; |
| 209 | return; |
| 210 | } |
| 211 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 212 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 213 | * lpfc_config_async - Prepare a mailbox command for enabling HBA async event |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 214 | * @phba: pointer to lpfc hba data structure. |
| 215 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 216 | * @ring: ring number for the asynchronous event to be configured. |
| 217 | * |
| 218 | * The asynchronous event enable mailbox command is used to enable the |
| 219 | * asynchronous event posting via the ASYNC_STATUS_CN IOCB response and |
| 220 | * specifies the default ring to which events are posted. |
| 221 | * |
| 222 | * This routine prepares the mailbox command for enabling HBA asynchronous |
| 223 | * event support on a IOCB ring. |
| 224 | **/ |
James Smart | 57127f1 | 2007-10-27 13:37:05 -0400 | [diff] [blame] | 225 | void |
| 226 | lpfc_config_async(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb, |
| 227 | uint32_t ring) |
| 228 | { |
| 229 | MAILBOX_t *mb; |
| 230 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 231 | mb = &pmb->u.mb; |
James Smart | 57127f1 | 2007-10-27 13:37:05 -0400 | [diff] [blame] | 232 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 233 | mb->mbxCommand = MBX_ASYNCEVT_ENABLE; |
| 234 | mb->un.varCfgAsyncEvent.ring = ring; |
| 235 | mb->mbxOwner = OWN_HOST; |
| 236 | return; |
| 237 | } |
| 238 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 239 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 240 | * lpfc_heart_beat - Prepare a mailbox command for heart beat |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 241 | * @phba: pointer to lpfc hba data structure. |
| 242 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 243 | * |
| 244 | * The heart beat mailbox command is used to detect an unresponsive HBA, which |
| 245 | * is defined as any device where no error attention is sent and both mailbox |
| 246 | * and rings are not processed. |
| 247 | * |
| 248 | * This routine prepares the mailbox command for issuing a heart beat in the |
| 249 | * form of mailbox command to the HBA. The timely completion of the heart |
| 250 | * beat mailbox command indicates the health of the HBA. |
| 251 | **/ |
James Smart | 858c9f6 | 2007-06-17 19:56:39 -0500 | [diff] [blame] | 252 | void |
| 253 | lpfc_heart_beat(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 254 | { |
| 255 | MAILBOX_t *mb; |
| 256 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 257 | mb = &pmb->u.mb; |
James Smart | 858c9f6 | 2007-06-17 19:56:39 -0500 | [diff] [blame] | 258 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 259 | mb->mbxCommand = MBX_HEARTBEAT; |
| 260 | mb->mbxOwner = OWN_HOST; |
| 261 | return; |
| 262 | } |
| 263 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 264 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 265 | * lpfc_read_la - Prepare a mailbox command for reading HBA link attention |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 266 | * @phba: pointer to lpfc hba data structure. |
| 267 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 268 | * @mp: DMA buffer memory for reading the link attention information into. |
| 269 | * |
| 270 | * The read link attention mailbox command is issued to read the Link Event |
| 271 | * Attention information indicated by the HBA port when the Link Event bit |
| 272 | * of the Host Attention (HSTATT) register is set to 1. A Link Event |
| 273 | * Attention occurs based on an exception detected at the Fibre Channel link |
| 274 | * interface. |
| 275 | * |
| 276 | * This routine prepares the mailbox command for reading HBA link attention |
| 277 | * information. A DMA memory has been set aside and address passed to the |
| 278 | * HBA through @mp for the HBA to DMA link attention information into the |
| 279 | * memory as part of the execution of the mailbox command. |
| 280 | * |
| 281 | * Return codes |
| 282 | * 0 - Success (currently always return 0) |
| 283 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 284 | int |
| 285 | lpfc_read_la(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb, struct lpfc_dmabuf *mp) |
| 286 | { |
| 287 | MAILBOX_t *mb; |
| 288 | struct lpfc_sli *psli; |
| 289 | |
| 290 | psli = &phba->sli; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 291 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 292 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 293 | |
| 294 | INIT_LIST_HEAD(&mp->list); |
| 295 | mb->mbxCommand = MBX_READ_LA64; |
| 296 | mb->un.varReadLA.un.lilpBde64.tus.f.bdeSize = 128; |
| 297 | mb->un.varReadLA.un.lilpBde64.addrHigh = putPaddrHigh(mp->phys); |
| 298 | mb->un.varReadLA.un.lilpBde64.addrLow = putPaddrLow(mp->phys); |
| 299 | |
| 300 | /* Save address for later completion and set the owner to host so that |
| 301 | * the FW knows this mailbox is available for processing. |
| 302 | */ |
| 303 | pmb->context1 = (uint8_t *) mp; |
| 304 | mb->mbxOwner = OWN_HOST; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 305 | return (0); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 306 | } |
| 307 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 308 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 309 | * lpfc_clear_la - Prepare a mailbox command for clearing HBA link attention |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 310 | * @phba: pointer to lpfc hba data structure. |
| 311 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 312 | * |
| 313 | * The clear link attention mailbox command is issued to clear the link event |
| 314 | * attention condition indicated by the Link Event bit of the Host Attention |
| 315 | * (HSTATT) register. The link event attention condition is cleared only if |
| 316 | * the event tag specified matches that of the current link event counter. |
| 317 | * The current event tag is read using the read link attention event mailbox |
| 318 | * command. |
| 319 | * |
| 320 | * This routine prepares the mailbox command for clearing HBA link attention |
| 321 | * information. |
| 322 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 323 | void |
| 324 | lpfc_clear_la(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 325 | { |
| 326 | MAILBOX_t *mb; |
| 327 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 328 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 329 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 330 | |
| 331 | mb->un.varClearLA.eventTag = phba->fc_eventTag; |
| 332 | mb->mbxCommand = MBX_CLEAR_LA; |
| 333 | mb->mbxOwner = OWN_HOST; |
| 334 | return; |
| 335 | } |
| 336 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 337 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 338 | * lpfc_config_link - Prepare a mailbox command for configuring link on a HBA |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 339 | * @phba: pointer to lpfc hba data structure. |
| 340 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 341 | * |
| 342 | * The configure link mailbox command is used before the initialize link |
| 343 | * mailbox command to override default value and to configure link-oriented |
| 344 | * parameters such as DID address and various timers. Typically, this |
| 345 | * command would be used after an F_Port login to set the returned DID address |
| 346 | * and the fabric timeout values. This command is not valid before a configure |
| 347 | * port command has configured the HBA port. |
| 348 | * |
| 349 | * This routine prepares the mailbox command for configuring link on a HBA. |
| 350 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 351 | void |
| 352 | lpfc_config_link(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 353 | { |
James Smart | 2e0fef8 | 2007-06-17 19:56:36 -0500 | [diff] [blame] | 354 | struct lpfc_vport *vport = phba->pport; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 355 | MAILBOX_t *mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 356 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 357 | |
| 358 | /* NEW_FEATURE |
| 359 | * SLI-2, Coalescing Response Feature. |
| 360 | */ |
| 361 | if (phba->cfg_cr_delay) { |
| 362 | mb->un.varCfgLnk.cr = 1; |
| 363 | mb->un.varCfgLnk.ci = 1; |
| 364 | mb->un.varCfgLnk.cr_delay = phba->cfg_cr_delay; |
| 365 | mb->un.varCfgLnk.cr_count = phba->cfg_cr_count; |
| 366 | } |
| 367 | |
James Smart | 2e0fef8 | 2007-06-17 19:56:36 -0500 | [diff] [blame] | 368 | mb->un.varCfgLnk.myId = vport->fc_myDID; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 369 | mb->un.varCfgLnk.edtov = phba->fc_edtov; |
| 370 | mb->un.varCfgLnk.arbtov = phba->fc_arbtov; |
| 371 | mb->un.varCfgLnk.ratov = phba->fc_ratov; |
| 372 | mb->un.varCfgLnk.rttov = phba->fc_rttov; |
| 373 | mb->un.varCfgLnk.altov = phba->fc_altov; |
| 374 | mb->un.varCfgLnk.crtov = phba->fc_crtov; |
| 375 | mb->un.varCfgLnk.citov = phba->fc_citov; |
| 376 | |
| 377 | if (phba->cfg_ack0) |
| 378 | mb->un.varCfgLnk.ack0_enable = 1; |
| 379 | |
| 380 | mb->mbxCommand = MBX_CONFIG_LINK; |
| 381 | mb->mbxOwner = OWN_HOST; |
| 382 | return; |
| 383 | } |
| 384 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 385 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 386 | * lpfc_config_msi - Prepare a mailbox command for configuring msi-x |
James Smart | 9399627 | 2008-08-24 21:50:30 -0400 | [diff] [blame] | 387 | * @phba: pointer to lpfc hba data structure. |
| 388 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 389 | * |
| 390 | * The configure MSI-X mailbox command is used to configure the HBA's SLI-3 |
| 391 | * MSI-X multi-message interrupt vector association to interrupt attention |
| 392 | * conditions. |
| 393 | * |
| 394 | * Return codes |
| 395 | * 0 - Success |
| 396 | * -EINVAL - Failure |
| 397 | **/ |
| 398 | int |
| 399 | lpfc_config_msi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) |
| 400 | { |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 401 | MAILBOX_t *mb = &pmb->u.mb; |
James Smart | 9399627 | 2008-08-24 21:50:30 -0400 | [diff] [blame] | 402 | uint32_t attentionConditions[2]; |
| 403 | |
| 404 | /* Sanity check */ |
| 405 | if (phba->cfg_use_msi != 2) { |
| 406 | lpfc_printf_log(phba, KERN_ERR, LOG_INIT, |
| 407 | "0475 Not configured for supporting MSI-X " |
| 408 | "cfg_use_msi: 0x%x\n", phba->cfg_use_msi); |
| 409 | return -EINVAL; |
| 410 | } |
| 411 | |
| 412 | if (phba->sli_rev < 3) { |
| 413 | lpfc_printf_log(phba, KERN_ERR, LOG_INIT, |
| 414 | "0476 HBA not supporting SLI-3 or later " |
| 415 | "SLI Revision: 0x%x\n", phba->sli_rev); |
| 416 | return -EINVAL; |
| 417 | } |
| 418 | |
| 419 | /* Clear mailbox command fields */ |
| 420 | memset(pmb, 0, sizeof(LPFC_MBOXQ_t)); |
| 421 | |
| 422 | /* |
| 423 | * SLI-3, Message Signaled Interrupt Fearure. |
| 424 | */ |
| 425 | |
| 426 | /* Multi-message attention configuration */ |
| 427 | attentionConditions[0] = (HA_R0ATT | HA_R1ATT | HA_R2ATT | HA_ERATT | |
| 428 | HA_LATT | HA_MBATT); |
| 429 | attentionConditions[1] = 0; |
| 430 | |
| 431 | mb->un.varCfgMSI.attentionConditions[0] = attentionConditions[0]; |
| 432 | mb->un.varCfgMSI.attentionConditions[1] = attentionConditions[1]; |
| 433 | |
| 434 | /* |
| 435 | * Set up message number to HA bit association |
| 436 | */ |
| 437 | #ifdef __BIG_ENDIAN_BITFIELD |
| 438 | /* RA0 (FCP Ring) */ |
| 439 | mb->un.varCfgMSI.messageNumberByHA[HA_R0_POS] = 1; |
| 440 | /* RA1 (Other Protocol Extra Ring) */ |
| 441 | mb->un.varCfgMSI.messageNumberByHA[HA_R1_POS] = 1; |
| 442 | #else /* __LITTLE_ENDIAN_BITFIELD */ |
| 443 | /* RA0 (FCP Ring) */ |
| 444 | mb->un.varCfgMSI.messageNumberByHA[HA_R0_POS^3] = 1; |
| 445 | /* RA1 (Other Protocol Extra Ring) */ |
| 446 | mb->un.varCfgMSI.messageNumberByHA[HA_R1_POS^3] = 1; |
| 447 | #endif |
| 448 | /* Multi-message interrupt autoclear configuration*/ |
| 449 | mb->un.varCfgMSI.autoClearHA[0] = attentionConditions[0]; |
| 450 | mb->un.varCfgMSI.autoClearHA[1] = attentionConditions[1]; |
| 451 | |
| 452 | /* For now, HBA autoclear does not work reliably, disable it */ |
| 453 | mb->un.varCfgMSI.autoClearHA[0] = 0; |
| 454 | mb->un.varCfgMSI.autoClearHA[1] = 0; |
| 455 | |
| 456 | /* Set command and owner bit */ |
| 457 | mb->mbxCommand = MBX_CONFIG_MSI; |
| 458 | mb->mbxOwner = OWN_HOST; |
| 459 | |
| 460 | return 0; |
| 461 | } |
| 462 | |
| 463 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 464 | * lpfc_init_link - Prepare a mailbox command for initialize link on a HBA |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 465 | * @phba: pointer to lpfc hba data structure. |
| 466 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 467 | * @topology: the link topology for the link to be initialized to. |
| 468 | * @linkspeed: the link speed for the link to be initialized to. |
| 469 | * |
| 470 | * The initialize link mailbox command is used to initialize the Fibre |
| 471 | * Channel link. This command must follow a configure port command that |
| 472 | * establishes the mode of operation. |
| 473 | * |
| 474 | * This routine prepares the mailbox command for initializing link on a HBA |
| 475 | * with the specified link topology and speed. |
| 476 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 477 | void |
| 478 | lpfc_init_link(struct lpfc_hba * phba, |
| 479 | LPFC_MBOXQ_t * pmb, uint32_t topology, uint32_t linkspeed) |
| 480 | { |
| 481 | lpfc_vpd_t *vpd; |
| 482 | struct lpfc_sli *psli; |
| 483 | MAILBOX_t *mb; |
| 484 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 485 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 486 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 487 | |
| 488 | psli = &phba->sli; |
| 489 | switch (topology) { |
| 490 | case FLAGS_TOPOLOGY_MODE_LOOP_PT: |
| 491 | mb->un.varInitLnk.link_flags = FLAGS_TOPOLOGY_MODE_LOOP; |
| 492 | mb->un.varInitLnk.link_flags |= FLAGS_TOPOLOGY_FAILOVER; |
| 493 | break; |
| 494 | case FLAGS_TOPOLOGY_MODE_PT_PT: |
| 495 | mb->un.varInitLnk.link_flags = FLAGS_TOPOLOGY_MODE_PT_PT; |
| 496 | break; |
| 497 | case FLAGS_TOPOLOGY_MODE_LOOP: |
| 498 | mb->un.varInitLnk.link_flags = FLAGS_TOPOLOGY_MODE_LOOP; |
| 499 | break; |
| 500 | case FLAGS_TOPOLOGY_MODE_PT_LOOP: |
| 501 | mb->un.varInitLnk.link_flags = FLAGS_TOPOLOGY_MODE_PT_PT; |
| 502 | mb->un.varInitLnk.link_flags |= FLAGS_TOPOLOGY_FAILOVER; |
| 503 | break; |
Jamie Wellnitz | 367c271 | 2006-02-28 19:25:32 -0500 | [diff] [blame] | 504 | case FLAGS_LOCAL_LB: |
| 505 | mb->un.varInitLnk.link_flags = FLAGS_LOCAL_LB; |
| 506 | break; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 507 | } |
| 508 | |
James Smart | 4b0b91d | 2006-04-15 11:53:00 -0400 | [diff] [blame] | 509 | /* Enable asynchronous ABTS responses from firmware */ |
| 510 | mb->un.varInitLnk.link_flags |= FLAGS_IMED_ABORT; |
| 511 | |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 512 | /* NEW_FEATURE |
| 513 | * Setting up the link speed |
| 514 | */ |
| 515 | vpd = &phba->vpd; |
| 516 | if (vpd->rev.feaLevelHigh >= 0x02){ |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 517 | switch(linkspeed){ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 518 | case LINK_SPEED_1G: |
| 519 | case LINK_SPEED_2G: |
| 520 | case LINK_SPEED_4G: |
James Smart | b87eab3 | 2007-04-25 09:53:28 -0400 | [diff] [blame] | 521 | case LINK_SPEED_8G: |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 522 | mb->un.varInitLnk.link_flags |= |
| 523 | FLAGS_LINK_SPEED; |
| 524 | mb->un.varInitLnk.link_speed = linkspeed; |
| 525 | break; |
| 526 | case LINK_SPEED_AUTO: |
| 527 | default: |
| 528 | mb->un.varInitLnk.link_speed = |
| 529 | LINK_SPEED_AUTO; |
| 530 | break; |
| 531 | } |
| 532 | |
| 533 | } |
| 534 | else |
| 535 | mb->un.varInitLnk.link_speed = LINK_SPEED_AUTO; |
| 536 | |
| 537 | mb->mbxCommand = (volatile uint8_t)MBX_INIT_LINK; |
| 538 | mb->mbxOwner = OWN_HOST; |
| 539 | mb->un.varInitLnk.fabric_AL_PA = phba->fc_pref_ALPA; |
| 540 | return; |
| 541 | } |
| 542 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 543 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 544 | * lpfc_read_sparam - Prepare a mailbox command for reading HBA parameters |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 545 | * @phba: pointer to lpfc hba data structure. |
| 546 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 547 | * @vpi: virtual N_Port identifier. |
| 548 | * |
| 549 | * The read service parameter mailbox command is used to read the HBA port |
| 550 | * service parameters. The service parameters are read into the buffer |
| 551 | * specified directly by a BDE in the mailbox command. These service |
| 552 | * parameters may then be used to build the payload of an N_Port/F_POrt |
| 553 | * login request and reply (LOGI/ACC). |
| 554 | * |
| 555 | * This routine prepares the mailbox command for reading HBA port service |
| 556 | * parameters. The DMA memory is allocated in this function and the addresses |
| 557 | * are populated into the mailbox command for the HBA to DMA the service |
| 558 | * parameters into. |
| 559 | * |
| 560 | * Return codes |
| 561 | * 0 - Success |
| 562 | * 1 - DMA memory allocation failed |
| 563 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 564 | int |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 565 | lpfc_read_sparam(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb, int vpi) |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 566 | { |
| 567 | struct lpfc_dmabuf *mp; |
| 568 | MAILBOX_t *mb; |
| 569 | struct lpfc_sli *psli; |
| 570 | |
| 571 | psli = &phba->sli; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 572 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 573 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 574 | |
| 575 | mb->mbxOwner = OWN_HOST; |
| 576 | |
| 577 | /* Get a buffer to hold the HBAs Service Parameters */ |
| 578 | |
James Smart | 98c9ea5 | 2007-10-27 13:37:33 -0400 | [diff] [blame] | 579 | mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); |
| 580 | if (mp) |
| 581 | mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); |
| 582 | if (!mp || !mp->virt) { |
Jesper Juhl | c9475cb | 2005-11-07 01:01:26 -0800 | [diff] [blame] | 583 | kfree(mp); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 584 | mb->mbxCommand = MBX_READ_SPARM64; |
| 585 | /* READ_SPARAM: no buffers */ |
James Smart | e8b6201 | 2007-08-02 11:10:09 -0400 | [diff] [blame] | 586 | lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX, |
| 587 | "0301 READ_SPARAM: no buffers\n"); |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 588 | return (1); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 589 | } |
| 590 | INIT_LIST_HEAD(&mp->list); |
| 591 | mb->mbxCommand = MBX_READ_SPARM64; |
| 592 | mb->un.varRdSparm.un.sp64.tus.f.bdeSize = sizeof (struct serv_parm); |
| 593 | mb->un.varRdSparm.un.sp64.addrHigh = putPaddrHigh(mp->phys); |
| 594 | mb->un.varRdSparm.un.sp64.addrLow = putPaddrLow(mp->phys); |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 595 | mb->un.varRdSparm.vpi = vpi + phba->vpi_base; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 596 | |
| 597 | /* save address for completion */ |
| 598 | pmb->context1 = mp; |
| 599 | |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 600 | return (0); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 601 | } |
| 602 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 603 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 604 | * lpfc_unreg_did - Prepare a mailbox command for unregistering DID |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 605 | * @phba: pointer to lpfc hba data structure. |
| 606 | * @vpi: virtual N_Port identifier. |
| 607 | * @did: remote port identifier. |
| 608 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 609 | * |
| 610 | * The unregister DID mailbox command is used to unregister an N_Port/F_Port |
| 611 | * login for an unknown RPI by specifying the DID of a remote port. This |
| 612 | * command frees an RPI context in the HBA port. This has the effect of |
| 613 | * performing an implicit N_Port/F_Port logout. |
| 614 | * |
| 615 | * This routine prepares the mailbox command for unregistering a remote |
| 616 | * N_Port/F_Port (DID) login. |
| 617 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 618 | void |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 619 | lpfc_unreg_did(struct lpfc_hba * phba, uint16_t vpi, uint32_t did, |
| 620 | LPFC_MBOXQ_t * pmb) |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 621 | { |
| 622 | MAILBOX_t *mb; |
| 623 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 624 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 625 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 626 | |
| 627 | mb->un.varUnregDID.did = did; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 628 | if (vpi != 0xffff) |
| 629 | vpi += phba->vpi_base; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 630 | mb->un.varUnregDID.vpi = vpi; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 631 | |
| 632 | mb->mbxCommand = MBX_UNREG_D_ID; |
| 633 | mb->mbxOwner = OWN_HOST; |
| 634 | return; |
| 635 | } |
| 636 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 637 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 638 | * lpfc_read_config - Prepare a mailbox command for reading HBA configuration |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 639 | * @phba: pointer to lpfc hba data structure. |
| 640 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 641 | * |
| 642 | * The read configuration mailbox command is used to read the HBA port |
| 643 | * configuration parameters. This mailbox command provides a method for |
| 644 | * seeing any parameters that may have changed via various configuration |
| 645 | * mailbox commands. |
| 646 | * |
| 647 | * This routine prepares the mailbox command for reading out HBA configuration |
| 648 | * parameters. |
| 649 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 650 | void |
| 651 | lpfc_read_config(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 652 | { |
| 653 | MAILBOX_t *mb; |
| 654 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 655 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 656 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 657 | |
| 658 | mb->mbxCommand = MBX_READ_CONFIG; |
| 659 | mb->mbxOwner = OWN_HOST; |
| 660 | return; |
| 661 | } |
| 662 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 663 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 664 | * lpfc_read_lnk_stat - Prepare a mailbox command for reading HBA link stats |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 665 | * @phba: pointer to lpfc hba data structure. |
| 666 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 667 | * |
| 668 | * The read link status mailbox command is used to read the link status from |
| 669 | * the HBA. Link status includes all link-related error counters. These |
| 670 | * counters are maintained by the HBA and originated in the link hardware |
| 671 | * unit. Note that all of these counters wrap. |
| 672 | * |
| 673 | * This routine prepares the mailbox command for reading out HBA link status. |
| 674 | **/ |
Jamie Wellnitz | 7bb3b13 | 2006-02-28 19:25:15 -0500 | [diff] [blame] | 675 | void |
| 676 | lpfc_read_lnk_stat(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 677 | { |
| 678 | MAILBOX_t *mb; |
| 679 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 680 | mb = &pmb->u.mb; |
Jamie Wellnitz | 7bb3b13 | 2006-02-28 19:25:15 -0500 | [diff] [blame] | 681 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 682 | |
| 683 | mb->mbxCommand = MBX_READ_LNK_STAT; |
| 684 | mb->mbxOwner = OWN_HOST; |
| 685 | return; |
| 686 | } |
| 687 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 688 | /** |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 689 | * lpfc_reg_rpi - Prepare a mailbox command for registering remote login |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 690 | * @phba: pointer to lpfc hba data structure. |
| 691 | * @vpi: virtual N_Port identifier. |
| 692 | * @did: remote port identifier. |
| 693 | * @param: pointer to memory holding the server parameters. |
| 694 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 695 | * @flag: action flag to be passed back for the complete function. |
| 696 | * |
| 697 | * The registration login mailbox command is used to register an N_Port or |
| 698 | * F_Port login. This registration allows the HBA to cache the remote N_Port |
| 699 | * service parameters internally and thereby make the appropriate FC-2 |
| 700 | * decisions. The remote port service parameters are handed off by the driver |
| 701 | * to the HBA using a descriptor entry that directly identifies a buffer in |
| 702 | * host memory. In exchange, the HBA returns an RPI identifier. |
| 703 | * |
| 704 | * This routine prepares the mailbox command for registering remote port login. |
| 705 | * The function allocates DMA buffer for passing the service parameters to the |
| 706 | * HBA with the mailbox command. |
| 707 | * |
| 708 | * Return codes |
| 709 | * 0 - Success |
| 710 | * 1 - DMA memory allocation failed |
| 711 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 712 | int |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 713 | lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did, |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 714 | uint8_t *param, LPFC_MBOXQ_t *pmb, uint32_t flag) |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 715 | { |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 716 | MAILBOX_t *mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 717 | uint8_t *sparam; |
| 718 | struct lpfc_dmabuf *mp; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 719 | |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 720 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 721 | |
| 722 | mb->un.varRegLogin.rpi = 0; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 723 | if (phba->sli_rev == LPFC_SLI_REV4) { |
| 724 | mb->un.varRegLogin.rpi = lpfc_sli4_alloc_rpi(phba); |
| 725 | if (mb->un.varRegLogin.rpi == LPFC_RPI_ALLOC_ERROR) |
| 726 | return 1; |
| 727 | } |
| 728 | |
| 729 | mb->un.varRegLogin.vpi = vpi + phba->vpi_base; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 730 | mb->un.varRegLogin.did = did; |
| 731 | mb->un.varWords[30] = flag; /* Set flag to issue action on cmpl */ |
| 732 | |
| 733 | mb->mbxOwner = OWN_HOST; |
| 734 | |
| 735 | /* Get a buffer to hold NPorts Service Parameters */ |
James Smart | 98c9ea5 | 2007-10-27 13:37:33 -0400 | [diff] [blame] | 736 | mp = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); |
| 737 | if (mp) |
| 738 | mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); |
| 739 | if (!mp || !mp->virt) { |
Jesper Juhl | c9475cb | 2005-11-07 01:01:26 -0800 | [diff] [blame] | 740 | kfree(mp); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 741 | mb->mbxCommand = MBX_REG_LOGIN64; |
| 742 | /* REG_LOGIN: no buffers */ |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 743 | lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX, |
James Smart | e8b6201 | 2007-08-02 11:10:09 -0400 | [diff] [blame] | 744 | "0302 REG_LOGIN: no buffers, VPI:%d DID:x%x, " |
| 745 | "flag x%x\n", vpi, did, flag); |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 746 | return (1); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 747 | } |
| 748 | INIT_LIST_HEAD(&mp->list); |
| 749 | sparam = mp->virt; |
| 750 | |
| 751 | /* Copy param's into a new buffer */ |
| 752 | memcpy(sparam, param, sizeof (struct serv_parm)); |
| 753 | |
| 754 | /* save address for completion */ |
| 755 | pmb->context1 = (uint8_t *) mp; |
| 756 | |
| 757 | mb->mbxCommand = MBX_REG_LOGIN64; |
| 758 | mb->un.varRegLogin.un.sp64.tus.f.bdeSize = sizeof (struct serv_parm); |
| 759 | mb->un.varRegLogin.un.sp64.addrHigh = putPaddrHigh(mp->phys); |
| 760 | mb->un.varRegLogin.un.sp64.addrLow = putPaddrLow(mp->phys); |
| 761 | |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 762 | return (0); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 763 | } |
| 764 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 765 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 766 | * lpfc_unreg_login - Prepare a mailbox command for unregistering remote login |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 767 | * @phba: pointer to lpfc hba data structure. |
| 768 | * @vpi: virtual N_Port identifier. |
| 769 | * @rpi: remote port identifier |
| 770 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 771 | * |
| 772 | * The unregistration login mailbox command is used to unregister an N_Port |
| 773 | * or F_Port login. This command frees an RPI context in the HBA. It has the |
| 774 | * effect of performing an implicit N_Port/F_Port logout. |
| 775 | * |
| 776 | * This routine prepares the mailbox command for unregistering remote port |
| 777 | * login. |
| 778 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 779 | void |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 780 | lpfc_unreg_login(struct lpfc_hba *phba, uint16_t vpi, uint32_t rpi, |
| 781 | LPFC_MBOXQ_t * pmb) |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 782 | { |
| 783 | MAILBOX_t *mb; |
| 784 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 785 | mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 786 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 787 | |
| 788 | mb->un.varUnregLogin.rpi = (uint16_t) rpi; |
| 789 | mb->un.varUnregLogin.rsvd1 = 0; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 790 | mb->un.varUnregLogin.vpi = vpi + phba->vpi_base; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 791 | |
| 792 | mb->mbxCommand = MBX_UNREG_LOGIN; |
| 793 | mb->mbxOwner = OWN_HOST; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 794 | |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 795 | return; |
| 796 | } |
| 797 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 798 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 799 | * lpfc_reg_vpi - Prepare a mailbox command for registering vport identifier |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 800 | * @phba: pointer to lpfc hba data structure. |
| 801 | * @vpi: virtual N_Port identifier. |
| 802 | * @sid: Fibre Channel S_ID (N_Port_ID assigned to a virtual N_Port). |
| 803 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 804 | * |
| 805 | * The registration vport identifier mailbox command is used to activate a |
| 806 | * virtual N_Port after it has acquired an N_Port_ID. The HBA validates the |
| 807 | * N_Port_ID against the information in the selected virtual N_Port context |
| 808 | * block and marks it active to allow normal processing of IOCB commands and |
| 809 | * received unsolicited exchanges. |
| 810 | * |
| 811 | * This routine prepares the mailbox command for registering a virtual N_Port. |
| 812 | **/ |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 813 | void |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 814 | lpfc_reg_vpi(struct lpfc_vport *vport, LPFC_MBOXQ_t *pmb) |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 815 | { |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 816 | MAILBOX_t *mb = &pmb->u.mb; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 817 | |
| 818 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 819 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 820 | mb->un.varRegVpi.vpi = vport->vpi + vport->phba->vpi_base; |
| 821 | mb->un.varRegVpi.sid = vport->fc_myDID; |
| 822 | mb->un.varRegVpi.vfi = vport->vfi + vport->phba->vfi_base; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 823 | |
| 824 | mb->mbxCommand = MBX_REG_VPI; |
| 825 | mb->mbxOwner = OWN_HOST; |
| 826 | return; |
| 827 | |
| 828 | } |
| 829 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 830 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 831 | * lpfc_unreg_vpi - Prepare a mailbox command for unregistering vport id |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 832 | * @phba: pointer to lpfc hba data structure. |
| 833 | * @vpi: virtual N_Port identifier. |
| 834 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 835 | * |
| 836 | * The unregistration vport identifier mailbox command is used to inactivate |
| 837 | * a virtual N_Port. The driver must have logged out and unregistered all |
| 838 | * remote N_Ports to abort any activity on the virtual N_Port. The HBA will |
| 839 | * unregisters any default RPIs associated with the specified vpi, aborting |
| 840 | * any active exchanges. The HBA will post the mailbox response after making |
| 841 | * the virtual N_Port inactive. |
| 842 | * |
| 843 | * This routine prepares the mailbox command for unregistering a virtual |
| 844 | * N_Port. |
| 845 | **/ |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 846 | void |
| 847 | lpfc_unreg_vpi(struct lpfc_hba *phba, uint16_t vpi, LPFC_MBOXQ_t *pmb) |
| 848 | { |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 849 | MAILBOX_t *mb = &pmb->u.mb; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 850 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 851 | |
James Smart | 6669f9b | 2009-10-02 15:16:45 -0400 | [diff] [blame^] | 852 | if (phba->sli_rev < LPFC_SLI_REV4) |
| 853 | mb->un.varUnregVpi.vpi = vpi + phba->vpi_base; |
| 854 | else |
| 855 | mb->un.varUnregVpi.sli4_vpi = vpi + phba->vpi_base; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 856 | |
| 857 | mb->mbxCommand = MBX_UNREG_VPI; |
| 858 | mb->mbxOwner = OWN_HOST; |
| 859 | return; |
| 860 | |
| 861 | } |
| 862 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 863 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 864 | * lpfc_config_pcb_setup - Set up IOCB rings in the Port Control Block (PCB) |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 865 | * @phba: pointer to lpfc hba data structure. |
| 866 | * |
| 867 | * This routine sets up and initializes the IOCB rings in the Port Control |
| 868 | * Block (PCB). |
| 869 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 870 | static void |
| 871 | lpfc_config_pcb_setup(struct lpfc_hba * phba) |
| 872 | { |
| 873 | struct lpfc_sli *psli = &phba->sli; |
| 874 | struct lpfc_sli_ring *pring; |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 875 | PCB_t *pcbp = phba->pcb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 876 | dma_addr_t pdma_addr; |
| 877 | uint32_t offset; |
James Smart | 2e0fef8 | 2007-06-17 19:56:36 -0500 | [diff] [blame] | 878 | uint32_t iocbCnt = 0; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 879 | int i; |
| 880 | |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 881 | pcbp->maxRing = (psli->num_rings - 1); |
| 882 | |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 883 | for (i = 0; i < psli->num_rings; i++) { |
| 884 | pring = &psli->ring[i]; |
James Smart | 2e0fef8 | 2007-06-17 19:56:36 -0500 | [diff] [blame] | 885 | |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 886 | pring->sizeCiocb = phba->sli_rev == 3 ? SLI3_IOCB_CMD_SIZE: |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 887 | SLI2_IOCB_CMD_SIZE; |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 888 | pring->sizeRiocb = phba->sli_rev == 3 ? SLI3_IOCB_RSP_SIZE: |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 889 | SLI2_IOCB_RSP_SIZE; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 890 | /* A ring MUST have both cmd and rsp entries defined to be |
| 891 | valid */ |
| 892 | if ((pring->numCiocb == 0) || (pring->numRiocb == 0)) { |
| 893 | pcbp->rdsc[i].cmdEntries = 0; |
| 894 | pcbp->rdsc[i].rspEntries = 0; |
| 895 | pcbp->rdsc[i].cmdAddrHigh = 0; |
| 896 | pcbp->rdsc[i].rspAddrHigh = 0; |
| 897 | pcbp->rdsc[i].cmdAddrLow = 0; |
| 898 | pcbp->rdsc[i].rspAddrLow = 0; |
| 899 | pring->cmdringaddr = NULL; |
| 900 | pring->rspringaddr = NULL; |
| 901 | continue; |
| 902 | } |
| 903 | /* Command ring setup for ring */ |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 904 | pring->cmdringaddr = (void *)&phba->IOCBs[iocbCnt]; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 905 | pcbp->rdsc[i].cmdEntries = pring->numCiocb; |
| 906 | |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 907 | offset = (uint8_t *) &phba->IOCBs[iocbCnt] - |
| 908 | (uint8_t *) phba->slim2p.virt; |
| 909 | pdma_addr = phba->slim2p.phys + offset; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 910 | pcbp->rdsc[i].cmdAddrHigh = putPaddrHigh(pdma_addr); |
| 911 | pcbp->rdsc[i].cmdAddrLow = putPaddrLow(pdma_addr); |
| 912 | iocbCnt += pring->numCiocb; |
| 913 | |
| 914 | /* Response ring setup for ring */ |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 915 | pring->rspringaddr = (void *) &phba->IOCBs[iocbCnt]; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 916 | |
| 917 | pcbp->rdsc[i].rspEntries = pring->numRiocb; |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 918 | offset = (uint8_t *)&phba->IOCBs[iocbCnt] - |
| 919 | (uint8_t *)phba->slim2p.virt; |
| 920 | pdma_addr = phba->slim2p.phys + offset; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 921 | pcbp->rdsc[i].rspAddrHigh = putPaddrHigh(pdma_addr); |
| 922 | pcbp->rdsc[i].rspAddrLow = putPaddrLow(pdma_addr); |
| 923 | iocbCnt += pring->numRiocb; |
| 924 | } |
| 925 | } |
| 926 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 927 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 928 | * lpfc_read_rev - Prepare a mailbox command for reading HBA revision |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 929 | * @phba: pointer to lpfc hba data structure. |
| 930 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 931 | * |
| 932 | * The read revision mailbox command is used to read the revision levels of |
| 933 | * the HBA components. These components include hardware units, resident |
| 934 | * firmware, and available firmware. HBAs that supports SLI-3 mode of |
| 935 | * operation provide different response information depending on the version |
| 936 | * requested by the driver. |
| 937 | * |
| 938 | * This routine prepares the mailbox command for reading HBA revision |
| 939 | * information. |
| 940 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 941 | void |
| 942 | lpfc_read_rev(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 943 | { |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 944 | MAILBOX_t *mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 945 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 946 | mb->un.varRdRev.cv = 1; |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 947 | mb->un.varRdRev.v3req = 1; /* Request SLI3 info */ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 948 | mb->mbxCommand = MBX_READ_REV; |
| 949 | mb->mbxOwner = OWN_HOST; |
| 950 | return; |
| 951 | } |
| 952 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 953 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 954 | * lpfc_build_hbq_profile2 - Set up the HBQ Selection Profile 2 |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 955 | * @hbqmb: pointer to the HBQ configuration data structure in mailbox command. |
| 956 | * @hbq_desc: pointer to the HBQ selection profile descriptor. |
| 957 | * |
| 958 | * The Host Buffer Queue (HBQ) Selection Profile 2 specifies that the HBA |
| 959 | * tests the incoming frames' R_CTL/TYPE fields with works 10:15 and performs |
| 960 | * the Sequence Length Test using the fields in the Selection Profile 2 |
| 961 | * extension in words 20:31. |
| 962 | **/ |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 963 | static void |
| 964 | lpfc_build_hbq_profile2(struct config_hbq_var *hbqmb, |
| 965 | struct lpfc_hbq_init *hbq_desc) |
| 966 | { |
| 967 | hbqmb->profiles.profile2.seqlenbcnt = hbq_desc->seqlenbcnt; |
| 968 | hbqmb->profiles.profile2.maxlen = hbq_desc->maxlen; |
| 969 | hbqmb->profiles.profile2.seqlenoff = hbq_desc->seqlenoff; |
| 970 | } |
| 971 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 972 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 973 | * lpfc_build_hbq_profile3 - Set up the HBQ Selection Profile 3 |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 974 | * @hbqmb: pointer to the HBQ configuration data structure in mailbox command. |
| 975 | * @hbq_desc: pointer to the HBQ selection profile descriptor. |
| 976 | * |
| 977 | * The Host Buffer Queue (HBQ) Selection Profile 3 specifies that the HBA |
| 978 | * tests the incoming frame's R_CTL/TYPE fields with words 10:15 and performs |
| 979 | * the Sequence Length Test and Byte Field Test using the fields in the |
| 980 | * Selection Profile 3 extension in words 20:31. |
| 981 | **/ |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 982 | static void |
| 983 | lpfc_build_hbq_profile3(struct config_hbq_var *hbqmb, |
| 984 | struct lpfc_hbq_init *hbq_desc) |
| 985 | { |
| 986 | hbqmb->profiles.profile3.seqlenbcnt = hbq_desc->seqlenbcnt; |
| 987 | hbqmb->profiles.profile3.maxlen = hbq_desc->maxlen; |
| 988 | hbqmb->profiles.profile3.cmdcodeoff = hbq_desc->cmdcodeoff; |
| 989 | hbqmb->profiles.profile3.seqlenoff = hbq_desc->seqlenoff; |
| 990 | memcpy(&hbqmb->profiles.profile3.cmdmatch, hbq_desc->cmdmatch, |
| 991 | sizeof(hbqmb->profiles.profile3.cmdmatch)); |
| 992 | } |
| 993 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 994 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 995 | * lpfc_build_hbq_profile5 - Set up the HBQ Selection Profile 5 |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 996 | * @hbqmb: pointer to the HBQ configuration data structure in mailbox command. |
| 997 | * @hbq_desc: pointer to the HBQ selection profile descriptor. |
| 998 | * |
| 999 | * The Host Buffer Queue (HBQ) Selection Profile 5 specifies a header HBQ. The |
| 1000 | * HBA tests the initial frame of an incoming sequence using the frame's |
| 1001 | * R_CTL/TYPE fields with words 10:15 and performs the Sequence Length Test |
| 1002 | * and Byte Field Test using the fields in the Selection Profile 5 extension |
| 1003 | * words 20:31. |
| 1004 | **/ |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1005 | static void |
| 1006 | lpfc_build_hbq_profile5(struct config_hbq_var *hbqmb, |
| 1007 | struct lpfc_hbq_init *hbq_desc) |
| 1008 | { |
| 1009 | hbqmb->profiles.profile5.seqlenbcnt = hbq_desc->seqlenbcnt; |
| 1010 | hbqmb->profiles.profile5.maxlen = hbq_desc->maxlen; |
| 1011 | hbqmb->profiles.profile5.cmdcodeoff = hbq_desc->cmdcodeoff; |
| 1012 | hbqmb->profiles.profile5.seqlenoff = hbq_desc->seqlenoff; |
| 1013 | memcpy(&hbqmb->profiles.profile5.cmdmatch, hbq_desc->cmdmatch, |
| 1014 | sizeof(hbqmb->profiles.profile5.cmdmatch)); |
| 1015 | } |
| 1016 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1017 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1018 | * lpfc_config_hbq - Prepare a mailbox command for configuring an HBQ |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1019 | * @phba: pointer to lpfc hba data structure. |
| 1020 | * @id: HBQ identifier. |
| 1021 | * @hbq_desc: pointer to the HBA descriptor data structure. |
| 1022 | * @hbq_entry_index: index of the HBQ entry data structures. |
| 1023 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 1024 | * |
| 1025 | * The configure HBQ (Host Buffer Queue) mailbox command is used to configure |
| 1026 | * an HBQ. The configuration binds events that require buffers to a particular |
| 1027 | * ring and HBQ based on a selection profile. |
| 1028 | * |
| 1029 | * This routine prepares the mailbox command for configuring an HBQ. |
| 1030 | **/ |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1031 | void |
James Smart | 51ef4c2 | 2007-08-02 11:10:31 -0400 | [diff] [blame] | 1032 | lpfc_config_hbq(struct lpfc_hba *phba, uint32_t id, |
| 1033 | struct lpfc_hbq_init *hbq_desc, |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1034 | uint32_t hbq_entry_index, LPFC_MBOXQ_t *pmb) |
| 1035 | { |
| 1036 | int i; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1037 | MAILBOX_t *mb = &pmb->u.mb; |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1038 | struct config_hbq_var *hbqmb = &mb->un.varCfgHbq; |
| 1039 | |
| 1040 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
James Smart | 51ef4c2 | 2007-08-02 11:10:31 -0400 | [diff] [blame] | 1041 | hbqmb->hbqId = id; |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1042 | hbqmb->entry_count = hbq_desc->entry_count; /* # entries in HBQ */ |
| 1043 | hbqmb->recvNotify = hbq_desc->rn; /* Receive |
| 1044 | * Notification */ |
| 1045 | hbqmb->numMask = hbq_desc->mask_count; /* # R_CTL/TYPE masks |
| 1046 | * # in words 0-19 */ |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1047 | hbqmb->profile = hbq_desc->profile; /* Selection profile: |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1048 | * 0 = all, |
| 1049 | * 7 = logentry */ |
| 1050 | hbqmb->ringMask = hbq_desc->ring_mask; /* Binds HBQ to a ring |
| 1051 | * e.g. Ring0=b0001, |
| 1052 | * ring2=b0100 */ |
| 1053 | hbqmb->headerLen = hbq_desc->headerLen; /* 0 if not profile 4 |
| 1054 | * or 5 */ |
| 1055 | hbqmb->logEntry = hbq_desc->logEntry; /* Set to 1 if this |
| 1056 | * HBQ will be used |
| 1057 | * for LogEntry |
| 1058 | * buffers */ |
| 1059 | hbqmb->hbqaddrLow = putPaddrLow(phba->hbqslimp.phys) + |
| 1060 | hbq_entry_index * sizeof(struct lpfc_hbq_entry); |
| 1061 | hbqmb->hbqaddrHigh = putPaddrHigh(phba->hbqslimp.phys); |
| 1062 | |
| 1063 | mb->mbxCommand = MBX_CONFIG_HBQ; |
| 1064 | mb->mbxOwner = OWN_HOST; |
| 1065 | |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1066 | /* Copy info for profiles 2,3,5. Other |
| 1067 | * profiles this area is reserved |
| 1068 | */ |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1069 | if (hbq_desc->profile == 2) |
| 1070 | lpfc_build_hbq_profile2(hbqmb, hbq_desc); |
| 1071 | else if (hbq_desc->profile == 3) |
| 1072 | lpfc_build_hbq_profile3(hbqmb, hbq_desc); |
| 1073 | else if (hbq_desc->profile == 5) |
| 1074 | lpfc_build_hbq_profile5(hbqmb, hbq_desc); |
| 1075 | |
| 1076 | /* Return if no rctl / type masks for this HBQ */ |
| 1077 | if (!hbq_desc->mask_count) |
| 1078 | return; |
| 1079 | |
| 1080 | /* Otherwise we setup specific rctl / type masks for this HBQ */ |
| 1081 | for (i = 0; i < hbq_desc->mask_count; i++) { |
| 1082 | hbqmb->hbqMasks[i].tmatch = hbq_desc->hbqMasks[i].tmatch; |
| 1083 | hbqmb->hbqMasks[i].tmask = hbq_desc->hbqMasks[i].tmask; |
| 1084 | hbqmb->hbqMasks[i].rctlmatch = hbq_desc->hbqMasks[i].rctlmatch; |
| 1085 | hbqmb->hbqMasks[i].rctlmask = hbq_desc->hbqMasks[i].rctlmask; |
| 1086 | } |
| 1087 | |
| 1088 | return; |
| 1089 | } |
| 1090 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1091 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1092 | * lpfc_config_ring - Prepare a mailbox command for configuring an IOCB ring |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1093 | * @phba: pointer to lpfc hba data structure. |
| 1094 | * @ring: |
| 1095 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 1096 | * |
| 1097 | * The configure ring mailbox command is used to configure an IOCB ring. This |
| 1098 | * configuration binds from one to six of HBA RC_CTL/TYPE mask entries to the |
| 1099 | * ring. This is used to map incoming sequences to a particular ring whose |
| 1100 | * RC_CTL/TYPE mask entry matches that of the sequence. The driver should not |
| 1101 | * attempt to configure a ring whose number is greater than the number |
| 1102 | * specified in the Port Control Block (PCB). It is an error to issue the |
| 1103 | * configure ring command more than once with the same ring number. The HBA |
| 1104 | * returns an error if the driver attempts this. |
| 1105 | * |
| 1106 | * This routine prepares the mailbox command for configuring IOCB ring. |
| 1107 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1108 | void |
| 1109 | lpfc_config_ring(struct lpfc_hba * phba, int ring, LPFC_MBOXQ_t * pmb) |
| 1110 | { |
| 1111 | int i; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1112 | MAILBOX_t *mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1113 | struct lpfc_sli *psli; |
| 1114 | struct lpfc_sli_ring *pring; |
| 1115 | |
| 1116 | memset(pmb, 0, sizeof (LPFC_MBOXQ_t)); |
| 1117 | |
| 1118 | mb->un.varCfgRing.ring = ring; |
| 1119 | mb->un.varCfgRing.maxOrigXchg = 0; |
| 1120 | mb->un.varCfgRing.maxRespXchg = 0; |
| 1121 | mb->un.varCfgRing.recvNotify = 1; |
| 1122 | |
| 1123 | psli = &phba->sli; |
| 1124 | pring = &psli->ring[ring]; |
| 1125 | mb->un.varCfgRing.numMask = pring->num_mask; |
| 1126 | mb->mbxCommand = MBX_CONFIG_RING; |
| 1127 | mb->mbxOwner = OWN_HOST; |
| 1128 | |
| 1129 | /* Is this ring configured for a specific profile */ |
| 1130 | if (pring->prt[0].profile) { |
| 1131 | mb->un.varCfgRing.profile = pring->prt[0].profile; |
| 1132 | return; |
| 1133 | } |
| 1134 | |
| 1135 | /* Otherwise we setup specific rctl / type masks for this ring */ |
| 1136 | for (i = 0; i < pring->num_mask; i++) { |
| 1137 | mb->un.varCfgRing.rrRegs[i].rval = pring->prt[i].rctl; |
| 1138 | if (mb->un.varCfgRing.rrRegs[i].rval != FC_ELS_REQ) |
| 1139 | mb->un.varCfgRing.rrRegs[i].rmask = 0xff; |
| 1140 | else |
| 1141 | mb->un.varCfgRing.rrRegs[i].rmask = 0xfe; |
| 1142 | mb->un.varCfgRing.rrRegs[i].tval = pring->prt[i].type; |
| 1143 | mb->un.varCfgRing.rrRegs[i].tmask = 0xff; |
| 1144 | } |
| 1145 | |
| 1146 | return; |
| 1147 | } |
| 1148 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1149 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1150 | * lpfc_config_port - Prepare a mailbox command for configuring port |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1151 | * @phba: pointer to lpfc hba data structure. |
| 1152 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 1153 | * |
| 1154 | * The configure port mailbox command is used to identify the Port Control |
| 1155 | * Block (PCB) in the driver memory. After this command is issued, the |
| 1156 | * driver must not access the mailbox in the HBA without first resetting |
| 1157 | * the HBA. The HBA may copy the PCB information to internal storage for |
| 1158 | * subsequent use; the driver can not change the PCB information unless it |
| 1159 | * resets the HBA. |
| 1160 | * |
| 1161 | * This routine prepares the mailbox command for configuring port. |
| 1162 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1163 | void |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1164 | lpfc_config_port(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1165 | { |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1166 | MAILBOX_t __iomem *mb_slim = (MAILBOX_t __iomem *) phba->MBslimaddr; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1167 | MAILBOX_t *mb = &pmb->u.mb; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1168 | dma_addr_t pdma_addr; |
| 1169 | uint32_t bar_low, bar_high; |
| 1170 | size_t offset; |
James.Smart@Emulex.Com | 4cc2da1 | 2005-06-25 10:34:00 -0400 | [diff] [blame] | 1171 | struct lpfc_hgp hgp; |
James.Smart@Emulex.Com | f91b392 | 2005-10-28 20:29:28 -0400 | [diff] [blame] | 1172 | int i; |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1173 | uint32_t pgp_offset; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1174 | |
| 1175 | memset(pmb, 0, sizeof(LPFC_MBOXQ_t)); |
| 1176 | mb->mbxCommand = MBX_CONFIG_PORT; |
| 1177 | mb->mbxOwner = OWN_HOST; |
| 1178 | |
| 1179 | mb->un.varCfgPort.pcbLen = sizeof(PCB_t); |
| 1180 | |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1181 | offset = (uint8_t *)phba->pcb - (uint8_t *)phba->slim2p.virt; |
| 1182 | pdma_addr = phba->slim2p.phys + offset; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1183 | mb->un.varCfgPort.pcbLow = putPaddrLow(pdma_addr); |
| 1184 | mb->un.varCfgPort.pcbHigh = putPaddrHigh(pdma_addr); |
| 1185 | |
James Smart | 9720748 | 2008-12-04 22:39:19 -0500 | [diff] [blame] | 1186 | /* Always Host Group Pointer is in SLIM */ |
| 1187 | mb->un.varCfgPort.hps = 1; |
| 1188 | |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1189 | /* If HBA supports SLI=3 ask for it */ |
| 1190 | |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1191 | if (phba->sli_rev == LPFC_SLI_REV3 && phba->vpd.sli3Feat.cerbm) { |
James Smart | e2a0a9d | 2008-12-04 22:40:02 -0500 | [diff] [blame] | 1192 | if (phba->cfg_enable_bg) |
| 1193 | mb->un.varCfgPort.cbg = 1; /* configure BlockGuard */ |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1194 | mb->un.varCfgPort.cdss = 1; /* Configure Security */ |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1195 | mb->un.varCfgPort.cerbm = 1; /* Request HBQs */ |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1196 | mb->un.varCfgPort.ccrp = 1; /* Command Ring Polling */ |
| 1197 | mb->un.varCfgPort.cinb = 1; /* Interrupt Notification Block */ |
James Smart | 51ef4c2 | 2007-08-02 11:10:31 -0400 | [diff] [blame] | 1198 | mb->un.varCfgPort.max_hbq = lpfc_sli_hbq_count(); |
James Smart | 78b2d85 | 2007-08-02 11:10:21 -0400 | [diff] [blame] | 1199 | if (phba->max_vpi && phba->cfg_enable_npiv && |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1200 | phba->vpd.sli3Feat.cmv) { |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1201 | mb->un.varCfgPort.max_vpi = LPFC_MAX_VPI; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1202 | mb->un.varCfgPort.cmv = 1; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1203 | } else |
| 1204 | mb->un.varCfgPort.max_vpi = phba->max_vpi = 0; |
| 1205 | } else |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1206 | phba->sli_rev = LPFC_SLI_REV2; |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1207 | mb->un.varCfgPort.sli_mode = phba->sli_rev; |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1208 | |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1209 | /* Now setup pcb */ |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1210 | phba->pcb->type = TYPE_NATIVE_SLI2; |
| 1211 | phba->pcb->feature = FEATURE_INITIAL_SLI2; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1212 | |
| 1213 | /* Setup Mailbox pointers */ |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1214 | phba->pcb->mailBoxSize = sizeof(MAILBOX_t); |
| 1215 | offset = (uint8_t *)phba->mbox - (uint8_t *)phba->slim2p.virt; |
| 1216 | pdma_addr = phba->slim2p.phys + offset; |
| 1217 | phba->pcb->mbAddrHigh = putPaddrHigh(pdma_addr); |
| 1218 | phba->pcb->mbAddrLow = putPaddrLow(pdma_addr); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1219 | |
| 1220 | /* |
| 1221 | * Setup Host Group ring pointer. |
| 1222 | * |
| 1223 | * For efficiency reasons, the ring get/put pointers can be |
| 1224 | * placed in adapter memory (SLIM) rather than in host memory. |
| 1225 | * This allows firmware to avoid PCI reads/writes when updating |
| 1226 | * and checking pointers. |
| 1227 | * |
| 1228 | * The firmware recognizes the use of SLIM memory by comparing |
| 1229 | * the address of the get/put pointers structure with that of |
| 1230 | * the SLIM BAR (BAR0). |
| 1231 | * |
| 1232 | * Caution: be sure to use the PCI config space value of BAR0/BAR1 |
| 1233 | * (the hardware's view of the base address), not the OS's |
| 1234 | * value of pci_resource_start() as the OS value may be a cookie |
| 1235 | * for ioremap/iomap. |
| 1236 | */ |
| 1237 | |
| 1238 | |
| 1239 | pci_read_config_dword(phba->pcidev, PCI_BASE_ADDRESS_0, &bar_low); |
| 1240 | pci_read_config_dword(phba->pcidev, PCI_BASE_ADDRESS_1, &bar_high); |
| 1241 | |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1242 | /* |
| 1243 | * Set up HGP - Port Memory |
| 1244 | * |
| 1245 | * The port expects the host get/put pointers to reside in memory |
| 1246 | * following the "non-diagnostic" mode mailbox (32 words, 0x80 bytes) |
| 1247 | * area of SLIM. In SLI-2 mode, there's an additional 16 reserved |
| 1248 | * words (0x40 bytes). This area is not reserved if HBQs are |
| 1249 | * configured in SLI-3. |
| 1250 | * |
| 1251 | * CR0Put - SLI2(no HBQs) = 0xc0, With HBQs = 0x80 |
| 1252 | * RR0Get 0xc4 0x84 |
| 1253 | * CR1Put 0xc8 0x88 |
| 1254 | * RR1Get 0xcc 0x8c |
| 1255 | * CR2Put 0xd0 0x90 |
| 1256 | * RR2Get 0xd4 0x94 |
| 1257 | * CR3Put 0xd8 0x98 |
| 1258 | * RR3Get 0xdc 0x9c |
| 1259 | * |
| 1260 | * Reserved 0xa0-0xbf |
| 1261 | * If HBQs configured: |
| 1262 | * HBQ 0 Put ptr 0xc0 |
| 1263 | * HBQ 1 Put ptr 0xc4 |
| 1264 | * HBQ 2 Put ptr 0xc8 |
| 1265 | * ...... |
| 1266 | * HBQ(M-1)Put Pointer 0xc0+(M-1)*4 |
| 1267 | * |
| 1268 | */ |
| 1269 | |
| 1270 | if (phba->sli_rev == 3) { |
| 1271 | phba->host_gp = &mb_slim->us.s3.host[0]; |
| 1272 | phba->hbq_put = &mb_slim->us.s3.hbq_put[0]; |
| 1273 | } else { |
| 1274 | phba->host_gp = &mb_slim->us.s2.host[0]; |
| 1275 | phba->hbq_put = NULL; |
| 1276 | } |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1277 | |
| 1278 | /* mask off BAR0's flag bits 0 - 3 */ |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1279 | phba->pcb->hgpAddrLow = (bar_low & PCI_BASE_ADDRESS_MEM_MASK) + |
| 1280 | (void __iomem *)phba->host_gp - |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1281 | (void __iomem *)phba->MBslimaddr; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1282 | if (bar_low & PCI_BASE_ADDRESS_MEM_TYPE_64) |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1283 | phba->pcb->hgpAddrHigh = bar_high; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1284 | else |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1285 | phba->pcb->hgpAddrHigh = 0; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1286 | /* write HGP data to SLIM at the required longword offset */ |
James.Smart@Emulex.Com | 4cc2da1 | 2005-06-25 10:34:00 -0400 | [diff] [blame] | 1287 | memset(&hgp, 0, sizeof(struct lpfc_hgp)); |
James.Smart@Emulex.Com | f91b392 | 2005-10-28 20:29:28 -0400 | [diff] [blame] | 1288 | |
| 1289 | for (i=0; i < phba->sli.num_rings; i++) { |
James Smart | ed95768 | 2007-06-17 19:56:37 -0500 | [diff] [blame] | 1290 | lpfc_memcpy_to_slim(phba->host_gp + i, &hgp, |
| 1291 | sizeof(*phba->host_gp)); |
James.Smart@Emulex.Com | f91b392 | 2005-10-28 20:29:28 -0400 | [diff] [blame] | 1292 | } |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1293 | |
James Smart | 8f34f4c | 2008-12-04 22:39:23 -0500 | [diff] [blame] | 1294 | /* Setup Port Group offset */ |
| 1295 | if (phba->sli_rev == 3) |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1296 | pgp_offset = offsetof(struct lpfc_sli2_slim, |
| 1297 | mbx.us.s3_pgp.port); |
James Smart | 8f34f4c | 2008-12-04 22:39:23 -0500 | [diff] [blame] | 1298 | else |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1299 | pgp_offset = offsetof(struct lpfc_sli2_slim, mbx.us.s2.port); |
| 1300 | pdma_addr = phba->slim2p.phys + pgp_offset; |
| 1301 | phba->pcb->pgpAddrHigh = putPaddrHigh(pdma_addr); |
| 1302 | phba->pcb->pgpAddrLow = putPaddrLow(pdma_addr); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1303 | |
| 1304 | /* Use callback routine to setp rings in the pcb */ |
| 1305 | lpfc_config_pcb_setup(phba); |
| 1306 | |
| 1307 | /* special handling for LC HBAs */ |
| 1308 | if (lpfc_is_LC_HBA(phba->pcidev->device)) { |
| 1309 | uint32_t hbainit[5]; |
| 1310 | |
| 1311 | lpfc_hba_init(phba, hbainit); |
| 1312 | |
| 1313 | memcpy(&mb->un.varCfgPort.hbainit, hbainit, 20); |
| 1314 | } |
| 1315 | |
| 1316 | /* Swap PCB if needed */ |
James Smart | 34b02dc | 2008-08-24 21:49:55 -0400 | [diff] [blame] | 1317 | lpfc_sli_pcimem_bcopy(phba->pcb, phba->pcb, sizeof(PCB_t)); |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1318 | } |
| 1319 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1320 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1321 | * lpfc_kill_board - Prepare a mailbox command for killing board |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1322 | * @phba: pointer to lpfc hba data structure. |
| 1323 | * @pmb: pointer to the driver internal queue element for mailbox command. |
| 1324 | * |
| 1325 | * The kill board mailbox command is used to tell firmware to perform a |
| 1326 | * graceful shutdown of a channel on a specified board to prepare for reset. |
| 1327 | * When the kill board mailbox command is received, the ER3 bit is set to 1 |
| 1328 | * in the Host Status register and the ER Attention bit is set to 1 in the |
| 1329 | * Host Attention register of the HBA function that received the kill board |
| 1330 | * command. |
| 1331 | * |
| 1332 | * This routine prepares the mailbox command for killing the board in |
| 1333 | * preparation for a graceful shutdown. |
| 1334 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1335 | void |
Jamie Wellnitz | 4141586 | 2006-02-28 19:25:27 -0500 | [diff] [blame] | 1336 | lpfc_kill_board(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) |
| 1337 | { |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1338 | MAILBOX_t *mb = &pmb->u.mb; |
Jamie Wellnitz | 4141586 | 2006-02-28 19:25:27 -0500 | [diff] [blame] | 1339 | |
| 1340 | memset(pmb, 0, sizeof(LPFC_MBOXQ_t)); |
| 1341 | mb->mbxCommand = MBX_KILL_BOARD; |
| 1342 | mb->mbxOwner = OWN_HOST; |
| 1343 | return; |
| 1344 | } |
| 1345 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1346 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1347 | * lpfc_mbox_put - Put a mailbox cmd into the tail of driver's mailbox queue |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1348 | * @phba: pointer to lpfc hba data structure. |
| 1349 | * @mbq: pointer to the driver internal queue element for mailbox command. |
| 1350 | * |
| 1351 | * Driver maintains a internal mailbox command queue implemented as a linked |
| 1352 | * list. When a mailbox command is issued, it shall be put into the mailbox |
| 1353 | * command queue such that they shall be processed orderly as HBA can process |
| 1354 | * one mailbox command at a time. |
| 1355 | **/ |
Jamie Wellnitz | 4141586 | 2006-02-28 19:25:27 -0500 | [diff] [blame] | 1356 | void |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1357 | lpfc_mbox_put(struct lpfc_hba * phba, LPFC_MBOXQ_t * mbq) |
| 1358 | { |
| 1359 | struct lpfc_sli *psli; |
| 1360 | |
| 1361 | psli = &phba->sli; |
| 1362 | |
| 1363 | list_add_tail(&mbq->list, &psli->mboxq); |
| 1364 | |
| 1365 | psli->mboxq_cnt++; |
| 1366 | |
| 1367 | return; |
| 1368 | } |
| 1369 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1370 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1371 | * lpfc_mbox_get - Remove a mailbox cmd from the head of driver's mailbox queue |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1372 | * @phba: pointer to lpfc hba data structure. |
| 1373 | * |
| 1374 | * Driver maintains a internal mailbox command queue implemented as a linked |
| 1375 | * list. When a mailbox command is issued, it shall be put into the mailbox |
| 1376 | * command queue such that they shall be processed orderly as HBA can process |
| 1377 | * one mailbox command at a time. After HBA finished processing a mailbox |
| 1378 | * command, the driver will remove a pending mailbox command from the head of |
| 1379 | * the mailbox command queue and send to the HBA for processing. |
| 1380 | * |
| 1381 | * Return codes |
| 1382 | * pointer to the driver internal queue element for mailbox command. |
| 1383 | **/ |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1384 | LPFC_MBOXQ_t * |
| 1385 | lpfc_mbox_get(struct lpfc_hba * phba) |
| 1386 | { |
| 1387 | LPFC_MBOXQ_t *mbq = NULL; |
| 1388 | struct lpfc_sli *psli = &phba->sli; |
| 1389 | |
James Smart | 2e0fef8 | 2007-06-17 19:56:36 -0500 | [diff] [blame] | 1390 | list_remove_head((&psli->mboxq), mbq, LPFC_MBOXQ_t, list); |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1391 | if (mbq) |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1392 | psli->mboxq_cnt--; |
| dea3101 | 2005-04-17 16:05:31 -0500 | [diff] [blame] | 1393 | |
| 1394 | return mbq; |
| 1395 | } |
James Smart | a309a6b | 2006-08-01 07:33:43 -0400 | [diff] [blame] | 1396 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1397 | /** |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1398 | * __lpfc_mbox_cmpl_put - Put mailbox cmd into mailbox cmd complete list |
| 1399 | * @phba: pointer to lpfc hba data structure. |
| 1400 | * @mbq: pointer to the driver internal queue element for mailbox command. |
| 1401 | * |
| 1402 | * This routine put the completed mailbox command into the mailbox command |
| 1403 | * complete list. This is the unlocked version of the routine. The mailbox |
| 1404 | * complete list is used by the driver worker thread to process mailbox |
| 1405 | * complete callback functions outside the driver interrupt handler. |
| 1406 | **/ |
| 1407 | void |
| 1408 | __lpfc_mbox_cmpl_put(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbq) |
| 1409 | { |
| 1410 | list_add_tail(&mbq->list, &phba->sli.mboxq_cmpl); |
| 1411 | } |
| 1412 | |
| 1413 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1414 | * lpfc_mbox_cmpl_put - Put mailbox command into mailbox command complete list |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1415 | * @phba: pointer to lpfc hba data structure. |
| 1416 | * @mbq: pointer to the driver internal queue element for mailbox command. |
| 1417 | * |
| 1418 | * This routine put the completed mailbox command into the mailbox command |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1419 | * complete list. This is the locked version of the routine. The mailbox |
| 1420 | * complete list is used by the driver worker thread to process mailbox |
| 1421 | * complete callback functions outside the driver interrupt handler. |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1422 | **/ |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1423 | void |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1424 | lpfc_mbox_cmpl_put(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbq) |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1425 | { |
James Smart | 5b75da2 | 2008-12-04 22:39:35 -0500 | [diff] [blame] | 1426 | unsigned long iflag; |
| 1427 | |
Joe Perches | b1c1181 | 2008-02-03 17:28:22 +0200 | [diff] [blame] | 1428 | /* This function expects to be called from interrupt context */ |
James Smart | 5b75da2 | 2008-12-04 22:39:35 -0500 | [diff] [blame] | 1429 | spin_lock_irqsave(&phba->hbalock, iflag); |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1430 | __lpfc_mbox_cmpl_put(phba, mbq); |
James Smart | 5b75da2 | 2008-12-04 22:39:35 -0500 | [diff] [blame] | 1431 | spin_unlock_irqrestore(&phba->hbalock, iflag); |
James Smart | 92d7f7b | 2007-06-17 19:56:38 -0500 | [diff] [blame] | 1432 | return; |
| 1433 | } |
| 1434 | |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1435 | /** |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1436 | * lpfc_mbox_cmd_check - Check the validality of a mailbox command |
| 1437 | * @phba: pointer to lpfc hba data structure. |
| 1438 | * @mboxq: pointer to the driver internal queue element for mailbox command. |
| 1439 | * |
| 1440 | * This routine is to check whether a mailbox command is valid to be issued. |
| 1441 | * This check will be performed by both the mailbox issue API when a client |
| 1442 | * is to issue a mailbox command to the mailbox transport. |
| 1443 | * |
| 1444 | * Return 0 - pass the check, -ENODEV - fail the check |
| 1445 | **/ |
| 1446 | int |
| 1447 | lpfc_mbox_cmd_check(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) |
| 1448 | { |
| 1449 | /* Mailbox command that have a completion handler must also have a |
| 1450 | * vport specified. |
| 1451 | */ |
| 1452 | if (mboxq->mbox_cmpl && mboxq->mbox_cmpl != lpfc_sli_def_mbox_cmpl && |
| 1453 | mboxq->mbox_cmpl != lpfc_sli_wake_mbox_wait) { |
| 1454 | if (!mboxq->vport) { |
| 1455 | lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_VPORT, |
| 1456 | "1814 Mbox x%x failed, no vport\n", |
| 1457 | mboxq->u.mb.mbxCommand); |
| 1458 | dump_stack(); |
| 1459 | return -ENODEV; |
| 1460 | } |
| 1461 | } |
| 1462 | return 0; |
| 1463 | } |
| 1464 | |
| 1465 | /** |
| 1466 | * lpfc_mbox_dev_check - Check the device state for issuing a mailbox command |
| 1467 | * @phba: pointer to lpfc hba data structure. |
| 1468 | * |
| 1469 | * This routine is to check whether the HBA device is ready for posting a |
| 1470 | * mailbox command. It is used by the mailbox transport API at the time the |
| 1471 | * to post a mailbox command to the device. |
| 1472 | * |
| 1473 | * Return 0 - pass the check, -ENODEV - fail the check |
| 1474 | **/ |
| 1475 | int |
| 1476 | lpfc_mbox_dev_check(struct lpfc_hba *phba) |
| 1477 | { |
| 1478 | /* If the PCI channel is in offline state, do not issue mbox */ |
| 1479 | if (unlikely(pci_channel_offline(phba->pcidev))) |
| 1480 | return -ENODEV; |
| 1481 | |
| 1482 | /* If the HBA is in error state, do not issue mbox */ |
| 1483 | if (phba->link_state == LPFC_HBA_ERROR) |
| 1484 | return -ENODEV; |
| 1485 | |
| 1486 | return 0; |
| 1487 | } |
| 1488 | |
| 1489 | /** |
James Smart | 3621a71 | 2009-04-06 18:47:14 -0400 | [diff] [blame] | 1490 | * lpfc_mbox_tmo_val - Retrieve mailbox command timeout value |
James Smart | e59058c | 2008-08-24 21:49:00 -0400 | [diff] [blame] | 1491 | * @phba: pointer to lpfc hba data structure. |
| 1492 | * @cmd: mailbox command code. |
| 1493 | * |
| 1494 | * This routine retrieves the proper timeout value according to the mailbox |
| 1495 | * command code. |
| 1496 | * |
| 1497 | * Return codes |
| 1498 | * Timeout value to be used for the given mailbox command |
| 1499 | **/ |
James Smart | a309a6b | 2006-08-01 07:33:43 -0400 | [diff] [blame] | 1500 | int |
| 1501 | lpfc_mbox_tmo_val(struct lpfc_hba *phba, int cmd) |
| 1502 | { |
| 1503 | switch (cmd) { |
| 1504 | case MBX_WRITE_NV: /* 0x03 */ |
| 1505 | case MBX_UPDATE_CFG: /* 0x1B */ |
| 1506 | case MBX_DOWN_LOAD: /* 0x1C */ |
| 1507 | case MBX_DEL_LD_ENTRY: /* 0x1D */ |
| 1508 | case MBX_LOAD_AREA: /* 0x81 */ |
James Smart | 0937282 | 2008-01-11 01:52:54 -0500 | [diff] [blame] | 1509 | case MBX_WRITE_WWN: /* 0x98 */ |
James Smart | a309a6b | 2006-08-01 07:33:43 -0400 | [diff] [blame] | 1510 | case MBX_LOAD_EXP_ROM: /* 0x9C */ |
| 1511 | return LPFC_MBOX_TMO_FLASH_CMD; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1512 | case MBX_SLI4_CONFIG: /* 0x9b */ |
| 1513 | return LPFC_MBOX_SLI4_CONFIG_TMO; |
James Smart | a309a6b | 2006-08-01 07:33:43 -0400 | [diff] [blame] | 1514 | } |
| 1515 | return LPFC_MBOX_TMO; |
| 1516 | } |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1517 | |
| 1518 | /** |
| 1519 | * lpfc_sli4_mbx_sge_set - Set a sge entry in non-embedded mailbox command |
| 1520 | * @mbox: pointer to lpfc mbox command. |
| 1521 | * @sgentry: sge entry index. |
| 1522 | * @phyaddr: physical address for the sge |
| 1523 | * @length: Length of the sge. |
| 1524 | * |
| 1525 | * This routine sets up an entry in the non-embedded mailbox command at the sge |
| 1526 | * index location. |
| 1527 | **/ |
| 1528 | void |
| 1529 | lpfc_sli4_mbx_sge_set(struct lpfcMboxq *mbox, uint32_t sgentry, |
| 1530 | dma_addr_t phyaddr, uint32_t length) |
| 1531 | { |
| 1532 | struct lpfc_mbx_nembed_cmd *nembed_sge; |
| 1533 | |
| 1534 | nembed_sge = (struct lpfc_mbx_nembed_cmd *) |
| 1535 | &mbox->u.mqe.un.nembed_cmd; |
| 1536 | nembed_sge->sge[sgentry].pa_lo = putPaddrLow(phyaddr); |
| 1537 | nembed_sge->sge[sgentry].pa_hi = putPaddrHigh(phyaddr); |
| 1538 | nembed_sge->sge[sgentry].length = length; |
| 1539 | } |
| 1540 | |
| 1541 | /** |
| 1542 | * lpfc_sli4_mbx_sge_get - Get a sge entry from non-embedded mailbox command |
| 1543 | * @mbox: pointer to lpfc mbox command. |
| 1544 | * @sgentry: sge entry index. |
| 1545 | * |
| 1546 | * This routine gets an entry from the non-embedded mailbox command at the sge |
| 1547 | * index location. |
| 1548 | **/ |
| 1549 | void |
| 1550 | lpfc_sli4_mbx_sge_get(struct lpfcMboxq *mbox, uint32_t sgentry, |
| 1551 | struct lpfc_mbx_sge *sge) |
| 1552 | { |
| 1553 | struct lpfc_mbx_nembed_cmd *nembed_sge; |
| 1554 | |
| 1555 | nembed_sge = (struct lpfc_mbx_nembed_cmd *) |
| 1556 | &mbox->u.mqe.un.nembed_cmd; |
| 1557 | sge->pa_lo = nembed_sge->sge[sgentry].pa_lo; |
| 1558 | sge->pa_hi = nembed_sge->sge[sgentry].pa_hi; |
| 1559 | sge->length = nembed_sge->sge[sgentry].length; |
| 1560 | } |
| 1561 | |
| 1562 | /** |
| 1563 | * lpfc_sli4_mbox_cmd_free - Free a sli4 mailbox command |
| 1564 | * @phba: pointer to lpfc hba data structure. |
| 1565 | * @mbox: pointer to lpfc mbox command. |
| 1566 | * |
| 1567 | * This routine frees SLI4 specific mailbox command for sending IOCTL command. |
| 1568 | **/ |
| 1569 | void |
| 1570 | lpfc_sli4_mbox_cmd_free(struct lpfc_hba *phba, struct lpfcMboxq *mbox) |
| 1571 | { |
| 1572 | struct lpfc_mbx_sli4_config *sli4_cfg; |
| 1573 | struct lpfc_mbx_sge sge; |
| 1574 | dma_addr_t phyaddr; |
| 1575 | uint32_t sgecount, sgentry; |
| 1576 | |
| 1577 | sli4_cfg = &mbox->u.mqe.un.sli4_config; |
| 1578 | |
| 1579 | /* For embedded mbox command, just free the mbox command */ |
| 1580 | if (bf_get(lpfc_mbox_hdr_emb, &sli4_cfg->header.cfg_mhdr)) { |
| 1581 | mempool_free(mbox, phba->mbox_mem_pool); |
| 1582 | return; |
| 1583 | } |
| 1584 | |
| 1585 | /* For non-embedded mbox command, we need to free the pages first */ |
| 1586 | sgecount = bf_get(lpfc_mbox_hdr_sge_cnt, &sli4_cfg->header.cfg_mhdr); |
| 1587 | /* There is nothing we can do if there is no sge address array */ |
| 1588 | if (unlikely(!mbox->sge_array)) { |
| 1589 | mempool_free(mbox, phba->mbox_mem_pool); |
| 1590 | return; |
| 1591 | } |
| 1592 | /* Each non-embedded DMA memory was allocated in the length of a page */ |
| 1593 | for (sgentry = 0; sgentry < sgecount; sgentry++) { |
| 1594 | lpfc_sli4_mbx_sge_get(mbox, sgentry, &sge); |
| 1595 | phyaddr = getPaddr(sge.pa_hi, sge.pa_lo); |
| 1596 | dma_free_coherent(&phba->pcidev->dev, PAGE_SIZE, |
| 1597 | mbox->sge_array->addr[sgentry], phyaddr); |
| 1598 | } |
| 1599 | /* Free the sge address array memory */ |
| 1600 | kfree(mbox->sge_array); |
| 1601 | /* Finally, free the mailbox command itself */ |
| 1602 | mempool_free(mbox, phba->mbox_mem_pool); |
| 1603 | } |
| 1604 | |
| 1605 | /** |
| 1606 | * lpfc_sli4_config - Initialize the SLI4 Config Mailbox command |
| 1607 | * @phba: pointer to lpfc hba data structure. |
| 1608 | * @mbox: pointer to lpfc mbox command. |
| 1609 | * @subsystem: The sli4 config sub mailbox subsystem. |
| 1610 | * @opcode: The sli4 config sub mailbox command opcode. |
| 1611 | * @length: Length of the sli4 config mailbox command. |
| 1612 | * |
| 1613 | * This routine sets up the header fields of SLI4 specific mailbox command |
| 1614 | * for sending IOCTL command. |
| 1615 | * |
| 1616 | * Return: the actual length of the mbox command allocated (mostly useful |
| 1617 | * for none embedded mailbox command). |
| 1618 | **/ |
| 1619 | int |
| 1620 | lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox, |
| 1621 | uint8_t subsystem, uint8_t opcode, uint32_t length, bool emb) |
| 1622 | { |
| 1623 | struct lpfc_mbx_sli4_config *sli4_config; |
| 1624 | union lpfc_sli4_cfg_shdr *cfg_shdr = NULL; |
| 1625 | uint32_t alloc_len; |
| 1626 | uint32_t resid_len; |
| 1627 | uint32_t pagen, pcount; |
| 1628 | void *viraddr; |
| 1629 | dma_addr_t phyaddr; |
| 1630 | |
| 1631 | /* Set up SLI4 mailbox command header fields */ |
| 1632 | memset(mbox, 0, sizeof(*mbox)); |
| 1633 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_SLI4_CONFIG); |
| 1634 | |
| 1635 | /* Set up SLI4 ioctl command header fields */ |
| 1636 | sli4_config = &mbox->u.mqe.un.sli4_config; |
| 1637 | |
| 1638 | /* Setup for the embedded mbox command */ |
| 1639 | if (emb) { |
| 1640 | /* Set up main header fields */ |
| 1641 | bf_set(lpfc_mbox_hdr_emb, &sli4_config->header.cfg_mhdr, 1); |
| 1642 | sli4_config->header.cfg_mhdr.payload_length = |
| 1643 | LPFC_MBX_CMD_HDR_LENGTH + length; |
| 1644 | /* Set up sub-header fields following main header */ |
| 1645 | bf_set(lpfc_mbox_hdr_opcode, |
| 1646 | &sli4_config->header.cfg_shdr.request, opcode); |
| 1647 | bf_set(lpfc_mbox_hdr_subsystem, |
| 1648 | &sli4_config->header.cfg_shdr.request, subsystem); |
| 1649 | sli4_config->header.cfg_shdr.request.request_length = length; |
| 1650 | return length; |
| 1651 | } |
| 1652 | |
| 1653 | /* Setup for the none-embedded mbox command */ |
| 1654 | pcount = (PAGE_ALIGN(length))/PAGE_SIZE; |
| 1655 | pcount = (pcount > LPFC_SLI4_MBX_SGE_MAX_PAGES) ? |
| 1656 | LPFC_SLI4_MBX_SGE_MAX_PAGES : pcount; |
| 1657 | /* Allocate record for keeping SGE virtual addresses */ |
| 1658 | mbox->sge_array = kmalloc(sizeof(struct lpfc_mbx_nembed_sge_virt), |
| 1659 | GFP_KERNEL); |
| 1660 | if (!mbox->sge_array) |
| 1661 | return 0; |
| 1662 | |
| 1663 | for (pagen = 0, alloc_len = 0; pagen < pcount; pagen++) { |
| 1664 | /* The DMA memory is always allocated in the length of a |
| 1665 | * page even though the last SGE might not fill up to a |
| 1666 | * page, this is used as a priori size of PAGE_SIZE for |
| 1667 | * the later DMA memory free. |
| 1668 | */ |
| 1669 | viraddr = dma_alloc_coherent(&phba->pcidev->dev, PAGE_SIZE, |
| 1670 | &phyaddr, GFP_KERNEL); |
| 1671 | /* In case of malloc fails, proceed with whatever we have */ |
| 1672 | if (!viraddr) |
| 1673 | break; |
James Smart | d11e31d | 2009-06-10 17:23:06 -0400 | [diff] [blame] | 1674 | memset(viraddr, 0, PAGE_SIZE); |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1675 | mbox->sge_array->addr[pagen] = viraddr; |
| 1676 | /* Keep the first page for later sub-header construction */ |
| 1677 | if (pagen == 0) |
| 1678 | cfg_shdr = (union lpfc_sli4_cfg_shdr *)viraddr; |
| 1679 | resid_len = length - alloc_len; |
| 1680 | if (resid_len > PAGE_SIZE) { |
| 1681 | lpfc_sli4_mbx_sge_set(mbox, pagen, phyaddr, |
| 1682 | PAGE_SIZE); |
| 1683 | alloc_len += PAGE_SIZE; |
| 1684 | } else { |
| 1685 | lpfc_sli4_mbx_sge_set(mbox, pagen, phyaddr, |
| 1686 | resid_len); |
| 1687 | alloc_len = length; |
| 1688 | } |
| 1689 | } |
| 1690 | |
| 1691 | /* Set up main header fields in mailbox command */ |
| 1692 | sli4_config->header.cfg_mhdr.payload_length = alloc_len; |
| 1693 | bf_set(lpfc_mbox_hdr_sge_cnt, &sli4_config->header.cfg_mhdr, pagen); |
| 1694 | |
| 1695 | /* Set up sub-header fields into the first page */ |
| 1696 | if (pagen > 0) { |
| 1697 | bf_set(lpfc_mbox_hdr_opcode, &cfg_shdr->request, opcode); |
| 1698 | bf_set(lpfc_mbox_hdr_subsystem, &cfg_shdr->request, subsystem); |
| 1699 | cfg_shdr->request.request_length = |
| 1700 | alloc_len - sizeof(union lpfc_sli4_cfg_shdr); |
| 1701 | } |
| 1702 | /* The sub-header is in DMA memory, which needs endian converstion */ |
| 1703 | lpfc_sli_pcimem_bcopy(cfg_shdr, cfg_shdr, |
| 1704 | sizeof(union lpfc_sli4_cfg_shdr)); |
| 1705 | |
| 1706 | return alloc_len; |
| 1707 | } |
| 1708 | |
| 1709 | /** |
| 1710 | * lpfc_sli4_mbox_opcode_get - Get the opcode from a sli4 mailbox command |
| 1711 | * @phba: pointer to lpfc hba data structure. |
| 1712 | * @mbox: pointer to lpfc mbox command. |
| 1713 | * |
| 1714 | * This routine gets the opcode from a SLI4 specific mailbox command for |
| 1715 | * sending IOCTL command. If the mailbox command is not MBX_SLI4_CONFIG |
| 1716 | * (0x9B) or if the IOCTL sub-header is not present, opcode 0x0 shall be |
| 1717 | * returned. |
| 1718 | **/ |
| 1719 | uint8_t |
| 1720 | lpfc_sli4_mbox_opcode_get(struct lpfc_hba *phba, struct lpfcMboxq *mbox) |
| 1721 | { |
| 1722 | struct lpfc_mbx_sli4_config *sli4_cfg; |
| 1723 | union lpfc_sli4_cfg_shdr *cfg_shdr; |
| 1724 | |
| 1725 | if (mbox->u.mb.mbxCommand != MBX_SLI4_CONFIG) |
| 1726 | return 0; |
| 1727 | sli4_cfg = &mbox->u.mqe.un.sli4_config; |
| 1728 | |
| 1729 | /* For embedded mbox command, get opcode from embedded sub-header*/ |
| 1730 | if (bf_get(lpfc_mbox_hdr_emb, &sli4_cfg->header.cfg_mhdr)) { |
| 1731 | cfg_shdr = &mbox->u.mqe.un.sli4_config.header.cfg_shdr; |
| 1732 | return bf_get(lpfc_mbox_hdr_opcode, &cfg_shdr->request); |
| 1733 | } |
| 1734 | |
| 1735 | /* For non-embedded mbox command, get opcode from first dma page */ |
| 1736 | if (unlikely(!mbox->sge_array)) |
| 1737 | return 0; |
| 1738 | cfg_shdr = (union lpfc_sli4_cfg_shdr *)mbox->sge_array->addr[0]; |
| 1739 | return bf_get(lpfc_mbox_hdr_opcode, &cfg_shdr->request); |
| 1740 | } |
| 1741 | |
| 1742 | /** |
| 1743 | * lpfc_request_features: Configure SLI4 REQUEST_FEATURES mailbox |
| 1744 | * @mboxq: pointer to lpfc mbox command. |
| 1745 | * |
| 1746 | * This routine sets up the mailbox for an SLI4 REQUEST_FEATURES |
| 1747 | * mailbox command. |
| 1748 | **/ |
| 1749 | void |
| 1750 | lpfc_request_features(struct lpfc_hba *phba, struct lpfcMboxq *mboxq) |
| 1751 | { |
| 1752 | /* Set up SLI4 mailbox command header fields */ |
| 1753 | memset(mboxq, 0, sizeof(LPFC_MBOXQ_t)); |
| 1754 | bf_set(lpfc_mqe_command, &mboxq->u.mqe, MBX_SLI4_REQ_FTRS); |
| 1755 | |
| 1756 | /* Set up host requested features. */ |
| 1757 | bf_set(lpfc_mbx_rq_ftr_rq_fcpi, &mboxq->u.mqe.un.req_ftrs, 1); |
| 1758 | |
James Smart | 0c28758 | 2009-06-10 17:22:56 -0400 | [diff] [blame] | 1759 | if (phba->cfg_enable_fip) |
| 1760 | bf_set(lpfc_mbx_rq_ftr_rq_ifip, &mboxq->u.mqe.un.req_ftrs, 0); |
| 1761 | else |
| 1762 | bf_set(lpfc_mbx_rq_ftr_rq_ifip, &mboxq->u.mqe.un.req_ftrs, 1); |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1763 | |
| 1764 | /* Enable DIF (block guard) only if configured to do so. */ |
| 1765 | if (phba->cfg_enable_bg) |
| 1766 | bf_set(lpfc_mbx_rq_ftr_rq_dif, &mboxq->u.mqe.un.req_ftrs, 1); |
| 1767 | |
| 1768 | /* Enable NPIV only if configured to do so. */ |
| 1769 | if (phba->max_vpi && phba->cfg_enable_npiv) |
| 1770 | bf_set(lpfc_mbx_rq_ftr_rq_npiv, &mboxq->u.mqe.un.req_ftrs, 1); |
| 1771 | |
| 1772 | return; |
| 1773 | } |
| 1774 | |
| 1775 | /** |
| 1776 | * lpfc_init_vfi - Initialize the INIT_VFI mailbox command |
| 1777 | * @mbox: pointer to lpfc mbox command to initialize. |
| 1778 | * @vport: Vport associated with the VF. |
| 1779 | * |
| 1780 | * This routine initializes @mbox to all zeros and then fills in the mailbox |
| 1781 | * fields from @vport. INIT_VFI configures virtual fabrics identified by VFI |
| 1782 | * in the context of an FCF. The driver issues this command to setup a VFI |
| 1783 | * before issuing a FLOGI to login to the VSAN. The driver should also issue a |
| 1784 | * REG_VFI after a successful VSAN login. |
| 1785 | **/ |
| 1786 | void |
| 1787 | lpfc_init_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport) |
| 1788 | { |
| 1789 | struct lpfc_mbx_init_vfi *init_vfi; |
| 1790 | |
| 1791 | memset(mbox, 0, sizeof(*mbox)); |
| 1792 | init_vfi = &mbox->u.mqe.un.init_vfi; |
| 1793 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_INIT_VFI); |
| 1794 | bf_set(lpfc_init_vfi_vr, init_vfi, 1); |
| 1795 | bf_set(lpfc_init_vfi_vt, init_vfi, 1); |
| 1796 | bf_set(lpfc_init_vfi_vfi, init_vfi, vport->vfi + vport->phba->vfi_base); |
| 1797 | bf_set(lpfc_init_vfi_fcfi, init_vfi, vport->phba->fcf.fcfi); |
| 1798 | } |
| 1799 | |
| 1800 | /** |
| 1801 | * lpfc_reg_vfi - Initialize the REG_VFI mailbox command |
| 1802 | * @mbox: pointer to lpfc mbox command to initialize. |
| 1803 | * @vport: vport associated with the VF. |
| 1804 | * @phys: BDE DMA bus address used to send the service parameters to the HBA. |
| 1805 | * |
| 1806 | * This routine initializes @mbox to all zeros and then fills in the mailbox |
| 1807 | * fields from @vport, and uses @buf as a DMAable buffer to send the vport's |
| 1808 | * fc service parameters to the HBA for this VFI. REG_VFI configures virtual |
| 1809 | * fabrics identified by VFI in the context of an FCF. |
| 1810 | **/ |
| 1811 | void |
| 1812 | lpfc_reg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport, dma_addr_t phys) |
| 1813 | { |
| 1814 | struct lpfc_mbx_reg_vfi *reg_vfi; |
| 1815 | |
| 1816 | memset(mbox, 0, sizeof(*mbox)); |
| 1817 | reg_vfi = &mbox->u.mqe.un.reg_vfi; |
| 1818 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_REG_VFI); |
| 1819 | bf_set(lpfc_reg_vfi_vp, reg_vfi, 1); |
| 1820 | bf_set(lpfc_reg_vfi_vfi, reg_vfi, vport->vfi + vport->phba->vfi_base); |
| 1821 | bf_set(lpfc_reg_vfi_fcfi, reg_vfi, vport->phba->fcf.fcfi); |
| 1822 | bf_set(lpfc_reg_vfi_vpi, reg_vfi, vport->vpi + vport->phba->vpi_base); |
| 1823 | reg_vfi->bde.addrHigh = putPaddrHigh(phys); |
| 1824 | reg_vfi->bde.addrLow = putPaddrLow(phys); |
| 1825 | reg_vfi->bde.tus.f.bdeSize = sizeof(vport->fc_sparam); |
| 1826 | reg_vfi->bde.tus.f.bdeFlags = BUFF_TYPE_BDE_64; |
| 1827 | bf_set(lpfc_reg_vfi_nport_id, reg_vfi, vport->fc_myDID); |
| 1828 | } |
| 1829 | |
| 1830 | /** |
| 1831 | * lpfc_init_vpi - Initialize the INIT_VPI mailbox command |
James Smart | 1c6834a | 2009-07-19 10:01:26 -0400 | [diff] [blame] | 1832 | * @phba: pointer to the hba structure to init the VPI for. |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1833 | * @mbox: pointer to lpfc mbox command to initialize. |
| 1834 | * @vpi: VPI to be initialized. |
| 1835 | * |
| 1836 | * The INIT_VPI mailbox command supports virtual N_Ports. The driver uses the |
| 1837 | * command to activate a virtual N_Port. The HBA assigns a MAC address to use |
| 1838 | * with the virtual N Port. The SLI Host issues this command before issuing a |
| 1839 | * FDISC to connect to the Fabric. The SLI Host should issue a REG_VPI after a |
| 1840 | * successful virtual NPort login. |
| 1841 | **/ |
| 1842 | void |
James Smart | 1c6834a | 2009-07-19 10:01:26 -0400 | [diff] [blame] | 1843 | lpfc_init_vpi(struct lpfc_hba *phba, struct lpfcMboxq *mbox, uint16_t vpi) |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1844 | { |
| 1845 | memset(mbox, 0, sizeof(*mbox)); |
| 1846 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_INIT_VPI); |
James Smart | 1c6834a | 2009-07-19 10:01:26 -0400 | [diff] [blame] | 1847 | bf_set(lpfc_init_vpi_vpi, &mbox->u.mqe.un.init_vpi, |
| 1848 | vpi + phba->vpi_base); |
| 1849 | bf_set(lpfc_init_vpi_vfi, &mbox->u.mqe.un.init_vpi, |
| 1850 | phba->pport->vfi + phba->vfi_base); |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1851 | } |
| 1852 | |
| 1853 | /** |
| 1854 | * lpfc_unreg_vfi - Initialize the UNREG_VFI mailbox command |
| 1855 | * @mbox: pointer to lpfc mbox command to initialize. |
James Smart | 6669f9b | 2009-10-02 15:16:45 -0400 | [diff] [blame^] | 1856 | * @vport: vport associated with the VF. |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1857 | * |
| 1858 | * The UNREG_VFI mailbox command causes the SLI Host to put a virtual fabric |
| 1859 | * (logical NPort) into the inactive state. The SLI Host must have logged out |
| 1860 | * and unregistered all remote N_Ports to abort any activity on the virtual |
| 1861 | * fabric. The SLI Port posts the mailbox response after marking the virtual |
| 1862 | * fabric inactive. |
| 1863 | **/ |
| 1864 | void |
James Smart | 6669f9b | 2009-10-02 15:16:45 -0400 | [diff] [blame^] | 1865 | lpfc_unreg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport) |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1866 | { |
| 1867 | memset(mbox, 0, sizeof(*mbox)); |
| 1868 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_UNREG_VFI); |
James Smart | 6669f9b | 2009-10-02 15:16:45 -0400 | [diff] [blame^] | 1869 | bf_set(lpfc_unreg_vfi_vfi, &mbox->u.mqe.un.unreg_vfi, |
| 1870 | vport->vfi + vport->phba->vfi_base); |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1871 | } |
| 1872 | |
| 1873 | /** |
| 1874 | * lpfc_dump_fcoe_param - Dump config region 23 to get FCoe parameters. |
| 1875 | * @phba: pointer to the hba structure containing. |
| 1876 | * @mbox: pointer to lpfc mbox command to initialize. |
| 1877 | * |
| 1878 | * This function create a SLI4 dump mailbox command to dump FCoE |
| 1879 | * parameters stored in region 23. |
| 1880 | **/ |
| 1881 | int |
| 1882 | lpfc_dump_fcoe_param(struct lpfc_hba *phba, |
| 1883 | struct lpfcMboxq *mbox) |
| 1884 | { |
| 1885 | struct lpfc_dmabuf *mp = NULL; |
| 1886 | MAILBOX_t *mb; |
| 1887 | |
| 1888 | memset(mbox, 0, sizeof(*mbox)); |
| 1889 | mb = &mbox->u.mb; |
| 1890 | |
| 1891 | mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); |
| 1892 | if (mp) |
| 1893 | mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); |
| 1894 | |
| 1895 | if (!mp || !mp->virt) { |
| 1896 | kfree(mp); |
| 1897 | /* dump_fcoe_param failed to allocate memory */ |
| 1898 | lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX, |
| 1899 | "2569 lpfc_dump_fcoe_param: memory" |
James Smart | e4e7427 | 2009-07-19 10:01:38 -0400 | [diff] [blame] | 1900 | " allocation failed\n"); |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1901 | return 1; |
| 1902 | } |
| 1903 | |
| 1904 | memset(mp->virt, 0, LPFC_BPL_SIZE); |
| 1905 | INIT_LIST_HEAD(&mp->list); |
| 1906 | |
| 1907 | /* save address for completion */ |
| 1908 | mbox->context1 = (uint8_t *) mp; |
| 1909 | |
| 1910 | mb->mbxCommand = MBX_DUMP_MEMORY; |
| 1911 | mb->un.varDmp.type = DMP_NV_PARAMS; |
James Smart | a0c87cb | 2009-07-19 10:01:10 -0400 | [diff] [blame] | 1912 | mb->un.varDmp.region_id = DMP_REGION_23; |
| 1913 | mb->un.varDmp.sli4_length = DMP_RGN23_SIZE; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1914 | mb->un.varWords[3] = putPaddrLow(mp->phys); |
| 1915 | mb->un.varWords[4] = putPaddrHigh(mp->phys); |
| 1916 | return 0; |
| 1917 | } |
| 1918 | |
| 1919 | /** |
| 1920 | * lpfc_reg_fcfi - Initialize the REG_FCFI mailbox command |
| 1921 | * @phba: pointer to the hba structure containing the FCF index and RQ ID. |
| 1922 | * @mbox: pointer to lpfc mbox command to initialize. |
| 1923 | * |
| 1924 | * The REG_FCFI mailbox command supports Fibre Channel Forwarders (FCFs). The |
| 1925 | * SLI Host uses the command to activate an FCF after it has acquired FCF |
| 1926 | * information via a READ_FCF mailbox command. This mailbox command also is used |
| 1927 | * to indicate where received unsolicited frames from this FCF will be sent. By |
| 1928 | * default this routine will set up the FCF to forward all unsolicited frames |
| 1929 | * the the RQ ID passed in the @phba. This can be overridden by the caller for |
| 1930 | * more complicated setups. |
| 1931 | **/ |
| 1932 | void |
| 1933 | lpfc_reg_fcfi(struct lpfc_hba *phba, struct lpfcMboxq *mbox) |
| 1934 | { |
| 1935 | struct lpfc_mbx_reg_fcfi *reg_fcfi; |
| 1936 | |
| 1937 | memset(mbox, 0, sizeof(*mbox)); |
| 1938 | reg_fcfi = &mbox->u.mqe.un.reg_fcfi; |
| 1939 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_REG_FCFI); |
| 1940 | bf_set(lpfc_reg_fcfi_rq_id0, reg_fcfi, phba->sli4_hba.hdr_rq->queue_id); |
| 1941 | bf_set(lpfc_reg_fcfi_rq_id1, reg_fcfi, REG_FCF_INVALID_QID); |
| 1942 | bf_set(lpfc_reg_fcfi_rq_id2, reg_fcfi, REG_FCF_INVALID_QID); |
| 1943 | bf_set(lpfc_reg_fcfi_rq_id3, reg_fcfi, REG_FCF_INVALID_QID); |
| 1944 | bf_set(lpfc_reg_fcfi_info_index, reg_fcfi, phba->fcf.fcf_indx); |
| 1945 | /* reg_fcf addr mode is bit wise inverted value of fcf addr_mode */ |
| 1946 | bf_set(lpfc_reg_fcfi_mam, reg_fcfi, |
| 1947 | (~phba->fcf.addr_mode) & 0x3); |
| 1948 | if (phba->fcf.fcf_flag & FCF_VALID_VLAN) { |
| 1949 | bf_set(lpfc_reg_fcfi_vv, reg_fcfi, 1); |
| 1950 | bf_set(lpfc_reg_fcfi_vlan_tag, reg_fcfi, phba->fcf.vlan_id); |
| 1951 | } |
| 1952 | } |
| 1953 | |
| 1954 | /** |
| 1955 | * lpfc_unreg_fcfi - Initialize the UNREG_FCFI mailbox command |
| 1956 | * @mbox: pointer to lpfc mbox command to initialize. |
| 1957 | * @fcfi: FCFI to be unregistered. |
| 1958 | * |
| 1959 | * The UNREG_FCFI mailbox command supports Fibre Channel Forwarders (FCFs). |
| 1960 | * The SLI Host uses the command to inactivate an FCFI. |
| 1961 | **/ |
| 1962 | void |
| 1963 | lpfc_unreg_fcfi(struct lpfcMboxq *mbox, uint16_t fcfi) |
| 1964 | { |
| 1965 | memset(mbox, 0, sizeof(*mbox)); |
| 1966 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_UNREG_FCFI); |
| 1967 | bf_set(lpfc_unreg_fcfi, &mbox->u.mqe.un.unreg_fcfi, fcfi); |
| 1968 | } |
| 1969 | |
| 1970 | /** |
| 1971 | * lpfc_resume_rpi - Initialize the RESUME_RPI mailbox command |
| 1972 | * @mbox: pointer to lpfc mbox command to initialize. |
| 1973 | * @ndlp: The nodelist structure that describes the RPI to resume. |
| 1974 | * |
| 1975 | * The RESUME_RPI mailbox command is used to restart I/O to an RPI after a |
| 1976 | * link event. |
| 1977 | **/ |
| 1978 | void |
| 1979 | lpfc_resume_rpi(struct lpfcMboxq *mbox, struct lpfc_nodelist *ndlp) |
| 1980 | { |
| 1981 | struct lpfc_mbx_resume_rpi *resume_rpi; |
| 1982 | |
| 1983 | memset(mbox, 0, sizeof(*mbox)); |
| 1984 | resume_rpi = &mbox->u.mqe.un.resume_rpi; |
| 1985 | bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_RESUME_RPI); |
James Smart | 8fa3851 | 2009-07-19 10:01:03 -0400 | [diff] [blame] | 1986 | bf_set(lpfc_resume_rpi_index, resume_rpi, ndlp->nlp_rpi); |
| 1987 | bf_set(lpfc_resume_rpi_ii, resume_rpi, RESUME_INDEX_RPI); |
| 1988 | resume_rpi->event_tag = ndlp->phba->fc_eventTag; |
James Smart | 04c6849 | 2009-05-22 14:52:52 -0400 | [diff] [blame] | 1989 | } |