cec: handle CEC_OPCODE_ACTIVE_SOURCE
[deb_libcec.git] / src / lib / implementations / CECCommandHandler.cpp
CommitLineData
e9de9629
LOK
1/*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33#include "CECCommandHandler.h"
eafa9d46 34#include "../devices/CECBusDevice.h"
a1f8fb1b 35#include "../devices/CECAudioSystem.h"
28089abc 36#include "../devices/CECPlaybackDevice.h"
387b6f6f 37#include "../CECProcessor.h"
e9de9629
LOK
38
39using namespace CEC;
8747dd4f 40using namespace std;
e9de9629
LOK
41
42CCECCommandHandler::CCECCommandHandler(CCECBusDevice *busDevice)
43{
44 m_busDevice = busDevice;
45}
46
47bool CCECCommandHandler::HandleCommand(const cec_command &command)
48{
49 bool bHandled(true);
50
5e822b09 51 CStdString strLog;
62f5527d 52 strLog.Format(">> %s (%X) -> %s (%X): %s (%2X)", ToString(command.initiator), command.initiator, ToString(command.destination), command.destination, ToString(command.opcode), command.opcode);
5e822b09
LOK
53 m_busDevice->AddLog(CEC_LOG_NOTICE, strLog);
54
f8513317 55 if (m_busDevice->MyLogicalAddressContains(command.destination))
e9de9629
LOK
56 {
57 switch(command.opcode)
58 {
e55f3f70
LOK
59 case CEC_OPCODE_REPORT_POWER_STATUS:
60 HandleReportPowerStatus(command);
61 break;
6a1c0009
LOK
62 case CEC_OPCODE_CEC_VERSION:
63 HandleDeviceCecVersion(command);
64 break;
a3269a0a
LOK
65 case CEC_OPCODE_SET_MENU_LANGUAGE:
66 HandleSetMenuLanguage(command);
4d6b4433 67 /* pass to listeners */
a9e03a86 68 m_busDevice->GetProcessor()->AddCommand(command);
a3269a0a 69 break;
e9de9629
LOK
70 case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
71 HandleGivePhysicalAddress(command);
72 break;
73 case CEC_OPCODE_GIVE_OSD_NAME:
74 HandleGiveOSDName(command);
75 break;
76 case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
77 HandleGiveDeviceVendorId(command);
78 break;
79 case CEC_OPCODE_DEVICE_VENDOR_ID:
80 HandleDeviceVendorId(command);
81 break;
82 case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
83 HandleDeviceVendorCommandWithId(command);
84 break;
85 case CEC_OPCODE_GIVE_DECK_STATUS:
86 HandleGiveDeckStatus(command);
87 break;
88 case CEC_OPCODE_MENU_REQUEST:
89 HandleMenuRequest(command);
90 break;
91 case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
92 HandleGiveDevicePowerStatus(command);
93 break;
94 case CEC_OPCODE_GET_CEC_VERSION:
95 HandleGetCecVersion(command);
96 break;
97 case CEC_OPCODE_USER_CONTROL_PRESSED:
98 HandleUserControlPressed(command);
99 break;
100 case CEC_OPCODE_USER_CONTROL_RELEASE:
101 HandleUserControlRelease(command);
102 break;
a1f8fb1b
LOK
103 case CEC_OPCODE_GIVE_AUDIO_STATUS:
104 HandleGiveAudioStatus(command);
105 break;
cf0ecd85
LOK
106 case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
107 HandleGiveSystemAudioModeStatus(command);
108 break;
e5e86c76
LOK
109 case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
110 HandleSetSystemAudioModeRequest(command);
111 break;
e9de9629
LOK
112 default:
113 UnhandledCommand(command);
4d6b4433 114 /* pass to listeners */
a9e03a86 115 m_busDevice->GetProcessor()->AddCommand(command);
e9de9629
LOK
116 bHandled = false;
117 break;
118 }
119 }
120 else if (command.destination == CECDEVICE_BROADCAST)
121 {
122 CStdString strLog;
123 switch (command.opcode)
124 {
a3269a0a
LOK
125 case CEC_OPCODE_SET_MENU_LANGUAGE:
126 HandleSetMenuLanguage(command);
4d6b4433 127 /* pass to listeners */
a9e03a86 128 m_busDevice->GetProcessor()->AddCommand(command);
a3269a0a 129 break;
e9de9629
LOK
130 case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
131 HandleRequestActiveSource(command);
132 break;
133 case CEC_OPCODE_SET_STREAM_PATH:
134 HandleSetStreamPath(command);
135 break;
136 case CEC_OPCODE_ROUTING_CHANGE:
137 HandleRoutingChange(command);
138 break;
139 case CEC_OPCODE_DEVICE_VENDOR_ID:
140 HandleDeviceVendorId(command);
141 break;
142 case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
143 HandleDeviceVendorCommandWithId(command);
144 break;
4d6b4433
LOK
145 case CEC_OPCODE_STANDBY:
146 HandleStandby(command);
147 /* pass to listeners */
148 m_busDevice->GetProcessor()->AddCommand(command);
149 break;
be5b0e24
LOK
150 case CEC_OPCODE_ACTIVE_SOURCE:
151 HandleActiveSource(command);
152 /* pass to listeners */
153 m_busDevice->GetProcessor()->AddCommand(command);
154 break;
e9de9629
LOK
155 default:
156 UnhandledCommand(command);
4d6b4433 157 /* pass to listeners */
a9e03a86 158 m_busDevice->GetProcessor()->AddCommand(command);
e9de9629
LOK
159 bHandled = false;
160 break;
161 }
162 }
163 else
164 {
165 CStdString strLog;
f8513317 166 strLog.Format("ignoring frame: we're not at destination %x", command.destination);
e9de9629
LOK
167 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
168 bHandled = false;
169 }
170
171 return bHandled;
172}
173
be5b0e24
LOK
174bool CCECCommandHandler::HandleActiveSource(const cec_command &command)
175{
176 if (command.parameters.size == 2)
177 {
178 uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
179 return m_busDevice->GetProcessor()->SetStreamPath(iAddress);
180 }
181
182 return true;
183}
184
6a1c0009
LOK
185bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
186{
187 if (command.parameters.size == 1)
188 {
189 CCECBusDevice *device = GetDevice(command.initiator);
190 if (device)
191 device->SetCecVersion((cec_version) command.parameters[0]);
192 }
193
194 return true;
195}
196
e9de9629
LOK
197bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
198{
181b3475 199 SetVendorId(command);
6a1c0009 200 return true;
e9de9629
LOK
201}
202
203bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
204{
181b3475 205 SetVendorId(command);
6a1c0009 206 return true;
e9de9629
LOK
207}
208
209bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
210{
f8513317 211 CCECBusDevice *device = GetDevice(command.destination);
0f23c85c 212 if (device)
29912296 213 return device->TransmitCECVersion(command.initiator);
0f23c85c
LOK
214
215 return false;
e9de9629
LOK
216}
217
a1f8fb1b
LOK
218bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
219{
220 CCECBusDevice *device = GetDevice(command.destination);
221 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
222 return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
223
224 return false;
225}
226
e9de9629
LOK
227bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
228{
f8513317 229 CCECBusDevice *device = GetDevice(command.destination);
28089abc
LOK
230 if (device && device->GetType() == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
231 return ((CCECPlaybackDevice *) device)->TransmitDeckStatus(command.initiator);
0f23c85c
LOK
232
233 return false;
e9de9629
LOK
234}
235
236bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
237{
f8513317 238 CCECBusDevice *device = GetDevice(command.destination);
0f23c85c 239 if (device)
29912296 240 return device->TransmitPowerState(command.initiator);
0f23c85c
LOK
241
242 return false;
e9de9629
LOK
243}
244
245bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
246{
f8513317 247 CCECBusDevice *device = GetDevice(command.destination);
0f23c85c 248 if (device)
29912296 249 return device->TransmitVendorID(command.initiator);
0f23c85c
LOK
250
251 return false;
e9de9629
LOK
252}
253
254bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
255{
f8513317 256 CCECBusDevice *device = GetDevice(command.destination);
0f23c85c 257 if (device)
29912296 258 return device->TransmitOSDName(command.initiator);
0f23c85c
LOK
259
260 return false;
e9de9629
LOK
261}
262
263bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
264{
f8513317 265 CCECBusDevice *device = GetDevice(command.destination);
09c10b66 266 if (device)
29912296 267 return device->TransmitPhysicalAddress();
09c10b66
LOK
268
269 return false;
e9de9629
LOK
270}
271
272bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
273{
274 if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
0f23c85c 275 {
f8513317 276 CCECBusDevice *device = GetDevice(command.destination);
0f23c85c 277 if (device)
29912296 278 return device->TransmitMenuState(command.initiator);
0f23c85c
LOK
279 }
280 return false;
e9de9629
LOK
281}
282
e55f3f70
LOK
283bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
284{
285 if (command.parameters.size == 1)
286 {
287 CCECBusDevice *device = GetDevice(command.initiator);
288 if (device)
289 device->SetPowerStatus((cec_power_status) command.parameters[0]);
290 }
291 return true;
292}
293
e9de9629
LOK
294bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
295{
296 CStdString strLog;
297 strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
298 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
8747dd4f
LOK
299
300 vector<CCECBusDevice *> devices;
301 for (int iDevicePtr = (int)GetMyDevices(devices)-1; iDevicePtr >=0; iDevicePtr--)
302 devices[iDevicePtr]->TransmitActiveSource();
303 return true;
e9de9629
LOK
304}
305
306bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
307{
308 if (command.parameters.size == 4)
309 {
310 uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
311 uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);
e9de9629 312
0f23c85c
LOK
313 CCECBusDevice *device = GetDevice(command.initiator);
314 if (device)
9dc04b07 315 device->SetStreamPath(iNewAddress, iOldAddress);
e9de9629
LOK
316 }
317 return true;
318}
319
a3269a0a
LOK
320bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
321{
322 if (command.parameters.size == 3)
323 {
324 CCECBusDevice *device = GetDevice(command.initiator);
325 if (device)
326 {
327 cec_menu_language language;
328 language.device = command.initiator;
56701628 329 for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
a3269a0a
LOK
330 language.language[iPtr] = command.parameters[iPtr];
331 language.language[3] = 0;
332 device->SetMenuLanguage(language);
333 }
334 }
335 return true;
336}
337
e9de9629
LOK
338bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
339{
340 if (command.parameters.size >= 2)
341 {
342 int streamaddr = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
343 CStdString strLog;
344 strLog.Format(">> %i requests stream path from physical address %04x", command.initiator, streamaddr);
345 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
6685ae07
LOK
346 CCECBusDevice *device = GetDeviceByPhysicalAddress(streamaddr);
347 if (device)
348 return device->TransmitActiveSource();
e9de9629
LOK
349 }
350 return true;
351}
352
e5e86c76
LOK
353bool CCECCommandHandler::HandleSetSystemAudioModeRequest(const cec_command &command)
354{
355 if (command.parameters.size >= 1)
356 {
357 CCECBusDevice *device = GetDevice(command.destination);
358 if (device&& device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
359 return ((CCECAudioSystem *) device)->SetSystemAudioMode(command);
360 }
361 return true;
362}
363
4d6b4433
LOK
364bool CCECCommandHandler::HandleStandby(const cec_command &command)
365{
366 CCECBusDevice *device = GetDevice(command.initiator);
367 if (device)
368 device->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
369 return true;
370}
371
cf0ecd85
LOK
372bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
373{
374 CCECBusDevice *device = GetDevice(command.destination);
375 if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
376 return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
377
378 return false;
379}
380
e9de9629
LOK
381bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
382{
383 if (command.parameters.size > 0)
384 {
385 m_busDevice->GetProcessor()->AddKey();
386
387 if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
388 {
389 CStdString strLog;
390 strLog.Format("key pressed: %1x", command.parameters[0]);
391 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
392
393 m_busDevice->GetProcessor()->SetCurrentButton((cec_user_control_code) command.parameters[0]);
394 }
395 }
396 return true;
397}
398
399bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
400{
401 m_busDevice->GetProcessor()->AddKey();
402 return true;
403}
404
405void CCECCommandHandler::UnhandledCommand(const cec_command &command)
406{
b5b53c7d
LOK
407 CStdString strLog;
408 strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
409 m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
0f23c85c
LOK
410}
411
8747dd4f
LOK
412unsigned int CCECCommandHandler::GetMyDevices(vector<CCECBusDevice *> &devices) const
413{
414 unsigned int iReturn(0);
415
416 cec_logical_addresses addresses = m_busDevice->GetProcessor()->GetLogicalAddresses();
417 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
418 {
419 if (addresses[iPtr])
420 {
421 devices.push_back(GetDevice((cec_logical_address) iPtr));
422 ++iReturn;
423 }
424 }
425
426 return iReturn;
427}
428
0f23c85c
LOK
429CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
430{
431 CCECBusDevice *device = NULL;
432
433 if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
434 device = m_busDevice->GetProcessor()->m_busDevices[iLogicalAddress];
435
436 return device;
e9de9629 437}
6685ae07
LOK
438
439CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
440{
8ac9c610 441 return m_busDevice->GetProcessor()->GetDeviceByPhysicalAddress(iPhysicalAddress);
6685ae07 442}
181b3475 443
181b3475
LOK
444void CCECCommandHandler::SetVendorId(const cec_command &command)
445{
446 if (command.parameters.size < 3)
447 {
448 m_busDevice->AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
449 return;
450 }
451
bae71306
LOK
452 uint64_t iVendorId = ((uint64_t)command.parameters[0] << 16) +
453 ((uint64_t)command.parameters[1] << 8) +
181b3475
LOK
454 (uint64_t)command.parameters[2];
455
456 CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
457 if (device)
a7bed660 458 device->SetVendorId(iVendorId, command.parameters.size > 3 ? command.parameters[3] : 0);
181b3475 459}
5e822b09 460
62f5527d
LOK
461const char *CCECCommandHandler::ToString(const cec_logical_address address)
462{
463 switch(address)
464 {
465 case CECDEVICE_AUDIOSYSTEM:
466 return "Audio";
467 case CECDEVICE_BROADCAST:
468 return "Broadcast";
469 case CECDEVICE_FREEUSE:
470 return "Free use";
471 case CECDEVICE_PLAYBACKDEVICE1:
472 return "Playback 1";
473 case CECDEVICE_PLAYBACKDEVICE2:
474 return "Playback 2";
475 case CECDEVICE_PLAYBACKDEVICE3:
476 return "Playback 3";
477 case CECDEVICE_RECORDINGDEVICE1:
478 return "Recorder 1";
479 case CECDEVICE_RECORDINGDEVICE2:
480 return "Recorder 2";
481 case CECDEVICE_RECORDINGDEVICE3:
482 return "Recorder 3";
483 case CECDEVICE_RESERVED1:
484 return "Reserved 1";
485 case CECDEVICE_RESERVED2:
486 return "Reserved 2";
487 case CECDEVICE_TUNER1:
488 return "Tuner 1";
489 case CECDEVICE_TUNER2:
490 return "Tuner 2";
491 case CECDEVICE_TUNER3:
492 return "Tuner 3";
493 case CECDEVICE_TUNER4:
494 return "Tuner 4";
495 case CECDEVICE_TV:
496 return "TV";
497 default:
498 return "unknown";
499 }
500}
501
8ac9c610
LOK
502const char *CCECCommandHandler::ToString(const cec_deck_info status)
503{
504 switch (status)
505 {
506 case CEC_DECK_INFO_PLAY:
507 return "play";
508 case CEC_DECK_INFO_RECORD:
509 return "record";
510 case CEC_DECK_INFO_PLAY_REVERSE:
511 return "play reverse";
512 case CEC_DECK_INFO_STILL:
513 return "still";
514 case CEC_DECK_INFO_SLOW:
515 return "slow";
516 case CEC_DECK_INFO_SLOW_REVERSE:
517 return "slow reverse";
518 case CEC_DECK_INFO_FAST_FORWARD:
519 return "fast forward";
520 case CEC_DECK_INFO_FAST_REVERSE:
521 return "fast reverse";
522 case CEC_DECK_INFO_NO_MEDIA:
523 return "no media";
524 case CEC_DECK_INFO_STOP:
525 return "stop";
526 case CEC_DECK_INFO_SKIP_FORWARD_WIND:
527 return "info skip forward wind";
528 case CEC_DECK_INFO_SKIP_REVERSE_REWIND:
529 return "info skip reverse rewind";
530 case CEC_DECK_INFO_INDEX_SEARCH_FORWARD:
531 return "info index search forward";
532 case CEC_DECK_INFO_INDEX_SEARCH_REVERSE:
533 return "info index search reverse";
534 case CEC_DECK_INFO_OTHER_STATUS:
535 return "other";
536 default:
537 return "unknown";
538 }
539}
540
5e822b09
LOK
541const char *CCECCommandHandler::ToString(const cec_opcode opcode)
542{
543 switch (opcode)
544 {
545 case CEC_OPCODE_ACTIVE_SOURCE:
546 return "active source";
547 case CEC_OPCODE_IMAGE_VIEW_ON:
548 return "image view on";
549 case CEC_OPCODE_TEXT_VIEW_ON:
550 return "text view on";
551 case CEC_OPCODE_INACTIVE_SOURCE:
552 return "inactive source";
553 case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
554 return "request active source";
555 case CEC_OPCODE_ROUTING_CHANGE:
556 return "routing change";
557 case CEC_OPCODE_ROUTING_INFORMATION:
558 return "routing information";
559 case CEC_OPCODE_SET_STREAM_PATH:
560 return "set stream path";
561 case CEC_OPCODE_STANDBY:
562 return "standby";
563 case CEC_OPCODE_RECORD_OFF:
564 return "record off";
565 case CEC_OPCODE_RECORD_ON:
566 return "record on";
567 case CEC_OPCODE_RECORD_STATUS:
568 return "record status";
569 case CEC_OPCODE_RECORD_TV_SCREEN:
570 return "record tv screen";
571 case CEC_OPCODE_CLEAR_ANALOGUE_TIMER:
572 return "clear analogue timer";
573 case CEC_OPCODE_CLEAR_DIGITAL_TIMER:
574 return "clear digital timer";
575 case CEC_OPCODE_CLEAR_EXTERNAL_TIMER:
576 return "clear external timer";
577 case CEC_OPCODE_SET_ANALOGUE_TIMER:
578 return "set analogue timer";
579 case CEC_OPCODE_SET_DIGITAL_TIMER:
580 return "set digital timer";
581 case CEC_OPCODE_SET_EXTERNAL_TIMER:
582 return "set external timer";
583 case CEC_OPCODE_SET_TIMER_PROGRAM_TITLE:
584 return "set timer program title";
585 case CEC_OPCODE_TIMER_CLEARED_STATUS:
586 return "timer cleared status";
587 case CEC_OPCODE_TIMER_STATUS:
588 return "timer status";
589 case CEC_OPCODE_CEC_VERSION:
590 return "cec version";
591 case CEC_OPCODE_GET_CEC_VERSION:
592 return "get cec version";
593 case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
594 return "give physical address";
595 case CEC_OPCODE_GET_MENU_LANGUAGE:
596 return "get menu language";
597 case CEC_OPCODE_REPORT_PHYSICAL_ADDRESS:
598 return "report physical address";
599 case CEC_OPCODE_SET_MENU_LANGUAGE:
600 return "set menu language";
601 case CEC_OPCODE_DECK_CONTROL:
602 return "deck control";
603 case CEC_OPCODE_DECK_STATUS:
604 return "deck status";
605 case CEC_OPCODE_GIVE_DECK_STATUS:
606 return "give deck status";
607 case CEC_OPCODE_PLAY:
608 return "play";
609 case CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS:
610 return "give tuner status";
611 case CEC_OPCODE_SELECT_ANALOGUE_SERVICE:
612 return "select analogue service";
613 case CEC_OPCODE_SELECT_DIGITAL_SERVICE:
614 return "set digital service";
615 case CEC_OPCODE_TUNER_DEVICE_STATUS:
616 return "tuner device status";
617 case CEC_OPCODE_TUNER_STEP_DECREMENT:
618 return "tuner step decrement";
619 case CEC_OPCODE_TUNER_STEP_INCREMENT:
620 return "tuner step increment";
621 case CEC_OPCODE_DEVICE_VENDOR_ID:
622 return "device vendor id";
623 case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
624 return "give device vendor id";
625 case CEC_OPCODE_VENDOR_COMMAND:
626 return "vendor command";
627 case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
628 return "vendor command with id";
629 case CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN:
630 return "vendor remote button down";
631 case CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP:
632 return "vendor remote button up";
633 case CEC_OPCODE_SET_OSD_STRING:
634 return "set osd string";
635 case CEC_OPCODE_GIVE_OSD_NAME:
636 return "give osd name";
637 case CEC_OPCODE_SET_OSD_NAME:
638 return "set osd name";
639 case CEC_OPCODE_MENU_REQUEST:
640 return "menu request";
641 case CEC_OPCODE_MENU_STATUS:
642 return "menu status";
643 case CEC_OPCODE_USER_CONTROL_PRESSED:
644 return "user control pressed";
645 case CEC_OPCODE_USER_CONTROL_RELEASE:
646 return "user control release";
647 case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
648 return "give device power status";
649 case CEC_OPCODE_REPORT_POWER_STATUS:
650 return "report power status";
651 case CEC_OPCODE_FEATURE_ABORT:
652 return "feature abort";
653 case CEC_OPCODE_ABORT:
654 return "abort";
655 case CEC_OPCODE_GIVE_AUDIO_STATUS:
656 return "give audio status";
657 case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
658 return "give audio mode status";
659 case CEC_OPCODE_REPORT_AUDIO_STATUS:
660 return "report audio status";
661 case CEC_OPCODE_SET_SYSTEM_AUDIO_MODE:
662 return "set system audio mode";
663 case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
664 return "system audio mode request";
665 case CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS:
666 return "system audio mode status";
667 case CEC_OPCODE_SET_AUDIO_RATE:
668 return "set audio rate";
669 default:
670 return "UNKNOWN";
671 }
672}