xref: /freebsd/sys/dev/hptmv/gui_lib.c (revision a0b9e2e854027e6ff61fb075a1309dbc71c42b54)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2004-2005 HighPoint Technologies, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
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.
15  *
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
26  * SUCH DAMAGE.
27  *
28  * $FreeBSD$
29  */
30 /*
31  * gui_lib.c
32  * Copyright (c) 2002-2004 HighPoint Technologies, Inc. All rights reserved.
33  *
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.
37  *
38  *  This implementation doesn't use any synchronization; the caller must
39  *  assure the proper context when calling these functions.
40  */
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/malloc.h>
46 
47 #ifndef __KERNEL__
48 #define __KERNEL__
49 #endif
50 
51 #include <dev/hptmv/global.h>
52 #include <dev/hptmv/hptintf.h>
53 #include <dev/hptmv/osbsd.h>
54 #include <dev/hptmv/access601.h>
55 
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);
70 
71 int
72 check_VDevice_valid(PVDevice p)
73 {
74 	int i;
75 	PVDevice pVDevice;
76 	PVBus    _vbus_p;
77 	IAL_ADAPTER_T *pAdapter = gIal_Adapter;
78 
79 	while(pAdapter != NULL)
80 	{
81 		for (i = 0; i < MV_SATA_CHANNELS_NUM; i++)
82 			if(&(pAdapter->VDevices[i]) == p)  return 0;
83 		pAdapter = pAdapter->next;
84 	}
85 
86 #ifdef SUPPORT_ARRAY
87 	pAdapter = gIal_Adapter;
88 	while(pAdapter != NULL)
89 	{
90 		_vbus_p = &pAdapter->VBus;
91 		for (i=0;i<MAX_ARRAY_PER_VBUS;i++)
92 		{
93 			pVDevice=ArrayTables(i);
94 			if ((pVDevice->u.array.dArStamp != 0) && (pVDevice == p))
95 				return 0;
96 		}
97 		pAdapter = pAdapter->next;
98 	}
99 #endif
100 
101 	return -1;
102 }
103 
104 #ifdef SUPPORT_ARRAY
105 
106 static UCHAR get_vdev_type(PVDevice pVDevice)
107 	{
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;
114 	}
115 	}
116 
117 static DWORD get_array_flag(PVDevice pVDevice)
118 {
119 	int i;
120 	DWORD f = 0;
121 
122 	/* The array is disabled */
123 	if(!pVDevice->vf_online)	{
124 		f |= ARRAY_FLAG_DISABLED;
125 		/* Ignore other info */
126 		return f;
127 	}
128 
129 	/* array need synchronizing */
130 	if(pVDevice->u.array.rf_need_rebuild && !pVDevice->u.array.rf_duplicate_and_create)
131 		f |= ARRAY_FLAG_NEEDBUILDING;
132 
133 	/* array is in rebuilding process */
134 	if(pVDevice->u.array.rf_rebuilding)
135 		f |= ARRAY_FLAG_REBUILDING;
136 
137 	/* array is being verified */
138 	if(pVDevice->u.array.rf_verifying)
139 		f |= ARRAY_FLAG_VERIFYING;
140 
141 	/* array is being initialized */
142 	if(pVDevice->u.array.rf_initializing)
143 		f |= ARRAY_FLAG_INITIALIZING;
144 
145 	/* broken but may still working */
146 	if(pVDevice->u.array.rf_broken)
147 		f |= ARRAY_FLAG_BROKEN;
148 
149 	/* array has a active partition */
150 	if(pVDevice->vf_bootable)
151 		f |= ARRAY_FLAG_BOOTDISK;
152 
153 	/* a newly created array */
154 	if(pVDevice->u.array.rf_newly_created)
155 		f |= ARRAY_FLAG_NEWLY_CREATED;
156 
157 	/* array has boot mark set */
158 	if(pVDevice->vf_bootmark)
159 		f |= ARRAY_FLAG_BOOTMARK;
160 
161 	/* auto-rebuild should start */
162 	if(pVDevice->u.array.rf_auto_rebuild)
163 		f |= ARRAY_FLAG_NEED_AUTOREBUILD;
164 
165 	for(i = 0; i < pVDevice->u.array.bArnMember; i++)
166 	{
167 		PVDevice pMember = pVDevice->u.array.pMember[i];
168 		if (!pMember || !pMember->vf_online || (pMember->VDeviceType==VD_SINGLE_DISK))
169 			continue;
170 
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;
175 
176 		/* array is in rebuilding process */
177 		if(pMember->u.array.rf_rebuilding)
178 			f |= ARRAY_FLAG_REBUILDING;
179 
180 		/* array is being verified */
181 		if(pMember->u.array.rf_verifying)
182 			f |= ARRAY_FLAG_VERIFYING;
183 
184 		/* array is being initialized */
185 		if(pMember->u.array.rf_initializing)
186 			f |= ARRAY_FLAG_INITIALIZING;
187 
188 		/* broken but may still working */
189 		if(pMember->u.array.rf_broken)
190 			f |= ARRAY_FLAG_BROKEN;
191 
192 		/* a newly created array */
193 		if(pMember->u.array.rf_newly_created)
194 			f |= ARRAY_FLAG_NEWLY_CREATED;
195 
196 		/* auto-rebuild should start */
197 		if(pMember->u.array.rf_auto_rebuild)
198 			f |= ARRAY_FLAG_NEED_AUTOREBUILD;
199 	}
200 
201 	return f;
202 }
203 
204 static DWORD calc_rebuild_progress(PVDevice pVDevice)
205 {
206 	int i;
207 	DWORD result = ((ULONG)(pVDevice->u.array.RebuildSectors>>11)*1000 /
208 		(ULONG)(pVDevice->VDeviceCapacity>>11) * (pVDevice->u.array.bArnMember-1)) * 10;
209 
210 	for(i = 0; i < pVDevice->u.array.bArnMember; i++)
211 	{
212 		PVDevice pMember = pVDevice->u.array.pMember[i];
213 		if (!pMember || !pMember->vf_online || (pMember->VDeviceType==VD_SINGLE_DISK))
214 			continue;
215 
216 		/* for RAID1/0 case */
217 		if (pMember->u.array.rf_rebuilding ||
218 			pMember->u.array.rf_verifying ||
219 			pMember->u.array.rf_initializing)
220 		{
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)
224 				result = percent;
225 		}
226 		}
227 
228 	if (result>10000) result = 10000;
229 	return result;
230 	}
231 
232 static void get_array_info(PVDevice pVDevice, PHPT_ARRAY_INFO pArrayInfo)
233 {
234 	int	i;
235 
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);
242 
243 	pArrayInfo->nDisk = 0;
244 
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]);
248 
249 	for(i=pArrayInfo->nDisk; i<MAX_ARRAY_MEMBERS; i++)
250 		pArrayInfo->Members[i] = INVALID_DEVICEID;
251 	}
252 
253 static void get_array_info_v2(PVDevice pVDevice, PHPT_ARRAY_INFO_V2 pArrayInfo)
254 {
255 	int	i;
256 
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);
264 
265 	pArrayInfo->nDisk = 0;
266 
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]);
270 
271 	for(i=pArrayInfo->nDisk; i<MAX_ARRAY_MEMBERS_V2; i++)
272 		pArrayInfo->Members[i] = INVALID_DEVICEID;
273 }
274 #endif
275 
276 static int get_disk_info(PVDevice pVDevice, PDEVICE_INFO pDiskInfo)
277 {
278 	MV_SATA_ADAPTER *pSataAdapter;
279 	MV_SATA_CHANNEL *pSataChannel;
280 	IAL_ADAPTER_T   *pAdapter;
281 	MV_CHANNEL		*channelInfo;
282 	char *p;
283 	int i;
284 
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;
291 
292 	pAdapter = pSataAdapter->IALData;
293 
294 	pDiskInfo->PathId = pSataChannel->channelNumber;
295 	pDiskInfo->ControllerId = (UCHAR)pSataAdapter->adapterId;
296 
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.
301 */
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;
306 	else {
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;
311 		else
312 			pDiskInfo->DeviceModeSetting = pVDevice->u.disk.bDeModeSetting;
313 	}
314 
315 	pDiskInfo->UsableMode = pVDevice->u.disk.bDeUsable_Mode;
316 
317 	pDiskInfo->DeviceType = PDT_HARDDISK;
318 
319 	pDiskInfo->Flags = 0x0;
320 
321 	/* device is disabled */
322 	if(!pVDevice->u.disk.df_on_line)
323 		pDiskInfo->Flags |= DEVICE_FLAG_DISABLED;
324 
325 	/* disk has a active partition */
326 	if(pVDevice->vf_bootable)
327 		pDiskInfo->Flags |= DEVICE_FLAG_BOOTDISK;
328 
329 	/* disk has boot mark set */
330 	if(pVDevice->vf_bootmark)
331 		pDiskInfo->Flags |= DEVICE_FLAG_BOOTMARK;
332 
333 	pDiskInfo->Flags |= DEVICE_FLAG_SATA;
334 
335 	/* is a spare disk */
336 	if(pVDevice->VDeviceType == VD_SPARE)
337 		pDiskInfo->Flags |= DEVICE_FLAG_IS_SPARE;
338 
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]);
343 	p[39] = '\0';
344 
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;
355 	return 0;
356 }
357 
358 int hpt_get_driver_capabilities(PDRIVER_CAPABILITIES cap)
359 {
360 	ZeroMemory(cap, sizeof(DRIVER_CAPABILITIES));
361 	cap->dwSize = sizeof(DRIVER_CAPABILITIES);
362 	cap->MaximumControllers = MAX_VBUS;
363 
364 	/* cap->SupportCrossControllerRAID = 0; */
365 	/* take care for various OSes! */
366 	cap->SupportCrossControllerRAID = 0;
367 
368 
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;
375 
376 
377 #ifdef SUPPORT_ARRAY
378 	/* Stripe */
379 	cap->SupportedRAIDTypes[0] = AT_RAID0;
380 	cap->MaximumArrayMembers[0] = MAX_MEMBERS;
381 	/* Mirror */
382 	cap->SupportedRAIDTypes[1] = AT_RAID1;
383 	cap->MaximumArrayMembers[1] = 2;
384 	/* Mirror + Stripe */
385 #ifdef ARRAY_V2_ONLY
386 	cap->SupportedRAIDTypes[2] = (AT_RAID1<<4)|AT_RAID0; /* RAID0/1 */
387 #else
388 	cap->SupportedRAIDTypes[2] = (AT_RAID0<<4)|AT_RAID1; /* RAID1/0 */
389 #endif
390 	cap->MaximumArrayMembers[2] = MAX_MEMBERS;
391 	/* Jbod */
392 	cap->SupportedRAIDTypes[3] = AT_JBOD;
393 	cap->MaximumArrayMembers[3] = MAX_MEMBERS;
394 	/* RAID5 */
395 #if SUPPORT_RAID5
396 	cap->SupportedRAIDTypes[4] = AT_RAID5;
397 	cap->MaximumArrayMembers[4] = MAX_MEMBERS;
398 #endif
399 #endif
400 	return 0;
401 }
402 
403 int hpt_get_controller_count(void)
404 {
405 	IAL_ADAPTER_T    *pAdapTemp = gIal_Adapter;
406 	int iControllerCount = 0;
407 
408 	while(pAdapTemp != NULL)
409 	{
410 		iControllerCount++;
411 		pAdapTemp = pAdapTemp->next;
412 	}
413 
414 	return iControllerCount;
415 }
416 
417 int hpt_get_controller_info(int id, PCONTROLLER_INFO pInfo)
418 {
419 	IAL_ADAPTER_T    *pAdapTemp;
420 	int iControllerCount = 0;
421 
422 	for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next) {
423 		if (iControllerCount++==id) {
424 			pInfo->InterruptLevel = 0;
425 			pInfo->ChipType = 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;
432 #endif
433 			strcpy(pInfo->szProductID, GUI_CONTROLLER_NAME);
434 #define _set_product_id(x)
435 #else
436 #define _set_product_id(x) strcpy(pInfo->szProductID, x)
437 #endif
438 			_set_product_id("RocketRAID 18xx SATA Controller");
439 			pInfo->NumBuses = 8;
440 			pInfo->ChipFlags |= CHIP_SUPPORT_ULTRA_133|CHIP_SUPPORT_ULTRA_150;
441 			return 0;
442 		}
443 	}
444 	return -1;
445 }
446 
447 
448 int hpt_get_channel_info(int id, int bus, PCHANNEL_INFO pInfo)
449 {
450 	IAL_ADAPTER_T    *pAdapTemp = gIal_Adapter;
451 	int i,iControllerCount = 0;
452 
453 	while(pAdapTemp != NULL)
454 	{
455 		if (iControllerCount++==id)
456 			goto found;
457 		pAdapTemp = pAdapTemp->next;
458 	}
459 	return -1;
460 
461 found:
462 
463 	pInfo->IoPort = 0;
464 	pInfo->ControlPort = 0;
465 
466 	for (i=0; i<2 ;i++)
467 	{
468 		pInfo->Devices[i] = (DEVICEID)INVALID_DEVICEID;
469 	}
470 
471 	if (pAdapTemp->mvChannel[bus].online == MV_TRUE)
472 		pInfo->Devices[0] = VDEV_TO_ID(&pAdapTemp->VDevices[bus]);
473 	else
474 		pInfo->Devices[0] = (DEVICEID)INVALID_DEVICEID;
475 
476 	return 0;
477 
478 
479 }
480 
481 int hpt_get_logical_devices(DEVICEID * pIds, int nMaxCount)
482 {
483 	int count = 0;
484 	int	i,j;
485 	PVDevice pPhysical, pLogical;
486 	IAL_ADAPTER_T    *pAdapTemp;
487 
488 	for(i = 0; i < nMaxCount; i++)
489 		pIds[i] = INVALID_DEVICEID;
490 
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++)
494 		{
495 			pPhysical = &pAdapTemp->VDevices[i];
496 			pLogical = pPhysical;
497 
498 			while (pLogical->pParent) pLogical = pLogical->pParent;
499 			if (pLogical->VDeviceType==VD_SPARE)
500 				continue;
501 
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;
506 			next:;
507 		}
508 	}
509 
510 done:
511 	return count;
512 }
513 
514 int hpt_get_device_info(DEVICEID id, PLOGICAL_DEVICE_INFO pInfo)
515 {
516 	PVDevice pVDevice = ID_TO_VDEV(id);
517 
518 	if((id == 0) || check_VDevice_valid(pVDevice))
519 		return -1;
520 
521 #ifdef SUPPORT_ARRAY
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);
527 		return 0;
528 	}
529 #endif
530 
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);
536 }
537 
538 int hpt_get_device_info_v2(DEVICEID id, PLOGICAL_DEVICE_INFO_V2 pInfo)
539 {
540 	PVDevice pVDevice = ID_TO_VDEV(id);
541 
542 	if((id == 0) || check_VDevice_valid(pVDevice))
543 		return -1;
544 
545 #ifdef SUPPORT_ARRAY
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);
552 	return 0;
553 }
554 #endif
555 
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);
562 }
563 
564 #ifdef SUPPORT_ARRAY
565 DEVICEID hpt_create_array_v2(_VBUS_ARG PCREATE_ARRAY_PARAMS_V2 pParam)
566 {
567 	ULONG Stamp = GetStamp();
568 	int	i,j;
569 	LBA_T  capacity = MAX_LBA_T;
570 	PVDevice pArray,pChild;
571 	int		Loca = -1;
572 
573 	if (pParam->nDisk > MAX_MEMBERS)
574 		return INVALID_DEVICEID;
575 /* check in verify_vd
576 	for(i = 0; i < pParam->nDisk; i++)
577 	{
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;
582 		if (!_vbus_p)
583 			_vbus_p = pVDev->u.disk.pVBus;
584 		else if (_vbus_p != pVDev->u.disk.pVBus)
585 			return INVALID_DEVICEID;
586 	}
587 */
588 	_vbus_p = (ID_TO_VDEV(pParam->Members[0]))->u.disk.pVBus;
589 	if (!_vbus_p) return INVALID_DEVICEID;
590 
591 	mArGetArrayTable(pArray);
592 	if(!pArray)	return INVALID_DEVICEID;
593 
594 	switch (pParam->ArrayType)
595 	{
596 		case AT_JBOD:
597 			pArray->VDeviceType = VD_JBOD;
598 			goto simple;
599 
600 		case AT_RAID0:
601 			if((pParam->BlockSizeShift < MinBlockSizeShift) || (pParam->BlockSizeShift > MaxBlockSizeShift))
602 				goto error;
603 			pArray->VDeviceType = VD_RAID_0;
604 			goto simple;
605 
606 		case AT_RAID5:
607 			if((pParam->BlockSizeShift < MinBlockSizeShift) || (pParam->BlockSizeShift > MaxBlockSizeShift))
608 				goto error;
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;
613 			goto simple;
614 
615 		case AT_RAID1:
616 			if(pParam->nDisk <= 2)
617 			{
618 				pArray->VDeviceType = VD_RAID_1;
619 simple:
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;
625 
626 				pArray->u.array.rf_need_sync = 1;
627 				pArray->u.array.rf_newly_created = 1;
628 
629 				if ((pParam->CreateFlags & CAF_CREATE_AND_DUPLICATE) &&
630 					(pArray->VDeviceType == VD_RAID_1))
631 				{
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;
636 
637 					for(i = 0; i < MAX_VDEVICE_PER_VBUS; i++)
638 						if (_vbus_p->pVDevice[i] == ID_TO_VDEV(pParam->Members[0]))
639 							Loca = i;
640 				}
641 
642 				pArray->u.array.RebuildSectors = pArray->u.array.rf_need_rebuild? 0 : MAX_LBA_T;
643 
644 				memcpy(pArray->u.array.ArrayName, pParam->ArrayName, MAX_ARRAY_NAME);
645 
646 				for(i = 0; i < pParam->nDisk; i++)
647 				{
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;
651 
652 					/* don't unregister source disk for duplicate RAID1 */
653 					if (i ||
654 						pArray->VDeviceType!=VD_RAID_1 ||
655 						(pParam->CreateFlags & CAF_CREATE_AND_DUPLICATE)==0)
656 						UnregisterVDevice(pArray->u.array.pMember[i]);
657 
658 					if(pArray->VDeviceType == VD_RAID_5)
659 						pArray->u.array.pMember[i]->vf_cache_disk = 1;
660 				}
661 			}
662 			else
663 			{
664 				for(i = 0; i < (pParam->nDisk / 2); i++)
665 				{
666 					mArGetArrayTable(pChild);
667 					pChild->VDeviceType = VD_RAID_1;
668 
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;
674 
675 					pChild->u.array.rf_need_sync = 1;
676 					pChild->u.array.rf_newly_created = 1;
677 
678 					pChild->u.array.RebuildSectors = MAX_LBA_T;
679 
680 					memcpy(pChild->u.array.ArrayName, pParam->ArrayName, MAX_ARRAY_NAME);
681 
682 					for(j = 0; j < 2; j++)
683 					{
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]);
689 					}
690 
691 					pArray->u.array.pMember[i] = pChild;
692 
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);
698 
699 					pChild->pfnSendCommand = pfnSendCommand[pChild->VDeviceType];
700 					pChild->pfnDeviceFailed = pfnDeviceFailed[VD_RAID_0];
701 				}
702 
703 				pArray->VDeviceType = VD_RAID_0;
704 
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;
710 
711 				pArray->u.array.rf_need_sync = 1;
712 				pArray->u.array.rf_newly_created = 1;
713 
714 				memcpy(pArray->u.array.ArrayName, pParam->ArrayName, MAX_ARRAY_NAME);
715 			}
716 			break;
717 
718 		default:
719 			goto error;
720 	}
721 
722 	for(i = 0; i < pArray->u.array.bArnMember; i++)
723 		pArray->u.array.pMember[i]->pfnDeviceFailed = pfnDeviceFailed[pArray->VDeviceType];
724 
725 	if ((pParam->CreateFlags & CAF_CREATE_AND_DUPLICATE) &&
726 		(pArray->VDeviceType == VD_RAID_1))
727 	{
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;
732 		if (Loca>=0) {
733 			_vbus_p->pVDevice[Loca] = pArray;
734 			/* to comfort OS */
735 			pArray->u.array.rf_duplicate_and_created = 1;
736 			pArray->pVBus = _vbus_p;
737 		}
738 	}
739 	else {
740 		UCHAR TempBuffer[512];
741 		ZeroMemory(TempBuffer, 512);
742 		for(i = 0; i < pParam->nDisk; i++)
743 		{
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);
747 		}
748 	}
749 
750 	pArray->vf_online = 1;
751 	pArray->pParent = NULL;
752 
753 	switch(pArray->VDeviceType)
754 	{
755 		case VD_RAID_0:
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;
759 #ifdef ARRAY_V2_ONLY
760 			capacity -= 10;
761 #endif
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;
768 			break;
769 
770 		case VD_RAID_1:
771 			pArray->VDeviceCapacity = MIN(pArray->u.array.pMember[0]->VDeviceCapacity,
772 						pArray->u.array.pMember[1]->VDeviceCapacity);
773 			break;
774 
775 		case VD_JBOD:
776 			for(i = 0; i < pArray->u.array.bArnMember; i++)
777 				pArray->VDeviceCapacity += pArray->u.array.pMember[i]->VDeviceCapacity
778 #ifdef ARRAY_V2_ONLY
779 				-10
780 #endif
781 				;
782 			break;
783 
784 		case VD_RAID_5:
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);
790 			break;
791 
792 		default:
793 			goto error;
794 	}
795 
796 	pArray->pfnSendCommand = pfnSendCommand[pArray->VDeviceType];
797 	pArray->pfnDeviceFailed = fOsDiskFailed;
798 	SyncArrayInfo(pArray);
799 
800 	if (!pArray->u.array.rf_duplicate_and_created)
801 		RegisterVDevice(pArray);
802 	return VDEV_TO_ID(pArray);
803 
804 error:
805 	for(i = 0; i < pArray->u.array.bArnMember; i++)
806 	{
807 		pChild = pArray->u.array.pMember[i];
808 		if((pChild != NULL) && (pChild->VDeviceType != VD_SINGLE_DISK))
809 			mArFreeArrayTable(pChild);
810 	}
811 	mArFreeArrayTable(pArray);
812 	return INVALID_DEVICEID;
813 }
814 
815 DEVICEID hpt_create_array(_VBUS_ARG PCREATE_ARRAY_PARAMS pParam)
816 {
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 &param2);
829 }
830 
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)
834 {
835 	PVDevice pArray1 = ID_TO_VDEV(idArray);
836 	PVDevice pArray2 = 0;
837 	PVDevice pDisk	= ID_TO_VDEV(idDisk);
838 	int	i;
839 	IAL_ADAPTER_T *pAdapter = gIal_Adapter;
840 
841 	if (pArray1->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;}
842 
843 	if(pDisk->u.disk.dDeRealCapacity < (pArray1->VDeviceCapacity / 2))
844 		return -1;
845 
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++;
865 	}
866 
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)
869 		{
870 			if(pArray2->u.array.pMember[i] != NULL)
871 				pArray2->u.array.pMember[i]->pParent = NULL;
872 			pArray2->u.array.pMember[i] = pDisk;
873 			goto find;
874 		}
875 	return -1;
876 
877 find:
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];
886 
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;
891 	}
892 
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;
898 
899 	}
900 	pArray1->u.array.RebuildSectors = 0;
901 	pArray1->u.array.dArStamp = GetStamp();
902 	SyncArrayInfo(pArray1);
903 	return 1;
904 }
905 #endif
906 
907 int hpt_add_disk_to_array(_VBUS_ARG DEVICEID idArray, DEVICEID idDisk)
908 {
909 	int	i;
910 
911 	LBA_T Capacity;
912 	PVDevice pArray = ID_TO_VDEV(idArray);
913 	PVDevice pDisk	= ID_TO_VDEV(idDisk);
914 
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;
918 
919 	if(pArray->VDeviceType != VD_RAID_1 && pArray->VDeviceType != VD_RAID_5)
920 		return -1;
921 	if((pDisk->VDeviceType != VD_SINGLE_DISK) && (pDisk->VDeviceType != VD_SPARE))
922 		return -1;
923 
924 #ifdef SUPPORT_OLD_ARRAY
925 	/* RAID 0 + 1 */
926 	if (pArray->vf_format_v2 && pArray->VDeviceType==VD_RAID_1 &&
927 		pArray->u.array.pMember[0] &&
928 		mIsArray(pArray->u.array.pMember[0]))
929 	{
930 		if(old_add_disk_to_raid01(_VBUS_P idArray, idDisk))
931 			return 0;
932 		else
933 			return -1;
934 	}
935 #endif
936 
937 	Capacity = pArray->VDeviceCapacity / (pArray->u.array.bArnMember - 1);
938 
939 	if (pArray->vf_format_v2) {
940 		if(pDisk->u.disk.dDeRealCapacity < Capacity) return -1;
941 	}
942 	else
943 		if(pDisk->VDeviceCapacity < Capacity) return -1;
944 
945 	if (pArray->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;}
946 
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)
949 		{
950 			if(pArray->u.array.pMember[i] != NULL)
951 				pArray->u.array.pMember[i]->pParent = NULL;
952 			pArray->u.array.pMember[i] = pDisk;
953 			goto find;
954 		}
955 	return -1;
956 
957 find:
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;
967 	}
968 
969 	pArray->u.array.bArRealnMember++;
970 	if(pArray->u.array.bArnMember == pArray->u.array.bArRealnMember)
971 	{
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;
976 	}
977 	pArray->u.array.RebuildSectors = 0;
978 
979 	/* sync the whole array */
980 	while (pArray->pParent) pArray = pArray->pParent;
981 	pArray->u.array.dArStamp = GetStamp();
982 	SyncArrayInfo(pArray);
983 	return 0;
984 }
985 
986 int hpt_add_spare_disk(_VBUS_ARG DEVICEID idDisk)
987 {
988 	PVDevice pVDevice = ID_TO_VDEV(idDisk);
989 	DECLARE_BUFFER(PUCHAR, pbuffer);
990 
991 	if(idDisk == 0 || check_VDevice_valid(pVDevice))	return -1;
992 	if (pVDevice->VDeviceType != VD_SINGLE_DISK || pVDevice->pParent)
993 		return -1;
994 
995 	if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
996 
997 	UnregisterVDevice(pVDevice);
998 	pVDevice->VDeviceType = VD_SPARE;
999 	pVDevice->vf_bootmark = 0;
1000 
1001 	ZeroMemory((char *)pbuffer, 512);
1002 	fDeReadWrite(&pVDevice->u.disk, 0, IDE_COMMAND_WRITE, pbuffer);
1003 	SyncArrayInfo(pVDevice);
1004 	return 0;
1005 }
1006 
1007 int hpt_remove_spare_disk(_VBUS_ARG DEVICEID idDisk)
1008 {
1009 	PVDevice pVDevice = ID_TO_VDEV(idDisk);
1010 
1011 	if(idDisk == 0 || check_VDevice_valid(pVDevice))	return -1;
1012 
1013 	if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
1014 
1015 	pVDevice->VDeviceType = VD_SINGLE_DISK;
1016 
1017 	SyncArrayInfo(pVDevice);
1018 	RegisterVDevice(pVDevice);
1019 	return 0;
1020 }
1021 
1022 int hpt_set_array_info(_VBUS_ARG DEVICEID idArray, PALTERABLE_ARRAY_INFO pInfo)
1023 {
1024 	PVDevice pVDevice = ID_TO_VDEV(idArray);
1025 
1026 	if(idArray == 0 || check_VDevice_valid(pVDevice)) return -1;
1027 	if (!mIsArray(pVDevice)) return -1;
1028 
1029 	/* if the pVDevice isn't a top level, return -1; */
1030 	if(pVDevice->pParent != NULL) return -1;
1031 
1032 	if (pVDevice->pVBus!=_vbus_p) { HPT_ASSERT(0); return -1;}
1033 
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;
1038 	}
1039 
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;
1043 	}
1044 
1045 	if (pVDevice->u.array.rf_need_sync)
1046 		SyncArrayInfo(pVDevice);
1047 	return 0;
1048 }
1049 
1050 static int hpt_set_device_info(_VBUS_ARG DEVICEID idDisk, PALTERABLE_DEVICE_INFO pInfo)
1051 {
1052 	PVDevice pVDevice = ID_TO_VDEV(idDisk);
1053 
1054 	if(idDisk == 0 || check_VDevice_valid(pVDevice)) return -1;
1055 	if (mIsArray(pVDevice))
1056 		return -1;
1057 
1058 	if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
1059 
1060 	/* TODO */
1061 		return 0;
1062 	}
1063 
1064 static int hpt_set_device_info_v2(_VBUS_ARG DEVICEID idDisk, PALTERABLE_DEVICE_INFO_V2 pInfo)
1065 {
1066 	PVDevice pVDevice = ID_TO_VDEV(idDisk);
1067 	int sync = 0;
1068 
1069 	if(idDisk==0 || check_VDevice_valid(pVDevice)) return -1;
1070 	if (mIsArray(pVDevice))
1071 		return -1;
1072 
1073 	if (pVDevice->u.disk.pVBus!=_vbus_p) return -1;
1074 
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);
1080 		sync = 1;
1081 }
1082 
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;
1087 			sync = 1;
1088 }
1089 	}
1090 
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;
1095 			sync = 1;
1096 	}
1097 	}
1098 
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;
1103 			sync = 1;
1104 	}
1105 	}
1106 
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;
1111 			sync = 1;
1112 		}
1113 	}
1114 
1115 	if (sync)
1116 		SyncArrayInfo(pVDevice);
1117 	return 0;
1118 }
1119 
1120 #endif
1121 
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.
1126  */
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 */
1134 					)
1135 {
1136 	switch(dwIoControlCode)	{
1137 
1138 	case HPT_IOCTL_GET_VERSION:
1139 
1140 		if (nInBufferSize != 0) return -1;
1141 		if (nOutBufferSize != sizeof(DWORD)) return -1;
1142 		*((DWORD*)lpOutBuffer) = HPT_INTERFACE_VERSION;
1143 		break;
1144 
1145 	case HPT_IOCTL_GET_CONTROLLER_COUNT:
1146 
1147 		if (nOutBufferSize!=sizeof(DWORD)) return -1;
1148 		*(PDWORD)lpOutBuffer = hpt_get_controller_count();
1149 		break;
1150 
1151 	case HPT_IOCTL_GET_CONTROLLER_INFO:
1152 		{
1153 			int id;
1154 			PCONTROLLER_INFO pInfo;
1155 
1156 			if (nInBufferSize!=sizeof(DWORD)) return -1;
1157 			if (nOutBufferSize!=sizeof(CONTROLLER_INFO)) return -1;
1158 
1159 			id = *(DWORD *)lpInBuffer;
1160 			pInfo = (PCONTROLLER_INFO)lpOutBuffer;
1161 			if (hpt_get_controller_info(id, pInfo)!=0)
1162 				return -1;
1163 		}
1164 		break;
1165 
1166 	case HPT_IOCTL_GET_CHANNEL_INFO:
1167 		{
1168 			int id, bus;
1169 			PCHANNEL_INFO pInfo;
1170 
1171 			if (nInBufferSize!=8) return -1;
1172 			if (nOutBufferSize!=sizeof(CHANNEL_INFO)) return -1;
1173 
1174 			id = *(DWORD *)lpInBuffer;
1175 			bus = ((DWORD *)lpInBuffer)[1];
1176 			pInfo = (PCHANNEL_INFO)lpOutBuffer;
1177 
1178 			if (hpt_get_channel_info(id, bus, pInfo)!=0)
1179 				return -1;
1180 		}
1181 		break;
1182 
1183 	case HPT_IOCTL_GET_LOGICAL_DEVICES:
1184 		{
1185 			DWORD nMax;
1186 			DEVICEID *pIds;
1187 
1188 			if (nInBufferSize!=sizeof(DWORD)) return -1;
1189 			nMax = *(DWORD *)lpInBuffer;
1190 			if (nOutBufferSize < sizeof(DWORD)+sizeof(DWORD)*nMax) return -1;
1191 
1192 			pIds = ((DEVICEID *)lpOutBuffer)+1;
1193 			*(DWORD*)lpOutBuffer = hpt_get_logical_devices(pIds, nMax);
1194 		}
1195 		break;
1196 
1197 	case HPT_IOCTL_GET_DEVICE_INFO:
1198 		{
1199 			DEVICEID id;
1200 			PLOGICAL_DEVICE_INFO pInfo;
1201 
1202 			if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1203 			if (nOutBufferSize!=sizeof(LOGICAL_DEVICE_INFO)) return -1;
1204 
1205 			id = *(DWORD *)lpInBuffer;
1206 			if (id == INVALID_DEVICEID)	return -1;
1207 
1208 			pInfo = (PLOGICAL_DEVICE_INFO)lpOutBuffer;
1209 			memset(pInfo, 0, sizeof(LOGICAL_DEVICE_INFO));
1210 
1211 			if (hpt_get_device_info(id, pInfo)!=0)
1212 				return -1;
1213 		}
1214 		break;
1215 
1216 	case HPT_IOCTL_GET_DEVICE_INFO_V2:
1217 		{
1218 			DEVICEID id;
1219 			PLOGICAL_DEVICE_INFO_V2 pInfo;
1220 
1221 			if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1222 			if (nOutBufferSize!=sizeof(LOGICAL_DEVICE_INFO_V2)) return -1;
1223 
1224 			id = *(DWORD *)lpInBuffer;
1225 			if (id == INVALID_DEVICEID)	return -1;
1226 
1227 			pInfo = (PLOGICAL_DEVICE_INFO_V2)lpOutBuffer;
1228 			memset(pInfo, 0, sizeof(LOGICAL_DEVICE_INFO_V2));
1229 
1230 			if (hpt_get_device_info_v2(id, pInfo)!=0)
1231 				return -1;
1232 		}
1233 		break;
1234 
1235 #ifdef SUPPORT_ARRAY
1236 	case HPT_IOCTL_CREATE_ARRAY:
1237 		{
1238 			if (nInBufferSize!=sizeof(CREATE_ARRAY_PARAMS)) return -1;
1239 			if (nOutBufferSize!=sizeof(DEVICEID)) return -1;
1240 
1241 			*(DEVICEID *)lpOutBuffer = hpt_create_array(_VBUS_P (PCREATE_ARRAY_PARAMS)lpInBuffer);
1242 
1243 			if(*(DEVICEID *)lpOutBuffer == INVALID_DEVICEID)
1244 				return -1;
1245 		}
1246 		break;
1247 
1248 	case HPT_IOCTL_CREATE_ARRAY_V2:
1249 		{
1250 			if (nInBufferSize!=sizeof(CREATE_ARRAY_PARAMS_V2)) return -1;
1251 			if (nOutBufferSize!=sizeof(DEVICEID)) return -1;
1252 
1253 			*(DEVICEID *)lpOutBuffer = hpt_create_array_v2(_VBUS_P (PCREATE_ARRAY_PARAMS_V2)lpInBuffer);
1254 
1255 			if (*(DEVICEID *)lpOutBuffer == INVALID_DEVICEID)
1256 				return -1;
1257 		}
1258 		break;
1259 
1260 	case HPT_IOCTL_SET_ARRAY_INFO:
1261 		{
1262 			DEVICEID idArray;
1263 			PALTERABLE_ARRAY_INFO pInfo;
1264 
1265 			if (nInBufferSize!=sizeof(HPT_SET_ARRAY_INFO)) return -1;
1266 			if (nOutBufferSize!=0) return -1;
1267 
1268 			idArray = ((PHPT_SET_ARRAY_INFO)lpInBuffer)->idArray;
1269 			pInfo = &((PHPT_SET_ARRAY_INFO)lpInBuffer)->Info;
1270 
1271 			if(hpt_set_array_info(_VBUS_P idArray,  pInfo))
1272 				return -1;
1273 		}
1274 		break;
1275 
1276 	case HPT_IOCTL_SET_DEVICE_INFO:
1277 		{
1278 			DEVICEID idDisk;
1279 			PALTERABLE_DEVICE_INFO pInfo;
1280 
1281 			if (nInBufferSize!=sizeof(HPT_SET_DEVICE_INFO)) return -1;
1282 			if (nOutBufferSize!=0) return -1;
1283 
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)
1287 				return -1;
1288 		}
1289 		break;
1290 
1291 	case HPT_IOCTL_SET_DEVICE_INFO_V2:
1292 		{
1293 			DEVICEID idDisk;
1294 			PALTERABLE_DEVICE_INFO_V2 pInfo;
1295 
1296 			if (nInBufferSize < sizeof(HPT_SET_DEVICE_INFO_V2)) return -1;
1297 			if (nOutBufferSize!=0) return -1;
1298 
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)
1302 				return -1;
1303 		}
1304 		break;
1305 
1306 	case HPT_IOCTL_SET_BOOT_MARK:
1307 		{
1308 			DEVICEID id;
1309 			PVDevice pTop;
1310 			int i;
1311 			IAL_ADAPTER_T *pAdapter = gIal_Adapter;
1312 			PVBus pVBus;
1313 
1314 			if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1315 			id = *(DEVICEID *)lpInBuffer;
1316 			while(pAdapter != 0)
1317 			{
1318 				pVBus = &pAdapter->VBus;
1319 				for(i = 0; i < MAX_VDEVICE_PER_VBUS; i++)
1320 				{
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;
1328 					else
1329 						continue;
1330 					SyncArrayInfo(pTop);
1331 					break;
1332 				}
1333 				pAdapter = pAdapter->next;
1334 			}
1335 		}
1336 		break;
1337 
1338 	case HPT_IOCTL_ADD_SPARE_DISK:
1339 		{
1340 			DEVICEID id;
1341 
1342 			if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1343 			if (nOutBufferSize!=0) return -1;
1344 
1345 			id = *(DEVICEID *)lpInBuffer;
1346 
1347 			if(hpt_add_spare_disk(_VBUS_P id))
1348 				return -1;
1349 		}
1350 		break;
1351 
1352 	case HPT_IOCTL_REMOVE_SPARE_DISK:
1353 		{
1354 			DEVICEID id;
1355 
1356 			if (nInBufferSize!=sizeof(DEVICEID)) return -1;
1357 			if (nOutBufferSize!=0) return -1;
1358 
1359 			id = *(DEVICEID *)lpInBuffer;
1360 
1361 			if(hpt_remove_spare_disk(_VBUS_P id))
1362 				return -1;
1363 		}
1364 		break;
1365 
1366 	case HPT_IOCTL_ADD_DISK_TO_ARRAY:
1367 		{
1368 			DEVICEID id1,id2;
1369 			id1 = ((PHPT_ADD_DISK_TO_ARRAY)lpInBuffer)->idArray;
1370 			id2 = ((PHPT_ADD_DISK_TO_ARRAY)lpInBuffer)->idDisk;
1371 
1372 			if (nInBufferSize != sizeof(HPT_ADD_DISK_TO_ARRAY)) return -1;
1373 			if (nOutBufferSize != 0) return -1;
1374 
1375 			if(hpt_add_disk_to_array(_VBUS_P id1, id2))
1376 				return -1;
1377 		}
1378 		break;
1379 #endif
1380 	case HPT_IOCTL_GET_DRIVER_CAPABILITIES:
1381 		{
1382 			PDRIVER_CAPABILITIES cap;
1383 			if (nOutBufferSize<sizeof(DRIVER_CAPABILITIES)) return -1;
1384 			cap = (PDRIVER_CAPABILITIES)lpOutBuffer;
1385 
1386 			if(hpt_get_driver_capabilities(cap))
1387 				return -1;
1388 		}
1389 		break;
1390 
1391 	case HPT_IOCTL_GET_CONTROLLER_VENID:
1392 		{
1393 			DWORD id = ((DWORD*)lpInBuffer)[0];
1394 			IAL_ADAPTER_T *pAdapTemp;
1395 			int iControllerCount = 0;
1396 
1397 			for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next)
1398 				if (iControllerCount++==id)
1399 					break;
1400 
1401 			if (!pAdapTemp)
1402 				return -1;
1403 
1404 			if (nOutBufferSize < 4)
1405 				return -1;
1406 
1407 			*(DWORD*)lpOutBuffer = ((DWORD)pAdapTemp->mvSataAdapter.pciConfigDeviceId << 16) | 0x11AB;
1408 			return 0;
1409 		}
1410 
1411 	case HPT_IOCTL_EPROM_IO:
1412 		{
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;
1419 
1420 			for (pAdapTemp = gIal_Adapter; pAdapTemp; pAdapTemp = pAdapTemp->next)
1421 				if (iControllerCount++==id)
1422 					break;
1423 
1424 			if (!pAdapTemp)
1425 				return -1;
1426 
1427 			if (nInBufferSize < sizeof(DWORD) * 4 + (direction? length : 0) ||
1428 				nOutBufferSize < (direction? 0 : length))
1429 				return -1;
1430 
1431 			if (direction == 0) /* read */
1432 				sx508x_flash_access(&pAdapTemp->mvSataAdapter,
1433 					offset, lpOutBuffer, length, 1);
1434 			else
1435 				sx508x_flash_access(&pAdapTemp->mvSataAdapter,
1436 					offset, (char *)lpInBuffer + 16, length, 0);
1437 
1438 			return 0;
1439 		}
1440 		break;
1441 
1442 	default:
1443 		return -1;
1444 	}
1445 
1446 	if (lpBytesReturned)
1447 		*lpBytesReturned = nOutBufferSize;
1448 	return 0;
1449 }
1450