Commit | Line | Data |
---|---|---|
f142d3bd TR |
1 | /* |
2 | * Copyright (C) 2012 Avionic Design GmbH | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | */ | |
8 | ||
9 | #include <linux/bitops.h> | |
10 | #include <linux/errno.h> | |
11 | #include <linux/export.h> | |
12 | #include <linux/hdmi.h> | |
13 | #include <linux/string.h> | |
14 | ||
15 | static void hdmi_infoframe_checksum(void *buffer, size_t size) | |
16 | { | |
17 | u8 *ptr = buffer; | |
18 | u8 csum = 0; | |
19 | size_t i; | |
20 | ||
21 | /* compute checksum */ | |
22 | for (i = 0; i < size; i++) | |
23 | csum += ptr[i]; | |
24 | ||
25 | ptr[3] = 256 - csum; | |
26 | } | |
27 | ||
28 | /** | |
29 | * hdmi_avi_infoframe_init() - initialize an HDMI AVI infoframe | |
30 | * @frame: HDMI AVI infoframe | |
31 | * | |
32 | * Returns 0 on success or a negative error code on failure. | |
33 | */ | |
34 | int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame) | |
35 | { | |
36 | memset(frame, 0, sizeof(*frame)); | |
37 | ||
38 | frame->type = HDMI_INFOFRAME_TYPE_AVI; | |
39 | frame->version = 2; | |
40 | frame->length = 13; | |
41 | ||
42 | return 0; | |
43 | } | |
44 | EXPORT_SYMBOL(hdmi_avi_infoframe_init); | |
45 | ||
46 | /** | |
47 | * hdmi_avi_infoframe_pack() - write HDMI AVI infoframe to binary buffer | |
48 | * @frame: HDMI AVI infoframe | |
49 | * @buffer: destination buffer | |
50 | * @size: size of buffer | |
51 | * | |
52 | * Packs the information contained in the @frame structure into a binary | |
53 | * representation that can be written into the corresponding controller | |
54 | * registers. Also computes the checksum as required by section 5.3.5 of | |
55 | * the HDMI 1.4 specification. | |
56 | * | |
57 | * Returns the number of bytes packed into the binary buffer or a negative | |
58 | * error code on failure. | |
59 | */ | |
60 | ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer, | |
61 | size_t size) | |
62 | { | |
63 | u8 *ptr = buffer; | |
64 | size_t length; | |
65 | ||
66 | length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; | |
67 | ||
68 | if (size < length) | |
69 | return -ENOSPC; | |
70 | ||
71 | memset(buffer, 0, length); | |
72 | ||
73 | ptr[0] = frame->type; | |
74 | ptr[1] = frame->version; | |
75 | ptr[2] = frame->length; | |
76 | ptr[3] = 0; /* checksum */ | |
77 | ||
78 | /* start infoframe payload */ | |
79 | ptr += HDMI_INFOFRAME_HEADER_SIZE; | |
80 | ||
81 | ptr[0] = ((frame->colorspace & 0x3) << 5) | (frame->scan_mode & 0x3); | |
82 | ||
83 | if (frame->active_info_valid) | |
84 | ptr[0] |= BIT(4); | |
85 | ||
86 | if (frame->horizontal_bar_valid) | |
87 | ptr[0] |= BIT(3); | |
88 | ||
89 | if (frame->vertical_bar_valid) | |
90 | ptr[0] |= BIT(2); | |
91 | ||
92 | ptr[1] = ((frame->colorimetry & 0x3) << 6) | | |
93 | ((frame->picture_aspect & 0x3) << 4) | | |
94 | (frame->active_aspect & 0xf); | |
95 | ||
96 | ptr[2] = ((frame->extended_colorimetry & 0x7) << 4) | | |
97 | ((frame->quantization_range & 0x3) << 2) | | |
98 | (frame->nups & 0x3); | |
99 | ||
100 | if (frame->itc) | |
101 | ptr[2] |= BIT(7); | |
102 | ||
103 | ptr[3] = frame->video_code & 0x7f; | |
104 | ||
105 | ptr[4] = ((frame->ycc_quantization_range & 0x3) << 6) | | |
106 | ((frame->content_type & 0x3) << 4) | | |
107 | (frame->pixel_repeat & 0xf); | |
108 | ||
109 | ptr[5] = frame->top_bar & 0xff; | |
110 | ptr[6] = (frame->top_bar >> 8) & 0xff; | |
111 | ptr[7] = frame->bottom_bar & 0xff; | |
112 | ptr[8] = (frame->bottom_bar >> 8) & 0xff; | |
113 | ptr[9] = frame->left_bar & 0xff; | |
114 | ptr[10] = (frame->left_bar >> 8) & 0xff; | |
115 | ptr[11] = frame->right_bar & 0xff; | |
116 | ptr[12] = (frame->right_bar >> 8) & 0xff; | |
117 | ||
118 | hdmi_infoframe_checksum(buffer, length); | |
119 | ||
120 | return length; | |
121 | } | |
122 | EXPORT_SYMBOL(hdmi_avi_infoframe_pack); | |
123 | ||
124 | /** | |
125 | * hdmi_spd_infoframe_init() - initialize an HDMI SPD infoframe | |
126 | * @frame: HDMI SPD infoframe | |
127 | * @vendor: vendor string | |
128 | * @product: product string | |
129 | * | |
130 | * Returns 0 on success or a negative error code on failure. | |
131 | */ | |
132 | int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame, | |
133 | const char *vendor, const char *product) | |
134 | { | |
135 | memset(frame, 0, sizeof(*frame)); | |
136 | ||
137 | frame->type = HDMI_INFOFRAME_TYPE_SPD; | |
138 | frame->version = 1; | |
139 | frame->length = 25; | |
140 | ||
141 | strncpy(frame->vendor, vendor, sizeof(frame->vendor)); | |
142 | strncpy(frame->product, product, sizeof(frame->product)); | |
143 | ||
144 | return 0; | |
145 | } | |
146 | EXPORT_SYMBOL(hdmi_spd_infoframe_init); | |
147 | ||
148 | /** | |
149 | * hdmi_spd_infoframe_pack() - write HDMI SPD infoframe to binary buffer | |
150 | * @frame: HDMI SPD infoframe | |
151 | * @buffer: destination buffer | |
152 | * @size: size of buffer | |
153 | * | |
154 | * Packs the information contained in the @frame structure into a binary | |
155 | * representation that can be written into the corresponding controller | |
156 | * registers. Also computes the checksum as required by section 5.3.5 of | |
157 | * the HDMI 1.4 specification. | |
158 | * | |
159 | * Returns the number of bytes packed into the binary buffer or a negative | |
160 | * error code on failure. | |
161 | */ | |
162 | ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer, | |
163 | size_t size) | |
164 | { | |
165 | u8 *ptr = buffer; | |
166 | size_t length; | |
167 | ||
168 | length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; | |
169 | ||
170 | if (size < length) | |
171 | return -ENOSPC; | |
172 | ||
173 | memset(buffer, 0, length); | |
174 | ||
175 | ptr[0] = frame->type; | |
176 | ptr[1] = frame->version; | |
177 | ptr[2] = frame->length; | |
178 | ptr[3] = 0; /* checksum */ | |
179 | ||
180 | /* start infoframe payload */ | |
181 | ptr += HDMI_INFOFRAME_HEADER_SIZE; | |
182 | ||
183 | memcpy(ptr, frame->vendor, sizeof(frame->vendor)); | |
184 | memcpy(ptr + 8, frame->product, sizeof(frame->product)); | |
185 | ||
186 | ptr[24] = frame->sdi; | |
187 | ||
188 | hdmi_infoframe_checksum(buffer, length); | |
189 | ||
190 | return length; | |
191 | } | |
192 | EXPORT_SYMBOL(hdmi_spd_infoframe_pack); | |
193 | ||
194 | /** | |
195 | * hdmi_audio_infoframe_init() - initialize an HDMI audio infoframe | |
196 | * @frame: HDMI audio infoframe | |
197 | * | |
198 | * Returns 0 on success or a negative error code on failure. | |
199 | */ | |
200 | int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame) | |
201 | { | |
202 | memset(frame, 0, sizeof(*frame)); | |
203 | ||
204 | frame->type = HDMI_INFOFRAME_TYPE_AUDIO; | |
205 | frame->version = 1; | |
206 | frame->length = 10; | |
207 | ||
208 | return 0; | |
209 | } | |
210 | EXPORT_SYMBOL(hdmi_audio_infoframe_init); | |
211 | ||
212 | /** | |
213 | * hdmi_audio_infoframe_pack() - write HDMI audio infoframe to binary buffer | |
214 | * @frame: HDMI audio infoframe | |
215 | * @buffer: destination buffer | |
216 | * @size: size of buffer | |
217 | * | |
218 | * Packs the information contained in the @frame structure into a binary | |
219 | * representation that can be written into the corresponding controller | |
220 | * registers. Also computes the checksum as required by section 5.3.5 of | |
221 | * the HDMI 1.4 specification. | |
222 | * | |
223 | * Returns the number of bytes packed into the binary buffer or a negative | |
224 | * error code on failure. | |
225 | */ | |
226 | ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame, | |
227 | void *buffer, size_t size) | |
228 | { | |
229 | unsigned char channels; | |
230 | u8 *ptr = buffer; | |
231 | size_t length; | |
232 | ||
233 | length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; | |
234 | ||
235 | if (size < length) | |
236 | return -ENOSPC; | |
237 | ||
238 | memset(buffer, 0, length); | |
239 | ||
240 | if (frame->channels >= 2) | |
241 | channels = frame->channels - 1; | |
242 | else | |
243 | channels = 0; | |
244 | ||
245 | ptr[0] = frame->type; | |
246 | ptr[1] = frame->version; | |
247 | ptr[2] = frame->length; | |
248 | ptr[3] = 0; /* checksum */ | |
249 | ||
250 | /* start infoframe payload */ | |
251 | ptr += HDMI_INFOFRAME_HEADER_SIZE; | |
252 | ||
253 | ptr[0] = ((frame->coding_type & 0xf) << 4) | (channels & 0x7); | |
254 | ptr[1] = ((frame->sample_frequency & 0x7) << 2) | | |
255 | (frame->sample_size & 0x3); | |
256 | ptr[2] = frame->coding_type_ext & 0x1f; | |
257 | ptr[3] = frame->channel_allocation; | |
258 | ptr[4] = (frame->level_shift_value & 0xf) << 3; | |
259 | ||
260 | if (frame->downmix_inhibit) | |
261 | ptr[4] |= BIT(7); | |
262 | ||
263 | hdmi_infoframe_checksum(buffer, length); | |
264 | ||
265 | return length; | |
266 | } | |
267 | EXPORT_SYMBOL(hdmi_audio_infoframe_pack); | |
268 | ||
269 | /** | |
270 | * hdmi_vendor_infoframe_pack() - write a HDMI vendor infoframe to binary | |
271 | * buffer | |
272 | * @frame: HDMI vendor infoframe | |
273 | * @buffer: destination buffer | |
274 | * @size: size of buffer | |
275 | * | |
276 | * Packs the information contained in the @frame structure into a binary | |
277 | * representation that can be written into the corresponding controller | |
278 | * registers. Also computes the checksum as required by section 5.3.5 of | |
279 | * the HDMI 1.4 specification. | |
280 | * | |
281 | * Returns the number of bytes packed into the binary buffer or a negative | |
282 | * error code on failure. | |
283 | */ | |
284 | ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame, | |
285 | void *buffer, size_t size) | |
286 | { | |
287 | u8 *ptr = buffer; | |
288 | size_t length; | |
289 | ||
290 | length = HDMI_INFOFRAME_HEADER_SIZE + frame->length; | |
291 | ||
292 | if (size < length) | |
293 | return -ENOSPC; | |
294 | ||
295 | memset(buffer, 0, length); | |
296 | ||
297 | ptr[0] = frame->type; | |
298 | ptr[1] = frame->version; | |
299 | ptr[2] = frame->length; | |
300 | ptr[3] = 0; /* checksum */ | |
301 | ||
302 | memcpy(&ptr[HDMI_INFOFRAME_HEADER_SIZE], frame->data, frame->length); | |
303 | ||
304 | hdmi_infoframe_checksum(buffer, length); | |
305 | ||
306 | return length; | |
307 | } | |
308 | EXPORT_SYMBOL(hdmi_vendor_infoframe_pack); |