source: svn/newcon3bcm2_21bu/dta/src/nexus/bsettop_user_io.c @ 76

Last change on this file since 76 was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 10.5 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2012, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile:  $
11 * $brcm_Revision:  $
12 * $brcm_Date: $
13 *
14 * Module Description:
15 *
16 * Revision History:
17 *
18 * $brcm_Log:  $
19 *
20 ***************************************************************************/
21
22#include "nexus_platform.h"
23#include "nexus_ir_input.h"
24#include "bapp_remote.h"
25#include "bos.h"
26#include "bir_codes.h"
27
28BDBG_MODULE(app_remote);                /* Register software module with debug interface */
29
30#define BUSER_IO_NUM_EVENTS     16
31
32#define BUSER_IO_MSG    BDBG_ERR
33
34        /* Convert timeout from milliseconds to ticks */
35#define MAX_TIMEOUT             ((300 * g_ticks_per_second)/ 1000)
36#define DEFAULT_PEND_TIMEOUT    10 /* in milliseconds */
37
38
39static bapp_remote_config_t s_config = { 8, false/*rf4ce*/, true/*ir*/ };
40
41struct bapp_remote
42{
43        /* User IO */
44        NEXUS_IrInputHandle irHandle;   
45        unsigned int    timeout;
46        unsigned int    pend_timeout;
47
48        b_queue_t               queue;
49        b_queue_t               userio_queue;
50        b_event_t               events[BUSER_IO_NUM_EVENTS];
51        b_event_t               userio_events[BUSER_IO_NUM_EVENTS];
52        unsigned int    last_key;
53};
54
55static struct bapp_remote *s_p_remote = NULL;
56static unsigned int bapp_remote_irmap(unsigned int code);
57
58/* User Input API */
59
60void bapp_remote_ircallback(void *pParam, int iParam)
61{
62        size_t numEvents = 1;
63        NEXUS_Error rc = 0;
64        bool overflow;
65        int mapped_code;
66        unsigned int cur_ticks = bos_getticks();
67
68        NEXUS_IrInputHandle irHandle = *(NEXUS_IrInputHandle *)pParam;
69        BSTD_UNUSED(iParam);
70
71        while (numEvents && !rc) {
72                NEXUS_IrInputEvent irEvent;
73                rc = NEXUS_IrInput_GetEvents(irHandle, &irEvent, 1, &numEvents, &overflow);
74                if (numEvents) {
75                        mapped_code = bapp_remote_irmap(irEvent.code & 0xFF);
76                        s_p_remote->last_key = mapped_code;
77                        if (irEvent.repeat == false) {
78                                bos_post_event(s_p_remote->userio_queue, (b_event_t*)(eKEY_DOWN|mapped_code));
79                        }
80                        s_p_remote->timeout = cur_ticks + MS_TO_TICKS(100);
81                }
82        }
83}
84
85/*
86Summary:
87Open a user input object for receiving IR remote and keypad input.
88Description:
89For now, the following id's are used:
900 - remote a
911 - remote b
922 - 56 MHz Sejin IR Keyboard
933 - keypad (TODO implement)
948 - Moto remote, device_type = 0x14
95 */
96bapp_result_t bapp_remote_open(bapp_remote_t *p_remote)
97{
98        NEXUS_IrInputSettings irSettings;
99
100        *p_remote = (struct bapp_remote*)BKNI_Malloc(sizeof(struct bapp_remote)); 
101        if (!*p_remote)
102                return eBAPP_RESULT_ALLOC_FAILURE;
103       
104        BKNI_Memset(*p_remote,0,sizeof(struct bapp_remote));
105
106        bos_create_queue(&(*p_remote)->userio_queue, (*p_remote)->userio_events, BUSER_IO_NUM_EVENTS);
107        if (!(*p_remote)->userio_queue)
108        {
109                bapp_remote_close(*p_remote);
110                return eBAPP_RESULT_ALLOC_FAILURE;
111        }
112
113        bos_create_queue(&(*p_remote)->queue,(*p_remote)->events,BUSER_IO_NUM_EVENTS);
114        if (!(*p_remote)->queue)
115        {
116                bapp_remote_close(*p_remote);
117                return eBAPP_RESULT_ALLOC_FAILURE;
118        }
119
120        NEXUS_IrInput_GetDefaultSettings(&irSettings);
121        irSettings.mode = NEXUS_IrInputMode_eRemoteA;
122        irSettings.dataReady.callback = bapp_remote_ircallback;
123        irSettings.dataReady.context = &(*p_remote)->irHandle;
124        (*p_remote)->irHandle = NEXUS_IrInput_Open(0, &irSettings);
125
126        s_p_remote = *p_remote;
127
128        s_p_remote->pend_timeout = DEFAULT_PEND_TIMEOUT;
129
130        return eBAPP_RESULT_OK;
131}
132
133/*
134Summary:
135Close a user input handle.
136Description:
137Releases all resources associated with the user input object
138 */
139void bapp_remote_close(
140                bapp_remote_t handle /* user input object */
141                )
142{
143        struct bapp_remote *p_remote = (struct bapp_remote*)handle;
144
145        if (p_remote->queue)
146        {
147                bos_delete_queue(&p_remote->queue);
148        }
149        if (p_remote->userio_queue)
150        {
151                bos_delete_queue(&p_remote->userio_queue);
152        }       
153
154        NEXUS_IrInput_Close(handle->irHandle);
155        BKNI_Free(p_remote);
156}
157
158static unsigned int bapp_remote_irmap(unsigned int code)
159{
160        unsigned int mapped_code = 0xFF;
161       
162        if ((code == 0x71) || (code == 0x72))
163        {
164                return code;
165        }
166       
167        switch(s_config.user_io_id)
168        {
169                default:
170                        return code;
171                case 8:
172                        switch (code)
173                {
174                                default: mapped_code = code; break;
175                                case 0x01: mapped_code = eIR_1; break;
176                                case 0x02: mapped_code = eIR_2; break;
177                                case 0x03: mapped_code = eIR_3; break;
178                                case 0x04: mapped_code = eIR_4; break;
179                                case 0x05: mapped_code = eIR_5; break;
180                                case 0x06: mapped_code = eIR_6; break;
181                                case 0x07: mapped_code = eIR_7; break;
182                                case 0x08: mapped_code = eIR_8; break;
183                                case 0x09: mapped_code = eIR_9; break;
184                                case 0x00: mapped_code = eIR_0; break;
185                                case 0x0b: mapped_code = eIR_CH_UP; break;
186                                case 0x0c: mapped_code = eIR_CH_DOWN; break;
187                                /* mute */
188                                case 0x0f: mapped_code = eIR_MUTE; break;
189                                /* + vol */
190                                case 0x0d: mapped_code = eIR_VOL_UP; break;
191                                /* - vol */
192                                case 0x0e: mapped_code = eIR_VOL_DOWN; break;
193                                /* '-' */
194                                case 0x39: mapped_code = eIR_DOT; break;
195                                /* C */
196                                case 0x28: mapped_code = eIR_DEBUG1; break;
197                                /* A */
198                                case 0x17: mapped_code = eIR_LANG; break;
199                                /* B */
200                                case 0x27: mapped_code = eIR_POWER_SAVING; break;
201                                /* exit */
202                                case 0x12: mapped_code = eIR_EXIT; break;
203                                /* menu */
204                                case 0x19:  mapped_code = eIR_MENU; break;
205                                /* arrow buttons */
206                                case 0x34: mapped_code = eIR_UP; break;
207                                case 0x35: mapped_code = eIR_DOWN; break;
208                                case 0x36: mapped_code = eIR_LEFT; break;
209                                case 0x37: mapped_code = eIR_RIGHT; break;
210                                /* select or OK */
211                                case 0x11: mapped_code = eIR_SELECT; break;
212                                case 0x33: mapped_code = eIR_INFO; break;
213                                case 0x30: mapped_code = eIR_GUIDE; break;
214                                case 0x13: mapped_code =  eIR_PRECH; break;
215                                /* power */
216                                case 0x0a: mapped_code = eIR_POWER; break;
217                                /* help */
218                                case 0x32:  mapped_code = eIR_HELP; break;
219                                /* FAV */
220                                case 0x15:  mapped_code = eIR_FAV; break;
221                        }
222                break;
223        }
224        return mapped_code;
225}
226
227/*
228Summary:
229        Map key codes to match type 0
230 */
231static unsigned int bapp_remote_map( unsigned int code )
232{
233        unsigned int mapped_code = 0xFF;
234        BDBG_ERR(("############### %s, code = 0x%08x\n",__FUNCTION__,code));
235        code &= 0x000000FF;
236        switch (code)
237        {
238                default: mapped_code = code; break;
239
240                case 0x09:  mapped_code = eIR_MENU; break;
241                case 0x37:  mapped_code = eIR_PGUP; break;
242                case 0x38:  mapped_code = eIR_PGDOWN; break;
243                case 0x0d:  mapped_code = eIR_EXIT; break;
244                case 0x4c:  mapped_code = eIR_PRECH; break; /* TODO: */
245#if 0
246                case 0x74:  mapped_code = eIR_A; break;
247                case 0x71:  mapped_code = eIR_B; break;
248                case 0x72:  mapped_code = eIR_C; break;
249                case 0x73:  mapped_code = eIR_D; break;
250#endif
251                case 0x00:  mapped_code = eIR_SELECT; break;
252                case 0x01:  mapped_code = eIR_UP; break;
253                case 0x02:  mapped_code = eIR_DOWN; break;
254                case 0x03:  mapped_code = eIR_LEFT; break;
255                case 0x04:  mapped_code = eIR_RIGHT; break;
256                case 0x0b:  mapped_code = eIR_GUIDE; break;
257                case 0x6b:  mapped_code = eIR_POWER; break;
258
259                case 0x21:  mapped_code = eIR_1; break;
260                case 0x22:  mapped_code = eIR_2; break;
261                case 0x23:  mapped_code = eIR_3; break;
262                case 0x24:  mapped_code = eIR_4; break;
263                case 0x25:  mapped_code = eIR_5; break;
264                case 0x26:  mapped_code = eIR_6; break;
265                case 0x27:  mapped_code = eIR_7; break;
266                case 0x28:  mapped_code = eIR_8; break;
267                case 0x29:  mapped_code = eIR_9; break;
268                case 0x20:  mapped_code = eIR_0; break;
269
270                case 0x30:  mapped_code = eIR_CH_UP; break;
271                case 0x31:  mapped_code = eIR_CH_DOWN; break;
272
273                                /* mute */
274                case 0x43:  mapped_code = eIR_MUTE; break;
275
276                                /* + vol */
277                case 0x41:  mapped_code = eIR_VOL_UP; break;
278
279                                /* - vol */
280                case 0x42:  mapped_code = eIR_VOL_DOWN; break;
281
282                                /* exit */
283                case 0x2a:  mapped_code = eIR_EXIT; break;
284                case 0x2b:  mapped_code = eIR_SELECT; break;
285
286                case 0x35:  mapped_code = eIR_INFO; break;
287                case 0x32:  mapped_code =  eIR_PRECH; break;
288
289                                /* power off/on */
290                case 0x6c:
291                case 0x6d:
292                                 mapped_code = eIR_POWER; break;
293
294                                /* help */
295                case 0x56:  mapped_code = eIR_HELP; break;
296
297                                /* FAV */
298                case 0x52:  mapped_code = eIR_FAV; break;
299                case 0xfd:  mapped_code = eIR_LANG; break;
300        }
301        return mapped_code;
302}
303
304/*
305Summary:
306map gpio based buttons to key code based on current IR remote protocol used
307
308 */
309static unsigned int bapp_remote_map_code(
310        bapp_remote_t handle, /* user input object */
311        unsigned int button_id)
312{
313        BSTD_UNUSED(handle);
314        return bapp_remote_map(button_id);
315}
316
317/*
318Summary:
319Read events from a user input device.
320
321Description:
322Because this function does not return a void* to raw data, but an array of structures,
323it is not called buser_input_read.
324 */
325bapp_result_t bapp_remote_get_event(
326                bapp_remote_t handle, /* user input object */
327                bapp_event_t *p_event /* [out] event from the user input device */
328                )
329{
330        uint32_t pend_event;
331        bapp_result_t result = eBAPP_RESULT_BUSY;
332        struct bapp_remote *p_remote = (struct bapp_remote*)handle; 
333        unsigned int cur_ticks = bos_getticks();
334
335        /* check first IR remote  (10ms timeout is consumed) */
336        pend_event = (unsigned int)bos_pend_event(p_remote->userio_queue, p_remote->pend_timeout);
337        if (pend_event)
338        {
339                p_event->code = (pend_event & 0xFF);
340                if (pend_event & eKEY_UP) {
341                        p_event->code |= eKEY_UP;
342                }
343                return eBAPP_RESULT_OK;
344        }
345        else if (s_p_remote->timeout && (cur_ticks > s_p_remote->timeout))
346        {
347                bos_post_event(s_p_remote->userio_queue, (b_event_t *)(eKEY_UP|s_p_remote->last_key));
348                s_p_remote->timeout = 0;
349                return eBAPP_RESULT_BUSY;
350        }
351
352        /* for RF4CE remote */
353        pend_event = (unsigned int)bos_pend_event(p_remote->queue,p_remote->pend_timeout);
354
355        if (pend_event)
356        {
357                if (!s_config.use_rf4ce) 
358                        return eBAPP_RESULT_TIMEOUT;
359
360                BDBG_ERR(("%s, pend_event = 0x%08x\n",__FUNCTION__,pend_event));
361               
362                p_event->code = pend_event & 0xFF;
363
364                if (!(pend_event & eKEY_CMD))
365                {
366                        p_event->code = bapp_remote_map_code(handle,p_event->code);
367                }
368
369                if (pend_event & eKEY_UP)
370                        p_event->code |= eKEY_UP;
371                result = eBAPP_RESULT_OK;
372                BUSER_IO_MSG(("%s, event = 0x%08x\n",__FUNCTION__,p_event->code));
373        }
374
375        return result;
376}
377
378void bapp_remote_set_config(
379                                                bapp_remote_config_t *p_config
380                                                )
381{
382        BKNI_Memcpy(&s_config,p_config,sizeof(s_config));
383}
384void bapp_remote_get_config(
385                                                bapp_remote_config_t *p_config
386                                                )
387{
388        BKNI_Memcpy(p_config,&s_config,sizeof(s_config));
389}
390
391void bapp_remote_post_event(uint32_t code,uint8_t modifier)
392{
393        if (s_p_remote && s_p_remote->queue)
394        {
395                if (modifier == 0x01)
396                        bos_post_event(s_p_remote->queue,(b_event_t*)(eKEY_DOWN | code));
397                else
398                        bos_post_event(s_p_remote->queue,(b_event_t*)(eKEY_UP | code));
399        }
400}
401
402void buser_input_sim_key(uint32_t code)
403{
404    bapp_remote_post_event(code, 0);
405
406}       
Note: See TracBrowser for help on using the repository browser.