2 * Copyright 2012-15 Advanced Micro Devices, Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
25 #include "dm_services.h"
26 #include "include/logger_interface.h"
30 #define NUM_ELEMENTS(a) (sizeof(a) / sizeof((a)[0]))
32 static const struct dc_log_type_info log_type_info_tbl
[] = {
34 {LOG_WARNING
, "Warning"},
36 {LOG_DC
, "DC_Interface"},
37 {LOG_SURFACE
, "Surface"},
38 {LOG_HW_HOTPLUG
, "HW_Hotplug"},
39 {LOG_HW_LINK_TRAINING
, "HW_LKTN"},
40 {LOG_HW_SET_MODE
, "HW_Mode"},
41 {LOG_HW_RESUME_S3
, "HW_Resume"},
42 {LOG_HW_AUDIO
, "HW_Audio"},
43 {LOG_HW_HPD_IRQ
, "HW_HPDIRQ"},
45 {LOG_SCALER
, "Scaler"},
47 {LOG_BANDWIDTH_CALCS
, "BWCalcs"},
48 {LOG_BANDWIDTH_VALIDATION
, "BWValidation"},
49 {LOG_I2C_AUX
, "I2C_AUX"},
51 {LOG_BACKLIGHT
, "Backlight"},
52 {LOG_FEATURE_OVERRIDE
, "Override"},
53 {LOG_DETECTION_EDID_PARSER
, "Edid"},
54 {LOG_DETECTION_DP_CAPS
, "DP_Caps"},
55 {LOG_RESOURCE
, "Resource"},
57 {LOG_EVENT_MODE_SET
, "Mode"},
58 {LOG_EVENT_DETECTION
, "Detect"},
59 {LOG_EVENT_LINK_TRAINING
, "LKTN"},
60 {LOG_EVENT_LINK_LOSS
, "LinkLoss"},
61 {LOG_EVENT_UNDERFLOW
, "Underflow"},
62 {LOG_IF_TRACE
, "InterfaceTrace"},
64 {LOG_DISPLAYSTATS
, "DisplayStats"}
68 /* ----------- Object init and destruction ----------- */
69 static bool construct(struct dc_context
*ctx
, struct dal_logger
*logger
,
72 /* malloc buffer and init offsets */
73 logger
->log_buffer_size
= DAL_LOGGER_BUFFER_MAX_SIZE
;
74 logger
->log_buffer
= kcalloc(logger
->log_buffer_size
, sizeof(char),
76 if (!logger
->log_buffer
)
79 /* Initialize both offsets to start of buffer (empty) */
80 logger
->buffer_read_offset
= 0;
81 logger
->buffer_write_offset
= 0;
83 logger
->open_count
= 0;
85 logger
->flags
.bits
.ENABLE_CONSOLE
= 1;
86 logger
->flags
.bits
.ENABLE_BUFFER
= 0;
90 logger
->mask
= log_mask
;
95 static void destruct(struct dal_logger
*logger
)
97 if (logger
->log_buffer
) {
98 kfree(logger
->log_buffer
);
99 logger
->log_buffer
= NULL
;
103 struct dal_logger
*dal_logger_create(struct dc_context
*ctx
, uint32_t log_mask
)
106 struct dal_logger
*logger
= kzalloc(sizeof(struct dal_logger
),
111 if (!construct(ctx
, logger
, log_mask
)) {
119 uint32_t dal_logger_destroy(struct dal_logger
**logger
)
121 if (logger
== NULL
|| *logger
== NULL
)
130 /* ------------------------------------------------------------------------ */
133 static bool dal_logger_should_log(
134 struct dal_logger
*logger
,
135 enum dc_log_type log_type
)
137 if (logger
->mask
& (1 << log_type
))
143 static void log_to_debug_console(struct log_entry
*entry
)
145 struct dal_logger
*logger
= entry
->logger
;
147 if (logger
->flags
.bits
.ENABLE_CONSOLE
== 0)
150 if (entry
->buf_offset
) {
151 switch (entry
->type
) {
153 dm_error("%s", entry
->buf
);
156 dm_output_to_console("%s", entry
->buf
);
162 /* Print everything unread existing in log_buffer to debug console*/
163 void dm_logger_flush_buffer(struct dal_logger
*logger
, bool should_warn
)
165 char *string_start
= &logger
->log_buffer
[logger
->buffer_read_offset
];
168 dm_output_to_console(
169 "---------------- FLUSHING LOG BUFFER ----------------\n");
170 while (logger
->buffer_read_offset
< logger
->buffer_write_offset
) {
172 if (logger
->log_buffer
[logger
->buffer_read_offset
] == '\0') {
173 dm_output_to_console("%s", string_start
);
174 string_start
= logger
->log_buffer
+ logger
->buffer_read_offset
+ 1;
176 logger
->buffer_read_offset
++;
179 dm_output_to_console(
180 "-------------- END FLUSHING LOG BUFFER --------------\n\n");
183 static void log_to_internal_buffer(struct log_entry
*entry
)
186 uint32_t size
= entry
->buf_offset
;
187 struct dal_logger
*logger
= entry
->logger
;
189 if (logger
->flags
.bits
.ENABLE_BUFFER
== 0)
192 if (logger
->log_buffer
== NULL
)
195 if (size
> 0 && size
< logger
->log_buffer_size
) {
197 int buffer_space
= logger
->log_buffer_size
-
198 logger
->buffer_write_offset
;
200 if (logger
->buffer_write_offset
== logger
->buffer_read_offset
) {
201 /* Buffer is empty, start writing at beginning */
202 buffer_space
= logger
->log_buffer_size
;
203 logger
->buffer_write_offset
= 0;
204 logger
->buffer_read_offset
= 0;
207 if (buffer_space
> size
) {
208 /* No wrap around, copy 'size' bytes
209 * from 'entry->buf' to 'log_buffer'
211 memmove(logger
->log_buffer
+
212 logger
->buffer_write_offset
,
214 logger
->buffer_write_offset
+= size
;
217 /* Not enough room remaining, we should flush
220 /* Flush existing unread logs to console */
221 dm_logger_flush_buffer(logger
, true);
223 /* Start writing to beginning of buffer */
224 memmove(logger
->log_buffer
, entry
->buf
, size
);
225 logger
->buffer_write_offset
= size
;
226 logger
->buffer_read_offset
= 0;
232 static void log_heading(struct log_entry
*entry
)
236 for (j
= 0; j
< NUM_ELEMENTS(log_type_info_tbl
); j
++) {
238 const struct dc_log_type_info
*info
= &log_type_info_tbl
[j
];
240 if (info
->type
== entry
->type
)
241 dm_logger_append(entry
, "[%s]\t", info
->name
);
245 static void append_entry(
246 struct log_entry
*entry
,
251 entry
->buf_offset
+ buf_size
> entry
->max_buf_bytes
257 /* Todo: check if off by 1 byte due to \0 anywhere */
258 memmove(entry
->buf
+ entry
->buf_offset
, buffer
, buf_size
);
259 entry
->buf_offset
+= buf_size
;
262 /* ------------------------------------------------------------------------ */
264 /* Warning: Be careful that 'msg' is null terminated and the total size is
265 * less than DAL_LOGGER_BUFFER_MAX_LOG_LINE_SIZE (256) including '\0'
267 void dm_logger_write(
268 struct dal_logger
*logger
,
269 enum dc_log_type log_type
,
273 if (logger
&& dal_logger_should_log(logger
, log_type
)) {
276 char buffer
[LOG_MAX_LINE_SIZE
];
277 struct log_entry entry
;
281 entry
.logger
= logger
;
285 entry
.buf_offset
= 0;
286 entry
.max_buf_bytes
= DAL_LOGGER_BUFFER_MAX_SIZE
* sizeof(char);
288 entry
.type
= log_type
;
292 size
= dm_log_to_buffer(
293 buffer
, LOG_MAX_LINE_SIZE
- 1, msg
, args
);
295 buffer
[entry
.buf_offset
+ size
] = '\0';
296 entry
.buf_offset
+= size
+ 1;
298 /* --Flush log_entry buffer-- */
299 /* print to kernel console */
300 log_to_debug_console(&entry
);
301 /* log internally for dsat */
302 log_to_internal_buffer(&entry
);
308 /* Same as dm_logger_write, except without open() and close(), which must
309 * be done separately.
311 void dm_logger_append(
312 struct log_entry
*entry
,
319 dm_logger_append_va(entry
, msg
, args
);
323 void dm_logger_append_va(
324 struct log_entry
*entry
,
328 struct dal_logger
*logger
;
335 logger
= entry
->logger
;
337 if (logger
&& logger
->open_count
> 0 &&
338 dal_logger_should_log(logger
, entry
->type
)) {
341 char buffer
[LOG_MAX_LINE_SIZE
];
343 size
= dm_log_to_buffer(
344 buffer
, LOG_MAX_LINE_SIZE
, msg
, args
);
346 if (size
< LOG_MAX_LINE_SIZE
- 1) {
347 append_entry(entry
, buffer
, size
);
349 append_entry(entry
, "LOG_ERROR, line too long\n", 27);
355 struct dal_logger
*logger
,
356 struct log_entry
*entry
, /* out */
357 enum dc_log_type log_type
)
364 entry
->type
= log_type
;
365 entry
->logger
= logger
;
367 entry
->buf
= kzalloc(DAL_LOGGER_BUFFER_MAX_SIZE
,
370 entry
->buf_offset
= 0;
371 entry
->max_buf_bytes
= DAL_LOGGER_BUFFER_MAX_SIZE
* sizeof(char);
373 logger
->open_count
++;
378 void dm_logger_close(struct log_entry
*entry
)
380 struct dal_logger
*logger
= entry
->logger
;
382 if (logger
&& logger
->open_count
> 0) {
383 logger
->open_count
--;
389 /* --Flush log_entry buffer-- */
390 /* print to kernel console */
391 log_to_debug_console(entry
);
392 /* log internally for dsat */
393 log_to_internal_buffer(entry
);
395 /* TODO: Write end heading */
401 entry
->buf_offset
= 0;
402 entry
->max_buf_bytes
= 0;