drivers/gpu/drm/amd/display/dc/basics/logger.c

   1 /*
   2  * Copyright 2012-15 Advanced Micro Devices, Inc.
   3  *
   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:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  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.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25 #include "dm_services.h"
  26 #include "include/logger_interface.h"
  27 #include "logger.h"
  28
  29
  30 #define NUM_ELEMENTS(a) (sizeof(a) / sizeof((a)[0]))
  31
  32 static const struct dc_log_type_info log_type_info_tbl[] = {
  33                 {LOG_ERROR,                 "Error"},
  34                 {LOG_WARNING,               "Warning"},
  35                 {LOG_DEBUG,                 "Debug"},
  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"},
  44                 {LOG_MST,                   "MST"},
  45                 {LOG_SCALER,                "Scaler"},
  46                 {LOG_BIOS,                  "BIOS"},
  47                 {LOG_BANDWIDTH_CALCS,       "BWCalcs"},
  48                 {LOG_BANDWIDTH_VALIDATION,  "BWValidation"},
  49                 {LOG_I2C_AUX,               "I2C_AUX"},
  50                 {LOG_SYNC,                  "Sync"},
  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"},
  56                 {LOG_DML,                   "DML"},
  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"},
  63                 {LOG_DTN,                   "DTN"},
  64                 {LOG_DISPLAYSTATS,          "DisplayStats"}
  65 };
  66
  67
  68 /* ----------- Object init and destruction ----------- */
  69 static bool construct(struct dc_context *ctx, struct dal_logger *logger,
  70                       uint32_t log_mask)
  71 {
  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),
  75                                      GFP_KERNEL);
  76         if (!logger->log_buffer)
  77                 return false;
  78
  79         /* Initialize both offsets to start of buffer (empty) */
  80         logger->buffer_read_offset = 0;
  81         logger->buffer_write_offset = 0;
  82
  83         logger->open_count = 0;
  84
  85         logger->flags.bits.ENABLE_CONSOLE = 1;
  86         logger->flags.bits.ENABLE_BUFFER = 0;
  87
  88         logger->ctx = ctx;
  89
  90         logger->mask = log_mask;
  91
  92         return true;
  93 }
  94
  95 static void destruct(struct dal_logger *logger)
  96 {
  97         if (logger->log_buffer) {
  98                 kfree(logger->log_buffer);
  99                 logger->log_buffer = NULL;
 100         }
 101 }
 102
 103 struct dal_logger *dal_logger_create(struct dc_context *ctx, uint32_t log_mask)
 104 {
 105         /* malloc struct */
 106         struct dal_logger *logger = kzalloc(sizeof(struct dal_logger),
 107                                             GFP_KERNEL);
 108
 109         if (!logger)
 110                 return NULL;
 111         if (!construct(ctx, logger, log_mask)) {
 112                 kfree(logger);
 113                 return NULL;
 114         }
 115
 116         return logger;
 117 }
 118
 119 uint32_t dal_logger_destroy(struct dal_logger **logger)
 120 {
 121         if (logger == NULL || *logger == NULL)
 122                 return 1;
 123         destruct(*logger);
 124         kfree(*logger);
 125         *logger = NULL;
 126
 127         return 0;
 128 }
 129
 130 /* ------------------------------------------------------------------------ */
 131
 132
 133 static bool dal_logger_should_log(
 134         struct dal_logger *logger,
 135         enum dc_log_type log_type)
 136 {
 137         if (logger->mask & (1 << log_type))
 138                 return true;
 139
 140         return false;
 141 }
 142
 143 static void log_to_debug_console(struct log_entry *entry)
 144 {
 145         struct dal_logger *logger = entry->logger;
 146
 147         if (logger->flags.bits.ENABLE_CONSOLE == 0)
 148                 return;
 149
 150         if (entry->buf_offset) {
 151                 switch (entry->type) {
 152                 case LOG_ERROR:
 153                         dm_error("%s", entry->buf);
 154                         break;
 155                 default:
 156                         dm_output_to_console("%s", entry->buf);
 157                         break;
 158                 }
 159         }
 160 }
 161
 162 /* Print everything unread existing in log_buffer to debug console*/
 163 void dm_logger_flush_buffer(struct dal_logger *logger, bool should_warn)
 164 {
 165         char *string_start = &logger->log_buffer[logger->buffer_read_offset];
 166
 167         if (should_warn)
 168                 dm_output_to_console(
 169                         "---------------- FLUSHING LOG BUFFER ----------------\n");
 170         while (logger->buffer_read_offset < logger->buffer_write_offset) {
 171
 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;
 175                 }
 176                 logger->buffer_read_offset++;
 177         }
 178         if (should_warn)
 179                 dm_output_to_console(
 180                         "-------------- END FLUSHING LOG BUFFER --------------\n\n");
 181 }
 182
 183 static void log_to_internal_buffer(struct log_entry *entry)
 184 {
 185
 186         uint32_t size = entry->buf_offset;
 187         struct dal_logger *logger = entry->logger;
 188
 189         if (logger->flags.bits.ENABLE_BUFFER == 0)
 190                 return;
 191
 192         if (logger->log_buffer == NULL)
 193                 return;
 194
 195         if (size > 0 && size < logger->log_buffer_size) {
 196
 197                 int buffer_space = logger->log_buffer_size -
 198                                 logger->buffer_write_offset;
 199
 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;
 205                 }
 206
 207                 if (buffer_space > size) {
 208                         /* No wrap around, copy 'size' bytes
 209                          * from 'entry->buf' to 'log_buffer'
 210                          */
 211                         memmove(logger->log_buffer +
 212                                         logger->buffer_write_offset,
 213                                         entry->buf, size);
 214                         logger->buffer_write_offset += size;
 215
 216                 } else {
 217                         /* Not enough room remaining, we should flush
 218                          * existing logs */
 219
 220                         /* Flush existing unread logs to console */
 221                         dm_logger_flush_buffer(logger, true);
 222
 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;
 227                 }
 228
 229         }
 230 }
 231
 232 static void log_heading(struct log_entry *entry)
 233 {
 234         int j;
 235
 236         for (j = 0; j < NUM_ELEMENTS(log_type_info_tbl); j++) {
 237
 238                 const struct dc_log_type_info *info = &log_type_info_tbl[j];
 239
 240                 if (info->type == entry->type)
 241                         dm_logger_append(entry, "[%s]\t", info->name);
 242         }
 243 }
 244
 245 static void append_entry(
 246                 struct log_entry *entry,
 247                 char *buffer,
 248                 uint32_t buf_size)
 249 {
 250         if (!entry->buf ||
 251                 entry->buf_offset + buf_size > entry->max_buf_bytes
 252         ) {
 253                 BREAK_TO_DEBUGGER();
 254                 return;
 255         }
 256
 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;
 260 }
 261
 262 /* ------------------------------------------------------------------------ */
 263
 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'
 266  */
 267 void dm_logger_write(
 268         struct dal_logger *logger,
 269         enum dc_log_type log_type,
 270         const char *msg,
 271         ...)
 272 {
 273         if (logger && dal_logger_should_log(logger, log_type)) {
 274                 uint32_t size;
 275                 va_list args;
 276                 char buffer[LOG_MAX_LINE_SIZE];
 277                 struct log_entry entry;
 278
 279                 va_start(args, msg);
 280
 281                 entry.logger = logger;
 282
 283                 entry.buf = buffer;
 284
 285                 entry.buf_offset = 0;
 286                 entry.max_buf_bytes = DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char);
 287
 288                 entry.type = log_type;
 289
 290                 log_heading(&entry);
 291
 292                 size = dm_log_to_buffer(
 293                         buffer, LOG_MAX_LINE_SIZE - 1, msg, args);
 294
 295                 buffer[entry.buf_offset + size] = '\0';
 296                 entry.buf_offset += size + 1;
 297
 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);
 303
 304                 va_end(args);
 305         }
 306 }
 307
 308 /* Same as dm_logger_write, except without open() and close(), which must
 309  * be done separately.
 310  */
 311 void dm_logger_append(
 312         struct log_entry *entry,
 313         const char *msg,
 314         ...)
 315 {
 316         va_list args;
 317
 318         va_start(args, msg);
 319         dm_logger_append_va(entry, msg, args);
 320         va_end(args);
 321 }
 322
 323 void dm_logger_append_va(
 324         struct log_entry *entry,
 325         const char *msg,
 326         va_list args)
 327 {
 328         struct dal_logger *logger;
 329
 330         if (!entry) {
 331                 BREAK_TO_DEBUGGER();
 332                 return;
 333         }
 334
 335         logger = entry->logger;
 336
 337         if (logger && logger->open_count > 0 &&
 338                 dal_logger_should_log(logger, entry->type)) {
 339
 340                 uint32_t size;
 341                 char buffer[LOG_MAX_LINE_SIZE];
 342
 343                 size = dm_log_to_buffer(
 344                         buffer, LOG_MAX_LINE_SIZE, msg, args);
 345
 346                 if (size < LOG_MAX_LINE_SIZE - 1) {
 347                         append_entry(entry, buffer, size);
 348                 } else {
 349                         append_entry(entry, "LOG_ERROR, line too long\n", 27);
 350                 }
 351         }
 352 }
 353
 354 void dm_logger_open(
 355                 struct dal_logger *logger,
 356                 struct log_entry *entry, /* out */
 357                 enum dc_log_type log_type)
 358 {
 359         if (!entry) {
 360                 BREAK_TO_DEBUGGER();
 361                 return;
 362         }
 363
 364         entry->type = log_type;
 365         entry->logger = logger;
 366
 367         entry->buf = kzalloc(DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char),
 368                              GFP_KERNEL);
 369
 370         entry->buf_offset = 0;
 371         entry->max_buf_bytes = DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char);
 372
 373         logger->open_count++;
 374
 375         log_heading(entry);
 376 }
 377
 378 void dm_logger_close(struct log_entry *entry)
 379 {
 380         struct dal_logger *logger = entry->logger;
 381
 382         if (logger && logger->open_count > 0) {
 383                 logger->open_count--;
 384         } else {
 385                 BREAK_TO_DEBUGGER();
 386                 goto cleanup;
 387         }
 388
 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);
 394
 395         /* TODO: Write end heading */
 396
 397 cleanup:
 398         if (entry->buf) {
 399                 kfree(entry->buf);
 400                 entry->buf = NULL;
 401                 entry->buf_offset = 0;
 402                 entry->max_buf_bytes = 0;
 403         }
 404 }
 405