source: titan/titan/cec.h @ 40434

Last change on this file since 40434 was 40434, checked in by gost, 6 years ago

[titan] mipsel/arm next fix cec

  • Property svn:executable set to *
File size: 20.2 KB
Line 
1#ifndef CEC_H
2#define CEC_H
3
4int cecon = 0;
5struct stimerthread* hdmiEventthread = NULL;
6
7
8void sendName(unsigned char address)
9{
10        unsigned char cmd = 0x47;
11        char data[16] = "TitanNit";
12       
13        data[8] = '\0';
14        sendMessage(address, cmd, data, strlen(data));
15
16}
17
18void sendMenuInfo(unsigned char address)
19{
20        unsigned char cmd = 0x8e;
21        char data[2];
22               
23        data[0] = 0x00;
24        if(status.standby > 0 || getconfigint("cec_menue", NULL) == 0)
25                data[0] = 0x01;
26        data[1] = '\0';
27        sendMessage(address, cmd, data, 1);
28}
29
30void sendVendorid(unsigned char address)
31{
32        unsigned char cmd = 0x87;
33        char data[4];
34       
35        data[0] = 0x00;
36        data[1] = 0x00;
37        data[2] = 0x00;
38        data[3] = '\0';
39        sendMessage(address, cmd, data, 3);
40}
41
42void sendSource(unsigned char address)
43{
44        unsigned char cmd = 0x82;
45        char data[4];
46       
47        data[0] = cec_physicalAddress[0];
48        data[1] = cec_physicalAddress[1];
49        data[2] = '\0';
50        sendMessage(address, cmd, data, 2);
51}
52
53void sendVersion(unsigned char address)
54{
55        unsigned char cmd = 0x9e;
56        char data[4];
57       
58        data[0] = 0x01;
59        data[1] = '\0';
60        sendMessage(address, cmd, data, 2);
61}
62
63void sendTVon()
64{
65        char data[3];
66        unsigned char address = 0x00;
67        unsigned char cmd = 0x04;
68        data[0] = '\0';
69        sendMessage(address, cmd, data, 0);
70}
71
72void sendswitch()
73{       
74        char data[3];
75        unsigned char address = 0x0f;
76        unsigned char cmd = 0x82;
77        data[0] = cec_physicalAddress[0];
78        data[1] = cec_physicalAddress[1];
79        data[2] = '\0';
80        //if(getconfigint("cec_tv_switch", NULL) == 1)
81        sendMessage(address, cmd, data, 2);
82}
83
84int translateKey(unsigned char code)
85{
86        int key = 0;
87        switch (code)
88        {
89                case 0x09:
90                        key = 0x8b;
91                        break;
92                case 0x0A:
93                        key = 0x18e;
94                        break;
95                case 0x0B:
96                        key = 0x166;
97                        break;
98                case 0x32:
99                        key = 0x8b;
100                        break;
101                case 0x20:
102                        key = 0x0b;
103                        break;
104                case 0x21:
105                        key = 0x02;
106                        break;
107                case 0x22:
108                        key = 0x03;
109                        break;
110                case 0x23:
111                        key = 0x04;
112                        break;
113                case 0x24:
114                        key = 0x05;
115                        break;
116                case 0x25:
117                        key = 0x06;
118                        break;
119                case 0x26:
120                        key = 0x07;
121                        break;
122                case 0x27:
123                        key = 0x08;
124                        break;
125                case 0x28:
126                        key = 0x09;
127                        break;
128                case 0x29:
129                        key = 0x0a;
130                        break;
131                case 0x30:
132                        key = 0x192;
133                        break;
134                case 0x31:
135                        key = 0x193;
136                        break;
137                case 0x44:
138                        key = 0xcf;
139                        break;
140                case 0x45:
141                        key = 0x80;
142                        break;
143                case 0x46:
144                        key = 0x77;
145                        break;
146                case 0x47:
147                        key = 0xa7;
148                        break;
149                case 0x48:
150                        key = 0xa8;
151                        break;
152                case 0x49:
153                        key = 0xd0;
154                        break;
155                case 0x53:
156                        key = 0x166;
157                        break;
158                case 0x54:
159                        key = 0x16a;
160                        break;
161                case 0x60:
162                        key = 0xcf;
163                        break;
164                case 0x61:
165                        key = 0xa4;
166                        break;
167                case 0x62:
168                        key = 0xa7;
169                        break;
170                case 0x64:
171                        key = 0x80;
172                        break;
173                case 0x00:
174                        key = 0x160;
175                        break;
176                case 0x03:
177                        key = 0x69;
178                        break;
179                case 0x04:
180                        key = 0x6a;
181                        break;
182                case 0x01:
183                        key = 0x67;
184                        break;
185                case 0x02:
186                        key = 0x6c;
187                        break;
188                case 0x0d:
189                        key = 0xae;
190                        break;
191                case 0x72:
192                        key = 0x18e;
193                        break;
194                case 0x71:
195                        key = 0x191;
196                        break;
197                case 0x73:
198                        key = 0x18f;
199                        break;
200                case 0x74:
201                        key = 0x190;
202                        break;
203                default:
204                        key = 0x8b;
205                        break;
206        }
207        return key;
208}
209       
210void setVolumeForward()
211{
212        unsigned char address = 0x00;
213        unsigned char cmd = 0x7d;
214        char data[2];
215        data[0] = '\0';
216       
217        addconfiginttmp("ForwardVolume", 1);
218        data[0] = '\0';
219        if(getconfigint("cec_volume", NULL) > 0)
220        {
221                if(getconfigint("cec_volume", NULL) == 1)
222                        address = 0x05;
223                if(getconfigint("cec_volume", NULL) == 2)
224                        address = 0x00;
225               
226                //cmd = 0x72;
227                //data[0] = 0x01;
228                //data[1] = '\0';
229                //m_lock(&status.cecmutex, 26);
230                //sendMessage(address, cmd, data, strlen(data));
231                //m_unlock(&status.cecmutex, 26);
232               
233                //cmd = 0x70;
234                //data[0] = 0x02;
235                //data[1] = 0x00;
236                //data[2] = '\0';
237                //m_lock(&status.cecmutex, 26);
238                //sendMessage(address, cmd, data, 2);
239                //m_unlock(&status.cecmutex, 26);
240               
241                cmd = 0x7d;
242                data[0] = '\0';
243                sendMessage(address, cmd, data, strlen(data));
244
245        }
246}
247
248void hdmiEvent()
249{
250        fd_set rfds;
251        struct timeval tv;
252        struct cec_rx_message rxmessage;
253        int ret = 0;
254        int hasdata = 0;
255        int keypressed = 0;
256        int transkey = 0;
257        unsigned char pressedkey = 0x00;
258       
259        while (hdmiEventthread->aktion != STOP)
260        {
261                printf("**** start Thread\n");
262                tv.tv_sec = 0x7fffffff;
263                tv.tv_usec = 0;
264                FD_ZERO(&rfds);
265                FD_SET(status.hdmiFd, &rfds);
266
267                hasdata = 0;
268
269                ret = select(status.hdmiFd + 1, &rfds, NULL, NULL, &tv);
270                if(ret > 0)
271                {
272                        if(FD_ISSET(status.hdmiFd, &rfds))
273                        {
274#ifdef DREAMBOX
275                                if (ioctl(status.hdmiFd, 2, &rxmessage) >= 0)
276                                        hasdata = 1;
277                               
278                                unsigned int val = 0;
279                                ioctl(status.hdmiFd, 4, &val);
280#else
281                                if (read(status.hdmiFd, &rxmessage, 2) == 2)
282                                {
283                                        if (read(status.hdmiFd, &rxmessage.data, rxmessage.length) == rxmessage.length)
284                                                hasdata = 1;
285                                }
286#endif
287                                if(hasdata)
288                                {
289                                        printf("CEC: rxmessage ->");
290                                        printf(" %02x ", rxmessage.address);
291                                        for (int i = 0; i < rxmessage.length; i++)
292                                                printf(" %02x", rxmessage.data[i]);
293                                        printf("\n");
294                                       
295                                        switch (rxmessage.data[0])
296                                        {
297                                                case 0x7e:
298                                                case 0x72: /* system audio mode status */
299                                                {
300                                                        if(rxmessage.data[1] == 0x01)
301                                                        {
302                                                                addconfiginttmp("ForwardVolume", 1);
303                                                                printf("HDMI_CEC: Volume forward is acticated\n");     
304                                                        }
305                                                        else
306                                                        {
307                                                                printf("HDMI_CEC: Volume forward is not supported\n"); 
308                                                                addconfiginttmp("ForwardVolume", 0);
309                                                        }
310                                                        break;
311                                                }
312                                               
313                                                case 0x46: /* request name */
314                                                {
315                                                        sendName(rxmessage.address);
316                                                        break;
317                                                }
318                                                case 0x8c: /* request vendor id */
319                                                {
320                                                        sendVendorid(rxmessage.address);
321                                                        break;
322                                                }
323                                                case 0x8d: /* menu request */
324                                                {
325                                                        //if(rxmessage.data[1] == 0x02)
326                                                                sendMenuInfo(rxmessage.address);
327                                                        break;
328                                                }
329                                                case 0x80:
330                                                {
331                                                        if(rxmessage.data[3]== cec_physicalAddress[0] && rxmessage.data[4]== cec_physicalAddress[1])
332                                                        {
333                                                                sendswitch();
334                                                                setFixedPhysicalAddress(getconfigint("cec_fixedAddress", NULL));
335                                                                reportPhysicalAddress(0);
336                                                                sendMenuInfo(0x00);
337                                                                setVolumeForward();
338                                                        }
339                                                        break;
340                                                }
341                                                case 0x82:
342                                                {
343                                                //cecon = 0;
344                                                //sendTVon();
345                                                        if(rxmessage.data[1]== cec_physicalAddress[0] && rxmessage.data[2]== cec_physicalAddress[1])
346                                                        {
347                                                                sendswitch();
348                                                                setFixedPhysicalAddress(getconfigint("cec_fixedAddress", NULL));
349                                                                reportPhysicalAddress(0);
350                                                                sendMenuInfo(0x00);
351                                                                setVolumeForward();
352                                                        }
353                                                        break;
354                                                }
355                                                case 0x00: /* feature abort */
356                                                {
357                                                        if(rxmessage.data[1] == 0x44 || rxmessage.data[1] == 0x7d)
358                                                        {
359                                                                addconfiginttmp("ForwardVolume", 0);
360                                                                printf("HdmiCec: volume forwarding not supported by device %02x\n", rxmessage.address);
361                                                        }
362                                                        break;
363                                                }
364                                                case 0x44: /* key pressed */
365                                                {
366                                                        keypressed = 1;
367                                                        pressedkey = rxmessage.data[1];
368                                                        transkey = translateKey(pressedkey);
369                                                        writerc(transkey);
370                                                        break;
371                                                }
372                                                case 0x45: /* key released */
373                                                {
374                                                        printf("HdmiCec: key received  -- %02x\n", pressedkey);
375                                                        transkey = translateKey(pressedkey);
376                                                        printf("HdmiCec: key TitanCode -- %i\n", transkey);
377                                                        //writerc(transkey);
378                                                        keypressed = 0;
379                                                        break;
380                                                }
381                                                case 0x83: /* request address */
382                                                {
383                                                        reportPhysicalAddress(1);
384                                                        break;
385                                                }
386                                                case 0x85: /* request active source */
387                                                {
388                                                        sendSource(rxmessage.address);
389                                                        break;
390                                                }
391                                                case 0x9f: /* request cec version */
392                                                {
393                                                        sendVersion(rxmessage.address);
394                                                        break;
395                                                }
396                                        }
397                                }
398                        }
399                        usleep(10000);
400                        continue;
401                }
402                else //timeout or error
403                {
404                        printf("read error or timeout if ret is 0: ret=%d\n", ret);
405                        sleep(1);
406                }               
407        }
408        hdmiEventthread = NULL;
409        printf("**** stop Thread\n");   
410}       
411
412
413int getPhysicalAddress()
414{
415        return (cec_physicalAddress[0] << 8) | cec_physicalAddress[1];
416}
417
418//void sendMessage(struct cec_message &message)
419void sendMessageReal(struct cec_message message)
420{
421        int i = 0;
422        if (status.hdmiFd >= 0)
423        {
424                printf("HdmiCEC: send message\n");
425                printf("%02x ", message.address);
426                for(i = 0; i < message.length; i++)
427                {
428                        printf(" %02X", message.data[i]);
429                }
430                printf("\n");
431                int ret = 0;
432#ifdef DREAMBOX
433                message.flag = 1;
434                ret = ioctl(status.hdmiFd, 3, &message);
435                if(ret == 0)
436                        ret = 1 + message.length;
437#else
438                ret = write(status.hdmiFd, &message, 2 + message.length);
439#endif
440                printf("%i Bytes wurden gesendet\n", ret);
441        }
442}
443
444void sendMessageReal_thread(struct stimerthread* timernode, struct cec_message* message, int flag)
445{
446        m_lock(&status.cecmutex, 26);
447        int i = 0;
448        if (status.hdmiFd >= 0)
449        {
450                printf("HdmiCEC: send message\n");
451                printf("%02x ", message->address);
452                for(i = 0; i < message->length; i++)
453                {
454                        printf(" %02X", message->data[i]);
455                }
456                printf("\n");
457                int ret = 0;
458#ifdef DREAMBOX
459                message->flag = 1;
460                ret = ioctl(status.hdmiFd, 3, message);
461                if(ret == 0)
462                        ret = 1 + message->length;
463#else
464                ret = write(status.hdmiFd, message, 2 + message->length);
465#endif
466                printf("%i Bytes wurden gesendet\n", ret);
467        }
468        free(message); message=NULL;
469        usleep(100000);
470        m_unlock(&status.cecmutex, 26);
471}
472
473void sendMessageReal_add(struct cec_message message)
474{
475        struct cec_message* smessage;
476        smessage = calloc(1, sizeof(struct cec_message));
477        if(smessage == NULL)
478        {
479                err("no mem");
480                return;
481        }
482        memcpy(smessage, &message, sizeof(struct cec_message));
483        addtimer(&sendMessageReal_thread, START, 1000, 1, (void*)smessage, NULL, NULL);
484}
485       
486
487void sendMessage(unsigned char address, unsigned char cmd, char *data, int length)
488{
489        struct cec_message message;
490        message.address = address;
491        if (length > (int)(sizeof(message.data) - 1)) length = sizeof(message.data) - 1;
492        message.length = length + 1;
493        message.data[0] = cmd;
494        memcpy(&message.data[1], data, length);
495        sendMessageReal_add(message);
496}
497
498void reportPhysicalAddress(int flag)
499{
500        struct cec_message txmessage;
501        txmessage.address = 0x0f; /* broadcast */
502        txmessage.data[0] = 0x84; /* report address */
503        txmessage.data[1] = cec_physicalAddress[0];
504        txmessage.data[2] = cec_physicalAddress[1];
505        txmessage.data[3] = cec_deviceType;
506        txmessage.length = 4;
507        sendMessageReal_add(txmessage);
508}
509
510
511void getAddressInfo()
512{
513        int hasdata = 0;
514       
515        if (status.hdmiFd >= 0)
516        {
517#if DREAMBOX
518                struct
519                {
520                        unsigned char physical[2];
521                        unsigned char logical;
522                        unsigned char type;
523                } addressinfo;
524
525                if (ioctl(status.hdmiFd, 1, &addressinfo) >= 0)
526                {
527                        hasdata = 1;
528                        /* we do not get the device type, check the logical address to determine the type */
529                        switch (addressinfo.logical)
530                        {
531                        case 0x1:
532                        case 0x2:
533                        case 0x9:
534                                addressinfo.type = 1; /* recorder */
535                                break;
536                        case 0x3:
537                        case 0x6:
538                        case 0x7:
539                        case 0xa:
540                                addressinfo.type = 3; /* tuner */
541                                break;
542                        case 0x4:
543                        case 0x8:
544                        case 0xb:
545                                addressinfo.type = 4; /* playback */
546                                break;
547                        }
548                }
549#else
550                struct
551                {
552                        unsigned char logical;
553                        unsigned char physical[2];
554                        unsigned char type;
555                } addressinfo;
556                if (ioctl(status.hdmiFd, 1, &addressinfo) < 0)
557                {
558                        printf("ERROR: cec read AddressInfo");
559                        return;
560                }
561                else
562                        hasdata = 1;
563#endif
564                if(hasdata == 1)
565                {
566                        cec_deviceType = addressinfo.type;
567                        cec_logicalAddress = addressinfo.logical;
568                        printf("HdmiCEC: detected deviceType: %02X\n", addressinfo.type);
569                        printf("HdmiCEC: detected logical address: %02X\n", addressinfo.logical);
570                        printf("HdmiCEC: detected physical address: %02X%02X\n", addressinfo.physical[0], addressinfo.physical[1]);
571                        if (status.cec_fixedAddress == 0)
572                        {
573                                //if(cecon > 0)
574                                if (memcmp(cec_physicalAddress, addressinfo.physical, sizeof(cec_physicalAddress)))
575                                {
576                                        printf("HdmiCEC: detected physical address change: %02X%02X --> %02X%02X\n", cec_physicalAddress[0], cec_physicalAddress[1], addressinfo.physical[0], addressinfo.physical[1]);
577                                        memcpy(cec_physicalAddress, addressinfo.physical, sizeof(cec_physicalAddress));
578                                        reportPhysicalAddress(0);
579                                        /* emit */ //addressChanged((cec_physicalAddress[0] << 8) | cec_physicalAddress[1]);
580                                }
581                        }
582                }
583        }
584}
585               
586void screencec()
587{
588        struct skin* tmp = NULL;
589        struct skin* cec = getscreen("cec");
590        struct skin* listbox = getscreennode(cec, "listbox");
591        struct skin* workpink = getscreennode(cec, "workpink");
592        struct skin* cecon = getscreennode(cec, "cecon");
593        struct skin* alloff = getscreennode(cec, "alloff");
594        struct skin* allon = getscreennode(cec, "allon");
595        struct skin* tvoff = getscreennode(cec, "tvoff");
596        struct skin* tvon = getscreennode(cec, "tvon");
597        struct skin* recoff = getscreennode(cec, "recoff");
598        struct skin* recon = getscreennode(cec, "recon");
599        struct skin* tvswitch = getscreennode(cec, "tvswitch");
600        struct skin* cecfix = getscreennode(cec, "cecfix");
601        struct skin* volume = getscreennode(cec, "volume");
602        struct skin* menue = getscreennode(cec, "menue");
603        int rcret = 0;
604        int help = 0;   
605       
606        addchoicebox(workpink, "0", _("off"));
607        addchoicebox(workpink, "1", _("on"));
608        setchoiceboxselection(workpink, getconfig("workpink", NULL));
609       
610        addchoicebox(cecon, "0", _("no"));
611        addchoicebox(cecon, "1", _("yes"));
612        setchoiceboxselection(cecon, getconfig("cec_on", NULL));
613       
614        addchoicebox(alloff, "0", _("no"));
615        addchoicebox(alloff, "1", _("yes"));
616        setchoiceboxselection(alloff, getconfig("cec_all_off", NULL));
617       
618        addchoicebox(allon, "0", _("no"));
619        addchoicebox(allon, "1", _("yes"));
620        setchoiceboxselection(allon, getconfig("cec_all_on", NULL));
621       
622        addchoicebox(tvoff, "0", _("no"));
623        addchoicebox(tvoff, "1", _("yes"));
624        setchoiceboxselection(tvoff, getconfig("cec_tv_off", NULL));
625       
626        addchoicebox(tvon, "0", _("no"));
627        addchoicebox(tvon, "1", _("yes"));
628        setchoiceboxselection(tvon, getconfig("cec_tv_on", NULL));
629       
630        addchoicebox(recoff, "0", _("no"));
631        addchoicebox(recoff, "1", _("yes"));
632        setchoiceboxselection(recoff, getconfig("cec_rec_off", NULL));
633       
634        addchoicebox(recon, "0", _("no"));
635        addchoicebox(recon, "1", _("yes"));
636        setchoiceboxselection(recon, getconfig("cec_rec_on", NULL));
637       
638        addchoicebox(tvswitch, "0", _("no"));
639        addchoicebox(tvswitch, "1", _("yes"));
640        setchoiceboxselection(tvswitch, getconfig("cec_tv_switch", NULL));
641       
642        addchoicebox(cecfix, "0", _("no"));
643        addchoicebox(cecfix, "1", _("yes"));
644        if(getconfigint("cec_fixedAddress", NULL) == 0)
645                setchoiceboxselection(cecfix, "0");
646        else
647                setchoiceboxselection(cecfix, "1");
648       
649        addchoicebox(volume, "0", _("none"));
650        addchoicebox(volume, "1", _("Receiver"));
651        addchoicebox(volume, "2", _("TV"));
652        setchoiceboxselection(volume, getconfig("cec_volume", NULL));
653       
654        addchoicebox(menue, "0", _("off"));
655        addchoicebox(menue, "1", _("on"));
656        setchoiceboxselection(menue, getconfig("cec_menue", NULL));
657       
658       
659        if(getconfigint("cec_on", NULL) == 0)
660        {
661                workpink->hidden = YES;
662                alloff->hidden = YES;   
663                allon->hidden = YES;           
664                tvoff->hidden = YES;   
665                tvon->hidden = YES;             
666                recoff->hidden = YES;   
667                recon->hidden = YES;   
668                tvswitch->hidden = YES;
669                cecfix->hidden = YES;
670                volume->hidden = YES;
671                menue->hidden = YES;
672        }
673        else
674        {
675                workpink->hidden = NO;
676                alloff->hidden = NO;   
677                allon->hidden = NO;             
678                tvoff->hidden = NO;     
679                tvon->hidden = NO;             
680                recoff->hidden = NO;   
681                recon->hidden = NO;     
682                tvswitch->hidden = NO;
683                cecfix->hidden = NO;   
684                volume->hidden = NO;
685                menue->hidden = NO;
686        }
687
688        drawscreen(cec, 0, 0);
689        addscreenrc(cec, listbox);
690        tmp = listbox->select;
691        while(1)
692        {
693                addscreenrc(cec, tmp);
694                rcret = waitrc(cec, 0, 0);
695                tmp = listbox->select;
696               
697                if((rcret == getrcconfigint("rcleft", NULL) || rcret == getrcconfigint("rcright", NULL)) && listbox->select != NULL && ostrcmp(listbox->select->name, "cecon") == 0)
698                {
699                        if(ostrcmp(cecon->ret, "0") == 0)
700                        {
701                                workpink->hidden = YES;
702                                alloff->hidden = YES;   
703                                allon->hidden = YES;           
704                                tvoff->hidden = YES;   
705                                tvon->hidden = YES;             
706                                recoff->hidden = YES;   
707                                recon->hidden = YES;   
708                                tvswitch->hidden = YES;
709                                cecfix->hidden = YES;   
710                                volume->hidden = YES;
711                                menue->hidden = YES;
712                        }
713                        else
714                        {
715                                workpink->hidden = NO;
716                                alloff->hidden = NO;   
717                                allon->hidden = NO;             
718                                tvoff->hidden = NO;     
719                                tvon->hidden = NO;             
720                                recoff->hidden = NO;   
721                                recon->hidden = NO;     
722                                tvswitch->hidden = NO; 
723                                cecfix->hidden = NO;   
724                                volume->hidden = NO;
725                                menue->hidden = NO;
726                        }
727                }
728                if(rcret == getrcconfigint("rcexit", NULL))
729                        break;
730                if(rcret == getrcconfigint("rcok", NULL))       
731                {
732                        addconfig("workpink", workpink->ret);
733                        addconfig("cec_on", cecon->ret);
734                        addconfig("cec_all_off", alloff->ret); 
735                        addconfig("cec_all_on", allon->ret);
736                        addconfig("cec_tv_off", tvoff->ret);   
737                        addconfig("cec_tv_on", tvon->ret);
738                        addconfig("cec_rec_off", recoff->ret); 
739                        addconfig("cec_rec_on", recon->ret);
740                        addconfig("cec_tv_switch", tvswitch->ret);
741                        addconfig("cec_volume", volume->ret);
742                        addconfig("cec_menue", menue->ret);
743                        if(ostrcmp(cecfix->ret, "0") == 0)
744                        {
745                                addconfig("cec_fixedAddress", "0");
746                                //setFixedPhysicalAddress(0);
747                        }
748                        else
749                        {
750                                help = 0;
751                                help = (cec_physicalAddress[0] << 8) | cec_physicalAddress[1] ;
752                                addconfigint("cec_fixedAddress", help);
753                                //setFixedPhysicalAddress(help);
754                        }
755                        if(getconfigint("cec_activ", NULL) == 0 || getconfigint("cec_on", NULL) == 0)
756                                cecinit();
757                        break;
758                }
759                drawscreen(cec, 0, 0);
760        }
761        delownerrc(cec);
762        clearscreen(cec);
763}
764
765void setFixedPhysicalAddress(int address)
766{
767        if (address > 0)
768        {
769                status.cec_fixedAddress = 1;
770                cec_physicalAddress[0] = (address >> 8) & 0xff;
771                cec_physicalAddress[1] = address & 0xff;
772                /* report our (possibly new) address */
773                reportPhysicalAddress(0);
774        }
775        else
776        {
777                status.cec_fixedAddress = 0;
778                /* get our current address */
779                getAddressInfo();
780        }
781}               
782
783void cecinit()
784{
785        status.cec_fixedAddress = 0;
786        status.hdmiFd = -1;
787        cec_physicalAddress[0] = 0x10;
788        cec_physicalAddress[1] = 0x00;
789        cec_logicalAddress = 1;
790        cec_deviceType = 1; /* default: recorder */
791       
792        if(getconfigint("cec_on", NULL) == 0)
793        {
794                addconfiginttmp("cec_activ", 0);
795                if(hdmiEventthread != NULL)
796                        hdmiEventthread->aktion = STOP;
797                return;
798        }
799        addconfiginttmp("cec_activ", 1);
800       
801       
802#ifdef DREAMBOX
803        status.hdmiFd = open("/dev/misc/hdmi_cec0", O_RDWR | O_NONBLOCK);
804        unsigned int val = 0;
805        ioctl(status.hdmiFd, 4, &val);
806#else
807        status.hdmiFd = open("/dev/hdmi_cec", O_RDWR | O_NONBLOCK);
808        ioctl(status.hdmiFd, 0); /* flush old messages */
809#endif
810       
811        if(hdmiEventthread == NULL)
812                hdmiEventthread = addtimer(&hdmiEvent, START, 10000, 1, NULL, NULL, NULL);
813               
814        getAddressInfo();
815       
816        if(checkbox("DM900") == 1 && getwaswakuptimer() != 1)
817        {       
818                sleep(2);
819                cecwakeup();
820        }
821       
822        return;
823}
824
825void cecstandby()
826{
827        char data[1];
828        unsigned char address = 0x00;
829        unsigned char cmd = 0x36;
830       
831        data[0] = '\0';
832       
833        if(getconfigint("cec_on", NULL) == 1)
834        {
835                if(getconfigint("cec_all_off", NULL) == 1)
836                {
837                        address = 0x0f;
838                        sendMessage(address, cmd, data, strlen(data));
839                }
840                if(getconfigint("cec_tv_off", NULL) == 1)
841                {
842                        address = 0x00;
843                        sendMessage(address, cmd, data, strlen(data));
844                        //sleep(1);
845                }
846                if(getconfigint("cec_rec_off", NULL) == 1)
847                {
848                        address = 0x05;
849                        sendMessage(address, cmd, data, strlen(data));
850                        //sleep(1);
851                }
852        }
853}
854
855void cecwakeup()
856{
857        char data[3];
858        unsigned char address = 0x00;
859        unsigned char cmd = 0x04;
860       
861        data[0] = '\0';
862       
863        if(getconfigint("cec_on", NULL) == 1 && cecon == 0)
864        {
865                if(getconfigint("cec_all_on", NULL) == 1)
866                {
867                        address = 0x0f;
868                        sendMessage(address, cmd, data, 0);
869                        //sleep(1);
870                }
871                if(getconfigint("cec_rec_on", NULL) == 1)
872                {
873                        address = 0x05;
874                        sendMessage(address, cmd, data, 0);
875                        //sleep(1);
876                }
877                if(getconfigint("cec_tv_on", NULL) == 1)
878                {       
879                        address = 0x00;
880                        sendMessage(address, cmd, data, 0);
881                        //sleep(1);
882                }
883                if(getconfigint("cec_tv_switch", NULL) == 1)
884                {                       
885                        address = 0x0f;
886                        cmd     = 0x82;
887                        data[0] = cec_physicalAddress[0];
888                        data[1] = cec_physicalAddress[1];
889                        data[2] = '\0';
890                        sendMessage(address, cmd, data, 2);
891                        //sleep(1);
892                }
893                cecon = 1;
894                printf("**********wakeup\n");   
895        }
896        if(cecon < 2)
897        {
898                //setFixedPhysicalAddress(getconfigint("cec_fixedAddress", NULL));
899                //setVolumeForward();
900                //sendMenuInfo(0x00);
901                cecon = 2;
902        }
903}
904
905void forwardKey(int key)
906{
907        char data[3];
908        unsigned char address = 0x00;
909        unsigned char cmd = 0x44;
910       
911        data[0] = '\0';
912       
913        if(getconfigint("cec_volume", NULL) == 1)
914                        address = 0x05;
915        else if(getconfigint("cec_volume", NULL) == 2)
916                        address = 0x00;
917       
918        if(key == getrcconfigint("rcvolup", NULL))
919                data[0] = 0x41;
920        else if(key == getrcconfigint("rcvoldown", NULL))
921                data[0] = 0x42;
922        else if(key == getrcconfigint("rcmute", NULL))
923                data[0] = 0x43;
924               
925        data[1] = '\0';
926        sendMessage(address, cmd, data, 1);
927        data[0] = '\0';
928        cmd = 0x45;
929        sendMessage(address, cmd, data, 0); /* release */
930}
931       
932#endif
Note: See TracBrowser for help on using the repository browser.