drivers/gator/gator_annotate_kernel.c

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