tools/tools/bus_autoconf/bus_sections.c

   1 /* $FreeBSD: head/tools/tools/bus_autoconf/bus_sections.c 223534 2011-06-25 13:44:05Z hselasky $ */
   2
   3 /*-
   4  * Copyright (c) 2011 Hans Petter Selasky. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdint.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <sysexits.h>
  33 #include <err.h>
  34 #include <string.h>
  35
  36 #include <sys/queue.h>
  37
  38 #include "bus_sections.h"
  39
  40 #define MAX_STRING      64
  41
  42 struct format_info;
  43 typedef TAILQ_HEAD(,format_info) format_info_head_t;
  44 typedef TAILQ_ENTRY(format_info) format_info_entry_t;
  45
  46 static format_info_head_t format_head = TAILQ_HEAD_INITIALIZER(format_head);
  47
  48 struct format_info {
  49         format_info_entry_t entry;
  50         format_info_head_t fields;
  51         char    name[MAX_STRING];
  52         uint16_t bit_offset;
  53         uint16_t bit_size;
  54 };
  55
  56 static struct format_info *
  57 format_info_new(char *pstr, uint16_t bo, uint16_t bs)
  58 {
  59         struct format_info *pfi;
  60
  61         pfi = malloc(sizeof(*pfi));
  62         if (pfi == NULL)
  63                 errx(EX_SOFTWARE, "Out of memory.");
  64
  65         memset(pfi, 0, sizeof(*pfi));
  66
  67         TAILQ_INIT(&pfi->fields);
  68
  69         strlcpy(pfi->name, pstr, sizeof(pfi->name));
  70         pfi->bit_offset = bo;
  71         pfi->bit_size = bs;
  72         return (pfi);
  73 }
  74
  75 static const struct format_info *
  76 format_get_section(const char *section)
  77 {
  78         const struct format_info *psub;
  79         static const struct format_info *psub_last;
  80         static const char *psub_cache;
  81
  82         if (psub_cache && strcmp(psub_cache, section) == 0)
  83                 return (psub_last);
  84
  85         TAILQ_FOREACH(psub, &format_head, entry) {
  86                 if (strcmp(section, psub->name) == 0) {
  87                         psub_cache = section;
  88                         psub_last = psub;
  89                         return (psub);
  90                 }
  91         }
  92         warnx("Section '%s' not found", section);
  93         psub_cache = section;
  94         psub_last = psub;
  95         return (NULL);
  96 }
  97
  98 uint16_t
  99 format_get_section_size(const char *section)
 100 {
 101         const struct format_info *pfi;
 102
 103         pfi = format_get_section(section);
 104         if (pfi == NULL)
 105                 return (0);
 106
 107         return ((pfi->bit_offset + 7) / 8);
 108 }
 109
 110
 111 uint8_t
 112 format_get_field(const char *section, const char *field,
 113     const uint8_t *ptr, uint16_t size)
 114 {
 115         const struct format_info *pfi;
 116         const struct format_info *psub;
 117         uint16_t rem;
 118         uint16_t off;
 119         uint16_t sz;
 120
 121         pfi = format_get_section(section);
 122         if (pfi == NULL)
 123                 return (0);
 124
 125         /* skip until we find the fields */
 126         while (pfi && TAILQ_FIRST(&pfi->fields) == NULL)
 127                 pfi = TAILQ_NEXT(pfi, entry);
 128
 129         if (pfi == NULL)
 130                 return (0);
 131
 132         TAILQ_FOREACH(psub, &pfi->fields, entry) {
 133                 if (strcmp(field, psub->name) == 0) {
 134
 135                         /* range check */
 136                         if (((psub->bit_offset + psub->bit_size) / 8) > size)
 137                                 return (0);
 138
 139                         /* compute byte offset */
 140                         rem = psub->bit_offset & 7;
 141                         off = psub->bit_offset / 8;
 142                         sz = psub->bit_size;
 143
 144                         /* extract bit-field */
 145                         return ((ptr[off] >> rem) & ((1 << sz) - 1));
 146                 }
 147         }
 148         warnx("Field '%s' not found in '%s'", field, pfi->name);
 149         return (0);
 150 }
 151
 152 void
 153 format_parse_entries(const uint8_t *ptr, uint32_t len)
 154 {
 155         static const char *command_list = "012345678:";
 156         const char *cmd;
 157         struct format_info *pfi;
 158         struct format_info *pfi_last = NULL;
 159         char linebuf[3][MAX_STRING];
 160         uint32_t off = 0;
 161         uint16_t bit_offset = 0;
 162         uint8_t state = 0;
 163         uint8_t cmd_index;
 164         int c;
 165
 166         /*
 167          * The format we are parsing:
 168          * <string>{string,string}<next_string>{...}
 169          */
 170         while (len--) {
 171                 c = *(ptr++);
 172
 173                 /* skip some characters */
 174                 if (c == 0 || c == '\n' || c == '\r' || c == ' ' || c == '\t')
 175                         continue;
 176
 177                 /* accumulate non-field delimiters */
 178                 if (strchr("{,}", c) == NULL) {
 179                         if (off < (MAX_STRING - 1)) {
 180                                 linebuf[state][off] = c;
 181                                 off++;
 182                         }
 183                         continue;
 184                 }
 185                 /* parse keyword */
 186                 linebuf[state][off] = 0;
 187                 off = 0;
 188                 state++;
 189                 if (state == 3) {
 190                         /* check for command in command list */
 191                         cmd = strchr(command_list, linebuf[2][0]);
 192                         if (cmd != NULL)
 193                                 cmd_index = cmd - command_list;
 194                         else
 195                                 cmd_index = 255;
 196
 197                         /*
 198                          * Check for new field, format is:
 199                          *
 200                          * <field_name>{bit_offset_xor, bit_size}
 201                          */
 202                         if (cmd_index < 9 && pfi_last != NULL) {
 203                                 pfi = format_info_new(linebuf[0], bit_offset ^
 204                                     atoi(linebuf[1]), cmd_index);
 205                                 TAILQ_INSERT_TAIL(&pfi_last->fields, pfi, entry);
 206                                 bit_offset += cmd_index;
 207                         }
 208                         /*
 209                          * Check for new section, format is:
 210                          *
 211                          * <section_name>{section_bit_size, :}
 212                          */
 213                         if (cmd_index == 9) {
 214                                 pfi_last = format_info_new(linebuf[0],
 215                                     atoi(linebuf[1]), cmd_index);
 216                                 TAILQ_INSERT_TAIL(&format_head, pfi_last, entry);
 217                                 bit_offset = 0;
 218                         }
 219                         state = 0;
 220                         continue;
 221                 }
 222         }
 223 }