drivers/gator/gator_annotate_kernel.c

   1 /**
   2  * Copyright (C) ARM Limited 2012-2013. 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         buf[0] = val & 0xff;
  34         buf[1] = (val >> 8) & 0xff;
  35 }
  36
  37 static void marshal_u32(char *buf, u32 val) {
  38         buf[0] = val & 0xff;
  39         buf[1] = (val >> 8) & 0xff;
  40         buf[2] = (val >> 16) & 0xff;
  41         buf[3] = (val >> 24) & 0xff;
  42 }
  43
  44 void gator_annotate_channel(int channel, const char *str)
  45 {
  46         const u16 str_size = strlen(str) & 0xffff;
  47         char header[8];
  48         header[0] = ESCAPE_CODE;
  49         header[1] = STRING_ANNOTATION;
  50         marshal_u32(header + 2, channel);
  51         marshal_u16(header + 6, str_size);
  52         kannotate_write(header, sizeof(header));
  53         kannotate_write(str, str_size);
  54 }
  55
  56 EXPORT_SYMBOL(gator_annotate_channel);
  57
  58 void gator_annotate(const char *str)
  59 {
  60         gator_annotate_channel(0, str);
  61 }
  62
  63 EXPORT_SYMBOL(gator_annotate);
  64
  65 void gator_annotate_channel_color(int channel, int color, const char *str)
  66 {
  67         const u16 str_size = (strlen(str) + 4) & 0xffff;
  68         char header[12];
  69         header[0] = ESCAPE_CODE;
  70         header[1] = STRING_ANNOTATION;
  71         marshal_u32(header + 2, channel);
  72         marshal_u16(header + 6, str_size);
  73         marshal_u32(header + 8, color);
  74         kannotate_write(header, sizeof(header));
  75         kannotate_write(str, str_size - 4);
  76 }
  77
  78 EXPORT_SYMBOL(gator_annotate_channel_color);
  79
  80 void gator_annotate_color(int color, const char *str)
  81 {
  82         gator_annotate_channel_color(0, color, str);
  83 }
  84
  85 EXPORT_SYMBOL(gator_annotate_color);
  86
  87 void gator_annotate_channel_end(int channel)
  88 {
  89         char header[8];
  90         header[0] = ESCAPE_CODE;
  91         header[1] = STRING_ANNOTATION;
  92         marshal_u32(header + 2, channel);
  93         marshal_u16(header + 6, 0);
  94         kannotate_write(header, sizeof(header));
  95 }
  96
  97 EXPORT_SYMBOL(gator_annotate_channel_end);
  98
  99 void gator_annotate_end(void)
 100 {
 101         gator_annotate_channel_end(0);
 102 }
 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         header[0] = ESCAPE_CODE;
 111         header[1] = NAME_CHANNEL_ANNOTATION;
 112         marshal_u32(header + 2, channel);
 113         marshal_u32(header + 6, group);
 114         marshal_u16(header + 10, str_size);
 115         kannotate_write(header, sizeof(header));
 116         kannotate_write(str, str_size);
 117 }
 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         header[0] = ESCAPE_CODE;
 126         header[1] = NAME_GROUP_ANNOTATION;
 127         marshal_u32(header + 2, group);
 128         marshal_u16(header + 6, str_size);
 129         kannotate_write(header, sizeof(header));
 130         kannotate_write(str, str_size);
 131 }
 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         header[0] = ESCAPE_CODE;
 141         header[1] = VISUAL_ANNOTATION;
 142         marshal_u16(header + 2, str_size);
 143         marshal_u32(header_length, length);
 144         kannotate_write(header, sizeof(header));
 145         kannotate_write(str, str_size);
 146         kannotate_write(header_length, sizeof(header_length));
 147         kannotate_write(data, length);
 148 }
 149
 150 EXPORT_SYMBOL(gator_annotate_visual);
 151
 152 void gator_annotate_marker(void)
 153 {
 154         char header[4];
 155         header[0] = ESCAPE_CODE;
 156         header[1] = MARKER_ANNOTATION;
 157         marshal_u16(header + 2, 0);
 158         kannotate_write(header, sizeof(header));
 159 }
 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         header[0] = ESCAPE_CODE;
 168         header[1] = MARKER_ANNOTATION;
 169         marshal_u16(header + 2, str_size);
 170         kannotate_write(header, sizeof(header));
 171         kannotate_write(str, str_size);
 172 }
 173
 174 EXPORT_SYMBOL(gator_annotate_marker_str);
 175
 176 void gator_annotate_marker_color(int color)
 177 {
 178         char header[8];
 179         header[0] = ESCAPE_CODE;
 180         header[1] = MARKER_ANNOTATION;
 181         marshal_u16(header + 2, 4);
 182         marshal_u32(header + 4, color);
 183         kannotate_write(header, sizeof(header));
 184 }
 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         header[0] = ESCAPE_CODE;
 193         header[1] = MARKER_ANNOTATION;
 194         marshal_u16(header + 2, str_size);
 195         marshal_u32(header + 4, color);
 196         kannotate_write(header, sizeof(header));
 197         kannotate_write(str, str_size - 4);
 198 }
 199
 200 EXPORT_SYMBOL(gator_annotate_marker_color_str);