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