ADuCM4x50 Device Drivers API Reference Manual  Release 4.0.0.0
adi_beep.c
1 
16 #include <adi_processor.h>
17 
18 #include <stddef.h>
19 #include <assert.h>
20 
21 #include <drivers/beep/adi_beep.h>
22 #include <rtos_map/adi_rtos_map.h>
23 #include "adi_beep_def.h"
24 
33 #ifdef __ICCARM__
34 /*
35 * IAR MISRA C 2004 error suppressions.
36 *
37 * Pm123 (rule 8.5): there shall be no definition of objects or functions in a header file
38 * This isn't a header as such.
39 *
40 * Pm073 (rule 14.7): a function should have a single point of exit.
41 * Pm143 (rule 14.7): a function should have a single point of exit at the end of the function.
42 * Multiple returns are used for error handling.
43 *
44 * Pm050 (rule 14.2): a null statement shall only occur on a line by itself
45 * Needed for null expansion of ADI_INSTALL_HANDLER and others.
46 *
47 * Pm140 (rule 11.3): a cast should not be performed between a pointer type and an integral type
48 * Required for MMR addresses and callback parameters.
49 *
50 * Pm031: (MISRA C 2004 rule 12.7) bitwise operations shall not be performed on signed integer types
51 * Required for MMR manipulations.
52 *
53 * Pm152: (MISRA C 2004 rule 17.4) array indexing shall only be applied to objects defined as an array type
54 * Required for adi_beep_PlaySequence() to access the user-supplied array of notes.
55 *
56 * Pm141: (MISRA C 2004 rule 11.4) a cast should not be performed between a pointer to object type and a
57 * different pointer to object type, this casts from type.
58 * Required to store a an array of varying size in a device structure.
59 *
60 * Required for adi_beep_PlaySequence() to access the user-supplied array of notes.
61 */
62 #pragma diag_suppress=Pm123,Pm073,Pm143,Pm050,Pm140,Pm031,Pm152,Pm141
63 #endif /* __ICCARM__ */
64 
65 /*========== D A T A ==========*/
66 static ADI_BEEP_DRIVER adi_beep_Device[1];
67 
69 /* Handler for the BEEP interrupt */
70 void Beep_Int_Handler(void);
71 
72 /* debug handle checker */
73 #ifdef ADI_DEBUG
74 #define ADI_BEEP_INVALID_HANDLE(h) (&adi_beep_Device[0] != (h))
75 #endif
76 
77 /* definition for the BEEP IRQ - there is only ever one instance of the
78  * BEEP driver, so reducing space by using a #define rather than including
79  * it in the device structure. */
80 #define BEEP_IRQ (BEEP_EVT_IRQn)
81 
82 #if ADI_BEEP_CFG_SEQUENCE_REPEAT_VALUE == 0
83 /* A single note is requested. Only enable the AEND int. */
84 #define INTERRUPT_ON_SEQEND (0)
85 #define INTERRUPT_ON_AEND (1)
86 #else
87 /* A two-tone sequence is requested. Only enable the SEQEND int. */
88 #define INTERRUPT_ON_SEQEND (1)
89 #define INTERRUPT_ON_AEND (0)
90 #endif
91 
94 static const ADI_BEEP_STATIC_INIT gBeeperStaticConfigData[ADI_BEEP_MAX_DEVID] = {
95  /* single instance of Beeper device */
96  {
97  /* configuration register */
98  ( (INTERRUPT_ON_SEQEND << BITP_BEEP_CFG_SEQATENDIRQ)
99  | (INTERRUPT_ON_AEND << BITP_BEEP_CFG_AENDIRQ)
100  | (ADI_BEEP_CFG_SEQUENCE_REPEAT_VALUE << BITP_BEEP_CFG_SEQREPEAT)
101  ),
102 
103  /* Status register (interrupt clears) */
104  (ADI_BEEP_ALL_INTERRUPTS),
105 
106  /* ToneA control register */
107  ( ((uint32_t)ADI_BEEP_TONEA_DISABLE << BITP_BEEP_TONEA_DIS)
108  | ((uint32_t)ADI_BEEP_TONEA_FREQUENCY << BITP_BEEP_TONEA_FREQ)
109  | ((uint32_t)ADI_BEEP_TONEA_DURATION << BITP_BEEP_TONEA_DUR)
110  ),
111 
112  /* ToneB control register */
113  ( ((uint32_t)ADI_BEEP_TONEB_DISABLE << BITP_BEEP_TONEB_DIS)
114  | ((uint32_t)ADI_BEEP_TONEB_FREQUENCY << BITP_BEEP_TONEB_FREQ)
115  | ((uint32_t)ADI_BEEP_TONEB_DURATION << BITP_BEEP_TONEB_DUR)
116  )
117  }
118 };
119 
162  void* const pMemory,
163  uint32_t const MemorySize,
164  ADI_BEEP_HANDLE* const phDevice)
165 {
166  ADI_BEEP_DRIVER *pDevice;
167  ADI_BEEP_DEV_DATA *pData;
168  /* store a bad handle in case of failure */
169  *phDevice = (ADI_BEEP_HANDLE) NULL;
170 
171 #ifdef ADI_DEBUG
172  if (DeviceNum >= ADI_BEEP_MAX_DEVID)
173  {
174  return ADI_BEEP_BAD_DEV_ID;
175  }
176 
177  if (pMemory == NULL)
178  {
179  return ADI_BEEP_NULL_PTR;
180  }
181 
182  assert (MemorySize >= sizeof(ADI_BEEP_DRIVER));
183 #endif
184 
185  /* local pointer to instance data */
186  pDevice = &adi_beep_Device[DeviceNum];
187  pDevice->pReg = pADI_BEEP0;
188  pDevice->pData = (ADI_BEEP_DEV_DATA*)pMemory;
189  pData = pDevice->pData;
190 
191 #ifdef ADI_DEBUG
192  if (ADI_BEEP_STATE_UNINITIALIZED != adi_beep_Device[DeviceNum].pData->state)
193  {
195  }
196 #endif
197 
198  pData->cbFunc = NULL;
199  pData->cbParam = NULL;
200  SEM_CREATE(pDevice->pData, "BEEP_SEM", ADI_BEEP_SEMAPHORE_FAILED);
201 
202  /* set statically configured initialization data */
203  ADI_BEEP_STATIC_INIT const* pInitData = &gBeeperStaticConfigData[DeviceNum];
204  ADI_BEEP_TypeDef *pReg = pDevice->pReg;
205 
206  pReg->CFG = pInitData->BEEP_CFG;
207  pReg->STAT = pInitData->BEEP_STAT;
208  pReg->TONEA = pInitData->BEEP_TONEA;
209  pReg->TONEB = pInitData->BEEP_TONEB;
210 
211  /* enable beeper interrupts in NVIC */
212  NVIC_EnableIRQ(BEEP_IRQ);
213 
214  /* mark driver initialized */
215  pData->state = ADI_BEEP_STATE_INITIALIZED;
216 
217  /* store handle at application handle pointer */
218  *phDevice = (ADI_BEEP_HANDLE)pDevice;
219 
220  return ADI_BEEP_SUCCESS; /* initialized */
221 }
222 
223 
239 {
240 
241  ADI_BEEP_DRIVER *pDevice;
242  ADI_BEEP_DEV_DATA *pData;
243  ADI_BEEP_TypeDef *pReg;
244 
245  pDevice = (ADI_BEEP_DRIVER*)hDevice;
246  pData = pDevice->pData;
247  pReg = pDevice->pReg;
248 
249 #ifdef ADI_DEBUG
250  if (ADI_BEEP_INVALID_HANDLE(hDevice))
251  {
253  }
254  if (ADI_BEEP_STATE_UNINITIALIZED == pData->state)
255  {
257  }
258 #endif
259 
260  /* uninitialize */
261  NVIC_DisableIRQ(BEEP_IRQ);
262 
263  pData->state = ADI_BEEP_STATE_UNINITIALIZED;
264  pData->cbFunc = NULL;
265  pReg->CFG = 0u;
266  pReg->STAT = 0u;
267  pReg->TONEA = 0u;
268  pReg->TONEB = 0u;
269  SEM_DELETE(pDevice->pData, ADI_BEEP_SEMAPHORE_FAILED);
270  return ADI_BEEP_SUCCESS;
271 }
272 
294  ADI_CALLBACK pfCallback,
295  void* const pCBParam)
296 {
297  ADI_BEEP_DRIVER *pDevice = (ADI_BEEP_DRIVER*)hDevice;
298 
299  ADI_INT_STATUS_ALLOC();
300 
301 #ifdef ADI_DEBUG
302  if (ADI_BEEP_INVALID_HANDLE(hDevice)) {
304  }
305 
306  if (ADI_BEEP_STATE_UNINITIALIZED == pDevice->pData->state) {
308  }
309 #endif
310  /* Assign the callback within a critical region. */
311  ADI_ENTER_CRITICAL_REGION();
312  pDevice->pData->cbFunc = pfCallback;
313  pDevice->pData->cbParam = pCBParam;
314  ADI_EXIT_CRITICAL_REGION();
315 
316  return ADI_BEEP_SUCCESS;
317 }
318 
319 
320 #if ADI_BEEP_INCLUDE_PLAY_SEQUENCE == 1
321 
346  ADI_BEEP_NOTE aSequence[],
347  uint8_t count)
348 {
349  ADI_BEEP_DRIVER *pDevice = (ADI_BEEP_DRIVER*)hDevice;
350  ADI_BEEP_TypeDef *pReg = pDevice->pReg;
351  uint16_t nSeqCnt = 0u;
352 
353  ADI_INT_STATUS_ALLOC();
354 
355 #ifdef ADI_DEBUG
356  if (ADI_BEEP_INVALID_HANDLE(hDevice)) {
358  }
359 
360  if (ADI_BEEP_STATE_UNINITIALIZED == pDevice->pData->state) {
362  }
363 
364  if (NULL == aSequence) {
365  return ADI_BEEP_NULL_PTR;
366  }
367 
368  /* The sequence count must be a multiple of two, be greater than 1
369  * and must be a maximum of (127 * 2) notes in length. The hardware supports a
370  * sequence of up to 127, and there are two notes associated with that. */
371  if (((127u * 2u) < count) ||
372  ((count % 2u) != 0u) ||
373  (count < 2u)) {
374  return ADI_BEEP_INVALID_COUNT;
375  }
376 #endif
377 
378  /* Two notes are loaded at a time, and the sequence count refers to
379  * the number of times that both tone registers should be played. */
380  nSeqCnt = ((uint16_t)count) >> 1u;
381 
382  ADI_ENTER_CRITICAL_REGION();
383 
384  /* make a hole, and disable the beeper */
385  pReg->CFG &= (uint16_t)~(BITM_BEEP_CFG_SEQREPEAT | BITM_BEEP_CFG_AENDIRQ | BITM_BEEP_CFG_EN);
386 
387  pReg->TONEA = ( (uint16_t)((uint16_t)aSequence[0].frequency << ADI_BEEP_TONE_FREQ_BITPOS)
388  |(uint16_t)((uint16_t)aSequence[0].duration << ADI_BEEP_TONE_DUR_BITPOS) );
389 
390  pReg->TONEB = ( (uint16_t)((uint16_t)aSequence[1].frequency << ADI_BEEP_TONE_FREQ_BITPOS)
391  |(uint16_t)((uint16_t)aSequence[1].duration << ADI_BEEP_TONE_DUR_BITPOS) );
392 
393 
394  /* program new sequence count, while preserving everything else */
395  pReg->CFG |= (BITM_BEEP_CFG_EN |
396  BITM_BEEP_CFG_BSTARTIRQ |
397  BITM_BEEP_CFG_SEQATENDIRQ |
398  (uint16_t)((uint16_t)(nSeqCnt) << BITP_BEEP_CFG_SEQREPEAT));
399 
400  pDevice->pData->pSeqArray = (ADI_BEEP_NOTE(*)[])aSequence;
401  pDevice->pData->nSeqMax = count;
402  pDevice->pData->nSeqIndex = 2u;
403 
404  /* We're now playing, but not blocked */
405  pDevice->pData->state |= (ADI_BEEP_STATE_PLAYING);
406 
407  ADI_EXIT_CRITICAL_REGION();
408 
409  return ADI_BEEP_SUCCESS;
410 }
411 #endif
412 
429  ADI_BEEP_NOTE note)
430 {
431  ADI_BEEP_DRIVER *pDevice;
432  ADI_BEEP_TypeDef *pReg;
433  ADI_INT_STATUS_ALLOC();
434 
435  pDevice = (ADI_BEEP_DRIVER*)hDevice;
436  pReg = pDevice->pReg;
437 
438 #ifdef ADI_DEBUG
439  if (ADI_BEEP_INVALID_HANDLE(hDevice)) {
441  }
442 
443  if (ADI_BEEP_STATE_UNINITIALIZED == pDevice->pData->state) {
445  }
446 #endif
447 
448  ADI_ENTER_CRITICAL_REGION();
449 
450  /* Clear any previous sequence setup, and disable the beeper */
451  pReg->CFG &= (uint16_t)~(BITM_BEEP_CFG_SEQREPEAT | BITM_BEEP_CFG_EN);
452 
453  /* Set Tone A */
454  pReg->TONEA = ( (uint16_t)((uint16_t)note.frequency << ADI_BEEP_TONE_FREQ_BITPOS)
455  |(uint16_t)((uint16_t)note.duration << ADI_BEEP_TONE_DUR_BITPOS) );
456 
457  /* program new sequence count, while preserving everything else */
458  pReg->CFG |= (BITM_BEEP_CFG_EN | BITM_BEEP_CFG_AENDIRQ);
459 
460  /* We're now playing but not blocked */
461  pDevice->pData->state |= (ADI_BEEP_STATE_PLAYING);
462  ADI_EXIT_CRITICAL_REGION();
463 
464  return ADI_BEEP_SUCCESS;
465 }
466 
467 
492  ADI_BEEP_NOTE noteA,
493  ADI_BEEP_NOTE noteB,
494  uint8_t count)
495 {
496  ADI_BEEP_DRIVER *pDevice;
497  ADI_BEEP_TypeDef *pReg;
498  ADI_INT_STATUS_ALLOC();
499 
500  pDevice = (ADI_BEEP_DRIVER*)hDevice;
501  pReg = pDevice->pReg;
502 
503 #ifdef ADI_DEBUG
504  if (ADI_BEEP_INVALID_HANDLE(hDevice)) {
506  }
507 
508  if (ADI_BEEP_STATE_UNINITIALIZED == pDevice->pData->state) {
510  }
511 #endif
512 
513  ADI_ENTER_CRITICAL_REGION();
514 
515  /* make a hole, and disable the beeper */
516  pReg->CFG &= (uint16_t)~(BITM_BEEP_CFG_SEQREPEAT | BITM_BEEP_CFG_AENDIRQ |BITM_BEEP_CFG_EN);
517 
518  pReg->TONEA = ( (uint16_t)((uint16_t)noteA.frequency << ADI_BEEP_TONE_FREQ_BITPOS)
519  |(uint16_t)((uint16_t)noteA.duration << ADI_BEEP_TONE_DUR_BITPOS) );
520 
521  pReg->TONEB = ( (uint16_t)((uint16_t)noteB.frequency << ADI_BEEP_TONE_FREQ_BITPOS)
522  |(uint16_t)((uint16_t)noteB.duration << ADI_BEEP_TONE_DUR_BITPOS) );
523 
524  /* program new sequence count, while preserving everything else */
525  pReg->CFG |= (BITM_BEEP_CFG_EN | BITM_BEEP_CFG_SEQATENDIRQ |(uint16_t)((uint16_t)count << BITP_BEEP_CFG_SEQREPEAT));
526 
527  /* We're now playing but not blocked */
528  pDevice->pData->state |= (ADI_BEEP_STATE_PLAYING);
529  ADI_EXIT_CRITICAL_REGION();
530 
531  return ADI_BEEP_SUCCESS;
532 }
533 
552 ADI_BEEP_RESULT adi_beep_Enable(ADI_BEEP_HANDLE const hDevice, bool const bFlag)
553 {
554  ADI_BEEP_DRIVER *pDevice;
555  ADI_BEEP_TypeDef *pReg;
556  ADI_INT_STATUS_ALLOC();
557 
558  pDevice = (ADI_BEEP_DRIVER*)hDevice;
559  pReg = pDevice->pReg;
560 
561 #ifdef ADI_DEBUG
562  if (ADI_BEEP_INVALID_HANDLE(hDevice)) {
564  }
565 
566  if (ADI_BEEP_STATE_UNINITIALIZED == pDevice->pData->state) {
568  }
569 #endif
570 
571  ADI_ENTER_CRITICAL_REGION();
572 
573  if (bFlag == true) {
574  /* All the registers should already be set - just enable the beep */
575  pReg->CFG |= BITM_BEEP_CFG_EN;
576  pDevice->pData->state |= (ADI_BEEP_STATE_PLAYING);
577  }
578  else {
579  pReg->CFG &= (uint16_t)~(BITM_BEEP_CFG_EN);
580  pDevice->pData->state &= ~(ADI_BEEP_STATE_PLAYING);
581  }
582 
583  ADI_EXIT_CRITICAL_REGION();
584 
585  return ADI_BEEP_SUCCESS;
586 }
587 
604 {
605  ADI_BEEP_DRIVER *pDevice;
606  bool wait = false;
607  ADI_INT_STATUS_ALLOC();
608 
609  pDevice = (ADI_BEEP_DRIVER*)hDevice;
610 
611 #ifdef ADI_DEBUG
612  if (ADI_BEEP_INVALID_HANDLE(hDevice)) {
614  }
615 
616  if (ADI_BEEP_STATE_UNINITIALIZED == pDevice->pData->state) {
618  }
619 #endif
620 
621  ADI_ENTER_CRITICAL_REGION();
622 
623  if((pDevice->pData->state | ADI_BEEP_STATE_PLAYING) > 0u) {
624  /* We are going to pend on the semaphore, no matter what. */
625  pDevice->pData->state |= ADI_BEEP_STATE_BLOCKED;
626  wait = true;
627  }
628 
629  ADI_EXIT_CRITICAL_REGION();
630 
631  if(wait == true) {
632  /* Wait for the completion interrupt to post */
633  SEM_PEND(pDevice->pData, ADI_BEEP_SEMAPHORE_FAILED);
634  }
635 
636  return ADI_BEEP_SUCCESS;
637 }
638 
643 void Beep_Int_Handler(void)
644 {
645  ISR_PROLOG();
646 #if ADI_BEEP_INCLUDE_PLAY_SEQUENCE == 1
647  ADI_BEEP_DEV_DATA *pData;
648  ADI_BEEP_NOTE noteA, noteB;
649 #endif
650  ADI_BEEP_DRIVER *pDevice = &adi_beep_Device[ADI_BEEP_DEVID_0]; /* so far, there is only one BEEP, so this is safe */
651  ADI_BEEP_TypeDef *pReg = pDevice->pReg;
652  uint16_t fired = ADI_BEEP_ALL_INTERRUPTS;
653  register uint16_t candidate;
654 
655  /* Make sure our driver is up and running. */
656  if (ADI_BEEP_STATE_UNINITIALIZED != pDevice->pData->state) {
657 
658  /* read both status and mask registers */
659  candidate = pReg->CFG & ADI_BEEP_ALL_INTERRUPTS; /* Take the fired interrupts */
660  fired = candidate; /* ...and a copy. */
661  candidate = candidate & pReg->STAT; /* ...and remove the unused set interrupt bits */
662 
663  /* From this driver's perspective, there are only two states
664  * to watch for - finished playing, or continuing the playing sequence.
665  * Finished will be handled here. */
666  if((candidate & (BITM_BEEP_CFG_SEQATENDIRQ | BITM_BEEP_CFG_AENDIRQ)) > 0u) {
667 
668  /* If we are blocked, unblock by posting the semaphore */
669  if((pDevice->pData->state | ADI_BEEP_STATE_BLOCKED) > 0u) {
670  SEM_POST(pDevice->pData);
671  }
672 
673  /* Reset the device playing status. */
674  pDevice->pData->state &= ~(ADI_BEEP_STATE_PLAYING | ADI_BEEP_STATE_BLOCKED);
675 
676  /* ...and disable the device. */
677  pReg->CFG &= (uint16_t)(~(BITM_BEEP_CFG_EN));
678 
679  /* forward the interrupt to the user if they are watching it and it has fired */
680  /* pass the interrupt as the event. */
681  if (pDevice->pData->cbFunc != NULL) {
682  pDevice->pData->cbFunc (pDevice->pData->cbParam, (uint32_t)candidate, NULL);
683  }
684  }
685 
686  #if ADI_BEEP_INCLUDE_PLAY_SEQUENCE == 1
687  /* The second state is if we are playing a longer sequence, so this
688  * interrupt may be to move the sequence along. */
689  if ((BITM_BEEP_CFG_BSTARTIRQ & candidate) != 0u) {
690 
691  /* Get a local copy of data, to shorten the following code. */
692  pData = pDevice->pData;
693 
694  /* If there's still data to play */
695  if(pData->nSeqIndex < pData->nSeqMax) {
696  /* Move the sequence along.*/
697  noteA = (*pData->pSeqArray)[pData->nSeqIndex];
698  pData->nSeqIndex++;
699  noteB = (*pData->pSeqArray)[pData->nSeqIndex];
700  pData->nSeqIndex++;
701 
702  /* Any values written will not impact the current tones,
703  * they will take effect after the current tone is completed */
704  pReg->TONEA = ( (uint16_t)((uint16_t)noteA.frequency << ADI_BEEP_TONE_FREQ_BITPOS)
705  | (uint16_t)((uint16_t)noteA.duration << ADI_BEEP_TONE_DUR_BITPOS) );
706 
707  pReg->TONEB = ( (uint16_t)((uint16_t)noteB.frequency << ADI_BEEP_TONE_FREQ_BITPOS)
708  | (uint16_t)((uint16_t)noteB.duration << ADI_BEEP_TONE_DUR_BITPOS) );
709  }
710  }
711 #endif
712  }
713 
714  /* clear the watched interrupt(s) that fired */
715  pReg->STAT |= (uint16_t)(fired & ADI_BEEP_ALL_INTERRUPTS); /* only write allowed interrupt bits */
716  ISR_EPILOG();
717 }
721 
722 
723 
ADI_BEEP_RESULT adi_beep_PlayNote(ADI_BEEP_HANDLE const hDevice, ADI_BEEP_NOTE note)
Play a single note/beep.
Definition: adi_beep.c:428
ADI_BEEP_RESULT
Definition: adi_beep.h:45
ADI_BEEP_RESULT adi_beep_Open(ADI_BEEP_DEV_ID const DeviceNum, void *const pMemory, uint32_t const MemorySize, ADI_BEEP_HANDLE *const phDevice)
BEEP Initialization.
Definition: adi_beep.c:161
ADI_BEEP_NOTE_FREQUENCY frequency
Definition: adi_beep.h:204
#define ADI_BEEP_TONEB_FREQUENCY
ADI_BEEP_NOTE_DURATION duration
Definition: adi_beep.h:205
#define ADI_BEEP_TONEA_DURATION
ADI_BEEP_RESULT adi_beep_PlaySequence(ADI_BEEP_HANDLE const hDevice, ADI_BEEP_NOTE aSequence[], uint8_t count)
Play a beeper tone sequence.
Definition: adi_beep.c:345
#define ADI_BEEP_TONEB_DURATION
ADI_BEEP_RESULT adi_beep_PlayTwoTone(ADI_BEEP_HANDLE const hDevice, ADI_BEEP_NOTE noteA, ADI_BEEP_NOTE noteB, uint8_t count)
Play a a repeating two-tone beep. Similar to an alarm.
Definition: adi_beep.c:491
#define ADI_BEEP_CFG_SEQUENCE_REPEAT_VALUE
ADI_BEEP_RESULT adi_beep_Wait(ADI_BEEP_HANDLE const hDevice)
Wait for the current playback to finish. This is a blocking call, that will not return until the curr...
Definition: adi_beep.c:603
void * ADI_BEEP_HANDLE
Definition: adi_beep.h:174
ADI_BEEP_RESULT adi_beep_Close(ADI_BEEP_HANDLE const hDevice)
Uninitialize and deallocate a BEEP device.
Definition: adi_beep.c:238
ADI_BEEP_RESULT adi_beep_RegisterCallback(ADI_BEEP_HANDLE const hDevice, ADI_CALLBACK pfCallback, void *const pCBParam)
Register a callback for the beeper driver.
Definition: adi_beep.c:293
ADI_BEEP_DEV_ID
Beeper Device IDs.
Definition: adi_beep.h:66
#define ADI_BEEP_TONEA_FREQUENCY
#define ADI_BEEP_TONEA_DISABLE
ADI_BEEP_RESULT adi_beep_Enable(ADI_BEEP_HANDLE const hDevice, bool const bFlag)
Enable or disable the beeper. Other APIs will automatically enable the beeper if required,...
Definition: adi_beep.c:552
Beeper note structure.
Definition: adi_beep.h:203
#define ADI_BEEP_TONEB_DISABLE