Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #ifndef ANDROID_INCLUDE_HARDWARE_HDMI_CEC_H |
| 18 | #define ANDROID_INCLUDE_HARDWARE_HDMI_CEC_H |
| 19 | |
| 20 | #include <stdint.h> |
| 21 | #include <sys/cdefs.h> |
| 22 | |
| 23 | #include <hardware/hardware.h> |
| 24 | |
| 25 | __BEGIN_DECLS |
| 26 | |
| 27 | #define HDMI_CEC_MODULE_API_VERSION_1_0 HARDWARE_MODULE_API_VERSION(1, 0) |
| 28 | #define HDMI_CEC_MODULE_API_VERSION_CURRENT HDMI_MODULE_API_VERSION_1_0 |
| 29 | |
| 30 | #define HDMI_CEC_DEVICE_API_VERSION_1_0 HARDWARE_DEVICE_API_VERSION(1, 0) |
| 31 | #define HDMI_CEC_DEVICE_API_VERSION_CURRENT HDMI_DEVICE_API_VERSION_1_0 |
| 32 | |
| 33 | #define HDMI_CEC_HARDWARE_MODULE_ID "hdmi_cec" |
| 34 | #define HDMI_CEC_HARDWARE_INTERFACE "hdmi_cec_hw_if" |
| 35 | |
| 36 | typedef enum cec_device_type { |
Jinsuk Kim | efbdb25 | 2014-03-24 13:26:40 +0900 | [diff] [blame] | 37 | CEC_DEVICE_INACTIVE = -1, |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 38 | CEC_DEVICE_TV = 0, |
| 39 | CEC_DEVICE_RECORDER = 1, |
| 40 | CEC_DEVICE_RESERVED = 2, |
| 41 | CEC_DEVICE_TUNER = 3, |
| 42 | CEC_DEVICE_PLAYBACK = 4, |
| 43 | CEC_DEVICE_AUDIO_SYSTEM = 5, |
| 44 | CEC_DEVICE_MAX = CEC_DEVICE_AUDIO_SYSTEM |
| 45 | } cec_device_type_t; |
| 46 | |
| 47 | typedef enum cec_logical_address { |
| 48 | CEC_ADDR_TV = 0, |
| 49 | CEC_ADDR_RECORDER_1 = 1, |
| 50 | CEC_ADDR_RECORDER_2 = 2, |
| 51 | CEC_ADDR_TUNER_1 = 3, |
| 52 | CEC_ADDR_PLAYBACK_1 = 4, |
| 53 | CEC_ADDR_AUDIO_SYSTEM = 5, |
| 54 | CEC_ADDR_TUNER_2 = 6, |
| 55 | CEC_ADDR_TUNER_3 = 7, |
| 56 | CEC_ADDR_PLAYBACK_2 = 8, |
| 57 | CEC_ADDR_RECORDER_3 = 9, |
| 58 | CEC_ADDR_TUNER_4 = 10, |
| 59 | CEC_ADDR_PLAYBACK_3 = 11, |
| 60 | CEC_ADDR_RESERVED_1 = 12, |
| 61 | CEC_ADDR_RESERVED_2 = 13, |
| 62 | CEC_ADDR_FREE_USE = 14, |
| 63 | CEC_ADDR_UNREGISTERED = 15, |
| 64 | CEC_ADDR_BROADCAST = 15 |
| 65 | } cec_logical_address_t; |
| 66 | |
| 67 | /* |
| 68 | * HDMI CEC messages |
| 69 | */ |
| 70 | enum cec_message_type { |
| 71 | CEC_MESSAGE_FEATURE_ABORT = 0x00, |
| 72 | CEC_MESSAGE_IMAGE_VIEW_ON = 0x04, |
| 73 | CEC_MESSAGE_TUNER_STEP_INCREMENT = 0x05, |
| 74 | CEC_MESSAGE_TUNER_STEP_DECREMENT = 0x06, |
| 75 | CEC_MESSAGE_TUNER_DEVICE_STATUS = 0x07, |
| 76 | CEC_MESSAGE_GIVE_TUNER_DEVICE_STATUS = 0x08, |
| 77 | CEC_MESSAGE_RECORD_ON = 0x09, |
| 78 | CEC_MESSAGE_RECORD_STATUS = 0x0A, |
| 79 | CEC_MESSAGE_RECORD_OFF = 0x0B, |
| 80 | CEC_MESSAGE_TEXT_VIEW_ON = 0x0D, |
| 81 | CEC_MESSAGE_RECORD_TV_SCREEN = 0x0F, |
| 82 | CEC_MESSAGE_GIVE_DECK_STATUS = 0x1A, |
| 83 | CEC_MESSAGE_DECK_STATUS = 0x1B, |
| 84 | CEC_MESSAGE_SET_MENU_LANGUAGE = 0x32, |
| 85 | CEC_MESSAGE_CLEAR_ANALOG_TIMER = 0x33, |
| 86 | CEC_MESSAGE_SET_ANALOG_TIMER = 0x34, |
| 87 | CEC_MESSAGE_TIMER_STATUS = 0x35, |
| 88 | CEC_MESSAGE_STANDBY = 0x36, |
| 89 | CEC_MESSAGE_PLAY = 0x41, |
| 90 | CEC_MESSAGE_DECK_CONTROL = 0x42, |
| 91 | CEC_MESSAGE_TIMER_CLEARED_STATUS = 0x043, |
| 92 | CEC_MESSAGE_USER_CONTROL_PRESSED = 0x44, |
| 93 | CEC_MESSAGE_USER_CONTROL_RELEASED = 0x45, |
Jungshik Jang | 5bf6716 | 2014-05-16 16:31:27 +0900 | [diff] [blame] | 94 | CEC_MESSAGE_GIVE_OSD_NAME = 0x46, |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 95 | CEC_MESSAGE_SET_OSD_NAME = 0x47, |
| 96 | CEC_MESSAGE_SET_OSD_STRING = 0x64, |
| 97 | CEC_MESSAGE_SET_TIMER_PROGRAM_TITLE = 0x67, |
| 98 | CEC_MESSAGE_SYSTEM_AUDIO_MODE_REQUEST = 0x70, |
| 99 | CEC_MESSAGE_GIVE_AUDIO_STATUS = 0x71, |
| 100 | CEC_MESSAGE_SET_SYSTEM_AUDIO_MODE = 0x72, |
| 101 | CEC_MESSAGE_REPORT_AUDIO_STATUS = 0x7A, |
| 102 | CEC_MESSAGE_GIVE_SYSTEM_AUDIO_MODE_STATUS = 0x7D, |
| 103 | CEC_MESSAGE_SYSTEM_AUDIO_MODE_STATUS = 0x7E, |
| 104 | CEC_MESSAGE_ROUTING_CHANGE = 0x80, |
| 105 | CEC_MESSAGE_ROUTING_INFORMATION = 0x81, |
| 106 | CEC_MESSAGE_ACTIVE_SOURCE = 0x82, |
| 107 | CEC_MESSAGE_GIVE_PHYSICAL_ADDRESS = 0x83, |
| 108 | CEC_MESSAGE_REPORT_PHYSICAL_ADDRESS = 0x84, |
| 109 | CEC_MESSAGE_REQUEST_ACTIVE_SOURCE = 0x85, |
| 110 | CEC_MESSAGE_SET_STREAM_PATH = 0x86, |
| 111 | CEC_MESSAGE_DEVICE_VENDOR_ID = 0x87, |
| 112 | CEC_MESSAGE_VENDOR_COMMAND = 0x89, |
| 113 | CEC_MESSAGE_VENDOR_REMOTE_BUTTON_DOWN = 0x8A, |
| 114 | CEC_MESSAGE_VENDOR_REMOTE_BUTTON_UP = 0x8B, |
| 115 | CEC_MESSAGE_GIVE_DEVICE_VENDOR_ID = 0x8C, |
| 116 | CEC_MESSAGE_MENU_REQUEST = 0x8D, |
| 117 | CEC_MESSAGE_MENU_STATUS = 0x8E, |
| 118 | CEC_MESSAGE_GIVE_DEVICE_POWER_STATUS = 0x8F, |
| 119 | CEC_MESSAGE_REPORT_POWER_STATUS = 0x90, |
| 120 | CEC_MESSAGE_GET_MENU_LANGUAGE = 0x91, |
| 121 | CEC_MESSAGE_SELECT_ANALOG_SERVICE = 0x92, |
| 122 | CEC_MESSAGE_SELECT_DIGITAL_SERVICE = 0x93, |
| 123 | CEC_MESSAGE_SET_DIGITAL_TIMER = 0x97, |
| 124 | CEC_MESSAGE_CLEAR_DIGITAL_TIMER = 0x99, |
| 125 | CEC_MESSAGE_SET_AUDIO_RATE = 0x9A, |
| 126 | CEC_MESSAGE_INACTIVE_SOURCE = 0x9D, |
| 127 | CEC_MESSAGE_CEC_VERSION = 0x9E, |
| 128 | CEC_MESSAGE_GET_CEC_VERSION = 0x9F, |
| 129 | CEC_MESSAGE_VENDOR_COMMAND_WITH_ID = 0xA0, |
| 130 | CEC_MESSAGE_CLEAR_EXTERNAL_TIMER = 0xA1, |
Jinsuk Kim | efbdb25 | 2014-03-24 13:26:40 +0900 | [diff] [blame] | 131 | CEC_MESSAGE_SET_EXTERNAL_TIMER = 0xA2, |
Jungshik Jang | 5bf6716 | 2014-05-16 16:31:27 +0900 | [diff] [blame] | 132 | CEC_MESSAGE_INITIATE_ARC = 0xC0, |
| 133 | CEC_MESSAGE_REPORT_ARC_INITIATED = 0xC1, |
| 134 | CEC_MESSAGE_REPORT_ARC_TERMINATED = 0xC2, |
| 135 | CEC_MESSAGE_REQUEST_ARC_INITIATION = 0xC3, |
| 136 | CEC_MESSAGE_REQUEST_ARC_TERMINATION = 0xC4, |
| 137 | CEC_MESSAGE_TERMINATE_ARC = 0xC5, |
Jinsuk Kim | efbdb25 | 2014-03-24 13:26:40 +0900 | [diff] [blame] | 138 | CEC_MESSAGE_ABORT = 0xFF |
| 139 | }; |
| 140 | |
| 141 | /* |
| 142 | * Operand description [Abort Reason] |
| 143 | */ |
| 144 | enum abort_reason { |
| 145 | ABORT_UNRECOGNIZED_MODE = 0, |
| 146 | ABORT_NOT_IN_CORRECT_MODE = 1, |
| 147 | ABORT_CANNOT_PROVIDE_SOURCE = 2, |
| 148 | ABORT_INVALID_OPERAND = 3, |
| 149 | ABORT_REFUSED = 4, |
| 150 | ABORT_UNABLE_TO_DETERMINE = 5 |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 151 | }; |
| 152 | |
| 153 | /* |
| 154 | * HDMI event type. used for hdmi_event_t. |
| 155 | */ |
| 156 | enum { |
| 157 | HDMI_EVENT_CEC_MESSAGE = 1, |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 158 | HDMI_EVENT_HOT_PLUG = 2, |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 159 | }; |
| 160 | |
| 161 | /* |
| 162 | * HDMI hotplug event type. Used when the event |
| 163 | * type is HDMI_EVENT_HOT_PLUG. |
| 164 | */ |
| 165 | enum { |
| 166 | HDMI_NOT_CONNECTED = 0, |
| 167 | HDMI_CONNECTED = 1 |
| 168 | }; |
| 169 | |
| 170 | /* |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 171 | * error code used for send_message. |
| 172 | */ |
| 173 | enum { |
| 174 | HDMI_RESULT_SUCCESS = 0, |
| 175 | HDMI_RESULT_NACK = 1, /* not acknowledged */ |
Jinsuk Kim | ada8314 | 2014-07-03 09:30:42 +0900 | [diff] [blame] | 176 | HDMI_RESULT_BUSY = 2, /* bus is busy */ |
| 177 | HDMI_RESULT_FAIL = 3, |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 178 | }; |
| 179 | |
| 180 | /* |
| 181 | * HDMI port type. |
| 182 | */ |
| 183 | typedef enum hdmi_port_type { |
| 184 | HDMI_INPUT = 0, |
| 185 | HDMI_OUTPUT = 1 |
| 186 | } hdmi_port_type_t; |
| 187 | |
| 188 | /* |
| 189 | * Flags used for set_option() |
| 190 | */ |
| 191 | enum { |
| 192 | /* When set to false, HAL does not wake up the system upon receiving |
| 193 | * <Image View On> or <Text View On>. Used when user changes the TV |
| 194 | * settings to disable the auto TV on functionality. |
| 195 | * True by default. |
| 196 | */ |
| 197 | HDMI_OPTION_WAKEUP = 1, |
| 198 | |
| 199 | /* When set to false, all the CEC commands are discarded. Used when |
| 200 | * user changes the TV settings to disable CEC functionality. |
| 201 | * True by default. |
| 202 | */ |
| 203 | HDMI_OPTION_ENABLE_CEC = 2, |
| 204 | |
| 205 | /* Setting this flag to false means Android system will stop handling |
| 206 | * CEC service and yield the control over to the microprocessor that is |
| 207 | * powered on through the standby mode. When set to true, the system |
| 208 | * will gain the control over, hence telling the microprocessor to stop |
| 209 | * handling the cec commands. This is called when system goes |
| 210 | * in and out of standby mode to notify the microprocessor that it should |
| 211 | * start/stop handling CEC commands on behalf of the system. |
| 212 | * False by default. |
| 213 | */ |
| 214 | HDMI_OPTION_SYSTEM_CEC_CONTROL = 3, |
Jinsuk Kim | 8b7eca8 | 2015-01-19 07:20:09 +0900 | [diff] [blame] | 215 | |
| 216 | /* Option 4 not used */ |
| 217 | |
| 218 | /* Passes the updated language information of Android system. |
| 219 | * Contains 3-byte ASCII code as defined in ISO/FDIS 639-2. Can be |
| 220 | * used for HAL to respond to <Get Menu Language> while in standby mode. |
| 221 | * English(eng), for example, is converted to 0x656e67. |
| 222 | */ |
| 223 | HDMI_OPTION_SET_LANG = 5, |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 224 | }; |
| 225 | |
| 226 | /* |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 227 | * Maximum length in bytes of cec message body (exclude header block), |
| 228 | * should not exceed 16 (spec CEC 6 Frame Description) |
| 229 | */ |
| 230 | #define CEC_MESSAGE_BODY_MAX_LENGTH 16 |
| 231 | |
| 232 | typedef struct cec_message { |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 233 | /* logical address of sender */ |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 234 | cec_logical_address_t initiator; |
| 235 | |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 236 | /* logical address of receiver */ |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 237 | cec_logical_address_t destination; |
| 238 | |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 239 | /* Length in bytes of body, range [0, CEC_MESSAGE_BODY_MAX_LENGTH] */ |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 240 | size_t length; |
| 241 | unsigned char body[CEC_MESSAGE_BODY_MAX_LENGTH]; |
| 242 | } cec_message_t; |
| 243 | |
| 244 | typedef struct hotplug_event { |
| 245 | /* |
| 246 | * true if the cable is connected; otherwise false. |
| 247 | */ |
| 248 | int connected; |
Jinsuk Kim | ca6fa79 | 2014-07-09 17:17:24 +0900 | [diff] [blame] | 249 | int port_id; |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 250 | } hotplug_event_t; |
| 251 | |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 252 | typedef struct tx_status_event { |
| 253 | int status; |
| 254 | int opcode; /* CEC opcode */ |
| 255 | } tx_status_event_t; |
| 256 | |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 257 | /* |
| 258 | * HDMI event generated from HAL. |
| 259 | */ |
| 260 | typedef struct hdmi_event { |
| 261 | int type; |
| 262 | struct hdmi_cec_device* dev; |
| 263 | union { |
| 264 | cec_message_t cec; |
| 265 | hotplug_event_t hotplug; |
| 266 | }; |
| 267 | } hdmi_event_t; |
| 268 | |
| 269 | /* |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 270 | * HDMI port descriptor |
| 271 | */ |
| 272 | typedef struct hdmi_port_info { |
| 273 | hdmi_port_type_t type; |
Jinsuk Kim | ca6fa79 | 2014-07-09 17:17:24 +0900 | [diff] [blame] | 274 | // Port ID should start from 1 which corresponds to HDMI "port 1". |
| 275 | int port_id; |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 276 | int cec_supported; |
| 277 | int arc_supported; |
| 278 | uint16_t physical_address; |
| 279 | } hdmi_port_info_t; |
| 280 | |
| 281 | /* |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 282 | * Callback function type that will be called by HAL implementation. |
| 283 | * Services can not close/open the device in the callback. |
| 284 | */ |
Jinsuk Kim | 70ae777 | 2014-03-06 19:25:19 +0900 | [diff] [blame] | 285 | typedef void (*event_callback_t)(const hdmi_event_t* event, void* arg); |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 286 | |
| 287 | typedef struct hdmi_cec_module { |
Stewart Miles | 84d3549 | 2014-05-01 09:03:27 -0700 | [diff] [blame] | 288 | /** |
| 289 | * Common methods of the HDMI CEC module. This *must* be the first member of |
| 290 | * hdmi_cec_module as users of this structure will cast a hw_module_t to hdmi_cec_module |
| 291 | * pointer in contexts where it's known the hw_module_t references a hdmi_cec_module. |
| 292 | */ |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 293 | struct hw_module_t common; |
| 294 | } hdmi_module_t; |
| 295 | |
| 296 | /* |
| 297 | * HDMI-CEC HAL interface definition. |
| 298 | */ |
| 299 | typedef struct hdmi_cec_device { |
Stewart Miles | 84d3549 | 2014-05-01 09:03:27 -0700 | [diff] [blame] | 300 | /** |
| 301 | * Common methods of the HDMI CEC device. This *must* be the first member of |
| 302 | * hdmi_cec_device as users of this structure will cast a hw_device_t to hdmi_cec_device |
| 303 | * pointer in contexts where it's known the hw_device_t references a hdmi_cec_device. |
| 304 | */ |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 305 | struct hw_device_t common; |
| 306 | |
| 307 | /* |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 308 | * (*add_logical_address)() passes the logical address that will be used |
| 309 | * in this system. |
Jinsuk Kim | f02ed91 | 2014-04-10 19:24:02 +0900 | [diff] [blame] | 310 | * |
| 311 | * HAL may use it to configure the hardware so that the CEC commands addressed |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 312 | * the given logical address can be filtered in. This method can be called |
| 313 | * as many times as necessary in order to support multiple logical devices. |
| 314 | * addr should be in the range of valid logical addresses for the call |
| 315 | * to succeed. |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 316 | * |
| 317 | * Returns 0 on success or -errno on error. |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 318 | */ |
Jinsuk Kim | f02ed91 | 2014-04-10 19:24:02 +0900 | [diff] [blame] | 319 | int (*add_logical_address)(const struct hdmi_cec_device* dev, cec_logical_address_t addr); |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 320 | |
| 321 | /* |
Jinsuk Kim | f02ed91 | 2014-04-10 19:24:02 +0900 | [diff] [blame] | 322 | * (*clear_logical_address)() tells HAL to reset all the logical addresses. |
Jinsuk Kim | 98add89 | 2014-03-05 18:08:02 +0900 | [diff] [blame] | 323 | * |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 324 | * It is used when the system doesn't need to process CEC command any more, |
| 325 | * hence to tell HAL to stop receiving commands from the CEC bus, and change |
| 326 | * the state back to the beginning. |
Jinsuk Kim | 98add89 | 2014-03-05 18:08:02 +0900 | [diff] [blame] | 327 | */ |
Jinsuk Kim | f02ed91 | 2014-04-10 19:24:02 +0900 | [diff] [blame] | 328 | void (*clear_logical_address)(const struct hdmi_cec_device* dev); |
| 329 | |
Jinsuk Kim | 98add89 | 2014-03-05 18:08:02 +0900 | [diff] [blame] | 330 | /* |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 331 | * (*get_physical_address)() returns the CEC physical address. The |
| 332 | * address is written to addr. |
| 333 | * |
| 334 | * The physical address depends on the topology of the network formed |
| 335 | * by connected HDMI devices. It is therefore likely to change if the cable |
| 336 | * is plugged off and on again. It is advised to call get_physical_address |
| 337 | * to get the updated address when hot plug event takes place. |
| 338 | * |
| 339 | * Returns 0 on success or -errno on error. |
| 340 | */ |
| 341 | int (*get_physical_address)(const struct hdmi_cec_device* dev, uint16_t* addr); |
| 342 | |
| 343 | /* |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 344 | * (*send_message)() transmits HDMI-CEC message to other HDMI device. |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 345 | * |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 346 | * The method should be designed to return in a certain amount of time not |
| 347 | * hanging forever, which can happen if CEC signal line is pulled low for |
| 348 | * some reason. HAL implementation should take the situation into account |
| 349 | * so as not to wait forever for the message to get sent out. |
| 350 | * |
Jinsuk Kim | 634e948 | 2014-07-28 07:51:32 +0000 | [diff] [blame] | 351 | * It should try retransmission at least once as specified in the standard. |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 352 | * |
| 353 | * Returns error code. See HDMI_RESULT_SUCCESS, HDMI_RESULT_NACK, and |
| 354 | * HDMI_RESULT_BUSY. |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 355 | */ |
Jinsuk Kim | efbdb25 | 2014-03-24 13:26:40 +0900 | [diff] [blame] | 356 | int (*send_message)(const struct hdmi_cec_device* dev, const cec_message_t*); |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 357 | |
| 358 | /* |
| 359 | * (*register_event_callback)() registers a callback that HDMI-CEC HAL |
| 360 | * can later use for incoming CEC messages or internal HDMI events. |
Jinsuk Kim | 70ae777 | 2014-03-06 19:25:19 +0900 | [diff] [blame] | 361 | * When calling from C++, use the argument arg to pass the calling object. |
| 362 | * It will be passed back when the callback is invoked so that the context |
| 363 | * can be retrieved. |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 364 | */ |
| 365 | void (*register_event_callback)(const struct hdmi_cec_device* dev, |
Jinsuk Kim | 70ae777 | 2014-03-06 19:25:19 +0900 | [diff] [blame] | 366 | event_callback_t callback, void* arg); |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 367 | |
| 368 | /* |
Jinsuk Kim | f02ed91 | 2014-04-10 19:24:02 +0900 | [diff] [blame] | 369 | * (*get_version)() returns the CEC version supported by underlying hardware. |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 370 | */ |
| 371 | void (*get_version)(const struct hdmi_cec_device* dev, int* version); |
| 372 | |
| 373 | /* |
| 374 | * (*get_vendor_id)() returns the identifier of the vendor. It is |
| 375 | * the 24-bit unique company ID obtained from the IEEE Registration |
| 376 | * Authority Committee (RAC). |
| 377 | */ |
| 378 | void (*get_vendor_id)(const struct hdmi_cec_device* dev, uint32_t* vendor_id); |
| 379 | |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 380 | /* |
| 381 | * (*get_port_info)() returns the hdmi port information of underlying hardware. |
| 382 | * info is the list of HDMI port information, and 'total' is the number of |
| 383 | * HDMI ports in the system. |
| 384 | */ |
| 385 | void (*get_port_info)(const struct hdmi_cec_device* dev, |
| 386 | struct hdmi_port_info* list[], int* total); |
| 387 | |
| 388 | /* |
| 389 | * (*set_option)() passes flags controlling the way HDMI-CEC service works down |
| 390 | * to HAL implementation. Those flags will be used in case the feature needs |
| 391 | * update in HAL itself, firmware or microcontroller. |
| 392 | */ |
| 393 | void (*set_option)(const struct hdmi_cec_device* dev, int flag, int value); |
| 394 | |
| 395 | /* |
| 396 | * (*set_audio_return_channel)() configures ARC circuit in the hardware logic |
| 397 | * to start or stop the feature. Flag can be either 1 to start the feature |
| 398 | * or 0 to stop it. |
| 399 | * |
| 400 | * Returns 0 on success or -errno on error. |
| 401 | */ |
Jinsuk Kim | 4b280b0 | 2014-12-17 16:22:54 +0900 | [diff] [blame] | 402 | void (*set_audio_return_channel)(const struct hdmi_cec_device* dev, int port_id, int flag); |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 403 | |
| 404 | /* |
| 405 | * (*is_connected)() returns the connection status of the specified port. |
| 406 | * Returns HDMI_CONNECTED if a device is connected, otherwise HDMI_NOT_CONNECTED. |
| 407 | * The HAL should watch for +5V power signal to determine the status. |
| 408 | */ |
Jinsuk Kim | ca6fa79 | 2014-07-09 17:17:24 +0900 | [diff] [blame] | 409 | int (*is_connected)(const struct hdmi_cec_device* dev, int port_id); |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 410 | |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 411 | /* Reserved for future use to maximum 16 functions. Must be NULL. */ |
Jinsuk Kim | c4178a6 | 2014-05-14 11:01:00 +0900 | [diff] [blame] | 412 | void* reserved[16 - 11]; |
Jinsuk Kim | 62195dc | 2014-02-19 10:21:35 +0900 | [diff] [blame] | 413 | } hdmi_cec_device_t; |
| 414 | |
| 415 | /** convenience API for opening and closing a device */ |
| 416 | |
| 417 | static inline int hdmi_cec_open(const struct hw_module_t* module, |
| 418 | struct hdmi_cec_device** device) { |
| 419 | return module->methods->open(module, |
| 420 | HDMI_CEC_HARDWARE_INTERFACE, (struct hw_device_t**)device); |
| 421 | } |
| 422 | |
| 423 | static inline int hdmi_cec_close(struct hdmi_cec_device* device) { |
| 424 | return device->common.close(&device->common); |
| 425 | } |
| 426 | |
| 427 | __END_DECLS |
| 428 | |
| 429 | #endif /* ANDROID_INCLUDE_HARDWARE_HDMI_CEC_H */ |