2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2004-2005 HighPoint Technologies, Inc.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * Copyright (c) 2002-2004 HighPoint Technologies, Inc. All rights reserved.
34 * Platform independent ioctl interface implementation.
35 * The platform dependent part may reuse this function and/or use it own
36 * implementation for each ioctl function.
38 * This implementation doesn't use any synchronization; the caller must
39 * assure the proper context when calling these functions.
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/malloc.h>
51 #include <dev/hptmv/global.h>
52 #include <dev/hptmv/hptintf.h>
53 #include <dev/hptmv/osbsd.h>
54 #include <dev/hptmv/access601.h>
56 static int hpt_get_driver_capabilities(PDRIVER_CAPABILITIES cap);
57 static int hpt_get_controller_count(void);
58 static int hpt_get_controller_info(int id, PCONTROLLER_INFO pInfo);
59 static int hpt_get_channel_info(int id, int bus, PCHANNEL_INFO pInfo);
60 static int hpt_get_logical_devices(DEVICEID * pIds, int nMaxCount);
61 static int hpt_get_device_info(DEVICEID id, PLOGICAL_DEVICE_INFO pInfo);
62 static int hpt_get_device_info_v2(DEVICEID id, PLOGICAL_DEVICE_INFO_V2 pInfo);
63 static DEVICEID hpt_create_array(_VBUS_ARG PCREATE_ARRAY_PARAMS pParam);
64 static DEVICEID hpt_create_array_v2(_VBUS_ARG PCREATE_ARRAY_PARAMS_V2 pParam);
65 static int hpt_add_spare_disk(_VBUS_ARG DEVICEID idDisk);
66 static int hpt_remove_spare_disk(_VBUS_ARG DEVICEID idDisk);
67 static int hpt_set_array_info(_VBUS_ARG DEVICEID idArray, PALTERABLE_ARRAY_INFO pInfo);
68 static int hpt_set_device_info(_VBUS_ARG DEVICEID idDisk, PALTERABLE_DEVICE_INFO pInfo);
69 static int hpt_set_device_info_v2(_VBUS_ARG DEVICEID idDisk, PALTERABLE_DEVICE_INFO_V2 pInfo);
72 check_VDevice_valid(PVDevice p)
77 IAL_ADAPTER_T *pAdapter = gIal_Adapter;
79 while(pAdapter != NULL)
81 for (i = 0; i < MV_SATA_CHANNELS_NUM; i++)
82 if(&(pAdapter->VDevices[i]) == p) return 0;
83 pAdapter = pAdapter->next;
87 pAdapter = gIal_Adapter;
88 while(pAdapter != NULL)
90 _vbus_p = &pAdapter->VBus;
91 for (i=0;i<MAX_ARRAY_PER_VBUS;i++)
93 pVDevice=ArrayTables(i);
94 if ((pVDevice->u.array.dArStamp != 0) && (pVDevice == p))
97 pAdapter = pAdapter->next;
106 static UCHAR get_vdev_type(PVDevice pVDevice)
108 switch (pVDevice->VDeviceType) {
109 case VD_RAID_0: return AT_RAID0;
110 case VD_RAID_1: return AT_RAID1;
111 case VD_JBOD: return AT_JBOD;
112 case VD_RAID_5: return AT_RAID5;
113 default: return AT_UNKNOWN;
117 static DWORD get_array_flag(PVDevice pVDevice)
122 /* The array is disabled */
123 if(!pVDevice->vf_online) {
124 f |= ARRAY_FLAG_DISABLED;
125 /* Ignore other info */
129 /* array need synchronizing */
130 if(pVDevice->u.array.rf_need_rebuild && !pVDevice->u.array.rf_duplicate_and_create)
131 f |= ARRAY_FLAG_NEEDBUILDING;
133 /* array is in rebuilding process */
134 if(pVDevice->u.array.rf_rebuilding)
135 f |= ARRAY_FLAG_REBUILDING;
137 /* array is being verified */
138 if(pVDevice->u.array.rf_verifying)
139 f |= ARRAY_FLAG_VERIFYING;
141 /* array is being initialized */
142 if(pVDevice->u.array.rf_initializing)
143 f |= ARRAY_FLAG_INITIALIZING;
145 /* broken but may still working */
146 if(pVDevice->u.array.rf_broken)
147 f |= ARRAY_FLAG_BROKEN;
149 /* array has a active partition */
150 if(pVDevice->vf_bootable)
151 f |= ARRAY_FLAG_BOOTDISK;
153 /* a newly created array */
154 if(pVDevice->u.array.rf_newly_created)
155 f |= ARRAY_FLAG_NEWLY_CREATED;
157 /* array has boot mark set */
158 if(pVDevice->vf_bootmark)
159 f |= ARRAY_FLAG_BOOTMARK;
161 /* auto-rebuild should start */
162 if(pVDevice->u.array.rf_auto_rebuild)
163 f |= ARRAY_FLAG_NEED_AUTOREBUILD;
165 for(i = 0; i < pVDevice->u.array.bArnMember; i++)
167 PVDevice pMember = pVDevice->u.array.pMember[i];
168 if (!pMember || !pMember->vf_online || (pMember->VDeviceType==VD_SINGLE_DISK))
171 /* array need synchronizing */
172 if(pMember->u.array.rf_need_rebuild &&
173 !pMember->u.array.rf_duplicate_and_create)
174 f |= ARRAY_FLAG_NEEDBUILDING;
176 /* array is in rebuilding process */
177 if(pMember->u.array.rf_rebuilding)
178 f |= ARRAY_FLAG_REBUILDING;
180 /* array is being verified */
181 if(pMember->u.array.rf_verifying)
182 f |= ARRAY_FLAG_VERIFYING;
184 /* array is being initialized */
185 if(pMember->u.array.rf_initializing)
186 f |= ARRAY_FLAG_INITIALIZING;
188 /* broken but may still working */
189 if(pMember->u.array.rf_broken)
190 f |= ARRAY_FLAG_BROKEN;
192 /* a newly created array */
193 if(pMember->u.array.rf_newly_created)
194 f |= ARRAY_FLAG_NEWLY_CREATED;
196 /* auto-rebuild should start */
197 if(pMember->u.array.rf_auto_rebuild)
198 f |= ARRAY_FLAG_NEED_AUTOREBUILD;
204 static DWORD calc_rebuild_progress(PVDevice pVDevice)
207 DWORD result = ((ULONG)(pVDevice->u.array.RebuildSectors>>11)*1000 /
208 (ULONG)(pVDevice->VDeviceCapacity>>11) * (pVDevice->u.array.bArnMember-1)) * 10;
210 for(i = 0; i < pVDevice->u.array.bArnMember; i++)
212 PVDevice pMember = pVDevice->u.array.pMember[i];
213 if (!pMember || !pMember->vf_online || (pMember->VDeviceType==VD_SINGLE_DISK))
216 /* for RAID1/0 case */
217 if (pMember->u.array.rf_rebuilding ||
218 pMember->u.array.rf_verifying ||
219 pMember->u.array.rf_initializing)
221 DWORD percent = ((ULONG)(pMember->u.array.RebuildSectors>>11)*1000 /
222 (ULONG)(pMember->VDeviceCapacity>>11) * (pMember->u.array.bArnMember-1)) * 10;
223 if (result==0 || result>percent)
228 if (result>10000) result = 10000;
232 static void get_array_info(PVDevice pVDevice, PHPT_ARRAY_INFO pArrayInfo)
236 memcpy(pArrayInfo->Name, pVDevice->u.array.ArrayName, MAX_ARRAY_NAME);
237 pArrayInfo->ArrayType = get_vdev_type(pVDevice);
238 pArrayInfo->BlockSizeShift = pVDevice->u.array.bArBlockSizeShift;
239 pArrayInfo->RebuiltSectors = pVDevice->u.array.RebuildSectors;
240 pArrayInfo->Flags = get_array_flag(pVDevice);
241 pArrayInfo->RebuildingProgress = calc_rebuild_progress(pVDevice);
243 pArrayInfo->nDisk = 0;
245 for(i = 0; i < pVDevice->u.array.bArnMember; i++)
246 if(pVDevice->u.array.pMember[i] != NULL)
247 pArrayInfo->Members[pArrayInfo->nDisk++] = VDEV_TO_ID(pVDevice->u.array.pMember[i]);
249 for(i=pArrayInfo->nDisk; i<MAX_ARRAY_MEMBERS; i++)
250 pArrayInfo->Members[i] = INVALID_DEVICEID;
253 static void get_array_info_v2(PVDevice pVDevice, PHPT_ARRAY_INFO_V2 pArrayInfo)
257 memcpy(pArrayInfo->Name, pVDevice->u.array.ArrayName, MAX_ARRAYNAME_LEN);
258 pArrayInfo->ArrayType = get_vdev_type(pVDevice);
259 pArrayInfo->BlockSizeShift = pVDevice->u.array.bArBlockSizeShift;
260 pArrayInfo->RebuiltSectors.lo32 = pVDevice->u.array.RebuildSectors;
261 pArrayInfo->RebuiltSectors.hi32 = sizeof(LBA_T)>4? (pVDevice->u.array.RebuildSectors>>32) : 0;
262 pArrayInfo->Flags = get_array_flag(pVDevice);
263 pArrayInfo->RebuildingProgress = calc_rebuild_progress(pVDevice);
265 pArrayInfo->nDisk = 0;
267 for(i = 0; i < pVDevice->u.array.bArnMember; i++)
268 if(pVDevice->u.array.pMember[i] != NULL)
269 pArrayInfo->Members[pArrayInfo->nDisk++] = VDEV_TO_ID(pVDevice->u.array.pMember[i]);
271 for(i=pArrayInfo->nDisk; i<MAX_ARRAY_MEMBERS_V2; i++)
272 pArrayInfo->Members[i] = INVALID_DEVICEID;
276 static int get_disk_info(PVDevice pVDevice, PDEVICE_INFO pDiskInfo)
278 MV_SATA_ADAPTER *pSataAdapter;
279 MV_SATA_CHANNEL *pSataChannel;
280 IAL_ADAPTER_T *pAdapter;
281 MV_CHANNEL *channelInfo;
285 /* device location */
286 pSataChannel = pVDevice->u.disk.mv;
287 if(pSataChannel == NULL) return -1;
288 pDiskInfo->TargetId = 0;
289 pSataAdapter = pSataChannel->mvSataAdapter;
290 if(pSataAdapter == NULL) return -1;
292 pAdapter = pSataAdapter->IALData;
294 pDiskInfo->PathId = pSataChannel->channelNumber;
295 pDiskInfo->ControllerId = (UCHAR)pSataAdapter->adapterId;
297 /*GUI uses DeviceModeSetting to display to users
298 (1) if users select a mode, GUI/BIOS should display that mode.
299 (2) if SATA/150, GUI/BIOS should display 150 if case (1) isn't satisfied.
300 (3) display real mode if case (1)&&(2) not satisfied.
302 if (pVDevice->u.disk.df_user_mode_set)
303 pDiskInfo->DeviceModeSetting = pVDevice->u.disk.bDeUserSelectMode;
304 else if (((((PIDENTIFY_DATA)pVDevice->u.disk.mv->identifyDevice)->SataCapability) & 3)==2)
305 pDiskInfo->DeviceModeSetting = 15;
307 p = (char *)&((PIDENTIFY_DATA)pVDevice->u.disk.mv->identifyDevice)->ModelNumber;
308 if (*(WORD*)p==(0x5354) /*'ST'*/ &&
309 (*(WORD*)(p+8)==(0x4153)/*'AS'*/ || (p[8]=='A' && p[11]=='S')))
310 pDiskInfo->DeviceModeSetting = 15;
312 pDiskInfo->DeviceModeSetting = pVDevice->u.disk.bDeModeSetting;
315 pDiskInfo->UsableMode = pVDevice->u.disk.bDeUsable_Mode;
317 pDiskInfo->DeviceType = PDT_HARDDISK;
319 pDiskInfo->Flags = 0x0;
321 /* device is disabled */
322 if(!pVDevice->u.disk.df_on_line)
323 pDiskInfo->Flags |= DEVICE_FLAG_DISABLED;
325 /* disk has a active partition */
326 if(pVDevice->vf_bootable)
327 pDiskInfo->Flags |= DEVICE_FLAG_BOOTDISK;
329 /* disk has boot mark set */
330 if(pVDevice->vf_bootmark)
331 pDiskInfo->Flags |= DEVICE_FLAG_BOOTMARK;
333 pDiskInfo->Flags |= DEVICE_FLAG_SATA;
335 /* is a spare disk */
336 if(pVDevice->VDeviceType == VD_SPARE)
337 pDiskInfo->Flags |= DEVICE_FLAG_IS_SPARE;
339 memcpy(&(pDiskInfo->IdentifyData), (pSataChannel->identifyDevice), sizeof(IDENTIFY_DATA2));
340 p = (char *)&pDiskInfo->IdentifyData.ModelNumber;
341 for (i = 0; i < 20; i++)
342 ((WORD*)p)[i] = shortswap(pSataChannel->identifyDevice[IDEN_MODEL_OFFSET+i]);
345 channelInfo = &pAdapter->mvChannel[pSataChannel->channelNumber];
346 pDiskInfo->ReadAheadSupported = channelInfo->readAheadSupported;
347 pDiskInfo->ReadAheadEnabled = channelInfo->readAheadEnabled;
348 pDiskInfo->WriteCacheSupported = channelInfo->writeCacheSupported;
349 pDiskInfo->WriteCacheEnabled = channelInfo->writeCacheEnabled;
350 pDiskInfo->TCQSupported = (pSataChannel->identifyDevice[IDEN_SUPPORTED_COMMANDS2] & (0x2))!=0;
351 pDiskInfo->TCQEnabled = pSataChannel->queuedDMA==MV_EDMA_MODE_QUEUED;
352 pDiskInfo->NCQSupported = MV_SATA_GEN_2(pSataAdapter) &&
353 (pSataChannel->identifyDevice[IDEN_SATA_CAPABILITIES] & (0x0100));
354 pDiskInfo->NCQEnabled = pSataChannel->queuedDMA==MV_EDMA_MODE_NATIVE_QUEUING;
358 int hpt_get_driver_capabilities(PDRIVER_CAPABILITIES cap)
360 ZeroMemory(cap, sizeof(DRIVER_CAPABILITIES));
361 cap->dwSize = sizeof(DRIVER_CAPABILITIES);
362 cap->MaximumControllers = MAX_VBUS;
364 /* cap->SupportCrossControllerRAID = 0; */
365 /* take care for various OSes! */
366 cap->SupportCrossControllerRAID = 0;
369 cap->MinimumBlockSizeShift = MinBlockSizeShift;
370 cap->MaximumBlockSizeShift = MaxBlockSizeShift;
371 cap->SupportDiskModeSetting = 0;
372 cap->SupportSparePool = 1;
373 cap->MaximumArrayNameLength = MAX_ARRAY_NAME - 1;
374 cap->SupportDedicatedSpare = 0;
379 cap->SupportedRAIDTypes[0] = AT_RAID0;
380 cap->MaximumArrayMembers[0] = MAX_MEMBERS;
382 cap->SupportedRAIDTypes[1] = AT_RAID1;
383 cap->MaximumArrayMembers[1] = 2;
384 /* Mirror + Stripe */
386 cap->SupportedRAIDTypes[2] = (AT_RAID1<<4)|AT_RAID0; /* RAID0/1 */
388 cap->SupportedRAIDTypes[2] = (AT_RAID0<<4)|AT_RAID1; /* RAID1/0 */
390 cap->MaximumArrayMembers[2] = MAX_MEMBERS;
392 cap->SupportedRAIDTypes[3] = AT_JBOD;
393 cap->MaximumArrayMembers[3] = MAX_MEMBERS;
396 cap->SupportedRAIDTypes[4] = AT_RAID5;
397 cap->MaximumArrayMembers[4] = MAX_MEMBERS;
403 int hpt_get_controller_count(void)
405 IAL_ADAPTER_T *pAdapTemp = gIal_Adapter;
406 int iControllerCount = 0;
408 while(pAdapTemp != NULL)
411 pAdapTemp = pAdapTemp->next;
414 return iControllerCount;
417 int hpt_get_controller_info(int id, PCONTROLLER_INFO pInfo)
419 IAL_ADAPTER_T *pAdapTemp;
420 int iControllerCount = 0;
422 for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next) {
423 if (iControllerCount++==id) {
424 pInfo->InterruptLevel = 0;
426 pInfo->ChipFlags = CHIP_SUPPORT_ULTRA_100;
427 strcpy( pInfo->szVendorID, "HighPoint Technologies, Inc.");
428 #ifdef GUI_CONTROLLER_NAME
429 #ifdef FORCE_ATA150_DISPLAY
430 /* show "Bus Type: ATA/150" in GUI for SATA controllers */
431 pInfo->ChipFlags = CHIP_SUPPORT_ULTRA_150;
433 strcpy(pInfo->szProductID, GUI_CONTROLLER_NAME);
434 #define _set_product_id(x)
436 #define _set_product_id(x) strcpy(pInfo->szProductID, x)
438 _set_product_id("RocketRAID 18xx SATA Controller");
440 pInfo->ChipFlags |= CHIP_SUPPORT_ULTRA_133|CHIP_SUPPORT_ULTRA_150;
448 int hpt_get_channel_info(int id, int bus, PCHANNEL_INFO pInfo)
450 IAL_ADAPTER_T *pAdapTemp = gIal_Adapter;
451 int i,iControllerCount = 0;
453 while(pAdapTemp != NULL)
455 if (iControllerCount++==id)
457 pAdapTemp = pAdapTemp->next;
464 pInfo->ControlPort = 0;
468 pInfo->Devices[i] = (DEVICEID)INVALID_DEVICEID;
471 if (pAdapTemp->mvChannel[bus].online == MV_TRUE)
472 pInfo->Devices[0] = VDEV_TO_ID(&pAdapTemp->VDevices[bus]);
474 pInfo->Devices[0] = (DEVICEID)INVALID_DEVICEID;
481 int hpt_get_logical_devices(DEVICEID * pIds, int nMaxCount)
485 PVDevice pPhysical, pLogical;
486 IAL_ADAPTER_T *pAdapTemp;
488 for(i = 0; i < nMaxCount; i++)
489 pIds[i] = INVALID_DEVICEID;
491 /* append the arrays not registered on VBus */
492 for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next) {
493 for(i = 0; i < MV_SATA_CHANNELS_NUM; i++)
495 pPhysical = &pAdapTemp->VDevices[i];
496 pLogical = pPhysical;
498 while (pLogical->pParent) pLogical = pLogical->pParent;
499 if (pLogical->VDeviceType==VD_SPARE)
502 for (j=0; j<count; j++)
503 if (pIds[j]==VDEV_TO_ID(pLogical)) goto next;
504 pIds[count++] = VDEV_TO_ID(pLogical);
505 if (count>=nMaxCount) goto done;
514 int hpt_get_device_info(DEVICEID id, PLOGICAL_DEVICE_INFO pInfo)
516 PVDevice pVDevice = ID_TO_VDEV(id);
518 if((id == 0) || check_VDevice_valid(pVDevice))
522 if (mIsArray(pVDevice)) {
523 pInfo->Type = LDT_ARRAY;
524 pInfo->Capacity = pVDevice->VDeviceCapacity;
525 pInfo->ParentArray = VDEV_TO_ID(pVDevice->pParent);
526 get_array_info(pVDevice, &pInfo->u.array);
531 pInfo->Type = LDT_DEVICE;
532 pInfo->ParentArray = pVDevice->pParent? VDEV_TO_ID(pVDevice->pParent) : INVALID_DEVICEID;
533 /* report real capacity to be compatible with old arrays */
534 pInfo->Capacity = pVDevice->u.disk.dDeRealCapacity;
535 return get_disk_info(pVDevice, &pInfo->u.device);
538 int hpt_get_device_info_v2(DEVICEID id, PLOGICAL_DEVICE_INFO_V2 pInfo)
540 PVDevice pVDevice = ID_TO_VDEV(id);
542 if((id == 0) || check_VDevice_valid(pVDevice))
546 if (mIsArray(pVDevice)) {
547 pInfo->Type = LDT_ARRAY;
548 pInfo->Capacity.lo32 = pVDevice->VDeviceCapacity;
549 pInfo->Capacity.hi32 = sizeof(LBA_T)>4? (pVDevice->VDeviceCapacity>>32) : 0;
550 pInfo->ParentArray = VDEV_TO_ID(pVDevice->pParent);
551 get_array_info_v2(pVDevice, &pInfo->u.array);
556 pInfo->Type = LDT_DEVICE;
557 pInfo->ParentArray = pVDevice->pParent? VDEV_TO_ID(pVDevice->pParent) : INVALID_DEVICEID;
558 /* report real capacity to be compatible with old arrays */
559 pInfo->Capacity.lo32 = pVDevice->u.disk.dDeRealCapacity;
560 pInfo->Capacity.hi32 = 0;
561 return get_disk_info(pVDevice, &pInfo->u.device);
565 DEVICEID hpt_create_array_v2(_VBUS_ARG PCREATE_ARRAY_PARAMS_V2 pParam)
567 ULONG Stamp = GetStamp();
569 LBA_T capacity = MAX_LBA_T;
570 PVDevice pArray,pChild;
573 if (pParam->nDisk > MAX_MEMBERS)
574 return INVALID_DEVICEID;
575 /* check in verify_vd
576 for(i = 0; i < pParam->nDisk; i++)
578 PVDevice pVDev = ID_TO_VDEV(pParam->Members[i]);
579 if (check_VDevice_valid(pVDev)) return INVALID_DEVICEID;
580 if (mIsArray(pVDev)) return INVALID_DEVICEID;
581 if (!pVDev->vf_online) return INVALID_DEVICEID;
583 _vbus_p = pVDev->u.disk.pVBus;
584 else if (_vbus_p != pVDev->u.disk.pVBus)
585 return INVALID_DEVICEID;
588 _vbus_p = (ID_TO_VDEV(pParam->Members[0]))->u.disk.pVBus;
589 if (!_vbus_p) return INVALID_DEVICEID;
591 mArGetArrayTable(pArray);
592 if(!pArray) return INVALID_DEVICEID;
594 switch (pParam->ArrayType)
597 pArray->VDeviceType = VD_JBOD;
601 if((pParam->BlockSizeShift < MinBlockSizeShift) || (pParam->BlockSizeShift > MaxBlockSizeShift))
603 pArray->VDeviceType = VD_RAID_0;
607 if((pParam->BlockSizeShift < MinBlockSizeShift) || (pParam->BlockSizeShift > MaxBlockSizeShift))
609 pArray->VDeviceType = VD_RAID_5;
610 /* only "no build" R5 is not critical after creation. */
611 if ((pParam->CreateFlags & CAF_CREATE_R5_NO_BUILD)==0)
612 pArray->u.array.rf_need_rebuild = 1;
616 if(pParam->nDisk <= 2)
618 pArray->VDeviceType = VD_RAID_1;
620 pArray->u.array.bArnMember = pParam->nDisk;
621 pArray->u.array.bArRealnMember = pParam->nDisk;
622 pArray->u.array.bArBlockSizeShift = pParam->BlockSizeShift;
623 pArray->u.array.bStripeWitch = (1 << pParam->BlockSizeShift);
624 pArray->u.array.dArStamp = Stamp;
626 pArray->u.array.rf_need_sync = 1;
627 pArray->u.array.rf_newly_created = 1;
629 if ((pParam->CreateFlags & CAF_CREATE_AND_DUPLICATE) &&
630 (pArray->VDeviceType == VD_RAID_1))
632 pArray->u.array.rf_newly_created = 0; /* R1 shall still be accessible */
633 pArray->u.array.rf_need_rebuild = 1;
634 pArray->u.array.rf_auto_rebuild = 1;
635 pArray->u.array.rf_duplicate_and_create = 1;
637 for(i = 0; i < MAX_VDEVICE_PER_VBUS; i++)
638 if (_vbus_p->pVDevice[i] == ID_TO_VDEV(pParam->Members[0]))
642 pArray->u.array.RebuildSectors = pArray->u.array.rf_need_rebuild? 0 : MAX_LBA_T;
644 memcpy(pArray->u.array.ArrayName, pParam->ArrayName, MAX_ARRAY_NAME);
646 for(i = 0; i < pParam->nDisk; i++)
648 pArray->u.array.pMember[i] = ID_TO_VDEV(pParam->Members[i]);
649 pArray->u.array.pMember[i]->bSerialNumber = i;
650 pArray->u.array.pMember[i]->pParent = pArray;
652 /* don't unregister source disk for duplicate RAID1 */
654 pArray->VDeviceType!=VD_RAID_1 ||
655 (pParam->CreateFlags & CAF_CREATE_AND_DUPLICATE)==0)
656 UnregisterVDevice(pArray->u.array.pMember[i]);
658 if(pArray->VDeviceType == VD_RAID_5)
659 pArray->u.array.pMember[i]->vf_cache_disk = 1;
664 for(i = 0; i < (pParam->nDisk / 2); i++)
666 mArGetArrayTable(pChild);
667 pChild->VDeviceType = VD_RAID_1;
669 pChild->u.array.bArnMember = 2;
670 pChild->u.array.bArRealnMember = 2;
671 pChild->u.array.bArBlockSizeShift = pParam->BlockSizeShift;
672 pChild->u.array.bStripeWitch = (1 << pParam->BlockSizeShift);
673 pChild->u.array.dArStamp = Stamp;
675 pChild->u.array.rf_need_sync = 1;
676 pChild->u.array.rf_newly_created = 1;
678 pChild->u.array.RebuildSectors = MAX_LBA_T;
680 memcpy(pChild->u.array.ArrayName, pParam->ArrayName, MAX_ARRAY_NAME);
682 for(j = 0; j < 2; j++)
684 pChild->u.array.pMember[j] = ID_TO_VDEV(pParam->Members[i*2 + j]);
685 pChild->u.array.pMember[j]->bSerialNumber = j;
686 pChild->u.array.pMember[j]->pParent = pChild;
687 pChild->u.array.pMember[j]->pfnDeviceFailed = pfnDeviceFailed[pChild->VDeviceType];
688 UnregisterVDevice(pChild->u.array.pMember[j]);
691 pArray->u.array.pMember[i] = pChild;
693 pChild->vf_online = 1;
694 pChild->bSerialNumber = i;
695 pChild->pParent = pArray;
696 pChild->VDeviceCapacity = MIN(pChild->u.array.pMember[0]->VDeviceCapacity,
697 pChild->u.array.pMember[1]->VDeviceCapacity);
699 pChild->pfnSendCommand = pfnSendCommand[pChild->VDeviceType];
700 pChild->pfnDeviceFailed = pfnDeviceFailed[VD_RAID_0];
703 pArray->VDeviceType = VD_RAID_0;
705 pArray->u.array.bArnMember = pParam->nDisk / 2;
706 pArray->u.array.bArRealnMember = pParam->nDisk / 2;
707 pArray->u.array.bArBlockSizeShift = pParam->BlockSizeShift;
708 pArray->u.array.bStripeWitch = (1 << pParam->BlockSizeShift);
709 pArray->u.array.dArStamp = Stamp;
711 pArray->u.array.rf_need_sync = 1;
712 pArray->u.array.rf_newly_created = 1;
714 memcpy(pArray->u.array.ArrayName, pParam->ArrayName, MAX_ARRAY_NAME);
722 for(i = 0; i < pArray->u.array.bArnMember; i++)
723 pArray->u.array.pMember[i]->pfnDeviceFailed = pfnDeviceFailed[pArray->VDeviceType];
725 if ((pParam->CreateFlags & CAF_CREATE_AND_DUPLICATE) &&
726 (pArray->VDeviceType == VD_RAID_1))
728 pArray->vf_bootmark = pArray->u.array.pMember[0]->vf_bootmark;
729 pArray->vf_bootable = pArray->u.array.pMember[0]->vf_bootable;
730 pArray->u.array.pMember[0]->vf_bootable = 0;
731 pArray->u.array.pMember[0]->vf_bootmark = 0;
733 _vbus_p->pVDevice[Loca] = pArray;
735 pArray->u.array.rf_duplicate_and_created = 1;
736 pArray->pVBus = _vbus_p;
740 UCHAR TempBuffer[512];
741 ZeroMemory(TempBuffer, 512);
742 for(i = 0; i < pParam->nDisk; i++)
744 PVDevice pDisk = ID_TO_VDEV(pParam->Members[i]);
745 pDisk->vf_bootmark = pDisk->vf_bootable = 0;
746 fDeReadWrite(&pDisk->u.disk, 0, IDE_COMMAND_WRITE, TempBuffer);
750 pArray->vf_online = 1;
751 pArray->pParent = NULL;
753 switch(pArray->VDeviceType)
756 for(i = 0; i < pArray->u.array.bArnMember; i++)
757 if(pArray->u.array.pMember[i]->VDeviceCapacity < capacity)
758 capacity = pArray->u.array.pMember[i]->VDeviceCapacity;
762 capacity &= ~(pArray->u.array.bStripeWitch - 1);
763 /* shrink member capacity for RAID 1/0 */
764 for(i = 0; i < pArray->u.array.bArnMember; i++)
765 if (mIsArray(pArray->u.array.pMember[i]))
766 pArray->u.array.pMember[i]->VDeviceCapacity = capacity;
767 pArray->VDeviceCapacity = capacity * pArray->u.array.bArnMember;
771 pArray->VDeviceCapacity = MIN(pArray->u.array.pMember[0]->VDeviceCapacity,
772 pArray->u.array.pMember[1]->VDeviceCapacity);
776 for(i = 0; i < pArray->u.array.bArnMember; i++)
777 pArray->VDeviceCapacity += pArray->u.array.pMember[i]->VDeviceCapacity
785 for(i = 0; i < pArray->u.array.bArnMember; i++)
786 if(pArray->u.array.pMember[i]->VDeviceCapacity < capacity)
787 capacity = pArray->u.array.pMember[i]->VDeviceCapacity;
788 pArray->VDeviceCapacity = rounddown2(capacity, pArray->u.array.bStripeWitch) *
789 (pArray->u.array.bArnMember - 1);
796 pArray->pfnSendCommand = pfnSendCommand[pArray->VDeviceType];
797 pArray->pfnDeviceFailed = fOsDiskFailed;
798 SyncArrayInfo(pArray);
800 if (!pArray->u.array.rf_duplicate_and_created)
801 RegisterVDevice(pArray);
802 return VDEV_TO_ID(pArray);
805 for(i = 0; i < pArray->u.array.bArnMember; i++)
807 pChild = pArray->u.array.pMember[i];
808 if((pChild != NULL) && (pChild->VDeviceType != VD_SINGLE_DISK))
809 mArFreeArrayTable(pChild);
811 mArFreeArrayTable(pArray);
812 return INVALID_DEVICEID;
815 DEVICEID hpt_create_array(_VBUS_ARG PCREATE_ARRAY_PARAMS pParam)
817 CREATE_ARRAY_PARAMS_V2 param2;
818 param2.ArrayType = pParam->ArrayType;
819 param2.nDisk = pParam->nDisk;
820 param2.BlockSizeShift = pParam->BlockSizeShift;
821 param2.CreateFlags = pParam->CreateFlags;
822 param2.CreateTime = pParam->CreateTime;
823 memcpy(param2.ArrayName, pParam->ArrayName, sizeof(param2.ArrayName));
824 memcpy(param2.Description, pParam->Description, sizeof(param2.Description));
825 memcpy(param2.CreateManager, pParam->CreateManager, sizeof(param2.CreateManager));
826 param2.Capacity.lo32 = param2.Capacity.hi32 = 0;
827 memcpy(param2.Members, pParam->Members, sizeof(pParam->Members));
828 return hpt_create_array_v2(_VBUS_P ¶m2);
831 #ifdef SUPPORT_OLD_ARRAY
832 /* this is only for old RAID 0/1 */
833 int old_add_disk_to_raid01(_VBUS_ARG DEVICEID idArray, DEVICEID idDisk)
835 PVDevice pArray1 = ID_TO_VDEV(idArray);
836 PVDevice pArray2 = 0;
837 PVDevice pDisk = ID_TO_VDEV(idDisk);
839 IAL_ADAPTER_T *pAdapter = gIal_Adapter;
841 if (pArray1->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;}
843 if(pDisk->u.disk.dDeRealCapacity < (pArray1->VDeviceCapacity / 2))
846 pArray2 = pArray1->u.array.pMember[1];
847 if(pArray2 == NULL) {
848 /* create a Stripe */
849 mArGetArrayTable(pArray2);
850 pArray2->VDeviceType = VD_RAID_0;
851 pArray2->u.array.dArStamp = GetStamp();
852 pArray2->vf_format_v2 = 1;
853 pArray2->u.array.rf_broken = 1;
854 pArray2->u.array.bArBlockSizeShift = pArray1->u.array.bArBlockSizeShift;
855 pArray2->u.array.bStripeWitch = (1 << pArray2->u.array.bArBlockSizeShift);
856 pArray2->u.array.bArnMember = 2;
857 pArray2->VDeviceCapacity = pArray1->VDeviceCapacity;
858 pArray2->pfnSendCommand = pfnSendCommand[pArray2->VDeviceType];
859 pArray2->pfnDeviceFailed = pfnDeviceFailed[pArray1->VDeviceType];
860 memcpy(pArray2->u.array.ArrayName, pArray1->u.array.ArrayName, MAX_ARRAY_NAME);
861 pArray2->pParent = pArray1;
862 pArray2->bSerialNumber = 1;
863 pArray1->u.array.pMember[1] = pArray2;
864 pArray1->u.array.bArRealnMember++;
867 for(i = 0; i < pArray2->u.array.bArnMember; i++)
868 if((pArray2->u.array.pMember[i] == NULL) || !pArray2->u.array.pMember[i]->vf_online)
870 if(pArray2->u.array.pMember[i] != NULL)
871 pArray2->u.array.pMember[i]->pParent = NULL;
872 pArray2->u.array.pMember[i] = pDisk;
878 UnregisterVDevice(pDisk);
879 pDisk->VDeviceType = VD_SINGLE_DISK;
880 pDisk->bSerialNumber = i;
881 pDisk->pParent = pArray2;
882 pDisk->vf_format_v2 = 1;
883 pDisk->u.disk.dDeHiddenLba = i? 10 : 0;
884 pDisk->VDeviceCapacity = pDisk->u.disk.dDeRealCapacity;
885 pDisk->pfnDeviceFailed = pfnDeviceFailed[pArray2->VDeviceType];
887 pArray2->u.array.bArRealnMember++;
888 if(pArray2->u.array.bArnMember == pArray2->u.array.bArRealnMember){
889 pArray2->vf_online = 1;
890 pArray2->u.array.rf_broken = 0;
893 if(pArray1->u.array.pMember[0]->vf_online && pArray1->u.array.pMember[1]->vf_online){
894 pArray1->u.array.bArRealnMember = pArray1->u.array.bArnMember;
895 pArray1->u.array.rf_broken = 0;
896 pArray1->u.array.rf_need_rebuild = 1;
897 pArray1->u.array.rf_auto_rebuild = 1;
900 pArray1->u.array.RebuildSectors = 0;
901 pArray1->u.array.dArStamp = GetStamp();
902 SyncArrayInfo(pArray1);
907 int hpt_add_disk_to_array(_VBUS_ARG DEVICEID idArray, DEVICEID idDisk)
912 PVDevice pArray = ID_TO_VDEV(idArray);
913 PVDevice pDisk = ID_TO_VDEV(idDisk);
915 if((idArray == 0) || (idDisk == 0)) return -1;
916 if(check_VDevice_valid(pArray) || check_VDevice_valid(pDisk)) return -1;
917 if(!pArray->u.array.rf_broken) return -1;
919 if(pArray->VDeviceType != VD_RAID_1 && pArray->VDeviceType != VD_RAID_5)
921 if((pDisk->VDeviceType != VD_SINGLE_DISK) && (pDisk->VDeviceType != VD_SPARE))
924 #ifdef SUPPORT_OLD_ARRAY
926 if (pArray->vf_format_v2 && pArray->VDeviceType==VD_RAID_1 &&
927 pArray->u.array.pMember[0] &&
928 mIsArray(pArray->u.array.pMember[0]))
930 if(old_add_disk_to_raid01(_VBUS_P idArray, idDisk))
937 Capacity = pArray->VDeviceCapacity / (pArray->u.array.bArnMember - 1);
939 if (pArray->vf_format_v2) {
940 if(pDisk->u.disk.dDeRealCapacity < Capacity) return -1;
943 if(pDisk->VDeviceCapacity < Capacity) return -1;
945 if (pArray->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;}
947 for(i = 0; i < pArray->u.array.bArnMember; i++)
948 if((pArray->u.array.pMember[i] == 0) || !pArray->u.array.pMember[i]->vf_online)
950 if(pArray->u.array.pMember[i] != NULL)
951 pArray->u.array.pMember[i]->pParent = NULL;
952 pArray->u.array.pMember[i] = pDisk;
958 UnregisterVDevice(pDisk);
959 pDisk->VDeviceType = VD_SINGLE_DISK;
960 pDisk->bSerialNumber = i;
961 pDisk->pParent = pArray;
962 if (pArray->VDeviceType==VD_RAID_5) pDisk->vf_cache_disk = 1;
963 pDisk->pfnDeviceFailed = pfnDeviceFailed[pArray->VDeviceType];
964 if (pArray->vf_format_v2) {
965 pDisk->vf_format_v2 = 1;
966 pDisk->VDeviceCapacity = pDisk->u.disk.dDeRealCapacity;
969 pArray->u.array.bArRealnMember++;
970 if(pArray->u.array.bArnMember == pArray->u.array.bArRealnMember)
972 pArray->u.array.rf_need_rebuild = 1;
973 pArray->u.array.RebuildSectors = 0;
974 pArray->u.array.rf_auto_rebuild = 1;
975 pArray->u.array.rf_broken = 0;
977 pArray->u.array.RebuildSectors = 0;
979 /* sync the whole array */
980 while (pArray->pParent) pArray = pArray->pParent;
981 pArray->u.array.dArStamp = GetStamp();
982 SyncArrayInfo(pArray);
986 int hpt_add_spare_disk(_VBUS_ARG DEVICEID idDisk)
988 PVDevice pVDevice = ID_TO_VDEV(idDisk);
989 DECLARE_BUFFER(PUCHAR, pbuffer);
991 if(idDisk == 0 || check_VDevice_valid(pVDevice)) return -1;
992 if (pVDevice->VDeviceType != VD_SINGLE_DISK || pVDevice->pParent)
995 if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
997 UnregisterVDevice(pVDevice);
998 pVDevice->VDeviceType = VD_SPARE;
999 pVDevice->vf_bootmark = 0;
1001 ZeroMemory((char *)pbuffer, 512);
1002 fDeReadWrite(&pVDevice->u.disk, 0, IDE_COMMAND_WRITE, pbuffer);
1003 SyncArrayInfo(pVDevice);
1007 int hpt_remove_spare_disk(_VBUS_ARG DEVICEID idDisk)
1009 PVDevice pVDevice = ID_TO_VDEV(idDisk);
1011 if(idDisk == 0 || check_VDevice_valid(pVDevice)) return -1;
1013 if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
1015 pVDevice->VDeviceType = VD_SINGLE_DISK;
1017 SyncArrayInfo(pVDevice);
1018 RegisterVDevice(pVDevice);
1022 int hpt_set_array_info(_VBUS_ARG DEVICEID idArray, PALTERABLE_ARRAY_INFO pInfo)
1024 PVDevice pVDevice = ID_TO_VDEV(idArray);
1026 if(idArray == 0 || check_VDevice_valid(pVDevice)) return -1;
1027 if (!mIsArray(pVDevice)) return -1;
1029 /* if the pVDevice isn't a top level, return -1; */
1030 if(pVDevice->pParent != NULL) return -1;
1032 if (pVDevice->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;}
1034 if (pInfo->ValidFields & AAIF_NAME) {
1035 memset(pVDevice->u.array.ArrayName, 0, MAX_ARRAY_NAME);
1036 memcpy(pVDevice->u.array.ArrayName, pInfo->Name, sizeof(pInfo->Name));
1037 pVDevice->u.array.rf_need_sync = 1;
1040 if (pInfo->ValidFields & AAIF_DESCRIPTION) {
1041 memcpy(pVDevice->u.array.Description, pInfo->Description, sizeof(pInfo->Description));
1042 pVDevice->u.array.rf_need_sync = 1;
1045 if (pVDevice->u.array.rf_need_sync)
1046 SyncArrayInfo(pVDevice);
1050 static int hpt_set_device_info(_VBUS_ARG DEVICEID idDisk, PALTERABLE_DEVICE_INFO pInfo)
1052 PVDevice pVDevice = ID_TO_VDEV(idDisk);
1054 if(idDisk == 0 || check_VDevice_valid(pVDevice)) return -1;
1055 if (mIsArray(pVDevice))
1058 if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
1064 static int hpt_set_device_info_v2(_VBUS_ARG DEVICEID idDisk, PALTERABLE_DEVICE_INFO_V2 pInfo)
1066 PVDevice pVDevice = ID_TO_VDEV(idDisk);
1069 if(idDisk==0 || check_VDevice_valid(pVDevice)) return -1;
1070 if (mIsArray(pVDevice))
1073 if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
1075 if (pInfo->ValidFields & ADIF_MODE) {
1076 pVDevice->u.disk.bDeModeSetting = pInfo->DeviceModeSetting;
1077 pVDevice->u.disk.bDeUserSelectMode = pInfo->DeviceModeSetting;
1078 pVDevice->u.disk.df_user_mode_set = 1;
1079 fDeSelectMode((PDevice)&(pVDevice->u.disk), (UCHAR)pInfo->DeviceModeSetting);
1083 if (pInfo->ValidFields & ADIF_TCQ) {
1084 if (fDeSetTCQ(&pVDevice->u.disk, pInfo->TCQEnabled, 0)) {
1085 pVDevice->u.disk.df_tcq_set = 1;
1086 pVDevice->u.disk.df_tcq = pInfo->TCQEnabled!=0;
1091 if (pInfo->ValidFields & ADIF_NCQ) {
1092 if (fDeSetNCQ(&pVDevice->u.disk, pInfo->NCQEnabled, 0)) {
1093 pVDevice->u.disk.df_ncq_set = 1;
1094 pVDevice->u.disk.df_ncq = pInfo->NCQEnabled!=0;
1099 if (pInfo->ValidFields & ADIF_WRITE_CACHE) {
1100 if (fDeSetWriteCache(&pVDevice->u.disk, pInfo->WriteCacheEnabled)) {
1101 pVDevice->u.disk.df_write_cache_set = 1;
1102 pVDevice->u.disk.df_write_cache = pInfo->WriteCacheEnabled!=0;
1107 if (pInfo->ValidFields & ADIF_READ_AHEAD) {
1108 if (fDeSetReadAhead(&pVDevice->u.disk, pInfo->ReadAheadEnabled)) {
1109 pVDevice->u.disk.df_read_ahead_set = 1;
1110 pVDevice->u.disk.df_read_ahead = pInfo->ReadAheadEnabled!=0;
1116 SyncArrayInfo(pVDevice);
1122 /* hpt_default_ioctl()
1123 * This is a default implementation. The platform dependent part
1124 * may reuse this function and/or use it own implementation for
1125 * each ioctl function.
1127 int hpt_default_ioctl(_VBUS_ARG
1128 DWORD dwIoControlCode, /* operation control code */
1129 PVOID lpInBuffer, /* input data buffer */
1130 DWORD nInBufferSize, /* size of input data buffer */
1131 PVOID lpOutBuffer, /* output data buffer */
1132 DWORD nOutBufferSize, /* size of output data buffer */
1133 PDWORD lpBytesReturned /* byte count */
1136 switch(dwIoControlCode) {
1138 case HPT_IOCTL_GET_VERSION:
1140 if (nInBufferSize != 0) return -1;
1141 if (nOutBufferSize != sizeof(DWORD)) return -1;
1142 *((DWORD*)lpOutBuffer) = HPT_INTERFACE_VERSION;
1145 case HPT_IOCTL_GET_CONTROLLER_COUNT:
1147 if (nOutBufferSize!=sizeof(DWORD)) return -1;
1148 *(PDWORD)lpOutBuffer = hpt_get_controller_count();
1151 case HPT_IOCTL_GET_CONTROLLER_INFO:
1154 PCONTROLLER_INFO pInfo;
1156 if (nInBufferSize!=sizeof(DWORD)) return -1;
1157 if (nOutBufferSize!=sizeof(CONTROLLER_INFO)) return -1;
1159 id = *(DWORD *)lpInBuffer;
1160 pInfo = (PCONTROLLER_INFO)lpOutBuffer;
1161 if (hpt_get_controller_info(id, pInfo)!=0)
1166 case HPT_IOCTL_GET_CHANNEL_INFO:
1169 PCHANNEL_INFO pInfo;
1171 if (nInBufferSize!=8) return -1;
1172 if (nOutBufferSize!=sizeof(CHANNEL_INFO)) return -1;
1174 id = *(DWORD *)lpInBuffer;
1175 bus = ((DWORD *)lpInBuffer)[1];
1176 pInfo = (PCHANNEL_INFO)lpOutBuffer;
1178 if (hpt_get_channel_info(id, bus, pInfo)!=0)
1183 case HPT_IOCTL_GET_LOGICAL_DEVICES:
1188 if (nInBufferSize!=sizeof(DWORD)) return -1;
1189 nMax = *(DWORD *)lpInBuffer;
1190 if (nOutBufferSize < sizeof(DWORD)+sizeof(DWORD)*nMax) return -1;
1192 pIds = ((DEVICEID *)lpOutBuffer)+1;
1193 *(DWORD*)lpOutBuffer = hpt_get_logical_devices(pIds, nMax);
1197 case HPT_IOCTL_GET_DEVICE_INFO:
1200 PLOGICAL_DEVICE_INFO pInfo;
1202 if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1203 if (nOutBufferSize!=sizeof(LOGICAL_DEVICE_INFO)) return -1;
1205 id = *(DWORD *)lpInBuffer;
1206 if (id == INVALID_DEVICEID) return -1;
1208 pInfo = (PLOGICAL_DEVICE_INFO)lpOutBuffer;
1209 memset(pInfo, 0, sizeof(LOGICAL_DEVICE_INFO));
1211 if (hpt_get_device_info(id, pInfo)!=0)
1216 case HPT_IOCTL_GET_DEVICE_INFO_V2:
1219 PLOGICAL_DEVICE_INFO_V2 pInfo;
1221 if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1222 if (nOutBufferSize!=sizeof(LOGICAL_DEVICE_INFO_V2)) return -1;
1224 id = *(DWORD *)lpInBuffer;
1225 if (id == INVALID_DEVICEID) return -1;
1227 pInfo = (PLOGICAL_DEVICE_INFO_V2)lpOutBuffer;
1228 memset(pInfo, 0, sizeof(LOGICAL_DEVICE_INFO_V2));
1230 if (hpt_get_device_info_v2(id, pInfo)!=0)
1235 #ifdef SUPPORT_ARRAY
1236 case HPT_IOCTL_CREATE_ARRAY:
1238 if (nInBufferSize!=sizeof(CREATE_ARRAY_PARAMS)) return -1;
1239 if (nOutBufferSize!=sizeof(DEVICEID)) return -1;
1241 *(DEVICEID *)lpOutBuffer = hpt_create_array(_VBUS_P (PCREATE_ARRAY_PARAMS)lpInBuffer);
1243 if(*(DEVICEID *)lpOutBuffer == INVALID_DEVICEID)
1248 case HPT_IOCTL_CREATE_ARRAY_V2:
1250 if (nInBufferSize!=sizeof(CREATE_ARRAY_PARAMS_V2)) return -1;
1251 if (nOutBufferSize!=sizeof(DEVICEID)) return -1;
1253 *(DEVICEID *)lpOutBuffer = hpt_create_array_v2(_VBUS_P (PCREATE_ARRAY_PARAMS_V2)lpInBuffer);
1255 if (*(DEVICEID *)lpOutBuffer == INVALID_DEVICEID)
1260 case HPT_IOCTL_SET_ARRAY_INFO:
1263 PALTERABLE_ARRAY_INFO pInfo;
1265 if (nInBufferSize!=sizeof(HPT_SET_ARRAY_INFO)) return -1;
1266 if (nOutBufferSize!=0) return -1;
1268 idArray = ((PHPT_SET_ARRAY_INFO)lpInBuffer)->idArray;
1269 pInfo = &((PHPT_SET_ARRAY_INFO)lpInBuffer)->Info;
1271 if(hpt_set_array_info(_VBUS_P idArray, pInfo))
1276 case HPT_IOCTL_SET_DEVICE_INFO:
1279 PALTERABLE_DEVICE_INFO pInfo;
1281 if (nInBufferSize!=sizeof(HPT_SET_DEVICE_INFO)) return -1;
1282 if (nOutBufferSize!=0) return -1;
1284 idDisk = ((PHPT_SET_DEVICE_INFO)lpInBuffer)->idDisk;
1285 pInfo = &((PHPT_SET_DEVICE_INFO)lpInBuffer)->Info;
1286 if(hpt_set_device_info(_VBUS_P idDisk, pInfo) != 0)
1291 case HPT_IOCTL_SET_DEVICE_INFO_V2:
1294 PALTERABLE_DEVICE_INFO_V2 pInfo;
1296 if (nInBufferSize < sizeof(HPT_SET_DEVICE_INFO_V2)) return -1;
1297 if (nOutBufferSize!=0) return -1;
1299 idDisk = ((PHPT_SET_DEVICE_INFO_V2)lpInBuffer)->idDisk;
1300 pInfo = &((PHPT_SET_DEVICE_INFO_V2)lpInBuffer)->Info;
1301 if(hpt_set_device_info_v2(_VBUS_P idDisk, pInfo) != 0)
1306 case HPT_IOCTL_SET_BOOT_MARK:
1311 IAL_ADAPTER_T *pAdapter = gIal_Adapter;
1314 if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1315 id = *(DEVICEID *)lpInBuffer;
1316 while(pAdapter != 0)
1318 pVBus = &pAdapter->VBus;
1319 for(i = 0; i < MAX_VDEVICE_PER_VBUS; i++)
1321 if(!(pTop = pVBus->pVDevice[i])) continue;
1322 if (pTop->pVBus!=_vbus_p) return -1;
1323 while (pTop->pParent) pTop = pTop->pParent;
1324 if (id==0 && pTop->vf_bootmark)
1325 pTop->vf_bootmark = 0;
1326 else if (pTop==ID_TO_VDEV(id) && !pTop->vf_bootmark)
1327 pTop->vf_bootmark = 1;
1330 SyncArrayInfo(pTop);
1333 pAdapter = pAdapter->next;
1338 case HPT_IOCTL_ADD_SPARE_DISK:
1342 if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1343 if (nOutBufferSize!=0) return -1;
1345 id = *(DEVICEID *)lpInBuffer;
1347 if(hpt_add_spare_disk(_VBUS_P id))
1352 case HPT_IOCTL_REMOVE_SPARE_DISK:
1356 if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1357 if (nOutBufferSize!=0) return -1;
1359 id = *(DEVICEID *)lpInBuffer;
1361 if(hpt_remove_spare_disk(_VBUS_P id))
1366 case HPT_IOCTL_ADD_DISK_TO_ARRAY:
1369 id1 = ((PHPT_ADD_DISK_TO_ARRAY)lpInBuffer)->idArray;
1370 id2 = ((PHPT_ADD_DISK_TO_ARRAY)lpInBuffer)->idDisk;
1372 if (nInBufferSize != sizeof(HPT_ADD_DISK_TO_ARRAY)) return -1;
1373 if (nOutBufferSize != 0) return -1;
1375 if(hpt_add_disk_to_array(_VBUS_P id1, id2))
1380 case HPT_IOCTL_GET_DRIVER_CAPABILITIES:
1382 PDRIVER_CAPABILITIES cap;
1383 if (nOutBufferSize<sizeof(DRIVER_CAPABILITIES)) return -1;
1384 cap = (PDRIVER_CAPABILITIES)lpOutBuffer;
1386 if(hpt_get_driver_capabilities(cap))
1391 case HPT_IOCTL_GET_CONTROLLER_VENID:
1393 DWORD id = ((DWORD*)lpInBuffer)[0];
1394 IAL_ADAPTER_T *pAdapTemp;
1395 int iControllerCount = 0;
1397 for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next)
1398 if (iControllerCount++==id)
1404 if (nOutBufferSize < 4)
1407 *(DWORD*)lpOutBuffer = ((DWORD)pAdapTemp->mvSataAdapter.pciConfigDeviceId << 16) | 0x11AB;
1411 case HPT_IOCTL_EPROM_IO:
1413 DWORD id = ((DWORD*)lpInBuffer)[0];
1414 DWORD offset = ((DWORD*)lpInBuffer)[1];
1415 DWORD direction = ((DWORD*)lpInBuffer)[2];
1416 DWORD length = ((DWORD*)lpInBuffer)[3];
1417 IAL_ADAPTER_T *pAdapTemp;
1418 int iControllerCount = 0;
1420 for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next)
1421 if (iControllerCount++==id)
1427 if (nInBufferSize < sizeof(DWORD) * 4 + (direction? length : 0) ||
1428 nOutBufferSize < (direction? 0 : length))
1431 if (direction == 0) /* read */
1432 sx508x_flash_access(&pAdapTemp->mvSataAdapter,
1433 offset, lpOutBuffer, length, 1);
1435 sx508x_flash_access(&pAdapTemp->mvSataAdapter,
1436 offset, (char *)lpInBuffer + 16, length, 0);
1446 if (lpBytesReturned)
1447 *lpBytesReturned = nOutBufferSize;