source: titan/titan/cec.h @ 40484

Last change on this file since 40484 was 40484, checked in by gost, 7 years ago

[titan] fix arm cec

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