source: titan/titan/cec.h @ 40508

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

[titan] fix mipsel cec

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