drivers/staging/unisys/visorbus/vbuschannel.h

   1 /* Copyright (C) 2010 - 2015 UNISYS CORPORATION
   2  * All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  * NON INFRINGEMENT.  See the GNU General Public License for more
  12  * details.
  13  */
  14
  15 #ifndef __VBUSCHANNEL_H__
  16 #define __VBUSCHANNEL_H__
  17
  18 /*  The vbus channel is the channel area provided via the BUS_CREATE controlvm
  19  *  message for each virtual bus.  This channel area is provided to both server
  20  *  and client ends of the bus.  The channel header area is initialized by
  21  *  the server, and the remaining information is filled in by the client.
  22  *  We currently use this for the client to provide various information about
  23  *  the client devices and client drivers for the server end to see.
  24  */
  25 #include <linux/uuid.h>
  26 #include "channel.h"
  27
  28 /* {193b331b-c58f-11da-95a9-00e08161165f} */
  29 #define SPAR_VBUS_CHANNEL_PROTOCOL_UUID \
  30                 UUID_LE(0x193b331b, 0xc58f, 0x11da, \
  31                                 0x95, 0xa9, 0x0, 0xe0, 0x81, 0x61, 0x16, 0x5f)
  32 static const uuid_le spar_vbus_channel_protocol_uuid =
  33         SPAR_VBUS_CHANNEL_PROTOCOL_UUID;
  34
  35 #define SPAR_VBUS_CHANNEL_PROTOCOL_SIGNATURE ULTRA_CHANNEL_PROTOCOL_SIGNATURE
  36
  37 /* Must increment this whenever you insert or delete fields within this channel
  38  * struct.  Also increment whenever you change the meaning of fields within this
  39  * channel struct so as to break pre-existing software.  Note that you can
  40  * usually add fields to the END of the channel struct withOUT needing to
  41  * increment this.
  42  */
  43 #define SPAR_VBUS_CHANNEL_PROTOCOL_VERSIONID 1
  44
  45 #define SPAR_VBUS_CHANNEL_OK_CLIENT(ch)       \
  46         spar_check_channel_client(ch,                           \
  47                                    spar_vbus_channel_protocol_uuid,     \
  48                                    "vbus",                              \
  49                                    sizeof(struct spar_vbus_channel_protocol),\
  50                                    SPAR_VBUS_CHANNEL_PROTOCOL_VERSIONID, \
  51                                    SPAR_VBUS_CHANNEL_PROTOCOL_SIGNATURE)
  52
  53 #define SPAR_VBUS_CHANNEL_OK_SERVER(actual_bytes)    \
  54         (spar_check_channel_server(spar_vbus_channel_protocol_uuid,     \
  55                                    "vbus",                              \
  56                                    sizeof(struct spar_vbus_channel_protocol),\
  57                                    actual_bytes))
  58
  59 #pragma pack(push, 1)           /* both GCC and VC now allow this pragma */
  60
  61 /*
  62  * An array of this struct is present in the channel area for each vbus.
  63  * (See vbuschannel.h.)
  64  * It is filled in by the client side to provide info about the device
  65  * and driver from the client's perspective.
  66  */
  67 struct ultra_vbus_deviceinfo {
  68         u8 devtype[16];         /* short string identifying the device type */
  69         u8 drvname[16];         /* driver .sys file name */
  70         u8 infostrs[96];        /* kernel version */
  71         u8 reserved[128];       /* pad size to 256 bytes */
  72 };
  73
  74 /**
  75  * vbuschannel_sanitize_buffer() - remove non-printable chars from buffer
  76  * @p: destination buffer where chars are written to
  77  * @remain: number of bytes that can be written starting at #p
  78  * @src: pointer to source buffer
  79  * @srcmax: number of valid characters at #src
  80  *
  81  * Reads chars from the buffer at @src for @srcmax bytes, and writes to
  82  * the buffer at @p, which is @remain bytes long, ensuring never to
  83  * overflow the buffer at @p, using the following rules:
  84  * - printable characters are simply copied from the buffer at @src to the
  85  *   buffer at @p
  86  * - intervening streaks of non-printable characters in the buffer at @src
  87  *   are replaced with a single space in the buffer at @p
  88  * Note that we pay no attention to '\0'-termination.
  89  *
  90  * Pass @p == NULL and @remain == 0 for this special behavior -- In this
  91  * case, we simply return the number of bytes that WOULD HAVE been written
  92  * to a buffer at @p, had it been infinitely big.
  93  *
  94  * Return: the number of bytes written to @p (or WOULD HAVE been written to
  95  *         @p, as described in the previous paragraph)
  96  */
  97 static inline int
  98 vbuschannel_sanitize_buffer(char *p, int remain, char *src, int srcmax)
  99 {
 100         int chars = 0;
 101         int nonprintable_streak = 0;
 102
 103         while (srcmax > 0) {
 104                 if ((*src >= ' ') && (*src < 0x7f)) {
 105                         if (nonprintable_streak) {
 106                                 if (remain > 0) {
 107                                         *p = ' ';
 108                                         p++;
 109                                         remain--;
 110                                         chars++;
 111                                 } else if (!p) {
 112                                         chars++;
 113                                 }
 114                                 nonprintable_streak = 0;
 115                         }
 116                         if (remain > 0) {
 117                                 *p = *src;
 118                                 p++;
 119                                 remain--;
 120                                 chars++;
 121                         } else if (!p) {
 122                                 chars++;
 123                         }
 124                 } else {
 125                         nonprintable_streak = 1;
 126                 }
 127                 src++;
 128                 srcmax--;
 129         }
 130         return chars;
 131 }
 132
 133 #define VBUSCHANNEL_ADDACHAR(ch, p, remain, chars) \
 134         do {                                       \
 135                 if (remain <= 0)                   \
 136                         break;                     \
 137                 *p = ch;                           \
 138                 p++;  chars++;  remain--;          \
 139         } while (0)
 140
 141 /**
 142  * vbuschannel_itoa() - convert non-negative int to string
 143  * @p: destination string
 144  * @remain: max number of bytes that can be written to @p
 145  * @num: input int to convert
 146  *
 147  * Converts the non-negative value at @num to an ascii decimal string
 148  * at @p, writing at most @remain bytes.  Note there is NO '\0' termination
 149  * written to @p.
 150  *
 151  * Return: number of bytes written to @p
 152  *
 153  */
 154 static inline int
 155 vbuschannel_itoa(char *p, int remain, int num)
 156 {
 157         int digits = 0;
 158         char s[32];
 159         int i;
 160
 161         if (num == 0) {
 162                 /* '0' is a special case */
 163                 if (remain <= 0)
 164                         return 0;
 165                 *p = '0';
 166                 return 1;
 167         }
 168         /* form a backwards decimal ascii string in <s> */
 169         while (num > 0) {
 170                 if (digits >= (int)sizeof(s))
 171                         return 0;
 172                 s[digits++] = (num % 10) + '0';
 173                 num = num / 10;
 174         }
 175         if (remain < digits) {
 176                 /* not enough room left at <p> to hold number, so fill with
 177                  * '?'
 178                  */
 179                 for (i = 0; i < remain; i++, p++)
 180                         *p = '?';
 181                 return remain;
 182         }
 183         /* plug in the decimal ascii string representing the number, by */
 184         /* reversing the string we just built in <s> */
 185         i = digits;
 186         while (i > 0) {
 187                 i--;
 188                 *p = s[i];
 189                 p++;
 190         }
 191         return digits;
 192 }
 193
 194 /**
 195  * vbuschannel_devinfo_to_string() - format a struct ultra_vbus_deviceinfo
 196  *                                   to a printable string
 197  * @devinfo: the struct ultra_vbus_deviceinfo to format
 198  * @p: destination string area
 199  * @remain: size of destination string area in bytes
 200  * @devix: the device index to be included in the output data, or -1 if no
 201  *         device index is to be included
 202  *
 203  * Reads @devInfo, and converts its contents to a printable string at @p,
 204  * writing at most @remain bytes. Note there is NO '\0' termination
 205  * written to @p.
 206  *
 207  * Return: number of bytes written to @p
 208  */
 209 static inline int
 210 vbuschannel_devinfo_to_string(struct ultra_vbus_deviceinfo *devinfo,
 211                               char *p, int remain, int devix)
 212 {
 213         char *psrc;
 214         int nsrc, x, i, pad;
 215         int chars = 0;
 216
 217         psrc = &devinfo->devtype[0];
 218         nsrc = sizeof(devinfo->devtype);
 219         if (vbuschannel_sanitize_buffer(NULL, 0, psrc, nsrc) <= 0)
 220                 return 0;
 221
 222         /* emit device index */
 223         if (devix >= 0) {
 224                 VBUSCHANNEL_ADDACHAR('[', p, remain, chars);
 225                 x = vbuschannel_itoa(p, remain, devix);
 226                 p += x;
 227                 remain -= x;
 228                 chars += x;
 229                 VBUSCHANNEL_ADDACHAR(']', p, remain, chars);
 230         } else {
 231                 VBUSCHANNEL_ADDACHAR(' ', p, remain, chars);
 232                 VBUSCHANNEL_ADDACHAR(' ', p, remain, chars);
 233                 VBUSCHANNEL_ADDACHAR(' ', p, remain, chars);
 234         }
 235
 236         /* emit device type */
 237         x = vbuschannel_sanitize_buffer(p, remain, psrc, nsrc);
 238         p += x;
 239         remain -= x;
 240         chars += x;
 241         pad = 15 - x;           /* pad device type to be exactly 15 chars */
 242         for (i = 0; i < pad; i++)
 243                 VBUSCHANNEL_ADDACHAR(' ', p, remain, chars);
 244         VBUSCHANNEL_ADDACHAR(' ', p, remain, chars);
 245
 246         /* emit driver name */
 247         psrc = &devinfo->drvname[0];
 248         nsrc = sizeof(devinfo->drvname);
 249         x = vbuschannel_sanitize_buffer(p, remain, psrc, nsrc);
 250         p += x;
 251         remain -= x;
 252         chars += x;
 253         pad = 15 - x;           /* pad driver name to be exactly 15 chars */
 254         for (i = 0; i < pad; i++)
 255                 VBUSCHANNEL_ADDACHAR(' ', p, remain, chars);
 256         VBUSCHANNEL_ADDACHAR(' ', p, remain, chars);
 257
 258         /* emit strings */
 259         psrc = &devinfo->infostrs[0];
 260         nsrc = sizeof(devinfo->infostrs);
 261         x = vbuschannel_sanitize_buffer(p, remain, psrc, nsrc);
 262         p += x;
 263         remain -= x;
 264         chars += x;
 265         VBUSCHANNEL_ADDACHAR('\n', p, remain, chars);
 266
 267         return chars;
 268 }
 269
 270 struct spar_vbus_headerinfo {
 271         u32 struct_bytes;       /* size of this struct in bytes */
 272         u32 device_info_struct_bytes;   /* sizeof(ULTRA_VBUS_DEVICEINFO) */
 273         u32 dev_info_count;     /* num of items in DevInfo member */
 274         /* (this is the allocated size) */
 275         u32 chp_info_offset;    /* byte offset from beginning of this struct */
 276         /* to the ChpInfo struct (below) */
 277         u32 bus_info_offset;    /* byte offset from beginning of this struct */
 278         /* to the BusInfo struct (below) */
 279         u32 dev_info_offset;    /* byte offset from beginning of this struct */
 280         /* to the DevInfo array (below) */
 281         u8 reserved[104];
 282 };
 283
 284 struct spar_vbus_channel_protocol {
 285         struct channel_header channel_header;   /* initialized by server */
 286         struct spar_vbus_headerinfo hdr_info;   /* initialized by server */
 287         /* the remainder of this channel is filled in by the client */
 288         struct ultra_vbus_deviceinfo chp_info;
 289         /* describes client chipset device and driver */
 290         struct ultra_vbus_deviceinfo bus_info;
 291         /* describes client bus device and driver */
 292         struct ultra_vbus_deviceinfo dev_info[0];
 293         /* describes client device and driver for each device on the bus */
 294 };
 295
 296 #define VBUS_CH_SIZE_EXACT(MAXDEVICES) \
 297         (sizeof(ULTRA_VBUS_CHANNEL_PROTOCOL) + ((MAXDEVICES) * \
 298                                                 sizeof(ULTRA_VBUS_DEVICEINFO)))
 299 #define VBUS_CH_SIZE(MAXDEVICES) COVER(VBUS_CH_SIZE_EXACT(MAXDEVICES), 4096)
 300
 301 #pragma pack(pop)
 302
 303 #endif