1/*----------------------------------------------------------------------------
2 *
3 * File:
4 * eas_host.c
5 *
6 * Contents and purpose:
7 * This file contains the host wrapper functions for stdio, stdlib, etc.
8 * This is a sample version that wraps the standard library functions.
9 * Modify this file to suit the needs of your particular system.
10 *
11 * EAS_MAX_FILE_HANDLES sets the maximum number of MIDI streams within
12 * a MIDI type 1 file that can be played. To maintain efficiency, data
13 * is buffered locally when byte access is used (EAS_HWGetByte). The
14 * size of the buffer is set by EAS_FILE_BUFFER_SIZE.
15 *
16 * EAS_HW_FILE is a structure to support local file buffering. It
17 * comprises the OS File handle, some data related to the local file
18 * buffer, the position of the next byte of data to be read, the dup
19 * flag which when set, indicates that the handle has been duplicated,
20 * and the data buffer. Since the data buffer is only used for byte
21 * access, it does not need to be large.
22 *
23 * If the file system supports duplicate file handles and buffering,
24 * this entire subsystem can be replaced with direct calls to the
25 * native file I/O routines.
26 *
27 * If the system has enough memory to support reading the entire file
28 * into memory, it will be much more efficient to do so on the call to
29 * EAS_HWOpenFile and then close the file. Simply substitute a memory
30 * pointer for the FILE* pointer. Calls to EAS_HW_DupHandle will work
31 * as they do in this version. In the call to EAS_HWCloseFile, instead
32 * of calling fclose, free the memory containing the file data.
33 *
34 * Copyright 2005 Sonic Network Inc.
35
36 * Licensed under the Apache License, Version 2.0 (the "License");
37 * you may not use this file except in compliance with the License.
38 * You may obtain a copy of the License at
39 *
40 *      http://www.apache.org/licenses/LICENSE-2.0
41 *
42 * Unless required by applicable law or agreed to in writing, software
43 * distributed under the License is distributed on an "AS IS" BASIS,
44 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
45 * See the License for the specific language governing permissions and
46 * limitations under the License.
47 *
48 *----------------------------------------------------------------------------
49 * Revision Control:
50 *   $Revision: 853 $
51 *   $Date: 2007-09-05 09:54:17 -0700 (Wed, 05 Sep 2007) $
52 *----------------------------------------------------------------------------
53*/
54
55#ifdef _lint
56#include "lint_stdlib.h"
57#else
58#include <stdio.h>
59#include <stdlib.h>
60#include <string.h>
61#endif
62
63#include "eas_host.h"
64
65// #define DEBUG_FILE_IO
66
67/* Only for debugging LED, vibrate, and backlight functions */
68#include "eas_report.h"
69
70#ifndef EAS_MAX_FILE_HANDLES
71#define EAS_MAX_FILE_HANDLES    32
72#endif
73
74#ifndef EAS_FILE_BUFFER_SIZE
75#define EAS_FILE_BUFFER_SIZE    32
76#endif
77
78/*
79 * this structure and the related function are here
80 * to support the ability to create duplicate handles
81 * and buffering into a single file. If the OS supports
82 * duplicate file handles natively, this code can be
83 * stripped to eliminate double-buffering.
84 */
85typedef struct eas_hw_file_tag
86{
87    FILE *pFile;
88    EAS_I32 bytesInBuffer;
89    EAS_I32 readIndex;
90    EAS_I32 filePos;
91    EAS_BOOL dup;
92    EAS_U8 buffer[EAS_FILE_BUFFER_SIZE];
93} EAS_HW_FILE;
94
95typedef struct eas_hw_inst_data_tag
96{
97    EAS_HW_FILE files[EAS_MAX_FILE_HANDLES];
98} EAS_HW_INST_DATA;
99
100/* local memory for files and streams */
101#ifdef _STATIC_MEMORY
102EAS_HW_INST_DATA fileData;
103#endif
104
105/*----------------------------------------------------------------------------
106 * EAS_HWInit
107 *
108 * Initialize host wrapper interface
109 *
110 *----------------------------------------------------------------------------
111*/
112EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)
113{
114
115    /* need to track file opens for duplicate handles */
116#ifndef _STATIC_MEMORY
117    *pHWInstData = malloc(sizeof(EAS_HW_INST_DATA));
118    if (!(*pHWInstData))
119        return EAS_ERROR_MALLOC_FAILED;
120#else
121    *pHWInstData = &fileData;
122#endif
123    EAS_HWMemSet(*pHWInstData, 0, sizeof(EAS_HW_INST_DATA));
124    return EAS_SUCCESS;
125}
126
127/*----------------------------------------------------------------------------
128 * EAS_HWShutdown
129 *
130 * Shut down host wrapper interface
131 *
132 *----------------------------------------------------------------------------
133*/
134/*lint -esym(715, hwInstData) hwInstData available for customer use */
135EAS_RESULT EAS_HWShutdown (EAS_HW_DATA_HANDLE hwInstData)
136{
137
138#ifndef _STATIC_MEMORY
139    free(hwInstData);
140#endif
141    return EAS_SUCCESS;
142}
143
144/*----------------------------------------------------------------------------
145 *
146 * EAS_HWMalloc
147 *
148 * Allocates dynamic memory
149 *
150 *----------------------------------------------------------------------------
151*/
152/*lint -esym(715, hwInstData) hwInstData available for customer use */
153#ifdef _STATIC_MEMORY
154/*lint -esym(715, size) not used in static memory model */
155#endif
156void *EAS_HWMalloc (EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size)
157{
158#ifdef _STATIC_MEMORY
159    return NULL;
160#else
161    return malloc((EAS_U32)size);
162#endif
163}
164
165/*----------------------------------------------------------------------------
166 *
167 * EAS_HWFree
168 *
169 * Frees dynamic memory
170 *
171 *----------------------------------------------------------------------------
172*/
173/*lint -esym(715, hwInstData) hwInstData available for customer use */
174#ifdef _STATIC_MEMORY
175/*lint -esym(715, p) not used in static memory model */
176#endif
177void EAS_HWFree(EAS_HW_DATA_HANDLE hwInstData, void *p)
178{
179#ifndef _STATIC_MEMORY
180    free(p);
181#endif
182}
183
184/*----------------------------------------------------------------------------
185 *
186 * EAS_HWMemCpy
187 *
188 * Copy memory wrapper
189 *
190 *----------------------------------------------------------------------------
191*/
192void *EAS_HWMemCpy (void *dest, const void *src, EAS_I32 amount)
193{
194    return memcpy(dest,src,(size_t) amount);
195}
196
197/*----------------------------------------------------------------------------
198 *
199 * EAS_HWMemSet
200 *
201 * Set memory wrapper
202 *
203 *----------------------------------------------------------------------------
204*/
205void *EAS_HWMemSet (void *dest, int val, EAS_I32 amount)
206{
207    return memset(dest,val,(size_t) amount);
208}
209
210/*----------------------------------------------------------------------------
211 *
212 * EAS_HWMemCmp
213 *
214 * Compare memory wrapper
215 *
216 *----------------------------------------------------------------------------
217*/
218EAS_I32 EAS_HWMemCmp (const void *s1, const void *s2, EAS_I32 amount)
219{
220    return (EAS_I32) memcmp(s1, s2, (size_t) amount);
221}
222
223/*----------------------------------------------------------------------------
224 *
225 * EAS_HWOpenFile
226 *
227 * Open a file for read or write
228 *
229 *----------------------------------------------------------------------------
230*/
231EAS_RESULT EAS_HWOpenFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_LOCATOR locator, EAS_FILE_HANDLE *pFile, EAS_FILE_MODE mode)
232{
233    EAS_HW_FILE *file;
234    int i;
235
236    /* set return value to NULL */
237    *pFile = NULL;
238
239    /* only support read mode at this time */
240    if (mode != EAS_FILE_READ)
241        return EAS_ERROR_INVALID_FILE_MODE;
242
243    /* find an empty entry in the file table */
244    file = hwInstData->files;
245    for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
246    {
247        /* is this slot being used? */
248        if (file->pFile == NULL)
249        {
250            /* open the file */
251            if (locator->path)
252                file->pFile = fopen((const char*) locator->path, "rb");
253            if (file->pFile == NULL)
254                return EAS_ERROR_FILE_OPEN_FAILED;
255
256#ifdef DEBUG_FILE_IO
257            EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWOpenFile: Open file %d\n", i);
258#endif
259
260            /* initialize some values */
261            file->bytesInBuffer = 0;
262            file->readIndex = 0;
263            file->filePos = 0;
264            file->dup = EAS_FALSE;
265
266            *pFile = file;
267            return EAS_SUCCESS;
268        }
269        file++;
270    }
271
272    /* too many open files */
273    return EAS_ERROR_MAX_FILES_OPEN;
274}
275
276/*----------------------------------------------------------------------------
277 *
278 * EAS_HWFillBuffer
279 *
280 * Fill buffer from file
281 *----------------------------------------------------------------------------
282*/
283/*lint -esym(715, hwInstData) hwInstData available for customer use */
284EAS_RESULT EAS_HWFillBuffer (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file)
285{
286    /* reposition the file pointer */
287    if (fseek(file->pFile, file->filePos, SEEK_SET) != 0)
288        return EAS_ERROR_FILE_SEEK;
289
290    /* read some data from the file */
291    file->bytesInBuffer = (EAS_I32) fread(file->buffer, 1, EAS_FILE_BUFFER_SIZE, file->pFile);
292    file->readIndex = 0;
293    if (file->bytesInBuffer == 0)
294        return EAS_EOF;
295    return EAS_SUCCESS;
296}
297
298/*----------------------------------------------------------------------------
299 *
300 * EAS_HWReadFile
301 *
302 * Read data from a file
303 *----------------------------------------------------------------------------
304*/
305/*lint -esym(715, hwInstData) hwInstData available for customer use */
306EAS_RESULT EAS_HWReadFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *pBuffer, EAS_I32 n, EAS_I32 *pBytesRead)
307{
308    EAS_RESULT result;
309    EAS_I32 temp;
310    EAS_U8 *p = pBuffer;
311    EAS_I32 bytesLeft = n;
312
313    *pBytesRead = 0;
314
315    /* check handle integrity */
316    if (file->pFile == NULL)
317        return EAS_ERROR_INVALID_HANDLE;
318
319#ifdef DEBUG_FILE_IO
320    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWReadFile: Reading %d bytes from position %d\n", n, file->filePos);
321#endif
322
323    /* try to fulfill request from buffer */
324    for (;bytesLeft > 0;)
325    {
326        /* how many bytes can we get from buffer? */
327        temp = file->bytesInBuffer - file->readIndex;
328        if (temp > bytesLeft)
329            temp = bytesLeft;
330
331        /* copy data from buffer */
332        EAS_HWMemCpy(p, &file->buffer[file->readIndex], temp);
333        *pBytesRead += temp;
334        file->readIndex += temp;
335        file->filePos += temp;
336        bytesLeft -= temp;
337        p += temp;
338
339        /* don't refill buffer if request is bigger than buffer */
340        if ((bytesLeft == 0) || (bytesLeft >= EAS_FILE_BUFFER_SIZE))
341            break;
342
343        /* refill buffer */
344        if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)
345            return result;
346    }
347
348    /* more to read? do unbuffered read directly to target memory */
349    if (bytesLeft)
350    {
351
352        /* position the file pointer */
353        if (fseek(file->pFile, file->filePos, SEEK_SET) != 0)
354            return EAS_ERROR_FILE_SEEK;
355
356        /* read data in the buffer */
357        /*lint -e{826} lint doesn't like this with STATIC_MEMORY defined for some reason */
358        temp = (EAS_I32) fread(p, 1, (size_t) bytesLeft, file->pFile);
359        *pBytesRead += temp;
360        file->filePos += temp;
361
362        /* reset buffer info */
363        file->bytesInBuffer = 0;
364        file->readIndex = 0;
365    }
366
367#ifdef DEBUG_FILE_IO
368    {
369#define BYTES_PER_LINE 16
370        char str[BYTES_PER_LINE * 3 + 1];
371        EAS_INT i;
372        for (i = 0; i < (n > BYTES_PER_LINE ? BYTES_PER_LINE : n) ; i ++)
373            sprintf(&str[i*3], "%02x ", ((EAS_U8*)pBuffer)[i]);
374        if (i)
375            EAS_ReportX(_EAS_SEVERITY_NOFILTER, "%s\n", str);
376    }
377#endif
378
379    /* were n bytes read? */
380    if (*pBytesRead != n)
381        return EAS_EOF;
382
383    return EAS_SUCCESS;
384}
385
386/*----------------------------------------------------------------------------
387 *
388 * EAS_HWGetByte
389 *
390 * Read a byte from a file
391 *----------------------------------------------------------------------------
392*/
393/*lint -esym(715, hwInstData) hwInstData available for customer use */
394EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
395{
396    EAS_RESULT result;
397
398    /* check handle integrity */
399    if (file->pFile == NULL)
400        return EAS_ERROR_INVALID_HANDLE;
401
402    /* use local buffer - do we have any data? */
403    if (file->readIndex >= file->bytesInBuffer)
404    {
405        if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)
406            return result;
407
408        /* if nothing to read, return EOF */
409        if (file->bytesInBuffer == 0)
410            return EAS_EOF;
411    }
412
413    /* get a character from the buffer */
414    *((EAS_U8*) p) = file->buffer[file->readIndex++];
415
416#ifdef DEBUG_FILE_IO
417    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetByte: Reading from position %d, byte = 0x%02x\n", file->filePos, *(EAS_U8*)p);
418#endif
419
420    file->filePos++;
421    return EAS_SUCCESS;
422}
423
424/*----------------------------------------------------------------------------
425 *
426 * EAS_HWGetWord
427 *
428 * Read a 16-bit value from the file
429 *----------------------------------------------------------------------------
430*/
431EAS_RESULT EAS_HWGetWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
432{
433    EAS_RESULT result;
434    EAS_I32 count;
435    EAS_U8 c[2];
436
437#ifdef DEBUG_FILE_IO
438    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetWord: Reading 2 bytes from position %d\n", file->filePos);
439#endif
440
441    /* read 2 bytes from the file */
442    if ((result = EAS_HWReadFile(hwInstData, file, c, 2, &count)) != EAS_SUCCESS)
443        return result;
444
445    /* order them as requested */
446    if (msbFirst)
447        *((EAS_U16*) p) = ((EAS_U16) c[0] << 8) | c[1];
448    else
449        *((EAS_U16*) p) = ((EAS_U16) c[1] << 8) | c[0];
450
451    return EAS_SUCCESS;
452}
453
454/*----------------------------------------------------------------------------
455 *
456 * EAS_HWGetDWord
457 *
458 * Read a 16-bit value from the file
459 *----------------------------------------------------------------------------
460*/
461EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
462{
463    EAS_RESULT result;
464    EAS_I32 count;
465    EAS_U8 c[4];
466
467#ifdef DEBUG_FILE_IO
468    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetDWord: Reading 4 bytes from position %d\n", file->filePos);
469#endif
470
471    /* read 4 bytes from the file */
472    if ((result = EAS_HWReadFile(hwInstData, file, c, 4, &count)) != EAS_SUCCESS)
473        return result;
474
475    /* order them as requested */
476    if (msbFirst)
477        *((EAS_U32*) p) = ((EAS_U32) c[0] << 24) | ((EAS_U32) c[1] << 16) | ((EAS_U32) c[2] << 8) | c[3];
478    else
479        *((EAS_U32*) p) = ((EAS_U32) c[3] << 24) | ((EAS_U32) c[2] << 16) | ((EAS_U32) c[1] << 8) | c[0];
480
481    return EAS_SUCCESS;
482}
483
484/*----------------------------------------------------------------------------
485 *
486 * EAS_HWFilePos
487 *
488 * Returns the current location in the file
489 *
490 *----------------------------------------------------------------------------
491*/
492/*lint -esym(715, hwInstData) hwInstData available for customer use */
493EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)
494{
495
496    /* check handle integrity */
497    if (file->pFile == NULL)
498        return EAS_ERROR_INVALID_HANDLE;
499
500    *pPosition = file->filePos;
501    return EAS_SUCCESS;
502}
503
504/*----------------------------------------------------------------------------
505 *
506 * EAS_HWFileSeek
507 *
508 * Seek to a specific location in the file
509 *
510 *----------------------------------------------------------------------------
511*/
512/*lint -esym(715, hwInstData) hwInstData available for customer use */
513EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
514{
515    EAS_I32 newIndex;
516
517    /* check handle integrity */
518    if (file->pFile == NULL)
519        return EAS_ERROR_INVALID_HANDLE;
520
521#ifdef DEBUG_FILE_IO
522    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeek: Seeking to new position %d\n", file->filePos);
523#endif
524
525    /* is new position in current buffer? */
526    newIndex = position - file->filePos + file->readIndex;
527    if ((newIndex >= 0) && (newIndex < file->bytesInBuffer))
528    {
529        file->readIndex = newIndex;
530        file->filePos = position;
531        return EAS_SUCCESS;
532    }
533
534    /* save new position and reset buffer info so EAS_HWGetByte doesn't fail */
535    file->filePos = position;
536    file->bytesInBuffer = 0;
537    file->readIndex = 0;
538    return EAS_SUCCESS;
539}
540
541/*----------------------------------------------------------------------------
542 *
543 * EAS_HWFileSeekOfs
544 *
545 * Seek forward or back relative to the current position
546 *
547 *----------------------------------------------------------------------------
548*/
549/*lint -esym(715, hwInstData) hwInstData available for customer use */
550EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
551{
552    EAS_I32 temp;
553
554#ifdef DEBUG_FILE_IO
555    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeekOfs: Seeking to new position %d\n", file->filePos + position);
556#endif
557
558    /* check handle integrity */
559    if (file->pFile == NULL)
560        return EAS_ERROR_INVALID_HANDLE;
561
562    /* is new position in current buffer? */
563    temp = position + file->readIndex;
564    if ((temp >= 0) && (temp < file->bytesInBuffer))
565    {
566        file->readIndex = temp;
567        file->filePos += position;
568        return EAS_SUCCESS;
569    }
570
571    /* save new position and reset buffer info so EAS_HWGetByte doesn't fail */
572    file->filePos += position;
573    file->bytesInBuffer = 0;
574    file->readIndex = 0;
575    return EAS_SUCCESS;
576}
577
578/*----------------------------------------------------------------------------
579 *
580 * EAS_HWFileLength
581 *
582 * Return the file length
583 *
584 *----------------------------------------------------------------------------
585*/
586/*lint -esym(715, hwInstData) hwInstData available for customer use */
587EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)
588{
589    long pos;
590
591    /* check handle integrity */
592    if (file->pFile == NULL)
593        return EAS_ERROR_INVALID_HANDLE;
594
595    if ((pos = ftell(file->pFile)) == -1L)
596        return EAS_ERROR_FILE_LENGTH;
597    if (fseek(file->pFile, 0L, SEEK_END) != 0)
598        return EAS_ERROR_FILE_LENGTH;
599    if ((*pLength = ftell(file->pFile)) == -1L)
600        return EAS_ERROR_FILE_LENGTH;
601    if (fseek(file->pFile, pos, SEEK_SET) != 0)
602        return EAS_ERROR_FILE_LENGTH;
603    return EAS_SUCCESS;
604}
605
606/*----------------------------------------------------------------------------
607 *
608 * EAS_HWDupHandle
609 *
610 * Duplicate a file handle
611 *
612 *----------------------------------------------------------------------------
613*/
614EAS_RESULT EAS_HWDupHandle (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_FILE_HANDLE* pDupFile)
615{
616    EAS_HW_FILE *dupfile;
617    int i;
618
619    /* check handle integrity */
620    *pDupFile = NULL;
621    if (file->pFile == NULL)
622        return EAS_ERROR_INVALID_HANDLE;
623
624    /* find an empty entry in the file table */
625    dupfile = hwInstData->files;
626    for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
627    {
628        /* is this slot being used? */
629        if (dupfile->pFile == NULL)
630        {
631
632            /* copy info from the handle to be duplicated */
633            dupfile->filePos = file->filePos;
634            dupfile->pFile = file->pFile;
635
636            /* set the duplicate handle flag */
637            dupfile->dup = file->dup = EAS_TRUE;
638
639            /* initialize some values */
640            dupfile->bytesInBuffer = 0;
641            dupfile->readIndex = 0;
642
643            *pDupFile = dupfile;
644            return EAS_SUCCESS;
645        }
646        dupfile++;
647    }
648
649    /* too many open files */
650    return EAS_ERROR_MAX_FILES_OPEN;
651}
652
653/*----------------------------------------------------------------------------
654 *
655 * EAS_HWClose
656 *
657 * Wrapper for fclose function
658 *
659 *----------------------------------------------------------------------------
660*/
661EAS_RESULT EAS_HWCloseFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file1)
662{
663    EAS_HW_FILE *file2,*dupFile;
664    int i;
665
666    /* check handle integrity */
667    if (file1->pFile == NULL)
668        return EAS_ERROR_INVALID_HANDLE;
669
670    /* check for duplicate handle */
671    if (file1->dup)
672    {
673        dupFile = NULL;
674        file2 = hwInstData->files;
675        for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
676        {
677            /* check for duplicate */
678            if ((file1 != file2) && (file2->pFile == file1->pFile))
679            {
680                /* is there more than one duplicate? */
681                if (dupFile != NULL)
682                {
683                    /* clear this entry and return */
684                    file1->pFile = NULL;
685                    return EAS_SUCCESS;
686                }
687
688                /* this is the first duplicate found */
689                dupFile = file2;
690            }
691            file2++;
692        }
693
694        /* there is only one duplicate, clear the dup flag */
695        if (dupFile)
696            dupFile->dup = EAS_FALSE;
697        else
698            /* if we get here, there's a serious problem */
699            return EAS_ERROR_HANDLE_INTEGRITY;
700
701        /* clear this entry and return */
702        file1->pFile = NULL;
703        return EAS_SUCCESS;
704    }
705
706    /* no duplicates - close the file */
707    if (fclose(file1->pFile) != 0)
708        return EAS_ERROR_CLOSE_FAILED;
709
710    /* clear this entry and return */
711    file1->pFile = NULL;
712    return EAS_SUCCESS;
713}
714
715/*----------------------------------------------------------------------------
716 *
717 * EAS_HWVibrate
718 *
719 * Turn on/off vibrate function
720 *
721 *----------------------------------------------------------------------------
722*/
723/*lint -esym(715, hwInstData) hwInstData available for customer use */
724EAS_RESULT EAS_HWVibrate (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
725{
726    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Vibrate state: %d\n", state);
727    return EAS_SUCCESS;
728}
729
730/*----------------------------------------------------------------------------
731 *
732 * EAS_HWLED
733 *
734 * Turn on/off LED
735 *
736 *----------------------------------------------------------------------------
737*/
738/*lint -esym(715, hwInstData) hwInstData available for customer use */
739EAS_RESULT EAS_HWLED (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
740{
741    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "LED state: %d\n", state);
742    return EAS_SUCCESS;
743}
744
745/*----------------------------------------------------------------------------
746 *
747 * EAS_HWBackLight
748 *
749 * Turn on/off backlight
750 *
751 *----------------------------------------------------------------------------
752*/
753/*lint -esym(715, hwInstData) hwInstData available for customer use */
754EAS_RESULT EAS_HWBackLight (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
755{
756    EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Backlight state: %d\n", state);
757    return EAS_SUCCESS;
758}
759
760/*----------------------------------------------------------------------------
761 *
762 * EAS_HWYield
763 *
764 * This function is called periodically by the EAS library to give the
765 * host an opportunity to allow other tasks to run. There are two ways to
766 * use this call:
767 *
768 * If you have a multi-tasking OS, you can call the yield function in the
769 * OS to allow other tasks to run. In this case, return EAS_FALSE to tell
770 * the EAS library to continue processing when control returns from this
771 * function.
772 *
773 * If tasks run in a single thread by sequential function calls (sometimes
774 * call a "commutator loop"), return EAS_TRUE to cause the EAS Library to
775 * return to the caller. Be sure to check the number of bytes rendered
776 * before passing the audio buffer to the codec - it may not be filled.
777 * The next call to EAS_Render will continue processing until the buffer
778 * has been filled.
779 *
780 *----------------------------------------------------------------------------
781*/
782/*lint -esym(715, hwInstData) hwInstData available for customer use */
783EAS_BOOL EAS_HWYield (EAS_HW_DATA_HANDLE hwInstData)
784{
785    /* put your code here */
786    return EAS_FALSE;
787}
788