Added support for the WNC M14A2A Cellular LTE Data Module.
Dependencies: WNC14A2AInterface
MCR20Drv.c
00001 /*! 00002 * Copyright (c) 2015, Freescale Semiconductor, Inc. 00003 * All rights reserved. 00004 * 00005 * \file MCR20Drv.c 00006 * 00007 * Redistribution and use in source and binary forms, with or without modification, 00008 * are permitted provided that the following conditions are met: 00009 * 00010 * o Redistributions of source code must retain the above copyright notice, this list 00011 * of conditions and the following disclaimer. 00012 * 00013 * o Redistributions in binary form must reproduce the above copyright notice, this 00014 * list of conditions and the following disclaimer in the documentation and/or 00015 * other materials provided with the distribution. 00016 * 00017 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its 00018 * contributors may be used to endorse or promote products derived from this 00019 * software without specific prior written permission. 00020 * 00021 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 00022 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 00023 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00024 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 00025 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 00026 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 00027 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 00028 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 00029 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 00030 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00031 */ 00032 00033 00034 /***************************************************************************** 00035 * INCLUDED HEADERS * 00036 *---------------------------------------------------------------------------* 00037 * Add to this section all the headers that this module needs to include. * 00038 *---------------------------------------------------------------------------* 00039 *****************************************************************************/ 00040 00041 #include "platform/arm_hal_interrupt.h" 00042 #include "MCR20Drv.h " 00043 #include "MCR20Reg.h" 00044 #include "XcvrSpi.h " 00045 00046 00047 /***************************************************************************** 00048 * PRIVATE VARIABLES * 00049 *---------------------------------------------------------------------------* 00050 * Add to this section all the variables and constants that have local * 00051 * (file) scope. * 00052 * Each of this declarations shall be preceded by the 'static' keyword. * 00053 * These variables / constants cannot be accessed outside this module. * 00054 *---------------------------------------------------------------------------* 00055 *****************************************************************************/ 00056 uint32_t mPhyIrqDisableCnt = 1; 00057 00058 /***************************************************************************** 00059 * PUBLIC VARIABLES * 00060 *---------------------------------------------------------------------------* 00061 * Add to this section all the variables and constants that have global * 00062 * (project) scope. * 00063 * These variables / constants can be accessed outside this module. * 00064 * These variables / constants shall be preceded by the 'extern' keyword in * 00065 * the interface header. * 00066 *---------------------------------------------------------------------------* 00067 *****************************************************************************/ 00068 00069 /***************************************************************************** 00070 * PRIVATE FUNCTIONS PROTOTYPES * 00071 *---------------------------------------------------------------------------* 00072 * Add to this section all the functions prototypes that have local (file) * 00073 * scope. * 00074 * These functions cannot be accessed outside this module. * 00075 * These declarations shall be preceded by the 'static' keyword. * 00076 *---------------------------------------------------------------------------* 00077 *****************************************************************************/ 00078 00079 /***************************************************************************** 00080 * PRIVATE FUNCTIONS * 00081 *---------------------------------------------------------------------------* 00082 * Add to this section all the functions that have local (file) scope. * 00083 * These functions cannot be accessed outside this module. * 00084 * These definitions shall be preceded by the 'static' keyword. * 00085 *---------------------------------------------------------------------------* 00086 *****************************************************************************/ 00087 00088 00089 /***************************************************************************** 00090 * PUBLIC FUNCTIONS * 00091 *---------------------------------------------------------------------------* 00092 * Add to this section all the functions that have global (project) scope. * 00093 * These functions can be accessed outside this module. * 00094 * These functions shall have their declarations (prototypes) within the * 00095 * interface header file and shall be preceded by the 'extern' keyword. * 00096 *---------------------------------------------------------------------------* 00097 *****************************************************************************/ 00098 00099 /*--------------------------------------------------------------------------- 00100 * Name: MCR20Drv_Init 00101 * Description: - 00102 * Parameters: - 00103 * Return: - 00104 *---------------------------------------------------------------------------*/ 00105 void MCR20Drv_Init 00106 ( 00107 void 00108 ) 00109 { 00110 xcvr_spi_init(gXcvrSpiInstance_c); 00111 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 8000000); 00112 00113 gXcvrDeassertCS_d(); 00114 MCR20Drv_RST_B_Deassert(); 00115 RF_IRQ_Init(); 00116 RF_IRQ_Disable(); 00117 mPhyIrqDisableCnt = 1; 00118 } 00119 00120 /*--------------------------------------------------------------------------- 00121 * Name: MCR20Drv_DirectAccessSPIWrite 00122 * Description: - 00123 * Parameters: - 00124 * Return: - 00125 *---------------------------------------------------------------------------*/ 00126 void MCR20Drv_DirectAccessSPIWrite 00127 ( 00128 uint8_t address, 00129 uint8_t value 00130 ) 00131 { 00132 uint16_t txData; 00133 00134 ProtectFromMCR20Interrupt(); 00135 00136 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 16000000); 00137 00138 gXcvrAssertCS_d(); 00139 00140 txData = (address & TransceiverSPI_DirectRegisterAddressMask); 00141 txData |= value << 8; 00142 00143 xcvr_spi_transfer(gXcvrSpiInstance_c, (uint8_t *)&txData, 0, sizeof(txData)); 00144 00145 gXcvrDeassertCS_d(); 00146 UnprotectFromMCR20Interrupt(); 00147 } 00148 00149 /*--------------------------------------------------------------------------- 00150 * Name: MCR20Drv_DirectAccessSPIMultiByteWrite 00151 * Description: - 00152 * Parameters: - 00153 * Return: - 00154 *---------------------------------------------------------------------------*/ 00155 void MCR20Drv_DirectAccessSPIMultiByteWrite 00156 ( 00157 uint8_t startAddress, 00158 uint8_t * byteArray, 00159 uint8_t numOfBytes 00160 ) 00161 { 00162 uint8_t txData; 00163 00164 if( (numOfBytes == 0) || (byteArray == 0) ) 00165 { 00166 return; 00167 } 00168 00169 ProtectFromMCR20Interrupt(); 00170 00171 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 16000000); 00172 00173 gXcvrAssertCS_d(); 00174 00175 txData = (startAddress & TransceiverSPI_DirectRegisterAddressMask); 00176 00177 xcvr_spi_transfer(gXcvrSpiInstance_c, &txData, 0, sizeof(txData)); 00178 xcvr_spi_transfer(gXcvrSpiInstance_c, byteArray, 0, numOfBytes); 00179 00180 gXcvrDeassertCS_d(); 00181 UnprotectFromMCR20Interrupt(); 00182 } 00183 00184 /*--------------------------------------------------------------------------- 00185 * Name: MCR20Drv_PB_SPIByteWrite 00186 * Description: - 00187 * Parameters: - 00188 * Return: - 00189 *---------------------------------------------------------------------------*/ 00190 void MCR20Drv_PB_SPIByteWrite 00191 ( 00192 uint8_t address, 00193 uint8_t value 00194 ) 00195 { 00196 uint32_t txData; 00197 00198 ProtectFromMCR20Interrupt(); 00199 00200 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 16000000); 00201 00202 gXcvrAssertCS_d(); 00203 00204 txData = TransceiverSPI_WriteSelect | 00205 TransceiverSPI_PacketBuffAccessSelect | 00206 TransceiverSPI_PacketBuffByteModeSelect; 00207 txData |= (address) << 8; 00208 txData |= (value) << 16; 00209 00210 xcvr_spi_transfer(gXcvrSpiInstance_c, (uint8_t*)&txData, 0, 3); 00211 00212 gXcvrDeassertCS_d(); 00213 UnprotectFromMCR20Interrupt(); 00214 } 00215 00216 /*--------------------------------------------------------------------------- 00217 * Name: MCR20Drv_PB_SPIBurstWrite 00218 * Description: - 00219 * Parameters: - 00220 * Return: - 00221 *---------------------------------------------------------------------------*/ 00222 void MCR20Drv_PB_SPIBurstWrite 00223 ( 00224 uint8_t * byteArray, 00225 uint8_t numOfBytes 00226 ) 00227 { 00228 uint8_t txData; 00229 00230 if( (numOfBytes == 0) || (byteArray == 0) ) 00231 { 00232 return; 00233 } 00234 00235 ProtectFromMCR20Interrupt(); 00236 00237 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 16000000); 00238 00239 gXcvrAssertCS_d(); 00240 00241 txData = TransceiverSPI_WriteSelect | 00242 TransceiverSPI_PacketBuffAccessSelect | 00243 TransceiverSPI_PacketBuffBurstModeSelect; 00244 00245 xcvr_spi_transfer(gXcvrSpiInstance_c, &txData, 0, 1); 00246 xcvr_spi_transfer(gXcvrSpiInstance_c, byteArray, 0, numOfBytes); 00247 00248 gXcvrDeassertCS_d(); 00249 UnprotectFromMCR20Interrupt(); 00250 } 00251 00252 /*--------------------------------------------------------------------------- 00253 * Name: MCR20Drv_DirectAccessSPIRead 00254 * Description: - 00255 * Parameters: - 00256 * Return: - 00257 *---------------------------------------------------------------------------*/ 00258 00259 uint8_t MCR20Drv_DirectAccessSPIRead 00260 ( 00261 uint8_t address 00262 ) 00263 { 00264 uint8_t txData; 00265 uint8_t rxData; 00266 00267 ProtectFromMCR20Interrupt(); 00268 00269 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 8000000); 00270 00271 gXcvrAssertCS_d(); 00272 00273 txData = (address & TransceiverSPI_DirectRegisterAddressMask) | 00274 TransceiverSPI_ReadSelect; 00275 00276 xcvr_spi_transfer(gXcvrSpiInstance_c, &txData, 0, sizeof(txData)); 00277 xcvr_spi_transfer(gXcvrSpiInstance_c, 0, &rxData, sizeof(rxData)); 00278 00279 gXcvrDeassertCS_d(); 00280 UnprotectFromMCR20Interrupt(); 00281 00282 return rxData; 00283 00284 } 00285 00286 /*--------------------------------------------------------------------------- 00287 * Name: MCR20Drv_DirectAccessSPIMultyByteRead 00288 * Description: - 00289 * Parameters: - 00290 * Return: - 00291 *---------------------------------------------------------------------------*/ 00292 uint8_t MCR20Drv_DirectAccessSPIMultiByteRead 00293 ( 00294 uint8_t startAddress, 00295 uint8_t * byteArray, 00296 uint8_t numOfBytes 00297 ) 00298 { 00299 uint8_t txData; 00300 uint8_t phyIRQSTS1; 00301 00302 if( (numOfBytes == 0) || (byteArray == 0) ) 00303 { 00304 return 0; 00305 } 00306 00307 ProtectFromMCR20Interrupt(); 00308 00309 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 8000000); 00310 00311 gXcvrAssertCS_d(); 00312 00313 txData = (startAddress & TransceiverSPI_DirectRegisterAddressMask) | 00314 TransceiverSPI_ReadSelect; 00315 00316 xcvr_spi_transfer(gXcvrSpiInstance_c, &txData, &phyIRQSTS1, sizeof(txData)); 00317 xcvr_spi_transfer(gXcvrSpiInstance_c, 0, byteArray, numOfBytes); 00318 00319 gXcvrDeassertCS_d(); 00320 UnprotectFromMCR20Interrupt(); 00321 00322 return phyIRQSTS1; 00323 } 00324 00325 /*--------------------------------------------------------------------------- 00326 * Name: MCR20Drv_PB_SPIBurstRead 00327 * Description: - 00328 * Parameters: - 00329 * Return: - 00330 *---------------------------------------------------------------------------*/ 00331 uint8_t MCR20Drv_PB_SPIBurstRead 00332 ( 00333 uint8_t * byteArray, 00334 uint8_t numOfBytes 00335 ) 00336 { 00337 uint8_t txData; 00338 uint8_t phyIRQSTS1; 00339 00340 if( (numOfBytes == 0) || (byteArray == 0) ) 00341 { 00342 return 0; 00343 } 00344 00345 ProtectFromMCR20Interrupt(); 00346 00347 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 8000000); 00348 00349 gXcvrAssertCS_d(); 00350 00351 txData = TransceiverSPI_ReadSelect | 00352 TransceiverSPI_PacketBuffAccessSelect | 00353 TransceiverSPI_PacketBuffBurstModeSelect; 00354 00355 xcvr_spi_transfer(gXcvrSpiInstance_c, &txData, &phyIRQSTS1, sizeof(txData)); 00356 xcvr_spi_transfer(gXcvrSpiInstance_c, 0, byteArray, numOfBytes); 00357 00358 gXcvrDeassertCS_d(); 00359 UnprotectFromMCR20Interrupt(); 00360 00361 return phyIRQSTS1; 00362 } 00363 00364 /*--------------------------------------------------------------------------- 00365 * Name: MCR20Drv_IndirectAccessSPIWrite 00366 * Description: - 00367 * Parameters: - 00368 * Return: - 00369 *---------------------------------------------------------------------------*/ 00370 void MCR20Drv_IndirectAccessSPIWrite 00371 ( 00372 uint8_t address, 00373 uint8_t value 00374 ) 00375 { 00376 uint32_t txData; 00377 00378 ProtectFromMCR20Interrupt(); 00379 00380 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 16000000); 00381 00382 gXcvrAssertCS_d(); 00383 00384 txData = TransceiverSPI_IARIndexReg; 00385 txData |= (address) << 8; 00386 txData |= (value) << 16; 00387 00388 xcvr_spi_transfer(gXcvrSpiInstance_c, (uint8_t*)&txData, 0, 3); 00389 00390 gXcvrDeassertCS_d(); 00391 UnprotectFromMCR20Interrupt(); 00392 } 00393 00394 /*--------------------------------------------------------------------------- 00395 * Name: MCR20Drv_IndirectAccessSPIMultiByteWrite 00396 * Description: - 00397 * Parameters: - 00398 * Return: - 00399 *---------------------------------------------------------------------------*/ 00400 void MCR20Drv_IndirectAccessSPIMultiByteWrite 00401 ( 00402 uint8_t startAddress, 00403 uint8_t * byteArray, 00404 uint8_t numOfBytes 00405 ) 00406 { 00407 uint16_t txData; 00408 00409 if( (numOfBytes == 0) || (byteArray == 0) ) 00410 { 00411 return; 00412 } 00413 00414 ProtectFromMCR20Interrupt(); 00415 00416 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 16000000); 00417 00418 gXcvrAssertCS_d(); 00419 00420 txData = TransceiverSPI_IARIndexReg; 00421 txData |= (startAddress) << 8; 00422 00423 xcvr_spi_transfer(gXcvrSpiInstance_c, (uint8_t*)&txData, 0, sizeof(txData)); 00424 xcvr_spi_transfer(gXcvrSpiInstance_c, (uint8_t*)byteArray, 0, numOfBytes); 00425 00426 gXcvrDeassertCS_d(); 00427 UnprotectFromMCR20Interrupt(); 00428 } 00429 00430 /*--------------------------------------------------------------------------- 00431 * Name: MCR20Drv_IndirectAccessSPIRead 00432 * Description: - 00433 * Parameters: - 00434 * Return: - 00435 *---------------------------------------------------------------------------*/ 00436 uint8_t MCR20Drv_IndirectAccessSPIRead 00437 ( 00438 uint8_t address 00439 ) 00440 { 00441 uint16_t txData; 00442 uint8_t rxData; 00443 00444 ProtectFromMCR20Interrupt(); 00445 00446 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 8000000); 00447 00448 gXcvrAssertCS_d(); 00449 00450 txData = TransceiverSPI_IARIndexReg | TransceiverSPI_ReadSelect; 00451 txData |= (address) << 8; 00452 00453 xcvr_spi_transfer(gXcvrSpiInstance_c, (uint8_t*)&txData, 0, sizeof(txData)); 00454 xcvr_spi_transfer(gXcvrSpiInstance_c, 0, &rxData, sizeof(rxData)); 00455 00456 gXcvrDeassertCS_d(); 00457 UnprotectFromMCR20Interrupt(); 00458 00459 return rxData; 00460 } 00461 00462 /*--------------------------------------------------------------------------- 00463 * Name: MCR20Drv_IndirectAccessSPIMultiByteRead 00464 * Description: - 00465 * Parameters: - 00466 * Return: - 00467 *---------------------------------------------------------------------------*/ 00468 void MCR20Drv_IndirectAccessSPIMultiByteRead 00469 ( 00470 uint8_t startAddress, 00471 uint8_t * byteArray, 00472 uint8_t numOfBytes 00473 ) 00474 { 00475 uint16_t txData; 00476 00477 if( (numOfBytes == 0) || (byteArray == 0) ) 00478 { 00479 return; 00480 } 00481 00482 ProtectFromMCR20Interrupt(); 00483 00484 xcvr_spi_configure_speed(gXcvrSpiInstance_c, 8000000); 00485 00486 gXcvrAssertCS_d(); 00487 00488 txData = (TransceiverSPI_IARIndexReg | TransceiverSPI_ReadSelect); 00489 txData |= (startAddress) << 8; 00490 00491 xcvr_spi_transfer(gXcvrSpiInstance_c, (uint8_t*)&txData, 0, sizeof(txData)); 00492 xcvr_spi_transfer(gXcvrSpiInstance_c, 0, byteArray, numOfBytes); 00493 00494 gXcvrDeassertCS_d(); 00495 UnprotectFromMCR20Interrupt(); 00496 } 00497 00498 /*--------------------------------------------------------------------------- 00499 * Name: MCR20Drv_IsIrqPending 00500 * Description: - 00501 * Parameters: - 00502 * Return: - 00503 *---------------------------------------------------------------------------*/ 00504 uint32_t MCR20Drv_IsIrqPending 00505 ( 00506 void 00507 ) 00508 { 00509 return RF_isIRQ_Pending(); 00510 } 00511 00512 /*--------------------------------------------------------------------------- 00513 * Name: MCR20Drv_IRQ_Disable 00514 * Description: - 00515 * Parameters: - 00516 * Return: - 00517 *---------------------------------------------------------------------------*/ 00518 void MCR20Drv_IRQ_Disable 00519 ( 00520 void 00521 ) 00522 { 00523 platform_enter_critical(); 00524 00525 if( mPhyIrqDisableCnt == 0 ) 00526 { 00527 RF_IRQ_Disable(); 00528 } 00529 00530 mPhyIrqDisableCnt++; 00531 00532 platform_exit_critical(); 00533 } 00534 00535 /*--------------------------------------------------------------------------- 00536 * Name: MCR20Drv_IRQ_Enable 00537 * Description: - 00538 * Parameters: - 00539 * Return: - 00540 *---------------------------------------------------------------------------*/ 00541 void MCR20Drv_IRQ_Enable 00542 ( 00543 void 00544 ) 00545 { 00546 platform_enter_critical(); 00547 00548 if( mPhyIrqDisableCnt ) 00549 { 00550 mPhyIrqDisableCnt--; 00551 00552 if( mPhyIrqDisableCnt == 0 ) 00553 { 00554 RF_IRQ_Enable(); 00555 } 00556 } 00557 00558 platform_exit_critical(); 00559 } 00560 00561 /*--------------------------------------------------------------------------- 00562 * Name: MCR20Drv_RST_Assert 00563 * Description: - 00564 * Parameters: - 00565 * Return: - 00566 *---------------------------------------------------------------------------*/ 00567 void MCR20Drv_RST_B_Assert 00568 ( 00569 void 00570 ) 00571 { 00572 RF_RST_Set(0); 00573 } 00574 00575 /*--------------------------------------------------------------------------- 00576 * Name: MCR20Drv_RST_Deassert 00577 * Description: - 00578 * Parameters: - 00579 * Return: - 00580 *---------------------------------------------------------------------------*/ 00581 void MCR20Drv_RST_B_Deassert 00582 ( 00583 void 00584 ) 00585 { 00586 RF_RST_Set(1); 00587 } 00588 00589 /*--------------------------------------------------------------------------- 00590 * Name: MCR20Drv_SoftRST_Assert 00591 * Description: - 00592 * Parameters: - 00593 * Return: - 00594 *---------------------------------------------------------------------------*/ 00595 void MCR20Drv_SoftRST_Assert 00596 ( 00597 void 00598 ) 00599 { 00600 MCR20Drv_IndirectAccessSPIWrite(SOFT_RESET, (0x80)); 00601 } 00602 00603 /*--------------------------------------------------------------------------- 00604 * Name: MCR20Drv_SoftRST_Deassert 00605 * Description: - 00606 * Parameters: - 00607 * Return: - 00608 *---------------------------------------------------------------------------*/ 00609 void MCR20Drv_SoftRST_Deassert 00610 ( 00611 void 00612 ) 00613 { 00614 MCR20Drv_IndirectAccessSPIWrite(SOFT_RESET, (0x00)); 00615 } 00616 00617 /*--------------------------------------------------------------------------- 00618 * Name: MCR20Drv_Soft_RESET 00619 * Description: - 00620 * Parameters: - 00621 * Return: - 00622 *---------------------------------------------------------------------------*/ 00623 void MCR20Drv_Soft_RESET 00624 ( 00625 void 00626 ) 00627 { 00628 //assert SOG_RST 00629 MCR20Drv_IndirectAccessSPIWrite(SOFT_RESET, (0x80)); 00630 00631 //deassert SOG_RST 00632 MCR20Drv_IndirectAccessSPIWrite(SOFT_RESET, (0x00)); 00633 } 00634 00635 /*--------------------------------------------------------------------------- 00636 * Name: MCR20Drv_RESET 00637 * Description: - 00638 * Parameters: - 00639 * Return: - 00640 *---------------------------------------------------------------------------*/ 00641 void MCR20Drv_RESET 00642 ( 00643 void 00644 ) 00645 { 00646 volatile uint32_t delay = 1000; 00647 //assert RST_B 00648 MCR20Drv_RST_B_Assert(); 00649 00650 while(delay--); 00651 00652 //deassert RST_B 00653 MCR20Drv_RST_B_Deassert(); 00654 } 00655 00656 /*--------------------------------------------------------------------------- 00657 * Name: MCR20Drv_Set_CLK_OUT_Freq 00658 * Description: - 00659 * Parameters: - 00660 * Return: - 00661 *---------------------------------------------------------------------------*/ 00662 void MCR20Drv_Set_CLK_OUT_Freq 00663 ( 00664 uint8_t freqDiv 00665 ) 00666 { 00667 uint8_t clkOutCtrlReg = (freqDiv & cCLK_OUT_DIV_Mask) | cCLK_OUT_EN | cCLK_OUT_EXTEND; 00668 00669 if(freqDiv == gCLK_OUT_FREQ_DISABLE) 00670 { 00671 clkOutCtrlReg = (cCLK_OUT_EXTEND | gCLK_OUT_FREQ_4_MHz); //reset value with clock out disabled 00672 } 00673 00674 MCR20Drv_DirectAccessSPIWrite((uint8_t) CLK_OUT_CTRL, clkOutCtrlReg); 00675 }
Generated on Tue Jul 12 2022 19:09:03 by 1.7.2