drivers/gator/gator_annotate_kernel.c

   1 /**
   2  * Copyright (C) ARM Limited 2012-2015. All rights reserved.
   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
  10 #define ESCAPE_CODE 0x1c
  11 #define STRING_ANNOTATION 0x06
  12 #define NAME_CHANNEL_ANNOTATION 0x07
  13 #define NAME_GROUP_ANNOTATION 0x08
  14 #define VISUAL_ANNOTATION 0x04
  15 #define MARKER_ANNOTATION 0x05
  16
  17 static void kannotate_write(const char *ptr, unsigned int size)
  18 {
  19         int retval;
  20         int pos = 0;
  21         loff_t offset = 0;
  22
  23         while (pos < size) {
  24                 retval = annotate_write(NULL, &ptr[pos], size - pos, &offset);
  25                 if (retval < 0) {
  26                         pr_warning("gator: kannotate_write failed with return value %d\n", retval);
  27                         return;
  28                 }
  29                 pos += retval;
  30         }
  31 }
  32
  33 static void marshal_u16(char *buf, u16 val)
  34 {
  35         buf[0] = val & 0xff;
  36         buf[1] = (val >> 8) & 0xff;
  37 }
  38
  39 static void marshal_u32(char *buf, u32 val)
  40 {
  41         buf[0] = val & 0xff;
  42         buf[1] = (val >> 8) & 0xff;
  43         buf[2] = (val >> 16) & 0xff;
  44         buf[3] = (val >> 24) & 0xff;
  45 }
  46
  47 void gator_annotate_channel(int channel, const char *str)
  48 {
  49         const u16 str_size = strlen(str) & 0xffff;
  50         char header[8];
  51
  52         header[0] = ESCAPE_CODE;
  53         header[1] = STRING_ANNOTATION;
  54         marshal_u32(header + 2, channel);
  55         marshal_u16(header + 6, str_size);
  56         kannotate_write(header, sizeof(header));
  57         kannotate_write(str, str_size);
  58 }
  59 EXPORT_SYMBOL(gator_annotate_channel);
  60
  61 void gator_annotate(const char *str)
  62 {
  63         gator_annotate_channel(0, str);
  64 }
  65 EXPORT_SYMBOL(gator_annotate);
  66
  67 void gator_annotate_channel_color(int channel, int color, const char *str)
  68 {
  69         const u16 str_size = (strlen(str) + 4) & 0xffff;
  70         char header[12];
  71
  72         header[0] = ESCAPE_CODE;
  73         header[1] = STRING_ANNOTATION;
  74         marshal_u32(header + 2, channel);
  75         marshal_u16(header + 6, str_size);
  76         marshal_u32(header + 8, color);
  77         kannotate_write(header, sizeof(header));
  78         kannotate_write(str, str_size - 4);
  79 }
  80 EXPORT_SYMBOL(gator_annotate_channel_color);
  81
  82 void gator_annotate_color(int color, const char *str)
  83 {
  84         gator_annotate_channel_color(0, color, str);
  85 }
  86 EXPORT_SYMBOL(gator_annotate_color);
  87
  88 void gator_annotate_channel_end(int channel)
  89 {
  90         char header[8];
  91
  92         header[0] = ESCAPE_CODE;
  93         header[1] = STRING_ANNOTATION;
  94         marshal_u32(header + 2, channel);
  95         marshal_u16(header + 6, 0);
  96         kannotate_write(header, sizeof(header));
  97 }
  98 EXPORT_SYMBOL(gator_annotate_channel_end);
  99
 100 void gator_annotate_end(void)
 101 {
 102         gator_annotate_channel_end(0);
 103 }
 104 EXPORT_SYMBOL(gator_annotate_end);
 105
 106 void gator_annotate_name_channel(int channel, int group, const char *str)
 107 {
 108         const u16 str_size = strlen(str) & 0xffff;
 109         char header[12];
 110
 111         header[0] = ESCAPE_CODE;
 112         header[1] = NAME_CHANNEL_ANNOTATION;
 113         marshal_u32(header + 2, channel);
 114         marshal_u32(header + 6, group);
 115         marshal_u16(header + 10, str_size);
 116         kannotate_write(header, sizeof(header));
 117         kannotate_write(str, str_size);
 118 }
 119 EXPORT_SYMBOL(gator_annotate_name_channel);
 120
 121 void gator_annotate_name_group(int group, const char *str)
 122 {
 123         const u16 str_size = strlen(str) & 0xffff;
 124         char header[8];
 125
 126         header[0] = ESCAPE_CODE;
 127         header[1] = NAME_GROUP_ANNOTATION;
 128         marshal_u32(header + 2, group);
 129         marshal_u16(header + 6, str_size);
 130         kannotate_write(header, sizeof(header));
 131         kannotate_write(str, str_size);
 132 }
 133 EXPORT_SYMBOL(gator_annotate_name_group);
 134
 135 void gator_annotate_visual(const char *data, unsigned int length, const char *str)
 136 {
 137         const u16 str_size = strlen(str) & 0xffff;
 138         char header[4];
 139         char header_length[4];
 140
 141         header[0] = ESCAPE_CODE;
 142         header[1] = VISUAL_ANNOTATION;
 143         marshal_u16(header + 2, str_size);
 144         marshal_u32(header_length, length);
 145         kannotate_write(header, sizeof(header));
 146         kannotate_write(str, str_size);
 147         kannotate_write(header_length, sizeof(header_length));
 148         kannotate_write(data, length);
 149 }
 150 EXPORT_SYMBOL(gator_annotate_visual);
 151
 152 void gator_annotate_marker(void)
 153 {
 154         char header[4];
 155
 156         header[0] = ESCAPE_CODE;
 157         header[1] = MARKER_ANNOTATION;
 158         marshal_u16(header + 2, 0);
 159         kannotate_write(header, sizeof(header));
 160 }
 161 EXPORT_SYMBOL(gator_annotate_marker);
 162
 163 void gator_annotate_marker_str(const char *str)
 164 {
 165         const u16 str_size = strlen(str) & 0xffff;
 166         char header[4];
 167
 168         header[0] = ESCAPE_CODE;
 169         header[1] = MARKER_ANNOTATION;
 170         marshal_u16(header + 2, str_size);
 171         kannotate_write(header, sizeof(header));
 172         kannotate_write(str, str_size);
 173 }
 174 EXPORT_SYMBOL(gator_annotate_marker_str);
 175
 176 void gator_annotate_marker_color(int color)
 177 {
 178         char header[8];
 179
 180         header[0] = ESCAPE_CODE;
 181         header[1] = MARKER_ANNOTATION;
 182         marshal_u16(header + 2, 4);
 183         marshal_u32(header + 4, color);
 184         kannotate_write(header, sizeof(header));
 185 }
 186 EXPORT_SYMBOL(gator_annotate_marker_color);
 187
 188 void gator_annotate_marker_color_str(int color, const char *str)
 189 {
 190         const u16 str_size = (strlen(str) + 4) & 0xffff;
 191         char header[8];
 192
 193         header[0] = ESCAPE_CODE;
 194         header[1] = MARKER_ANNOTATION;
 195         marshal_u16(header + 2, str_size);
 196         marshal_u32(header + 4, color);
 197         kannotate_write(header, sizeof(header));
 198         kannotate_write(str, str_size - 4);
 199 }
 200 EXPORT_SYMBOL(gator_annotate_marker_color_str);