1 /*******************************************************************************
2 *Copyright (c) 2014 PMC-Sierra, Inc. All rights reserved.
4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided
5 *that the following conditions are met:
6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
8 *2. Redistributions in binary form must reproduce the above copyright notice,
9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided
10 *with the distribution.
12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
21 ********************************************************************************/
22 /*******************************************************************************/
24 * \brief The file implements the functions to handle port
27 /******************************************************************************/
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
30 #include <dev/pms/config.h>
32 #include <dev/pms/RefTisa/sallsdk/spc/saglobal.h>
33 #ifdef SA_ENABLE_TRACE_FUNCTIONS
37 #define siTraceFileID 'L'
41 extern bit32 gFPGA_TEST;
42 /******************************************************************************/
43 /*! \brief Add a SAS device to the discovery list of the port
45 * Add a SAS device from the discovery list of the port
47 * \param agRoot handles for this instance of SAS/SATA LLL
52 * \param itNexusTimeout
53 * \param firstBurstSize
54 * \param dTypeSRate -- device type and link rate
57 * \return -the device descriptor-
59 /*******************************************************************************/
60 GLOBAL agsaDeviceDesc_t *siPortSASDeviceAdd(
63 agsaSASIdentify_t sasIdentify,
72 agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
73 agsaDeviceDesc_t *pDevice;
75 SA_DBG3(("siPortSASDeviceAdd: start\n"));
77 smTraceFuncEnter(hpDBG_VERY_LOUD, "23");
80 SA_ASSERT((agNULL != agRoot), "");
81 SA_ASSERT((agNULL != pPort), "");
83 /* Acquire Device Lock */
84 ossaSingleThreadedEnter(agRoot, LL_DEVICE_LOCK);
86 /* Try to Allocate from device list */
87 pDevice = (agsaDeviceDesc_t *) saLlistGetHead(&(saRoot->freeDevicesList));
89 /* If device handle available */
90 if ( agNULL != pDevice)
94 /* Remove from free device list */
95 saLlistRemove(&(saRoot->freeDevicesList), &(pDevice->linkNode));
97 /* Initialize device descriptor */
98 if ( agTRUE == sasInitiator )
100 pDevice->initiatorDevHandle.sdkData = pDevice;
101 pDevice->targetDevHandle.sdkData = agNULL;
105 pDevice->initiatorDevHandle.sdkData = agNULL;
106 pDevice->targetDevHandle.sdkData = pDevice;
109 pDevice->initiatorDevHandle.osData = agNULL;
110 pDevice->targetDevHandle.osData = agNULL;
112 /* setup device type */
113 pDevice->deviceType = (bit8)((dTypeSRate & 0x30) >> SHIFT4);
114 SA_DBG3(("siPortSASDeviceAdd: Device Type 0x%x, Port Context %p\n", pDevice->deviceType, pPort));
115 pDevice->pPort = pPort;
116 saLlistInitialize(&(pDevice->pendingIORequests));
118 /* setup sasDeviceInfo */
119 pDevice->devInfo.sasDeviceInfo.commonDevInfo.smpTimeout = (bit16)smpTimeout;
120 pDevice->devInfo.sasDeviceInfo.commonDevInfo.it_NexusTimeout = (bit16)itNexusTimeout;
121 pDevice->devInfo.sasDeviceInfo.commonDevInfo.firstBurstSize = (bit16)firstBurstSize;
122 pDevice->devInfo.sasDeviceInfo.commonDevInfo.devType_S_Rate = dTypeSRate;
123 pDevice->devInfo.sasDeviceInfo.commonDevInfo.flag = flag;
124 for (i = 0; i < 4; i++)
126 pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressHi[i] = sasIdentify.sasAddressHi[i];
127 pDevice->devInfo.sasDeviceInfo.commonDevInfo.sasAddressLo[i] = sasIdentify.sasAddressLo[i];
129 pDevice->devInfo.sasDeviceInfo.initiator_ssp_stp_smp = sasIdentify.initiator_ssp_stp_smp;
130 pDevice->devInfo.sasDeviceInfo.target_ssp_stp_smp = sasIdentify.target_ssp_stp_smp;
131 pDevice->devInfo.sasDeviceInfo.phyIdentifier = sasIdentify.phyIdentifier;
133 /* Add to discoverd device for the port */
134 saLlistAdd(&(pPort->listSASATADevices), &(pDevice->linkNode));
136 /* Release Device Lock */
137 ossaSingleThreadedLeave(agRoot, LL_DEVICE_LOCK);
140 SA_DBG3(("siPortSASDeviceAdd: sasIdentify addrHI 0x%x\n", SA_IDFRM_GET_SAS_ADDRESSHI(&sasIdentify)));
141 SA_DBG3(("siPortSASDeviceAdd: sasIdentify addrLO 0x%x\n", SA_IDFRM_GET_SAS_ADDRESSLO(&sasIdentify)));
146 /* Release Device Lock */
147 ossaSingleThreadedLeave(agRoot, LL_DEVICE_LOCK);
148 SA_ASSERT((agNULL != pDevice), "");
149 SA_DBG1(("siPortSASDeviceAdd: device allocation failed\n"));
151 SA_DBG3(("siPortSASDeviceAdd: end\n"));
153 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "23");
157 /******************************************************************************/
158 /*! \brief The function to remove a device descriptor
160 * The function to remove a device descriptor
162 * \param agRoot handles for this instance of SAS/SATA hardware
163 * \param pPort The pointer to the port
164 * \param pDevice The pointer to the device
168 /*******************************************************************************/
169 GLOBAL void siPortDeviceRemove(
172 agsaDeviceDesc_t *pDevice,
176 agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
179 smTraceFuncEnter(hpDBG_VERY_LOUD, "24");
182 SA_ASSERT((agNULL != agRoot), "");
183 SA_ASSERT((agNULL != pPort), "");
184 SA_ASSERT((agNULL != pDevice), "");
185 SA_ASSERT((SAS_SATA_UNKNOWN_DEVICE != pDevice->deviceType), "");
187 /* remove the device from discovered list */
188 SA_DBG3(("siPortDeviceRemove(SAS/SATA): DeviceIndex %d Device Context %p\n", pDevice->DeviceMapIndex, pDevice));
190 ossaSingleThreadedEnter(agRoot, LL_DEVICE_LOCK);
191 saLlistRemove(&(pPort->listSASATADevices), &(pDevice->linkNode));
193 /* Reset the device data structure */
194 pDevice->pPort = agNULL;
195 pDevice->initiatorDevHandle.osData = agNULL;
196 pDevice->initiatorDevHandle.sdkData = agNULL;
197 pDevice->targetDevHandle.osData = agNULL;
198 pDevice->targetDevHandle.sdkData = agNULL;
200 saLlistAdd(&(saRoot->freeDevicesList), &(pDevice->linkNode));
204 /* remove the DeviceMap and MapIndex */
205 deviceIdx = pDevice->DeviceMapIndex & DEVICE_ID_BITS;
206 OS_ASSERT(deviceIdx < MAX_IO_DEVICE_ENTRIES, "deviceIdx MAX_IO_DEVICE_ENTRIES");
208 saRoot->DeviceMap[deviceIdx].DeviceIdFromFW = 0;
209 saRoot->DeviceMap[deviceIdx].DeviceHandle = agNULL;
210 pDevice->DeviceMapIndex = 0;
212 ossaSingleThreadedLeave(agRoot, LL_DEVICE_LOCK);
214 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "24");
219 /******************************************************************************/
220 /*! \brief Add a SATA device to the discovery list of the port
222 * Add a SATA device from the discovery list of the port
224 * \param agRoot handles for this instance of SAS/SATA hardware
230 * \param smpReqTimeout
231 * \param itNexusTimeout
232 * \param firstBurstSize
235 * \return -the device descriptor-
237 /*******************************************************************************/
238 GLOBAL agsaDeviceDesc_t *siPortSATADeviceAdd(
241 agsaDeviceDesc_t *pSTPBridge,
246 bit32 itNexusTimeout,
247 bit32 firstBurstSize,
252 agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
253 agsaDeviceDesc_t *pDevice;
255 smTraceFuncEnter(hpDBG_VERY_LOUD, "25");
258 SA_ASSERT((agNULL != agRoot), "");
259 SA_ASSERT((agNULL != pPort), "");
261 /* Acquire Device Lock */
262 ossaSingleThreadedEnter(agRoot, LL_DEVICE_LOCK);
264 /* Try to Allocate from device list */
265 pDevice = (agsaDeviceDesc_t *) saLlistGetHead(&(saRoot->freeDevicesList));
267 /* If device handle available */
268 if ( agNULL != pDevice)
272 /* Remove from free device list */
273 saLlistRemove(&(saRoot->freeDevicesList), &(pDevice->linkNode));
275 /* Initialize the device descriptor */
276 pDevice->initiatorDevHandle.sdkData = agNULL;
277 pDevice->targetDevHandle.sdkData = pDevice;
278 pDevice->initiatorDevHandle.osData = agNULL;
279 pDevice->targetDevHandle.osData = agNULL;
281 pDevice->deviceType = (bit8)((dTypeSRate & 0x30) >> SHIFT4);
282 SA_DBG3(("siPortSATADeviceAdd: DeviceType 0x%x Port Context %p\n", pDevice->deviceType, pPort));
284 /* setup device common infomation */
285 pDevice->devInfo.sataDeviceInfo.commonDevInfo.smpTimeout = (bit16)smpReqTimeout;
286 pDevice->devInfo.sataDeviceInfo.commonDevInfo.it_NexusTimeout = (bit16)itNexusTimeout;
287 pDevice->devInfo.sataDeviceInfo.commonDevInfo.firstBurstSize = (bit16)firstBurstSize;
288 pDevice->devInfo.sataDeviceInfo.commonDevInfo.devType_S_Rate = dTypeSRate;
289 pDevice->devInfo.sataDeviceInfo.commonDevInfo.flag = flag;
290 for (i = 0; i < 4; i++)
292 pDevice->devInfo.sataDeviceInfo.commonDevInfo.sasAddressHi[i] = 0;
293 pDevice->devInfo.sataDeviceInfo.commonDevInfo.sasAddressLo[i] = 0;
295 /* setup SATA device information */
296 pDevice->devInfo.sataDeviceInfo.connection = pm;
297 pDevice->devInfo.sataDeviceInfo.portMultiplierField = pmField;
298 pDevice->devInfo.sataDeviceInfo.stpPhyIdentifier = 0;
299 pDevice->pPort = pPort;
301 /* Add to discoverd device for the port */
302 saLlistAdd(&(pPort->listSASATADevices), &(pDevice->linkNode));
304 /* Release Device Lock */
305 ossaSingleThreadedLeave(agRoot, LL_DEVICE_LOCK);
309 /* Release Device Lock */
310 ossaSingleThreadedLeave(agRoot, LL_DEVICE_LOCK);
311 SA_ASSERT((agNULL != pDevice), "");
312 SA_DBG1(("siPortSATADeviceAdd: device allocation failed\n"));
314 SA_DBG3(("siPortSATADeviceAdd: end\n"));
316 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "25");
320 /******************************************************************************/
321 /*! \brief Invalid a port
325 * \param agRoot handles for this instance of SAS/SATA hardware
330 /*******************************************************************************/
331 GLOBAL void siPortInvalid(
336 agsaLLRoot_t *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
337 smTraceFuncEnter(hpDBG_VERY_LOUD, "26");
340 SA_ASSERT((agNULL != agRoot), "");
341 SA_ASSERT((agNULL != pPort), "");
343 /* set port's status to invalidating */
344 pPort->status |= PORT_INVALIDATING;
346 /* Remove from validPort and add the port back to the free port link list */
347 ossaSingleThreadedEnter(agRoot, LL_PORT_LOCK);
348 saLlistRemove(&(saRoot->validPorts), &(pPort->linkNode));
349 saLlistAdd(&(saRoot->freePorts), &(pPort->linkNode));
350 pPort->tobedeleted = agFALSE;
351 ossaSingleThreadedLeave(agRoot, LL_PORT_LOCK);
353 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "26");
358 /******************************************************************************/
359 /*! \brief The function to remove a device descriptor
361 * The function to remove a device descriptor
363 * \param agRoot handles for this instance of SAS/SATA hardware
364 * \param pPort The pointer to the port
365 * \param pDevice The pointer to the device
369 /*******************************************************************************/
370 GLOBAL void siPortDeviceListRemove(
373 agsaDeviceDesc_t *pDevice
376 agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
378 smTraceFuncEnter(hpDBG_VERY_LOUD, "27");
381 SA_ASSERT((agNULL != agRoot), "");
382 SA_ASSERT((agNULL != pPort), "");
383 SA_ASSERT((agNULL != pDevice), "");
384 SA_ASSERT((SAS_SATA_UNKNOWN_DEVICE != pDevice->deviceType), "");
386 /* remove the device from discovered list */
387 SA_DBG3(("siPortDeviceListRemove(SAS/SATA): PortID %d Device Context %p\n", pPort->portId, pDevice));
389 ossaSingleThreadedEnter(agRoot, LL_DEVICE_LOCK);
390 saLlistRemove(&(pPort->listSASATADevices), &(pDevice->linkNode));
392 /* Reset the device data structure */
393 pDevice->pPort = agNULL;
394 pDevice->initiatorDevHandle.osData = agNULL;
395 pDevice->initiatorDevHandle.sdkData = agNULL;
396 pDevice->targetDevHandle.osData = agNULL;
397 pDevice->targetDevHandle.sdkData = agNULL;
399 saLlistAdd(&(saRoot->freeDevicesList), &(pDevice->linkNode));
400 ossaSingleThreadedLeave(agRoot, LL_DEVICE_LOCK);
402 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "27");
406 /******************************************************************************/
407 /*! \brief Initiate a Port COntrol IOMB command
409 * This function is called to initiate a Port COntrol command to the SPC.
410 * The completion of this function is reported in ossaPortControlCB().
412 * \param agRoot handles for this instance of SAS/SATA hardware
413 * \param agContext the context of this API
414 * \param queueNum queue number
415 * \param agPortContext point to the event source structure
416 * \param param0 parameter 0
417 * \param param1 parameter 1
419 * \return - successful or failure
421 /*******************************************************************************/
422 GLOBAL bit32 saPortControl(
424 agsaContext_t *agContext,
426 agsaPortContext_t *agPortContext,
432 agsaLLRoot_t *saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
433 agsaIORequestDesc_t *pRequest;
435 bit32 ret = AGSA_RC_SUCCESS;
437 agsaPortControlCmd_t payload;
438 bit32 using_reserved = agFALSE;
442 SA_ASSERT((agNULL !=saRoot ), "");
443 SA_ASSERT((agNULL != agPortContext), "");
446 SA_DBG1(("saPortControl: saRoot == agNULL\n"));
447 return(AGSA_RC_FAILURE);
449 smTraceFuncEnter(hpDBG_VERY_LOUD, "28");
451 SA_DBG1(("saPortControl: portContext %p portOperation 0x%x param0 0x%x param1 0x%x\n", agPortContext, portOperation, param0, param1));
453 /* Get request from free IORequests */
454 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
455 pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); /**/
456 /* If no LL Control request entry available */
457 if ( agNULL == pRequest )
459 pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeReservedRequests));
460 /* If no LL Control request entry available */
461 if(agNULL != pRequest)
463 using_reserved = agTRUE;
464 SA_DBG2(("saPortControl, using saRoot->freeReservedRequests\n"));
468 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
469 SA_DBG1(("saPortControl, No request from free list Not using saRoot->freeReservedRequests\n"));
470 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "28");
475 /* If LL Control request entry avaliable */
478 saLlistIORemove(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
482 /* Remove the request from free list */
483 saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
485 SA_ASSERT((!pRequest->valid), "The pRequest is in use");
486 saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
487 saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
488 saRoot->IOMap[pRequest->HTag].agContext = agContext;
489 pRequest->valid = agTRUE;
490 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
492 /* build IOMB command and send to SPC */
493 /* set payload to zeros */
494 si_memset(&payload, 0, sizeof(agsaPortControlCmd_t));
497 pPort = (agsaPort_t *) (agPortContext->sdkData);
498 opportId = (pPort->portId & PORTID_MASK) | (portOperation << SHIFT8);
500 OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPortControlCmd_t, tag), pRequest->HTag);
501 OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPortControlCmd_t, portOPPortId), opportId);
502 OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPortControlCmd_t, Param0), param0);
503 OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaPortControlCmd_t, Param1), param1);
505 SA_DBG1(("saPortControl: portId 0x%x portOperation 0x%x\n", (pPort->portId & PORTID_MASK),portOperation));
507 /* build IOMB command and send to SPC */
508 ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_PORT_CONTROL, IOMB_SIZE64, queueNum);
509 if (AGSA_RC_SUCCESS != ret)
511 /* remove the request from IOMap */
512 saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
513 saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
514 saRoot->IOMap[pRequest->HTag].agContext = agNULL;
515 pRequest->valid = agFALSE;
516 /* return the request to free pool */
517 ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
518 if (saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
520 SA_DBG1(("saPortControl: saving pRequest (%p) for later use\n", pRequest));
521 saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
525 /* return the request to free pool */
526 saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
528 ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
529 SA_DBG1(("saPortControl, sending IOMB failed\n" ));
533 if (portOperation == AGSA_PORT_HARD_RESET)
535 SA_DBG1(("saPortControl,0x%x AGSA_PORT_HARD_RESET 0x%x param0 0x%x\n",
536 pPort->portId, param0, param0 & AUTO_HARD_RESET_DEREG_FLAG));
537 saRoot->autoDeregDeviceflag[pPort->portId & PORTID_MASK] = param0 & AUTO_HARD_RESET_DEREG_FLAG;
539 else if (portOperation == AGSA_PORT_CLEAN_UP)
541 SA_DBG1(("saPortControl, 0x%x AGSA_PORT_CLEAN_UP param0 0x%x %d\n", pPort->portId, param0,((param0 & AUTO_FW_CLEANUP_DEREG_FLAG) ? 0:1)));
542 saRoot->autoDeregDeviceflag[pPort->portId & PORTID_MASK] = ((param0 & AUTO_FW_CLEANUP_DEREG_FLAG) ? 0:1);
544 SA_DBG1(("saPortControl, sending IOMB SUCCESS, portId 0x%x autoDeregDeviceflag=0x%x\n", pPort->portId,saRoot->autoDeregDeviceflag[pPort->portId & PORTID_MASK]));
547 smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "28");
555 * Returns the status, working state and sector size
556 * registers of the encryption engine
563 GLOBAL bit32 saEncryptGetMode(agsaRoot_t *agRoot,
564 agsaContext_t *agContext,
565 agsaEncryptInfo_t *encryptInfo)
567 bit32 ret = AGSA_RC_NOT_SUPPORTED;
569 smTraceFuncEnter(hpDBG_VERY_LOUD,"29");
570 agContext = agContext; /* Lint*/
571 SA_DBG4(("saEncryptGetMode, encryptInfo %p\n",encryptInfo ));
572 if(smIS_SPCV(agRoot))
574 bit32 ScratchPad1 =0;
575 bit32 ScratchPad3 =0;
577 encryptInfo->status = 0;
578 encryptInfo->encryptionCipherMode = 0;
579 encryptInfo->encryptionSecurityMode = 0;
580 encryptInfo->flag = 0;
582 ScratchPad1 = ossaHwRegRead(agRoot,V_Scratchpad_1_Register);
583 ScratchPad3 = ossaHwRegRead(agRoot,V_Scratchpad_3_Register);
584 if((ScratchPad1 & SCRATCH_PAD1_V_RAAE_MASK) == SCRATCH_PAD1_V_RAAE_MASK)
586 if((ScratchPad3 & SCRATCH_PAD3_V_ENC_MASK) == SCRATCH_PAD3_V_ENC_READY ) /* 3 */
588 if( ScratchPad3 & SCRATCH_PAD3_V_XTS_ENABLED)
590 encryptInfo->encryptionCipherMode = agsaEncryptCipherModeXTS;
592 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMF_ENABLED )
594 encryptInfo->encryptionSecurityMode = agsaEncryptSMF;
596 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMA_ENABLED)
598 encryptInfo->encryptionSecurityMode = agsaEncryptSMA;
600 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMB_ENABLED )
602 encryptInfo->encryptionSecurityMode = agsaEncryptSMB;
604 encryptInfo->status = AGSA_RC_SUCCESS;
605 ret = AGSA_RC_SUCCESS;
607 else if((ScratchPad3 & SCRATCH_PAD3_V_ENC_READY) == SCRATCH_PAD3_V_ENC_DISABLED) /* 0 */
609 SA_DBG1(("saEncryptGetMode, SCRATCH_PAD3_V_ENC_DISABLED 1 0x%08X 3 0x%08X\n",ScratchPad1,ScratchPad3 ));
610 encryptInfo->status = 0xFFFF;
611 encryptInfo->encryptionCipherMode = 0;
612 encryptInfo->encryptionSecurityMode = 0;
613 ret = AGSA_RC_NOT_SUPPORTED;
615 else if((ScratchPad3 & SCRATCH_PAD3_V_ENC_MASK ) == SCRATCH_PAD3_V_ENC_DIS_ERR) /* 1 */
617 SA_DBG1(("saEncryptGetMode, SCRATCH_PAD3_V_ENC_DIS_ERR 1 0x%08X 3 0x%08X\n",ScratchPad1,ScratchPad3 ));
618 encryptInfo->status = (ScratchPad3 & SCRATCH_PAD3_V_ERR_CODE ) >> SHIFT16;
619 if( ScratchPad3 & SCRATCH_PAD3_V_XTS_ENABLED)
621 encryptInfo->encryptionCipherMode = agsaEncryptCipherModeXTS;
623 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMF_ENABLED )
625 encryptInfo->encryptionSecurityMode = agsaEncryptSMF;
627 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMA_ENABLED)
629 encryptInfo->encryptionSecurityMode = agsaEncryptSMA;
631 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMB_ENABLED )
633 encryptInfo->encryptionSecurityMode = agsaEncryptSMB;
635 ret = AGSA_RC_FAILURE;
637 else if((ScratchPad3 & SCRATCH_PAD3_V_ENC_MASK ) == SCRATCH_PAD3_V_ENC_ENA_ERR) /* 2 */
640 SA_DBG1(("saEncryptGetMode, SCRATCH_PAD3_V_ENC_ENA_ERR 1 0x%08X 3 0x%08X\n",ScratchPad1,ScratchPad3 ));
641 encryptInfo->status = (ScratchPad3 & SCRATCH_PAD3_V_ERR_CODE ) >> SHIFT16;
642 if( ScratchPad3 & SCRATCH_PAD3_V_XTS_ENABLED)
644 encryptInfo->encryptionCipherMode = agsaEncryptCipherModeXTS;
645 SA_DBG1(("saEncryptGetMode, SCRATCH_PAD3_V_ENC_ENA_ERR 2 0x%08X 3 0x%08X\n",ScratchPad1,ScratchPad3 ));
647 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMF_ENABLED )
649 SA_DBG1(("saEncryptGetMode, SCRATCH_PAD3_V_ENC_ENA_ERR 3 0x%08X 3 0x%08X\n",ScratchPad1,ScratchPad3 ));
650 encryptInfo->encryptionSecurityMode = agsaEncryptSMF;
652 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMA_ENABLED)
654 encryptInfo->encryptionSecurityMode = agsaEncryptSMA;
656 if( (ScratchPad3 & SCRATCH_PAD3_V_SM_MASK ) == SCRATCH_PAD3_V_SMB_ENABLED )
658 encryptInfo->encryptionSecurityMode = agsaEncryptSMB;
661 SA_DBG1(("saEncryptGetMode,encryptInfo status 0x%08X CipherMode 0x%X SecurityMode 0x%X\n" ,
663 encryptInfo->encryptionCipherMode,
664 encryptInfo->encryptionSecurityMode));
666 #ifdef CCFLAGS_SPCV_FPGA_REVB /*The FPGA platform hasn't EEPROM*/
667 ret = AGSA_RC_SUCCESS;
669 ret = AGSA_RC_FAILURE;
673 else if((ScratchPad1 & SCRATCH_PAD1_V_RAAE_MASK) == SCRATCH_PAD1_V_RAAE_ERR)
675 SA_DBG1(("saEncryptGetMode, SCRATCH_PAD1_V_RAAE_ERR 1 0x%08X 3 0x%08X\n",ScratchPad1,ScratchPad3 ));
676 ret = AGSA_RC_FAILURE;
678 else if((ScratchPad1 & SCRATCH_PAD1_V_RAAE_MASK) == 0x0 )
680 SA_DBG1(("saEncryptGetMode, RAAE not ready AGSA_RC_BUSY 1 0x%08X 3 0x%08X\n",ScratchPad1,ScratchPad3 ));
683 if(ScratchPad3 & SCRATCH_PAD3_V_AUT)
685 encryptInfo->flag |= OperatorAuthenticationEnable_AUT;
687 if(ScratchPad3 & SCRATCH_PAD3_V_ARF)
689 encryptInfo->flag |= ReturnToFactoryMode_ARF;
692 SA_DBG2(("saEncryptGetMode, encryptionCipherMode 0x%x encryptionSecurityMode 0x%x flag 0x%x status 0x%x\n",
693 encryptInfo->encryptionCipherMode,
694 encryptInfo->encryptionSecurityMode,
696 encryptInfo->status));
697 SA_DBG2(("saEncryptGetMode, ScratchPad3 0x%x returns 0x%x\n",ScratchPad3, ret));
702 SA_DBG1(("saEncryptGetMode, SPC AGSA_RC_NOT_SUPPORTED\n"));
705 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "29");
710 GLOBAL bit32 saEncryptSetMode (
712 agsaContext_t *agContext,
714 agsaEncryptInfo_t *mode
718 bit32 ret = AGSA_RC_NOT_SUPPORTED;
719 agsaSetControllerConfigCmd_t agControllerConfig;
720 agsaSetControllerConfigCmd_t *pagControllerConfig = &agControllerConfig;
723 if(smIS_SPCV(agRoot))
725 bit32 ScratchPad1 =0;
727 ScratchPad1 = ossaHwRegRead(agRoot,V_Scratchpad_1_Register);
728 if((ScratchPad1 & SCRATCH_PAD1_V_RAAE_MASK) == SCRATCH_PAD1_V_RAAE_MASK)
730 si_memset(pagControllerConfig,0,sizeof(agsaSetControllerConfigCmd_t));
732 SA_DBG2(("saEncryptSetMode, encryptionCipherMode 0x%x encryptionSecurityMode 0x%x status 0x%x\n",
733 mode->encryptionCipherMode,
734 mode->encryptionSecurityMode,
738 smode = mode->encryptionSecurityMode;
740 if( mode->encryptionCipherMode & agsaEncryptCipherModeXTS)
742 smode |= 1 << SHIFT22;
746 pagControllerConfig->pageCode = AGSA_ENCRYPTION_CONTROL_PARM_PAGE | smode;
747 pagControllerConfig->tag =0;
749 SA_DBG2(("saEncryptSetMode,tag 0x%x pageCode 0x%x\n",
750 pagControllerConfig->tag,
751 pagControllerConfig->pageCode
754 SA_DBG2(("saEncryptSetMode, 0x%x 0x%x 0x%x 0x%x\n",
755 pagControllerConfig->configPage[0],
756 pagControllerConfig->configPage[1],
757 pagControllerConfig->configPage[2],
758 pagControllerConfig->configPage[3]
761 SA_DBG2(("saEncryptSetMode, 0x%x 0x%x 0x%x 0x%x\n",
762 pagControllerConfig->configPage[4],
763 pagControllerConfig->configPage[5],
764 pagControllerConfig->configPage[6],
765 pagControllerConfig->configPage[7]
768 SA_DBG2(("saEncryptSetMode, 0x%x 0x%x 0x%x 0x%x\n",
769 pagControllerConfig->configPage[8],
770 pagControllerConfig->configPage[9],
771 pagControllerConfig->configPage[10],
772 pagControllerConfig->configPage[11]
775 ret = mpiSetControllerConfigCmd(agRoot,agContext,pagControllerConfig,queueNum,agTRUE);
777 SA_DBG2(("saEncryptSetMode, pageCode 0x%x tag 0x%x status 0x%x\n",
778 pagControllerConfig->pageCode,
779 pagControllerConfig->tag,
785 SA_DBG2(("saEncryptSetMode,ScratchPad1 not ready %08X\n",ScratchPad1 ));
796 * saEncryptKekUpdate()
798 * Replace a KEK within the controller
803 * @param wrapperKekIndex
804 * @param encryptKekBlob
808 GLOBAL bit32 saEncryptKekUpdate(
810 agsaContext_t *agContext,
814 bit32 wrapperKekIndex,
816 agsaEncryptKekBlob_t *encryptKekBlob
819 agsaKekManagementCmd_t payload;
822 smTraceFuncEnter(hpDBG_VERY_LOUD,"30");
824 SA_DBG2(("saEncryptKekUpdate, flags 0x%x newKekIndex 0x%x wrapperKekIndex 0x%x encryptKekBlob %p\n",flags,newKekIndex,wrapperKekIndex,encryptKekBlob));
825 SA_DBG2(("saEncryptKekUpdate, 0x%02X%02X%02X%02X 0x%02X%02X%02X%02X\n",
826 encryptKekBlob->kekBlob[0],encryptKekBlob->kekBlob[1],
827 encryptKekBlob->kekBlob[2],encryptKekBlob->kekBlob[3],
828 encryptKekBlob->kekBlob[4],encryptKekBlob->kekBlob[5],
829 encryptKekBlob->kekBlob[6],encryptKekBlob->kekBlob[7]));
830 SA_DBG2(("saEncryptKekUpdate, 0x%02X%02X%02X%02X 0x%02X%02X%02X%02X\n",
831 encryptKekBlob->kekBlob[ 8],encryptKekBlob->kekBlob[ 9],
832 encryptKekBlob->kekBlob[10],encryptKekBlob->kekBlob[11],
833 encryptKekBlob->kekBlob[12],encryptKekBlob->kekBlob[13],
834 encryptKekBlob->kekBlob[14],encryptKekBlob->kekBlob[15]));
835 SA_DBG2(("saEncryptKekUpdate, 0x%02X%02X%02X%02X 0x%02X%02X%02X%02X\n",
836 encryptKekBlob->kekBlob[16],encryptKekBlob->kekBlob[17],
837 encryptKekBlob->kekBlob[18],encryptKekBlob->kekBlob[19],
838 encryptKekBlob->kekBlob[20],encryptKekBlob->kekBlob[21],
839 encryptKekBlob->kekBlob[22],encryptKekBlob->kekBlob[23]));
840 SA_DBG2(("saEncryptKekUpdate, 0x%02X%02X%02X%02X 0x%02X%02X%02X%02X\n",
841 encryptKekBlob->kekBlob[24],encryptKekBlob->kekBlob[25],
842 encryptKekBlob->kekBlob[26],encryptKekBlob->kekBlob[27],
843 encryptKekBlob->kekBlob[28],encryptKekBlob->kekBlob[29],
844 encryptKekBlob->kekBlob[30],encryptKekBlob->kekBlob[31]));
845 SA_DBG2(("saEncryptKekUpdate, 0x%02X%02X%02X%02X 0x%02X%02X%02X%02X\n",
846 encryptKekBlob->kekBlob[32],encryptKekBlob->kekBlob[33],
847 encryptKekBlob->kekBlob[34],encryptKekBlob->kekBlob[35],
848 encryptKekBlob->kekBlob[36],encryptKekBlob->kekBlob[37],
849 encryptKekBlob->kekBlob[38],encryptKekBlob->kekBlob[39]));
850 SA_DBG2(("saEncryptKekUpdate, 0x%02X%02X%02X%02X 0x%02X%02X%02X%02X\n",
851 encryptKekBlob->kekBlob[40],encryptKekBlob->kekBlob[41],
852 encryptKekBlob->kekBlob[42],encryptKekBlob->kekBlob[43],
853 encryptKekBlob->kekBlob[44],encryptKekBlob->kekBlob[45],
854 encryptKekBlob->kekBlob[46],encryptKekBlob->kekBlob[47]));
855 /* create payload for IOMB */
856 si_memset(&payload, 0, sizeof(agsaKekManagementCmd_t));
858 OSSA_WRITE_LE_32(agRoot,
860 OSSA_OFFSET_OF(agsaKekManagementCmd_t, NEWKIDX_CURKIDX_KBF_Reserved_SKNV_KSOP),
861 (newKekIndex << SHIFT24) | (wrapperKekIndex << SHIFT16) | blobFormat << SHIFT14 | (flags << SHIFT8) | KEK_MGMT_SUBOP_UPDATE);
862 for (i = 0; i < 12; i++)
865 OSSA_WRITE_LE_32(agRoot,
867 OSSA_OFFSET_OF(agsaKekManagementCmd_t, kekBlob[i ]),
868 (bit32)*(bit32*)&encryptKekBlob->kekBlob[i * sizeof(bit32)] );
872 ret = mpiKekManagementCmd(agRoot, agContext, &payload, queueNum );
874 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "30");
879 #ifdef HIALEAH_ENCRYPTION
881 GLOBAL bit32 saEncryptHilUpdate(
883 agsaContext_t *agContext,
887 agsaKekManagementCmd_t payload;
889 bit32 ScratchPad1 =0;
890 bit32 ScratchPad3 =0;
893 ScratchPad1 = ossaHwRegRead(agRoot,V_Scratchpad_1_Register);
894 ScratchPad3 = ossaHwRegRead(agRoot,V_Scratchpad_3_Register);
897 smTraceFuncEnter(hpDBG_VERY_LOUD,"xxx");
899 SA_DBG2(("saEncryptHilUpdate ScratchPad1 0x08%x ScratchPad3 0x08%x\n",ScratchPad1,ScratchPad3));
900 /* create payload for IOMB */
901 si_memset(&payload, 0, sizeof(agsaKekManagementCmd_t));
903 OSSA_WRITE_LE_32(agRoot,
905 OSSA_OFFSET_OF(agsaKekManagementCmd_t, NEWKIDX_CURKIDX_KBF_Reserved_SKNV_KSOP),
906 (1 << SHIFT24) | (1 << SHIFT16) | (1 << SHIFT8) | KEK_MGMT_SUBOP_KEYCARDUPDATE);
909 ret = mpiKekManagementCmd(agRoot, agContext, &payload, queueNum );
911 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "xxx");
914 #endif /* HIALEAH_ENCRYPTION */
917 * saEncryptKekInvalidate()
919 * Remove a KEK from the controller
924 * @param wrapperKekIndex
925 * @param encryptKekBlob
929 GLOBAL bit32 saEncryptKekInvalidate(
931 agsaContext_t *agContext,
936 agsaKekManagementCmd_t payload;
939 smTraceFuncEnter(hpDBG_VERY_LOUD,"31");
941 SA_DBG2(("saEncryptKekInvalidate, kekIndex 0x%x \n",kekIndex));
944 /* create payload for IOMB */
945 si_memset(&payload, 0, sizeof(agsaDekManagementCmd_t));
947 OSSA_WRITE_LE_32(agRoot,
949 OSSA_OFFSET_OF(agsaKekManagementCmd_t, NEWKIDX_CURKIDX_KBF_Reserved_SKNV_KSOP),
950 kekIndex << SHIFT16 | KEK_MGMT_SUBOP_INVALIDATE);
952 ret = mpiKekManagementCmd(agRoot, agContext, &payload, queueNum );
954 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "31");
959 * saEncryptDekCacheUpdate()
961 * Replace a DEK within the controller cache
965 * @param dekTableSelect
969 * @param dekNumberOfEntries
973 GLOBAL bit32 saEncryptDekCacheUpdate(
975 agsaContext_t *agContext,
978 bit32 dekTableSelect,
982 bit32 dekNumberOfEntries,
984 bit32 dekTableKeyEntrySize
987 agsaDekManagementCmd_t payload;
990 smTraceFuncEnter(hpDBG_VERY_LOUD,"32");
992 SA_DBG2(("saEncryptDekCacheUpdate, kekIndex 0x%x dekTableSelect 0x%x dekAddrHi 0x%x dekAddrLo 0x%x\n",
997 SA_DBG2(("saEncryptDekCacheUpdate, dekIndex 0x%x dekNumberOfEntries 0x%x dekBlobFormat 0x%x dekTableKeyEntrySize 0x%x\n",
1001 dekTableKeyEntrySize));
1003 /* create payload for IOMB */
1004 si_memset(&payload, 0, sizeof(agsaDekManagementCmd_t));
1006 OSSA_WRITE_LE_32(agRoot,
1008 OSSA_OFFSET_OF(agsaDekManagementCmd_t, KEKIDX_Reserved_TBLS_DSOP),
1009 (kekIndex << SHIFT24) | (dekTableSelect << SHIFT8) | DEK_MGMT_SUBOP_UPDATE);
1011 OSSA_WRITE_LE_32(agRoot,
1013 OSSA_OFFSET_OF(agsaDekManagementCmd_t, dekIndex),
1016 OSSA_WRITE_LE_32(agRoot,
1018 OSSA_OFFSET_OF(agsaDekManagementCmd_t, tableAddrLo),
1021 OSSA_WRITE_LE_32(agRoot,
1023 OSSA_OFFSET_OF(agsaDekManagementCmd_t, tableAddrHi),
1026 OSSA_WRITE_LE_32(agRoot,
1028 OSSA_OFFSET_OF(agsaDekManagementCmd_t, tableEntries),
1029 dekNumberOfEntries);
1031 OSSA_WRITE_LE_32(agRoot,
1033 OSSA_OFFSET_OF(agsaDekManagementCmd_t, Reserved_DBF_TBL_SIZE),
1034 dekBlobFormat << SHIFT8 | dekTableKeyEntrySize );
1036 ret = mpiDekManagementCmd(agRoot, agContext, &payload, queueNum);
1038 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "32");
1043 * saEncryptDekCacheInvalidate()
1045 * Remove a DEK from the controller cache
1053 * @param dekNumberOfEntries
1057 GLOBAL bit32 saEncryptDekCacheInvalidate(
1059 agsaContext_t *agContext,
1065 agsaDekManagementCmd_t payload;
1068 smTraceFuncEnter(hpDBG_VERY_LOUD,"33");
1070 SA_DBG2(("saEncryptDekCacheInvalidate,dekTable 0x%x dekIndex 0x%x\n",dekTable,dekIndex));
1072 /* create payload for IOMB */
1073 si_memset(&payload, 0, sizeof(agsaDekManagementCmd_t));
1075 OSSA_WRITE_LE_32(agRoot,
1077 OSSA_OFFSET_OF(agsaDekManagementCmd_t, KEKIDX_Reserved_TBLS_DSOP),
1078 (dekTable << SHIFT8) | DEK_MGMT_SUBOP_INVALIDATE);
1080 OSSA_WRITE_LE_32(agRoot,
1082 OSSA_OFFSET_OF(agsaDekManagementCmd_t, dekIndex),
1085 /* Assume all DEKs are 80 bytes*/
1086 OSSA_WRITE_LE_32(agRoot,
1088 OSSA_OFFSET_OF(agsaDekManagementCmd_t, Reserved_DBF_TBL_SIZE),
1091 ret = mpiDekManagementCmd(agRoot, agContext, &payload, queueNum);
1093 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "33");
1098 * saDIFEncryptionOffloadStart()
1100 * initiate the SPCv controller offload function
1106 * @param agsaDifEncPayload
1111 GLOBAL bit32 saDIFEncryptionOffloadStart(
1113 agsaContext_t *agContext,
1116 agsaDifEncPayload_t *agsaDifEncPayload,
1117 ossaDIFEncryptionOffloadStartCB_t agCB)
1119 bit32 ret = AGSA_RC_FAILURE;
1121 smTraceFuncEnter(hpDBG_VERY_LOUD,"3I");
1122 SA_DBG1(("saDIFEncryptionOffloadStart: start op=%d, agsaDifEncPayload=%p\n", op, agsaDifEncPayload));
1124 if(smIS_SPCV(agRoot))
1126 ret = mpiDIFEncryptionOffloadCmd(agRoot, agContext, queueNum, op, agsaDifEncPayload, agCB);
1130 SA_DBG1(("saDIFEncryptionOffloadStart: spcv only AGSA_RC_FAILURE \n"));
1133 SA_DBG1(("saDIFEncryptionOffloadStart: end status 0x%x\n",ret));
1134 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3I");
1139 * saSetControllerConfig()
1141 * Update a controller mode page
1151 GLOBAL bit32 saSetControllerConfig(
1157 agsaContext_t *agContext
1160 agsaSetControllerConfigCmd_t agControllerConfig;
1164 smTraceFuncEnter(hpDBG_VERY_LOUD,"34");
1167 if(smIS_SPCV(agRoot))
1170 SA_DBG2(("saSetControllerConfig: queueNum %d modePage 0x%x length %d\n",queueNum,modePage,length ));
1172 /* If the page is well known, validate the size of the buffer */
1173 if (((modePage == AGSA_INTERRUPT_CONFIGURATION_PAGE) && (length != sizeof(agsaInterruptConfigPage_t ))) ||
1174 ((modePage == AGSA_ENCRYPTION_DEK_CONFIG_PAGE) && (length != sizeof(agsaEncryptDekConfigPage_t))) ||
1175 ((modePage == AGSA_ENCRYPTION_CONTROL_PARM_PAGE) && (length != sizeof(agsaEncryptControlParamPage_t ))) ||
1176 ((modePage == AGSA_ENCRYPTION_HMAC_CONFIG_PAGE) && (length != sizeof(agsaEncryptHMACConfigPage_t ))) ||
1177 ((modePage == AGSA_SAS_PROTOCOL_TIMER_CONFIG_PAGE) && (length != sizeof(agsaSASProtocolTimerConfigurationPage_t ))) )
1179 SA_DBG1(("saSetControllerConfig: AGSA_RC_FAILURE queueNum %d modePage 0x%x length %d\n",queueNum,modePage,length ));
1180 ret = AGSA_RC_FAILURE;
1182 else if(modePage == AGSA_ENCRYPTION_GENERAL_CONFIG_PAGE)
1184 SA_DBG1(("saSetControllerConfig: Warning!!!!GENERAL_CONFIG_PAGE cannot be set\n"));
1185 ret = AGSA_RC_FAILURE;
1189 /* Copy the raw mode page data into something that can be wrapped in an IOMB. */
1190 si_memset(&agControllerConfig, 0, sizeof(agsaSetControllerConfigCmd_t));
1192 agControllerConfig.tag = 0; /*HTAG */
1194 src = (bit32 *) buffer;
1196 for (i = 0; i < (length / 4); i++)
1198 OSSA_WRITE_LE_32(agRoot,
1199 &agControllerConfig,
1200 OSSA_OFFSET_OF(agsaSetControllerConfigCmd_t, pageCode) + (i * 4),
1205 ret = mpiSetControllerConfigCmd(agRoot, agContext, &agControllerConfig, queueNum,agFALSE);
1208 SA_DBG1(("saSetControllerConfig: AGSA_RC_FAILURE (sending) queueNum %d modePage 0x%x length %d\n",queueNum,modePage,length ));
1215 SA_DBG1(("saSetControllerConfig: spcv only AGSA_RC_FAILURE queueNum %d modePage 0x%x length %d\n",queueNum,modePage,length ));
1216 ret = AGSA_RC_FAILURE;
1218 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "34");
1224 * saGetControllerConfig()
1226 * Retrieve the contents of a controller mode page
1234 GLOBAL bit32 saGetControllerConfig(
1240 agsaContext_t *agContext
1244 agsaGetControllerConfigCmd_t agControllerConfig;
1246 smTraceFuncEnter(hpDBG_VERY_LOUD,"35");
1248 SA_DBG2(("saGetControllerConfig, modePage 0x%x agContext %p flag0 0x%08x flag1 0x%08x\n",modePage,agContext, flag0, flag1 ));
1249 if(smIS_SPCV(agRoot))
1251 si_memset(&agControllerConfig, 0, sizeof(agsaGetControllerConfigCmd_t));
1253 agControllerConfig.pageCode = modePage;
1254 if(modePage == AGSA_INTERRUPT_CONFIGURATION_PAGE)
1256 agControllerConfig.INT_VEC_MSK0 = flag0;
1257 agControllerConfig.INT_VEC_MSK1 = flag1;
1259 ret = mpiGetControllerConfigCmd(agRoot, agContext, &agControllerConfig, queueNum);
1263 SA_DBG1(("saGetControllerConfig: spcv only AGSA_RC_FAILURE queueNum %d modePage 0x%x flag0 0x%08x flag1 0x%08x\n",queueNum,modePage, flag0, flag1 ));
1264 ret = AGSA_RC_FAILURE;
1267 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "35");
1271 GLOBAL bit32 saEncryptSelftestExecute (
1273 agsaContext_t *agContext,
1277 void *TestDescriptor)
1279 bit32 ret = AGSA_RC_SUCCESS;
1281 agsaEncryptBist_t bist;
1282 smTraceFuncEnter(hpDBG_VERY_LOUD,"2e");
1283 si_memset(&bist, 0, (sizeof(agsaEncryptBist_t)));
1285 SA_DBG1(("saEncryptSelftestExecute, enter\n" ));
1286 bist.r_subop = (type & 0xFF);
1288 si_memcpy(&bist.testDiscption,TestDescriptor,length );
1290 /* setup IOMB payload */
1291 ret = mpiEncryptBistCmd( agRoot, queueNum, agContext, &bist );
1293 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2e");
1297 GLOBAL bit32 saOperatorManagement(
1299 agsaContext_t *agContext,
1304 agsaEncryptKekBlob_t *kblob)
1306 bit32 ret = AGSA_RC_SUCCESS;
1307 agsaOperatorMangmentCmd_t opmcmd;
1309 smTraceFuncEnter(hpDBG_VERY_LOUD,"2i");
1311 SA_DBG1(("saOperatorManagement, enter\n" ));
1313 si_memset(&opmcmd, 0, sizeof(agsaOperatorMangmentCmd_t));
1314 /*role = ((flag & SA_OPR_MGMNT_FLAG_MASK) >> SA_OPR_MGMNT_FLAG_SHIFT);*/
1316 flag = (flag & ~SA_OPR_MGMNT_FLAG_MASK);
1318 opmcmd.OPRIDX_AUTIDX_R_KBF_PKT_OMO = flag;
1320 opmcmd.IDString_Role[0] = (bit8)role;
1321 SA_DBG1(("saOperatorManagement, role 0x%X flags 0x%08X\n", role, opmcmd.OPRIDX_AUTIDX_R_KBF_PKT_OMO ));
1323 si_memcpy(&opmcmd.IDString_Role[1], id->ID, AGSA_ID_SIZE);
1324 si_memcpy(&opmcmd.Kblob, kblob, sizeof(agsaEncryptKekBlob_t));
1326 /* setup IOMB payload */
1327 ret = mpiOperatorManagementCmd(agRoot, queueNum, agContext, &opmcmd);
1329 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "2i");
1335 The command is for an operator to login to/logout from SPCve.
1336 Only when all IOs are quiesced, can an operator logout.
1339 Access type (ACS) [4 bits]
1343 KEYopr pinned in the KEK RAM (PIN) [1 bit]
1344 0: not pinned, operator ID table will be searched during authentication.
1345 1: pinned, OPRIDX is referenced to unwrap the certificate.
1346 KEYopr Index in the KEK RAM (OPRIDX) [8 bits]
1347 If KEYopr is pinned in the KEK RAM, OPRIDX is to reference to the KEK for authentication
1350 Operator Certificate (CERT) [40 bytes]
1352 response calls ossaSetOperatorCB
1358 agsaContext_t *agContext,
1364 bit32 ret = AGSA_RC_SUCCESS;
1365 agsaSetOperatorCmd_t SetOperatorCmd;
1367 smTraceFuncEnter(hpDBG_VERY_LOUD,"3c");
1368 SA_DBG1(("saSetOperator, flag 0x%x cert %p\n",flag, cert));
1370 /* initialize set operator IOMB */
1371 si_memset(&SetOperatorCmd, 0, sizeof(agsaSetOperatorCmd_t));
1372 SetOperatorCmd.OPRIDX_PIN_ACS = flag;
1373 si_memcpy((bit8*)SetOperatorCmd.cert, (bit8*)cert, 40);
1375 /* setup IOMB payload */
1376 ret = mpiSetOperatorCmd(agRoot, queueNum, agContext, &SetOperatorCmd);
1378 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3c");
1383 The command is to get role and ID of either current or all operators from SPCve.
1385 0x1: current operator
1390 the host buffer address to store the role and ID of all operators. Valid only when option == 0x2.
1391 Buffer size must be 1KB to store max 32 operators's role and ID.
1392 response calls ossaGetOperatorCB
1397 agsaContext_t *agContext,
1404 bit32 ret = AGSA_RC_SUCCESS;
1405 agsaGetOperatorCmd_t GetOperatorCmd;
1407 smTraceFuncEnter(hpDBG_VERY_LOUD,"3d");
1408 SA_DBG1(("saGetOperator, option 0x%x 0x%08x_%08x\n",option,AddrHi,AddrLo ));
1410 /* initialize get operator IOMB */
1411 si_memset(&GetOperatorCmd, 0, sizeof(agsaGetOperatorCmd_t));
1412 GetOperatorCmd.option = option;
1413 GetOperatorCmd.OprBufAddrLo = AddrLo;
1414 GetOperatorCmd.OprBufAddrHi = AddrHi;
1416 /* setup IOMB payload */
1417 ret = mpiGetOperatorCmd(agRoot, queueNum, agContext, &GetOperatorCmd);
1419 smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3d");