1 /*- 2 * Copyright (c) 2011-2015 LSI Corp. 3 * Copyright (c) 2013-2015 Avago Technologies 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * Avago Technologies (LSI) MPT-Fusion Host Adapter FreeBSD 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 /* TODO Move headers to mpsvar */ 34 #include <sys/types.h> 35 #include <sys/param.h> 36 #include <sys/lock.h> 37 #include <sys/mutex.h> 38 #include <sys/systm.h> 39 #include <sys/kernel.h> 40 #include <sys/malloc.h> 41 #include <sys/kthread.h> 42 #include <sys/taskqueue.h> 43 #include <sys/bus.h> 44 #include <sys/endian.h> 45 #include <sys/sysctl.h> 46 #include <sys/eventhandler.h> 47 #include <sys/uio.h> 48 #include <machine/bus.h> 49 #include <machine/resource.h> 50 #include <dev/mps/mpi/mpi2_type.h> 51 #include <dev/mps/mpi/mpi2.h> 52 #include <dev/mps/mpi/mpi2_ioc.h> 53 #include <dev/mps/mpi/mpi2_sas.h> 54 #include <dev/mps/mpi/mpi2_cnfg.h> 55 #include <dev/mps/mpi/mpi2_init.h> 56 #include <dev/mps/mpi/mpi2_tool.h> 57 #include <dev/mps/mps_ioctl.h> 58 #include <dev/mps/mpsvar.h> 59 60 /** 61 * mps_config_get_ioc_pg8 - obtain ioc page 8 62 * @sc: per adapter object 63 * @mpi_reply: reply mf payload returned from firmware 64 * @config_page: contents of the config page 65 * Context: sleep. 66 * 67 * Returns 0 for success, non-zero for failure. 68 */ 69 int 70 mps_config_get_ioc_pg8(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply, 71 Mpi2IOCPage8_t *config_page) 72 { 73 MPI2_CONFIG_REQUEST *request; 74 MPI2_CONFIG_REPLY *reply; 75 struct mps_command *cm; 76 MPI2_CONFIG_PAGE_IOC_8 *page = NULL; 77 int error = 0; 78 u16 ioc_status; 79 80 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 81 82 if ((cm = mps_alloc_command(sc)) == NULL) { 83 printf("%s: command alloc failed @ line %d\n", __func__, 84 __LINE__); 85 error = EBUSY; 86 goto out; 87 } 88 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 89 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 90 request->Function = MPI2_FUNCTION_CONFIG; 91 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 92 request->Header.PageType = MPI2_CONFIG_PAGETYPE_IOC; 93 request->Header.PageNumber = 8; 94 request->Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION; 95 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 96 cm->cm_data = NULL; 97 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 98 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 99 if (error || (reply == NULL)) { 100 /* FIXME */ 101 /* 102 * If the request returns an error then we need to do a diag 103 * reset 104 */ 105 printf("%s: request for header completed with error %d", 106 __func__, error); 107 error = ENXIO; 108 goto out; 109 } 110 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 111 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 112 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 113 /* FIXME */ 114 /* 115 * If the request returns an error then we need to do a diag 116 * reset 117 */ 118 printf("%s: header read with error; iocstatus = 0x%x\n", 119 __func__, ioc_status); 120 error = ENXIO; 121 goto out; 122 } 123 /* We have to do free and alloc for the reply-free and reply-post 124 * counters to match - Need to review the reply FIFO handling. 125 */ 126 mps_free_command(sc, cm); 127 128 if ((cm = mps_alloc_command(sc)) == NULL) { 129 printf("%s: command alloc failed @ line %d\n", __func__, 130 __LINE__); 131 error = EBUSY; 132 goto out; 133 } 134 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 135 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 136 request->Function = MPI2_FUNCTION_CONFIG; 137 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 138 request->Header.PageType = MPI2_CONFIG_PAGETYPE_IOC; 139 request->Header.PageNumber = 8; 140 request->Header.PageVersion = MPI2_IOCPAGE8_PAGEVERSION; 141 request->Header.PageLength = mpi_reply->Header.PageLength; 142 cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4; 143 cm->cm_sge = &request->PageBufferSGE; 144 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 145 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 146 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 147 page = malloc((cm->cm_length), M_MPT2, M_ZERO | M_NOWAIT); 148 if (!page) { 149 printf("%s: page alloc failed\n", __func__); 150 error = ENOMEM; 151 goto out; 152 } 153 cm->cm_data = page; 154 155 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 156 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 157 if (error || (reply == NULL)) { 158 /* FIXME */ 159 /* 160 * If the request returns an error then we need to do a diag 161 * reset 162 */ 163 printf("%s: request for page completed with error %d", 164 __func__, error); 165 error = ENXIO; 166 goto out; 167 } 168 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 169 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 170 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 171 /* FIXME */ 172 /* 173 * If the request returns an error then we need to do a diag 174 * reset 175 */ 176 printf("%s: page read with error; iocstatus = 0x%x\n", 177 __func__, ioc_status); 178 error = ENXIO; 179 goto out; 180 } 181 bcopy(page, config_page, MIN(cm->cm_length, (sizeof(Mpi2IOCPage8_t)))); 182 183 out: 184 free(page, M_MPT2); 185 if (cm) 186 mps_free_command(sc, cm); 187 return (error); 188 } 189 190 /** 191 * mps_config_get_man_pg10 - obtain Manufacturing Page 10 data and set flags 192 * accordingly. Currently, this page does not need to return to caller. 193 * @sc: per adapter object 194 * @mpi_reply: reply mf payload returned from firmware 195 * Context: sleep. 196 * 197 * Returns 0 for success, non-zero for failure. 198 */ 199 int 200 mps_config_get_man_pg10(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply) 201 { 202 MPI2_CONFIG_REQUEST *request; 203 MPI2_CONFIG_REPLY *reply; 204 struct mps_command *cm; 205 pMpi2ManufacturingPagePS_t page = NULL; 206 uint32_t *pPS_info; 207 uint8_t OEM_Value = 0; 208 int error = 0; 209 u16 ioc_status; 210 211 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 212 213 if ((cm = mps_alloc_command(sc)) == NULL) { 214 printf("%s: command alloc failed @ line %d\n", __func__, 215 __LINE__); 216 error = EBUSY; 217 goto out; 218 } 219 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 220 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 221 request->Function = MPI2_FUNCTION_CONFIG; 222 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 223 request->Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING; 224 request->Header.PageNumber = 10; 225 request->Header.PageVersion = MPI2_MANUFACTURING10_PAGEVERSION; 226 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 227 cm->cm_data = NULL; 228 229 /* 230 * This page must be polled because the IOC isn't ready yet when this 231 * page is needed. 232 */ 233 error = mps_request_polled(sc, cm); 234 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 235 if (error || (reply == NULL)) { 236 /* FIXME */ 237 /* If the poll returns error then we need to do diag reset */ 238 printf("%s: poll for header completed with error %d", 239 __func__, error); 240 error = ENXIO; 241 goto out; 242 } 243 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 244 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 245 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 246 /* FIXME */ 247 /* If the poll returns error then we need to do diag reset */ 248 printf("%s: header read with error; iocstatus = 0x%x\n", 249 __func__, ioc_status); 250 error = ENXIO; 251 goto out; 252 } 253 /* We have to do free and alloc for the reply-free and reply-post 254 * counters to match - Need to review the reply FIFO handling. 255 */ 256 mps_free_command(sc, cm); 257 258 if ((cm = mps_alloc_command(sc)) == NULL) { 259 printf("%s: command alloc failed @ line %d\n", __func__, 260 __LINE__); 261 error = EBUSY; 262 goto out; 263 } 264 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 265 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 266 request->Function = MPI2_FUNCTION_CONFIG; 267 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 268 request->Header.PageType = MPI2_CONFIG_PAGETYPE_MANUFACTURING; 269 request->Header.PageNumber = 10; 270 request->Header.PageVersion = MPI2_MANUFACTURING10_PAGEVERSION; 271 request->Header.PageLength = mpi_reply->Header.PageLength; 272 cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4; 273 cm->cm_sge = &request->PageBufferSGE; 274 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 275 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 276 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 277 page = malloc(MPS_MAN_PAGE10_SIZE, M_MPT2, M_ZERO | M_NOWAIT); 278 if (!page) { 279 printf("%s: page alloc failed\n", __func__); 280 error = ENOMEM; 281 goto out; 282 } 283 cm->cm_data = page; 284 285 /* 286 * This page must be polled because the IOC isn't ready yet when this 287 * page is needed. 288 */ 289 error = mps_request_polled(sc, cm); 290 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 291 if (error || (reply == NULL)) { 292 /* FIXME */ 293 /* If the poll returns error then we need to do diag reset */ 294 printf("%s: poll for page completed with error %d", 295 __func__, error); 296 error = ENXIO; 297 goto out; 298 } 299 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 300 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 301 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 302 /* FIXME */ 303 /* If the poll returns error then we need to do diag reset */ 304 printf("%s: page read with error; iocstatus = 0x%x\n", 305 __func__, ioc_status); 306 error = ENXIO; 307 goto out; 308 } 309 310 /* 311 * If OEM ID is unknown, fail the request. 312 */ 313 sc->WD_hide_expose = MPS_WD_HIDE_ALWAYS; 314 OEM_Value = (uint8_t)(page->ProductSpecificInfo & 0x000000FF); 315 if (OEM_Value != MPS_WD_LSI_OEM) { 316 mps_dprint(sc, MPS_FAULT, "Unknown OEM value for WarpDrive " 317 "(0x%x)\n", OEM_Value); 318 error = ENXIO; 319 goto out; 320 } 321 322 /* 323 * Set the phys disks hide/expose value. 324 */ 325 pPS_info = &page->ProductSpecificInfo; 326 sc->WD_hide_expose = (uint8_t)(pPS_info[5]); 327 sc->WD_hide_expose &= MPS_WD_HIDE_EXPOSE_MASK; 328 if ((sc->WD_hide_expose != MPS_WD_HIDE_ALWAYS) && 329 (sc->WD_hide_expose != MPS_WD_EXPOSE_ALWAYS) && 330 (sc->WD_hide_expose != MPS_WD_HIDE_IF_VOLUME)) { 331 mps_dprint(sc, MPS_FAULT, "Unknown value for WarpDrive " 332 "hide/expose: 0x%x\n", sc->WD_hide_expose); 333 error = ENXIO; 334 goto out; 335 } 336 337 out: 338 free(page, M_MPT2); 339 if (cm) 340 mps_free_command(sc, cm); 341 return (error); 342 } 343 344 /** 345 * mps_base_static_config_pages - static start of day config pages. 346 * @sc: per adapter object 347 * 348 * Return nothing. 349 */ 350 void 351 mps_base_static_config_pages(struct mps_softc *sc) 352 { 353 Mpi2ConfigReply_t mpi_reply; 354 int retry; 355 356 retry = 0; 357 while (mps_config_get_ioc_pg8(sc, &mpi_reply, &sc->ioc_pg8)) { 358 retry++; 359 if (retry > 5) { 360 /* We need to Handle this situation */ 361 /*FIXME*/ 362 break; 363 } 364 } 365 } 366 367 /** 368 * mps_wd_config_pages - get info required to support WarpDrive. This needs to 369 * be called after discovery is complete to guarentee that IR info is there. 370 * @sc: per adapter object 371 * 372 * Return nothing. 373 */ 374 void 375 mps_wd_config_pages(struct mps_softc *sc) 376 { 377 Mpi2ConfigReply_t mpi_reply; 378 pMpi2RaidVolPage0_t raid_vol_pg0 = NULL; 379 Mpi2RaidPhysDiskPage0_t phys_disk_pg0; 380 pMpi2RaidVol0PhysDisk_t pRVPD; 381 uint32_t stripe_size, phys_disk_page_address; 382 uint16_t block_size; 383 uint8_t index, stripe_exp = 0, block_exp = 0; 384 385 /* 386 * Get the WD settings from manufacturing page 10 if using a WD HBA. 387 * This will be used to determine if phys disks should always be 388 * hidden, hidden only if part of a WD volume, or never hidden. Also, 389 * get the WD RAID Volume info and fail if volume does not exist or if 390 * volume does not meet the requirements for a WD volume. No retry 391 * here. Just default to HIDE ALWAYS if man Page10 fails, or clear WD 392 * Valid flag if Volume info fails. 393 */ 394 sc->WD_valid_config = FALSE; 395 if (sc->mps_flags & MPS_FLAGS_WD_AVAILABLE) { 396 if (mps_config_get_man_pg10(sc, &mpi_reply)) { 397 mps_dprint(sc, MPS_FAULT, 398 "mps_config_get_man_pg10 failed! Using 0 (Hide " 399 "Always) for WarpDrive hide/expose value.\n"); 400 sc->WD_hide_expose = MPS_WD_HIDE_ALWAYS; 401 } 402 403 /* 404 * Get first RAID Volume Page0 using GET_NEXT_HANDLE. 405 */ 406 raid_vol_pg0 = malloc(sizeof(Mpi2RaidVolPage0_t) + 407 (sizeof(Mpi2RaidVol0PhysDisk_t) * MPS_MAX_DISKS_IN_VOL), 408 M_MPT2, M_ZERO | M_NOWAIT); 409 if (!raid_vol_pg0) { 410 printf("%s: page alloc failed\n", __func__); 411 goto out; 412 } 413 414 if (mps_config_get_raid_volume_pg0(sc, &mpi_reply, raid_vol_pg0, 415 0x0000FFFF)) { 416 mps_dprint(sc, MPS_INFO, 417 "mps_config_get_raid_volume_pg0 failed! Assuming " 418 "WarpDrive IT mode.\n"); 419 goto out; 420 } 421 422 /* 423 * Check for valid WD configuration: 424 * volume type is RAID0 425 * number of phys disks in the volume is no more than 8 426 */ 427 if ((raid_vol_pg0->VolumeType != MPI2_RAID_VOL_TYPE_RAID0) || 428 (raid_vol_pg0->NumPhysDisks > 8)) { 429 mps_dprint(sc, MPS_FAULT, 430 "Invalid WarpDrive configuration. Direct Drive I/O " 431 "will not be used.\n"); 432 goto out; 433 } 434 435 /* 436 * Save the WD RAID data to be used during WD I/O. 437 */ 438 sc->DD_max_lba = le64toh((uint64_t)raid_vol_pg0->MaxLBA.High << 439 32 | (uint64_t)raid_vol_pg0->MaxLBA.Low); 440 sc->DD_num_phys_disks = raid_vol_pg0->NumPhysDisks; 441 sc->DD_dev_handle = raid_vol_pg0->DevHandle; 442 sc->DD_stripe_size = raid_vol_pg0->StripeSize; 443 sc->DD_block_size = raid_vol_pg0->BlockSize; 444 445 /* 446 * Find power of 2 of stripe size and set this as the exponent. 447 * Fail if stripe size is 0. 448 */ 449 stripe_size = raid_vol_pg0->StripeSize; 450 for (index = 0; index < 32; index++) { 451 if (stripe_size & 1) 452 break; 453 stripe_exp++; 454 stripe_size >>= 1; 455 } 456 if (index == 32) { 457 mps_dprint(sc, MPS_FAULT, 458 "RAID Volume's stripe size is 0. Direct Drive I/O " 459 "will not be used.\n"); 460 goto out; 461 } 462 sc->DD_stripe_exponent = stripe_exp; 463 464 /* 465 * Find power of 2 of block size and set this as the exponent. 466 * Fail if block size is 0. 467 */ 468 block_size = raid_vol_pg0->BlockSize; 469 for (index = 0; index < 16; index++) { 470 if (block_size & 1) 471 break; 472 block_exp++; 473 block_size >>= 1; 474 } 475 if (index == 16) { 476 mps_dprint(sc, MPS_FAULT, 477 "RAID Volume's block size is 0. Direct Drive I/O " 478 "will not be used.\n"); 479 goto out; 480 } 481 sc->DD_block_exponent = block_exp; 482 483 /* 484 * Loop through all of the volume's Phys Disks to map the phys 485 * disk number into the columm map. This is used during Direct 486 * Drive I/O to send the request to the correct SSD. 487 */ 488 pRVPD = (pMpi2RaidVol0PhysDisk_t)&raid_vol_pg0->PhysDisk; 489 for (index = 0; index < raid_vol_pg0->NumPhysDisks; index++) { 490 sc->DD_column_map[pRVPD->PhysDiskMap].phys_disk_num = 491 pRVPD->PhysDiskNum; 492 pRVPD++; 493 } 494 495 /* 496 * Get second RAID Volume Page0 using previous handle. This 497 * page should not exist. If it does, must not proceed with WD 498 * handling. 499 */ 500 if (mps_config_get_raid_volume_pg0(sc, &mpi_reply, 501 raid_vol_pg0, (u32)raid_vol_pg0->DevHandle)) { 502 if (mpi_reply.IOCStatus != 503 MPI2_IOCSTATUS_CONFIG_INVALID_PAGE) { 504 mps_dprint(sc, MPS_FAULT, 505 "Multiple RAID Volume Page0! Direct Drive " 506 "I/O will not be used.\n"); 507 goto out; 508 } 509 } else { 510 mps_dprint(sc, MPS_FAULT, 511 "Multiple volumes! Direct Drive I/O will not be " 512 "used.\n"); 513 goto out; 514 } 515 516 /* 517 * Get RAID Volume Phys Disk Page 0 for all SSDs in the volume. 518 */ 519 for (index = 0; index < raid_vol_pg0->NumPhysDisks; index++) { 520 phys_disk_page_address = 521 MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM + 522 sc->DD_column_map[index].phys_disk_num; 523 if (mps_config_get_raid_pd_pg0(sc, &mpi_reply, 524 &phys_disk_pg0, phys_disk_page_address)) { 525 mps_dprint(sc, MPS_FAULT, 526 "mps_config_get_raid_pd_pg0 failed! Direct " 527 "Drive I/O will not be used.\n"); 528 goto out; 529 } 530 if (phys_disk_pg0.DevHandle == 0xFFFF) { 531 mps_dprint(sc, MPS_FAULT, 532 "Invalid Phys Disk DevHandle! Direct Drive " 533 "I/O will not be used.\n"); 534 goto out; 535 } 536 sc->DD_column_map[index].dev_handle = 537 phys_disk_pg0.DevHandle; 538 } 539 sc->WD_valid_config = TRUE; 540 out: 541 if (raid_vol_pg0) 542 free(raid_vol_pg0, M_MPT2); 543 } 544 } 545 546 /** 547 * mps_config_get_dpm_pg0 - obtain driver persistent mapping page0 548 * @sc: per adapter object 549 * @mpi_reply: reply mf payload returned from firmware 550 * @config_page: contents of the config page 551 * @sz: size of buffer passed in config_page 552 * Context: sleep. 553 * 554 * Returns 0 for success, non-zero for failure. 555 */ 556 int 557 mps_config_get_dpm_pg0(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply, 558 Mpi2DriverMappingPage0_t *config_page, u16 sz) 559 { 560 MPI2_CONFIG_REQUEST *request; 561 MPI2_CONFIG_REPLY *reply; 562 struct mps_command *cm; 563 Mpi2DriverMappingPage0_t *page = NULL; 564 int error = 0; 565 u16 ioc_status; 566 567 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 568 569 memset(config_page, 0, sz); 570 if ((cm = mps_alloc_command(sc)) == NULL) { 571 printf("%s: command alloc failed @ line %d\n", __func__, 572 __LINE__); 573 error = EBUSY; 574 goto out; 575 } 576 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 577 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 578 request->Function = MPI2_FUNCTION_CONFIG; 579 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 580 request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 581 request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING; 582 request->Header.PageNumber = 0; 583 request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION; 584 request->PageAddress = sc->max_dpm_entries << 585 MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT; 586 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 587 cm->cm_data = NULL; 588 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 589 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 590 if (error || (reply == NULL)) { 591 /* FIXME */ 592 /* 593 * If the request returns an error then we need to do a diag 594 * reset 595 */ 596 printf("%s: request for header completed with error %d", 597 __func__, error); 598 error = ENXIO; 599 goto out; 600 } 601 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 602 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 603 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 604 /* FIXME */ 605 /* 606 * If the request returns an error then we need to do a diag 607 * reset 608 */ 609 printf("%s: header read with error; iocstatus = 0x%x\n", 610 __func__, ioc_status); 611 error = ENXIO; 612 goto out; 613 } 614 /* We have to do free and alloc for the reply-free and reply-post 615 * counters to match - Need to review the reply FIFO handling. 616 */ 617 mps_free_command(sc, cm); 618 619 if ((cm = mps_alloc_command(sc)) == NULL) { 620 printf("%s: command alloc failed @ line %d\n", __func__, 621 __LINE__); 622 error = EBUSY; 623 goto out; 624 } 625 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 626 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 627 request->Function = MPI2_FUNCTION_CONFIG; 628 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_NVRAM; 629 request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 630 request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING; 631 request->Header.PageNumber = 0; 632 request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION; 633 request->PageAddress = sc->max_dpm_entries << 634 MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT; 635 request->ExtPageLength = mpi_reply->ExtPageLength; 636 cm->cm_length = le16toh(request->ExtPageLength) * 4; 637 cm->cm_sge = &request->PageBufferSGE; 638 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 639 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 640 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 641 page = malloc(cm->cm_length, M_MPT2, M_ZERO|M_NOWAIT); 642 if (!page) { 643 printf("%s: page alloc failed\n", __func__); 644 error = ENOMEM; 645 goto out; 646 } 647 cm->cm_data = page; 648 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 649 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 650 if (error || (reply == NULL)) { 651 /* FIXME */ 652 /* 653 * If the request returns an error then we need to do a diag 654 * reset 655 */ 656 printf("%s: request for page completed with error %d", 657 __func__, error); 658 error = ENXIO; 659 goto out; 660 } 661 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 662 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 663 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 664 /* FIXME */ 665 /* 666 * If the request returns an error then we need to do a diag 667 * reset 668 */ 669 printf("%s: page read with error; iocstatus = 0x%x\n", 670 __func__, ioc_status); 671 error = ENXIO; 672 goto out; 673 } 674 bcopy(page, config_page, MIN(cm->cm_length, sz)); 675 out: 676 free(page, M_MPT2); 677 if (cm) 678 mps_free_command(sc, cm); 679 return (error); 680 } 681 682 /** 683 * mps_config_set_dpm_pg0 - write an entry in driver persistent mapping page0 684 * @sc: per adapter object 685 * @mpi_reply: reply mf payload returned from firmware 686 * @config_page: contents of the config page 687 * @entry_idx: entry index in DPM Page0 to be modified 688 * Context: sleep. 689 * 690 * Returns 0 for success, non-zero for failure. 691 */ 692 693 int mps_config_set_dpm_pg0(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply, 694 Mpi2DriverMappingPage0_t *config_page, u16 entry_idx) 695 { 696 MPI2_CONFIG_REQUEST *request; 697 MPI2_CONFIG_REPLY *reply; 698 struct mps_command *cm; 699 MPI2_CONFIG_PAGE_DRIVER_MAPPING_0 *page = NULL; 700 int error = 0; 701 u16 ioc_status; 702 703 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 704 705 if ((cm = mps_alloc_command(sc)) == NULL) { 706 printf("%s: command alloc failed @ line %d\n", __func__, 707 __LINE__); 708 error = EBUSY; 709 goto out; 710 } 711 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 712 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 713 request->Function = MPI2_FUNCTION_CONFIG; 714 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 715 request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 716 request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING; 717 request->Header.PageNumber = 0; 718 request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION; 719 /* We can remove below two lines ????*/ 720 request->PageAddress = 1 << MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT; 721 request->PageAddress |= htole16(entry_idx); 722 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 723 cm->cm_data = NULL; 724 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 725 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 726 if (error || (reply == NULL)) { 727 /* FIXME */ 728 /* 729 * If the request returns an error then we need to do a diag 730 * reset 731 */ 732 printf("%s: request for header completed with error %d", 733 __func__, error); 734 error = ENXIO; 735 goto out; 736 } 737 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 738 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 739 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 740 /* FIXME */ 741 /* 742 * If the request returns an error then we need to do a diag 743 * reset 744 */ 745 printf("%s: header read with error; iocstatus = 0x%x\n", 746 __func__, ioc_status); 747 error = ENXIO; 748 goto out; 749 } 750 /* We have to do free and alloc for the reply-free and reply-post 751 * counters to match - Need to review the reply FIFO handling. 752 */ 753 mps_free_command(sc, cm); 754 755 if ((cm = mps_alloc_command(sc)) == NULL) { 756 printf("%s: command alloc failed @ line %d\n", __func__, 757 __LINE__); 758 error = EBUSY; 759 goto out; 760 } 761 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 762 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 763 request->Function = MPI2_FUNCTION_CONFIG; 764 request->Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM; 765 request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 766 request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING; 767 request->Header.PageNumber = 0; 768 request->Header.PageVersion = MPI2_DRIVERMAPPING0_PAGEVERSION; 769 request->ExtPageLength = mpi_reply->ExtPageLength; 770 request->PageAddress = 1 << MPI2_DPM_PGAD_ENTRY_COUNT_SHIFT; 771 request->PageAddress |= htole16(entry_idx); 772 cm->cm_length = le16toh(mpi_reply->ExtPageLength) * 4; 773 cm->cm_sge = &request->PageBufferSGE; 774 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 775 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAOUT; 776 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 777 page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT); 778 if (!page) { 779 printf("%s: page alloc failed\n", __func__); 780 error = ENOMEM; 781 goto out; 782 } 783 bcopy(config_page, page, MIN(cm->cm_length, 784 (sizeof(Mpi2DriverMappingPage0_t)))); 785 cm->cm_data = page; 786 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 787 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 788 if (error || (reply == NULL)) { 789 /* FIXME */ 790 /* 791 * If the request returns an error then we need to do a diag 792 * reset 793 */ 794 printf("%s: request to write page completed with error %d", 795 __func__, error); 796 error = ENXIO; 797 goto out; 798 } 799 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 800 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 801 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 802 /* FIXME */ 803 /* 804 * If the request returns an error then we need to do a diag 805 * reset 806 */ 807 printf("%s: page written with error; iocstatus = 0x%x\n", 808 __func__, ioc_status); 809 error = ENXIO; 810 goto out; 811 } 812 out: 813 free(page, M_MPT2); 814 if (cm) 815 mps_free_command(sc, cm); 816 return (error); 817 } 818 819 /** 820 * mps_config_get_sas_device_pg0 - obtain sas device page 0 821 * @sc: per adapter object 822 * @mpi_reply: reply mf payload returned from firmware 823 * @config_page: contents of the config page 824 * @form: GET_NEXT_HANDLE or HANDLE 825 * @handle: device handle 826 * Context: sleep. 827 * 828 * Returns 0 for success, non-zero for failure. 829 */ 830 int 831 mps_config_get_sas_device_pg0(struct mps_softc *sc, Mpi2ConfigReply_t 832 *mpi_reply, Mpi2SasDevicePage0_t *config_page, u32 form, u16 handle) 833 { 834 MPI2_CONFIG_REQUEST *request; 835 MPI2_CONFIG_REPLY *reply; 836 struct mps_command *cm; 837 Mpi2SasDevicePage0_t *page = NULL; 838 int error = 0; 839 u16 ioc_status; 840 841 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 842 843 if ((cm = mps_alloc_command(sc)) == NULL) { 844 printf("%s: command alloc failed @ line %d\n", __func__, 845 __LINE__); 846 error = EBUSY; 847 goto out; 848 } 849 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 850 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 851 request->Function = MPI2_FUNCTION_CONFIG; 852 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 853 request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 854 request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE; 855 request->Header.PageNumber = 0; 856 request->Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION; 857 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 858 cm->cm_data = NULL; 859 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 860 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 861 if (error || (reply == NULL)) { 862 /* FIXME */ 863 /* 864 * If the request returns an error then we need to do a diag 865 * reset 866 */ 867 printf("%s: request for header completed with error %d", 868 __func__, error); 869 error = ENXIO; 870 goto out; 871 } 872 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 873 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 874 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 875 /* FIXME */ 876 /* 877 * If the request returns an error then we need to do a diag 878 * reset 879 */ 880 printf("%s: header read with error; iocstatus = 0x%x\n", 881 __func__, ioc_status); 882 error = ENXIO; 883 goto out; 884 } 885 /* We have to do free and alloc for the reply-free and reply-post 886 * counters to match - Need to review the reply FIFO handling. 887 */ 888 mps_free_command(sc, cm); 889 890 if ((cm = mps_alloc_command(sc)) == NULL) { 891 printf("%s: command alloc failed @ line %d\n", __func__, 892 __LINE__); 893 error = EBUSY; 894 goto out; 895 } 896 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 897 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 898 request->Function = MPI2_FUNCTION_CONFIG; 899 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 900 request->Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED; 901 request->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE; 902 request->Header.PageNumber = 0; 903 request->Header.PageVersion = MPI2_SASDEVICE0_PAGEVERSION; 904 request->ExtPageLength = mpi_reply->ExtPageLength; 905 request->PageAddress = htole32(form | handle); 906 cm->cm_length = le16toh(mpi_reply->ExtPageLength) * 4; 907 cm->cm_sge = &request->PageBufferSGE; 908 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 909 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 910 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 911 page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT); 912 if (!page) { 913 printf("%s: page alloc failed\n", __func__); 914 error = ENOMEM; 915 goto out; 916 } 917 cm->cm_data = page; 918 919 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 920 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 921 if (error || (reply == NULL)) { 922 /* FIXME */ 923 /* 924 * If the request returns an error then we need to do a diag 925 * reset 926 */ 927 printf("%s: request for page completed with error %d", 928 __func__, error); 929 error = ENXIO; 930 goto out; 931 } 932 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 933 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 934 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 935 /* FIXME */ 936 /* 937 * If the request returns an error then we need to do a diag 938 * reset 939 */ 940 printf("%s: page read with error; iocstatus = 0x%x\n", 941 __func__, ioc_status); 942 error = ENXIO; 943 goto out; 944 } 945 bcopy(page, config_page, MIN(cm->cm_length, 946 sizeof(Mpi2SasDevicePage0_t))); 947 out: 948 free(page, M_MPT2); 949 if (cm) 950 mps_free_command(sc, cm); 951 return (error); 952 } 953 954 /** 955 * mps_config_get_bios_pg3 - obtain BIOS page 3 956 * @sc: per adapter object 957 * @mpi_reply: reply mf payload returned from firmware 958 * @config_page: contents of the config page 959 * Context: sleep. 960 * 961 * Returns 0 for success, non-zero for failure. 962 */ 963 int 964 mps_config_get_bios_pg3(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply, 965 Mpi2BiosPage3_t *config_page) 966 { 967 MPI2_CONFIG_REQUEST *request; 968 MPI2_CONFIG_REPLY *reply; 969 struct mps_command *cm; 970 Mpi2BiosPage3_t *page = NULL; 971 int error = 0; 972 u16 ioc_status; 973 974 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 975 976 if ((cm = mps_alloc_command(sc)) == NULL) { 977 printf("%s: command alloc failed @ line %d\n", __func__, 978 __LINE__); 979 error = EBUSY; 980 goto out; 981 } 982 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 983 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 984 request->Function = MPI2_FUNCTION_CONFIG; 985 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 986 request->Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS; 987 request->Header.PageNumber = 3; 988 request->Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION; 989 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 990 cm->cm_data = NULL; 991 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 992 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 993 if (error || (reply == NULL)) { 994 /* FIXME */ 995 /* 996 * If the request returns an error then we need to do a diag 997 * reset 998 */ 999 printf("%s: request for header completed with error %d", 1000 __func__, error); 1001 error = ENXIO; 1002 goto out; 1003 } 1004 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1005 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1006 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1007 /* FIXME */ 1008 /* 1009 * If the request returns an error then we need to do a diag 1010 * reset 1011 */ 1012 printf("%s: header read with error; iocstatus = 0x%x\n", 1013 __func__, ioc_status); 1014 error = ENXIO; 1015 goto out; 1016 } 1017 /* We have to do free and alloc for the reply-free and reply-post 1018 * counters to match - Need to review the reply FIFO handling. 1019 */ 1020 mps_free_command(sc, cm); 1021 1022 if ((cm = mps_alloc_command(sc)) == NULL) { 1023 printf("%s: command alloc failed @ line %d\n", __func__, 1024 __LINE__); 1025 error = EBUSY; 1026 goto out; 1027 } 1028 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 1029 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 1030 request->Function = MPI2_FUNCTION_CONFIG; 1031 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 1032 request->Header.PageType = MPI2_CONFIG_PAGETYPE_BIOS; 1033 request->Header.PageNumber = 3; 1034 request->Header.PageVersion = MPI2_BIOSPAGE3_PAGEVERSION; 1035 request->Header.PageLength = mpi_reply->Header.PageLength; 1036 cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4; 1037 cm->cm_sge = &request->PageBufferSGE; 1038 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 1039 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 1040 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1041 page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT); 1042 if (!page) { 1043 printf("%s: page alloc failed\n", __func__); 1044 error = ENOMEM; 1045 goto out; 1046 } 1047 cm->cm_data = page; 1048 1049 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 1050 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 1051 if (error || (reply == NULL)) { 1052 /* FIXME */ 1053 /* 1054 * If the request returns an error then we need to do a diag 1055 * reset 1056 */ 1057 printf("%s: request for page completed with error %d", 1058 __func__, error); 1059 error = ENXIO; 1060 goto out; 1061 } 1062 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1063 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1064 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1065 /* FIXME */ 1066 /* 1067 * If the request returns an error then we need to do a diag 1068 * reset 1069 */ 1070 printf("%s: page read with error; iocstatus = 0x%x\n", 1071 __func__, ioc_status); 1072 error = ENXIO; 1073 goto out; 1074 } 1075 bcopy(page, config_page, MIN(cm->cm_length, sizeof(Mpi2BiosPage3_t))); 1076 out: 1077 free(page, M_MPT2); 1078 if (cm) 1079 mps_free_command(sc, cm); 1080 return (error); 1081 } 1082 1083 /** 1084 * mps_config_get_raid_volume_pg0 - obtain raid volume page 0 1085 * @sc: per adapter object 1086 * @mpi_reply: reply mf payload returned from firmware 1087 * @config_page: contents of the config page 1088 * @page_address: form and handle value used to get page 1089 * Context: sleep. 1090 * 1091 * Returns 0 for success, non-zero for failure. 1092 */ 1093 int 1094 mps_config_get_raid_volume_pg0(struct mps_softc *sc, Mpi2ConfigReply_t 1095 *mpi_reply, Mpi2RaidVolPage0_t *config_page, u32 page_address) 1096 { 1097 MPI2_CONFIG_REQUEST *request; 1098 MPI2_CONFIG_REPLY *reply; 1099 struct mps_command *cm; 1100 Mpi2RaidVolPage0_t *page = NULL; 1101 int error = 0; 1102 u16 ioc_status; 1103 1104 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 1105 1106 if ((cm = mps_alloc_command(sc)) == NULL) { 1107 printf("%s: command alloc failed @ line %d\n", __func__, 1108 __LINE__); 1109 error = EBUSY; 1110 goto out; 1111 } 1112 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 1113 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 1114 request->Function = MPI2_FUNCTION_CONFIG; 1115 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 1116 request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME; 1117 request->Header.PageNumber = 0; 1118 request->Header.PageVersion = MPI2_RAIDVOLPAGE0_PAGEVERSION; 1119 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1120 cm->cm_data = NULL; 1121 1122 /* 1123 * This page must be polled because the IOC isn't ready yet when this 1124 * page is needed. 1125 */ 1126 error = mps_request_polled(sc, cm); 1127 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 1128 if (error || (reply == NULL)) { 1129 /* FIXME */ 1130 /* If the poll returns error then we need to do diag reset */ 1131 printf("%s: poll for header completed with error %d", 1132 __func__, error); 1133 error = ENXIO; 1134 goto out; 1135 } 1136 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1137 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1138 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1139 /* FIXME */ 1140 /* If the poll returns error then we need to do diag reset */ 1141 printf("%s: header read with error; iocstatus = 0x%x\n", 1142 __func__, ioc_status); 1143 error = ENXIO; 1144 goto out; 1145 } 1146 /* We have to do free and alloc for the reply-free and reply-post 1147 * counters to match - Need to review the reply FIFO handling. 1148 */ 1149 mps_free_command(sc, cm); 1150 1151 if ((cm = mps_alloc_command(sc)) == NULL) { 1152 printf("%s: command alloc failed @ line %d\n", __func__, 1153 __LINE__); 1154 error = EBUSY; 1155 goto out; 1156 } 1157 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 1158 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 1159 request->Function = MPI2_FUNCTION_CONFIG; 1160 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 1161 request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME; 1162 request->Header.PageNumber = 0; 1163 request->Header.PageLength = mpi_reply->Header.PageLength; 1164 request->Header.PageVersion = mpi_reply->Header.PageVersion; 1165 request->PageAddress = page_address; 1166 cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4; 1167 cm->cm_sge = &request->PageBufferSGE; 1168 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 1169 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 1170 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1171 page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT); 1172 if (!page) { 1173 printf("%s: page alloc failed\n", __func__); 1174 error = ENOMEM; 1175 goto out; 1176 } 1177 cm->cm_data = page; 1178 1179 /* 1180 * This page must be polled because the IOC isn't ready yet when this 1181 * page is needed. 1182 */ 1183 error = mps_request_polled(sc, cm); 1184 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 1185 if (error || (reply == NULL)) { 1186 /* FIXME */ 1187 /* If the poll returns error then we need to do diag reset */ 1188 printf("%s: poll for page completed with error %d", 1189 __func__, error); 1190 error = ENXIO; 1191 goto out; 1192 } 1193 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1194 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1195 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1196 /* FIXME */ 1197 /* If the poll returns error then we need to do diag reset */ 1198 printf("%s: page read with error; iocstatus = 0x%x\n", 1199 __func__, ioc_status); 1200 error = ENXIO; 1201 goto out; 1202 } 1203 bcopy(page, config_page, cm->cm_length); 1204 out: 1205 free(page, M_MPT2); 1206 if (cm) 1207 mps_free_command(sc, cm); 1208 return (error); 1209 } 1210 1211 /** 1212 * mps_config_get_raid_volume_pg1 - obtain raid volume page 1 1213 * @sc: per adapter object 1214 * @mpi_reply: reply mf payload returned from firmware 1215 * @config_page: contents of the config page 1216 * @form: GET_NEXT_HANDLE or HANDLE 1217 * @handle: volume handle 1218 * Context: sleep. 1219 * 1220 * Returns 0 for success, non-zero for failure. 1221 */ 1222 int 1223 mps_config_get_raid_volume_pg1(struct mps_softc *sc, Mpi2ConfigReply_t 1224 *mpi_reply, Mpi2RaidVolPage1_t *config_page, u32 form, u16 handle) 1225 { 1226 MPI2_CONFIG_REQUEST *request; 1227 MPI2_CONFIG_REPLY *reply; 1228 struct mps_command *cm; 1229 Mpi2RaidVolPage1_t *page = NULL; 1230 int error = 0; 1231 u16 ioc_status; 1232 1233 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 1234 1235 if ((cm = mps_alloc_command(sc)) == NULL) { 1236 printf("%s: command alloc failed @ line %d\n", __func__, 1237 __LINE__); 1238 error = EBUSY; 1239 goto out; 1240 } 1241 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 1242 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 1243 request->Function = MPI2_FUNCTION_CONFIG; 1244 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 1245 request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME; 1246 request->Header.PageNumber = 1; 1247 request->Header.PageVersion = MPI2_RAIDVOLPAGE1_PAGEVERSION; 1248 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1249 cm->cm_data = NULL; 1250 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 1251 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 1252 if (error || (reply == NULL)) { 1253 /* FIXME */ 1254 /* 1255 * If the request returns an error then we need to do a diag 1256 * reset 1257 */ 1258 printf("%s: request for header completed with error %d", 1259 __func__, error); 1260 error = ENXIO; 1261 goto out; 1262 } 1263 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1264 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1265 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1266 /* FIXME */ 1267 /* 1268 * If the request returns an error then we need to do a diag 1269 * reset 1270 */ 1271 printf("%s: header read with error; iocstatus = 0x%x\n", 1272 __func__, ioc_status); 1273 error = ENXIO; 1274 goto out; 1275 } 1276 /* We have to do free and alloc for the reply-free and reply-post 1277 * counters to match - Need to review the reply FIFO handling. 1278 */ 1279 mps_free_command(sc, cm); 1280 1281 if ((cm = mps_alloc_command(sc)) == NULL) { 1282 printf("%s: command alloc failed @ line %d\n", __func__, 1283 __LINE__); 1284 error = EBUSY; 1285 goto out; 1286 } 1287 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 1288 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 1289 request->Function = MPI2_FUNCTION_CONFIG; 1290 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 1291 request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_VOLUME; 1292 request->Header.PageNumber = 1; 1293 request->Header.PageLength = mpi_reply->Header.PageLength; 1294 request->Header.PageVersion = mpi_reply->Header.PageVersion; 1295 request->PageAddress = htole32(form | handle); 1296 cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4; 1297 cm->cm_sge = &request->PageBufferSGE; 1298 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 1299 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 1300 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1301 page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT); 1302 if (!page) { 1303 printf("%s: page alloc failed\n", __func__); 1304 error = ENOMEM; 1305 goto out; 1306 } 1307 cm->cm_data = page; 1308 1309 error = mps_wait_command(sc, cm, 60, CAN_SLEEP); 1310 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 1311 if (error || (reply == NULL)) { 1312 /* FIXME */ 1313 /* 1314 * If the request returns an error then we need to do a diag 1315 * reset 1316 */ 1317 printf("%s: request for page completed with error %d", 1318 __func__, error); 1319 error = ENXIO; 1320 goto out; 1321 } 1322 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1323 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1324 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1325 /* FIXME */ 1326 /* 1327 * If the request returns an error then we need to do a diag 1328 * reset 1329 */ 1330 printf("%s: page read with error; iocstatus = 0x%x\n", 1331 __func__, ioc_status); 1332 error = ENXIO; 1333 goto out; 1334 } 1335 bcopy(page, config_page, MIN(cm->cm_length, 1336 sizeof(Mpi2RaidVolPage1_t))); 1337 out: 1338 free(page, M_MPT2); 1339 if (cm) 1340 mps_free_command(sc, cm); 1341 return (error); 1342 } 1343 1344 /** 1345 * mps_config_get_volume_wwid - returns wwid given the volume handle 1346 * @sc: per adapter object 1347 * @volume_handle: volume handle 1348 * @wwid: volume wwid 1349 * Context: sleep. 1350 * 1351 * Returns 0 for success, non-zero for failure. 1352 */ 1353 int 1354 mps_config_get_volume_wwid(struct mps_softc *sc, u16 volume_handle, u64 *wwid) 1355 { 1356 Mpi2ConfigReply_t mpi_reply; 1357 Mpi2RaidVolPage1_t raid_vol_pg1; 1358 1359 *wwid = 0; 1360 if (!(mps_config_get_raid_volume_pg1(sc, &mpi_reply, &raid_vol_pg1, 1361 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, volume_handle))) { 1362 *wwid = le64toh((u64)raid_vol_pg1.WWID.High << 32 | 1363 raid_vol_pg1.WWID.Low); 1364 return 0; 1365 } else 1366 return -1; 1367 } 1368 1369 /** 1370 * mps_config_get_pd_pg0 - obtain raid phys disk page 0 1371 * @sc: per adapter object 1372 * @mpi_reply: reply mf payload returned from firmware 1373 * @config_page: contents of the config page 1374 * @page_address: form and handle value used to get page 1375 * Context: sleep. 1376 * 1377 * Returns 0 for success, non-zero for failure. 1378 */ 1379 int 1380 mps_config_get_raid_pd_pg0(struct mps_softc *sc, Mpi2ConfigReply_t *mpi_reply, 1381 Mpi2RaidPhysDiskPage0_t *config_page, u32 page_address) 1382 { 1383 MPI2_CONFIG_REQUEST *request; 1384 MPI2_CONFIG_REPLY *reply; 1385 struct mps_command *cm; 1386 Mpi2RaidPhysDiskPage0_t *page = NULL; 1387 int error = 0; 1388 u16 ioc_status; 1389 1390 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 1391 1392 if ((cm = mps_alloc_command(sc)) == NULL) { 1393 printf("%s: command alloc failed @ line %d\n", __func__, 1394 __LINE__); 1395 error = EBUSY; 1396 goto out; 1397 } 1398 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 1399 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 1400 request->Function = MPI2_FUNCTION_CONFIG; 1401 request->Action = MPI2_CONFIG_ACTION_PAGE_HEADER; 1402 request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK; 1403 request->Header.PageNumber = 0; 1404 request->Header.PageVersion = MPI2_RAIDPHYSDISKPAGE0_PAGEVERSION; 1405 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1406 cm->cm_data = NULL; 1407 1408 /* 1409 * This page must be polled because the IOC isn't ready yet when this 1410 * page is needed. 1411 */ 1412 error = mps_request_polled(sc, cm); 1413 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 1414 if (error || (reply == NULL)) { 1415 /* FIXME */ 1416 /* If the poll returns error then we need to do diag reset */ 1417 printf("%s: poll for header completed with error %d", 1418 __func__, error); 1419 error = ENXIO; 1420 goto out; 1421 } 1422 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1423 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1424 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1425 /* FIXME */ 1426 /* If the poll returns error then we need to do diag reset */ 1427 printf("%s: header read with error; iocstatus = 0x%x\n", 1428 __func__, ioc_status); 1429 error = ENXIO; 1430 goto out; 1431 } 1432 /* We have to do free and alloc for the reply-free and reply-post 1433 * counters to match - Need to review the reply FIFO handling. 1434 */ 1435 mps_free_command(sc, cm); 1436 1437 if ((cm = mps_alloc_command(sc)) == NULL) { 1438 printf("%s: command alloc failed @ line %d\n", __func__, 1439 __LINE__); 1440 error = EBUSY; 1441 goto out; 1442 } 1443 request = (MPI2_CONFIG_REQUEST *)cm->cm_req; 1444 bzero(request, sizeof(MPI2_CONFIG_REQUEST)); 1445 request->Function = MPI2_FUNCTION_CONFIG; 1446 request->Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 1447 request->Header.PageType = MPI2_CONFIG_PAGETYPE_RAID_PHYSDISK; 1448 request->Header.PageNumber = 0; 1449 request->Header.PageLength = mpi_reply->Header.PageLength; 1450 request->Header.PageVersion = mpi_reply->Header.PageVersion; 1451 request->PageAddress = page_address; 1452 cm->cm_length = le16toh(mpi_reply->Header.PageLength) * 4; 1453 cm->cm_sge = &request->PageBufferSGE; 1454 cm->cm_sglsize = sizeof(MPI2_SGE_IO_UNION); 1455 cm->cm_flags = MPS_CM_FLAGS_SGE_SIMPLE | MPS_CM_FLAGS_DATAIN; 1456 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1457 page = malloc(cm->cm_length, M_MPT2, M_ZERO | M_NOWAIT); 1458 if (!page) { 1459 printf("%s: page alloc failed\n", __func__); 1460 error = ENOMEM; 1461 goto out; 1462 } 1463 cm->cm_data = page; 1464 1465 /* 1466 * This page must be polled because the IOC isn't ready yet when this 1467 * page is needed. 1468 */ 1469 error = mps_request_polled(sc, cm); 1470 reply = (MPI2_CONFIG_REPLY *)cm->cm_reply; 1471 if (error || (reply == NULL)) { 1472 /* FIXME */ 1473 /* If the poll returns error then we need to do diag reset */ 1474 printf("%s: poll for page completed with error %d", 1475 __func__, error); 1476 error = ENXIO; 1477 goto out; 1478 } 1479 ioc_status = le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK; 1480 bcopy(reply, mpi_reply, sizeof(MPI2_CONFIG_REPLY)); 1481 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1482 /* FIXME */ 1483 /* If the poll returns error then we need to do diag reset */ 1484 printf("%s: page read with error; iocstatus = 0x%x\n", 1485 __func__, ioc_status); 1486 error = ENXIO; 1487 goto out; 1488 } 1489 bcopy(page, config_page, MIN(cm->cm_length, 1490 sizeof(Mpi2RaidPhysDiskPage0_t))); 1491 out: 1492 free(page, M_MPT2); 1493 if (cm) 1494 mps_free_command(sc, cm); 1495 return (error); 1496 } 1497