drivers/gpu/drm/drm_print.c

   1 /*
   2  * Copyright (C) 2016 Red Hat
   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:
  23  * Rob Clark <robdclark@gmail.com>
  24  */
  25
  26 #define DEBUG /* for pr_debug() */
  27
  28 #include <stdarg.h>
  29
  30 #include <linux/io.h>
  31 #include <linux/seq_file.h>
  32 #include <linux/slab.h>
  33
  34 #include <drm/drm.h>
  35 #include <drm/drm_drv.h>
  36 #include <drm/drm_print.h>
  37
  38 void __drm_puts_coredump(struct drm_printer *p, const char *str)
  39 {
  40         struct drm_print_iterator *iterator = p->arg;
  41         ssize_t len;
  42
  43         if (!iterator->remain)
  44                 return;
  45
  46         if (iterator->offset < iterator->start) {
  47                 ssize_t copy;
  48
  49                 len = strlen(str);
  50
  51                 if (iterator->offset + len <= iterator->start) {
  52                         iterator->offset += len;
  53                         return;
  54                 }
  55
  56                 copy = len - (iterator->start - iterator->offset);
  57
  58                 if (copy > iterator->remain)
  59                         copy = iterator->remain;
  60
  61                 /* Copy out the bit of the string that we need */
  62                 memcpy(iterator->data,
  63                         str + (iterator->start - iterator->offset), copy);
  64
  65                 iterator->offset = iterator->start + copy;
  66                 iterator->remain -= copy;
  67         } else {
  68                 ssize_t pos = iterator->offset - iterator->start;
  69
  70                 len = min_t(ssize_t, strlen(str), iterator->remain);
  71
  72                 memcpy(iterator->data + pos, str, len);
  73
  74                 iterator->offset += len;
  75                 iterator->remain -= len;
  76         }
  77 }
  78 EXPORT_SYMBOL(__drm_puts_coredump);
  79
  80 void __drm_printfn_coredump(struct drm_printer *p, struct va_format *vaf)
  81 {
  82         struct drm_print_iterator *iterator = p->arg;
  83         size_t len;
  84         char *buf;
  85
  86         if (!iterator->remain)
  87                 return;
  88
  89         /* Figure out how big the string will be */
  90         len = snprintf(NULL, 0, "%pV", vaf);
  91
  92         /* This is the easiest path, we've already advanced beyond the offset */
  93         if (iterator->offset + len <= iterator->start) {
  94                 iterator->offset += len;
  95                 return;
  96         }
  97
  98         /* Then check if we can directly copy into the target buffer */
  99         if ((iterator->offset >= iterator->start) && (len < iterator->remain)) {
 100                 ssize_t pos = iterator->offset - iterator->start;
 101
 102                 snprintf(((char *) iterator->data) + pos,
 103                         iterator->remain, "%pV", vaf);
 104
 105                 iterator->offset += len;
 106                 iterator->remain -= len;
 107
 108                 return;
 109         }
 110
 111         /*
 112          * Finally, hit the slow path and make a temporary string to copy over
 113          * using _drm_puts_coredump
 114          */
 115         buf = kmalloc(len + 1, GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY);
 116         if (!buf)
 117                 return;
 118
 119         snprintf(buf, len + 1, "%pV", vaf);
 120         __drm_puts_coredump(p, (const char *) buf);
 121
 122         kfree(buf);
 123 }
 124 EXPORT_SYMBOL(__drm_printfn_coredump);
 125
 126 void __drm_puts_seq_file(struct drm_printer *p, const char *str)
 127 {
 128         seq_puts(p->arg, str);
 129 }
 130 EXPORT_SYMBOL(__drm_puts_seq_file);
 131
 132 void __drm_printfn_seq_file(struct drm_printer *p, struct va_format *vaf)
 133 {
 134         seq_printf(p->arg, "%pV", vaf);
 135 }
 136 EXPORT_SYMBOL(__drm_printfn_seq_file);
 137
 138 void __drm_printfn_info(struct drm_printer *p, struct va_format *vaf)
 139 {
 140         dev_info(p->arg, "[" DRM_NAME "] %pV", vaf);
 141 }
 142 EXPORT_SYMBOL(__drm_printfn_info);
 143
 144 void __drm_printfn_debug(struct drm_printer *p, struct va_format *vaf)
 145 {
 146         pr_debug("%s %pV", p->prefix, vaf);
 147 }
 148 EXPORT_SYMBOL(__drm_printfn_debug);
 149
 150 void __drm_printfn_err(struct drm_printer *p, struct va_format *vaf)
 151 {
 152         pr_err("*ERROR* %s %pV", p->prefix, vaf);
 153 }
 154 EXPORT_SYMBOL(__drm_printfn_err);
 155
 156 /**
 157  * drm_puts - print a const string to a &drm_printer stream
 158  * @p: the &drm printer
 159  * @str: const string
 160  *
 161  * Allow &drm_printer types that have a constant string
 162  * option to use it.
 163  */
 164 void drm_puts(struct drm_printer *p, const char *str)
 165 {
 166         if (p->puts)
 167                 p->puts(p, str);
 168         else
 169                 drm_printf(p, "%s", str);
 170 }
 171 EXPORT_SYMBOL(drm_puts);
 172
 173 /**
 174  * drm_printf - print to a &drm_printer stream
 175  * @p: the &drm_printer
 176  * @f: format string
 177  */
 178 void drm_printf(struct drm_printer *p, const char *f, ...)
 179 {
 180         va_list args;
 181
 182         va_start(args, f);
 183         drm_vprintf(p, f, &args);
 184         va_end(args);
 185 }
 186 EXPORT_SYMBOL(drm_printf);
 187
 188 void drm_dev_printk(const struct device *dev, const char *level,
 189                     const char *format, ...)
 190 {
 191         struct va_format vaf;
 192         va_list args;
 193
 194         va_start(args, format);
 195         vaf.fmt = format;
 196         vaf.va = &args;
 197
 198         if (dev)
 199                 dev_printk(level, dev, "[" DRM_NAME ":%ps] %pV",
 200                            __builtin_return_address(0), &vaf);
 201         else
 202                 printk("%s" "[" DRM_NAME ":%ps] %pV",
 203                        level, __builtin_return_address(0), &vaf);
 204
 205         va_end(args);
 206 }
 207 EXPORT_SYMBOL(drm_dev_printk);
 208
 209 void drm_dev_dbg(const struct device *dev, unsigned int category,
 210                  const char *format, ...)
 211 {
 212         struct va_format vaf;
 213         va_list args;
 214
 215         if (!(drm_debug & category))
 216                 return;
 217
 218         va_start(args, format);
 219         vaf.fmt = format;
 220         vaf.va = &args;
 221
 222         if (dev)
 223                 dev_printk(KERN_DEBUG, dev, "[" DRM_NAME ":%ps] %pV",
 224                            __builtin_return_address(0), &vaf);
 225         else
 226                 printk(KERN_DEBUG "[" DRM_NAME ":%ps] %pV",
 227                        __builtin_return_address(0), &vaf);
 228
 229         va_end(args);
 230 }
 231 EXPORT_SYMBOL(drm_dev_dbg);
 232
 233 void drm_dbg(unsigned int category, const char *format, ...)
 234 {
 235         struct va_format vaf;
 236         va_list args;
 237
 238         if (!(drm_debug & category))
 239                 return;
 240
 241         va_start(args, format);
 242         vaf.fmt = format;
 243         vaf.va = &args;
 244
 245         printk(KERN_DEBUG "[" DRM_NAME ":%ps] %pV",
 246                __builtin_return_address(0), &vaf);
 247
 248         va_end(args);
 249 }
 250 EXPORT_SYMBOL(drm_dbg);
 251
 252 void drm_err(const char *format, ...)
 253 {
 254         struct va_format vaf;
 255         va_list args;
 256
 257         va_start(args, format);
 258         vaf.fmt = format;
 259         vaf.va = &args;
 260
 261         printk(KERN_ERR "[" DRM_NAME ":%ps] *ERROR* %pV",
 262                __builtin_return_address(0), &vaf);
 263
 264         va_end(args);
 265 }
 266 EXPORT_SYMBOL(drm_err);
 267
 268 /**
 269  * drm_print_regset32 - print the contents of registers to a
 270  * &drm_printer stream.
 271  *
 272  * @p: the &drm printer
 273  * @regset: the list of registers to print.
 274  *
 275  * Often in driver debug, it's useful to be able to either capture the
 276  * contents of registers in the steady state using debugfs or at
 277  * specific points during operation.  This lets the driver have a
 278  * single list of registers for both.
 279  */
 280 void drm_print_regset32(struct drm_printer *p, struct debugfs_regset32 *regset)
 281 {
 282         int namelen = 0;
 283         int i;
 284
 285         for (i = 0; i < regset->nregs; i++)
 286                 namelen = max(namelen, (int)strlen(regset->regs[i].name));
 287
 288         for (i = 0; i < regset->nregs; i++) {
 289                 drm_printf(p, "%*s = 0x%08x\n",
 290                            namelen, regset->regs[i].name,
 291                            readl(regset->base + regset->regs[i].offset));
 292         }
 293 }
 294 EXPORT_SYMBOL(drm_print_regset32);