1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2008 Yahoo!, Inc. 5 * All rights reserved. 6 * Written by: John Baldwin <jhb@FreeBSD.org> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the author nor the names of any co-contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * LSI MPT-Fusion Host Adapter FreeBSD userland interface 33 */ 34 35 #include <sys/cdefs.h> 36 __FBSDID("$FreeBSD$"); 37 38 #include <sys/param.h> 39 #include <sys/conf.h> 40 #include <sys/errno.h> 41 #include <sys/ioccom.h> 42 #include <sys/mpt_ioctl.h> 43 44 #include <dev/mpt/mpt.h> 45 46 struct mpt_user_raid_action_result { 47 uint32_t volume_status; 48 uint32_t action_data[4]; 49 uint16_t action_status; 50 }; 51 52 struct mpt_page_memory { 53 bus_dma_tag_t tag; 54 bus_dmamap_t map; 55 bus_addr_t paddr; 56 void *vaddr; 57 }; 58 59 static mpt_probe_handler_t mpt_user_probe; 60 static mpt_attach_handler_t mpt_user_attach; 61 static mpt_enable_handler_t mpt_user_enable; 62 static mpt_ready_handler_t mpt_user_ready; 63 static mpt_event_handler_t mpt_user_event; 64 static mpt_reset_handler_t mpt_user_reset; 65 static mpt_detach_handler_t mpt_user_detach; 66 67 static struct mpt_personality mpt_user_personality = { 68 .name = "mpt_user", 69 .probe = mpt_user_probe, 70 .attach = mpt_user_attach, 71 .enable = mpt_user_enable, 72 .ready = mpt_user_ready, 73 .event = mpt_user_event, 74 .reset = mpt_user_reset, 75 .detach = mpt_user_detach, 76 }; 77 78 DECLARE_MPT_PERSONALITY(mpt_user, SI_ORDER_SECOND); 79 80 static mpt_reply_handler_t mpt_user_reply_handler; 81 82 static d_open_t mpt_open; 83 static d_close_t mpt_close; 84 static d_ioctl_t mpt_ioctl; 85 86 static struct cdevsw mpt_cdevsw = { 87 .d_version = D_VERSION, 88 .d_flags = 0, 89 .d_open = mpt_open, 90 .d_close = mpt_close, 91 .d_ioctl = mpt_ioctl, 92 .d_name = "mpt", 93 }; 94 95 static MALLOC_DEFINE(M_MPTUSER, "mpt_user", "Buffers for mpt(4) ioctls"); 96 97 static uint32_t user_handler_id = MPT_HANDLER_ID_NONE; 98 99 static int 100 mpt_user_probe(struct mpt_softc *mpt) 101 { 102 103 /* Attach to every controller. */ 104 return (0); 105 } 106 107 static int 108 mpt_user_attach(struct mpt_softc *mpt) 109 { 110 mpt_handler_t handler; 111 int error, unit; 112 113 MPT_LOCK(mpt); 114 handler.reply_handler = mpt_user_reply_handler; 115 error = mpt_register_handler(mpt, MPT_HANDLER_REPLY, handler, 116 &user_handler_id); 117 MPT_UNLOCK(mpt); 118 if (error != 0) { 119 mpt_prt(mpt, "Unable to register user handler!\n"); 120 return (error); 121 } 122 unit = device_get_unit(mpt->dev); 123 mpt->cdev = make_dev(&mpt_cdevsw, unit, UID_ROOT, GID_OPERATOR, 0640, 124 "mpt%d", unit); 125 if (mpt->cdev == NULL) { 126 MPT_LOCK(mpt); 127 mpt_deregister_handler(mpt, MPT_HANDLER_REPLY, handler, 128 user_handler_id); 129 MPT_UNLOCK(mpt); 130 return (ENOMEM); 131 } 132 mpt->cdev->si_drv1 = mpt; 133 return (0); 134 } 135 136 static int 137 mpt_user_enable(struct mpt_softc *mpt) 138 { 139 140 return (0); 141 } 142 143 static void 144 mpt_user_ready(struct mpt_softc *mpt) 145 { 146 147 } 148 149 static int 150 mpt_user_event(struct mpt_softc *mpt, request_t *req, 151 MSG_EVENT_NOTIFY_REPLY *msg) 152 { 153 154 /* Someday we may want to let a user daemon listen for events? */ 155 return (0); 156 } 157 158 static void 159 mpt_user_reset(struct mpt_softc *mpt, int type) 160 { 161 162 } 163 164 static void 165 mpt_user_detach(struct mpt_softc *mpt) 166 { 167 mpt_handler_t handler; 168 169 /* XXX: do a purge of pending requests? */ 170 destroy_dev(mpt->cdev); 171 172 MPT_LOCK(mpt); 173 handler.reply_handler = mpt_user_reply_handler; 174 mpt_deregister_handler(mpt, MPT_HANDLER_REPLY, handler, 175 user_handler_id); 176 MPT_UNLOCK(mpt); 177 } 178 179 static int 180 mpt_open(struct cdev *dev, int flags, int fmt, struct thread *td) 181 { 182 183 return (0); 184 } 185 186 static int 187 mpt_close(struct cdev *dev, int flags, int fmt, struct thread *td) 188 { 189 190 return (0); 191 } 192 193 static int 194 mpt_alloc_buffer(struct mpt_softc *mpt, struct mpt_page_memory *page_mem, 195 size_t len) 196 { 197 struct mpt_map_info mi; 198 int error; 199 200 page_mem->vaddr = NULL; 201 202 /* Limit requests to 16M. */ 203 if (len > 16 * 1024 * 1024) 204 return (ENOSPC); 205 error = mpt_dma_tag_create(mpt, mpt->parent_dmat, 1, 0, 206 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 207 len, 1, len, 0, &page_mem->tag); 208 if (error) 209 return (error); 210 error = bus_dmamem_alloc(page_mem->tag, &page_mem->vaddr, 211 BUS_DMA_NOWAIT | BUS_DMA_COHERENT, &page_mem->map); 212 if (error) { 213 bus_dma_tag_destroy(page_mem->tag); 214 return (error); 215 } 216 mi.mpt = mpt; 217 error = bus_dmamap_load(page_mem->tag, page_mem->map, page_mem->vaddr, 218 len, mpt_map_rquest, &mi, BUS_DMA_NOWAIT); 219 if (error == 0) 220 error = mi.error; 221 if (error) { 222 bus_dmamem_free(page_mem->tag, page_mem->vaddr, page_mem->map); 223 bus_dma_tag_destroy(page_mem->tag); 224 page_mem->vaddr = NULL; 225 return (error); 226 } 227 page_mem->paddr = mi.phys; 228 return (0); 229 } 230 231 static void 232 mpt_free_buffer(struct mpt_page_memory *page_mem) 233 { 234 235 if (page_mem->vaddr == NULL) 236 return; 237 bus_dmamap_unload(page_mem->tag, page_mem->map); 238 bus_dmamem_free(page_mem->tag, page_mem->vaddr, page_mem->map); 239 bus_dma_tag_destroy(page_mem->tag); 240 page_mem->vaddr = NULL; 241 } 242 243 static int 244 mpt_user_read_cfg_header(struct mpt_softc *mpt, 245 struct mpt_cfg_page_req *page_req) 246 { 247 request_t *req; 248 cfgparms_t params; 249 MSG_CONFIG *cfgp; 250 int error; 251 252 req = mpt_get_request(mpt, TRUE); 253 if (req == NULL) { 254 mpt_prt(mpt, "mpt_user_read_cfg_header: Get request failed!\n"); 255 return (ENOMEM); 256 } 257 258 params.Action = MPI_CONFIG_ACTION_PAGE_HEADER; 259 params.PageVersion = 0; 260 params.PageLength = 0; 261 params.PageNumber = page_req->header.PageNumber; 262 params.PageType = page_req->header.PageType; 263 params.PageAddress = le32toh(page_req->page_address); 264 error = mpt_issue_cfg_req(mpt, req, ¶ms, /*addr*/0, /*len*/0, 265 TRUE, 5000); 266 if (error != 0) { 267 /* 268 * Leave the request. Without resetting the chip, it's 269 * still owned by it and we'll just get into trouble 270 * freeing it now. Mark it as abandoned so that if it 271 * shows up later it can be freed. 272 */ 273 mpt_prt(mpt, "read_cfg_header timed out\n"); 274 return (ETIMEDOUT); 275 } 276 277 page_req->ioc_status = htole16(req->IOCStatus); 278 if ((req->IOCStatus & MPI_IOCSTATUS_MASK) == MPI_IOCSTATUS_SUCCESS) { 279 cfgp = req->req_vbuf; 280 bcopy(&cfgp->Header, &page_req->header, 281 sizeof(page_req->header)); 282 } 283 mpt_free_request(mpt, req); 284 return (0); 285 } 286 287 static int 288 mpt_user_read_cfg_page(struct mpt_softc *mpt, struct mpt_cfg_page_req *page_req, 289 struct mpt_page_memory *mpt_page) 290 { 291 CONFIG_PAGE_HEADER *hdr; 292 request_t *req; 293 cfgparms_t params; 294 int error; 295 296 req = mpt_get_request(mpt, TRUE); 297 if (req == NULL) { 298 mpt_prt(mpt, "mpt_user_read_cfg_page: Get request failed!\n"); 299 return (ENOMEM); 300 } 301 302 hdr = mpt_page->vaddr; 303 params.Action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 304 params.PageVersion = hdr->PageVersion; 305 params.PageLength = hdr->PageLength; 306 params.PageNumber = hdr->PageNumber; 307 params.PageType = hdr->PageType & MPI_CONFIG_PAGETYPE_MASK; 308 params.PageAddress = le32toh(page_req->page_address); 309 bus_dmamap_sync(mpt_page->tag, mpt_page->map, 310 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 311 error = mpt_issue_cfg_req(mpt, req, ¶ms, mpt_page->paddr, 312 le32toh(page_req->len), TRUE, 5000); 313 if (error != 0) { 314 mpt_prt(mpt, "mpt_user_read_cfg_page timed out\n"); 315 return (ETIMEDOUT); 316 } 317 318 page_req->ioc_status = htole16(req->IOCStatus); 319 if ((req->IOCStatus & MPI_IOCSTATUS_MASK) == MPI_IOCSTATUS_SUCCESS) 320 bus_dmamap_sync(mpt_page->tag, mpt_page->map, 321 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 322 mpt_free_request(mpt, req); 323 return (0); 324 } 325 326 static int 327 mpt_user_read_extcfg_header(struct mpt_softc *mpt, 328 struct mpt_ext_cfg_page_req *ext_page_req) 329 { 330 request_t *req; 331 cfgparms_t params; 332 MSG_CONFIG_REPLY *cfgp; 333 int error; 334 335 req = mpt_get_request(mpt, TRUE); 336 if (req == NULL) { 337 mpt_prt(mpt, "mpt_user_read_extcfg_header: Get request failed!\n"); 338 return (ENOMEM); 339 } 340 341 params.Action = MPI_CONFIG_ACTION_PAGE_HEADER; 342 params.PageVersion = ext_page_req->header.PageVersion; 343 params.PageLength = 0; 344 params.PageNumber = ext_page_req->header.PageNumber; 345 params.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 346 params.PageAddress = le32toh(ext_page_req->page_address); 347 params.ExtPageType = ext_page_req->header.ExtPageType; 348 params.ExtPageLength = 0; 349 error = mpt_issue_cfg_req(mpt, req, ¶ms, /*addr*/0, /*len*/0, 350 TRUE, 5000); 351 if (error != 0) { 352 /* 353 * Leave the request. Without resetting the chip, it's 354 * still owned by it and we'll just get into trouble 355 * freeing it now. Mark it as abandoned so that if it 356 * shows up later it can be freed. 357 */ 358 mpt_prt(mpt, "mpt_user_read_extcfg_header timed out\n"); 359 return (ETIMEDOUT); 360 } 361 362 ext_page_req->ioc_status = htole16(req->IOCStatus); 363 if ((req->IOCStatus & MPI_IOCSTATUS_MASK) == MPI_IOCSTATUS_SUCCESS) { 364 cfgp = req->req_vbuf; 365 ext_page_req->header.PageVersion = cfgp->Header.PageVersion; 366 ext_page_req->header.PageNumber = cfgp->Header.PageNumber; 367 ext_page_req->header.PageType = cfgp->Header.PageType; 368 ext_page_req->header.ExtPageLength = cfgp->ExtPageLength; 369 ext_page_req->header.ExtPageType = cfgp->ExtPageType; 370 } 371 mpt_free_request(mpt, req); 372 return (0); 373 } 374 375 static int 376 mpt_user_read_extcfg_page(struct mpt_softc *mpt, 377 struct mpt_ext_cfg_page_req *ext_page_req, struct mpt_page_memory *mpt_page) 378 { 379 CONFIG_EXTENDED_PAGE_HEADER *hdr; 380 request_t *req; 381 cfgparms_t params; 382 int error; 383 384 req = mpt_get_request(mpt, TRUE); 385 if (req == NULL) { 386 mpt_prt(mpt, "mpt_user_read_extcfg_page: Get request failed!\n"); 387 return (ENOMEM); 388 } 389 390 hdr = mpt_page->vaddr; 391 params.Action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 392 params.PageVersion = hdr->PageVersion; 393 params.PageLength = 0; 394 params.PageNumber = hdr->PageNumber; 395 params.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 396 params.PageAddress = le32toh(ext_page_req->page_address); 397 params.ExtPageType = hdr->ExtPageType; 398 params.ExtPageLength = hdr->ExtPageLength; 399 bus_dmamap_sync(mpt_page->tag, mpt_page->map, 400 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 401 error = mpt_issue_cfg_req(mpt, req, ¶ms, mpt_page->paddr, 402 le32toh(ext_page_req->len), TRUE, 5000); 403 if (error != 0) { 404 mpt_prt(mpt, "mpt_user_read_extcfg_page timed out\n"); 405 return (ETIMEDOUT); 406 } 407 408 ext_page_req->ioc_status = htole16(req->IOCStatus); 409 if ((req->IOCStatus & MPI_IOCSTATUS_MASK) == MPI_IOCSTATUS_SUCCESS) 410 bus_dmamap_sync(mpt_page->tag, mpt_page->map, 411 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 412 mpt_free_request(mpt, req); 413 return (0); 414 } 415 416 static int 417 mpt_user_write_cfg_page(struct mpt_softc *mpt, 418 struct mpt_cfg_page_req *page_req, struct mpt_page_memory *mpt_page) 419 { 420 CONFIG_PAGE_HEADER *hdr; 421 request_t *req; 422 cfgparms_t params; 423 u_int hdr_attr; 424 int error; 425 426 hdr = mpt_page->vaddr; 427 hdr_attr = hdr->PageType & MPI_CONFIG_PAGEATTR_MASK; 428 if (hdr_attr != MPI_CONFIG_PAGEATTR_CHANGEABLE && 429 hdr_attr != MPI_CONFIG_PAGEATTR_PERSISTENT) { 430 mpt_prt(mpt, "page type 0x%x not changeable\n", 431 hdr->PageType & MPI_CONFIG_PAGETYPE_MASK); 432 return (EINVAL); 433 } 434 435 #if 0 436 /* 437 * We shouldn't mask off other bits here. 438 */ 439 hdr->PageType &= ~MPI_CONFIG_PAGETYPE_MASK; 440 #endif 441 442 req = mpt_get_request(mpt, TRUE); 443 if (req == NULL) 444 return (ENOMEM); 445 446 bus_dmamap_sync(mpt_page->tag, mpt_page->map, BUS_DMASYNC_PREREAD | 447 BUS_DMASYNC_PREWRITE); 448 449 /* 450 * There isn't any point in restoring stripped out attributes 451 * if you then mask them going down to issue the request. 452 */ 453 454 params.Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT; 455 params.PageVersion = hdr->PageVersion; 456 params.PageLength = hdr->PageLength; 457 params.PageNumber = hdr->PageNumber; 458 params.PageAddress = le32toh(page_req->page_address); 459 #if 0 460 /* Restore stripped out attributes */ 461 hdr->PageType |= hdr_attr; 462 params.PageType = hdr->PageType & MPI_CONFIG_PAGETYPE_MASK; 463 #else 464 params.PageType = hdr->PageType; 465 #endif 466 error = mpt_issue_cfg_req(mpt, req, ¶ms, mpt_page->paddr, 467 le32toh(page_req->len), TRUE, 5000); 468 if (error != 0) { 469 mpt_prt(mpt, "mpt_write_cfg_page timed out\n"); 470 return (ETIMEDOUT); 471 } 472 473 page_req->ioc_status = htole16(req->IOCStatus); 474 bus_dmamap_sync(mpt_page->tag, mpt_page->map, BUS_DMASYNC_POSTREAD | 475 BUS_DMASYNC_POSTWRITE); 476 mpt_free_request(mpt, req); 477 return (0); 478 } 479 480 static int 481 mpt_user_reply_handler(struct mpt_softc *mpt, request_t *req, 482 uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 483 { 484 MSG_RAID_ACTION_REPLY *reply; 485 struct mpt_user_raid_action_result *res; 486 487 if (req == NULL) 488 return (TRUE); 489 490 if (reply_frame != NULL) { 491 reply = (MSG_RAID_ACTION_REPLY *)reply_frame; 492 req->IOCStatus = le16toh(reply->IOCStatus); 493 res = (struct mpt_user_raid_action_result *) 494 (((uint8_t *)req->req_vbuf) + MPT_RQSL(mpt)); 495 res->action_status = reply->ActionStatus; 496 res->volume_status = reply->VolumeStatus; 497 bcopy(&reply->ActionData, res->action_data, 498 sizeof(res->action_data)); 499 } 500 501 req->state &= ~REQ_STATE_QUEUED; 502 req->state |= REQ_STATE_DONE; 503 TAILQ_REMOVE(&mpt->request_pending_list, req, links); 504 505 if ((req->state & REQ_STATE_NEED_WAKEUP) != 0) { 506 wakeup(req); 507 } else if ((req->state & REQ_STATE_TIMEDOUT) != 0) { 508 /* 509 * Whew- we can free this request (late completion) 510 */ 511 mpt_free_request(mpt, req); 512 } 513 514 return (TRUE); 515 } 516 517 /* 518 * We use the first part of the request buffer after the request frame 519 * to hold the action data and action status from the RAID reply. The 520 * rest of the request buffer is used to hold the buffer for the 521 * action SGE. 522 */ 523 static int 524 mpt_user_raid_action(struct mpt_softc *mpt, struct mpt_raid_action *raid_act, 525 struct mpt_page_memory *mpt_page) 526 { 527 request_t *req; 528 struct mpt_user_raid_action_result *res; 529 MSG_RAID_ACTION_REQUEST *rap; 530 SGE_SIMPLE32 *se; 531 int error; 532 533 req = mpt_get_request(mpt, TRUE); 534 if (req == NULL) 535 return (ENOMEM); 536 rap = req->req_vbuf; 537 memset(rap, 0, sizeof *rap); 538 rap->Action = raid_act->action; 539 rap->ActionDataWord = raid_act->action_data_word; 540 rap->Function = MPI_FUNCTION_RAID_ACTION; 541 rap->VolumeID = raid_act->volume_id; 542 rap->VolumeBus = raid_act->volume_bus; 543 rap->PhysDiskNum = raid_act->phys_disk_num; 544 se = (SGE_SIMPLE32 *)&rap->ActionDataSGE; 545 if (mpt_page->vaddr != NULL && raid_act->len != 0) { 546 bus_dmamap_sync(mpt_page->tag, mpt_page->map, 547 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 548 se->Address = htole32(mpt_page->paddr); 549 MPI_pSGE_SET_LENGTH(se, le32toh(raid_act->len)); 550 MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT | 551 MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER | 552 MPI_SGE_FLAGS_END_OF_LIST | 553 (raid_act->write ? MPI_SGE_FLAGS_HOST_TO_IOC : 554 MPI_SGE_FLAGS_IOC_TO_HOST))); 555 } 556 se->FlagsLength = htole32(se->FlagsLength); 557 rap->MsgContext = htole32(req->index | user_handler_id); 558 559 mpt_check_doorbell(mpt); 560 mpt_send_cmd(mpt, req); 561 562 error = mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE, TRUE, 563 2000); 564 if (error != 0) { 565 /* 566 * Leave request so it can be cleaned up later. 567 */ 568 mpt_prt(mpt, "mpt_user_raid_action timed out\n"); 569 return (error); 570 } 571 572 raid_act->ioc_status = htole16(req->IOCStatus); 573 if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) { 574 mpt_free_request(mpt, req); 575 return (0); 576 } 577 578 res = (struct mpt_user_raid_action_result *) 579 (((uint8_t *)req->req_vbuf) + MPT_RQSL(mpt)); 580 raid_act->volume_status = res->volume_status; 581 raid_act->action_status = res->action_status; 582 bcopy(res->action_data, raid_act->action_data, 583 sizeof(res->action_data)); 584 if (mpt_page->vaddr != NULL) 585 bus_dmamap_sync(mpt_page->tag, mpt_page->map, 586 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 587 mpt_free_request(mpt, req); 588 return (0); 589 } 590 591 #ifdef __amd64__ 592 #define PTRIN(p) ((void *)(uintptr_t)(p)) 593 #define PTROUT(v) ((u_int32_t)(uintptr_t)(v)) 594 #endif 595 596 static int 597 mpt_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int flag, struct thread *td) 598 { 599 struct mpt_softc *mpt; 600 struct mpt_cfg_page_req *page_req; 601 struct mpt_ext_cfg_page_req *ext_page_req; 602 struct mpt_raid_action *raid_act; 603 struct mpt_page_memory mpt_page; 604 #ifdef __amd64__ 605 struct mpt_cfg_page_req32 *page_req32; 606 struct mpt_cfg_page_req page_req_swab; 607 struct mpt_ext_cfg_page_req32 *ext_page_req32; 608 struct mpt_ext_cfg_page_req ext_page_req_swab; 609 struct mpt_raid_action32 *raid_act32; 610 struct mpt_raid_action raid_act_swab; 611 #endif 612 int error; 613 614 mpt = dev->si_drv1; 615 page_req = (void *)arg; 616 ext_page_req = (void *)arg; 617 raid_act = (void *)arg; 618 mpt_page.vaddr = NULL; 619 620 #ifdef __amd64__ 621 /* Convert 32-bit structs to native ones. */ 622 page_req32 = (void *)arg; 623 ext_page_req32 = (void *)arg; 624 raid_act32 = (void *)arg; 625 switch (cmd) { 626 case MPTIO_READ_CFG_HEADER32: 627 case MPTIO_READ_CFG_PAGE32: 628 case MPTIO_WRITE_CFG_PAGE32: 629 page_req = &page_req_swab; 630 page_req->header = page_req32->header; 631 page_req->page_address = page_req32->page_address; 632 page_req->buf = PTRIN(page_req32->buf); 633 page_req->len = page_req32->len; 634 page_req->ioc_status = page_req32->ioc_status; 635 break; 636 case MPTIO_READ_EXT_CFG_HEADER32: 637 case MPTIO_READ_EXT_CFG_PAGE32: 638 ext_page_req = &ext_page_req_swab; 639 ext_page_req->header = ext_page_req32->header; 640 ext_page_req->page_address = ext_page_req32->page_address; 641 ext_page_req->buf = PTRIN(ext_page_req32->buf); 642 ext_page_req->len = ext_page_req32->len; 643 ext_page_req->ioc_status = ext_page_req32->ioc_status; 644 break; 645 case MPTIO_RAID_ACTION32: 646 raid_act = &raid_act_swab; 647 raid_act->action = raid_act32->action; 648 raid_act->volume_bus = raid_act32->volume_bus; 649 raid_act->volume_id = raid_act32->volume_id; 650 raid_act->phys_disk_num = raid_act32->phys_disk_num; 651 raid_act->action_data_word = raid_act32->action_data_word; 652 raid_act->buf = PTRIN(raid_act32->buf); 653 raid_act->len = raid_act32->len; 654 raid_act->volume_status = raid_act32->volume_status; 655 bcopy(raid_act32->action_data, raid_act->action_data, 656 sizeof(raid_act->action_data)); 657 raid_act->action_status = raid_act32->action_status; 658 raid_act->ioc_status = raid_act32->ioc_status; 659 raid_act->write = raid_act32->write; 660 break; 661 } 662 #endif 663 664 switch (cmd) { 665 #ifdef __amd64__ 666 case MPTIO_READ_CFG_HEADER32: 667 #endif 668 case MPTIO_READ_CFG_HEADER: 669 MPT_LOCK(mpt); 670 error = mpt_user_read_cfg_header(mpt, page_req); 671 MPT_UNLOCK(mpt); 672 break; 673 #ifdef __amd64__ 674 case MPTIO_READ_CFG_PAGE32: 675 #endif 676 case MPTIO_READ_CFG_PAGE: 677 error = mpt_alloc_buffer(mpt, &mpt_page, page_req->len); 678 if (error) 679 break; 680 error = copyin(page_req->buf, mpt_page.vaddr, 681 sizeof(CONFIG_PAGE_HEADER)); 682 if (error) 683 break; 684 MPT_LOCK(mpt); 685 error = mpt_user_read_cfg_page(mpt, page_req, &mpt_page); 686 MPT_UNLOCK(mpt); 687 if (error) 688 break; 689 error = copyout(mpt_page.vaddr, page_req->buf, page_req->len); 690 break; 691 #ifdef __amd64__ 692 case MPTIO_READ_EXT_CFG_HEADER32: 693 #endif 694 case MPTIO_READ_EXT_CFG_HEADER: 695 MPT_LOCK(mpt); 696 error = mpt_user_read_extcfg_header(mpt, ext_page_req); 697 MPT_UNLOCK(mpt); 698 break; 699 #ifdef __amd64__ 700 case MPTIO_READ_EXT_CFG_PAGE32: 701 #endif 702 case MPTIO_READ_EXT_CFG_PAGE: 703 error = mpt_alloc_buffer(mpt, &mpt_page, ext_page_req->len); 704 if (error) 705 break; 706 error = copyin(ext_page_req->buf, mpt_page.vaddr, 707 sizeof(CONFIG_EXTENDED_PAGE_HEADER)); 708 if (error) 709 break; 710 MPT_LOCK(mpt); 711 error = mpt_user_read_extcfg_page(mpt, ext_page_req, &mpt_page); 712 MPT_UNLOCK(mpt); 713 if (error) 714 break; 715 error = copyout(mpt_page.vaddr, ext_page_req->buf, 716 ext_page_req->len); 717 break; 718 #ifdef __amd64__ 719 case MPTIO_WRITE_CFG_PAGE32: 720 #endif 721 case MPTIO_WRITE_CFG_PAGE: 722 error = mpt_alloc_buffer(mpt, &mpt_page, page_req->len); 723 if (error) 724 break; 725 error = copyin(page_req->buf, mpt_page.vaddr, page_req->len); 726 if (error) 727 break; 728 MPT_LOCK(mpt); 729 error = mpt_user_write_cfg_page(mpt, page_req, &mpt_page); 730 MPT_UNLOCK(mpt); 731 break; 732 #ifdef __amd64__ 733 case MPTIO_RAID_ACTION32: 734 #endif 735 case MPTIO_RAID_ACTION: 736 if (raid_act->buf != NULL) { 737 error = mpt_alloc_buffer(mpt, &mpt_page, raid_act->len); 738 if (error) 739 break; 740 error = copyin(raid_act->buf, mpt_page.vaddr, 741 raid_act->len); 742 if (error) 743 break; 744 } 745 MPT_LOCK(mpt); 746 error = mpt_user_raid_action(mpt, raid_act, &mpt_page); 747 MPT_UNLOCK(mpt); 748 if (error) 749 break; 750 if (raid_act->buf != NULL) 751 error = copyout(mpt_page.vaddr, raid_act->buf, 752 raid_act->len); 753 break; 754 default: 755 error = ENOIOCTL; 756 break; 757 } 758 759 mpt_free_buffer(&mpt_page); 760 761 if (error) 762 return (error); 763 764 #ifdef __amd64__ 765 /* Convert native structs to 32-bit ones. */ 766 switch (cmd) { 767 case MPTIO_READ_CFG_HEADER32: 768 case MPTIO_READ_CFG_PAGE32: 769 case MPTIO_WRITE_CFG_PAGE32: 770 page_req32->header = page_req->header; 771 page_req32->page_address = page_req->page_address; 772 page_req32->buf = PTROUT(page_req->buf); 773 page_req32->len = page_req->len; 774 page_req32->ioc_status = page_req->ioc_status; 775 break; 776 case MPTIO_READ_EXT_CFG_HEADER32: 777 case MPTIO_READ_EXT_CFG_PAGE32: 778 ext_page_req32->header = ext_page_req->header; 779 ext_page_req32->page_address = ext_page_req->page_address; 780 ext_page_req32->buf = PTROUT(ext_page_req->buf); 781 ext_page_req32->len = ext_page_req->len; 782 ext_page_req32->ioc_status = ext_page_req->ioc_status; 783 break; 784 case MPTIO_RAID_ACTION32: 785 raid_act32->action = raid_act->action; 786 raid_act32->volume_bus = raid_act->volume_bus; 787 raid_act32->volume_id = raid_act->volume_id; 788 raid_act32->phys_disk_num = raid_act->phys_disk_num; 789 raid_act32->action_data_word = raid_act->action_data_word; 790 raid_act32->buf = PTROUT(raid_act->buf); 791 raid_act32->len = raid_act->len; 792 raid_act32->volume_status = raid_act->volume_status; 793 bcopy(raid_act->action_data, raid_act32->action_data, 794 sizeof(raid_act->action_data)); 795 raid_act32->action_status = raid_act->action_status; 796 raid_act32->ioc_status = raid_act->ioc_status; 797 raid_act32->write = raid_act->write; 798 break; 799 } 800 #endif 801 802 return (0); 803 } 804