hptiop.c revision 196970
1/* 2 * HighPoint RR3xxx/4xxx RAID Driver for FreeBSD 3 * Copyright (C) 2007-2008 HighPoint Technologies, Inc. All Rights Reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28__FBSDID("$FreeBSD: head/sys/dev/hptiop/hptiop.c 196970 2009-09-08 13:19:05Z phk $"); 29 30#include <sys/param.h> 31#include <sys/types.h> 32#include <sys/cons.h> 33#if (__FreeBSD_version >= 500000) 34#include <sys/time.h> 35#include <sys/systm.h> 36#else 37#include <machine/clock.h> 38#endif 39 40#include <sys/stat.h> 41#include <sys/malloc.h> 42#include <sys/conf.h> 43#include <sys/libkern.h> 44#include <sys/kernel.h> 45 46#if (__FreeBSD_version >= 500000) 47#include <sys/kthread.h> 48#include <sys/mutex.h> 49#include <sys/module.h> 50#endif 51 52#include <sys/eventhandler.h> 53#include <sys/bus.h> 54#include <sys/taskqueue.h> 55#include <sys/ioccom.h> 56 57#include <machine/resource.h> 58#include <machine/bus.h> 59#include <machine/stdarg.h> 60#include <sys/rman.h> 61 62#include <vm/vm.h> 63#include <vm/pmap.h> 64 65#if (__FreeBSD_version >= 500000) 66#include <dev/pci/pcireg.h> 67#include <dev/pci/pcivar.h> 68#else 69#include <pci/pcivar.h> 70#include <pci/pcireg.h> 71#endif 72 73#if (__FreeBSD_version <= 500043) 74#include <sys/devicestat.h> 75#endif 76 77#include <cam/cam.h> 78#include <cam/cam_ccb.h> 79#include <cam/cam_sim.h> 80#include <cam/cam_xpt_sim.h> 81#include <cam/cam_debug.h> 82#include <cam/cam_xpt_periph.h> 83#include <cam/cam_periph.h> 84#include <cam/scsi/scsi_all.h> 85#include <cam/scsi/scsi_message.h> 86 87#if (__FreeBSD_version < 500043) 88#include <sys/bus_private.h> 89#endif 90 91#include <dev/hptiop/hptiop.h> 92 93static char driver_name[] = "hptiop"; 94static char driver_version[] = "v1.3 (010208)"; 95 96static devclass_t hptiop_devclass; 97 98static int hptiop_send_sync_msg(struct hpt_iop_hba *hba, 99 u_int32_t msg, u_int32_t millisec); 100static void hptiop_request_callback_itl(struct hpt_iop_hba *hba, 101 u_int32_t req); 102static void hptiop_request_callback_mv(struct hpt_iop_hba *hba, u_int64_t req); 103static void hptiop_os_message_callback(struct hpt_iop_hba *hba, u_int32_t msg); 104static int hptiop_do_ioctl_itl(struct hpt_iop_hba *hba, 105 struct hpt_iop_ioctl_param *pParams); 106static int hptiop_do_ioctl_mv(struct hpt_iop_hba *hba, 107 struct hpt_iop_ioctl_param *pParams); 108static void hptiop_bus_scan_cb(struct cam_periph *periph, union ccb *ccb); 109static int hptiop_rescan_bus(struct hpt_iop_hba *hba); 110static int hptiop_alloc_pci_res_itl(struct hpt_iop_hba *hba); 111static int hptiop_alloc_pci_res_mv(struct hpt_iop_hba *hba); 112static int hptiop_get_config_itl(struct hpt_iop_hba *hba, 113 struct hpt_iop_request_get_config *config); 114static int hptiop_get_config_mv(struct hpt_iop_hba *hba, 115 struct hpt_iop_request_get_config *config); 116static int hptiop_set_config_itl(struct hpt_iop_hba *hba, 117 struct hpt_iop_request_set_config *config); 118static int hptiop_set_config_mv(struct hpt_iop_hba *hba, 119 struct hpt_iop_request_set_config *config); 120static int hptiop_internal_memalloc_mv(struct hpt_iop_hba *hba); 121static int hptiop_internal_memfree_mv(struct hpt_iop_hba *hba); 122static int hptiop_post_ioctl_command_itl(struct hpt_iop_hba *hba, 123 u_int32_t req32, struct hpt_iop_ioctl_param *pParams); 124static int hptiop_post_ioctl_command_mv(struct hpt_iop_hba *hba, 125 struct hpt_iop_request_ioctl_command *req, 126 struct hpt_iop_ioctl_param *pParams); 127static void hptiop_post_req_itl(struct hpt_iop_hba *hba, 128 struct hpt_iop_srb *srb, 129 bus_dma_segment_t *segs, int nsegs); 130static void hptiop_post_req_mv(struct hpt_iop_hba *hba, 131 struct hpt_iop_srb *srb, 132 bus_dma_segment_t *segs, int nsegs); 133static void hptiop_post_msg_itl(struct hpt_iop_hba *hba, u_int32_t msg); 134static void hptiop_post_msg_mv(struct hpt_iop_hba *hba, u_int32_t msg); 135static void hptiop_enable_intr_itl(struct hpt_iop_hba *hba); 136static void hptiop_enable_intr_mv(struct hpt_iop_hba *hba); 137static void hptiop_disable_intr_itl(struct hpt_iop_hba *hba); 138static void hptiop_disable_intr_mv(struct hpt_iop_hba *hba); 139static void hptiop_free_srb(struct hpt_iop_hba *hba, struct hpt_iop_srb *srb); 140static int hptiop_os_query_remove_device(struct hpt_iop_hba *hba, int tid); 141static int hptiop_probe(device_t dev); 142static int hptiop_attach(device_t dev); 143static int hptiop_detach(device_t dev); 144static int hptiop_shutdown(device_t dev); 145static void hptiop_action(struct cam_sim *sim, union ccb *ccb); 146static void hptiop_poll(struct cam_sim *sim); 147static void hptiop_async(void *callback_arg, u_int32_t code, 148 struct cam_path *path, void *arg); 149static void hptiop_pci_intr(void *arg); 150static void hptiop_release_resource(struct hpt_iop_hba *hba); 151static int hptiop_reset_adapter(struct hpt_iop_hba *hba); 152 153static d_open_t hptiop_open; 154static d_close_t hptiop_close; 155static d_ioctl_t hptiop_ioctl; 156 157static struct cdevsw hptiop_cdevsw = { 158 .d_open = hptiop_open, 159 .d_close = hptiop_close, 160 .d_ioctl = hptiop_ioctl, 161 .d_name = driver_name, 162#if __FreeBSD_version>=503000 163 .d_version = D_VERSION, 164#endif 165#if (__FreeBSD_version>=503000 && __FreeBSD_version<600034) 166 .d_flags = D_NEEDGIANT, 167#endif 168#if __FreeBSD_version<600034 169#if __FreeBSD_version>=501000 170 .d_maj = MAJOR_AUTO, 171#else 172 .d_maj = HPT_DEV_MAJOR, 173#endif 174#endif 175}; 176 177#if __FreeBSD_version < 503000 178#define hba_from_dev(dev) ((struct hpt_iop_hba *)(dev)->si_drv1) 179#else 180#define hba_from_dev(dev) \ 181 ((struct hpt_iop_hba *)devclass_get_softc(hptiop_devclass, dev2unit(dev))) 182#endif 183 184#define BUS_SPACE_WRT4_ITL(offset, value) bus_space_write_4(hba->bar0t,\ 185 hba->bar0h, offsetof(struct hpt_iopmu_itl, offset), (value)) 186#define BUS_SPACE_RD4_ITL(offset) bus_space_read_4(hba->bar0t,\ 187 hba->bar0h, offsetof(struct hpt_iopmu_itl, offset)) 188 189#define BUS_SPACE_WRT4_MV0(offset, value) bus_space_write_4(hba->bar0t,\ 190 hba->bar0h, offsetof(struct hpt_iopmv_regs, offset), value) 191#define BUS_SPACE_RD4_MV0(offset) bus_space_read_4(hba->bar0t,\ 192 hba->bar0h, offsetof(struct hpt_iopmv_regs, offset)) 193#define BUS_SPACE_WRT4_MV2(offset, value) bus_space_write_4(hba->bar2t,\ 194 hba->bar2h, offsetof(struct hpt_iopmu_mv, offset), value) 195#define BUS_SPACE_RD4_MV2(offset) bus_space_read_4(hba->bar2t,\ 196 hba->bar2h, offsetof(struct hpt_iopmu_mv, offset)) 197 198static int hptiop_open(ioctl_dev_t dev, int flags, 199 int devtype, ioctl_thread_t proc) 200{ 201 struct hpt_iop_hba *hba = hba_from_dev(dev); 202 203 if (hba==NULL) 204 return ENXIO; 205 if (hba->flag & HPT_IOCTL_FLAG_OPEN) 206 return EBUSY; 207 hba->flag |= HPT_IOCTL_FLAG_OPEN; 208 return 0; 209} 210 211static int hptiop_close(ioctl_dev_t dev, int flags, 212 int devtype, ioctl_thread_t proc) 213{ 214 struct hpt_iop_hba *hba = hba_from_dev(dev); 215 hba->flag &= ~(u_int32_t)HPT_IOCTL_FLAG_OPEN; 216 return 0; 217} 218 219static int hptiop_ioctl(ioctl_dev_t dev, u_long cmd, caddr_t data, 220 int flags, ioctl_thread_t proc) 221{ 222 int ret = EFAULT; 223 struct hpt_iop_hba *hba = hba_from_dev(dev); 224 225#if (__FreeBSD_version >= 500000) 226 mtx_lock(&Giant); 227#endif 228 229 switch (cmd) { 230 case HPT_DO_IOCONTROL: 231 ret = hba->ops->do_ioctl(hba, 232 (struct hpt_iop_ioctl_param *)data); 233 break; 234 case HPT_SCAN_BUS: 235 ret = hptiop_rescan_bus(hba); 236 break; 237 } 238 239#if (__FreeBSD_version >= 500000) 240 mtx_unlock(&Giant); 241#endif 242 243 return ret; 244} 245 246static u_int64_t hptiop_mv_outbound_read(struct hpt_iop_hba *hba) 247{ 248 u_int64_t p; 249 u_int32_t outbound_tail = BUS_SPACE_RD4_MV2(outbound_tail); 250 u_int32_t outbound_head = BUS_SPACE_RD4_MV2(outbound_head); 251 252 if (outbound_tail != outbound_head) { 253 bus_space_read_region_4(hba->bar2t, hba->bar2h, 254 offsetof(struct hpt_iopmu_mv, 255 outbound_q[outbound_tail]), 256 (u_int32_t *)&p, 2); 257 258 outbound_tail++; 259 260 if (outbound_tail == MVIOP_QUEUE_LEN) 261 outbound_tail = 0; 262 263 BUS_SPACE_WRT4_MV2(outbound_tail, outbound_tail); 264 return p; 265 } else 266 return 0; 267} 268 269static void hptiop_mv_inbound_write(u_int64_t p, struct hpt_iop_hba *hba) 270{ 271 u_int32_t inbound_head = BUS_SPACE_RD4_MV2(inbound_head); 272 u_int32_t head = inbound_head + 1; 273 274 if (head == MVIOP_QUEUE_LEN) 275 head = 0; 276 277 bus_space_write_region_4(hba->bar2t, hba->bar2h, 278 offsetof(struct hpt_iopmu_mv, inbound_q[inbound_head]), 279 (u_int32_t *)&p, 2); 280 BUS_SPACE_WRT4_MV2(inbound_head, head); 281 BUS_SPACE_WRT4_MV0(inbound_doorbell, MVIOP_MU_INBOUND_INT_POSTQUEUE); 282} 283 284static void hptiop_post_msg_itl(struct hpt_iop_hba *hba, u_int32_t msg) 285{ 286 BUS_SPACE_WRT4_ITL(inbound_msgaddr0, msg); 287 BUS_SPACE_RD4_ITL(outbound_intstatus); 288} 289 290static void hptiop_post_msg_mv(struct hpt_iop_hba *hba, u_int32_t msg) 291{ 292 293 BUS_SPACE_WRT4_MV2(inbound_msg, msg); 294 BUS_SPACE_WRT4_MV0(inbound_doorbell, MVIOP_MU_INBOUND_INT_MSG); 295 296 BUS_SPACE_RD4_MV0(outbound_intmask); 297} 298 299static int hptiop_wait_ready_itl(struct hpt_iop_hba * hba, u_int32_t millisec) 300{ 301 u_int32_t req=0; 302 int i; 303 304 for (i = 0; i < millisec; i++) { 305 req = BUS_SPACE_RD4_ITL(inbound_queue); 306 if (req != IOPMU_QUEUE_EMPTY) 307 break; 308 DELAY(1000); 309 } 310 311 if (req!=IOPMU_QUEUE_EMPTY) { 312 BUS_SPACE_WRT4_ITL(outbound_queue, req); 313 BUS_SPACE_RD4_ITL(outbound_intstatus); 314 return 0; 315 } 316 317 return -1; 318} 319 320static int hptiop_wait_ready_mv(struct hpt_iop_hba * hba, u_int32_t millisec) 321{ 322 if (hptiop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_NOP, millisec)) 323 return -1; 324 325 return 0; 326} 327 328static void hptiop_request_callback_itl(struct hpt_iop_hba * hba, 329 u_int32_t index) 330{ 331 struct hpt_iop_srb *srb; 332 struct hpt_iop_request_scsi_command *req=0; 333 union ccb *ccb; 334 u_int8_t *cdb; 335 u_int32_t result, temp, dxfer; 336 u_int64_t temp64; 337 338 if (index & IOPMU_QUEUE_MASK_HOST_BITS) { /*host req*/ 339 if (hba->firmware_version > 0x01020000 || 340 hba->interface_version > 0x01020000) { 341 srb = hba->srb[index & ~(u_int32_t) 342 (IOPMU_QUEUE_ADDR_HOST_BIT 343 | IOPMU_QUEUE_REQUEST_RESULT_BIT)]; 344 req = (struct hpt_iop_request_scsi_command *)srb; 345 if (index & IOPMU_QUEUE_REQUEST_RESULT_BIT) 346 result = IOP_RESULT_SUCCESS; 347 else 348 result = req->header.result; 349 } else { 350 srb = hba->srb[index & 351 ~(u_int32_t)IOPMU_QUEUE_ADDR_HOST_BIT]; 352 req = (struct hpt_iop_request_scsi_command *)srb; 353 result = req->header.result; 354 } 355 dxfer = req->dataxfer_length; 356 goto srb_complete; 357 } 358 359 /*iop req*/ 360 temp = bus_space_read_4(hba->bar0t, hba->bar0h, index + 361 offsetof(struct hpt_iop_request_header, type)); 362 result = bus_space_read_4(hba->bar0t, hba->bar0h, index + 363 offsetof(struct hpt_iop_request_header, result)); 364 switch(temp) { 365 case IOP_REQUEST_TYPE_IOCTL_COMMAND: 366 { 367 temp64 = 0; 368 bus_space_write_region_4(hba->bar0t, hba->bar0h, index + 369 offsetof(struct hpt_iop_request_header, context), 370 (u_int32_t *)&temp64, 2); 371 wakeup((void *)((unsigned long)hba->u.itl.mu + index)); 372 break; 373 } 374 375 case IOP_REQUEST_TYPE_SCSI_COMMAND: 376 bus_space_read_region_4(hba->bar0t, hba->bar0h, index + 377 offsetof(struct hpt_iop_request_header, context), 378 (u_int32_t *)&temp64, 2); 379 srb = (struct hpt_iop_srb *)(unsigned long)temp64; 380 dxfer = bus_space_read_4(hba->bar0t, hba->bar0h, 381 index + offsetof(struct hpt_iop_request_scsi_command, 382 dataxfer_length)); 383srb_complete: 384 ccb = (union ccb *)srb->ccb; 385 if (ccb->ccb_h.flags & CAM_CDB_POINTER) 386 cdb = ccb->csio.cdb_io.cdb_ptr; 387 else 388 cdb = ccb->csio.cdb_io.cdb_bytes; 389 390 if (cdb[0] == SYNCHRONIZE_CACHE) { /* ??? */ 391 ccb->ccb_h.status = CAM_REQ_CMP; 392 goto scsi_done; 393 } 394 395 switch (result) { 396 case IOP_RESULT_SUCCESS: 397 switch (ccb->ccb_h.flags & CAM_DIR_MASK) { 398 case CAM_DIR_IN: 399 bus_dmamap_sync(hba->io_dmat, 400 srb->dma_map, BUS_DMASYNC_POSTREAD); 401 bus_dmamap_unload(hba->io_dmat, srb->dma_map); 402 break; 403 case CAM_DIR_OUT: 404 bus_dmamap_sync(hba->io_dmat, 405 srb->dma_map, BUS_DMASYNC_POSTWRITE); 406 bus_dmamap_unload(hba->io_dmat, srb->dma_map); 407 break; 408 } 409 410 ccb->ccb_h.status = CAM_REQ_CMP; 411 break; 412 413 case IOP_RESULT_BAD_TARGET: 414 ccb->ccb_h.status = CAM_DEV_NOT_THERE; 415 break; 416 case IOP_RESULT_BUSY: 417 ccb->ccb_h.status = CAM_BUSY; 418 break; 419 case IOP_RESULT_INVALID_REQUEST: 420 ccb->ccb_h.status = CAM_REQ_INVALID; 421 break; 422 case IOP_RESULT_FAIL: 423 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 424 break; 425 case IOP_RESULT_RESET: 426 ccb->ccb_h.status = CAM_BUSY; 427 break; 428 case IOP_RESULT_CHECK_CONDITION: 429 if (srb->srb_flag & HPT_SRB_FLAG_HIGH_MEM_ACESS) {/*iop*/ 430 bus_space_read_region_1(hba->bar0t, hba->bar0h, 431 index + offsetof(struct hpt_iop_request_scsi_command, 432 sg_list), (u_int8_t *)&ccb->csio.sense_data, 433 MIN(dxfer, sizeof(ccb->csio.sense_data))); 434 } else { 435 memcpy(&ccb->csio.sense_data, &req->sg_list, 436 MIN(dxfer, sizeof(ccb->csio.sense_data))); 437 } 438 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 439 ccb->ccb_h.status |= CAM_AUTOSNS_VALID; 440 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 441 break; 442 default: 443 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 444 break; 445 } 446scsi_done: 447 if (srb->srb_flag & HPT_SRB_FLAG_HIGH_MEM_ACESS) 448 BUS_SPACE_WRT4_ITL(outbound_queue, index); 449 450 ccb->csio.resid = ccb->csio.dxfer_len - dxfer; 451 452 hptiop_free_srb(hba, srb); 453 xpt_done(ccb); 454 break; 455 } 456} 457 458static void hptiop_drain_outbound_queue_itl(struct hpt_iop_hba *hba) 459{ 460 u_int32_t req, temp; 461 462 while ((req = BUS_SPACE_RD4_ITL(outbound_queue)) !=IOPMU_QUEUE_EMPTY) { 463 if (req & IOPMU_QUEUE_MASK_HOST_BITS) 464 hptiop_request_callback_itl(hba, req); 465 else { 466 struct hpt_iop_request_header *p; 467 468 p = (struct hpt_iop_request_header *) 469 ((char *)hba->u.itl.mu + req); 470 temp = bus_space_read_4(hba->bar0t, 471 hba->bar0h,req + 472 offsetof(struct hpt_iop_request_header, 473 flags)); 474 if (temp & IOP_REQUEST_FLAG_SYNC_REQUEST) { 475 u_int64_t temp64; 476 bus_space_read_region_4(hba->bar0t, 477 hba->bar0h,req + 478 offsetof(struct hpt_iop_request_header, 479 context), 480 (u_int32_t *)&temp64, 2); 481 if (temp64) { 482 hptiop_request_callback_itl(hba, req); 483 } else { 484 temp64 = 1; 485 bus_space_write_region_4(hba->bar0t, 486 hba->bar0h,req + 487 offsetof(struct hpt_iop_request_header, 488 context), 489 (u_int32_t *)&temp64, 2); 490 } 491 } else 492 hptiop_request_callback_itl(hba, req); 493 } 494 } 495} 496 497static int hptiop_intr_itl(struct hpt_iop_hba * hba) 498{ 499 u_int32_t status; 500 int ret = 0; 501 502 status = BUS_SPACE_RD4_ITL(outbound_intstatus); 503 504 if (status & IOPMU_OUTBOUND_INT_MSG0) { 505 u_int32_t msg = BUS_SPACE_RD4_ITL(outbound_msgaddr0); 506 KdPrint(("hptiop: received outbound msg %x\n", msg)); 507 BUS_SPACE_WRT4_ITL(outbound_intstatus, IOPMU_OUTBOUND_INT_MSG0); 508 hptiop_os_message_callback(hba, msg); 509 ret = 1; 510 } 511 512 if (status & IOPMU_OUTBOUND_INT_POSTQUEUE) { 513 hptiop_drain_outbound_queue_itl(hba); 514 ret = 1; 515 } 516 517 return ret; 518} 519 520static void hptiop_request_callback_mv(struct hpt_iop_hba * hba, 521 u_int64_t _tag) 522{ 523 u_int32_t context = (u_int32_t)_tag; 524 525 if (context & MVIOP_CMD_TYPE_SCSI) { 526 struct hpt_iop_srb *srb; 527 struct hpt_iop_request_scsi_command *req; 528 union ccb *ccb; 529 u_int8_t *cdb; 530 531 srb = hba->srb[context >> MVIOP_REQUEST_NUMBER_START_BIT]; 532 req = (struct hpt_iop_request_scsi_command *)srb; 533 ccb = (union ccb *)srb->ccb; 534 if (ccb->ccb_h.flags & CAM_CDB_POINTER) 535 cdb = ccb->csio.cdb_io.cdb_ptr; 536 else 537 cdb = ccb->csio.cdb_io.cdb_bytes; 538 539 if (cdb[0] == SYNCHRONIZE_CACHE) { /* ??? */ 540 ccb->ccb_h.status = CAM_REQ_CMP; 541 goto scsi_done; 542 } 543 if (context & MVIOP_MU_QUEUE_REQUEST_RESULT_BIT) 544 req->header.result = IOP_RESULT_SUCCESS; 545 546 switch (req->header.result) { 547 case IOP_RESULT_SUCCESS: 548 switch (ccb->ccb_h.flags & CAM_DIR_MASK) { 549 case CAM_DIR_IN: 550 bus_dmamap_sync(hba->io_dmat, 551 srb->dma_map, BUS_DMASYNC_POSTREAD); 552 bus_dmamap_unload(hba->io_dmat, srb->dma_map); 553 break; 554 case CAM_DIR_OUT: 555 bus_dmamap_sync(hba->io_dmat, 556 srb->dma_map, BUS_DMASYNC_POSTWRITE); 557 bus_dmamap_unload(hba->io_dmat, srb->dma_map); 558 break; 559 } 560 ccb->ccb_h.status = CAM_REQ_CMP; 561 break; 562 case IOP_RESULT_BAD_TARGET: 563 ccb->ccb_h.status = CAM_DEV_NOT_THERE; 564 break; 565 case IOP_RESULT_BUSY: 566 ccb->ccb_h.status = CAM_BUSY; 567 break; 568 case IOP_RESULT_INVALID_REQUEST: 569 ccb->ccb_h.status = CAM_REQ_INVALID; 570 break; 571 case IOP_RESULT_FAIL: 572 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 573 break; 574 case IOP_RESULT_RESET: 575 ccb->ccb_h.status = CAM_BUSY; 576 break; 577 case IOP_RESULT_CHECK_CONDITION: 578 memcpy(&ccb->csio.sense_data, &req->sg_list, 579 MIN(req->dataxfer_length, sizeof(ccb->csio.sense_data))); 580 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 581 ccb->ccb_h.status |= CAM_AUTOSNS_VALID; 582 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 583 break; 584 default: 585 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 586 break; 587 } 588scsi_done: 589 ccb->csio.resid = ccb->csio.dxfer_len - req->dataxfer_length; 590 591 hptiop_free_srb(hba, srb); 592 xpt_done(ccb); 593 } else if (context & MVIOP_CMD_TYPE_IOCTL) { 594 struct hpt_iop_request_ioctl_command *req = hba->ctlcfg_ptr; 595 if (context & MVIOP_MU_QUEUE_REQUEST_RESULT_BIT) 596 hba->config_done = 1; 597 else 598 hba->config_done = -1; 599 wakeup(req); 600 } else if (context & 601 (MVIOP_CMD_TYPE_SET_CONFIG | 602 MVIOP_CMD_TYPE_GET_CONFIG)) 603 hba->config_done = 1; 604 else { 605 device_printf(hba->pcidev, "wrong callback type\n"); 606 } 607} 608 609static void hptiop_drain_outbound_queue_mv(struct hpt_iop_hba * hba) 610{ 611 u_int64_t req; 612 613 while ((req = hptiop_mv_outbound_read(hba))) { 614 if (req & MVIOP_MU_QUEUE_ADDR_HOST_BIT) { 615 if (req & MVIOP_MU_QUEUE_REQUEST_RETURN_CONTEXT) { 616 hptiop_request_callback_mv(hba, req); 617 } 618 } 619 } 620} 621 622static int hptiop_intr_mv(struct hpt_iop_hba * hba) 623{ 624 u_int32_t status; 625 int ret = 0; 626 627 status = BUS_SPACE_RD4_MV0(outbound_doorbell); 628 629 if (status) 630 BUS_SPACE_WRT4_MV0(outbound_doorbell, ~status); 631 632 if (status & MVIOP_MU_OUTBOUND_INT_MSG) { 633 u_int32_t msg = BUS_SPACE_RD4_MV2(outbound_msg); 634 KdPrint(("hptiop: received outbound msg %x\n", msg)); 635 hptiop_os_message_callback(hba, msg); 636 ret = 1; 637 } 638 639 if (status & MVIOP_MU_OUTBOUND_INT_POSTQUEUE) { 640 hptiop_drain_outbound_queue_mv(hba); 641 ret = 1; 642 } 643 644 return ret; 645} 646 647static int hptiop_send_sync_request_itl(struct hpt_iop_hba * hba, 648 u_int32_t req32, u_int32_t millisec) 649{ 650 u_int32_t i; 651 u_int64_t temp64; 652 653 BUS_SPACE_WRT4_ITL(inbound_queue, req32); 654 BUS_SPACE_RD4_ITL(outbound_intstatus); 655 656 for (i = 0; i < millisec; i++) { 657 hptiop_intr_itl(hba); 658 bus_space_read_region_4(hba->bar0t, hba->bar0h, req32 + 659 offsetof(struct hpt_iop_request_header, context), 660 (u_int32_t *)&temp64, 2); 661 if (temp64) 662 return 0; 663 DELAY(1000); 664 } 665 666 return -1; 667} 668 669static int hptiop_send_sync_request_mv(struct hpt_iop_hba *hba, 670 void *req, u_int32_t millisec) 671{ 672 u_int32_t i; 673 u_int64_t phy_addr; 674 hba->config_done = 0; 675 676 phy_addr = hba->ctlcfgcmd_phy | 677 (u_int64_t)MVIOP_MU_QUEUE_ADDR_HOST_BIT; 678 ((struct hpt_iop_request_get_config *)req)->header.flags |= 679 IOP_REQUEST_FLAG_SYNC_REQUEST | 680 IOP_REQUEST_FLAG_OUTPUT_CONTEXT; 681 hptiop_mv_inbound_write(phy_addr, hba); 682 BUS_SPACE_RD4_MV0(outbound_intmask); 683 684 for (i = 0; i < millisec; i++) { 685 hptiop_intr_mv(hba); 686 if (hba->config_done) 687 return 0; 688 DELAY(1000); 689 } 690 return -1; 691} 692 693static int hptiop_send_sync_msg(struct hpt_iop_hba *hba, 694 u_int32_t msg, u_int32_t millisec) 695{ 696 u_int32_t i; 697 698 hba->msg_done = 0; 699 hba->ops->post_msg(hba, msg); 700 701 for (i=0; i<millisec; i++) { 702 hba->ops->iop_intr(hba); 703 if (hba->msg_done) 704 break; 705 DELAY(1000); 706 } 707 708 return hba->msg_done? 0 : -1; 709} 710 711static int hptiop_get_config_itl(struct hpt_iop_hba * hba, 712 struct hpt_iop_request_get_config * config) 713{ 714 u_int32_t req32; 715 716 config->header.size = sizeof(struct hpt_iop_request_get_config); 717 config->header.type = IOP_REQUEST_TYPE_GET_CONFIG; 718 config->header.flags = IOP_REQUEST_FLAG_SYNC_REQUEST; 719 config->header.result = IOP_RESULT_PENDING; 720 config->header.context = 0; 721 722 req32 = BUS_SPACE_RD4_ITL(inbound_queue); 723 if (req32 == IOPMU_QUEUE_EMPTY) 724 return -1; 725 726 bus_space_write_region_4(hba->bar0t, hba->bar0h, 727 req32, (u_int32_t *)config, 728 sizeof(struct hpt_iop_request_header) >> 2); 729 730 if (hptiop_send_sync_request_itl(hba, req32, 20000)) { 731 KdPrint(("hptiop: get config send cmd failed")); 732 return -1; 733 } 734 735 bus_space_read_region_4(hba->bar0t, hba->bar0h, 736 req32, (u_int32_t *)config, 737 sizeof(struct hpt_iop_request_get_config) >> 2); 738 739 BUS_SPACE_WRT4_ITL(outbound_queue, req32); 740 741 return 0; 742} 743 744static int hptiop_get_config_mv(struct hpt_iop_hba * hba, 745 struct hpt_iop_request_get_config * config) 746{ 747 struct hpt_iop_request_get_config *req; 748 749 if (!(req = hba->ctlcfg_ptr)) 750 return -1; 751 752 req->header.flags = 0; 753 req->header.type = IOP_REQUEST_TYPE_GET_CONFIG; 754 req->header.size = sizeof(struct hpt_iop_request_get_config); 755 req->header.result = IOP_RESULT_PENDING; 756 req->header.context = MVIOP_CMD_TYPE_GET_CONFIG; 757 758 if (hptiop_send_sync_request_mv(hba, req, 20000)) { 759 KdPrint(("hptiop: get config send cmd failed")); 760 return -1; 761 } 762 763 *config = *req; 764 return 0; 765} 766 767static int hptiop_set_config_itl(struct hpt_iop_hba *hba, 768 struct hpt_iop_request_set_config *config) 769{ 770 u_int32_t req32; 771 772 req32 = BUS_SPACE_RD4_ITL(inbound_queue); 773 774 if (req32 == IOPMU_QUEUE_EMPTY) 775 return -1; 776 777 config->header.size = sizeof(struct hpt_iop_request_set_config); 778 config->header.type = IOP_REQUEST_TYPE_SET_CONFIG; 779 config->header.flags = IOP_REQUEST_FLAG_SYNC_REQUEST; 780 config->header.result = IOP_RESULT_PENDING; 781 config->header.context = 0; 782 783 bus_space_write_region_4(hba->bar0t, hba->bar0h, req32, 784 (u_int32_t *)config, 785 sizeof(struct hpt_iop_request_set_config) >> 2); 786 787 if (hptiop_send_sync_request_itl(hba, req32, 20000)) { 788 KdPrint(("hptiop: set config send cmd failed")); 789 return -1; 790 } 791 792 BUS_SPACE_WRT4_ITL(outbound_queue, req32); 793 794 return 0; 795} 796 797static int hptiop_set_config_mv(struct hpt_iop_hba *hba, 798 struct hpt_iop_request_set_config *config) 799{ 800 struct hpt_iop_request_set_config *req; 801 802 if (!(req = hba->ctlcfg_ptr)) 803 return -1; 804 805 memcpy((u_int8_t *)req + sizeof(struct hpt_iop_request_header), 806 (u_int8_t *)config + sizeof(struct hpt_iop_request_header), 807 sizeof(struct hpt_iop_request_set_config) - 808 sizeof(struct hpt_iop_request_header)); 809 810 req->header.flags = 0; 811 req->header.type = IOP_REQUEST_TYPE_SET_CONFIG; 812 req->header.size = sizeof(struct hpt_iop_request_set_config); 813 req->header.result = IOP_RESULT_PENDING; 814 req->header.context = MVIOP_CMD_TYPE_SET_CONFIG; 815 816 if (hptiop_send_sync_request_mv(hba, req, 20000)) { 817 KdPrint(("hptiop: set config send cmd failed")); 818 return -1; 819 } 820 821 return 0; 822} 823 824static int hptiop_post_ioctl_command_itl(struct hpt_iop_hba *hba, 825 u_int32_t req32, 826 struct hpt_iop_ioctl_param *pParams) 827{ 828 u_int64_t temp64; 829 struct hpt_iop_request_ioctl_command req; 830 831 if ((((pParams->nInBufferSize + 3) & ~3) + pParams->nOutBufferSize) > 832 (hba->max_request_size - 833 offsetof(struct hpt_iop_request_ioctl_command, buf))) { 834 device_printf(hba->pcidev, "request size beyond max value"); 835 return -1; 836 } 837 838 req.header.size = offsetof(struct hpt_iop_request_ioctl_command, buf) 839 + pParams->nInBufferSize; 840 req.header.type = IOP_REQUEST_TYPE_IOCTL_COMMAND; 841 req.header.flags = IOP_REQUEST_FLAG_SYNC_REQUEST; 842 req.header.result = IOP_RESULT_PENDING; 843 req.header.context = req32 + (u_int64_t)(unsigned long)hba->u.itl.mu; 844 req.ioctl_code = HPT_CTL_CODE_BSD_TO_IOP(pParams->dwIoControlCode); 845 req.inbuf_size = pParams->nInBufferSize; 846 req.outbuf_size = pParams->nOutBufferSize; 847 req.bytes_returned = 0; 848 849 bus_space_write_region_4(hba->bar0t, hba->bar0h, req32, (u_int32_t *)&req, 850 offsetof(struct hpt_iop_request_ioctl_command, buf)>>2); 851 852 hptiop_lock_adapter(hba); 853 854 BUS_SPACE_WRT4_ITL(inbound_queue, req32); 855 BUS_SPACE_RD4_ITL(outbound_intstatus); 856 857 bus_space_read_region_4(hba->bar0t, hba->bar0h, req32 + 858 offsetof(struct hpt_iop_request_ioctl_command, header.context), 859 (u_int32_t *)&temp64, 2); 860 while (temp64) { 861 if (hptiop_sleep(hba, (void *)((unsigned long)hba->u.itl.mu + req32), 862 PPAUSE, "hptctl", HPT_OSM_TIMEOUT)==0) 863 break; 864 hptiop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_RESET, 60000); 865 bus_space_read_region_4(hba->bar0t, hba->bar0h,req32 + 866 offsetof(struct hpt_iop_request_ioctl_command, 867 header.context), 868 (u_int32_t *)&temp64, 2); 869 } 870 871 hptiop_unlock_adapter(hba); 872 return 0; 873} 874 875static int hptiop_bus_space_copyin(struct hpt_iop_hba *hba, u_int32_t bus, void *user, int size) 876{ 877 unsigned char byte; 878 int i; 879 880 for (i=0; i<size; i++) { 881 if (copyin((u_int8_t *)user + i, &byte, 1)) 882 return -1; 883 bus_space_write_1(hba->bar0t, hba->bar0h, bus + i, byte); 884 } 885 886 return 0; 887} 888 889static int hptiop_bus_space_copyout(struct hpt_iop_hba *hba, u_int32_t bus, void *user, int size) 890{ 891 unsigned char byte; 892 int i; 893 894 for (i=0; i<size; i++) { 895 byte = bus_space_read_1(hba->bar0t, hba->bar0h, bus + i); 896 if (copyout(&byte, (u_int8_t *)user + i, 1)) 897 return -1; 898 } 899 900 return 0; 901} 902 903static int hptiop_do_ioctl_itl(struct hpt_iop_hba *hba, 904 struct hpt_iop_ioctl_param * pParams) 905{ 906 u_int32_t req32; 907 u_int32_t result; 908 909 if ((pParams->Magic != HPT_IOCTL_MAGIC) && 910 (pParams->Magic != HPT_IOCTL_MAGIC32)) 911 return EFAULT; 912 913 req32 = BUS_SPACE_RD4_ITL(inbound_queue); 914 if (req32 == IOPMU_QUEUE_EMPTY) 915 return EFAULT; 916 917 if (pParams->nInBufferSize) 918 if (hptiop_bus_space_copyin(hba, req32 + 919 offsetof(struct hpt_iop_request_ioctl_command, buf), 920 (void *)pParams->lpInBuffer, pParams->nInBufferSize)) 921 goto invalid; 922 923 if (hptiop_post_ioctl_command_itl(hba, req32, pParams)) 924 goto invalid; 925 926 result = bus_space_read_4(hba->bar0t, hba->bar0h, req32 + 927 offsetof(struct hpt_iop_request_ioctl_command, 928 header.result)); 929 930 if (result == IOP_RESULT_SUCCESS) { 931 if (pParams->nOutBufferSize) 932 if (hptiop_bus_space_copyout(hba, req32 + 933 offsetof(struct hpt_iop_request_ioctl_command, buf) + 934 ((pParams->nInBufferSize + 3) & ~3), 935 (void *)pParams->lpOutBuffer, pParams->nOutBufferSize)) 936 goto invalid; 937 938 if (pParams->lpBytesReturned) { 939 if (hptiop_bus_space_copyout(hba, req32 + 940 offsetof(struct hpt_iop_request_ioctl_command, bytes_returned), 941 (void *)pParams->lpBytesReturned, sizeof(unsigned long))) 942 goto invalid; 943 } 944 945 BUS_SPACE_WRT4_ITL(outbound_queue, req32); 946 947 return 0; 948 } else{ 949invalid: 950 BUS_SPACE_WRT4_ITL(outbound_queue, req32); 951 952 return EFAULT; 953 } 954} 955 956static int hptiop_post_ioctl_command_mv(struct hpt_iop_hba *hba, 957 struct hpt_iop_request_ioctl_command *req, 958 struct hpt_iop_ioctl_param *pParams) 959{ 960 u_int64_t req_phy; 961 int size = 0; 962 963 if ((((pParams->nInBufferSize + 3) & ~3) + pParams->nOutBufferSize) > 964 (hba->max_request_size - 965 offsetof(struct hpt_iop_request_ioctl_command, buf))) { 966 device_printf(hba->pcidev, "request size beyond max value"); 967 return -1; 968 } 969 970 req->ioctl_code = HPT_CTL_CODE_BSD_TO_IOP(pParams->dwIoControlCode); 971 req->inbuf_size = pParams->nInBufferSize; 972 req->outbuf_size = pParams->nOutBufferSize; 973 req->header.size = offsetof(struct hpt_iop_request_ioctl_command, buf) 974 + pParams->nInBufferSize; 975 req->header.context = (u_int64_t)MVIOP_CMD_TYPE_IOCTL; 976 req->header.type = IOP_REQUEST_TYPE_IOCTL_COMMAND; 977 req->header.result = IOP_RESULT_PENDING; 978 req->header.flags = IOP_REQUEST_FLAG_OUTPUT_CONTEXT; 979 size = req->header.size >> 8; 980 size = size > 3 ? 3 : size; 981 req_phy = hba->ctlcfgcmd_phy | MVIOP_MU_QUEUE_ADDR_HOST_BIT | size; 982 hptiop_mv_inbound_write(req_phy, hba); 983 984 BUS_SPACE_RD4_MV0(outbound_intmask); 985 986 while (hba->config_done == 0) { 987 if (hptiop_sleep(hba, req, PPAUSE, 988 "hptctl", HPT_OSM_TIMEOUT)==0) 989 continue; 990 hptiop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_RESET, 60000); 991 } 992 return 0; 993} 994 995static int hptiop_do_ioctl_mv(struct hpt_iop_hba *hba, 996 struct hpt_iop_ioctl_param *pParams) 997{ 998 struct hpt_iop_request_ioctl_command *req; 999 1000 if ((pParams->Magic != HPT_IOCTL_MAGIC) && 1001 (pParams->Magic != HPT_IOCTL_MAGIC32)) 1002 return EFAULT; 1003 1004 req = (struct hpt_iop_request_ioctl_command *)(hba->ctlcfg_ptr); 1005 hba->config_done = 0; 1006 hptiop_lock_adapter(hba); 1007 if (pParams->nInBufferSize) 1008 if (copyin((void *)pParams->lpInBuffer, 1009 req->buf, pParams->nInBufferSize)) 1010 goto invalid; 1011 if (hptiop_post_ioctl_command_mv(hba, req, pParams)) 1012 goto invalid; 1013 1014 if (hba->config_done == 1) { 1015 if (pParams->nOutBufferSize) 1016 if (copyout(req->buf + 1017 ((pParams->nInBufferSize + 3) & ~3), 1018 (void *)pParams->lpOutBuffer, 1019 pParams->nOutBufferSize)) 1020 goto invalid; 1021 1022 if (pParams->lpBytesReturned) 1023 if (copyout(&req->bytes_returned, 1024 (void*)pParams->lpBytesReturned, 1025 sizeof(u_int32_t))) 1026 goto invalid; 1027 hptiop_unlock_adapter(hba); 1028 return 0; 1029 } else{ 1030invalid: 1031 hptiop_unlock_adapter(hba); 1032 return EFAULT; 1033 } 1034} 1035 1036static int hptiop_rescan_bus(struct hpt_iop_hba * hba) 1037{ 1038 struct cam_path *path; 1039 union ccb *ccb; 1040 if (xpt_create_path(&path, xpt_periph, cam_sim_path(hba->sim), 1041 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) 1042 return(EIO); 1043 if ((ccb = malloc(sizeof(union ccb), M_TEMP, M_WAITOK)) == NULL) 1044 return(ENOMEM); 1045 bzero(ccb, sizeof(union ccb)); 1046 xpt_setup_ccb(&ccb->ccb_h, path, 5); 1047 ccb->ccb_h.func_code = XPT_SCAN_BUS; 1048 ccb->ccb_h.cbfcnp = hptiop_bus_scan_cb; 1049 ccb->crcn.flags = CAM_FLAG_NONE; 1050 xpt_action(ccb); 1051 return(0); 1052} 1053 1054static void hptiop_bus_scan_cb(struct cam_periph *periph, union ccb *ccb) 1055{ 1056 xpt_free_path(ccb->ccb_h.path); 1057 free(ccb, M_TEMP); 1058} 1059 1060static bus_dmamap_callback_t hptiop_map_srb; 1061static bus_dmamap_callback_t hptiop_post_scsi_command; 1062static bus_dmamap_callback_t hptiop_mv_map_ctlcfg; 1063 1064static int hptiop_alloc_pci_res_itl(struct hpt_iop_hba *hba) 1065{ 1066 hba->bar0_rid = 0x10; 1067 hba->bar0_res = bus_alloc_resource_any(hba->pcidev, 1068 SYS_RES_MEMORY, &hba->bar0_rid, RF_ACTIVE); 1069 1070 if (hba->bar0_res == NULL) { 1071 device_printf(hba->pcidev, 1072 "failed to get iop base adrress.\n"); 1073 return -1; 1074 } 1075 hba->bar0t = rman_get_bustag(hba->bar0_res); 1076 hba->bar0h = rman_get_bushandle(hba->bar0_res); 1077 hba->u.itl.mu = (struct hpt_iopmu_itl *) 1078 rman_get_virtual(hba->bar0_res); 1079 1080 if (!hba->u.itl.mu) { 1081 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1082 hba->bar0_rid, hba->bar0_res); 1083 device_printf(hba->pcidev, "alloc mem res failed\n"); 1084 return -1; 1085 } 1086 1087 return 0; 1088} 1089 1090static int hptiop_alloc_pci_res_mv(struct hpt_iop_hba *hba) 1091{ 1092 hba->bar0_rid = 0x10; 1093 hba->bar0_res = bus_alloc_resource_any(hba->pcidev, 1094 SYS_RES_MEMORY, &hba->bar0_rid, RF_ACTIVE); 1095 1096 if (hba->bar0_res == NULL) { 1097 device_printf(hba->pcidev, "failed to get iop bar0.\n"); 1098 return -1; 1099 } 1100 hba->bar0t = rman_get_bustag(hba->bar0_res); 1101 hba->bar0h = rman_get_bushandle(hba->bar0_res); 1102 hba->u.mv.regs = (struct hpt_iopmv_regs *) 1103 rman_get_virtual(hba->bar0_res); 1104 1105 if (!hba->u.mv.regs) { 1106 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1107 hba->bar0_rid, hba->bar0_res); 1108 device_printf(hba->pcidev, "alloc bar0 mem res failed\n"); 1109 return -1; 1110 } 1111 1112 hba->bar2_rid = 0x18; 1113 hba->bar2_res = bus_alloc_resource_any(hba->pcidev, 1114 SYS_RES_MEMORY, &hba->bar2_rid, RF_ACTIVE); 1115 1116 if (hba->bar2_res == NULL) { 1117 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1118 hba->bar0_rid, hba->bar0_res); 1119 device_printf(hba->pcidev, "failed to get iop bar2.\n"); 1120 return -1; 1121 } 1122 1123 hba->bar2t = rman_get_bustag(hba->bar2_res); 1124 hba->bar2h = rman_get_bushandle(hba->bar2_res); 1125 hba->u.mv.mu = (struct hpt_iopmu_mv *)rman_get_virtual(hba->bar2_res); 1126 1127 if (!hba->u.mv.mu) { 1128 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1129 hba->bar0_rid, hba->bar0_res); 1130 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1131 hba->bar2_rid, hba->bar2_res); 1132 device_printf(hba->pcidev, "alloc mem bar2 res failed\n"); 1133 return -1; 1134 } 1135 1136 return 0; 1137} 1138 1139static void hptiop_release_pci_res_itl(struct hpt_iop_hba *hba) 1140{ 1141 if (hba->bar0_res) 1142 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1143 hba->bar0_rid, hba->bar0_res); 1144} 1145 1146static void hptiop_release_pci_res_mv(struct hpt_iop_hba *hba) 1147{ 1148 if (hba->bar0_res) 1149 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1150 hba->bar0_rid, hba->bar0_res); 1151 if (hba->bar2_res) 1152 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 1153 hba->bar2_rid, hba->bar2_res); 1154} 1155 1156static int hptiop_internal_memalloc_mv(struct hpt_iop_hba *hba) 1157{ 1158 if (bus_dma_tag_create(hba->parent_dmat, 1159 1, 1160 0, 1161 BUS_SPACE_MAXADDR_32BIT, 1162 BUS_SPACE_MAXADDR, 1163 NULL, NULL, 1164 0x800 - 0x8, 1165 1, 1166 BUS_SPACE_MAXSIZE_32BIT, 1167 BUS_DMA_ALLOCNOW, 1168#if __FreeBSD_version > 502000 1169 NULL, 1170 NULL, 1171#endif 1172 &hba->ctlcfg_dmat)) { 1173 device_printf(hba->pcidev, "alloc ctlcfg_dmat failed\n"); 1174 return -1; 1175 } 1176 1177 if (bus_dmamem_alloc(hba->ctlcfg_dmat, (void **)&hba->ctlcfg_ptr, 1178#if __FreeBSD_version>501000 1179 BUS_DMA_WAITOK | BUS_DMA_COHERENT, 1180#else 1181 BUS_DMA_WAITOK, 1182#endif 1183 &hba->ctlcfg_dmamap) != 0) { 1184 device_printf(hba->pcidev, 1185 "bus_dmamem_alloc failed!\n"); 1186 bus_dma_tag_destroy(hba->ctlcfg_dmat); 1187 return -1; 1188 } 1189 1190 if (bus_dmamap_load(hba->ctlcfg_dmat, 1191 hba->ctlcfg_dmamap, hba->ctlcfg_ptr, 1192 MVIOP_IOCTLCFG_SIZE, 1193 hptiop_mv_map_ctlcfg, hba, 0)) { 1194 device_printf(hba->pcidev, "bus_dmamap_load failed!\n"); 1195 if (hba->ctlcfg_dmat) 1196 bus_dmamem_free(hba->ctlcfg_dmat, 1197 hba->ctlcfg_ptr, hba->ctlcfg_dmamap); 1198 bus_dma_tag_destroy(hba->ctlcfg_dmat); 1199 return -1; 1200 } 1201 1202 return 0; 1203} 1204 1205static int hptiop_internal_memfree_mv(struct hpt_iop_hba *hba) 1206{ 1207 if (hba->ctlcfg_dmat) { 1208 bus_dmamap_unload(hba->ctlcfg_dmat, hba->ctlcfg_dmamap); 1209 bus_dmamem_free(hba->ctlcfg_dmat, 1210 hba->ctlcfg_ptr, hba->ctlcfg_dmamap); 1211 bus_dma_tag_destroy(hba->ctlcfg_dmat); 1212 } 1213 1214 return 0; 1215} 1216 1217/* 1218 * CAM driver interface 1219 */ 1220static device_method_t driver_methods[] = { 1221 /* Device interface */ 1222 DEVMETHOD(device_probe, hptiop_probe), 1223 DEVMETHOD(device_attach, hptiop_attach), 1224 DEVMETHOD(device_detach, hptiop_detach), 1225 DEVMETHOD(device_shutdown, hptiop_shutdown), 1226 { 0, 0 } 1227}; 1228 1229static struct hptiop_adapter_ops hptiop_itl_ops = { 1230 .iop_wait_ready = hptiop_wait_ready_itl, 1231 .internal_memalloc = 0, 1232 .internal_memfree = 0, 1233 .alloc_pci_res = hptiop_alloc_pci_res_itl, 1234 .release_pci_res = hptiop_release_pci_res_itl, 1235 .enable_intr = hptiop_enable_intr_itl, 1236 .disable_intr = hptiop_disable_intr_itl, 1237 .get_config = hptiop_get_config_itl, 1238 .set_config = hptiop_set_config_itl, 1239 .iop_intr = hptiop_intr_itl, 1240 .post_msg = hptiop_post_msg_itl, 1241 .post_req = hptiop_post_req_itl, 1242 .do_ioctl = hptiop_do_ioctl_itl, 1243}; 1244 1245static struct hptiop_adapter_ops hptiop_mv_ops = { 1246 .iop_wait_ready = hptiop_wait_ready_mv, 1247 .internal_memalloc = hptiop_internal_memalloc_mv, 1248 .internal_memfree = hptiop_internal_memfree_mv, 1249 .alloc_pci_res = hptiop_alloc_pci_res_mv, 1250 .release_pci_res = hptiop_release_pci_res_mv, 1251 .enable_intr = hptiop_enable_intr_mv, 1252 .disable_intr = hptiop_disable_intr_mv, 1253 .get_config = hptiop_get_config_mv, 1254 .set_config = hptiop_set_config_mv, 1255 .iop_intr = hptiop_intr_mv, 1256 .post_msg = hptiop_post_msg_mv, 1257 .post_req = hptiop_post_req_mv, 1258 .do_ioctl = hptiop_do_ioctl_mv, 1259}; 1260 1261static driver_t hptiop_pci_driver = { 1262 driver_name, 1263 driver_methods, 1264 sizeof(struct hpt_iop_hba) 1265}; 1266 1267DRIVER_MODULE(hptiop, pci, hptiop_pci_driver, hptiop_devclass, 0, 0); 1268 1269static int hptiop_probe(device_t dev) 1270{ 1271 struct hpt_iop_hba *hba; 1272 u_int32_t id; 1273 static char buf[256]; 1274 int sas = 0; 1275 struct hptiop_adapter_ops *ops; 1276 1277 if (pci_get_vendor(dev) != 0x1103) 1278 return (ENXIO); 1279 1280 id = pci_get_device(dev); 1281 1282 switch (id) { 1283 case 0x4320: 1284 sas = 1; 1285 case 0x3220: 1286 case 0x3320: 1287 case 0x3410: 1288 case 0x3520: 1289 case 0x3510: 1290 case 0x3511: 1291 case 0x3521: 1292 case 0x3522: 1293 case 0x3540: 1294 ops = &hptiop_itl_ops; 1295 break; 1296 case 0x3120: 1297 case 0x3122: 1298 case 0x3020: 1299 ops = &hptiop_mv_ops; 1300 break; 1301 default: 1302 return (ENXIO); 1303 } 1304 1305 device_printf(dev, "adapter at PCI %d:%d:%d, IRQ %d\n", 1306 pci_get_bus(dev), pci_get_slot(dev), 1307 pci_get_function(dev), pci_get_irq(dev)); 1308 1309 sprintf(buf, "RocketRAID %x %s Controller\n", 1310 id, sas ? "SAS" : "SATA"); 1311 device_set_desc_copy(dev, buf); 1312 1313 hba = (struct hpt_iop_hba *)device_get_softc(dev); 1314 bzero(hba, sizeof(struct hpt_iop_hba)); 1315 hba->ops = ops; 1316 1317 KdPrint(("hba->ops=%p\n", hba->ops)); 1318 return 0; 1319} 1320 1321static int hptiop_attach(device_t dev) 1322{ 1323 struct hpt_iop_hba *hba = (struct hpt_iop_hba *)device_get_softc(dev); 1324 struct hpt_iop_request_get_config iop_config; 1325 struct hpt_iop_request_set_config set_config; 1326 int rid = 0; 1327 struct cam_devq *devq; 1328 struct ccb_setasync ccb; 1329 u_int32_t unit = device_get_unit(dev); 1330 1331 device_printf(dev, "%d RocketRAID 3xxx/4xxx controller driver %s\n", 1332 unit, driver_version); 1333 1334 KdPrint(("hptiop: attach(%d, %d/%d/%d) ops=%p\n", unit, 1335 pci_get_bus(dev), pci_get_slot(dev), 1336 pci_get_function(dev), hba->ops)); 1337 1338#if __FreeBSD_version >=440000 1339 pci_enable_busmaster(dev); 1340#endif 1341 hba->pcidev = dev; 1342 hba->pciunit = unit; 1343 1344 if (hba->ops->alloc_pci_res(hba)) 1345 return ENXIO; 1346 1347 if (hba->ops->iop_wait_ready(hba, 2000)) { 1348 device_printf(dev, "adapter is not ready\n"); 1349 goto release_pci_res; 1350 } 1351 1352#if (__FreeBSD_version >= 500000) 1353 mtx_init(&hba->lock, "hptioplock", NULL, MTX_DEF); 1354#endif 1355 1356 if (bus_dma_tag_create(NULL,/* parent */ 1357 1, /* alignment */ 1358 0, /* boundary */ 1359 BUS_SPACE_MAXADDR, /* lowaddr */ 1360 BUS_SPACE_MAXADDR, /* highaddr */ 1361 NULL, NULL, /* filter, filterarg */ 1362 BUS_SPACE_MAXSIZE_32BIT, /* maxsize */ 1363 BUS_SPACE_UNRESTRICTED, /* nsegments */ 1364 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 1365 0, /* flags */ 1366#if __FreeBSD_version>502000 1367 NULL, /* lockfunc */ 1368 NULL, /* lockfuncarg */ 1369#endif 1370 &hba->parent_dmat /* tag */)) 1371 { 1372 device_printf(dev, "alloc parent_dmat failed\n"); 1373 goto release_pci_res; 1374 } 1375 1376 if (hba->ops->internal_memalloc) { 1377 if (hba->ops->internal_memalloc(hba)) { 1378 device_printf(dev, "alloc srb_dmat failed\n"); 1379 goto destroy_parent_tag; 1380 } 1381 } 1382 1383 if (hba->ops->get_config(hba, &iop_config)) { 1384 device_printf(dev, "get iop config failed.\n"); 1385 goto get_config_failed; 1386 } 1387 1388 hba->firmware_version = iop_config.firmware_version; 1389 hba->interface_version = iop_config.interface_version; 1390 hba->max_requests = iop_config.max_requests; 1391 hba->max_devices = iop_config.max_devices; 1392 hba->max_request_size = iop_config.request_size; 1393 hba->max_sg_count = iop_config.max_sg_count; 1394 1395 if (bus_dma_tag_create(hba->parent_dmat,/* parent */ 1396 4, /* alignment */ 1397 BUS_SPACE_MAXADDR_32BIT+1, /* boundary */ 1398 BUS_SPACE_MAXADDR, /* lowaddr */ 1399 BUS_SPACE_MAXADDR, /* highaddr */ 1400 NULL, NULL, /* filter, filterarg */ 1401 PAGE_SIZE * (hba->max_sg_count-1), /* maxsize */ 1402 hba->max_sg_count, /* nsegments */ 1403 0x20000, /* maxsegsize */ 1404 BUS_DMA_ALLOCNOW, /* flags */ 1405#if __FreeBSD_version>502000 1406 busdma_lock_mutex, /* lockfunc */ 1407 &hba->lock, /* lockfuncarg */ 1408#endif 1409 &hba->io_dmat /* tag */)) 1410 { 1411 device_printf(dev, "alloc io_dmat failed\n"); 1412 goto get_config_failed; 1413 } 1414 1415 if (bus_dma_tag_create(hba->parent_dmat,/* parent */ 1416 1, /* alignment */ 1417 0, /* boundary */ 1418 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */ 1419 BUS_SPACE_MAXADDR, /* highaddr */ 1420 NULL, NULL, /* filter, filterarg */ 1421 HPT_SRB_MAX_SIZE * HPT_SRB_MAX_QUEUE_SIZE + 0x20, 1422 1, /* nsegments */ 1423 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */ 1424 0, /* flags */ 1425#if __FreeBSD_version>502000 1426 NULL, /* lockfunc */ 1427 NULL, /* lockfuncarg */ 1428#endif 1429 &hba->srb_dmat /* tag */)) 1430 { 1431 device_printf(dev, "alloc srb_dmat failed\n"); 1432 goto destroy_io_dmat; 1433 } 1434 1435 if (bus_dmamem_alloc(hba->srb_dmat, (void **)&hba->uncached_ptr, 1436#if __FreeBSD_version>501000 1437 BUS_DMA_WAITOK | BUS_DMA_COHERENT, 1438#else 1439 BUS_DMA_WAITOK, 1440#endif 1441 &hba->srb_dmamap) != 0) 1442 { 1443 device_printf(dev, "srb bus_dmamem_alloc failed!\n"); 1444 goto destroy_srb_dmat; 1445 } 1446 1447 if (bus_dmamap_load(hba->srb_dmat, 1448 hba->srb_dmamap, hba->uncached_ptr, 1449 (HPT_SRB_MAX_SIZE * HPT_SRB_MAX_QUEUE_SIZE) + 0x20, 1450 hptiop_map_srb, hba, 0)) 1451 { 1452 device_printf(dev, "bus_dmamap_load failed!\n"); 1453 goto srb_dmamem_free; 1454 } 1455 1456 if ((devq = cam_simq_alloc(hba->max_requests - 1 )) == NULL) { 1457 device_printf(dev, "cam_simq_alloc failed\n"); 1458 goto srb_dmamap_unload; 1459 } 1460 1461#if __FreeBSD_version <700000 1462 hba->sim = cam_sim_alloc(hptiop_action, hptiop_poll, driver_name, 1463 hba, unit, hba->max_requests - 1, 1, devq); 1464#else 1465 hba->sim = cam_sim_alloc(hptiop_action, hptiop_poll, driver_name, 1466 hba, unit, &Giant, hba->max_requests - 1, 1, devq); 1467#endif 1468 if (!hba->sim) { 1469 device_printf(dev, "cam_sim_alloc failed\n"); 1470 cam_simq_free(devq); 1471 goto srb_dmamap_unload; 1472 } 1473#if __FreeBSD_version <700000 1474 if (xpt_bus_register(hba->sim, 0) != CAM_SUCCESS) 1475#else 1476 if (xpt_bus_register(hba->sim, dev, 0) != CAM_SUCCESS) 1477#endif 1478 { 1479 device_printf(dev, "xpt_bus_register failed\n"); 1480 goto free_cam_sim; 1481 } 1482 1483 if (xpt_create_path(&hba->path, /*periph */ NULL, 1484 cam_sim_path(hba->sim), CAM_TARGET_WILDCARD, 1485 CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 1486 device_printf(dev, "xpt_create_path failed\n"); 1487 goto deregister_xpt_bus; 1488 } 1489 1490 bzero(&set_config, sizeof(set_config)); 1491 set_config.iop_id = unit; 1492 set_config.vbus_id = cam_sim_path(hba->sim); 1493 set_config.max_host_request_size = HPT_SRB_MAX_REQ_SIZE; 1494 1495 if (hba->ops->set_config(hba, &set_config)) { 1496 device_printf(dev, "set iop config failed.\n"); 1497 goto free_hba_path; 1498 } 1499 1500 xpt_setup_ccb(&ccb.ccb_h, hba->path, /*priority*/5); 1501 ccb.ccb_h.func_code = XPT_SASYNC_CB; 1502 ccb.event_enable = (AC_FOUND_DEVICE | AC_LOST_DEVICE); 1503 ccb.callback = hptiop_async; 1504 ccb.callback_arg = hba->sim; 1505 xpt_action((union ccb *)&ccb); 1506 1507 rid = 0; 1508 if ((hba->irq_res = bus_alloc_resource(hba->pcidev, SYS_RES_IRQ, 1509 &rid, 0, ~0ul, 1, RF_SHAREABLE | RF_ACTIVE)) == NULL) { 1510 device_printf(dev, "allocate irq failed!\n"); 1511 goto free_hba_path; 1512 } 1513 1514#if __FreeBSD_version <700000 1515 if (bus_setup_intr(hba->pcidev, hba->irq_res, INTR_TYPE_CAM, 1516 hptiop_pci_intr, hba, &hba->irq_handle)) 1517#else 1518 if (bus_setup_intr(hba->pcidev, hba->irq_res, INTR_TYPE_CAM, 1519 NULL, hptiop_pci_intr, hba, &hba->irq_handle)) 1520#endif 1521 { 1522 device_printf(dev, "allocate intr function failed!\n"); 1523 goto free_irq_resource; 1524 } 1525 1526 if (hptiop_send_sync_msg(hba, 1527 IOPMU_INBOUND_MSG0_START_BACKGROUND_TASK, 5000)) { 1528 device_printf(dev, "fail to start background task\n"); 1529 goto teartown_irq_resource; 1530 } 1531 1532 hba->ops->enable_intr(hba); 1533 1534 hba->ioctl_dev = make_dev(&hptiop_cdevsw, unit, 1535 UID_ROOT, GID_WHEEL /*GID_OPERATOR*/, 1536 S_IRUSR | S_IWUSR, "%s%d", driver_name, unit); 1537 1538#if __FreeBSD_version < 503000 1539 hba->ioctl_dev->si_drv1 = hba; 1540#endif 1541 1542 hptiop_rescan_bus(hba); 1543 1544 return 0; 1545 1546 1547teartown_irq_resource: 1548 bus_teardown_intr(dev, hba->irq_res, hba->irq_handle); 1549 1550free_irq_resource: 1551 bus_release_resource(dev, SYS_RES_IRQ, 0, hba->irq_res); 1552 1553free_hba_path: 1554 xpt_free_path(hba->path); 1555 1556deregister_xpt_bus: 1557 xpt_bus_deregister(cam_sim_path(hba->sim)); 1558 1559free_cam_sim: 1560 cam_sim_free(hba->sim, /*free devq*/ TRUE); 1561 1562srb_dmamap_unload: 1563 if (hba->uncached_ptr) 1564 bus_dmamap_unload(hba->srb_dmat, hba->srb_dmamap); 1565 1566srb_dmamem_free: 1567 if (hba->uncached_ptr) 1568 bus_dmamem_free(hba->srb_dmat, 1569 hba->uncached_ptr, hba->srb_dmamap); 1570 1571destroy_srb_dmat: 1572 if (hba->srb_dmat) 1573 bus_dma_tag_destroy(hba->srb_dmat); 1574 1575destroy_io_dmat: 1576 if (hba->io_dmat) 1577 bus_dma_tag_destroy(hba->io_dmat); 1578 1579get_config_failed: 1580 if (hba->ops->internal_memfree) 1581 hba->ops->internal_memfree(hba); 1582 1583destroy_parent_tag: 1584 if (hba->parent_dmat) 1585 bus_dma_tag_destroy(hba->parent_dmat); 1586 1587release_pci_res: 1588 if (hba->ops->release_pci_res) 1589 hba->ops->release_pci_res(hba); 1590 1591 return ENXIO; 1592} 1593 1594static int hptiop_detach(device_t dev) 1595{ 1596 struct hpt_iop_hba * hba = (struct hpt_iop_hba *)device_get_softc(dev); 1597 int i; 1598 int error = EBUSY; 1599 1600 hptiop_lock_adapter(hba); 1601 for (i = 0; i < hba->max_devices; i++) 1602 if (hptiop_os_query_remove_device(hba, i)) { 1603 device_printf(dev, "%d file system is busy. id=%d", 1604 hba->pciunit, i); 1605 goto out; 1606 } 1607 1608 if ((error = hptiop_shutdown(dev)) != 0) 1609 goto out; 1610 if (hptiop_send_sync_msg(hba, 1611 IOPMU_INBOUND_MSG0_STOP_BACKGROUND_TASK, 60000)) 1612 goto out; 1613 1614 hptiop_release_resource(hba); 1615 error = 0; 1616out: 1617 hptiop_unlock_adapter(hba); 1618 return error; 1619} 1620 1621static int hptiop_shutdown(device_t dev) 1622{ 1623 struct hpt_iop_hba * hba = (struct hpt_iop_hba *)device_get_softc(dev); 1624 1625 int error = 0; 1626 1627 if (hba->flag & HPT_IOCTL_FLAG_OPEN) { 1628 device_printf(dev, "%d device is busy", hba->pciunit); 1629 return EBUSY; 1630 } 1631 1632 hba->ops->disable_intr(hba); 1633 1634 if (hptiop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_SHUTDOWN, 60000)) 1635 error = EBUSY; 1636 1637 return error; 1638} 1639 1640static void hptiop_pci_intr(void *arg) 1641{ 1642 struct hpt_iop_hba * hba = (struct hpt_iop_hba *)arg; 1643 hptiop_lock_adapter(hba); 1644 hba->ops->iop_intr(hba); 1645 hptiop_unlock_adapter(hba); 1646} 1647 1648static void hptiop_poll(struct cam_sim *sim) 1649{ 1650 hptiop_pci_intr(cam_sim_softc(sim)); 1651} 1652 1653static void hptiop_async(void * callback_arg, u_int32_t code, 1654 struct cam_path * path, void * arg) 1655{ 1656} 1657 1658static void hptiop_enable_intr_itl(struct hpt_iop_hba *hba) 1659{ 1660 BUS_SPACE_WRT4_ITL(outbound_intmask, 1661 ~(IOPMU_OUTBOUND_INT_POSTQUEUE | IOPMU_OUTBOUND_INT_MSG0)); 1662} 1663 1664static void hptiop_enable_intr_mv(struct hpt_iop_hba *hba) 1665{ 1666 u_int32_t int_mask; 1667 1668 int_mask = BUS_SPACE_RD4_MV0(outbound_intmask); 1669 1670 int_mask |= MVIOP_MU_OUTBOUND_INT_POSTQUEUE 1671 | MVIOP_MU_OUTBOUND_INT_MSG; 1672 BUS_SPACE_WRT4_MV0(outbound_intmask,int_mask); 1673} 1674 1675static void hptiop_disable_intr_itl(struct hpt_iop_hba *hba) 1676{ 1677 u_int32_t int_mask; 1678 1679 int_mask = BUS_SPACE_RD4_ITL(outbound_intmask); 1680 1681 int_mask |= IOPMU_OUTBOUND_INT_POSTQUEUE | IOPMU_OUTBOUND_INT_MSG0; 1682 BUS_SPACE_WRT4_ITL(outbound_intmask, int_mask); 1683 BUS_SPACE_RD4_ITL(outbound_intstatus); 1684} 1685 1686static void hptiop_disable_intr_mv(struct hpt_iop_hba *hba) 1687{ 1688 u_int32_t int_mask; 1689 int_mask = BUS_SPACE_RD4_MV0(outbound_intmask); 1690 1691 int_mask &= ~(MVIOP_MU_OUTBOUND_INT_MSG 1692 | MVIOP_MU_OUTBOUND_INT_POSTQUEUE); 1693 BUS_SPACE_WRT4_MV0(outbound_intmask,int_mask); 1694 BUS_SPACE_RD4_MV0(outbound_intmask); 1695} 1696 1697static int hptiop_reset_adapter(struct hpt_iop_hba * hba) 1698{ 1699 return hptiop_send_sync_msg(hba, IOPMU_INBOUND_MSG0_RESET, 60000); 1700} 1701 1702static void *hptiop_get_srb(struct hpt_iop_hba * hba) 1703{ 1704 struct hpt_iop_srb * srb; 1705 1706 if (hba->srb_list) { 1707 srb = hba->srb_list; 1708 hba->srb_list = srb->next; 1709 return srb; 1710 } 1711 1712 return NULL; 1713} 1714 1715static void hptiop_free_srb(struct hpt_iop_hba *hba, struct hpt_iop_srb *srb) 1716{ 1717 srb->next = hba->srb_list; 1718 hba->srb_list = srb; 1719} 1720 1721static void hptiop_action(struct cam_sim *sim, union ccb *ccb) 1722{ 1723 struct hpt_iop_hba * hba = (struct hpt_iop_hba *)cam_sim_softc(sim); 1724 struct hpt_iop_srb * srb; 1725 1726 switch (ccb->ccb_h.func_code) { 1727 1728 case XPT_SCSI_IO: 1729 hptiop_lock_adapter(hba); 1730 if (ccb->ccb_h.target_lun != 0 || 1731 ccb->ccb_h.target_id >= hba->max_devices || 1732 (ccb->ccb_h.flags & CAM_CDB_PHYS)) 1733 { 1734 ccb->ccb_h.status = CAM_TID_INVALID; 1735 xpt_done(ccb); 1736 goto scsi_done; 1737 } 1738 1739 if ((srb = hptiop_get_srb(hba)) == NULL) { 1740 device_printf(hba->pcidev, "srb allocated failed"); 1741 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1742 xpt_done(ccb); 1743 goto scsi_done; 1744 } 1745 1746 srb->ccb = ccb; 1747 1748 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_NONE) 1749 hptiop_post_scsi_command(srb, NULL, 0, 0); 1750 else if ((ccb->ccb_h.flags & CAM_SCATTER_VALID) == 0) { 1751 if ((ccb->ccb_h.flags & CAM_DATA_PHYS) == 0) { 1752 int error; 1753 1754 error = bus_dmamap_load(hba->io_dmat, 1755 srb->dma_map, 1756 ccb->csio.data_ptr, 1757 ccb->csio.dxfer_len, 1758 hptiop_post_scsi_command, 1759 srb, 0); 1760 1761 if (error && error != EINPROGRESS) { 1762 device_printf(hba->pcidev, 1763 "%d bus_dmamap_load error %d", 1764 hba->pciunit, error); 1765 xpt_freeze_simq(hba->sim, 1); 1766 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1767invalid: 1768 hptiop_free_srb(hba, srb); 1769 xpt_done(ccb); 1770 goto scsi_done; 1771 } 1772 } 1773 else { 1774 device_printf(hba->pcidev, 1775 "CAM_DATA_PHYS not supported"); 1776 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1777 goto invalid; 1778 } 1779 } 1780 else { 1781 struct bus_dma_segment *segs; 1782 1783 if ((ccb->ccb_h.flags & CAM_SG_LIST_PHYS) == 0 || 1784 (ccb->ccb_h.flags & CAM_DATA_PHYS) != 0) { 1785 device_printf(hba->pcidev, "SCSI cmd failed"); 1786 ccb->ccb_h.status=CAM_PROVIDE_FAIL; 1787 goto invalid; 1788 } 1789 1790 segs = (struct bus_dma_segment *)ccb->csio.data_ptr; 1791 hptiop_post_scsi_command(srb, segs, 1792 ccb->csio.sglist_cnt, 0); 1793 } 1794 1795scsi_done: 1796 hptiop_unlock_adapter(hba); 1797 return; 1798 1799 case XPT_RESET_BUS: 1800 device_printf(hba->pcidev, "reset adapter"); 1801 hptiop_lock_adapter(hba); 1802 hba->msg_done = 0; 1803 hptiop_reset_adapter(hba); 1804 hptiop_unlock_adapter(hba); 1805 break; 1806 1807 case XPT_GET_TRAN_SETTINGS: 1808 case XPT_SET_TRAN_SETTINGS: 1809 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 1810 break; 1811 1812 case XPT_CALC_GEOMETRY: 1813 ccb->ccg.heads = 255; 1814 ccb->ccg.secs_per_track = 63; 1815 ccb->ccg.cylinders = ccb->ccg.volume_size / 1816 (ccb->ccg.heads * ccb->ccg.secs_per_track); 1817 ccb->ccb_h.status = CAM_REQ_CMP; 1818 break; 1819 1820 case XPT_PATH_INQ: 1821 { 1822 struct ccb_pathinq *cpi = &ccb->cpi; 1823 1824 cpi->version_num = 1; 1825 cpi->hba_inquiry = PI_SDTR_ABLE; 1826 cpi->target_sprt = 0; 1827 cpi->hba_misc = PIM_NOBUSRESET; 1828 cpi->hba_eng_cnt = 0; 1829 cpi->max_target = hba->max_devices; 1830 cpi->max_lun = 0; 1831 cpi->unit_number = cam_sim_unit(sim); 1832 cpi->bus_id = cam_sim_bus(sim); 1833 cpi->initiator_id = hba->max_devices; 1834 cpi->base_transfer_speed = 3300; 1835 1836 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 1837 strncpy(cpi->hba_vid, "HPT ", HBA_IDLEN); 1838 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 1839 cpi->ccb_h.status = CAM_REQ_CMP; 1840 break; 1841 } 1842 1843 default: 1844 ccb->ccb_h.status = CAM_REQ_INVALID; 1845 break; 1846 } 1847 1848 xpt_done(ccb); 1849 return; 1850} 1851 1852static void hptiop_post_req_itl(struct hpt_iop_hba *hba, 1853 struct hpt_iop_srb *srb, 1854 bus_dma_segment_t *segs, int nsegs) 1855{ 1856 int idx; 1857 union ccb *ccb = srb->ccb; 1858 u_int8_t *cdb; 1859 1860 if (ccb->ccb_h.flags & CAM_CDB_POINTER) 1861 cdb = ccb->csio.cdb_io.cdb_ptr; 1862 else 1863 cdb = ccb->csio.cdb_io.cdb_bytes; 1864 1865 KdPrint(("ccb=%p %x-%x-%x\n", 1866 ccb, *(u_int32_t *)cdb, *((u_int32_t *)cdb+1), *((u_int32_t *)cdb+2))); 1867 1868 if (srb->srb_flag & HPT_SRB_FLAG_HIGH_MEM_ACESS) { 1869 u_int32_t iop_req32; 1870 struct hpt_iop_request_scsi_command req; 1871 1872 iop_req32 = BUS_SPACE_RD4_ITL(inbound_queue); 1873 1874 if (iop_req32 == IOPMU_QUEUE_EMPTY) { 1875 device_printf(hba->pcidev, "invaild req offset\n"); 1876 ccb->ccb_h.status = CAM_BUSY; 1877 bus_dmamap_unload(hba->io_dmat, srb->dma_map); 1878 hptiop_free_srb(hba, srb); 1879 xpt_done(ccb); 1880 return; 1881 } 1882 1883 if (ccb->csio.dxfer_len && nsegs > 0) { 1884 struct hpt_iopsg *psg = req.sg_list; 1885 for (idx = 0; idx < nsegs; idx++, psg++) { 1886 psg->pci_address = (u_int64_t)segs[idx].ds_addr; 1887 psg->size = segs[idx].ds_len; 1888 psg->eot = 0; 1889 } 1890 psg[-1].eot = 1; 1891 } 1892 1893 bcopy(cdb, req.cdb, ccb->csio.cdb_len); 1894 1895 req.header.size = offsetof(struct hpt_iop_request_scsi_command, sg_list) 1896 + nsegs*sizeof(struct hpt_iopsg); 1897 req.header.type = IOP_REQUEST_TYPE_SCSI_COMMAND; 1898 req.header.flags = 0; 1899 req.header.result = IOP_RESULT_PENDING; 1900 req.header.context = (u_int64_t)(unsigned long)srb; 1901 req.dataxfer_length = ccb->csio.dxfer_len; 1902 req.channel = 0; 1903 req.target = ccb->ccb_h.target_id; 1904 req.lun = ccb->ccb_h.target_lun; 1905 1906 bus_space_write_region_1(hba->bar0t, hba->bar0h, iop_req32, 1907 (u_int8_t *)&req, req.header.size); 1908 1909 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 1910 bus_dmamap_sync(hba->io_dmat, 1911 srb->dma_map, BUS_DMASYNC_PREREAD); 1912 } 1913 else if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) 1914 bus_dmamap_sync(hba->io_dmat, 1915 srb->dma_map, BUS_DMASYNC_PREWRITE); 1916 1917 BUS_SPACE_WRT4_ITL(inbound_queue,iop_req32); 1918 } else { 1919 struct hpt_iop_request_scsi_command *req; 1920 1921 req = (struct hpt_iop_request_scsi_command *)srb; 1922 if (ccb->csio.dxfer_len && nsegs > 0) { 1923 struct hpt_iopsg *psg = req->sg_list; 1924 for (idx = 0; idx < nsegs; idx++, psg++) { 1925 psg->pci_address = 1926 (u_int64_t)segs[idx].ds_addr; 1927 psg->size = segs[idx].ds_len; 1928 psg->eot = 0; 1929 } 1930 psg[-1].eot = 1; 1931 } 1932 1933 bcopy(cdb, req->cdb, ccb->csio.cdb_len); 1934 1935 req->header.type = IOP_REQUEST_TYPE_SCSI_COMMAND; 1936 req->header.result = IOP_RESULT_PENDING; 1937 req->dataxfer_length = ccb->csio.dxfer_len; 1938 req->channel = 0; 1939 req->target = ccb->ccb_h.target_id; 1940 req->lun = ccb->ccb_h.target_lun; 1941 req->header.size = offsetof(struct hpt_iop_request_scsi_command, sg_list) 1942 + nsegs*sizeof(struct hpt_iopsg); 1943 req->header.context = (u_int64_t)srb->index | 1944 IOPMU_QUEUE_ADDR_HOST_BIT; 1945 req->header.flags = IOP_REQUEST_FLAG_OUTPUT_CONTEXT; 1946 1947 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 1948 bus_dmamap_sync(hba->io_dmat, 1949 srb->dma_map, BUS_DMASYNC_PREREAD); 1950 }else if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) { 1951 bus_dmamap_sync(hba->io_dmat, 1952 srb->dma_map, BUS_DMASYNC_PREWRITE); 1953 } 1954 1955 if (hba->firmware_version > 0x01020000 1956 || hba->interface_version > 0x01020000) { 1957 u_int32_t size_bits; 1958 1959 if (req->header.size < 256) 1960 size_bits = IOPMU_QUEUE_REQUEST_SIZE_BIT; 1961 else if (req->header.size < 512) 1962 size_bits = IOPMU_QUEUE_ADDR_HOST_BIT; 1963 else 1964 size_bits = IOPMU_QUEUE_REQUEST_SIZE_BIT 1965 | IOPMU_QUEUE_ADDR_HOST_BIT; 1966 1967 BUS_SPACE_WRT4_ITL(inbound_queue, 1968 (u_int32_t)srb->phy_addr | size_bits); 1969 } else 1970 BUS_SPACE_WRT4_ITL(inbound_queue, (u_int32_t)srb->phy_addr 1971 |IOPMU_QUEUE_ADDR_HOST_BIT); 1972 } 1973} 1974 1975static void hptiop_post_req_mv(struct hpt_iop_hba *hba, 1976 struct hpt_iop_srb *srb, 1977 bus_dma_segment_t *segs, int nsegs) 1978{ 1979 int idx, size; 1980 union ccb *ccb = srb->ccb; 1981 u_int8_t *cdb; 1982 struct hpt_iop_request_scsi_command *req; 1983 u_int64_t req_phy; 1984 1985 req = (struct hpt_iop_request_scsi_command *)srb; 1986 req_phy = srb->phy_addr; 1987 1988 if (ccb->csio.dxfer_len && nsegs > 0) { 1989 struct hpt_iopsg *psg = req->sg_list; 1990 for (idx = 0; idx < nsegs; idx++, psg++) { 1991 psg->pci_address = (u_int64_t)segs[idx].ds_addr; 1992 psg->size = segs[idx].ds_len; 1993 psg->eot = 0; 1994 } 1995 psg[-1].eot = 1; 1996 } 1997 if (ccb->ccb_h.flags & CAM_CDB_POINTER) 1998 cdb = ccb->csio.cdb_io.cdb_ptr; 1999 else 2000 cdb = ccb->csio.cdb_io.cdb_bytes; 2001 2002 bcopy(cdb, req->cdb, ccb->csio.cdb_len); 2003 req->header.type = IOP_REQUEST_TYPE_SCSI_COMMAND; 2004 req->header.result = IOP_RESULT_PENDING; 2005 req->dataxfer_length = ccb->csio.dxfer_len; 2006 req->channel = 0; 2007 req->target = ccb->ccb_h.target_id; 2008 req->lun = ccb->ccb_h.target_lun; 2009 req->header.size = sizeof(struct hpt_iop_request_scsi_command) 2010 - sizeof(struct hpt_iopsg) 2011 + nsegs * sizeof(struct hpt_iopsg); 2012 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 2013 bus_dmamap_sync(hba->io_dmat, 2014 srb->dma_map, BUS_DMASYNC_PREREAD); 2015 } 2016 else if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) 2017 bus_dmamap_sync(hba->io_dmat, 2018 srb->dma_map, BUS_DMASYNC_PREWRITE); 2019 req->header.context = (u_int64_t)srb->index 2020 << MVIOP_REQUEST_NUMBER_START_BIT 2021 | MVIOP_CMD_TYPE_SCSI; 2022 req->header.flags = IOP_REQUEST_FLAG_OUTPUT_CONTEXT; 2023 size = req->header.size >> 8; 2024 hptiop_mv_inbound_write(req_phy 2025 | MVIOP_MU_QUEUE_ADDR_HOST_BIT 2026 | (size > 3 ? 3 : size), hba); 2027} 2028 2029static void hptiop_post_scsi_command(void *arg, bus_dma_segment_t *segs, 2030 int nsegs, int error) 2031{ 2032 struct hpt_iop_srb *srb = (struct hpt_iop_srb *)arg; 2033 union ccb *ccb = srb->ccb; 2034 struct hpt_iop_hba *hba = srb->hba; 2035 2036 if (error || nsegs > hba->max_sg_count) { 2037 KdPrint(("hptiop: func_code=%x tid=%x lun=%x nsegs=%d\n", 2038 ccb->ccb_h.func_code, 2039 ccb->ccb_h.target_id, 2040 ccb->ccb_h.target_lun, nsegs)); 2041 ccb->ccb_h.status = CAM_BUSY; 2042 bus_dmamap_unload(hba->io_dmat, srb->dma_map); 2043 hptiop_free_srb(hba, srb); 2044 xpt_done(ccb); 2045 return; 2046 } 2047 2048 hba->ops->post_req(hba, srb, segs, nsegs); 2049} 2050 2051static void hptiop_mv_map_ctlcfg(void *arg, bus_dma_segment_t *segs, 2052 int nsegs, int error) 2053{ 2054 struct hpt_iop_hba *hba = (struct hpt_iop_hba *)arg; 2055 hba->ctlcfgcmd_phy = ((u_int64_t)segs->ds_addr + 0x1F) 2056 & ~(u_int64_t)0x1F; 2057 hba->ctlcfg_ptr = (u_int8_t *)(((unsigned long)hba->ctlcfg_ptr + 0x1F) 2058 & ~0x1F); 2059} 2060 2061static void hptiop_map_srb(void *arg, bus_dma_segment_t *segs, 2062 int nsegs, int error) 2063{ 2064 struct hpt_iop_hba * hba = (struct hpt_iop_hba *)arg; 2065 bus_addr_t phy_addr = (segs->ds_addr + 0x1F) & ~(bus_addr_t)0x1F; 2066 struct hpt_iop_srb *srb, *tmp_srb; 2067 int i; 2068 2069 if (error || nsegs == 0) { 2070 device_printf(hba->pcidev, "hptiop_map_srb error"); 2071 return; 2072 } 2073 2074 /* map srb */ 2075 srb = (struct hpt_iop_srb *) 2076 (((unsigned long)hba->uncached_ptr + 0x1F) 2077 & ~(unsigned long)0x1F); 2078 2079 for (i = 0; i < HPT_SRB_MAX_QUEUE_SIZE; i++) { 2080 tmp_srb = (struct hpt_iop_srb *) 2081 ((char *)srb + i * HPT_SRB_MAX_SIZE); 2082 if (((unsigned long)tmp_srb & 0x1F) == 0) { 2083 if (bus_dmamap_create(hba->io_dmat, 2084 0, &tmp_srb->dma_map)) { 2085 device_printf(hba->pcidev, "dmamap create failed"); 2086 return; 2087 } 2088 2089 bzero(tmp_srb, sizeof(struct hpt_iop_srb)); 2090 tmp_srb->hba = hba; 2091 tmp_srb->index = i; 2092 if (hba->ctlcfg_ptr == 0) {/*itl iop*/ 2093 tmp_srb->phy_addr = (u_int64_t)(u_int32_t) 2094 (phy_addr >> 5); 2095 if (phy_addr & IOPMU_MAX_MEM_SUPPORT_MASK_32G) 2096 tmp_srb->srb_flag = 2097 HPT_SRB_FLAG_HIGH_MEM_ACESS; 2098 } else { 2099 tmp_srb->phy_addr = phy_addr; 2100 } 2101 2102 hptiop_free_srb(hba, tmp_srb); 2103 hba->srb[i] = tmp_srb; 2104 phy_addr += HPT_SRB_MAX_SIZE; 2105 } 2106 else { 2107 device_printf(hba->pcidev, "invalid alignment"); 2108 return; 2109 } 2110 } 2111} 2112 2113static void hptiop_os_message_callback(struct hpt_iop_hba * hba, u_int32_t msg) 2114{ 2115 hba->msg_done = 1; 2116} 2117 2118static int hptiop_os_query_remove_device(struct hpt_iop_hba * hba, 2119 int target_id) 2120{ 2121 struct cam_periph *periph = NULL; 2122 struct cam_path *path; 2123 int status, retval = 0; 2124 2125 status = xpt_create_path(&path, NULL, hba->sim->path_id, target_id, 0); 2126 2127 if (status == CAM_REQ_CMP) { 2128 if ((periph = cam_periph_find(path, "da")) != NULL) { 2129 if (periph->refcount >= 1) { 2130 device_printf(hba->pcidev, "%d ," 2131 "target_id=0x%x," 2132 "refcount=%d", 2133 hba->pciunit, target_id, periph->refcount); 2134 retval = -1; 2135 } 2136 } 2137 xpt_free_path(path); 2138 } 2139 return retval; 2140} 2141 2142static void hptiop_release_resource(struct hpt_iop_hba *hba) 2143{ 2144 int i; 2145 if (hba->path) { 2146 struct ccb_setasync ccb; 2147 2148 xpt_setup_ccb(&ccb.ccb_h, hba->path, /*priority*/5); 2149 ccb.ccb_h.func_code = XPT_SASYNC_CB; 2150 ccb.event_enable = 0; 2151 ccb.callback = hptiop_async; 2152 ccb.callback_arg = hba->sim; 2153 xpt_action((union ccb *)&ccb); 2154 xpt_free_path(hba->path); 2155 } 2156 2157 if (hba->sim) { 2158 xpt_bus_deregister(cam_sim_path(hba->sim)); 2159 cam_sim_free(hba->sim, TRUE); 2160 } 2161 2162 if (hba->ctlcfg_dmat) { 2163 bus_dmamap_unload(hba->ctlcfg_dmat, hba->ctlcfg_dmamap); 2164 bus_dmamem_free(hba->ctlcfg_dmat, 2165 hba->ctlcfg_ptr, hba->ctlcfg_dmamap); 2166 bus_dma_tag_destroy(hba->ctlcfg_dmat); 2167 } 2168 2169 for (i = 0; i < HPT_SRB_MAX_QUEUE_SIZE; i++) { 2170 struct hpt_iop_srb *srb = hba->srb[i]; 2171 if (srb->dma_map) 2172 bus_dmamap_destroy(hba->io_dmat, srb->dma_map); 2173 } 2174 2175 if (hba->srb_dmat) { 2176 bus_dmamap_unload(hba->srb_dmat, hba->srb_dmamap); 2177 bus_dmamap_destroy(hba->srb_dmat, hba->srb_dmamap); 2178 bus_dma_tag_destroy(hba->srb_dmat); 2179 } 2180 2181 if (hba->io_dmat) 2182 bus_dma_tag_destroy(hba->io_dmat); 2183 2184 if (hba->parent_dmat) 2185 bus_dma_tag_destroy(hba->parent_dmat); 2186 2187 if (hba->irq_handle) 2188 bus_teardown_intr(hba->pcidev, hba->irq_res, hba->irq_handle); 2189 2190 if (hba->irq_res) 2191 bus_release_resource(hba->pcidev, SYS_RES_IRQ, 2192 0, hba->irq_res); 2193 2194 if (hba->bar0_res) 2195 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 2196 hba->bar0_rid, hba->bar0_res); 2197 if (hba->bar2_res) 2198 bus_release_resource(hba->pcidev, SYS_RES_MEMORY, 2199 hba->bar2_rid, hba->bar2_res); 2200 if (hba->ioctl_dev) 2201 destroy_dev(hba->ioctl_dev); 2202} 2203