drivers/misc/swap_case.c

   1 /*
   2  * PCI emulation device which swaps the case of text
   3  *
   4  * Copyright (c) 2014 Google, Inc
   5  * Written by Simon Glass <sjg@chromium.org>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <pci.h>
  14 #include <asm/test.h>
  15 #include <linux/ctype.h>
  16
  17 /**
  18  * struct swap_case_platdata - platform data for this device
  19  *
  20  * @command:    Current PCI command value
  21  * @bar:        Current base address values
  22  */
  23 struct swap_case_platdata {
  24         u16 command;
  25         u32 bar[2];
  26 };
  27
  28 #define offset_to_barnum(offset)        \
  29                 (((offset) - PCI_BASE_ADDRESS_0) / sizeof(u32))
  30
  31 enum {
  32         MEM_TEXT_SIZE   = 0x100,
  33 };
  34
  35 enum swap_case_op {
  36         OP_TO_LOWER,
  37         OP_TO_UPPER,
  38         OP_SWAP,
  39 };
  40
  41 static struct pci_bar {
  42         int type;
  43         u32 size;
  44 } barinfo[] = {
  45         { PCI_BASE_ADDRESS_SPACE_IO, 1 },
  46         { PCI_BASE_ADDRESS_MEM_TYPE_32, MEM_TEXT_SIZE },
  47         { 0, 0 },
  48         { 0, 0 },
  49         { 0, 0 },
  50         { 0, 0 },
  51 };
  52
  53 struct swap_case_priv {
  54         enum swap_case_op op;
  55         char mem_text[MEM_TEXT_SIZE];
  56 };
  57
  58 static int sandbox_swap_case_get_devfn(struct udevice *dev)
  59 {
  60         struct pci_child_platdata *plat = dev_get_parent_platdata(dev);
  61
  62         return plat->devfn;
  63 }
  64
  65 static int sandbox_swap_case_read_config(struct udevice *emul, uint offset,
  66                                          ulong *valuep, enum pci_size_t size)
  67 {
  68         struct swap_case_platdata *plat = dev_get_platdata(emul);
  69
  70         switch (offset) {
  71         case PCI_COMMAND:
  72                 *valuep = plat->command;
  73                 break;
  74         case PCI_HEADER_TYPE:
  75                 *valuep = 0;
  76                 break;
  77         case PCI_VENDOR_ID:
  78                 *valuep = SANDBOX_PCI_VENDOR_ID;
  79                 break;
  80         case PCI_DEVICE_ID:
  81                 *valuep = SANDBOX_PCI_DEVICE_ID;
  82                 break;
  83         case PCI_CLASS_DEVICE:
  84                 if (size == PCI_SIZE_8) {
  85                         *valuep = SANDBOX_PCI_CLASS_SUB_CODE;
  86                 } else {
  87                         *valuep = (SANDBOX_PCI_CLASS_CODE << 8) |
  88                                         SANDBOX_PCI_CLASS_SUB_CODE;
  89                 }
  90                 break;
  91         case PCI_CLASS_CODE:
  92                 *valuep = SANDBOX_PCI_CLASS_CODE;
  93                 break;
  94         case PCI_BASE_ADDRESS_0:
  95         case PCI_BASE_ADDRESS_1:
  96         case PCI_BASE_ADDRESS_2:
  97         case PCI_BASE_ADDRESS_3:
  98         case PCI_BASE_ADDRESS_4:
  99         case PCI_BASE_ADDRESS_5: {
 100                 int barnum;
 101                 u32 *bar, result;
 102
 103                 barnum = offset_to_barnum(offset);
 104                 bar = &plat->bar[barnum];
 105
 106                 result = *bar;
 107                 if (*bar == 0xffffffff) {
 108                         if (barinfo[barnum].type) {
 109                                 result = (~(barinfo[barnum].size - 1) &
 110                                         PCI_BASE_ADDRESS_IO_MASK) |
 111                                         PCI_BASE_ADDRESS_SPACE_IO;
 112                         } else {
 113                                 result = (~(barinfo[barnum].size - 1) &
 114                                         PCI_BASE_ADDRESS_MEM_MASK) |
 115                                         PCI_BASE_ADDRESS_MEM_TYPE_32;
 116                         }
 117                 }
 118                 debug("r bar %d=%x\n", barnum, result);
 119                 *valuep = result;
 120                 break;
 121         }
 122         }
 123
 124         return 0;
 125 }
 126
 127 static int sandbox_swap_case_write_config(struct udevice *emul, uint offset,
 128                                           ulong value, enum pci_size_t size)
 129 {
 130         struct swap_case_platdata *plat = dev_get_platdata(emul);
 131
 132         switch (offset) {
 133         case PCI_COMMAND:
 134                 plat->command = value;
 135                 break;
 136         case PCI_BASE_ADDRESS_0:
 137         case PCI_BASE_ADDRESS_1: {
 138                 int barnum;
 139                 u32 *bar;
 140
 141                 barnum = offset_to_barnum(offset);
 142                 bar = &plat->bar[barnum];
 143
 144                 debug("w bar %d=%lx\n", barnum, value);
 145                 *bar = value;
 146                 break;
 147         }
 148         }
 149
 150         return 0;
 151 }
 152
 153 static int sandbox_swap_case_find_bar(struct udevice *emul, unsigned int addr,
 154                                       int *barnump, unsigned int *offsetp)
 155 {
 156         struct swap_case_platdata *plat = dev_get_platdata(emul);
 157         int barnum;
 158
 159         for (barnum = 0; barnum < ARRAY_SIZE(barinfo); barnum++) {
 160                 unsigned int size = barinfo[barnum].size;
 161
 162                 if (addr >= plat->bar[barnum] &&
 163                     addr < plat->bar[barnum] + size) {
 164                         *barnump = barnum;
 165                         *offsetp = addr - plat->bar[barnum];
 166                         return 0;
 167                 }
 168         }
 169         *barnump = -1;
 170
 171         return -ENOENT;
 172 }
 173
 174 static void sandbox_swap_case_do_op(enum swap_case_op op, char *str, int len)
 175 {
 176         for (; len > 0; len--, str++) {
 177                 switch (op) {
 178                 case OP_TO_UPPER:
 179                         *str = toupper(*str);
 180                         break;
 181                 case OP_TO_LOWER:
 182                         *str = tolower(*str);
 183                         break;
 184                 case OP_SWAP:
 185                         if (isupper(*str))
 186                                 *str = tolower(*str);
 187                         else
 188                                 *str = toupper(*str);
 189                         break;
 190                 }
 191         }
 192 }
 193
 194 int sandbox_swap_case_read_io(struct udevice *dev, unsigned int addr,
 195                               ulong *valuep, enum pci_size_t size)
 196 {
 197         struct swap_case_priv *priv = dev_get_priv(dev);
 198         unsigned int offset;
 199         int barnum;
 200         int ret;
 201
 202         ret = sandbox_swap_case_find_bar(dev, addr, &barnum, &offset);
 203         if (ret)
 204                 return ret;
 205
 206         if (barnum == 0 && offset == 0)
 207                 *valuep = (*valuep & ~0xff) | priv->op;
 208
 209         return 0;
 210 }
 211
 212 int sandbox_swap_case_write_io(struct udevice *dev, unsigned int addr,
 213                                ulong value, enum pci_size_t size)
 214 {
 215         struct swap_case_priv *priv = dev_get_priv(dev);
 216         unsigned int offset;
 217         int barnum;
 218         int ret;
 219
 220         ret = sandbox_swap_case_find_bar(dev, addr, &barnum, &offset);
 221         if (ret)
 222                 return ret;
 223         if (barnum == 0 && offset == 0)
 224                 priv->op = value;
 225
 226         return 0;
 227 }
 228
 229 static int sandbox_swap_case_map_physmem(struct udevice *dev,
 230                 phys_addr_t addr, unsigned long *lenp, void **ptrp)
 231 {
 232         struct swap_case_priv *priv = dev_get_priv(dev);
 233         unsigned int offset, avail;
 234         int barnum;
 235         int ret;
 236
 237         ret = sandbox_swap_case_find_bar(dev, addr, &barnum, &offset);
 238         if (ret)
 239                 return ret;
 240         if (barnum == 1) {
 241                 *ptrp = priv->mem_text + offset;
 242                 avail = barinfo[1].size - offset;
 243                 if (avail > barinfo[1].size)
 244                         *lenp = 0;
 245                 else
 246                         *lenp = min(*lenp, (ulong)avail);
 247
 248                 return 0;
 249         }
 250
 251         return -ENOENT;
 252 }
 253
 254 static int sandbox_swap_case_unmap_physmem(struct udevice *dev,
 255                                            const void *vaddr, unsigned long len)
 256 {
 257         struct swap_case_priv *priv = dev_get_priv(dev);
 258
 259         sandbox_swap_case_do_op(priv->op, (void *)vaddr, len);
 260
 261         return 0;
 262 }
 263
 264 struct dm_pci_emul_ops sandbox_swap_case_emul_ops = {
 265         .get_devfn = sandbox_swap_case_get_devfn,
 266         .read_config = sandbox_swap_case_read_config,
 267         .write_config = sandbox_swap_case_write_config,
 268         .read_io = sandbox_swap_case_read_io,
 269         .write_io = sandbox_swap_case_write_io,
 270         .map_physmem = sandbox_swap_case_map_physmem,
 271         .unmap_physmem = sandbox_swap_case_unmap_physmem,
 272 };
 273
 274 static const struct udevice_id sandbox_swap_case_ids[] = {
 275         { .compatible = "sandbox,swap-case" },
 276         { }
 277 };
 278
 279 U_BOOT_DRIVER(sandbox_swap_case_emul) = {
 280         .name           = "sandbox_swap_case_emul",
 281         .id             = UCLASS_PCI_EMUL,
 282         .of_match       = sandbox_swap_case_ids,
 283         .ops            = &sandbox_swap_case_emul_ops,
 284         .priv_auto_alloc_size = sizeof(struct swap_case_priv),
 285         .platdata_auto_alloc_size = sizeof(struct swap_case_platdata),
 286 };