[processor-sdk/performance-audio-sr.git] / psdk_cust / pdk_k2g_1_0_1_0_eng / packages / ti / platform / evmk2g / platform_lib / src / evmc66x_audio_dc_adc.c
1 /*
2 * Copyright (c) 2015, Texas Instruments Incorporated
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * * 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 * * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
34 /**
35 * \file evmc66x_audio_dc_adc.c
36 *
37 * \brief Implementation of low level functions for PCM186x ADC.
38 *
39 * This file contains low level library implementation for PCM186x ADC.
40 * This library is designed to work together with a high-level API layer
41 * which takes care of application interfacing. Input argument selection
42 * is done for ease of programming. Input argument boundary check and
43 * verification is expected to be done at the upper layers.
44 *
45 */
47 /******************************************************************************
48 ** INCLUDE FILE
49 ******************************************************************************/
50 #include "platform_internal.h"
53 /******************************************************************************
54 ** GLOBAL DEFINITIONS
55 ******************************************************************************/
57 #if (PLATFORM_AUDIO_ADC)
59 /**
60 * \brief Array with the default values of ADC registers.
61 *
62 * {"Reg addr", "Value"}
63 *
64 * Array to to be used when we call pcm186xADCInit from app layer.
65 *
66 * Note: Default values shall be finalized while implementing audio demo
67 *
68 **/
69 static const AdcRegDefConfig Pcm186xReg[] = {
70 {0x00, 0x00}, /** ================ Changing to Page 0 ================ */
71 {0x01, 0x00}, /** PGA CH1_L to 0dB */
72 {0x02, 0x00}, /** PGA CH1_R to 0dB */
73 {0x03, 0x00}, /** PGA CH2_L to 0dB */
74 {0x04, 0x00}, /** PGA CH2_R to 0dB */
75 {0x05, 0x86}, /** SMOOTH : Smooth change,LINK : Independent control
76 DPGA_CLIP_EN : Disable,MAX_ATT : -3dB,START_ATT : 10,
77 AGC_EN : Disable */
78 {0x06, 0x41}, /** Polarity : Normal, Channel : VINL1[SE] */
79 {0x07, 0x41}, /** Polarity : Normal, Channel : VINR1[SE] */
80 {0x08, 0x42}, /** Polarity : Normal, Channel : VINL2[SE] */
81 {0x09, 0x42}, /** Polarity : Normal, Channel : VINR2[SE] */
82 {0x0A, 0x00}, /** Secondary ADC Input : No Selection */
83 {0x0B, 0x44}, /** RX WLEN : 24bit, TDM_LRCK_MODE : Duty cycle of LRCK is
84 50%, TX WLEN : 24 bit, FMT : I2S format */
85 {0x10, 0x05}, /** GPIO0_FUNC - DOUT2, GPIO0_POL - Normal
86 GPIO1_FUNC - GPIO1, GPIO1_POL - Normal */
87 {0x20, 0x40}, /** SCK_XI_SEL : SCK or XTAL,MST_SCK_SRC : SCK or XI,
88 MST_MODE : Slave,ADC_CLK_SRC : SCK,DSP2_CLK_SRC : SCK,
89 DSP1_CLK_SRC : SCK,CLKDET_EN : Enable */
91 {0x60, 0x00}, /** POSTPGA : Disable,CLKERR : Disable,DC_CHANG : Disable,
92 DIN_TOGGLE : Disable,ENGSTR : Disable */
93 {0x71, 0x10}, /** 2CH : 4 Channels,FLT : Normal,HPF_EN : Enable,
94 Unmute all the Channles */
95 {0x00, 0x03}, /** ================ Changing to Page 3 =============== */
96 {0x12, 0x00}, /** Oscillator : Power up */
97 {0x15, 0x01}, /** Resistor bypass : Disable, Mic Bias: Power up */
98 {0x00, 0xFD}, /** ============== Changing to Page 255 =============== */
99 {0x14, 0x00}, /** PGA_ICI : 100%, REF_ICI : 100% */
100 {0x00, 0x00} /** ================ Changing to Page 0 =============== */
101 };
104 /******************************************************************************
105 ** FUNCTION DEFINITIONS
106 ******************************************************************************/
108 /**
109 * \brief Reads ADC register.
110 *
111 * \param addr [IN] ADC HW instance I2C slave address.
112 * \param reg [IN] Register to be written.
113 * \param data [IN] Data to be written
114 *
115 * \return 0 for success.
116 *
117 **/
118 static ADC_RET pcm186x_read_reg(Uint8 addr, Uint8 reg, Uint8 *data)
119 {
120 ADC_RET ret;
122 DBG_PCM186x (platform_write("\nEnter pcm186x_read_reg\n"));
124 ret = i2cRead(PCM186x_I2C_PORT_NUM, addr, data, reg, 1, 1);
125 if(ret)
126 {
127 IFPRINT (platform_write("pcm186x_read_reg() : i2cRead error : ret = %d\n", ret));
128 }
129 else
130 {
131 DBG_PCM186x (platform_write("pcm186x_read_reg() : ADC Read Successful: Reg Addr = 0x%x; Reg Value = 0x%x\n", reg, *data));
132 }
134 DBG_PCM186x (platform_write("Exit pcm186x_read_reg\n"));
136 return (ret);
137 }
139 /**
140 * \brief Writes into ADC register.
141 *
142 * Note: Disable ENABLE_ADC_REG_ECHO to stop register echo by write function
143 *
144 * \param addr [IN] ADC HW instance I2C slave address.
145 * \param reg [IN] Register to be written.
146 * \param data [IN] Data to be written
147 *
148 * \return 0 for success.
149 *
150 **/
151 static ADC_RET pcm186x_write_reg(Uint8 addr, Uint8 reg, Uint8 data)
152 {
153 Uint8 slaveData[2];
154 ADC_RET ret;
155 Uint8 value;
157 slaveData[0] = reg;
158 slaveData[1] = data;
160 DBG_PCM186x (platform_write("\nEnter pcm186x_write_reg\n"));
162 DBG_PCM186x (platform_write("\n Write Request : addr = 0x%x reg = 0x%x"
163 " data = 0x%x page = %d\n", addr, reg, data,
164 pcm186xPageCheck(addr)));
166 ret = i2cWrite(PCM186x_I2C_PORT_NUM, addr, slaveData, 2, I2C_RELEASE_BUS);
167 if(ret)
168 {
169 IFPRINT (platform_write("\npcm186x_write_reg(): i2cWrite error : ret = %d\n", ret));
170 }
172 #ifdef ENABLE_ADC_REG_ECHO
173 ret = pcm186x_read_reg(addr, reg, &value);
174 if(ret)
175 {
176 IFPRINT (platform_write("pcm186x_write_reg(): ADC Read for Reg Echo Failed\n"));
177 }
178 #endif
180 DBG_PCM186x (platform_write("Exit pcm186x_write_reg\n"));
182 return (ret);
183 }
185 /**
186 * \brief Sets all ADC registers to the default value.
187 *
188 * \param addr [IN] ADC HW instance I2C slave address.
189 *
190 * \return 0 if success.
191 *
192 **/
193 ADC_RET pcm186xAdcInit(Uint8 addr)
194 {
195 ADC_RET ret = -1;
196 Uint8 count;
198 DBG_PCM186x (platform_write("\nEnter pcm186xAdcInit\n"));
200 DBG_PCM186x (platform_write("pcm186xAdcInit() : addr = 0x%x page = %d\n",
201 addr, pcm186xPageCheck(addr)));
203 for (count = 0; count < ARRAY_SIZE(Pcm186xReg); count++)
204 {
205 ret = pcm186x_write_reg(addr, Pcm186xReg[count].reg, Pcm186xReg[count].def);
206 if(ret)
207 {
208 IFPRINT (platform_write("pcm186xAdcInit() : Error in Writing Register = 0x%x\n",
209 Pcm186xReg[count].reg));
210 return (ret);
211 }
212 }
214 DBG_PCM186x (platform_write("pcm186xAdcInit() : In Page %d\n.", pcm186xPageCheck(addr)));
216 DBG_PCM186x (platform_write("Exit pcm186xAdcInit\n"));
218 return (ret);
219 }
221 /**
222 * \brief Reads the Current Page no.
223 *
224 * \param addr [IN] ADC HW instance I2C slave address.
225 *
226 * \return Page no if success.
227 *
228 **/
229 Int8 pcm186xPageCheck(Uint8 addr)
230 {
231 Int8 ret;
232 Uint8 read = 0;
234 DBG_PCM186x (platform_write("Enter pcm186xPageCheck\n"));
236 ret = pcm186x_read_reg(addr, 0x0, &read);
237 if(ret)
238 {
239 IFPRINT (platform_write("Error in reading Register 0 "
240 "ret = %d\n", ret));
241 return (ret);
242 }
244 DBG_PCM186x (platform_write("Exit pcm186xPageCheck\n"));
246 return (read);
247 }
249 /**
250 * \brief Register dump of Page 0, 1 and 253.
251 *
252 * \param addr [IN] ADC HW instance I2C slave address.
253 *
254 * \return 0 if success.
255 *
256 **/
257 ADC_RET pcm186xRegDump(Uint8 addr)
258 {
259 ADC_RET ret;
260 Uint8 count;
261 Uint8 read = 0;
263 DBG_PCM186x (platform_write("pcm186xRegDump() : addr = 0x%x\n", addr));
265 /* Page 0 Dump */
266 ret = pcm186x_write_reg(addr, 0x0, 0x00);
267 if(ret)
268 {
269 IFPRINT (platform_write("pcm186xRegDump() : ADC Page Switch Failed\n"));
270 return (ret);
271 }
273 /* Some of the register addresses in page 0 are not defined.
274 Not sure whether they can be accessed or not.
275 Need to change this in case of issues */
276 for (count = 1; count <= 120; count++)
277 {
278 ret = pcm186x_read_reg(addr, count, &read);
279 if(ret)
280 {
281 IFPRINT (platform_write("pcm186xRegDump() : Error in Reading Register = 0x%x\n",
282 count));
283 return (ret);
284 }
286 DBG_PCM186x (platform_write("Page %d : Register 0x%x = 0x%x\n",
287 pcm186xPageCheck(addr), count, read));
288 read = 0;
289 }
291 /* Page 1 Dump */
292 ret = pcm186x_write_reg(addr, 0x0, 0x01);
293 if(ret)
294 {
295 IFPRINT (platform_write("pcm186xRegDump() : ADC Page Switch Failed\n"));
296 return (ret);
297 }
299 for (count = 1; count <= 11; count++)
300 {
301 ret = pcm186x_read_reg(addr, count, &read);
302 if(ret)
303 {
304 IFPRINT (platform_write("pcm186xRegDump() : Error in Reading Register = 0x%x\n",
305 count));
306 return (ret);
307 }
309 DBG_PCM186x (platform_write("Page %d : Register 0x%x = 0x%x\n",
310 pcm186xPageCheck(addr), count, read));
311 read = 0;
312 }
314 /* Page 3 Dump */
315 ret = pcm186x_write_reg(addr, 0x0, 0x03);
316 if(ret)
317 {
318 IFPRINT (platform_write("pcm186xRegDump() : ADC Page Switch Failed\n"));
319 return (ret);
320 }
322 ret = pcm186x_read_reg(addr, 0x12, &read);
323 if(ret)
324 {
325 IFPRINT (platform_write("pcm186xRegDump() : Error in Reading Register = 0x%x\n",
326 0x12));
327 return (ret);
328 }
330 DBG_PCM186x (platform_write("Page %d : Register 0x12 = 0x%x\n",
331 pcm186xPageCheck(addr), read));
332 read = 0;
333 ret = pcm186x_read_reg(addr, 0x15, &read);
334 if(ret)
335 {
336 IFPRINT (platform_write("pcm186xRegDump() : Error in Reading Register = 0x%x\n",
337 0x15));
338 return (ret);
339 }
341 DBG_PCM186x (platform_write("Page %d : Register 0x15 = 0x%x\n",
342 pcm186xPageCheck(addr), read));
343 read = 0;
345 /* Page 253 Dump */
346 ret = pcm186x_write_reg(addr, 0x0, 0xFD);
347 if(ret)
348 {
349 IFPRINT (platform_write("pcm186xRegDump() : ADC Page Switch Failed\n"));
350 return (ret);
351 }
353 ret = pcm186x_read_reg(addr, 0x14, &read);
354 if(ret)
355 {
356 IFPRINT (platform_write("pcm186xRegDump() : Error in Reading Register = 0x%x\n",
357 0x14));
358 return (ret);
359 }
361 DBG_PCM186x (platform_write("Page %d : Register 0x14 = 0x%x\n",
362 pcm186xPageCheck(addr), read));
364 /* Change back to Page 0 */
365 ret = pcm186x_write_reg(addr, 0x0, 0x00);
367 return (ret);
368 }
370 /**
371 * \brief Enable/Disable Mic Bias Control for analog MIC input.
372 *
373 * \param addr [IN] ADC HW instance I2C slave address.
374 *
375 * \param power [IN] Mic bias control
376 * 1 - Power up mic bias
377 * 0 - Power down mic bias
378 *
379 * \return 0 if success.
380 *
381 */
382 ADC_RET pcm186xMicBiasCtrl(Uint8 addr, Uint8 power)
383 {
384 Uint8 read = 0;
385 ADC_RET ret;
387 /* Changing to Page 3 */
388 ret = pcm186x_write_reg(addr, 0x0, 0x03);
389 if(ret)
390 {
391 IFPRINT (platform_write("pcm186xMicBiasCtrl() : ADC Page Switch Failed\n"));
392 return (ret);
393 }
395 DBG_PCM186x (platform_write("pcm186xMicBiasCtrl() : addr = 0x%x"
396 " power = %d page = %d\n", addr, power,
397 pcm186xPageCheck(addr)));
399 ret = pcm186x_read_reg(addr, PCM186x_MIC_BIAS_CTRL, &read);
400 if(ret)
401 {
402 IFPRINT (platform_write("pcm186xMicBiasCtrl() : Error in Reading Register = 0x%x\n",
403 PCM186x_MIC_BIAS_CTRL));
404 return (ret);
405 }
407 ret = pcm186x_write_reg(addr, PCM186x_MIC_BIAS_CTRL, ((read & 0xFE) | power));
408 if(ret)
409 {
410 IFPRINT (platform_write("pcm186xMicBiasCtrl() : Error in Writing Register = 0x%x\n",
411 PCM186x_MIC_BIAS_CTRL));
412 return (ret);
413 }
415 /* Changing to Page 0 */
416 ret = pcm186x_write_reg(addr, 0x0, 0x00);
417 if(ret)
418 {
419 IFPRINT (platform_write("pcm186xMicBiasCtrl() : ADC Page Switch Failed\n"));
420 return (ret);
421 }
423 DBG_PCM186x (platform_write("pcm186xMicBiasCtrl() : In page %d.\n",
424 pcm186xPageCheck(addr)));
426 return (ret);
427 }
429 /**
430 * \brief Resets PCM1865 ADC. .
431 *
432 * \return 0 if success.
433 *
434 **/
435 ADC_RET pcm186xReset(Uint8 addr)
436 {
437 ADC_RET ret;
439 DBG_PCM186x (platform_write("pcm186xReset() : addr = 0x%x page = %d\n",
440 addr, pcm186xPageCheck(addr)));
442 ret = pcm186x_write_reg(addr, PCM186x_ADC_RESET, 0xFF);
444 return (ret);
445 }
447 /**
448 * \brief Configures the data format and slot width
449 *
450 * \param addr [IN] ADC HW instance I2C slave address.
451 *
452 * \param dataType [IN] Data type for the codec operation
453 * ADC_DATA_FORMAT_I2S - for I2S mode
454 * ADC_DATA_FORMAT_LEFTJ - for left aligned data
455 * ADC_DATA_FORMAT_RIGHTJ - for right aligned data
456 * ADC_DATA_FORMAT_TDM_DSP - for TDM/DSP data.
457 *
458 * \param slotWidth [IN] Slot width in bits
459 * ADC_RX_WLEN_24BIT - 24 bit
460 * ADC_RX_WLEN_20BIT - 20 bit
461 * ADC_RX_WLEN_16BIT - 16 bit
462 *
463 * \return 0 if success.
464 *
465 **/
466 ADC_RET pcm186xDataConfig(Uint8 addr, Uint8 dataType, Uint8 slotWidth)
467 {
468 Uint8 read = 0;
469 Uint8 val;
470 ADC_RET ret;
472 DBG_PCM186x (platform_write("pcm186xDataConfig() : addr = 0x%x dataType = %d "
473 "slotWidth = %d page = %d\n", addr, dataType,
474 slotWidth, pcm186xPageCheck(addr)));
476 ret = pcm186x_read_reg(addr, PCM186x_AUDIO_FMT, &read);
477 if(ret)
478 {
479 IFPRINT (platform_write("pcm186xDataConfig() : Error in Reading Register = 0x%x\n",
480 PCM186x_AUDIO_FMT));
481 return (ret);
482 }
484 val = (dataType | (slotWidth << 6));
486 ret = pcm186x_write_reg(addr, PCM186x_AUDIO_FMT, ((read & 0x3C) | val));
488 return (ret);
489 }
491 /**
492 * \brief Selects input channel for ADC.
493 *
494 * \param addr [IN] ADC HW instance I2C slave address.
495 *
496 * \param channel [IN] Channel selection
497 * 0 - ADC CH1 LEFT
498 * 1 - ADC CH1 RIGHT
499 * 2 - ADC CH2 LEFT
500 * 3 - ADC CH2 RIGHT
501 *
502 * \param input [IN] Input selection
503 * 0x0 : No Select
504 * 0x1 : VINL1[SE]
505 * 0x2 : VINL2[SE]
506 * 0x3 : VINL2[SE] + VINL1[SE]
507 * 0x4 : VINL3[SE]
508 * 0x5 : VINL3[SE] + VINL1[SE]
509 * 0x6 : VINL3[SE] + VINL2[SE]
510 * 0x7 : VINL3[SE] + VINL2[SE] + VINL1[SE]
511 * 0x8 : VINL4[SE]
512 * 0x9 : VINL4[SE] + VINL1[SE]
513 * 0xA : VINL4[SE] + VINL2[SE]
514 * 0xB : VINL4[SE] + VINL2[SE] + VINL1[SE]
515 * 0xC : VINL4[SE] + VINL3[SE]
516 * 0xD : VINL4[SE] + VINL3[SE] + VINL1[SE]
517 * 0xE : VINL4[SE] + VINL3[SE] + VINL2[SE]
518 * 0xF : VINL4[SE] + VINL3[SE] + VINL2[SE] + VINL1[SE]
519 * 0x10 : {VIN1P, VIN1M}[DIFF]
520 * 0x20 : {VIN4P, VIN4M}[DIFF]
521 * 0x30 : {VIN1P, VIN1M}[DIFF] + {VIN4P, VIN4M}[DIFF]
522 *
523 * \return 0 for success.
524 *
525 **/
526 ADC_RET pcm186xInputSel(Uint8 addr, Uint8 channel, Uint8 input)
527 {
528 ADC_RET ret;
529 Uint8 read = 0;
531 DBG_PCM186x (platform_write("pcm186xInputSel() : addr = 0x%x "
532 "channel = %d input = 0x%x page = %d\n",
533 addr, channel, input, pcm186xPageCheck(addr)));
535 ret = pcm186x_read_reg(addr, PCM186x_INPUT_SELECT(channel), &read);
536 if(ret)
537 {
538 IFPRINT (platform_write("pcm186xInputSel() : Error in Reading Register = 0x%x\n",
539 PCM186x_INPUT_SELECT(channel)));
540 return (ret);
541 }
543 read = ((read & 0xC0) | input);
544 ret = pcm186x_write_reg(addr, PCM186x_INPUT_SELECT(channel), read);
546 return (ret);
547 }
549 /**
550 * \brief Sets the ADC PGA Volume.
551 *
552 * \param addr [IN] ADC HW instance I2C slave address.
553 *
554 * \param vol [IN] Volume in percentage; 0 to 100
555 *
556 * \param channel [IN] Channel selection mask
557 * ADC_CH1_LEFT - ADC CH1 LEFT
558 * ADC_CH1_RIGHT - ADC CH1 RIGHT
559 * ADC_CH2_LEFT - ADC CH2 LEFT
560 * ADC_CH2_RIGHT - ADC CH2 RIGHT
561 * ADC_CH_ALL - All the four channels
562 *
563 * \return 0 for success.
564 *
565 **/
566 ADC_RET pcm186xSetVolume(Uint8 addr, Uint8 vol, Uint8 channel)
567 {
568 Uint8 value;
569 Uint8 count;
570 ADC_RET ret;
572 DBG_PCM186x (platform_write("pcm186xSetVolume() : addr = 0x%x vol = %d "
573 "channel = %d page = %d\n", addr,
574 vol, channel, pcm186xPageCheck(addr)));
576 /* Gains -12dB to 38dB are supported with step value of 0.5.
577 Values from 38.5dB to 40dB are ignored to simplify the computation.
578 Volume percentage 0 to 24 indicates -12dB to 0dB and
579 Volume percentage 25 to 100 indicates 0.5dB to 38dB */
580 if(vol <= 24)
581 {
582 value = (24 - vol)/2;
584 /* ADC datasheet shows same 7 bit value for -0.5 and -1.
585 Adding 1 to add values may be needed to satisfy this condition */
586 if(vol % 2)
587 {
588 value += 1;
589 }
591 if(value)
592 {
593 /* Calculate 2's compliment */
594 value = ~(value) + 1;
595 value <<= 1;
596 }
597 }
598 else
599 {
600 value = (vol - 24)/2;
601 value <<= 1;
602 }
604 if(vol % 2)
605 {
606 value = value | 0x1;
607 }
609 if(channel == ADC_CH_ALL)
610 {
611 for (count = ADC_CH1_LEFT; count <= ADC_CH2_RIGHT; count++)
612 {
613 ret = pcm186x_write_reg(addr, PCM186x_VOL_CTRL(count), value);
614 if(ret)
615 {
616 IFPRINT (platform_write("pcm186xSetVolume() : Error in Writing Register = 0x%x\n",
617 PCM186x_VOL_CTRL(count)));
618 return (ret);
619 }
620 }
621 }
622 else
623 {
624 ret = pcm186x_write_reg(addr, PCM186x_VOL_CTRL(channel), value);
625 }
627 return (ret);
628 }
630 /**
631 * \brief Unmute or Mute ADC the Channel.
632 *
633 * \param addr [IN] ADC HW instance I2C slave address.
634 *
635 * \param channel [IN] Channel selection mask
636 * 0 - ADC CH1 LEFT
637 * 2 - ADC CH1 RIGHT
638 * 4 - ADC CH2 LEFT
639 * 8 - ADC CH2 RIGHT
640 * 0xF - All the four channels
641 *
642 * \param mute [IN] Mute control
643 * 1 - Mute the channel
644 * 0 - Unmute the channel
645 *
646 * \return 0 for success.
647 *
648 **/
649 ADC_RET pcm186xMuteChannel(Uint8 addr, Uint8 channel, Uint8 mute)
650 {
651 ADC_RET ret;
652 Uint8 read = 0;
654 DBG_PCM186x (platform_write("pcm186xMuteChannel() : addr = 0x%x mute = %d"
655 " channel = %d page = %d\n", addr, mute,
656 channel, pcm186xPageCheck(addr)));
658 ret = pcm186x_read_reg(addr, PCM186x_MUTE_CTRL, &read);
659 if(ret)
660 {
661 IFPRINT (platform_write("pcm186xMuteChannel() : Error in Reading Register = 0x%x\n",
662 PCM186x_MUTE_CTRL));
663 return (ret);
664 }
666 if(mute == 0)
667 {
668 read = (read & ~(channel));
669 }
670 else
671 {
672 read = (read | channel);
673 }
675 ret = pcm186x_write_reg(addr, PCM186x_MUTE_CTRL, read);
677 return (ret);
678 }
680 /**
681 * \brief Unmute or Mute ADC the Channel.
682 *
683 * \param addr [IN] ADC HW instance I2C slave address.
684 *
685 * \param powState [IN] ADC power state
686 * ADC_POWER_STATE_STANDBY - ADC standby state
687 * ADC_POWER_STATE_SLEEP - ADC device sleep state
688 * ADC_POWER_STATE_POWERDOWN - ADC Analog Power Down state
689 *
690 * \param enable [IN] Mute control
691 * 1 - Enables the power state
692 * 0 - Disables the power state
693 *
694 * \return 0 for success.
695 *
696 **/
697 ADC_RET pcm186xConfigPowState(Uint8 addr, Uint8 powState, Uint8 enable)
698 {
699 ADC_RET ret;
700 Uint8 read = 0;
702 DBG_PCM186x (platform_write("pcm186xConfigPowState() : addr = 0x%x"
703 " powState = %d enable = %d page = %d\n",
704 addr, powState, enable,
705 pcm186xPageCheck(addr)));
707 ret = pcm186x_read_reg(addr, PCM186x_POWER_STATE_SEL, &read);
708 if(ret)
709 {
710 IFPRINT (platform_write("pcm186xConfigPowState() : Error in Reading Register = 0x%x\n",
711 PCM186x_POWER_STATE_SEL));
712 return (ret);
713 }
715 read = (read & ~(1 << powState)) | (enable << powState);
717 ret = pcm186x_write_reg(addr, PCM186x_POWER_STATE_SEL, read);
719 return (ret);
720 }
722 /**
723 * \brief Enables/Disables ADC interrupts.
724 *
725 * \param addr [IN] ADC HW instance I2C slave address.
726 *
727 * \param intrNum [IN] ADC interrupt ID
728 * ADC_INTR_ENERGY_SENSE - Energysense Interrupt
729 * ADC_INTR_DIN_TOGGLE - I2S RX DIN toggle Interrupt
730 * ADC_INTR_DC_CHANGE - DC Level Change Interrupt
731 * ADC_INTR_CLK_ERR - Clock Error Interrupt
732 * ADC_INTR_POST_PGA_CLIP - Post-PGA Clipping Interrupt
733 * ADC_INTR_ALL - To controls all the ADC interrupts together
734 *
735 * \param enable [IN] Interrupt control
736 * 1 - Enables the interrupt
737 * 0 - Disables the interrupt
738 *
739 * \return 0 for success.
740 *
741 **/
742 ADC_RET pcm186xSetIntr(Uint8 addr, Uint8 intrNum, Uint8 enable)
743 {
744 ADC_RET ret;
745 Uint8 value;
746 Uint8 read = 0;
748 DBG_PCM186x (platform_write("pcm186xSetIntr() : addr = 0x%x"
749 " intrNum = %d enable = %d page = %d read ="
750 " 0x%x", addr, intrNum, enable,
751 pcm186xPageCheck(addr), read));
753 ret = pcm186x_read_reg(addr, PCM186x_INTR_SEL, &read);
754 if(ret)
755 {
756 IFPRINT (platform_write("pcm186xSetIntr() : Error in Reading Register = 0x%x\n",
757 PCM186x_INTR_SEL));
758 return (ret);
759 }
761 if(intrNum == ADC_INTR_ALL)
762 {
763 if(enable)
764 {
765 value = 0x1F;
766 }
767 else
768 {
769 value = 0x00;
770 }
772 read = ((read & 0xE0) | value);
773 }
774 else
775 {
776 read = ((read & (~(1 << intrNum))) | (enable << intrNum));
777 }
779 ret = pcm186x_write_reg(addr, PCM186x_INTR_SEL, read);
781 return (ret);
782 }
784 /**
785 * \brief Reads ADC interrupt status register.
786 *
787 * \param addr [IN] ADC HW instance I2C slave address.
788 *
789 * \return Value of interrupt status register in case of success
790 * 0xFF in case of failure
791 *
792 **/
793 Uint8 pcm186xGetIntrStatus(Uint8 addr)
794 {
795 ADC_RET ret;
796 Uint8 read = 0;
798 DBG_PCM186x (platform_write("pcm186xGetIntrStatus() : addr = 0x%x page"
799 " = %d\n", addr, pcm186xPageCheck(addr)));
801 ret = pcm186x_read_reg(addr, PCM186x_INTR_STAT, &read);
802 if(ret)
803 {
804 IFPRINT (platform_write("pcm186xGetIntrStatus() : Error in Reading Register = 0x%x\n",
805 PCM186x_INTR_STAT));
806 return (0xFF);
807 }
808 else
809 {
810 DBG_PCM186x (platform_write("pcm186xGetIntrStatus() : Intr Status = 0x%x\n", read));
811 return (read);
812 }
813 }
815 /**
816 * \brief Controls ADC DSP channel configuration
817 *
818 * \param addr [IN] ADC HW instance I2C slave address.
819 *
820 * \param channel [IN] Channel configuration
821 * ADC_DSP_PROC_4CHAN - ADC DSP 4 channel mode processing
822 * ADC_DSP_PROC_2CHAN - ADC DSP 2 channel mode processing
823 *
824 * \return 0 for success.
825 *
826 **/
827 ADC_RET pcm186xDspCtrl(Uint8 addr, Uint8 channel)
828 {
829 ADC_RET ret;
830 Uint8 read;
832 DBG_PCM186x (platform_write("pcm186xDspCtrl() : addr = 0x%x channel = %d"
833 " page = %d\n", addr, channel,
834 pcm186xPageCheck(addr)));
836 ret = pcm186x_read_reg(addr, PCM186x_MUTE_CTRL, &read);
837 if(ret)
838 {
839 IFPRINT (platform_write("pcm186xDspCtrl() : Error in Reading Register = 0x%x\n",
840 PCM186x_MUTE_CTRL));
841 return (ret);
842 }
844 read = ((read & 0x7F) | (channel << 7));
846 ret = pcm186x_write_reg(addr, PCM186x_MUTE_CTRL, read);
848 return (ret);
849 }
851 /**
852 * \brief Programs ADC DSP coefficients
853 *
854 * \param addr [IN] ADC HW instance I2C slave address.
855 *
856 * \param regAddr [IN] DSP register address
857 *
858 * \param coeff [IN] DSP coefficient
859 *
860 * \return 0 for success.
861 *
862 **/
863 ADC_RET pcm186xProgDspCoeff(Uint8 addr, Uint8 regAddr, Uint32 coeff)
864 {
865 ADC_RET ret;
866 Uint8 value;
867 Uint8 count;
868 Uint8 coeffBuf[3];
870 DBG_PCM186x (platform_write("pcm186xProgDspCoeff() : addr = 0x%x "
871 "Coeff Reg = 0x%x Coeff = 0x%x page = %d\n",
872 addr, regAddr, coeff, pcm186xPageCheck(addr)));
874 /* Switch to page 1 */
875 ret = pcm186x_write_reg(addr, 0x0, 0x1);
876 if(ret)
877 {
878 IFPRINT (platform_write("pcm186xProgDspCoeff() : ADC Page Switch Failed\n"));
879 return (ret);
880 }
882 /* Write the memory address of coefficient register */
883 ret = pcm186x_write_reg(addr, PCM186x_DSP_MEM_ADDR, regAddr);
884 if(ret)
885 {
886 IFPRINT (platform_write("pcm186xProgDspCoeff() : Error in Writing Register = 0x%x\n",
887 PCM186x_DSP_MEM_ADDR));
888 return (ret);
889 }
891 coeffBuf[0] = (coeff >> 16) & 0xFF;
892 coeffBuf[1] = (coeff >> 8) & 0xFF;
893 coeffBuf[2] = (coeff & 0xFF);
895 /* Write the coefficient data */
896 for (count = 0; count < 3; count ++)
897 {
898 ret = pcm186x_write_reg(addr, PCM186x_DSP_MEM_WDATA(count),
899 coeffBuf[count]);
900 if(ret)
901 {
902 IFPRINT (platform_write("pcm186xProgDspCoeff() : Error in Writing Register = 0x%x\n",
903 PCM186x_DSP_MEM_WDATA(count)));
904 return (ret);
905 }
906 }
908 /* Execute write operation */
909 ret = pcm186x_write_reg(addr, PCM186x_DSP_PROG, 0x1);
910 if(ret)
911 {
912 IFPRINT (platform_write("pcm186xProgDspCoeff() : Error in Writing Register = 0x%x\n",
913 PCM186x_DSP_PROG));
914 return (ret);
915 }
917 /* Wait for DSP coefficient write to complete */
918 do
919 {
920 ret = pcm186x_read_reg(addr, PCM186x_DSP_PROG, &value);
921 if(ret)
922 {
923 IFPRINT (platform_write("pcm186xProgDspCoeff() : Error in Reading Register = 0x%x\n",
924 PCM186x_DSP_PROG));
925 return (ret);
926 }
927 } while (!(value & 0x10)); //TODO: Need to confirm the status check bit
929 /* Switch to page 0 */
930 ret = pcm186x_write_reg(addr, 0, 0x0);
931 if(ret)
932 {
933 IFPRINT (platform_write("pcm186xProgDspCoeff() : ADC Page Switch Failed\n"));
934 return (ret);
935 }
937 return (ret);
938 }
940 /**
941 * \brief Reads ADC power state
942 *
943 * \param addr [IN] ADC HW instance I2C slave address.
944 *
945 * \return 0xFF for failure or below values for success.
946 * 0x0 - Power Down
947 * 0x1 - Wait clock stable
948 * 0x2 - Release reset
949 * 0x3 - Stand-by
950 * 0x4 - Fade IN
951 * 0x5 - Fade OUT
952 * 0x9 - Sleep
953 * 0xF - Run
954 *
955 **/
956 Uint8 pcm186xGetPowerStateStatus(Uint8 addr)
957 {
958 ADC_RET ret;
959 Uint8 read = 0;
961 DBG_PCM186x (platform_write("pcm186xGetPowerStateStatus() : addr = 0x%x"
962 " page = %d\n", addr, pcm186xPageCheck(addr)));
964 ret = pcm186x_read_reg(addr, PCM186x_POWER_STAT, &read);
965 if(ret)
966 {
967 IFPRINT (platform_write("pcm186xGetPowerStateStatus() : Error in Reading Register = 0x%x\n",
968 PCM186x_POWER_STAT));
969 return (0xFF);
970 }
971 else
972 {
973 DBG_PCM186x (platform_write("pcm186xGetPowerStateStatus() : read = 0x%x\n", read));
974 return (read & 0x0F);
975 }
976 }
978 /**
979 * \brief Reads current sampling frequency
980 *
981 * \param addr [IN] ADC HW instance I2C slave address.
982 *
983 * \return 0xFF for failure or below values for success.
984 * 0x0 - Out of range (Low) or LRCK Halt
985 * 0x1 - 8kHz
986 * 0x2 - 16kHz
987 * 0x3 - 32-48kHz
988 * 0x4 - 88.2-96kHz
989 * 0x5 - 176.4-192kHz
990 * 0x6 - Out of range (High)
991 * 0x7 - Invalid Fs
992 *
993 **/
994 Uint8 pcm186xGetSampleFreqStatus(Uint8 addr)
995 {
996 ADC_RET ret;
997 Uint8 read = 0;
999 DBG_PCM186x (platform_write("pcm186xGetSampleFreqStatus() : addr = 0x%x"
1000 " page = %d\n", addr, pcm186xPageCheck(addr)));
1002 ret = pcm186x_read_reg(addr, PCM16x_SAMPLE_FREQ_STAT, &read);
1003 if(ret)
1004 {
1005 IFPRINT (platform_write("pcm186xGetSampleFreqStatus() : Error in Reading Register = 0x%x\n",
1006 PCM16x_SAMPLE_FREQ_STAT));
1007 return (0xFF);
1008 }
1009 else
1010 {
1011 DBG_PCM186x (platform_write("pcm186xGetSampleFreqStatus() : read = 0x%x\n", read));
1012 return (read & 0x07);
1013 }
1014 }
1016 /**
1017 * \brief Reads bit clock ratio status
1018 *
1019 * \param addr [IN] ADC HW instance I2C slave address.
1020 *
1021 * \return 0xFF for failure or below values for success.
1022 * 0x0 - Out of range (L) or BCK Halt
1023 * 0x1 - 32
1024 * 0x2 - 48
1025 * 0x3 - 64
1026 * 0x4 - 256
1027 * 0x6 - Out of range (High)
1028 * 0x7 - Invalid BCK ratio or LRCK Halt
1029 *
1030 **/
1031 Uint8 pcm186xGetBckRatioStatus(Uint8 addr)
1032 {
1033 ADC_RET ret;
1034 Uint8 read = 0;
1036 DBG_PCM186x (platform_write("pcm186xGetBckRatioStatus() : addr = 0x%x"
1037 " page = %d\n", addr, pcm186xPageCheck(addr)));
1039 ret = pcm186x_read_reg(addr, PCM186x_BCK_SCK_STAT, &read);
1040 if(ret)
1041 {
1042 IFPRINT (platform_write("pcm186xGetBckRatioStatus() : Error in Reading Register = 0x%x\n",
1043 PCM186x_BCK_SCK_STAT));
1044 return (0xFF);
1045 }
1046 else
1047 {
1048 DBG_PCM186x (platform_write("pcm186xGetBckRatioStatus() : read = 0x%x\n", read));
1049 return ((read & 0x70) >> 4);
1050 }
1051 }
1053 /**
1054 * \brief Reads Current SCK Ratio
1055 *
1056 * \param addr [IN] ADC HW instance I2C slave address.
1057 *
1058 * \return 0xFF for failure or below values for success.
1059 * 0x0 - Out of range (L) or SCK Halt
1060 * 0x1 - 128
1061 * 0x2 - 256
1062 * 0x3 - 384
1063 * 0x4 - 512
1064 * 0x5 - 768
1065 * 0x6 - Out of range (High)
1066 * 0x7 - Invalid SCK ratio or LRCK Halt
1067 *
1068 **/
1069 Uint8 pcm186xGetSckRatioStatus(Uint8 addr)
1070 {
1071 ADC_RET ret;
1072 Uint8 read = 0;
1074 DBG_PCM186x (platform_write("pcm186xGetSckRatioStatus() : addr = 0x%x"
1075 " page = %d\n", addr, pcm186xPageCheck(addr)));
1077 ret = pcm186x_read_reg(addr, PCM186x_BCK_SCK_STAT, &read);
1078 if(ret)
1079 {
1080 IFPRINT (platform_write("pcm186xGetSckRatioStatus() : Error in Reading Register = 0x%x\n",
1081 PCM186x_BCK_SCK_STAT));
1082 return (0xFF);
1083 }
1084 else
1085 {
1086 DBG_PCM186x (platform_write("read = 0x%x\n", read));
1087 return (read & 0x07);
1088 }
1089 }
1091 /**
1092 * \brief Reads LRCK Halt Status
1093 *
1094 * \param addr [IN] ADC HW instance I2C slave address.
1095 *
1096 * \return 0xFF for failure or below values for success.
1097 * 0 - No Error
1098 * 1 - Halt
1099 *
1100 **/
1101 Uint8 pcm186xGetLrckHltStatus(Uint8 addr)
1102 {
1103 ADC_RET ret;
1104 Uint8 read = 0;
1106 DBG_PCM186x (platform_write("pcm186xGetLrckHltStatus() : addr = 0x%x"
1107 " page = %d\n", addr, pcm186xPageCheck(addr)));
1109 ret = pcm186x_read_reg(addr, PCM186x_CLK_STAT, &read);
1110 if(ret)
1111 {
1112 IFPRINT (platform_write("pcm186xGetLrckHltStatus() : Error in Reading Register = 0x%x\n",
1113 PCM186x_CLK_STAT));
1114 return (0xFF);
1115 }
1116 else
1117 {
1118 DBG_PCM186x (platform_write("pcm186xGetLrckHltStatus() : read = 0x%x\n", read));
1119 return (EXTRACT_STATUS(read, LRCKHLT));
1120 }
1121 }
1123 /**
1124 * \brief Reads BCK Halt Status
1125 *
1126 * \param addr [IN] ADC HW instance I2C slave address.
1127 *
1128 * \return 0xFF for failure or below values for success.
1129 * 0 - No Error
1130 * 1 - Halt
1131 *
1132 **/
1133 Uint8 pcm186xGetBckHltStatus(Uint8 addr)
1134 {
1135 ADC_RET ret;
1136 Uint8 read = 0;
1138 DBG_PCM186x (platform_write("pcm186xGetBckHltStatus() : addr = 0x%x"
1139 " page = %d\n", addr, pcm186xPageCheck(addr)));
1141 ret = pcm186x_read_reg(addr, PCM186x_CLK_STAT, &read);
1142 if(ret)
1143 {
1144 IFPRINT (platform_write("pcm186xGetBckHltStatus() : Error in Reading Register = 0x%x\n",
1145 PCM186x_CLK_STAT));
1146 return (0xFF);
1147 }
1148 else
1149 {
1150 DBG_PCM186x (platform_write("pcm186xGetBckHltStatus() : read = 0x%x\n", read));
1151 return (EXTRACT_STATUS(read, BCKHLT));
1152 }
1153 }
1155 /**
1156 * \brief Reads SCK Halt Status
1157 *
1158 * \param addr [IN] ADC HW instance I2C slave address.
1159 *
1160 * \return 0xFF for failure or below values for success.
1161 * 0 - No Error
1162 * 1 - Halt
1163 *
1164 **/
1165 Uint8 pcm186xGetSckHltStatus(Uint8 addr)
1166 {
1167 ADC_RET ret;
1168 Uint8 read = 0;
1170 DBG_PCM186x (platform_write("pcm186xGetSckHltStatus() : addr = 0x%x"
1171 " page = %d\n", addr, pcm186xPageCheck(addr)));
1173 ret = pcm186x_read_reg(addr, PCM186x_CLK_STAT, &read);
1174 if(ret)
1175 {
1176 IFPRINT (platform_write("pcm186xGetSckHltStatus() : Error in Reading Register = 0x%x\n",
1177 PCM186x_CLK_STAT));
1178 return (0xFF);
1179 }
1180 else
1181 {
1182 DBG_PCM186x (platform_write("pcm186xGetSckHltStatus() : read = 0x%x\n", read));
1183 return (EXTRACT_STATUS(read, SCKHLT));
1184 }
1185 }
1187 /**
1188 * \brief Reads LRCK Error Status
1189 *
1190 * \param addr [IN] ADC HW instance I2C slave address.
1191 *
1192 * \return 0xFF for failure or below values for success.
1193 * 0 - No Error
1194 * 1 - Error
1195 *
1196 **/
1197 Uint8 pcm186xGetLrckErrStatus(Uint8 addr)
1198 {
1199 ADC_RET ret;
1200 Uint8 read = 0;
1202 DBG_PCM186x (platform_write("pcm186xGetLrckErrStatus() : addr = 0x%x"
1203 " page = %d\n", addr, pcm186xPageCheck(addr)));
1205 ret = pcm186x_read_reg(addr, PCM186x_CLK_STAT, &read);
1206 if(ret)
1207 {
1208 IFPRINT (platform_write("pcm186xGetLrckErrStatus() : Error in Reading Register = 0x%x\n",
1209 PCM186x_CLK_STAT));
1210 return (0xFF);
1211 }
1212 else
1213 {
1214 DBG_PCM186x (platform_write("pcm186xGetLrckErrStatus() : read = 0x%x\n", read));
1215 return (EXTRACT_STATUS(read, LRCKERR));
1216 }
1217 }
1219 /**
1220 * \brief Reads BCK Error Status
1221 *
1222 * \param addr [IN] ADC HW instance I2C slave address.
1223 *
1224 * \return 0xFF for failure or below values for success.
1225 * 0 - No Error
1226 * 1 - Error
1227 *
1228 **/
1229 Uint8 pcm186xGetBckErrStatus(Uint8 addr)
1230 {
1231 ADC_RET ret;
1232 Uint8 read = 0;
1234 DBG_PCM186x (platform_write("pcm186xGetBckErrStatus() : addr = 0x%x"
1235 " page = %d\n", addr, pcm186xPageCheck(addr)));
1237 ret = pcm186x_read_reg(addr, PCM186x_CLK_STAT, &read);
1238 if(ret)
1239 {
1240 IFPRINT (platform_write("pcm186xGetBckErrStatus() : Error in Reading Register = 0x%x\n",
1241 PCM186x_CLK_STAT));
1242 return (0xFF);
1243 }
1244 else
1245 {
1246 DBG_PCM186x (platform_write("pcm186xGetBckErrStatus() : read = 0x%x\n", read));
1247 return (EXTRACT_STATUS(read, BCKERR));
1248 }
1249 }
1251 /**
1252 * \brief Reads SCK Error Status
1253 *
1254 * \param addr [IN] ADC HW instance I2C slave address.
1255 *
1256 * \return 0xFF for failure or below values for success.
1257 * 0 - No Error
1258 * 1 - Error
1259 *
1260 **/
1261 Uint8 pcm186xGetSckErrStatus(Uint8 addr)
1262 {
1263 ADC_RET ret;
1264 Uint8 read = 0;
1266 DBG_PCM186x (platform_write("pcm186xGetSckErrStatus() : addr = 0x%x"
1267 " page = %d\n", addr, pcm186xPageCheck(addr)));
1269 ret = pcm186x_read_reg(addr, PCM186x_CLK_STAT, &read);
1270 if(ret)
1271 {
1272 IFPRINT (platform_write("pcm186xGetSckErrStatus() : Error in Reading Register = 0x%x\n",
1273 PCM186x_CLK_STAT));
1274 return (0xFF);
1275 }
1276 else
1277 {
1278 DBG_PCM186x (platform_write("pcm186xGetSckErrStatus() : read = 0x%x\n", read));
1279 return (EXTRACT_STATUS(read, SCKERR));
1280 }
1281 }
1283 /**
1284 * \brief Reads DVDD Status
1285 *
1286 * \param addr [IN] ADC HW instance I2C slave address.
1287 *
1288 * \return 0xFF for failure or below values for success.
1289 * 0 - Bad/Missing
1290 * 1 - Good
1291 *
1292 **/
1293 Uint8 pcm186xGetDvddStatus(Uint8 addr)
1294 {
1295 ADC_RET ret;
1296 Uint8 read = 0;
1298 DBG_PCM186x (platform_write("pcm186xGetDvddStatus() : addr = 0x%x"
1299 " page = %d\n", addr, pcm186xPageCheck(addr)));
1301 ret = pcm186x_read_reg(addr, PCM186x_VOLTAGE_STAT, &read);
1302 if(ret)
1303 {
1304 IFPRINT (platform_write("pcm186xGetDvddStatus() : Error in Reading Register = 0x%x\n",
1305 PCM186x_VOLTAGE_STAT));
1306 return (0xFF);
1307 }
1308 else
1309 {
1310 DBG_PCM186x (platform_write("pcm186xGetDvddStatus() : read = 0x%x\n", read));
1311 return (EXTRACT_STATUS(read, DVDD));
1312 }
1313 }
1315 /**
1316 * \brief Reads AVDD Status
1317 *
1318 * \param addr [IN] ADC HW instance I2C slave address.
1319 *
1320 * \return 0xFF for failure or below values for success.
1321 * 0 - Bad/Missing
1322 * 1 - Good
1323 *
1324 **/
1325 Uint8 pcm186xGetAvddStatus(Uint8 addr)
1326 {
1327 ADC_RET ret;
1328 Uint8 read = 0;
1330 DBG_PCM186x (platform_write("pcm186xGetAvddStatus() : addr = 0x%x"
1331 " page = %d\n", addr, pcm186xPageCheck(addr)));
1333 ret = pcm186x_read_reg(addr, PCM186x_VOLTAGE_STAT, &read);
1334 if(ret)
1335 {
1336 IFPRINT (platform_write("pcm186xGetAvddStatus() : Error in Reading Register = 0x%x\n",
1337 PCM186x_VOLTAGE_STAT));
1338 return (0xFF);
1339 }
1340 else {
1341 DBG_PCM186x (platform_write("pcm186xGetAvddStatus() : read = 0x%x\n", read));
1342 return (EXTRACT_STATUS(read, AVDD));
1343 }
1344 }
1346 /**
1347 * \brief Reads Digital LDO Status
1348 *
1349 * \param addr [IN] ADC HW instance I2C slave address.
1350 *
1351 * \return 0xFF for failure or below values for success.
1352 * 0 - Bad/Missing
1353 * 1 - Good
1354 *
1355 **/
1356 Uint8 pcm186xGetLdoStatus(Uint8 addr)
1357 {
1358 ADC_RET ret;
1359 Uint8 read = 0;
1361 DBG_PCM186x (platform_write("pcm186xGetLdoStatus() : addr = 0x%x"
1362 " page = %d\n", addr, pcm186xPageCheck(addr)));
1364 ret = pcm186x_read_reg(addr, PCM186x_VOLTAGE_STAT, &read);
1365 if(ret)
1366 {
1367 IFPRINT (platform_write("pcm186xGetLdoStatus() : Error in Reading Register = 0x%x\n",
1368 PCM186x_VOLTAGE_STAT));
1369 return (0xFF);
1370 }
1371 else
1372 {
1373 DBG_PCM186x (platform_write("pcm186xGetLdoStatus() : read = 0x%x\n", read));
1374 return (EXTRACT_STATUS(read, LDO));
1375 }
1376 }
1378 #endif /* #if (PLATFORM_AUDIO_ADC) */
1380 /***************************** End Of File ***********************************/