1 /* 2 * Copyright (c) 2004-2005 HighPoint Technologies, Inc. 3 * 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 * $FreeBSD$ 27 */ 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/kernel.h> 32 #include <sys/bus.h> 33 #include <sys/malloc.h> 34 #include <sys/resource.h> 35 #include <sys/time.h> 36 #include <sys/callout.h> 37 #include <sys/signalvar.h> 38 #include <sys/eventhandler.h> 39 #include <sys/proc.h> 40 #include <sys/kthread.h> 41 42 #if (__FreeBSD_version >= 500000) 43 #include <sys/mutex.h> 44 #include <sys/module.h> 45 #endif 46 47 #if (__FreeBSD_version >= 500000) 48 #include <dev/pci/pcireg.h> 49 #include <dev/pci/pcivar.h> 50 #else 51 #include <pci/pcireg.h> 52 #include <pci/pcivar.h> 53 #include <sys/wait.h> 54 #include <sys/sysproto.h> 55 #endif 56 57 #ifndef __KERNEL__ 58 #define __KERNEL__ 59 #endif 60 61 #include <dev/hptmv/global.h> 62 #include <dev/hptmv/hptintf.h> 63 #include <dev/hptmv/osbsd.h> 64 #include <dev/hptmv/access601.h> 65 66 67 #ifdef DEBUG 68 #ifdef DEBUG_LEVEL 69 int hpt_dbg_level = DEBUG_LEVEL; 70 #else 71 int hpt_dbg_level = 0; 72 #endif 73 #endif 74 75 #define MV_ERROR printf 76 77 /* 78 * CAM SIM entry points 79 */ 80 static int hpt_probe (device_t dev); 81 static void launch_worker_thread(void); 82 static int hpt_attach(device_t dev); 83 static int hpt_detach(device_t dev); 84 static int hpt_shutdown(device_t dev); 85 static void hpt_poll(struct cam_sim *sim); 86 static void hpt_intr(void *arg); 87 static void hpt_async(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg); 88 static void hpt_action(struct cam_sim *sim, union ccb *ccb); 89 90 static device_method_t driver_methods[] = { 91 /* Device interface */ 92 DEVMETHOD(device_probe, hpt_probe), 93 DEVMETHOD(device_attach, hpt_attach), 94 DEVMETHOD(device_detach, hpt_detach), 95 96 /* DEVMETHOD(device_shutdown, hpt_shutdown), */ 97 { 0, 0 } 98 }; 99 100 static driver_t hpt_pci_driver = { 101 __str(PROC_DIR_NAME), 102 driver_methods, 103 sizeof(IAL_ADAPTER_T) 104 }; 105 106 static devclass_t hpt_devclass; 107 108 #define __DRIVER_MODULE(p1, p2, p3, p4, p5, p6) DRIVER_MODULE(p1, p2, p3, p4, p5, p6) 109 __DRIVER_MODULE(PROC_DIR_NAME, pci, hpt_pci_driver, hpt_devclass, 0, 0); 110 111 #define ccb_ccb_ptr spriv_ptr0 112 #define ccb_adapter ccb_h.spriv_ptr1 113 114 static void SetInquiryData(PINQUIRYDATA inquiryData, PVDevice pVDev); 115 static void HPTLIBAPI OsSendCommand (_VBUS_ARG union ccb * ccb); 116 static void HPTLIBAPI fOsCommandDone(_VBUS_ARG PCommand pCmd); 117 static void ccb_done(union ccb *ccb); 118 static void hpt_queue_ccb(union ccb **ccb_Q, union ccb *ccb); 119 static void hpt_free_ccb(union ccb **ccb_Q, union ccb *ccb); 120 static void hptmv_free_edma_queues(IAL_ADAPTER_T *pAdapter); 121 static void hptmv_free_channel(IAL_ADAPTER_T *pAdapter, MV_U8 channelNum); 122 static void handleEdmaError(_VBUS_ARG PCommand pCmd); 123 static int hptmv_init_channel(IAL_ADAPTER_T *pAdapter, MV_U8 channelNum); 124 static int fResetActiveCommands(PVBus _vbus_p); 125 static void fRegisterVdevice(IAL_ADAPTER_T *pAdapter); 126 static int hptmv_allocate_edma_queues(IAL_ADAPTER_T *pAdapter); 127 static void hptmv_handle_event_disconnect(void *data); 128 static void hptmv_handle_event_connect(void *data); 129 static int start_channel(IAL_ADAPTER_T *pAdapter, MV_U8 channelNum); 130 static void init_vdev_params(IAL_ADAPTER_T *pAdapter, MV_U8 channel); 131 static int hptmv_parse_identify_results(MV_SATA_CHANNEL *pMvSataChannel); 132 static int HPTLIBAPI fOsBuildSgl(_VBUS_ARG PCommand pCmd, FPSCAT_GATH pSg, 133 int logical); 134 static MV_BOOLEAN CommandCompletionCB(MV_SATA_ADAPTER *pMvSataAdapter, 135 MV_U8 channelNum, MV_COMPLETION_TYPE comp_type, MV_VOID_PTR commandId, 136 MV_U16 responseFlags, MV_U32 timeStamp, 137 MV_STORAGE_DEVICE_REGISTERS *registerStruct); 138 static MV_BOOLEAN hptmv_event_notify(MV_SATA_ADAPTER *pMvSataAdapter, 139 MV_EVENT_TYPE eventType, MV_U32 param1, MV_U32 param2); 140 141 #define ccb_ccb_ptr spriv_ptr0 142 #define ccb_adapter ccb_h.spriv_ptr1 143 144 IAL_ADAPTER_T *gIal_Adapter = 0; 145 IAL_ADAPTER_T *pCurAdapter = 0; 146 static MV_SATA_CHANNEL gMvSataChannels[MAX_VBUS][MV_SATA_CHANNELS_NUM]; 147 148 typedef struct st_HPT_DPC { 149 IAL_ADAPTER_T *pAdapter; 150 void (*dpc)(IAL_ADAPTER_T *, void *, UCHAR); 151 void *arg; 152 UCHAR flags; 153 } ST_HPT_DPC; 154 155 #define MAX_DPC 16 156 UCHAR DPC_Request_Nums = 0; 157 static ST_HPT_DPC DpcQueue[MAX_DPC]; 158 static int DpcQueue_First=0; 159 static int DpcQueue_Last = 0; 160 161 char DRIVER_VERSION[] = "v1.12"; 162 163 #if (__FreeBSD_version >= 500000) 164 static struct mtx driver_lock; 165 intrmask_t lock_driver() 166 { 167 168 intrmask_t spl = 0; 169 mtx_lock(&driver_lock); 170 return spl; 171 } 172 void unlock_driver(intrmask_t spl) 173 { 174 mtx_unlock(&driver_lock); 175 } 176 #else 177 static int driver_locked = 0; 178 intrmask_t lock_driver() 179 { 180 intrmask_t spl = splcam(); 181 loop: 182 while (driver_locked) 183 tsleep(&driver_locked, PRIBIO, "hptlck", hz); 184 atomic_add_int(&driver_locked, 1); 185 if (driver_locked>1) { 186 atomic_subtract_int(&driver_locked, 1); 187 goto loop; 188 } 189 return spl; 190 } 191 192 void unlock_driver(intrmask_t spl) 193 { 194 atomic_subtract_int(&driver_locked, 1); 195 if (driver_locked==0) { 196 wakeup(&driver_locked); 197 } 198 splx(spl); 199 } 200 #endif 201 202 /******************************************************************************* 203 * Name: hptmv_free_channel 204 * 205 * Description: free allocated queues for the given channel 206 * 207 * Parameters: pMvSataAdapter - pointer to the RR182x controler this 208 * channel connected to. 209 * channelNum - channel number. 210 * 211 ******************************************************************************/ 212 static void 213 hptmv_free_channel(IAL_ADAPTER_T *pAdapter, MV_U8 channelNum) 214 { 215 HPT_ASSERT(channelNum < MV_SATA_CHANNELS_NUM); 216 pAdapter->mvSataAdapter.sataChannel[channelNum] = NULL; 217 } 218 219 static void failDevice(PVDevice pVDev) 220 { 221 PVBus _vbus_p = pVDev->pVBus; 222 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)_vbus_p->OsExt; 223 224 pVDev->u.disk.df_on_line = 0; 225 pVDev->vf_online = 0; 226 if (pVDev->pfnDeviceFailed) 227 CallWhenIdle(_VBUS_P (DPC_PROC)pVDev->pfnDeviceFailed, pVDev); 228 229 fNotifyGUI(ET_DEVICE_REMOVED, pVDev); 230 231 #ifndef FOR_DEMO 232 if (pAdapter->ver_601==2 && !pAdapter->beeping) { 233 pAdapter->beeping = 1; 234 BeepOn(pAdapter->mvSataAdapter.adapterIoBaseAddress); 235 set_fail_led(&pAdapter->mvSataAdapter, pVDev->u.disk.mv->channelNumber, 1); 236 } 237 #endif 238 } 239 240 int MvSataResetChannel(MV_SATA_ADAPTER *pMvSataAdapter, MV_U8 channel); 241 /*void fDeviceSendCommand(_VBUS_ARG PCommand pCmd); */ 242 243 static void 244 handleEdmaError(_VBUS_ARG PCommand pCmd) 245 { 246 PDevice pDevice = &pCmd->pVDevice->u.disk; 247 MV_SATA_ADAPTER * pSataAdapter = pDevice->mv->mvSataAdapter; 248 249 if (!pDevice->df_on_line) { 250 KdPrint(("Device is offline")); 251 pCmd->Result = RETURN_BAD_DEVICE; 252 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 253 return; 254 } 255 256 if (pCmd->RetryCount++>5) { 257 hpt_printk(("too many retries on channel(%d)\n", pDevice->mv->channelNumber)); 258 failed: 259 failDevice(pCmd->pVDevice); 260 pCmd->Result = RETURN_IDE_ERROR; 261 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 262 return; 263 } 264 265 /* reset the channel and retry the command */ 266 if (MvSataResetChannel(pSataAdapter, pDevice->mv->channelNumber)) 267 goto failed; 268 269 fNotifyGUI(ET_DEVICE_ERROR, Map2pVDevice(pDevice)); 270 271 hpt_printk(("Retry on channel(%d)\n", pDevice->mv->channelNumber)); 272 fDeviceSendCommand(_VBUS_P pCmd); 273 } 274 275 /**************************************************************** 276 * Name: hptmv_init_channel 277 * 278 * Description: allocate request and response queues for the EDMA of the 279 * given channel and sets other fields. 280 * 281 * Parameters: 282 * pAdapter - pointer to the emulated adapter data structure 283 * channelNum - channel number. 284 * Return: 0 on success, otherwise on failure 285 ****************************************************************/ 286 static int 287 hptmv_init_channel(IAL_ADAPTER_T *pAdapter, MV_U8 channelNum) 288 { 289 MV_SATA_CHANNEL *pMvSataChannel; 290 dma_addr_t req_dma_addr; 291 dma_addr_t rsp_dma_addr; 292 293 if (channelNum >= MV_SATA_CHANNELS_NUM) 294 { 295 MV_ERROR("RR182x[%d]: Bad channelNum=%d", 296 pAdapter->mvSataAdapter.adapterId, channelNum); 297 return -1; 298 } 299 300 pMvSataChannel = &gMvSataChannels[pAdapter->mvSataAdapter.adapterId][channelNum]; 301 pAdapter->mvSataAdapter.sataChannel[channelNum] = pMvSataChannel; 302 pMvSataChannel->channelNumber = channelNum; 303 pMvSataChannel->lba48Address = MV_FALSE; 304 pMvSataChannel->maxReadTransfer = MV_FALSE; 305 306 pMvSataChannel->requestQueue = (struct mvDmaRequestQueueEntry *) 307 (pAdapter->requestsArrayBaseAlignedAddr + (channelNum * MV_EDMA_REQUEST_QUEUE_SIZE)); 308 req_dma_addr = pAdapter->requestsArrayBaseDmaAlignedAddr + (channelNum * MV_EDMA_REQUEST_QUEUE_SIZE); 309 310 311 KdPrint(("requestQueue addr is 0x%llX", (HPT_U64)(ULONG_PTR)req_dma_addr)); 312 313 /* check the 1K alignment of the request queue*/ 314 if (req_dma_addr & 0x3ff) 315 { 316 MV_ERROR("RR182x[%d]: request queue allocated isn't 1 K aligned," 317 " dma_addr=%llx channel=%d\n", pAdapter->mvSataAdapter.adapterId, 318 (HPT_U64)(ULONG_PTR)req_dma_addr, channelNum); 319 return -1; 320 } 321 pMvSataChannel->requestQueuePciLowAddress = req_dma_addr; 322 pMvSataChannel->requestQueuePciHiAddress = 0; 323 KdPrint(("RR182x[%d,%d]: request queue allocated: 0x%p", 324 pAdapter->mvSataAdapter.adapterId, channelNum, 325 pMvSataChannel->requestQueue)); 326 pMvSataChannel->responseQueue = (struct mvDmaResponseQueueEntry *) 327 (pAdapter->responsesArrayBaseAlignedAddr + (channelNum * MV_EDMA_RESPONSE_QUEUE_SIZE)); 328 rsp_dma_addr = pAdapter->responsesArrayBaseDmaAlignedAddr + (channelNum * MV_EDMA_RESPONSE_QUEUE_SIZE); 329 330 /* check the 256 alignment of the response queue*/ 331 if (rsp_dma_addr & 0xff) 332 { 333 MV_ERROR("RR182x[%d,%d]: response queue allocated isn't 256 byte " 334 "aligned, dma_addr=%llx\n", 335 pAdapter->mvSataAdapter.adapterId, channelNum, (HPT_U64)(ULONG_PTR)rsp_dma_addr); 336 return -1; 337 } 338 pMvSataChannel->responseQueuePciLowAddress = rsp_dma_addr; 339 pMvSataChannel->responseQueuePciHiAddress = 0; 340 KdPrint(("RR182x[%d,%d]: response queue allocated: 0x%p", 341 pAdapter->mvSataAdapter.adapterId, channelNum, 342 pMvSataChannel->responseQueue)); 343 344 pAdapter->mvChannel[channelNum].online = MV_TRUE; 345 return 0; 346 } 347 348 /****************************************************************************** 349 * Name: hptmv_parse_identify_results 350 * 351 * Description: this functions parses the identify command results, checks 352 * that the connected deives can be accesed by RR182x EDMA, 353 * and updates the channel stucture accordingly. 354 * 355 * Parameters: pMvSataChannel, pointer to the channel data structure. 356 * 357 * Returns: =0 ->success, < 0 ->failure. 358 * 359 ******************************************************************************/ 360 static int 361 hptmv_parse_identify_results(MV_SATA_CHANNEL *pMvSataChannel) 362 { 363 MV_U16 *iden = pMvSataChannel->identifyDevice; 364 365 /*LBA addressing*/ 366 if (! (iden[IDEN_CAPACITY_1_OFFSET] & 0x200)) 367 { 368 KdPrint(("IAL Error in IDENTIFY info: LBA not supported\n")); 369 return -1; 370 } 371 else 372 { 373 KdPrint(("%25s - %s\n", "Capabilities", "LBA supported")); 374 } 375 /*DMA support*/ 376 if (! (iden[IDEN_CAPACITY_1_OFFSET] & 0x100)) 377 { 378 KdPrint(("IAL Error in IDENTIFY info: DMA not supported\n")); 379 return -1; 380 } 381 else 382 { 383 KdPrint(("%25s - %s\n", "Capabilities", "DMA supported")); 384 } 385 /* PIO */ 386 if ((iden[IDEN_VALID] & 2) == 0) 387 { 388 KdPrint(("IAL Error in IDENTIFY info: not able to find PIO mode\n")); 389 return -1; 390 } 391 KdPrint(("%25s - 0x%02x\n", "PIO modes supported", 392 iden[IDEN_PIO_MODE_SPPORTED] & 0xff)); 393 394 /*UDMA*/ 395 if ((iden[IDEN_VALID] & 4) == 0) 396 { 397 KdPrint(("IAL Error in IDENTIFY info: not able to find UDMA mode\n")); 398 return -1; 399 } 400 401 /* 48 bit address */ 402 if ((iden[IDEN_SUPPORTED_COMMANDS2] & 0x400)) 403 { 404 KdPrint(("%25s - %s\n", "LBA48 addressing", "supported")); 405 pMvSataChannel->lba48Address = MV_TRUE; 406 } 407 else 408 { 409 KdPrint(("%25s - %s\n", "LBA48 addressing", "Not supported")); 410 pMvSataChannel->lba48Address = MV_FALSE; 411 } 412 return 0; 413 } 414 415 static void 416 init_vdev_params(IAL_ADAPTER_T *pAdapter, MV_U8 channel) 417 { 418 PVDevice pVDev = &pAdapter->VDevices[channel]; 419 MV_SATA_CHANNEL *pMvSataChannel = pAdapter->mvSataAdapter.sataChannel[channel]; 420 MV_U16_PTR IdentifyData = pMvSataChannel->identifyDevice; 421 422 pMvSataChannel->outstandingCommands = 0; 423 424 pVDev->u.disk.mv = pMvSataChannel; 425 pVDev->u.disk.df_on_line = 1; 426 pVDev->u.disk.pVBus = &pAdapter->VBus; 427 pVDev->pVBus = &pAdapter->VBus; 428 429 #ifdef SUPPORT_48BIT_LBA 430 if (pMvSataChannel->lba48Address == MV_TRUE) 431 pVDev->u.disk.dDeRealCapacity = ((IdentifyData[101]<<16) | IdentifyData[100]) - 1; 432 else 433 #endif 434 if(IdentifyData[53] & 1) { 435 pVDev->u.disk.dDeRealCapacity = 436 (((IdentifyData[58]<<16 | IdentifyData[57]) < (IdentifyData[61]<<16 | IdentifyData[60])) ? 437 (IdentifyData[61]<<16 | IdentifyData[60]) : 438 (IdentifyData[58]<<16 | IdentifyData[57])) - 1; 439 } else 440 pVDev->u.disk.dDeRealCapacity = 441 (IdentifyData[61]<<16 | IdentifyData[60]) - 1; 442 443 pVDev->u.disk.bDeUsable_Mode = pVDev->u.disk.bDeModeSetting = 444 pAdapter->mvChannel[channel].maxPioModeSupported - MV_ATA_TRANSFER_PIO_0; 445 446 if (pAdapter->mvChannel[channel].maxUltraDmaModeSupported!=0xFF) { 447 pVDev->u.disk.bDeUsable_Mode = pVDev->u.disk.bDeModeSetting = 448 pAdapter->mvChannel[channel].maxUltraDmaModeSupported - MV_ATA_TRANSFER_UDMA_0 + 8; 449 } 450 } 451 452 static void device_change(IAL_ADAPTER_T *pAdapter , MV_U8 channelIndex, int plugged) 453 { 454 PVDevice pVDev; 455 MV_SATA_ADAPTER *pMvSataAdapter = &pAdapter->mvSataAdapter; 456 MV_SATA_CHANNEL *pMvSataChannel = pMvSataAdapter->sataChannel[channelIndex]; 457 458 if (!pMvSataChannel) return; 459 460 if (plugged) 461 { 462 pVDev = &(pAdapter->VDevices[channelIndex]); 463 init_vdev_params(pAdapter, channelIndex); 464 465 pVDev->VDeviceType = pVDev->u.disk.df_atapi? VD_ATAPI : 466 pVDev->u.disk.df_removable_drive? VD_REMOVABLE : VD_SINGLE_DISK; 467 468 pVDev->VDeviceCapacity = pVDev->u.disk.dDeRealCapacity-SAVE_FOR_RAID_INFO; 469 pVDev->pfnSendCommand = pfnSendCommand[pVDev->VDeviceType]; 470 pVDev->pfnDeviceFailed = pfnDeviceFailed[pVDev->VDeviceType]; 471 pVDev->vf_online = 1; 472 473 #ifdef SUPPORT_ARRAY 474 if(pVDev->pParent) 475 { 476 int iMember; 477 for(iMember = 0; iMember < pVDev->pParent->u.array.bArnMember; iMember++) 478 if((PVDevice)pVDev->pParent->u.array.pMember[iMember] == pVDev) 479 pVDev->pParent->u.array.pMember[iMember] = NULL; 480 pVDev->pParent = NULL; 481 } 482 #endif 483 fNotifyGUI(ET_DEVICE_PLUGGED,pVDev); 484 fCheckBootable(pVDev); 485 RegisterVDevice(pVDev); 486 487 #ifndef FOR_DEMO 488 if (pAdapter->beeping) { 489 pAdapter->beeping = 0; 490 BeepOff(pAdapter->mvSataAdapter.adapterIoBaseAddress); 491 } 492 #endif 493 494 } 495 else 496 { 497 pVDev = &(pAdapter->VDevices[channelIndex]); 498 failDevice(pVDev); 499 } 500 } 501 502 static int 503 start_channel(IAL_ADAPTER_T *pAdapter, MV_U8 channelNum) 504 { 505 MV_SATA_ADAPTER *pMvSataAdapter = &pAdapter->mvSataAdapter; 506 MV_SATA_CHANNEL *pMvSataChannel = pMvSataAdapter->sataChannel[channelNum]; 507 MV_CHANNEL *pChannelInfo = &(pAdapter->mvChannel[channelNum]); 508 MV_U32 udmaMode,pioMode; 509 510 KdPrint(("RR182x [%d]: start channel (%d)", pMvSataAdapter->adapterId, 511 channelNum)); 512 513 514 /* Software reset channel */ 515 if (mvStorageDevATASoftResetDevice(pMvSataAdapter, channelNum) == MV_FALSE) 516 { 517 MV_ERROR("RR182x [%d,%d]: failed to perform Software reset\n", 518 pMvSataAdapter->adapterId, channelNum); 519 return -1; 520 } 521 522 /* Hardware reset channel */ 523 if (mvSataChannelHardReset(pMvSataAdapter, channelNum) == MV_FALSE) 524 { 525 /* If failed, try again - this is when trying to hardreset a channel */ 526 /* when drive is just spinning up */ 527 StallExec(5000000); /* wait 5 sec before trying again */ 528 if (mvSataChannelHardReset(pMvSataAdapter, channelNum) == MV_FALSE) 529 { 530 MV_ERROR("RR182x [%d,%d]: failed to perform Hard reset\n", 531 pMvSataAdapter->adapterId, channelNum); 532 return -1; 533 } 534 } 535 536 /* identify device*/ 537 if (mvStorageDevATAIdentifyDevice(pMvSataAdapter, channelNum) == MV_FALSE) 538 { 539 MV_ERROR("RR182x [%d,%d]: failed to perform ATA Identify command\n" 540 , pMvSataAdapter->adapterId, channelNum); 541 return -1; 542 } 543 if (hptmv_parse_identify_results(pMvSataChannel)) 544 { 545 MV_ERROR("RR182x [%d,%d]: Error in parsing ATA Identify message\n" 546 , pMvSataAdapter->adapterId, channelNum); 547 return -1; 548 } 549 550 /* mvStorageDevATASetFeatures */ 551 /* Disable 8 bit PIO in case CFA enabled */ 552 if (pMvSataChannel->identifyDevice[86] & 4) 553 { 554 KdPrint(("RR182x [%d]: Disable 8 bit PIO (CFA enabled) \n", 555 pMvSataAdapter->adapterId)); 556 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 557 MV_ATA_SET_FEATURES_DISABLE_8_BIT_PIO, 0, 558 0, 0, 0) == MV_FALSE) 559 { 560 MV_ERROR("RR182x [%d]: channel %d: mvStorageDevATASetFeatures" 561 " failed\n", pMvSataAdapter->adapterId, channelNum); 562 return -1; 563 } 564 } 565 /* Write cache */ 566 #ifdef ENABLE_WRITE_CACHE 567 if (pMvSataChannel->identifyDevice[82] & 0x20) 568 { 569 if (!(pMvSataChannel->identifyDevice[85] & 0x20)) /* if not enabled by default */ 570 { 571 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 572 MV_ATA_SET_FEATURES_ENABLE_WCACHE, 0, 573 0, 0, 0) == MV_FALSE) 574 { 575 MV_ERROR("RR182x [%d]: channel %d: mvStorageDevATASetFeatures failed\n", 576 pMvSataAdapter->adapterId, channelNum); 577 return -1; 578 } 579 } 580 KdPrint(("RR182x [%d]: channel %d, write cache enabled\n", 581 pMvSataAdapter->adapterId, channelNum)); 582 } 583 else 584 { 585 KdPrint(("RR182x [%d]: channel %d, write cache not supported\n", 586 pMvSataAdapter->adapterId, channelNum)); 587 } 588 #else /* disable write cache */ 589 { 590 if (pMvSataChannel->identifyDevice[85] & 0x20) 591 { 592 KdPrint(("RR182x [%d]: channel =%d, disable write cache\n", 593 pMvSataAdapter->adapterId, channelNum)); 594 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 595 MV_ATA_SET_FEATURES_DISABLE_WCACHE, 0, 596 0, 0, 0) == MV_FALSE) 597 { 598 MV_ERROR("RR182x [%d]: channel %d: mvStorageDevATASetFeatures failed\n", 599 pMvSataAdapter->adapterId, channelNum); 600 return -1; 601 } 602 } 603 KdPrint(("RR182x [%d]: channel=%d, write cache disabled\n", 604 pMvSataAdapter->adapterId, channelNum)); 605 } 606 #endif 607 608 /* Set transfer mode */ 609 KdPrint(("RR182x [%d] Set transfer mode XFER_PIO_SLOW\n", 610 pMvSataAdapter->adapterId)); 611 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 612 MV_ATA_SET_FEATURES_TRANSFER, 613 MV_ATA_TRANSFER_PIO_SLOW, 0, 0, 0) == 614 MV_FALSE) 615 { 616 MV_ERROR("RR182x [%d] channel %d: Set Features failed\n", 617 pMvSataAdapter->adapterId, channelNum); 618 return -1; 619 } 620 621 if (pMvSataChannel->identifyDevice[IDEN_PIO_MODE_SPPORTED] & 1) 622 { 623 pioMode = MV_ATA_TRANSFER_PIO_4; 624 } 625 else if (pMvSataChannel->identifyDevice[IDEN_PIO_MODE_SPPORTED] & 2) 626 { 627 pioMode = MV_ATA_TRANSFER_PIO_3; 628 } 629 else 630 { 631 MV_ERROR("IAL Error in IDENTIFY info: PIO modes 3 and 4 not supported\n"); 632 pioMode = MV_ATA_TRANSFER_PIO_SLOW; 633 } 634 635 KdPrint(("RR182x [%d] Set transfer mode XFER_PIO_4\n", 636 pMvSataAdapter->adapterId)); 637 pAdapter->mvChannel[channelNum].maxPioModeSupported = pioMode; 638 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 639 MV_ATA_SET_FEATURES_TRANSFER, 640 pioMode, 0, 0, 0) == MV_FALSE) 641 { 642 MV_ERROR("RR182x [%d] channel %d: Set Features failed\n", 643 pMvSataAdapter->adapterId, channelNum); 644 return -1; 645 } 646 647 udmaMode = MV_ATA_TRANSFER_UDMA_0; 648 if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 0x40) 649 { 650 udmaMode = MV_ATA_TRANSFER_UDMA_6; 651 } 652 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 0x20) 653 { 654 udmaMode = MV_ATA_TRANSFER_UDMA_5; 655 } 656 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 0x10) 657 { 658 udmaMode = MV_ATA_TRANSFER_UDMA_4; 659 } 660 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 8) 661 { 662 udmaMode = MV_ATA_TRANSFER_UDMA_3; 663 } 664 else if (pMvSataChannel->identifyDevice[IDEN_UDMA_MODE] & 4) 665 { 666 udmaMode = MV_ATA_TRANSFER_UDMA_2; 667 } 668 669 KdPrint(("RR182x [%d] Set transfer mode XFER_UDMA_%d\n", 670 pMvSataAdapter->adapterId, udmaMode & 0xf)); 671 pChannelInfo->maxUltraDmaModeSupported = udmaMode; 672 673 /*if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 674 MV_ATA_SET_FEATURES_TRANSFER, udmaMode, 675 0, 0, 0) == MV_FALSE) 676 { 677 MV_ERROR("RR182x [%d] channel %d: Set Features failed\n", 678 pMvSataAdapter->adapterId, channelNum); 679 return -1; 680 }*/ 681 if (pChannelInfo->maxUltraDmaModeSupported == 0xFF) 682 return TRUE; 683 else 684 do 685 { 686 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 687 MV_ATA_SET_FEATURES_TRANSFER, 688 pChannelInfo->maxUltraDmaModeSupported, 689 0, 0, 0) == MV_FALSE) 690 { 691 if (pChannelInfo->maxUltraDmaModeSupported > MV_ATA_TRANSFER_UDMA_0) 692 { 693 if (mvStorageDevATASoftResetDevice(pMvSataAdapter, channelNum) == MV_FALSE) 694 { 695 MV_REG_WRITE_BYTE(pMvSataAdapter->adapterIoBaseAddress, 696 pMvSataChannel->eDmaRegsOffset + 697 0x11c, /* command reg */ 698 MV_ATA_COMMAND_IDLE_IMMEDIATE); 699 mvMicroSecondsDelay(10000); 700 mvSataChannelHardReset(pMvSataAdapter, channelNum); 701 if (mvStorageDevATASoftResetDevice(pMvSataAdapter, channelNum) == MV_FALSE) 702 return FALSE; 703 } 704 if (mvSataChannelHardReset(pMvSataAdapter, channelNum) == MV_FALSE) 705 return FALSE; 706 pChannelInfo->maxUltraDmaModeSupported--; 707 continue; 708 } 709 else return FALSE; 710 } 711 break; 712 }while (1); 713 714 /* Read look ahead */ 715 #ifdef ENABLE_READ_AHEAD 716 if (pMvSataChannel->identifyDevice[82] & 0x40) 717 { 718 if (!(pMvSataChannel->identifyDevice[85] & 0x40)) /* if not enabled by default */ 719 { 720 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 721 MV_ATA_SET_FEATURES_ENABLE_RLA, 0, 0, 722 0, 0) == MV_FALSE) 723 { 724 MV_ERROR("RR182x [%d] channel %d: Set Features failed\n", 725 pMvSataAdapter->adapterId, channelNum); 726 return -1; 727 } 728 } 729 KdPrint(("RR182x [%d]: channel=%d, read look ahead enabled\n", 730 pMvSataAdapter->adapterId, channelNum)); 731 } 732 else 733 { 734 KdPrint(("RR182x [%d]: channel %d, Read Look Ahead not supported\n", 735 pMvSataAdapter->adapterId, channelNum)); 736 } 737 #else 738 { 739 if (pMvSataChannel->identifyDevice[86] & 0x20) 740 { 741 KdPrint(("RR182x [%d]:channel %d, disable read look ahead\n", 742 pMvSataAdapter->adapterId, channelNum)); 743 if (mvStorageDevATASetFeatures(pMvSataAdapter, channelNum, 744 MV_ATA_SET_FEATURES_DISABLE_RLA, 0, 0, 745 0, 0) == MV_FALSE) 746 { 747 MV_ERROR("RR182x [%d]:channel %d: ATA Set Features failed\n", 748 pMvSataAdapter->adapterId, channelNum); 749 return -1; 750 } 751 } 752 KdPrint(("RR182x [%d]:channel %d, read look ahead disabled\n", 753 pMvSataAdapter->adapterId, channelNum)); 754 } 755 #endif 756 757 758 { 759 KdPrint(("RR182x [%d]: channel %d config EDMA, Non Queued Mode\n", 760 pMvSataAdapter->adapterId, 761 channelNum)); 762 if (mvSataConfigEdmaMode(pMvSataAdapter, channelNum, 763 MV_EDMA_MODE_NOT_QUEUED, 0) == MV_FALSE) 764 { 765 MV_ERROR("RR182x [%d] channel %d Error: mvSataConfigEdmaMode failed\n", 766 pMvSataAdapter->adapterId, channelNum); 767 return -1; 768 } 769 } 770 /* Enable EDMA */ 771 if (mvSataEnableChannelDma(pMvSataAdapter, channelNum) == MV_FALSE) 772 { 773 MV_ERROR("RR182x [%d] Failed to enable DMA, channel=%d\n", 774 pMvSataAdapter->adapterId, channelNum); 775 return -1; 776 } 777 MV_ERROR("RR182x [%d,%d]: channel started successfully\n", 778 pMvSataAdapter->adapterId, channelNum); 779 780 #ifndef FOR_DEMO 781 set_fail_led(pMvSataAdapter, channelNum, 0); 782 #endif 783 return 0; 784 } 785 786 static void 787 hptmv_handle_event(void * data, int flag) 788 { 789 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)data; 790 MV_SATA_ADAPTER *pMvSataAdapter = &pAdapter->mvSataAdapter; 791 MV_U8 channelIndex; 792 793 /* mvOsSemTake(&pMvSataAdapter->semaphore); */ 794 for (channelIndex = 0; channelIndex < MV_SATA_CHANNELS_NUM; channelIndex++) 795 { 796 switch(pAdapter->sataEvents[channelIndex]) 797 { 798 case SATA_EVENT_CHANNEL_CONNECTED: 799 /* Handle only connects */ 800 if (flag == 1) 801 break; 802 KdPrint(("RR182x [%d,%d]: new device connected\n", 803 pMvSataAdapter->adapterId, channelIndex)); 804 hptmv_init_channel(pAdapter, channelIndex); 805 if (mvSataConfigureChannel( pMvSataAdapter, channelIndex) == MV_FALSE) 806 { 807 MV_ERROR("RR182x [%d,%d] Failed to configure\n", 808 pMvSataAdapter->adapterId, channelIndex); 809 hptmv_free_channel(pAdapter, channelIndex); 810 } 811 else 812 { 813 /*mvSataChannelHardReset(pMvSataAdapter, channel);*/ 814 if (start_channel( pAdapter, channelIndex)) 815 { 816 MV_ERROR("RR182x [%d,%d]Failed to start channel\n", 817 pMvSataAdapter->adapterId, channelIndex); 818 hptmv_free_channel(pAdapter, channelIndex); 819 } 820 else 821 { 822 device_change(pAdapter, channelIndex, TRUE); 823 } 824 } 825 pAdapter->sataEvents[channelIndex] = SATA_EVENT_NO_CHANGE; 826 break; 827 828 case SATA_EVENT_CHANNEL_DISCONNECTED: 829 /* Handle only disconnects */ 830 if (flag == 0) 831 break; 832 KdPrint(("RR182x [%d,%d]: device disconnected\n", 833 pMvSataAdapter->adapterId, channelIndex)); 834 /* Flush pending commands */ 835 if(pMvSataAdapter->sataChannel[channelIndex]) 836 { 837 _VBUS_INST(&pAdapter->VBus) 838 mvSataFlushDmaQueue (pMvSataAdapter, channelIndex, 839 MV_FLUSH_TYPE_CALLBACK); 840 CheckPendingCall(_VBUS_P0); 841 mvSataRemoveChannel(pMvSataAdapter,channelIndex); 842 hptmv_free_channel(pAdapter, channelIndex); 843 pMvSataAdapter->sataChannel[channelIndex] = NULL; 844 KdPrint(("RR182x [%d,%d]: channel removed\n", 845 pMvSataAdapter->adapterId, channelIndex)); 846 if (pAdapter->outstandingCommands==0 && DPC_Request_Nums==0) 847 Check_Idle_Call(pAdapter); 848 } 849 else 850 { 851 KdPrint(("RR182x [%d,%d]: channel already removed!!\n", 852 pMvSataAdapter->adapterId, channelIndex)); 853 } 854 pAdapter->sataEvents[channelIndex] = SATA_EVENT_NO_CHANGE; 855 break; 856 857 case SATA_EVENT_NO_CHANGE: 858 break; 859 860 default: 861 break; 862 } 863 } 864 /* mvOsSemRelease(&pMvSataAdapter->semaphore); */ 865 } 866 867 #define EVENT_CONNECT 1 868 #define EVENT_DISCONNECT 0 869 870 static void 871 hptmv_handle_event_connect(void *data) 872 { 873 hptmv_handle_event (data, 0); 874 } 875 876 static void 877 hptmv_handle_event_disconnect(void *data) 878 { 879 hptmv_handle_event (data, 1); 880 } 881 882 static MV_BOOLEAN 883 hptmv_event_notify(MV_SATA_ADAPTER *pMvSataAdapter, MV_EVENT_TYPE eventType, 884 MV_U32 param1, MV_U32 param2) 885 { 886 IAL_ADAPTER_T *pAdapter = pMvSataAdapter->IALData; 887 888 switch (eventType) 889 { 890 case MV_EVENT_TYPE_SATA_CABLE: 891 { 892 MV_U8 channel = param2; 893 894 if (param1 == EVENT_CONNECT) 895 { 896 pAdapter->sataEvents[channel] = SATA_EVENT_CHANNEL_CONNECTED; 897 KdPrint(("RR182x [%d,%d]: device connected event received\n", 898 pMvSataAdapter->adapterId, channel)); 899 /* Delete previous timers (if multiple drives connected in the same time */ 900 pAdapter->event_timer_connect = timeout(hptmv_handle_event_connect, pAdapter, 10*hz); 901 } 902 else if (param1 == EVENT_DISCONNECT) 903 { 904 pAdapter->sataEvents[channel] = SATA_EVENT_CHANNEL_DISCONNECTED; 905 KdPrint(("RR182x [%d,%d]: device disconnected event received \n", 906 pMvSataAdapter->adapterId, channel)); 907 device_change(pAdapter, channel, FALSE); 908 /* Delete previous timers (if multiple drives disconnected in the same time */ 909 /*pAdapter->event_timer_disconnect = timeout(hptmv_handle_event_disconnect, pAdapter, 10*hz); */ 910 /*It is not necessary to wait, handle it directly*/ 911 hptmv_handle_event_disconnect(pAdapter); 912 } 913 else 914 { 915 916 MV_ERROR("RR182x: illigal value for param1(%d) at " 917 "connect/disconect event, host=%d\n", param1, 918 pMvSataAdapter->adapterId ); 919 920 } 921 } 922 break; 923 case MV_EVENT_TYPE_ADAPTER_ERROR: 924 KdPrint(("RR182x: DEVICE error event received, pci cause " 925 "reg=%x, don't how to handle this\n", param1)); 926 return MV_TRUE; 927 default: 928 MV_ERROR("RR182x[%d]: unknown event type (%d)\n", 929 pMvSataAdapter->adapterId, eventType); 930 return MV_FALSE; 931 } 932 return MV_TRUE; 933 } 934 935 static int 936 hptmv_allocate_edma_queues(IAL_ADAPTER_T *pAdapter) 937 { 938 pAdapter->requestsArrayBaseAddr = (MV_U8 *)contigmalloc(REQUESTS_ARRAY_SIZE, 939 M_DEVBUF, M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0ul); 940 if (pAdapter->requestsArrayBaseAddr == NULL) 941 { 942 MV_ERROR("RR182x[%d]: Failed to allocate memory for EDMA request" 943 " queues\n", pAdapter->mvSataAdapter.adapterId); 944 return -1; 945 } 946 pAdapter->requestsArrayBaseDmaAddr = fOsPhysicalAddress(pAdapter->requestsArrayBaseAddr); 947 pAdapter->requestsArrayBaseAlignedAddr = pAdapter->requestsArrayBaseAddr; 948 pAdapter->requestsArrayBaseAlignedAddr += MV_EDMA_REQUEST_QUEUE_SIZE; 949 pAdapter->requestsArrayBaseAlignedAddr = (MV_U8 *) 950 (((ULONG_PTR)pAdapter->requestsArrayBaseAlignedAddr) & ~(ULONG_PTR)(MV_EDMA_REQUEST_QUEUE_SIZE - 1)); 951 pAdapter->requestsArrayBaseDmaAlignedAddr = pAdapter->requestsArrayBaseDmaAddr; 952 pAdapter->requestsArrayBaseDmaAlignedAddr += MV_EDMA_REQUEST_QUEUE_SIZE; 953 pAdapter->requestsArrayBaseDmaAlignedAddr &= ~(ULONG_PTR)(MV_EDMA_REQUEST_QUEUE_SIZE - 1); 954 955 if ((pAdapter->requestsArrayBaseDmaAlignedAddr - pAdapter->requestsArrayBaseDmaAddr) != 956 (pAdapter->requestsArrayBaseAlignedAddr - pAdapter->requestsArrayBaseAddr)) 957 { 958 MV_ERROR("RR182x[%d]: Error in Request Quueues Alignment\n", 959 pAdapter->mvSataAdapter.adapterId); 960 contigfree(pAdapter->requestsArrayBaseAddr, REQUESTS_ARRAY_SIZE, M_DEVBUF); 961 return -1; 962 } 963 /* response queues */ 964 pAdapter->responsesArrayBaseAddr = (MV_U8 *)contigmalloc(RESPONSES_ARRAY_SIZE, 965 M_DEVBUF, M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0ul); 966 if (pAdapter->responsesArrayBaseAddr == NULL) 967 { 968 MV_ERROR("RR182x[%d]: Failed to allocate memory for EDMA response" 969 " queues\n", pAdapter->mvSataAdapter.adapterId); 970 contigfree(pAdapter->requestsArrayBaseAddr, RESPONSES_ARRAY_SIZE, M_DEVBUF); 971 return -1; 972 } 973 pAdapter->responsesArrayBaseDmaAddr = fOsPhysicalAddress(pAdapter->responsesArrayBaseAddr); 974 pAdapter->responsesArrayBaseAlignedAddr = pAdapter->responsesArrayBaseAddr; 975 pAdapter->responsesArrayBaseAlignedAddr += MV_EDMA_RESPONSE_QUEUE_SIZE; 976 pAdapter->responsesArrayBaseAlignedAddr = (MV_U8 *) 977 (((ULONG_PTR)pAdapter->responsesArrayBaseAlignedAddr) & ~(ULONG_PTR)(MV_EDMA_RESPONSE_QUEUE_SIZE - 1)); 978 pAdapter->responsesArrayBaseDmaAlignedAddr = pAdapter->responsesArrayBaseDmaAddr; 979 pAdapter->responsesArrayBaseDmaAlignedAddr += MV_EDMA_RESPONSE_QUEUE_SIZE; 980 pAdapter->responsesArrayBaseDmaAlignedAddr &= ~(ULONG_PTR)(MV_EDMA_RESPONSE_QUEUE_SIZE - 1); 981 982 if ((pAdapter->responsesArrayBaseDmaAlignedAddr - pAdapter->responsesArrayBaseDmaAddr) != 983 (pAdapter->responsesArrayBaseAlignedAddr - pAdapter->responsesArrayBaseAddr)) 984 { 985 MV_ERROR("RR182x[%d]: Error in Response Quueues Alignment\n", 986 pAdapter->mvSataAdapter.adapterId); 987 contigfree(pAdapter->requestsArrayBaseAddr, REQUESTS_ARRAY_SIZE, M_DEVBUF); 988 contigfree(pAdapter->responsesArrayBaseAddr, RESPONSES_ARRAY_SIZE, M_DEVBUF); 989 return -1; 990 } 991 return 0; 992 } 993 994 static void 995 hptmv_free_edma_queues(IAL_ADAPTER_T *pAdapter) 996 { 997 contigfree(pAdapter->requestsArrayBaseAddr, REQUESTS_ARRAY_SIZE, M_DEVBUF); 998 contigfree(pAdapter->responsesArrayBaseAddr, RESPONSES_ARRAY_SIZE, M_DEVBUF); 999 } 1000 1001 static PVOID 1002 AllocatePRDTable(IAL_ADAPTER_T *pAdapter) 1003 { 1004 PVOID ret; 1005 if (pAdapter->pFreePRDLink) { 1006 KdPrint(("pAdapter->pFreePRDLink:%p\n",pAdapter->pFreePRDLink)); 1007 ret = pAdapter->pFreePRDLink; 1008 pAdapter->pFreePRDLink = *(void**)ret; 1009 return ret; 1010 } 1011 return NULL; 1012 } 1013 1014 static void 1015 FreePRDTable(IAL_ADAPTER_T *pAdapter, PVOID PRDTable) 1016 { 1017 *(void**)PRDTable = pAdapter->pFreePRDLink; 1018 pAdapter->pFreePRDLink = PRDTable; 1019 } 1020 1021 extern PVDevice fGetFirstChild(PVDevice pLogical); 1022 extern void fResetBootMark(PVDevice pLogical); 1023 static void 1024 fRegisterVdevice(IAL_ADAPTER_T *pAdapter) 1025 { 1026 PVDevice pPhysical, pLogical; 1027 PVBus pVBus; 1028 int i,j; 1029 1030 for(i=0;i<MV_SATA_CHANNELS_NUM;i++) { 1031 pPhysical = &(pAdapter->VDevices[i]); 1032 pLogical = pPhysical; 1033 while (pLogical->pParent) pLogical = pLogical->pParent; 1034 if (pLogical->vf_online==0) { 1035 pPhysical->vf_bootmark = pLogical->vf_bootmark = 0; 1036 continue; 1037 } 1038 if (pLogical->VDeviceType==VD_SPARE || pPhysical!=fGetFirstChild(pLogical)) 1039 continue; 1040 1041 pVBus = &pAdapter->VBus; 1042 if(pVBus) 1043 { 1044 j=0; 1045 while(j<MAX_VDEVICE_PER_VBUS && pVBus->pVDevice[j]) j++; 1046 if(j<MAX_VDEVICE_PER_VBUS){ 1047 pVBus->pVDevice[j] = pLogical; 1048 pLogical->pVBus = pVBus; 1049 1050 if (j>0 && pLogical->vf_bootmark) { 1051 if (pVBus->pVDevice[0]->vf_bootmark) { 1052 fResetBootMark(pLogical); 1053 } 1054 else { 1055 do { pVBus->pVDevice[j] = pVBus->pVDevice[j-1]; } while (--j); 1056 pVBus->pVDevice[0] = pLogical; 1057 } 1058 } 1059 } 1060 } 1061 } 1062 } 1063 1064 PVDevice 1065 GetSpareDisk(_VBUS_ARG PVDevice pArray) 1066 { 1067 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)pArray->pVBus->OsExt; 1068 ULONG capacity = LongDiv(pArray->VDeviceCapacity, pArray->u.array.bArnMember-1); 1069 ULONG thiscap, maxcap = MAX_LBA_T; 1070 PVDevice pVDevice, pFind = NULL; 1071 int i; 1072 1073 for(i=0;i<MV_SATA_CHANNELS_NUM;i++) 1074 { 1075 pVDevice = &pAdapter->VDevices[i]; 1076 if(!pVDevice) 1077 continue; 1078 thiscap = pArray->vf_format_v2? pVDevice->u.disk.dDeRealCapacity : pVDevice->VDeviceCapacity; 1079 /* find the smallest usable spare disk */ 1080 if (pVDevice->VDeviceType==VD_SPARE && 1081 pVDevice->u.disk.df_on_line && 1082 thiscap < maxcap && 1083 thiscap >= capacity) 1084 { 1085 maxcap = pVDevice->VDeviceCapacity; 1086 pFind = pVDevice; 1087 } 1088 } 1089 return pFind; 1090 } 1091 1092 /****************************************************************** 1093 * IO ATA Command 1094 *******************************************************************/ 1095 int HPTLIBAPI 1096 fDeReadWrite(PDevice pDev, ULONG Lba, UCHAR Cmd, void *tmpBuffer) 1097 { 1098 return mvReadWrite(pDev->mv, Lba, Cmd, tmpBuffer); 1099 } 1100 1101 void HPTLIBAPI fDeSelectMode(PDevice pDev, UCHAR NewMode) 1102 { 1103 MV_SATA_CHANNEL *pSataChannel = pDev->mv; 1104 MV_SATA_ADAPTER *pSataAdapter = pSataChannel->mvSataAdapter; 1105 MV_U8 channelIndex = pSataChannel->channelNumber; 1106 UCHAR mvMode; 1107 /* 508x don't use MW-DMA? */ 1108 if (NewMode>4 && NewMode<8) NewMode = 4; 1109 pDev->bDeModeSetting = NewMode; 1110 if (NewMode<=4) 1111 mvMode = MV_ATA_TRANSFER_PIO_0 + NewMode; 1112 else 1113 mvMode = MV_ATA_TRANSFER_UDMA_0 + (NewMode-8); 1114 1115 /*To fix 88i8030 bug*/ 1116 if (mvMode > MV_ATA_TRANSFER_UDMA_0 && mvMode < MV_ATA_TRANSFER_UDMA_4) 1117 mvMode = MV_ATA_TRANSFER_UDMA_0; 1118 1119 mvSataDisableChannelDma(pSataAdapter, channelIndex); 1120 /* Flush pending commands */ 1121 mvSataFlushDmaQueue (pSataAdapter, channelIndex, MV_FLUSH_TYPE_NONE); 1122 1123 if (mvStorageDevATASetFeatures(pSataAdapter, channelIndex, 1124 MV_ATA_SET_FEATURES_TRANSFER, 1125 mvMode, 0, 0, 0) == MV_FALSE) 1126 { 1127 KdPrint(("channel %d: Set Features failed\n", channelIndex)); 1128 } 1129 /* Enable EDMA */ 1130 if (mvSataEnableChannelDma(pSataAdapter, channelIndex) == MV_FALSE) 1131 KdPrint(("Failed to enable DMA, channel=%d", channelIndex)); 1132 } 1133 1134 #ifdef SUPPORT_ARRAY 1135 #define IdeRegisterVDevice fCheckArray 1136 #else 1137 void 1138 IdeRegisterVDevice(PDevice pDev) 1139 { 1140 PVDevice pVDev = Map2pVDevice(pDev); 1141 1142 pVDev->VDeviceType = pDev->df_atapi? VD_ATAPI : 1143 pDev->df_removable_drive? VD_REMOVABLE : VD_SINGLE_DISK; 1144 pVDev->vf_online = 1; 1145 pVDev->VDeviceCapacity = pDev->dDeRealCapacity; 1146 pVDev->pfnSendCommand = pfnSendCommand[pVDev->VDeviceType]; 1147 pVDev->pfnDeviceFailed = pfnDeviceFailed[pVDev->VDeviceType]; 1148 } 1149 #endif 1150 1151 static __inline PBUS_DMAMAP 1152 dmamap_get(struct IALAdapter * pAdapter) 1153 { 1154 PBUS_DMAMAP p = pAdapter->pbus_dmamap_list; 1155 if (p) 1156 pAdapter->pbus_dmamap_list = p-> next; 1157 return p; 1158 } 1159 1160 static __inline void 1161 dmamap_put(PBUS_DMAMAP p) 1162 { 1163 p->next = p->pAdapter->pbus_dmamap_list; 1164 p->pAdapter->pbus_dmamap_list = p; 1165 } 1166 1167 /*Since mtx not provide the initialize when declare, so we Final init here to initialize the global mtx*/ 1168 #if __FreeBSD_version >= 500000 1169 static void hpt_init(void *dummy) 1170 { 1171 mtx_init(&driver_lock, "hptlock", NULL, MTX_DEF); 1172 } 1173 SYSINIT(hptinit, SI_SUB_CONFIGURE, SI_ORDER_FIRST, hpt_init, NULL); 1174 #endif 1175 1176 static int num_adapters = 0; 1177 static int 1178 init_adapter(IAL_ADAPTER_T *pAdapter) 1179 { 1180 PVBus _vbus_p = &pAdapter->VBus; 1181 MV_SATA_ADAPTER *pMvSataAdapter; 1182 int i, channel, rid; 1183 1184 PVDevice pVDev; 1185 1186 pAdapter->next = 0; 1187 1188 if(gIal_Adapter == 0){ 1189 gIal_Adapter = pAdapter; 1190 pCurAdapter = gIal_Adapter; 1191 } 1192 else { 1193 pCurAdapter->next = pAdapter; 1194 pCurAdapter = pAdapter; 1195 } 1196 1197 pAdapter->outstandingCommands = 0; 1198 1199 pMvSataAdapter = &(pAdapter->mvSataAdapter); 1200 _vbus_p->OsExt = (void *)pAdapter; 1201 pMvSataAdapter->IALData = pAdapter; 1202 1203 if (bus_dma_tag_create(NULL,/* parent */ 1204 4, /* alignment */ 1205 BUS_SPACE_MAXADDR_32BIT+1, /* boundary */ 1206 BUS_SPACE_MAXADDR, /* lowaddr */ 1207 BUS_SPACE_MAXADDR, /* highaddr */ 1208 NULL, NULL, /* filter, filterarg */ 1209 PAGE_SIZE * (MAX_SG_DESCRIPTORS-1), /* maxsize */ 1210 MAX_SG_DESCRIPTORS, /* nsegments */ 1211 0x10000, /* maxsegsize */ 1212 BUS_DMA_WAITOK, /* flags */ 1213 #if __FreeBSD_version>502000 1214 busdma_lock_mutex, /* lockfunc */ 1215 &driver_lock, /* lockfuncarg */ 1216 #endif 1217 &pAdapter->io_dma_parent /* tag */)) 1218 { 1219 return ENXIO;; 1220 } 1221 1222 1223 if (hptmv_allocate_edma_queues(pAdapter)) 1224 { 1225 MV_ERROR("RR182x: Failed to allocate memory for EDMA queues\n"); 1226 return ENOMEM; 1227 } 1228 1229 /* also map EPROM address */ 1230 rid = 0x10; 1231 if (!(pAdapter->mem_res = bus_alloc_resource(pAdapter->hpt_dev, SYS_RES_MEMORY, &rid, 1232 0, ~0, MV_SATA_PCI_BAR0_SPACE_SIZE+0x40000, RF_ACTIVE)) 1233 || 1234 !(pMvSataAdapter->adapterIoBaseAddress = rman_get_virtual(pAdapter->mem_res))) 1235 { 1236 MV_ERROR("RR182x: Failed to remap memory space\n"); 1237 hptmv_free_edma_queues(pAdapter); 1238 return ENXIO; 1239 } 1240 else 1241 { 1242 KdPrint(("RR182x: io base address 0x%p\n", pMvSataAdapter->adapterIoBaseAddress)); 1243 } 1244 1245 pMvSataAdapter->adapterId = num_adapters++; 1246 /* get the revision ID */ 1247 pMvSataAdapter->pciConfigRevisionId = pci_read_config(pAdapter->hpt_dev, PCIR_REVID, 1); 1248 pMvSataAdapter->pciConfigDeviceId = pci_get_device(pAdapter->hpt_dev); 1249 1250 /* init RR182x */ 1251 pMvSataAdapter->intCoalThre[0]= 1; 1252 pMvSataAdapter->intCoalThre[1]= 1; 1253 pMvSataAdapter->intTimeThre[0] = 1; 1254 pMvSataAdapter->intTimeThre[1] = 1; 1255 pMvSataAdapter->pciCommand = 0x0107E371; 1256 pMvSataAdapter->pciSerrMask = 0xd77fe6ul; 1257 pMvSataAdapter->pciInterruptMask = 0xd77fe6ul; 1258 pMvSataAdapter->mvSataEventNotify = hptmv_event_notify; 1259 1260 if (mvSataInitAdapter(pMvSataAdapter) == MV_FALSE) 1261 { 1262 MV_ERROR("RR182x[%d]: core failed to initialize the adapter\n", 1263 pMvSataAdapter->adapterId); 1264 unregister: 1265 bus_release_resource(pAdapter->hpt_dev, SYS_RES_MEMORY, rid, pAdapter->mem_res); 1266 hptmv_free_edma_queues(pAdapter); 1267 return ENXIO; 1268 } 1269 pAdapter->ver_601 = pMvSataAdapter->pcbVersion; 1270 1271 #ifndef FOR_DEMO 1272 set_fail_leds(pMvSataAdapter, 0); 1273 #endif 1274 1275 /* setup command blocks */ 1276 KdPrint(("Allocate command blocks\n")); 1277 _vbus_(pFreeCommands) = 0; 1278 pAdapter->pCommandBlocks = 1279 malloc(sizeof(struct _Command) * MAX_COMMAND_BLOCKS_FOR_EACH_VBUS, M_DEVBUF, M_NOWAIT); 1280 KdPrint(("pCommandBlocks:%p\n",pAdapter->pCommandBlocks)); 1281 if (!pAdapter->pCommandBlocks) { 1282 MV_ERROR("insufficient memory\n"); 1283 goto unregister; 1284 } 1285 1286 for (i=0; i<MAX_COMMAND_BLOCKS_FOR_EACH_VBUS; i++) { 1287 FreeCommand(_VBUS_P &(pAdapter->pCommandBlocks[i])); 1288 } 1289 1290 /*Set up the bus_dmamap*/ 1291 pAdapter->pbus_dmamap = (PBUS_DMAMAP)malloc (sizeof(struct _BUS_DMAMAP) * MAX_QUEUE_COMM, M_DEVBUF, M_NOWAIT); 1292 if(!pAdapter->pbus_dmamap) { 1293 MV_ERROR("insufficient memory\n"); 1294 free(pAdapter->pCommandBlocks, M_DEVBUF); 1295 goto unregister; 1296 } 1297 1298 memset((void *)pAdapter->pbus_dmamap, 0, sizeof(struct _BUS_DMAMAP) * MAX_QUEUE_COMM); 1299 pAdapter->pbus_dmamap_list = 0; 1300 for (i=0; i < MAX_QUEUE_COMM; i++) { 1301 PBUS_DMAMAP pmap = &(pAdapter->pbus_dmamap[i]); 1302 pmap->pAdapter = pAdapter; 1303 dmamap_put(pmap); 1304 1305 if(bus_dmamap_create(pAdapter->io_dma_parent, 0, &pmap->dma_map)) { 1306 MV_ERROR("Can not allocate dma map\n"); 1307 free(pAdapter->pCommandBlocks, M_DEVBUF); 1308 free(pAdapter->pbus_dmamap, M_DEVBUF); 1309 goto unregister; 1310 } 1311 } 1312 /* setup PRD Tables */ 1313 KdPrint(("Allocate PRD Tables\n")); 1314 pAdapter->pFreePRDLink = 0; 1315 1316 pAdapter->prdTableAddr = (PUCHAR)contigmalloc( 1317 (PRD_ENTRIES_SIZE*PRD_TABLES_FOR_VBUS + 32), M_DEVBUF, M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0ul); 1318 1319 KdPrint(("prdTableAddr:%p\n",pAdapter->prdTableAddr)); 1320 if (!pAdapter->prdTableAddr) { 1321 MV_ERROR("insufficient PRD Tables\n"); 1322 goto unregister; 1323 } 1324 pAdapter->prdTableAlignedAddr = (PUCHAR)(((ULONG_PTR)pAdapter->prdTableAddr + 0x1f) & ~(ULONG_PTR)0x1fL); 1325 { 1326 PUCHAR PRDTable = pAdapter->prdTableAlignedAddr; 1327 for (i=0; i<PRD_TABLES_FOR_VBUS; i++) 1328 { 1329 /* KdPrint(("i=%d,pAdapter->pFreePRDLink=%p\n",i,pAdapter->pFreePRDLink)); */ 1330 FreePRDTable(pAdapter, PRDTable); 1331 PRDTable += PRD_ENTRIES_SIZE; 1332 } 1333 } 1334 1335 /* enable the adapter interrupts */ 1336 1337 /* configure and start the connected channels*/ 1338 for (channel = 0; channel < MV_SATA_CHANNELS_NUM; channel++) 1339 { 1340 pAdapter->mvChannel[channel].online = MV_FALSE; 1341 if (mvSataIsStorageDeviceConnected(pMvSataAdapter, channel) 1342 == MV_TRUE) 1343 { 1344 KdPrint(("RR182x[%d]: channel %d is connected\n", 1345 pMvSataAdapter->adapterId, channel)); 1346 1347 if (hptmv_init_channel(pAdapter, channel) == 0) 1348 { 1349 if (mvSataConfigureChannel(pMvSataAdapter, channel) == MV_FALSE) 1350 { 1351 MV_ERROR("RR182x[%d]: Failed to configure channel" 1352 " %d\n",pMvSataAdapter->adapterId, channel); 1353 hptmv_free_channel(pAdapter, channel); 1354 } 1355 else 1356 { 1357 if (start_channel(pAdapter, channel)) 1358 { 1359 MV_ERROR("RR182x[%d]: Failed to start channel," 1360 " channel=%d\n",pMvSataAdapter->adapterId, 1361 channel); 1362 hptmv_free_channel(pAdapter, channel); 1363 } 1364 pAdapter->mvChannel[channel].online = MV_TRUE; 1365 /* mvSataChannelSetEdmaLoopBackMode(pMvSataAdapter, 1366 channel, 1367 MV_TRUE);*/ 1368 } 1369 } 1370 } 1371 KdPrint(("pAdapter->mvChannel[channel].online:%x, channel:%d\n", 1372 pAdapter->mvChannel[channel].online, channel)); 1373 } 1374 1375 #ifdef SUPPORT_ARRAY 1376 for(i = MAX_ARRAY_DEVICE - 1; i >= 0; i--) { 1377 pVDev = ArrayTables(i); 1378 mArFreeArrayTable(pVDev); 1379 } 1380 #endif 1381 1382 KdPrint(("Initialize Devices\n")); 1383 for (channel = 0; channel < MV_SATA_CHANNELS_NUM; channel++) { 1384 MV_SATA_CHANNEL *pMvSataChannel = pMvSataAdapter->sataChannel[channel]; 1385 if (pMvSataChannel) { 1386 init_vdev_params(pAdapter, channel); 1387 IdeRegisterVDevice(&pAdapter->VDevices[channel].u.disk); 1388 } 1389 } 1390 #ifdef SUPPORT_ARRAY 1391 CheckArrayCritical(_VBUS_P0); 1392 #endif 1393 _vbus_p->nInstances = 1; 1394 fRegisterVdevice(pAdapter); 1395 1396 for (channel=0;channel<MV_SATA_CHANNELS_NUM;channel++) { 1397 pVDev = _vbus_p->pVDevice[channel]; 1398 if (pVDev && pVDev->vf_online) 1399 fCheckBootable(pVDev); 1400 } 1401 1402 #if defined(SUPPORT_ARRAY) && defined(_RAID5N_) 1403 init_raid5_memory(_VBUS_P0); 1404 _vbus_(r5).enable_write_back = 1; 1405 printf("RR182x: RAID5 write-back %s\n", _vbus_(r5).enable_write_back? "enabled" : "disabled"); 1406 #endif 1407 1408 mvSataUnmaskAdapterInterrupt(pMvSataAdapter); 1409 return 0; 1410 } 1411 1412 int 1413 MvSataResetChannel(MV_SATA_ADAPTER *pMvSataAdapter, MV_U8 channel) 1414 { 1415 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)pMvSataAdapter->IALData; 1416 1417 mvSataDisableChannelDma(pMvSataAdapter, channel); 1418 /* Flush pending commands */ 1419 mvSataFlushDmaQueue (pMvSataAdapter, channel, MV_FLUSH_TYPE_CALLBACK); 1420 1421 /* Software reset channel */ 1422 if (mvStorageDevATASoftResetDevice(pMvSataAdapter, channel) == MV_FALSE) 1423 { 1424 MV_ERROR("RR182x [%d,%d]: failed to perform Software reset\n", 1425 pMvSataAdapter->adapterId, channel); 1426 hptmv_free_channel(pAdapter, channel); 1427 return -1; 1428 } 1429 1430 /* Hardware reset channel */ 1431 if (mvSataChannelHardReset(pMvSataAdapter, channel)== MV_FALSE) 1432 { 1433 MV_ERROR("RR182x [%d,%d] Failed to Hard reser the SATA channel\n", 1434 pMvSataAdapter->adapterId, channel); 1435 hptmv_free_channel(pAdapter, channel); 1436 return -1; 1437 } 1438 1439 if (mvSataIsStorageDeviceConnected(pMvSataAdapter, channel) == MV_FALSE) 1440 { 1441 MV_ERROR("RR182x [%d,%d] Failed to Connect Device\n", 1442 pMvSataAdapter->adapterId, channel); 1443 hptmv_free_channel(pAdapter, channel); 1444 return -1; 1445 }else 1446 { 1447 MV_ERROR("channel %d: perform recalibrate command", channel); 1448 if (!mvStorageDevATAExecuteNonUDMACommand(pMvSataAdapter, channel, 1449 MV_NON_UDMA_PROTOCOL_NON_DATA, 1450 MV_FALSE, 1451 NULL, /* pBuffer*/ 1452 0, /* count */ 1453 0, /*features*/ 1454 /* sectorCount */ 1455 0, 1456 0, /* lbaLow */ 1457 0, /* lbaMid */ 1458 /* lbaHigh */ 1459 0, 1460 0, /* device */ 1461 /* command */ 1462 0x10)) 1463 MV_ERROR("channel %d: recalibrate failed", channel); 1464 1465 /* Set transfer mode */ 1466 if((mvStorageDevATASetFeatures(pMvSataAdapter, channel, 1467 MV_ATA_SET_FEATURES_TRANSFER, 1468 MV_ATA_TRANSFER_PIO_SLOW, 0, 0, 0) == MV_FALSE) || 1469 (mvStorageDevATASetFeatures(pMvSataAdapter, channel, 1470 MV_ATA_SET_FEATURES_TRANSFER, 1471 pAdapter->mvChannel[channel].maxPioModeSupported, 0, 0, 0) == MV_FALSE) || 1472 (mvStorageDevATASetFeatures(pMvSataAdapter, channel, 1473 MV_ATA_SET_FEATURES_TRANSFER, 1474 pAdapter->mvChannel[channel].maxUltraDmaModeSupported, 0, 0, 0) == MV_FALSE) ) 1475 { 1476 MV_ERROR("channel %d: Set Features failed", channel); 1477 hptmv_free_channel(pAdapter, channel); 1478 return -1; 1479 } 1480 /* Enable EDMA */ 1481 if (mvSataEnableChannelDma(pMvSataAdapter, channel) == MV_FALSE) 1482 { 1483 MV_ERROR("Failed to enable DMA, channel=%d", channel); 1484 hptmv_free_channel(pAdapter, channel); 1485 return -1; 1486 } 1487 } 1488 return 0; 1489 } 1490 1491 static int 1492 fResetActiveCommands(PVBus _vbus_p) 1493 { 1494 MV_SATA_ADAPTER *pMvSataAdapter = &((IAL_ADAPTER_T *)_vbus_p->OsExt)->mvSataAdapter; 1495 MV_U8 channel; 1496 for (channel=0;channel< MV_SATA_CHANNELS_NUM;channel++) { 1497 if (pMvSataAdapter->sataChannel[channel] && pMvSataAdapter->sataChannel[channel]->outstandingCommands) 1498 MvSataResetChannel(pMvSataAdapter,channel); 1499 } 1500 return 0; 1501 } 1502 1503 void fCompleteAllCommandsSynchronously(PVBus _vbus_p) 1504 { 1505 UINT cont; 1506 ULONG ticks = 0; 1507 MV_U8 channel; 1508 MV_SATA_ADAPTER *pMvSataAdapter = &((IAL_ADAPTER_T *)_vbus_p->OsExt)->mvSataAdapter; 1509 MV_SATA_CHANNEL *pMvSataChannel; 1510 1511 do { 1512 check_cmds: 1513 cont = 0; 1514 CheckPendingCall(_VBUS_P0); 1515 #ifdef _RAID5N_ 1516 dataxfer_poll(); 1517 xor_poll(); 1518 #endif 1519 for (channel=0;channel< MV_SATA_CHANNELS_NUM;channel++) { 1520 pMvSataChannel = pMvSataAdapter->sataChannel[channel]; 1521 if (pMvSataChannel && pMvSataChannel->outstandingCommands) 1522 { 1523 while (pMvSataChannel->outstandingCommands) { 1524 if (!mvSataInterruptServiceRoutine(pMvSataAdapter)) { 1525 StallExec(1000); 1526 if (ticks++ > 3000) { 1527 MvSataResetChannel(pMvSataAdapter,channel); 1528 goto check_cmds; 1529 } 1530 } 1531 else 1532 ticks = 0; 1533 } 1534 cont = 1; 1535 } 1536 } 1537 } while (cont); 1538 } 1539 1540 void 1541 fResetVBus(_VBUS_ARG0) 1542 { 1543 KdPrint(("fMvResetBus(%p)", _vbus_p)); 1544 1545 /* some commands may already finished. */ 1546 CheckPendingCall(_VBUS_P0); 1547 1548 fResetActiveCommands(_vbus_p); 1549 /* 1550 * the other pending commands may still be finished successfully. 1551 */ 1552 fCompleteAllCommandsSynchronously(_vbus_p); 1553 1554 /* Now there should be no pending commands. No more action needed. */ 1555 CheckIdleCall(_VBUS_P0); 1556 1557 KdPrint(("fMvResetBus() done")); 1558 } 1559 1560 /*No rescan function*/ 1561 void 1562 fRescanAllDevice(_VBUS_ARG0) 1563 { 1564 } 1565 1566 static MV_BOOLEAN 1567 CommandCompletionCB(MV_SATA_ADAPTER *pMvSataAdapter, 1568 MV_U8 channelNum, 1569 MV_COMPLETION_TYPE comp_type, 1570 MV_VOID_PTR commandId, 1571 MV_U16 responseFlags, 1572 MV_U32 timeStamp, 1573 MV_STORAGE_DEVICE_REGISTERS *registerStruct) 1574 { 1575 PCommand pCmd = (PCommand) commandId; 1576 _VBUS_INST(pCmd->pVDevice->pVBus) 1577 1578 if (pCmd->uScratch.sata_param.prdAddr) 1579 FreePRDTable(pMvSataAdapter->IALData,pCmd->uScratch.sata_param.prdAddr); 1580 1581 switch (comp_type) 1582 { 1583 case MV_COMPLETION_TYPE_NORMAL: 1584 pCmd->Result = RETURN_SUCCESS; 1585 break; 1586 case MV_COMPLETION_TYPE_ABORT: 1587 pCmd->Result = RETURN_BUS_RESET; 1588 break; 1589 case MV_COMPLETION_TYPE_ERROR: 1590 MV_ERROR("IAL: COMPLETION ERROR, adapter %d, channel %d, flags=%x\n", 1591 pMvSataAdapter->adapterId, channelNum, responseFlags); 1592 1593 if (responseFlags & 4) { 1594 MV_ERROR("ATA regs: error %x, sector count %x, LBA low %x, LBA mid %x," 1595 " LBA high %x, device %x, status %x\n", 1596 registerStruct->errorRegister, 1597 registerStruct->sectorCountRegister, 1598 registerStruct->lbaLowRegister, 1599 registerStruct->lbaMidRegister, 1600 registerStruct->lbaHighRegister, 1601 registerStruct->deviceRegister, 1602 registerStruct->statusRegister); 1603 } 1604 /*We can't do handleEdmaError directly here, because CommandCompletionCB is called by 1605 * mv's ISR, if we retry the command, than the internel data structure may be destroyed*/ 1606 pCmd->uScratch.sata_param.responseFlags = responseFlags; 1607 pCmd->uScratch.sata_param.bIdeStatus = registerStruct->statusRegister; 1608 pCmd->uScratch.sata_param.errorRegister = registerStruct->errorRegister; 1609 pCmd->pVDevice->u.disk.QueueLength--; 1610 CallAfterReturn(_VBUS_P (DPC_PROC)handleEdmaError,pCmd); 1611 return TRUE; 1612 1613 default: 1614 MV_ERROR(" Unknown completion type (%d)\n", comp_type); 1615 return MV_FALSE; 1616 } 1617 1618 if (pCmd->uCmd.Ide.Command == IDE_COMMAND_VERIFY && pCmd->uScratch.sata_param.cmd_priv > 1) { 1619 pCmd->uScratch.sata_param.cmd_priv --; 1620 return TRUE; 1621 } 1622 pCmd->pVDevice->u.disk.QueueLength--; 1623 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 1624 return TRUE; 1625 } 1626 1627 void 1628 fDeviceSendCommand(_VBUS_ARG PCommand pCmd) 1629 { 1630 MV_SATA_EDMA_PRD_ENTRY *pPRDTable = 0; 1631 MV_SATA_ADAPTER *pMvSataAdapter; 1632 MV_SATA_CHANNEL *pMvSataChannel; 1633 PVDevice pVDevice = pCmd->pVDevice; 1634 PDevice pDevice = &pVDevice->u.disk; 1635 ULONG Lba = pCmd->uCmd.Ide.Lba; 1636 USHORT nSector = pCmd->uCmd.Ide.nSectors; 1637 1638 MV_QUEUE_COMMAND_RESULT result; 1639 MV_QUEUE_COMMAND_INFO commandInfo; 1640 MV_UDMA_COMMAND_PARAMS *pUdmaParams = &commandInfo.commandParams.udmaCommand; 1641 MV_NONE_UDMA_COMMAND_PARAMS *pNoUdmaParams = &commandInfo.commandParams.NoneUdmaCommand; 1642 1643 MV_BOOLEAN is48bit = MV_FALSE; 1644 MV_U8 channel; 1645 int i=0; 1646 1647 DECLARE_BUFFER(FPSCAT_GATH, tmpSg); 1648 1649 if (!pDevice->df_on_line) { 1650 MV_ERROR("Device is offline"); 1651 pCmd->Result = RETURN_BAD_DEVICE; 1652 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 1653 return; 1654 } 1655 1656 pDevice->HeadPosition = pCmd->uCmd.Ide.Lba + pCmd->uCmd.Ide.nSectors; 1657 pMvSataChannel = pDevice->mv; 1658 pMvSataAdapter = pMvSataChannel->mvSataAdapter; 1659 channel = pMvSataChannel->channelNumber; 1660 1661 /* old RAID0 has hidden lba. Remember to clear dDeHiddenLba when delete array! */ 1662 Lba += pDevice->dDeHiddenLba; 1663 /* check LBA */ 1664 if (Lba+nSector-1 > pDevice->dDeRealCapacity) { 1665 pCmd->Result = RETURN_INVALID_REQUEST; 1666 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 1667 return; 1668 } 1669 1670 if(Lba & 0xF0000000){ 1671 is48bit = MV_TRUE; 1672 } 1673 1674 switch (pCmd->uCmd.Ide.Command) 1675 { 1676 case IDE_COMMAND_READ: 1677 case IDE_COMMAND_WRITE: 1678 if (pDevice->bDeModeSetting<8) goto pio; 1679 1680 commandInfo.type = MV_QUEUED_COMMAND_TYPE_UDMA; 1681 pUdmaParams->isEXT = is48bit; 1682 pUdmaParams->numOfSectors = nSector; 1683 pUdmaParams->lowLBAAddress = Lba; 1684 pUdmaParams->highLBAAddress = 0; 1685 pUdmaParams->prdHighAddr = 0; 1686 pUdmaParams->callBack = CommandCompletionCB; 1687 pUdmaParams->commandId = (MV_VOID_PTR )pCmd; 1688 if(pCmd->uCmd.Ide.Command == IDE_COMMAND_READ) 1689 pUdmaParams->readWrite = MV_UDMA_TYPE_READ; 1690 else 1691 pUdmaParams->readWrite = MV_UDMA_TYPE_WRITE; 1692 1693 if (pCmd->pSgTable && pCmd->cf_physical_sg) { 1694 FPSCAT_GATH sg1=tmpSg, sg2=pCmd->pSgTable; 1695 do { *sg1++=*sg2; } while ((sg2++->wSgFlag & SG_FLAG_EOT)==0); 1696 } 1697 else { 1698 if (!pCmd->pfnBuildSgl || !pCmd->pfnBuildSgl(_VBUS_P pCmd, tmpSg, 0)) { 1699 pio: 1700 mvSataDisableChannelDma(pMvSataAdapter, channel); 1701 mvSataFlushDmaQueue(pMvSataAdapter, channel, MV_FLUSH_TYPE_CALLBACK); 1702 1703 if (pCmd->pSgTable && pCmd->cf_physical_sg==0) { 1704 FPSCAT_GATH sg1=tmpSg, sg2=pCmd->pSgTable; 1705 do { *sg1++=*sg2; } while ((sg2++->wSgFlag & SG_FLAG_EOT)==0); 1706 } 1707 else { 1708 if (!pCmd->pfnBuildSgl || !pCmd->pfnBuildSgl(_VBUS_P pCmd, tmpSg, 1)) { 1709 pCmd->Result = RETURN_NEED_LOGICAL_SG; 1710 goto finish_cmd; 1711 } 1712 } 1713 1714 do { 1715 ULONG size = tmpSg->wSgSize? tmpSg->wSgSize : 0x10000; 1716 ULONG_PTR addr = tmpSg->dSgAddress; 1717 if (size & 0x1ff) { 1718 pCmd->Result = RETURN_INVALID_REQUEST; 1719 goto finish_cmd; 1720 } 1721 if (mvStorageDevATAExecuteNonUDMACommand(pMvSataAdapter, channel, 1722 (pCmd->cf_data_out)?MV_NON_UDMA_PROTOCOL_PIO_DATA_OUT:MV_NON_UDMA_PROTOCOL_PIO_DATA_IN, 1723 is48bit, 1724 (MV_U16_PTR)addr, 1725 size >> 1, /* count */ 1726 0, /* features N/A */ 1727 (MV_U16)(size>>9), /*sector count*/ 1728 (MV_U16)( (is48bit? (MV_U16)((Lba >> 16) & 0xFF00) : 0 ) | (UCHAR)(Lba & 0xFF) ), /*lbalow*/ 1729 (MV_U16)((Lba >> 8) & 0xFF), /* lbaMid */ 1730 (MV_U16)((Lba >> 16) & 0xFF),/* lbaHigh */ 1731 (MV_U8)(0x40 | (is48bit ? 0 : (UCHAR)(Lba >> 24) & 0xFF )),/* device */ 1732 (MV_U8)(is48bit ? (pCmd->cf_data_in?IDE_COMMAND_READ_EXT:IDE_COMMAND_WRITE_EXT):pCmd->uCmd.Ide.Command) 1733 )==MV_FALSE) 1734 { 1735 pCmd->Result = RETURN_IDE_ERROR; 1736 goto finish_cmd; 1737 } 1738 Lba += size>>9; 1739 if(Lba & 0xF0000000) is48bit = MV_TRUE; 1740 } 1741 while ((tmpSg++->wSgFlag & SG_FLAG_EOT)==0); 1742 pCmd->Result = RETURN_SUCCESS; 1743 finish_cmd: 1744 mvSataEnableChannelDma(pMvSataAdapter,channel); 1745 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 1746 return; 1747 } 1748 } 1749 1750 pPRDTable = (MV_SATA_EDMA_PRD_ENTRY *) AllocatePRDTable(pMvSataAdapter->IALData); 1751 KdPrint(("pPRDTable:%p\n",pPRDTable)); 1752 if (!pPRDTable) { 1753 pCmd->Result = RETURN_DEVICE_BUSY; 1754 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 1755 HPT_ASSERT(0); 1756 return; 1757 } 1758 1759 do{ 1760 pPRDTable[i].highBaseAddr = (sizeof(tmpSg->dSgAddress)>4 ? (MV_U32)(tmpSg->dSgAddress>>32) : 0); 1761 pPRDTable[i].flags = (MV_U16)tmpSg->wSgFlag; 1762 pPRDTable[i].byteCount = (MV_U16)tmpSg->wSgSize; 1763 pPRDTable[i].lowBaseAddr = (MV_U32)tmpSg->dSgAddress; 1764 pPRDTable[i].reserved = 0; 1765 i++; 1766 }while((tmpSg++->wSgFlag & SG_FLAG_EOT)==0); 1767 1768 pUdmaParams->prdLowAddr = (ULONG)fOsPhysicalAddress(pPRDTable); 1769 if ((pUdmaParams->numOfSectors == 256) && (pMvSataChannel->lba48Address == MV_FALSE)) { 1770 pUdmaParams->numOfSectors = 0; 1771 } 1772 1773 pCmd->uScratch.sata_param.prdAddr = (PVOID)pPRDTable; 1774 1775 result = mvSataQueueCommand(pMvSataAdapter, channel, &commandInfo); 1776 1777 if (result != MV_QUEUE_COMMAND_RESULT_OK) 1778 { 1779 queue_failed: 1780 switch (result) 1781 { 1782 case MV_QUEUE_COMMAND_RESULT_BAD_LBA_ADDRESS: 1783 MV_ERROR("IAL Error: Edma Queue command failed. Bad LBA " 1784 "LBA[31:0](0x%08x)\n", pUdmaParams->lowLBAAddress); 1785 pCmd->Result = RETURN_IDE_ERROR; 1786 break; 1787 case MV_QUEUE_COMMAND_RESULT_QUEUED_MODE_DISABLED: 1788 MV_ERROR("IAL Error: Edma Queue command failed. EDMA" 1789 " disabled adapter %d channel %d\n", 1790 pMvSataAdapter->adapterId, channel); 1791 mvSataEnableChannelDma(pMvSataAdapter,channel); 1792 pCmd->Result = RETURN_IDE_ERROR; 1793 break; 1794 case MV_QUEUE_COMMAND_RESULT_FULL: 1795 MV_ERROR("IAL Error: Edma Queue command failed. Queue is" 1796 " Full adapter %d channel %d\n", 1797 pMvSataAdapter->adapterId, channel); 1798 pCmd->Result = RETURN_DEVICE_BUSY; 1799 break; 1800 case MV_QUEUE_COMMAND_RESULT_BAD_PARAMS: 1801 MV_ERROR("IAL Error: Edma Queue command failed. (Bad " 1802 "Params), pMvSataAdapter: %p, pSataChannel: %p.\n", 1803 pMvSataAdapter, pMvSataAdapter->sataChannel[channel]); 1804 pCmd->Result = RETURN_IDE_ERROR; 1805 break; 1806 default: 1807 MV_ERROR("IAL Error: Bad result value (%d) from queue" 1808 " command\n", result); 1809 pCmd->Result = RETURN_IDE_ERROR; 1810 } 1811 if(pPRDTable) 1812 FreePRDTable(pMvSataAdapter->IALData,pPRDTable); 1813 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 1814 } 1815 pDevice->QueueLength++; 1816 return; 1817 1818 case IDE_COMMAND_VERIFY: 1819 commandInfo.type = MV_QUEUED_COMMAND_TYPE_NONE_UDMA; 1820 pNoUdmaParams->bufPtr = NULL; 1821 pNoUdmaParams->callBack = CommandCompletionCB; 1822 pNoUdmaParams->commandId = (MV_VOID_PTR)pCmd; 1823 pNoUdmaParams->count = 0; 1824 pNoUdmaParams->features = 0; 1825 pNoUdmaParams->protocolType = MV_NON_UDMA_PROTOCOL_NON_DATA; 1826 1827 pCmd->uScratch.sata_param.cmd_priv = 1; 1828 if (pMvSataChannel->lba48Address == MV_TRUE){ 1829 pNoUdmaParams->command = MV_ATA_COMMAND_READ_VERIFY_SECTORS_EXT; 1830 pNoUdmaParams->isEXT = MV_TRUE; 1831 pNoUdmaParams->lbaHigh = (MV_U16)((Lba & 0xff0000) >> 16); 1832 pNoUdmaParams->lbaMid = (MV_U16)((Lba & 0xff00) >> 8); 1833 pNoUdmaParams->lbaLow = 1834 (MV_U16)(((Lba & 0xff000000) >> 16)| (Lba & 0xff)); 1835 pNoUdmaParams->sectorCount = nSector; 1836 pNoUdmaParams->device = 0x40; 1837 result = mvSataQueueCommand(pMvSataAdapter, channel, &commandInfo); 1838 if (result != MV_QUEUE_COMMAND_RESULT_OK){ 1839 goto queue_failed; 1840 } 1841 return; 1842 } 1843 else{ 1844 pNoUdmaParams->command = MV_ATA_COMMAND_READ_VERIFY_SECTORS; 1845 pNoUdmaParams->isEXT = MV_FALSE; 1846 pNoUdmaParams->lbaHigh = (MV_U16)((Lba & 0xff0000) >> 16); 1847 pNoUdmaParams->lbaMid = (MV_U16)((Lba & 0xff00) >> 8); 1848 pNoUdmaParams->lbaLow = (MV_U16)(Lba & 0xff); 1849 pNoUdmaParams->sectorCount = 0xff & nSector; 1850 pNoUdmaParams->device = (MV_U8)(0x40 | 1851 ((Lba & 0xf000000) >> 24)); 1852 pNoUdmaParams->callBack = CommandCompletionCB; 1853 result = mvSataQueueCommand(pMvSataAdapter, channel, &commandInfo); 1854 /*FIXME: how about the commands already queued? but marvel also forgets to consider this*/ 1855 if (result != MV_QUEUE_COMMAND_RESULT_OK){ 1856 goto queue_failed; 1857 } 1858 } 1859 break; 1860 default: 1861 pCmd->Result = RETURN_INVALID_REQUEST; 1862 CallAfterReturn(_VBUS_P (DPC_PROC)pCmd->pfnCompletion, pCmd); 1863 break; 1864 } 1865 } 1866 1867 /********************************************************** 1868 * 1869 * Probe the hostadapter. 1870 * 1871 **********************************************************/ 1872 static int 1873 hpt_probe(device_t dev) 1874 { 1875 if ((pci_get_vendor(dev) == MV_SATA_VENDOR_ID) && 1876 (pci_get_device(dev) == MV_SATA_DEVICE_ID_5081 1877 #ifdef FOR_DEMO 1878 || pci_get_device(dev) == MV_SATA_DEVICE_ID_5080 1879 #endif 1880 )) 1881 { 1882 KdPrintI((CONTROLLER_NAME " found\n")); 1883 device_set_desc(dev, CONTROLLER_NAME); 1884 return 0; 1885 } 1886 else 1887 return(ENXIO); 1888 } 1889 1890 /*********************************************************** 1891 * 1892 * Auto configuration: attach and init a host adapter. 1893 * 1894 ***********************************************************/ 1895 static int 1896 hpt_attach(device_t dev) 1897 { 1898 IAL_ADAPTER_T * pAdapter = device_get_softc(dev); 1899 int rid; 1900 union ccb *ccb; 1901 struct cam_devq *devq; 1902 struct cam_sim *hpt_vsim; 1903 1904 printf("%s Version %s \n", DRIVER_NAME, DRIVER_VERSION); 1905 1906 if (!pAdapter) 1907 { 1908 pAdapter = (IAL_ADAPTER_T *)malloc(sizeof (IAL_ADAPTER_T), M_DEVBUF, M_NOWAIT); 1909 #if __FreeBSD_version > 410000 1910 device_set_softc(dev, (void *)pAdapter); 1911 #else 1912 device_set_driver(dev, (driver_t *)pAdapter); 1913 #endif 1914 } 1915 1916 if (!pAdapter) return (ENOMEM); 1917 bzero(pAdapter, sizeof(IAL_ADAPTER_T)); 1918 1919 pAdapter->hpt_dev = dev; 1920 1921 rid = init_adapter(pAdapter); 1922 if (rid) 1923 return rid; 1924 1925 rid = 0; 1926 if ((pAdapter->hpt_irq = bus_alloc_resource(pAdapter->hpt_dev, SYS_RES_IRQ, &rid, 0, ~0ul, 1, RF_SHAREABLE | RF_ACTIVE)) == NULL) 1927 { 1928 hpt_printk(("can't allocate interrupt\n")); 1929 return(ENXIO); 1930 } 1931 1932 if(bus_setup_intr(pAdapter->hpt_dev, pAdapter->hpt_irq, INTR_TYPE_CAM, NULL, hpt_intr, pAdapter, &pAdapter->hpt_intr)) 1933 { 1934 hpt_printk(("can't set up interrupt\n")); 1935 free(pAdapter, M_DEVBUF); 1936 return(ENXIO); 1937 } 1938 1939 1940 if((ccb = (union ccb *)malloc(sizeof(*ccb), M_DEVBUF, M_WAITOK)) != (union ccb*)NULL) 1941 { 1942 bzero(ccb, sizeof(*ccb)); 1943 ccb->ccb_h.pinfo.priority = 1; 1944 ccb->ccb_h.pinfo.index = CAM_UNQUEUED_INDEX; 1945 } 1946 else 1947 { 1948 return ENOMEM; 1949 } 1950 /* 1951 * Create the device queue for our SIM(s). 1952 */ 1953 if((devq = cam_simq_alloc(8/*MAX_QUEUE_COMM*/)) == NULL) 1954 { 1955 KdPrint(("ENXIO\n")); 1956 return ENOMEM; 1957 } 1958 1959 /* 1960 * Construct our SIM entry 1961 */ 1962 if ((hpt_vsim = cam_sim_alloc(hpt_action, hpt_poll, __str(PROC_DIR_NAME), 1963 pAdapter, device_get_unit(pAdapter->hpt_dev), 1964 &Giant, /*untagged*/1, /*tagged*/8, devq)) == NULL) { 1965 cam_simq_free(devq); 1966 return ENOMEM; 1967 } 1968 1969 if(xpt_bus_register(hpt_vsim, dev, 0) != CAM_SUCCESS) 1970 { 1971 cam_sim_free(hpt_vsim, /*free devq*/ TRUE); 1972 hpt_vsim = NULL; 1973 return ENXIO; 1974 } 1975 1976 if(xpt_create_path(&pAdapter->path, /*periph */ NULL, 1977 cam_sim_path(hpt_vsim), CAM_TARGET_WILDCARD, 1978 CAM_LUN_WILDCARD) != CAM_REQ_CMP) 1979 { 1980 xpt_bus_deregister(cam_sim_path(hpt_vsim)); 1981 cam_sim_free(hpt_vsim, /*free_devq*/TRUE); 1982 hpt_vsim = NULL; 1983 return ENXIO; 1984 } 1985 1986 xpt_setup_ccb(&(ccb->ccb_h), pAdapter->path, /*priority*/5); 1987 ccb->ccb_h.func_code = XPT_SASYNC_CB; 1988 ccb->csa.event_enable = AC_LOST_DEVICE; 1989 ccb->csa.callback = hpt_async; 1990 ccb->csa.callback_arg = hpt_vsim; 1991 xpt_action((union ccb *)ccb); 1992 free(ccb, M_DEVBUF); 1993 1994 /* Register shutdown handler, and start the work thread. */ 1995 if (device_get_unit(dev) == 0) { 1996 pAdapter->eh = EVENTHANDLER_REGISTER(shutdown_final, 1997 hpt_shutdown, dev, SHUTDOWN_PRI_DEFAULT); 1998 if (pAdapter->eh) 1999 launch_worker_thread(); 2000 else 2001 hpt_printk(("shutdown event registration failed\n")); 2002 } 2003 2004 return 0; 2005 } 2006 2007 static int 2008 hpt_detach(device_t dev) 2009 { 2010 return (EBUSY); 2011 } 2012 2013 2014 /*************************************************************** 2015 * The poll function is used to simulate the interrupt when 2016 * the interrupt subsystem is not functioning. 2017 * 2018 ***************************************************************/ 2019 static void 2020 hpt_poll(struct cam_sim *sim) 2021 { 2022 hpt_intr((void *)cam_sim_softc(sim)); 2023 } 2024 2025 /**************************************************************** 2026 * Name: hpt_intr 2027 * Description: Interrupt handler. 2028 ****************************************************************/ 2029 static void 2030 hpt_intr(void *arg) 2031 { 2032 IAL_ADAPTER_T *pAdapter = (IAL_ADAPTER_T *)arg; 2033 intrmask_t oldspl = lock_driver(); 2034 2035 /* KdPrintI(("----- Entering Isr() -----\n")); */ 2036 if (mvSataInterruptServiceRoutine(&pAdapter->mvSataAdapter) == MV_TRUE) 2037 { 2038 _VBUS_INST(&pAdapter->VBus) 2039 CheckPendingCall(_VBUS_P0); 2040 } 2041 2042 /* KdPrintI(("----- Leaving Isr() -----\n")); */ 2043 unlock_driver(oldspl); 2044 } 2045 2046 /********************************************************** 2047 * Asynchronous Events 2048 *********************************************************/ 2049 #if (!defined(UNREFERENCED_PARAMETER)) 2050 #define UNREFERENCED_PARAMETER(x) (void)(x) 2051 #endif 2052 2053 static void 2054 hpt_async(void * callback_arg, u_int32_t code, struct cam_path * path, 2055 void * arg) 2056 { 2057 /* debug XXXX */ 2058 panic("Here"); 2059 UNREFERENCED_PARAMETER(callback_arg); 2060 UNREFERENCED_PARAMETER(code); 2061 UNREFERENCED_PARAMETER(path); 2062 UNREFERENCED_PARAMETER(arg); 2063 2064 } 2065 2066 static void 2067 FlushAdapter(IAL_ADAPTER_T *pAdapter) 2068 { 2069 int i; 2070 2071 hpt_printk(("flush all devices\n")); 2072 2073 /* flush all devices */ 2074 for (i=0; i<MAX_VDEVICE_PER_VBUS; i++) { 2075 PVDevice pVDev = pAdapter->VBus.pVDevice[i]; 2076 if(pVDev) fFlushVDev(pVDev); 2077 } 2078 } 2079 2080 static int 2081 hpt_shutdown(device_t dev) 2082 { 2083 IAL_ADAPTER_T *pAdapter; 2084 2085 pAdapter = device_get_softc(dev); 2086 if (pAdapter == NULL) 2087 return (EINVAL); 2088 2089 EVENTHANDLER_DEREGISTER(shutdown_final, pAdapter->eh); 2090 FlushAdapter(pAdapter); 2091 /* give the flush some time to happen, 2092 *otherwise "shutdown -p now" will make file system corrupted */ 2093 DELAY(1000 * 1000 * 5); 2094 return 0; 2095 } 2096 2097 void 2098 Check_Idle_Call(IAL_ADAPTER_T *pAdapter) 2099 { 2100 _VBUS_INST(&pAdapter->VBus) 2101 2102 if (mWaitingForIdle(_VBUS_P0)) { 2103 CheckIdleCall(_VBUS_P0); 2104 #ifdef SUPPORT_ARRAY 2105 { 2106 int i; 2107 PVDevice pArray; 2108 for(i = 0; i < MAX_ARRAY_PER_VBUS; i++){ 2109 if ((pArray=ArrayTables(i))->u.array.dArStamp==0) 2110 continue; 2111 else if (pArray->u.array.rf_auto_rebuild) { 2112 KdPrint(("auto rebuild.\n")); 2113 pArray->u.array.rf_auto_rebuild = 0; 2114 hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapter, pArray, DUPLICATE); 2115 } 2116 } 2117 } 2118 #endif 2119 } 2120 /* launch the awaiting commands blocked by mWaitingForIdle */ 2121 while(pAdapter->pending_Q!= NULL) 2122 { 2123 _VBUS_INST(&pAdapter->VBus) 2124 union ccb *ccb = (union ccb *)pAdapter->pending_Q->ccb_h.ccb_ccb_ptr; 2125 hpt_free_ccb(&pAdapter->pending_Q, ccb); 2126 CallAfterReturn(_VBUS_P (DPC_PROC)OsSendCommand, ccb); 2127 } 2128 } 2129 2130 static void 2131 ccb_done(union ccb *ccb) 2132 { 2133 PBUS_DMAMAP pmap = (PBUS_DMAMAP)ccb->ccb_adapter; 2134 IAL_ADAPTER_T * pAdapter = pmap->pAdapter; 2135 KdPrintI(("ccb_done: ccb %p status %x\n", ccb, ccb->ccb_h.status)); 2136 2137 dmamap_put(pmap); 2138 xpt_done(ccb); 2139 2140 pAdapter->outstandingCommands--; 2141 2142 if (pAdapter->outstandingCommands == 0) 2143 { 2144 if(DPC_Request_Nums == 0) 2145 Check_Idle_Call(pAdapter); 2146 } 2147 } 2148 2149 /**************************************************************** 2150 * Name: hpt_action 2151 * Description: Process a queued command from the CAM layer. 2152 * Parameters: sim - Pointer to SIM object 2153 * ccb - Pointer to SCSI command structure. 2154 ****************************************************************/ 2155 2156 void 2157 hpt_action(struct cam_sim *sim, union ccb *ccb) 2158 { 2159 intrmask_t oldspl; 2160 IAL_ADAPTER_T * pAdapter = (IAL_ADAPTER_T *) cam_sim_softc(sim); 2161 PBUS_DMAMAP pmap; 2162 _VBUS_INST(&pAdapter->VBus) 2163 2164 CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("hpt_action\n")); 2165 KdPrint(("hpt_action(%lx,%lx{%x})\n", (u_long)sim, (u_long)ccb, ccb->ccb_h.func_code)); 2166 2167 switch (ccb->ccb_h.func_code) 2168 { 2169 case XPT_SCSI_IO: /* Execute the requested I/O operation */ 2170 { 2171 /* ccb->ccb_h.path_id is not our bus id - don't check it */ 2172 2173 if (ccb->ccb_h.target_lun) { 2174 ccb->ccb_h.status = CAM_LUN_INVALID; 2175 xpt_done(ccb); 2176 return; 2177 } 2178 if (ccb->ccb_h.target_id >= MAX_VDEVICE_PER_VBUS || 2179 pAdapter->VBus.pVDevice[ccb->ccb_h.target_id]==0) { 2180 ccb->ccb_h.status = CAM_TID_INVALID; 2181 xpt_done(ccb); 2182 return; 2183 } 2184 2185 oldspl = lock_driver(); 2186 if (pAdapter->outstandingCommands==0 && DPC_Request_Nums==0) 2187 Check_Idle_Call(pAdapter); 2188 2189 pmap = dmamap_get(pAdapter); 2190 HPT_ASSERT(pmap); 2191 ccb->ccb_adapter = pmap; 2192 memset((void *)pmap->psg, 0, sizeof(pmap->psg)); 2193 2194 if (mWaitingForIdle(_VBUS_P0)) 2195 hpt_queue_ccb(&pAdapter->pending_Q, ccb); 2196 else 2197 OsSendCommand(_VBUS_P ccb); 2198 unlock_driver(oldspl); 2199 2200 /* KdPrint(("leave scsiio\n")); */ 2201 break; 2202 } 2203 2204 case XPT_RESET_BUS: 2205 KdPrint(("reset bus\n")); 2206 oldspl = lock_driver(); 2207 fResetVBus(_VBUS_P0); 2208 unlock_driver(oldspl); 2209 xpt_done(ccb); 2210 break; 2211 2212 case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */ 2213 case XPT_EN_LUN: /* Enable LUN as a target */ 2214 case XPT_TARGET_IO: /* Execute target I/O request */ 2215 case XPT_ACCEPT_TARGET_IO: /* Accept Host Target Mode CDB */ 2216 case XPT_CONT_TARGET_IO: /* Continue Host Target I/O Connection*/ 2217 case XPT_ABORT: /* Abort the specified CCB */ 2218 case XPT_TERM_IO: /* Terminate the I/O process */ 2219 /* XXX Implement */ 2220 ccb->ccb_h.status = CAM_REQ_INVALID; 2221 xpt_done(ccb); 2222 break; 2223 2224 case XPT_GET_TRAN_SETTINGS: 2225 case XPT_SET_TRAN_SETTINGS: 2226 /* XXX Implement */ 2227 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 2228 xpt_done(ccb); 2229 break; 2230 2231 case XPT_CALC_GEOMETRY: 2232 { 2233 struct ccb_calc_geometry *ccg; 2234 u_int32_t size_mb; 2235 u_int32_t secs_per_cylinder; 2236 2237 ccg = &ccb->ccg; 2238 size_mb = ccg->volume_size / ((1024L * 1024L) / ccg->block_size); 2239 2240 if (size_mb > 1024 ) { 2241 ccg->heads = 255; 2242 ccg->secs_per_track = 63; 2243 } else { 2244 ccg->heads = 64; 2245 ccg->secs_per_track = 32; 2246 } 2247 secs_per_cylinder = ccg->heads * ccg->secs_per_track; 2248 ccg->cylinders = ccg->volume_size / secs_per_cylinder; 2249 ccb->ccb_h.status = CAM_REQ_CMP; 2250 xpt_done(ccb); 2251 break; 2252 } 2253 2254 case XPT_PATH_INQ: /* Path routing inquiry */ 2255 { 2256 struct ccb_pathinq *cpi = &ccb->cpi; 2257 2258 cpi->version_num = 1; /* XXX??? */ 2259 cpi->hba_inquiry = PI_SDTR_ABLE; 2260 cpi->target_sprt = 0; 2261 /* Not necessary to reset bus */ 2262 cpi->hba_misc = PIM_NOBUSRESET; 2263 cpi->hba_eng_cnt = 0; 2264 2265 cpi->max_target = MAX_VDEVICE_PER_VBUS; 2266 cpi->max_lun = 0; 2267 cpi->initiator_id = MAX_VDEVICE_PER_VBUS; 2268 2269 cpi->bus_id = cam_sim_bus(sim); 2270 cpi->base_transfer_speed = 3300; 2271 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 2272 strncpy(cpi->hba_vid, "HPT ", HBA_IDLEN); 2273 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 2274 cpi->unit_number = cam_sim_unit(sim); 2275 cpi->ccb_h.status = CAM_REQ_CMP; 2276 xpt_done(ccb); 2277 break; 2278 } 2279 2280 default: 2281 KdPrint(("invalid cmd\n")); 2282 ccb->ccb_h.status = CAM_REQ_INVALID; 2283 xpt_done(ccb); 2284 break; 2285 } 2286 /* KdPrint(("leave hpt_action..............\n")); */ 2287 } 2288 2289 /* shall be called at lock_driver() */ 2290 static void 2291 hpt_queue_ccb(union ccb **ccb_Q, union ccb *ccb) 2292 { 2293 if(*ccb_Q == NULL) 2294 ccb->ccb_h.ccb_ccb_ptr = ccb; 2295 else { 2296 ccb->ccb_h.ccb_ccb_ptr = (*ccb_Q)->ccb_h.ccb_ccb_ptr; 2297 (*ccb_Q)->ccb_h.ccb_ccb_ptr = (char *)ccb; 2298 } 2299 2300 *ccb_Q = ccb; 2301 } 2302 2303 /* shall be called at lock_driver() */ 2304 static void 2305 hpt_free_ccb(union ccb **ccb_Q, union ccb *ccb) 2306 { 2307 union ccb *TempCCB; 2308 2309 TempCCB = *ccb_Q; 2310 2311 if(ccb->ccb_h.ccb_ccb_ptr == ccb) /*it means SCpnt is the last one in CURRCMDs*/ 2312 *ccb_Q = NULL; 2313 else { 2314 while(TempCCB->ccb_h.ccb_ccb_ptr != (char *)ccb) 2315 TempCCB = (union ccb *)TempCCB->ccb_h.ccb_ccb_ptr; 2316 2317 TempCCB->ccb_h.ccb_ccb_ptr = ccb->ccb_h.ccb_ccb_ptr; 2318 2319 if(*ccb_Q == ccb) 2320 *ccb_Q = TempCCB; 2321 } 2322 } 2323 2324 #ifdef SUPPORT_ARRAY 2325 /*************************************************************************** 2326 * Function: hpt_worker_thread 2327 * Description: Do background rebuilding. Execute in kernel thread context. 2328 * Returns: None 2329 ***************************************************************************/ 2330 static void hpt_worker_thread(void) 2331 { 2332 intrmask_t oldspl; 2333 2334 for(;;) { 2335 while (DpcQueue_First!=DpcQueue_Last) { 2336 ST_HPT_DPC p; 2337 oldspl = lock_driver(); 2338 p = DpcQueue[DpcQueue_First]; 2339 DpcQueue_First++; 2340 DpcQueue_First %= MAX_DPC; 2341 DPC_Request_Nums++; 2342 unlock_driver(oldspl); 2343 p.dpc(p.pAdapter, p.arg, p.flags); 2344 2345 oldspl = lock_driver(); 2346 DPC_Request_Nums--; 2347 /* since we may have prevented Check_Idle_Call, do it here */ 2348 if (DPC_Request_Nums==0) { 2349 if (p.pAdapter->outstandingCommands == 0) { 2350 _VBUS_INST(&p.pAdapter->VBus); 2351 Check_Idle_Call(p.pAdapter); 2352 CheckPendingCall(_VBUS_P0); 2353 } 2354 } 2355 unlock_driver(oldspl); 2356 2357 /*Schedule out*/ 2358 #if (__FreeBSD_version < 500000) 2359 YIELD_THREAD; 2360 #else 2361 pause("sched", 1); 2362 #endif 2363 if (SIGISMEMBER(curproc->p_siglist, SIGSTOP)) { 2364 /* abort rebuilding process. */ 2365 IAL_ADAPTER_T *pAdapter; 2366 PVDevice pArray; 2367 PVBus _vbus_p; 2368 int i; 2369 pAdapter = gIal_Adapter; 2370 2371 while(pAdapter != 0){ 2372 2373 _vbus_p = &pAdapter->VBus; 2374 2375 for (i=0;i<MAX_ARRAY_PER_VBUS;i++) 2376 { 2377 if ((pArray=ArrayTables(i))->u.array.dArStamp==0) 2378 continue; 2379 else if (pArray->u.array.rf_rebuilding || 2380 pArray->u.array.rf_verifying || 2381 pArray->u.array.rf_initializing) 2382 { 2383 pArray->u.array.rf_abort_rebuild = 1; 2384 } 2385 } 2386 pAdapter = pAdapter->next; 2387 } 2388 } 2389 } 2390 2391 /*Remove this debug option*/ 2392 /* 2393 #ifdef DEBUG 2394 if (SIGISMEMBER(curproc->p_siglist, SIGSTOP)) 2395 pause("hptrdy", 2*hz); 2396 #endif 2397 */ 2398 #if (__FreeBSD_version >= 500043) 2399 kproc_suspend_check(curproc); 2400 #else 2401 kproc_suspend_loop(curproc); 2402 #endif 2403 pause("hptrdy", 2*hz); /* wait for something to do */ 2404 } 2405 } 2406 2407 static struct proc *hptdaemonproc; 2408 static struct kproc_desc hpt_kp = { 2409 "hpt_wt", 2410 hpt_worker_thread, 2411 &hptdaemonproc 2412 }; 2413 2414 /*Start this thread in the hpt_attach, to prevent kernel from loading it without our controller.*/ 2415 static void 2416 launch_worker_thread(void) 2417 { 2418 IAL_ADAPTER_T *pAdapTemp; 2419 2420 kproc_start(&hpt_kp); 2421 2422 for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next) { 2423 2424 _VBUS_INST(&pAdapTemp->VBus) 2425 int i; 2426 PVDevice pVDev; 2427 2428 for(i = 0; i < MAX_ARRAY_PER_VBUS; i++) 2429 if ((pVDev=ArrayTables(i))->u.array.dArStamp==0) 2430 continue; 2431 else{ 2432 if (pVDev->u.array.rf_need_rebuild && !pVDev->u.array.rf_rebuilding) 2433 hpt_queue_dpc((HPT_DPC)hpt_rebuild_data_block, pAdapTemp, pVDev, 2434 (UCHAR)((pVDev->u.array.CriticalMembers || pVDev->VDeviceType == VD_RAID_1)? DUPLICATE : REBUILD_PARITY)); 2435 } 2436 } 2437 2438 /* 2439 * hpt_worker_thread needs to be suspended after shutdown sync, when fs sync finished. 2440 */ 2441 #if (__FreeBSD_version < 500043) 2442 EVENTHANDLER_REGISTER(shutdown_post_sync, shutdown_kproc, hptdaemonproc, SHUTDOWN_PRI_FIRST); 2443 #else 2444 EVENTHANDLER_REGISTER(shutdown_post_sync, kproc_shutdown, hptdaemonproc, SHUTDOWN_PRI_FIRST); 2445 #endif 2446 } 2447 /* 2448 *SYSINIT(hptwt, SI_SUB_KTHREAD_IDLE, SI_ORDER_FIRST, launch_worker_thread, NULL); 2449 */ 2450 2451 #endif 2452 2453 /********************************************************************************/ 2454 2455 int HPTLIBAPI fOsBuildSgl(_VBUS_ARG PCommand pCmd, FPSCAT_GATH pSg, int logical) 2456 { 2457 union ccb *ccb = (union ccb *)pCmd->pOrgCommand; 2458 bus_dma_segment_t *sgList = (bus_dma_segment_t *)ccb->csio.data_ptr; 2459 int idx; 2460 2461 if(logical) { 2462 if (ccb->ccb_h.flags & CAM_DATA_PHYS) 2463 panic("physical address unsupported"); 2464 2465 if (ccb->ccb_h.flags & CAM_SCATTER_VALID) { 2466 if (ccb->ccb_h.flags & CAM_SG_LIST_PHYS) 2467 panic("physical address unsupported"); 2468 2469 for (idx = 0; idx < ccb->csio.sglist_cnt; idx++) { 2470 pSg[idx].dSgAddress = (ULONG_PTR)(UCHAR *)sgList[idx].ds_addr; 2471 pSg[idx].wSgSize = sgList[idx].ds_len; 2472 pSg[idx].wSgFlag = (idx==ccb->csio.sglist_cnt-1)? SG_FLAG_EOT : 0; 2473 } 2474 } 2475 else { 2476 pSg->dSgAddress = (ULONG_PTR)(UCHAR *)ccb->csio.data_ptr; 2477 pSg->wSgSize = ccb->csio.dxfer_len; 2478 pSg->wSgFlag = SG_FLAG_EOT; 2479 } 2480 return TRUE; 2481 } 2482 2483 /* since we have provided physical sg, nobody will ask us to build physical sg */ 2484 HPT_ASSERT(0); 2485 return FALSE; 2486 } 2487 2488 /*******************************************************************************/ 2489 ULONG HPTLIBAPI 2490 GetStamp(void) 2491 { 2492 /* 2493 * the system variable, ticks, can't be used since it hasn't yet been active 2494 * when our driver starts (ticks==0, it's a invalid stamp value) 2495 */ 2496 ULONG stamp; 2497 do { stamp = random(); } while (stamp==0); 2498 return stamp; 2499 } 2500 2501 2502 static void 2503 SetInquiryData(PINQUIRYDATA inquiryData, PVDevice pVDev) 2504 { 2505 int i; 2506 IDENTIFY_DATA2 *pIdentify = (IDENTIFY_DATA2*)pVDev->u.disk.mv->identifyDevice; 2507 2508 inquiryData->DeviceType = T_DIRECT; /*DIRECT_ACCESS_DEVICE*/ 2509 inquiryData->AdditionalLength = (UCHAR)(sizeof(INQUIRYDATA) - 5); 2510 #ifndef SERIAL_CMDS 2511 inquiryData->CommandQueue = 1; 2512 #endif 2513 2514 switch(pVDev->VDeviceType) { 2515 case VD_SINGLE_DISK: 2516 case VD_ATAPI: 2517 case VD_REMOVABLE: 2518 /* Set the removable bit, if applicable. */ 2519 if ((pVDev->u.disk.df_removable_drive) || (pIdentify->GeneralConfiguration & 0x80)) 2520 inquiryData->RemovableMedia = 1; 2521 2522 /* Fill in vendor identification fields. */ 2523 for (i = 0; i < 20; i += 2) { 2524 inquiryData->VendorId[i] = ((PUCHAR)pIdentify->ModelNumber)[i + 1]; 2525 inquiryData->VendorId[i+1] = ((PUCHAR)pIdentify->ModelNumber)[i]; 2526 2527 } 2528 2529 /* Initialize unused portion of product id. */ 2530 for (i = 0; i < 4; i++) inquiryData->ProductId[12+i] = ' '; 2531 2532 /* firmware revision */ 2533 for (i = 0; i < 4; i += 2) 2534 { 2535 inquiryData->ProductRevisionLevel[i] = ((PUCHAR)pIdentify->FirmwareRevision)[i+1]; 2536 inquiryData->ProductRevisionLevel[i+1] = ((PUCHAR)pIdentify->FirmwareRevision)[i]; 2537 } 2538 break; 2539 default: 2540 memcpy(&inquiryData->VendorId, "RR182x ", 8); 2541 #ifdef SUPPORT_ARRAY 2542 switch(pVDev->VDeviceType){ 2543 case VD_RAID_0: 2544 if ((pVDev->u.array.pMember[0] && mIsArray(pVDev->u.array.pMember[0])) || 2545 (pVDev->u.array.pMember[1] && mIsArray(pVDev->u.array.pMember[1]))) 2546 memcpy(&inquiryData->ProductId, "RAID 1/0 Array ", 16); 2547 else 2548 memcpy(&inquiryData->ProductId, "RAID 0 Array ", 16); 2549 break; 2550 case VD_RAID_1: 2551 if ((pVDev->u.array.pMember[0] && mIsArray(pVDev->u.array.pMember[0])) || 2552 (pVDev->u.array.pMember[1] && mIsArray(pVDev->u.array.pMember[1]))) 2553 memcpy(&inquiryData->ProductId, "RAID 0/1 Array ", 16); 2554 else 2555 memcpy(&inquiryData->ProductId, "RAID 1 Array ", 16); 2556 break; 2557 case VD_RAID_5: 2558 memcpy(&inquiryData->ProductId, "RAID 5 Array ", 16); 2559 break; 2560 case VD_JBOD: 2561 memcpy(&inquiryData->ProductId, "JBOD Array ", 16); 2562 break; 2563 } 2564 #endif 2565 memcpy(&inquiryData->ProductRevisionLevel, "3.00", 4); 2566 break; 2567 } 2568 } 2569 2570 static void 2571 hpt_timeout(void *arg) 2572 { 2573 _VBUS_INST(&((PBUS_DMAMAP)((union ccb *)arg)->ccb_adapter)->pAdapter->VBus) 2574 intrmask_t oldspl = lock_driver(); 2575 fResetVBus(_VBUS_P0); 2576 unlock_driver(oldspl); 2577 } 2578 2579 static void 2580 hpt_io_dmamap_callback(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 2581 { 2582 PCommand pCmd = (PCommand)arg; 2583 union ccb *ccb = pCmd->pOrgCommand; 2584 struct ccb_hdr *ccb_h = &ccb->ccb_h; 2585 PBUS_DMAMAP pmap = (PBUS_DMAMAP) ccb->ccb_adapter; 2586 IAL_ADAPTER_T *pAdapter = pmap->pAdapter; 2587 PVDevice pVDev = pAdapter->VBus.pVDevice[ccb_h->target_id]; 2588 FPSCAT_GATH psg = pCmd->pSgTable; 2589 int idx; 2590 _VBUS_INST(pVDev->pVBus) 2591 2592 HPT_ASSERT(pCmd->cf_physical_sg); 2593 2594 if (error || nsegs == 0) 2595 panic("busdma error"); 2596 2597 HPT_ASSERT(nsegs<= MAX_SG_DESCRIPTORS); 2598 2599 for (idx = 0; idx < nsegs; idx++, psg++) { 2600 psg->dSgAddress = (ULONG_PTR)(UCHAR *)segs[idx].ds_addr; 2601 psg->wSgSize = segs[idx].ds_len; 2602 psg->wSgFlag = (idx == nsegs-1)? SG_FLAG_EOT: 0; 2603 /* KdPrint(("psg[%d]:add=%p,size=%x,flag=%x\n", idx, psg->dSgAddress,psg->wSgSize,psg->wSgFlag)); */ 2604 } 2605 /* psg[-1].wSgFlag = SG_FLAG_EOT; */ 2606 2607 if (pCmd->cf_data_in) { 2608 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map, BUS_DMASYNC_PREREAD); 2609 } 2610 else if (pCmd->cf_data_out) { 2611 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map, BUS_DMASYNC_PREWRITE); 2612 } 2613 2614 ccb->ccb_h.timeout_ch = timeout(hpt_timeout, (caddr_t)ccb, 20*hz); 2615 pVDev->pfnSendCommand(_VBUS_P pCmd); 2616 CheckPendingCall(_VBUS_P0); 2617 } 2618 2619 2620 2621 static void HPTLIBAPI 2622 OsSendCommand(_VBUS_ARG union ccb *ccb) 2623 { 2624 PBUS_DMAMAP pmap = (PBUS_DMAMAP)ccb->ccb_adapter; 2625 IAL_ADAPTER_T *pAdapter = pmap->pAdapter; 2626 struct ccb_hdr *ccb_h = &ccb->ccb_h; 2627 struct ccb_scsiio *csio = &ccb->csio; 2628 PVDevice pVDev = pAdapter->VBus.pVDevice[ccb_h->target_id]; 2629 2630 KdPrintI(("OsSendCommand: ccb %p cdb %x-%x-%x\n", 2631 ccb, 2632 *(ULONG *)&ccb->csio.cdb_io.cdb_bytes[0], 2633 *(ULONG *)&ccb->csio.cdb_io.cdb_bytes[4], 2634 *(ULONG *)&ccb->csio.cdb_io.cdb_bytes[8] 2635 )); 2636 2637 pAdapter->outstandingCommands++; 2638 2639 if (pVDev == NULL || pVDev->vf_online == 0) { 2640 ccb->ccb_h.status = CAM_REQ_INVALID; 2641 ccb_done(ccb); 2642 goto Command_Complished; 2643 } 2644 2645 switch(ccb->csio.cdb_io.cdb_bytes[0]) 2646 { 2647 case TEST_UNIT_READY: 2648 case START_STOP_UNIT: 2649 case SYNCHRONIZE_CACHE: 2650 /* FALLTHROUGH */ 2651 ccb->ccb_h.status = CAM_REQ_CMP; 2652 break; 2653 2654 case INQUIRY: 2655 ZeroMemory(ccb->csio.data_ptr, ccb->csio.dxfer_len); 2656 SetInquiryData((PINQUIRYDATA)ccb->csio.data_ptr, pVDev); 2657 ccb_h->status = CAM_REQ_CMP; 2658 break; 2659 2660 case READ_CAPACITY: 2661 { 2662 UCHAR swip[4]; 2663 /* Claim 512 byte blocks (big-endian). */ 2664 ((PREAD_CAPACITY_DATA)csio->data_ptr)->BytesPerBlock = 0x20000; 2665 *(ULONG*)swip = pVDev->VDeviceCapacity - 1; 2666 ((PREAD_CAPACITY_DATA)csio->data_ptr)->LogicalBlockAddress = 2667 (swip[0] << 24) | (swip[1] << 16) | (swip[2] << 8) | swip[3]; 2668 ccb_h->status = CAM_REQ_CMP; 2669 break; 2670 } 2671 2672 case READ_6: 2673 case WRITE_6: 2674 case READ_10: 2675 case WRITE_10: 2676 case 0x13: 2677 case 0x2f: 2678 { 2679 UCHAR Cdb[16]; 2680 UCHAR CdbLength; 2681 _VBUS_INST(pVDev->pVBus) 2682 PCommand pCmd = AllocateCommand(_VBUS_P0); 2683 HPT_ASSERT(pCmd); 2684 2685 CdbLength = csio->cdb_len; 2686 if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0) 2687 { 2688 if ((ccb->ccb_h.flags & CAM_CDB_PHYS) == 0) 2689 { 2690 bcopy(csio->cdb_io.cdb_ptr, Cdb, CdbLength); 2691 } 2692 else 2693 { 2694 KdPrintE(("ERROR!!!\n")); 2695 ccb->ccb_h.status = CAM_REQ_INVALID; 2696 break; 2697 } 2698 } 2699 else 2700 { 2701 bcopy(csio->cdb_io.cdb_bytes, Cdb, CdbLength); 2702 } 2703 2704 pCmd->pOrgCommand = ccb; 2705 pCmd->pVDevice = pVDev; 2706 pCmd->pfnCompletion = fOsCommandDone; 2707 pCmd->pfnBuildSgl = fOsBuildSgl; 2708 pCmd->pSgTable = pmap->psg; 2709 2710 switch (Cdb[0]) 2711 { 2712 case READ_6: 2713 case WRITE_6: 2714 case 0x13: 2715 pCmd->uCmd.Ide.Lba = ((ULONG)Cdb[1] << 16) | ((ULONG)Cdb[2] << 8) | (ULONG)Cdb[3]; 2716 pCmd->uCmd.Ide.nSectors = (USHORT) Cdb[4]; 2717 break; 2718 2719 default: 2720 pCmd->uCmd.Ide.Lba = (ULONG)Cdb[5] | ((ULONG)Cdb[4] << 8) | ((ULONG)Cdb[3] << 16) | ((ULONG)Cdb[2] << 24); 2721 pCmd->uCmd.Ide.nSectors = (USHORT) Cdb[8] | ((USHORT)Cdb[7]<<8); 2722 break; 2723 } 2724 2725 switch (Cdb[0]) 2726 { 2727 case READ_6: 2728 case READ_10: 2729 pCmd->uCmd.Ide.Command = IDE_COMMAND_READ; 2730 pCmd->cf_data_in = 1; 2731 break; 2732 2733 case WRITE_6: 2734 case WRITE_10: 2735 pCmd->uCmd.Ide.Command = IDE_COMMAND_WRITE; 2736 pCmd->cf_data_out = 1; 2737 break; 2738 case 0x13: 2739 case 0x2f: 2740 pCmd->uCmd.Ide.Command = IDE_COMMAND_VERIFY; 2741 break; 2742 } 2743 /*///////////////////////// */ 2744 if (ccb->ccb_h.flags & CAM_SCATTER_VALID) { 2745 int idx; 2746 bus_dma_segment_t *sgList = (bus_dma_segment_t *)ccb->csio.data_ptr; 2747 2748 if (ccb->ccb_h.flags & CAM_SG_LIST_PHYS) 2749 pCmd->cf_physical_sg = 1; 2750 2751 for (idx = 0; idx < ccb->csio.sglist_cnt; idx++) { 2752 pCmd->pSgTable[idx].dSgAddress = (ULONG_PTR)(UCHAR *)sgList[idx].ds_addr; 2753 pCmd->pSgTable[idx].wSgSize = sgList[idx].ds_len; 2754 pCmd->pSgTable[idx].wSgFlag= (idx==ccb->csio.sglist_cnt-1)?SG_FLAG_EOT: 0; 2755 } 2756 2757 ccb->ccb_h.timeout_ch = timeout(hpt_timeout, (caddr_t)ccb, 20*hz); 2758 pVDev->pfnSendCommand(_VBUS_P pCmd); 2759 } 2760 else { 2761 int error; 2762 pCmd->cf_physical_sg = 1; 2763 error = bus_dmamap_load(pAdapter->io_dma_parent, 2764 pmap->dma_map, 2765 ccb->csio.data_ptr, ccb->csio.dxfer_len, 2766 hpt_io_dmamap_callback, pCmd, 2767 BUS_DMA_WAITOK 2768 ); 2769 KdPrint(("bus_dmamap_load return %d\n", error)); 2770 if (error && error!=EINPROGRESS) { 2771 hpt_printk(("bus_dmamap_load error %d\n", error)); 2772 FreeCommand(_VBUS_P pCmd); 2773 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 2774 dmamap_put(pmap); 2775 pAdapter->outstandingCommands--; 2776 xpt_done(ccb); 2777 } 2778 } 2779 goto Command_Complished; 2780 } 2781 2782 default: 2783 ccb->ccb_h.status = CAM_REQ_INVALID; 2784 break; 2785 } 2786 ccb_done(ccb); 2787 Command_Complished: 2788 CheckPendingCall(_VBUS_P0); 2789 return; 2790 } 2791 2792 static void HPTLIBAPI 2793 fOsCommandDone(_VBUS_ARG PCommand pCmd) 2794 { 2795 union ccb *ccb = pCmd->pOrgCommand; 2796 PBUS_DMAMAP pmap = (PBUS_DMAMAP)ccb->ccb_adapter; 2797 IAL_ADAPTER_T *pAdapter = pmap->pAdapter; 2798 2799 KdPrint(("fOsCommandDone(pcmd=%p, result=%d)\n", pCmd, pCmd->Result)); 2800 2801 untimeout(hpt_timeout, (caddr_t)ccb, ccb->ccb_h.timeout_ch); 2802 2803 switch(pCmd->Result) { 2804 case RETURN_SUCCESS: 2805 ccb->ccb_h.status = CAM_REQ_CMP; 2806 break; 2807 case RETURN_BAD_DEVICE: 2808 ccb->ccb_h.status = CAM_DEV_NOT_THERE; 2809 break; 2810 case RETURN_DEVICE_BUSY: 2811 ccb->ccb_h.status = CAM_BUSY; 2812 break; 2813 case RETURN_INVALID_REQUEST: 2814 ccb->ccb_h.status = CAM_REQ_INVALID; 2815 break; 2816 case RETURN_SELECTION_TIMEOUT: 2817 ccb->ccb_h.status = CAM_SEL_TIMEOUT; 2818 break; 2819 case RETURN_RETRY: 2820 ccb->ccb_h.status = CAM_BUSY; 2821 break; 2822 default: 2823 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 2824 break; 2825 } 2826 2827 if (pCmd->cf_data_in) { 2828 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map, BUS_DMASYNC_POSTREAD); 2829 } 2830 else if (pCmd->cf_data_in) { 2831 bus_dmamap_sync(pAdapter->io_dma_parent, pmap->dma_map, BUS_DMASYNC_POSTWRITE); 2832 } 2833 2834 bus_dmamap_unload(pAdapter->io_dma_parent, pmap->dma_map); 2835 2836 FreeCommand(_VBUS_P pCmd); 2837 ccb_done(ccb); 2838 } 2839 2840 int 2841 hpt_queue_dpc(HPT_DPC dpc, IAL_ADAPTER_T * pAdapter, void *arg, UCHAR flags) 2842 { 2843 int p; 2844 2845 p = (DpcQueue_Last + 1) % MAX_DPC; 2846 if (p==DpcQueue_First) { 2847 KdPrint(("DPC Queue full!\n")); 2848 return -1; 2849 } 2850 2851 DpcQueue[DpcQueue_Last].dpc = dpc; 2852 DpcQueue[DpcQueue_Last].pAdapter = pAdapter; 2853 DpcQueue[DpcQueue_Last].arg = arg; 2854 DpcQueue[DpcQueue_Last].flags = flags; 2855 DpcQueue_Last = p; 2856 2857 return 0; 2858 } 2859 2860 #ifdef _RAID5N_ 2861 /* 2862 * Allocate memory above 16M, otherwise we may eat all low memory for ISA devices. 2863 * How about the memory for 5081 request/response array and PRD table? 2864 */ 2865 void 2866 *os_alloc_page(_VBUS_ARG0) 2867 { 2868 return (void *)contigmalloc(0x1000, M_DEVBUF, M_NOWAIT, 0x1000000, 0xffffffff, PAGE_SIZE, 0ul); 2869 } 2870 2871 void 2872 *os_alloc_dma_page(_VBUS_ARG0) 2873 { 2874 return (void *)contigmalloc(0x1000, M_DEVBUF, M_NOWAIT, 0x1000000, 0xffffffff, PAGE_SIZE, 0ul); 2875 } 2876 2877 void 2878 os_free_page(_VBUS_ARG void *p) 2879 { 2880 contigfree(p, 0x1000, M_DEVBUF); 2881 } 2882 2883 void 2884 os_free_dma_page(_VBUS_ARG void *p) 2885 { 2886 contigfree(p, 0x1000, M_DEVBUF); 2887 } 2888 2889 void 2890 DoXor1(ULONG *p0, ULONG *p1, ULONG *p2, UINT nBytes) 2891 { 2892 UINT i; 2893 for (i = 0; i < nBytes / 4; i++) *p0++ = *p1++ ^ *p2++; 2894 } 2895 2896 void 2897 DoXor2(ULONG *p0, ULONG *p2, UINT nBytes) 2898 { 2899 UINT i; 2900 for (i = 0; i < nBytes / 4; i++) *p0++ ^= *p2++; 2901 } 2902 #endif 2903