1 // SPDX-License-Identifier: GPL-2.0+
3 * PCI emulation device which swaps the case of text
5 * Copyright (c) 2014 Google, Inc
6 * Written by Simon Glass <sjg@chromium.org>
14 #include <linux/ctype.h>
17 * struct swap_case_platdata - platform data for this device
19 * @command: Current PCI command value
20 * @bar: Current base address values
22 struct swap_case_platdata {
27 #define offset_to_barnum(offset) \
28 (((offset) - PCI_BASE_ADDRESS_0) / sizeof(u32))
31 MEM_TEXT_SIZE = 0x100,
40 static struct pci_bar {
44 { PCI_BASE_ADDRESS_SPACE_IO, 1 },
45 { PCI_BASE_ADDRESS_MEM_TYPE_32, MEM_TEXT_SIZE },
52 struct swap_case_priv {
54 char mem_text[MEM_TEXT_SIZE];
57 static int sandbox_swap_case_use_ea(struct udevice *dev)
59 return !!ofnode_get_property(dev->node, "use-ea", NULL);
62 /* Please keep these macros in sync with ea_regs below */
63 #define PCI_CAP_ID_EA_SIZE (sizeof(ea_regs) + 4)
64 #define PCI_CAP_ID_EA_ENTRY_CNT 4
65 /* Hardcoded EA structure, excluding 1st DW. */
66 static const u32 ea_regs[] = {
67 /* BEI=0, ES=2, BAR0 32b Base + 32b MaxOffset, I/O space */
71 /* BEI=1, ES=2, BAR1 32b Base + 32b MaxOffset */
75 /* BEI=2, ES=3, BAR2 64b Base + 32b MaxOffset */
77 PCI_CAP_EA_BASE_LO2 | PCI_EA_IS_64,
80 /* BEI=4, ES=4, BAR4 64b Base + 64b MaxOffset */
82 PCI_CAP_EA_BASE_LO4 | PCI_EA_IS_64,
83 PCI_CAP_EA_SIZE_LO | PCI_EA_IS_64,
88 static int sandbox_swap_case_read_ea(struct udevice *emul, uint offset,
89 ulong *valuep, enum pci_size_t size)
93 offset = offset - PCI_CAP_ID_EA_OFFSET - 4;
94 reg = ea_regs[offset >> 2];
95 reg >>= (offset % 4) * 8;
101 static int sandbox_swap_case_read_config(struct udevice *emul, uint offset,
102 ulong *valuep, enum pci_size_t size)
104 struct swap_case_platdata *plat = dev_get_platdata(emul);
107 * The content of the EA capability structure is handled elsewhere to
108 * keep the switch/case below sane
110 if (offset > PCI_CAP_ID_EA_OFFSET + PCI_CAP_LIST_NEXT &&
111 offset < PCI_CAP_ID_EA_OFFSET + PCI_CAP_ID_EA_SIZE)
112 return sandbox_swap_case_read_ea(emul, offset, valuep, size);
116 *valuep = plat->command;
118 case PCI_HEADER_TYPE:
122 *valuep = SANDBOX_PCI_VENDOR_ID;
125 *valuep = SANDBOX_PCI_SWAP_CASE_EMUL_ID;
127 case PCI_CLASS_DEVICE:
128 if (size == PCI_SIZE_8) {
129 *valuep = SANDBOX_PCI_CLASS_SUB_CODE;
131 *valuep = (SANDBOX_PCI_CLASS_CODE << 8) |
132 SANDBOX_PCI_CLASS_SUB_CODE;
136 *valuep = SANDBOX_PCI_CLASS_CODE;
138 case PCI_BASE_ADDRESS_0:
139 case PCI_BASE_ADDRESS_1:
140 case PCI_BASE_ADDRESS_2:
141 case PCI_BASE_ADDRESS_3:
142 case PCI_BASE_ADDRESS_4:
143 case PCI_BASE_ADDRESS_5: {
147 barnum = offset_to_barnum(offset);
148 bar = &plat->bar[barnum];
151 if (*bar == 0xffffffff) {
152 if (barinfo[barnum].type) {
153 result = (~(barinfo[barnum].size - 1) &
154 PCI_BASE_ADDRESS_IO_MASK) |
155 PCI_BASE_ADDRESS_SPACE_IO;
157 result = (~(barinfo[barnum].size - 1) &
158 PCI_BASE_ADDRESS_MEM_MASK) |
159 PCI_BASE_ADDRESS_MEM_TYPE_32;
162 debug("r bar %d=%x\n", barnum, result);
166 case PCI_CAPABILITY_LIST:
167 *valuep = PCI_CAP_ID_PM_OFFSET;
169 case PCI_CAP_ID_PM_OFFSET:
170 *valuep = (PCI_CAP_ID_EXP_OFFSET << 8) | PCI_CAP_ID_PM;
172 case PCI_CAP_ID_PM_OFFSET + PCI_CAP_LIST_NEXT:
173 *valuep = PCI_CAP_ID_EXP_OFFSET;
175 case PCI_CAP_ID_EXP_OFFSET:
176 *valuep = (PCI_CAP_ID_MSIX_OFFSET << 8) | PCI_CAP_ID_EXP;
178 case PCI_CAP_ID_EXP_OFFSET + PCI_CAP_LIST_NEXT:
179 *valuep = PCI_CAP_ID_MSIX_OFFSET;
181 case PCI_CAP_ID_MSIX_OFFSET:
182 if (sandbox_swap_case_use_ea(emul))
183 *valuep = (PCI_CAP_ID_EA_OFFSET << 8) | PCI_CAP_ID_MSIX;
185 *valuep = PCI_CAP_ID_MSIX;
187 case PCI_CAP_ID_MSIX_OFFSET + PCI_CAP_LIST_NEXT:
188 if (sandbox_swap_case_use_ea(emul))
189 *valuep = PCI_CAP_ID_EA_OFFSET;
193 case PCI_CAP_ID_EA_OFFSET:
194 *valuep = (PCI_CAP_ID_EA_ENTRY_CNT << 16) | PCI_CAP_ID_EA;
196 case PCI_CAP_ID_EA_OFFSET + PCI_CAP_LIST_NEXT:
199 case PCI_EXT_CAP_ID_ERR_OFFSET:
200 *valuep = (PCI_EXT_CAP_ID_VC_OFFSET << 20) | PCI_EXT_CAP_ID_ERR;
202 case PCI_EXT_CAP_ID_VC_OFFSET:
203 *valuep = (PCI_EXT_CAP_ID_DSN_OFFSET << 20) | PCI_EXT_CAP_ID_VC;
205 case PCI_EXT_CAP_ID_DSN_OFFSET:
206 *valuep = PCI_EXT_CAP_ID_DSN;
213 static int sandbox_swap_case_write_config(struct udevice *emul, uint offset,
214 ulong value, enum pci_size_t size)
216 struct swap_case_platdata *plat = dev_get_platdata(emul);
220 plat->command = value;
222 case PCI_BASE_ADDRESS_0:
223 case PCI_BASE_ADDRESS_1: {
227 barnum = offset_to_barnum(offset);
228 bar = &plat->bar[barnum];
230 debug("w bar %d=%lx\n", barnum, value);
232 /* space indicator (bit#0) is read-only */
233 *bar |= barinfo[barnum].type;
241 static int sandbox_swap_case_find_bar(struct udevice *emul, unsigned int addr,
242 int *barnump, unsigned int *offsetp)
244 struct swap_case_platdata *plat = dev_get_platdata(emul);
247 for (barnum = 0; barnum < ARRAY_SIZE(barinfo); barnum++) {
248 unsigned int size = barinfo[barnum].size;
249 u32 base = plat->bar[barnum] & ~PCI_BASE_ADDRESS_SPACE;
251 if (addr >= base && addr < base + size) {
253 *offsetp = addr - base;
262 static void sandbox_swap_case_do_op(enum swap_case_op op, char *str, int len)
264 for (; len > 0; len--, str++) {
267 *str = toupper(*str);
270 *str = tolower(*str);
274 *str = tolower(*str);
276 *str = toupper(*str);
282 static int sandbox_swap_case_read_io(struct udevice *dev, unsigned int addr,
283 ulong *valuep, enum pci_size_t size)
285 struct swap_case_priv *priv = dev_get_priv(dev);
290 ret = sandbox_swap_case_find_bar(dev, addr, &barnum, &offset);
294 if (barnum == 0 && offset == 0)
295 *valuep = (*valuep & ~0xff) | priv->op;
300 static int sandbox_swap_case_write_io(struct udevice *dev, unsigned int addr,
301 ulong value, enum pci_size_t size)
303 struct swap_case_priv *priv = dev_get_priv(dev);
308 ret = sandbox_swap_case_find_bar(dev, addr, &barnum, &offset);
311 if (barnum == 0 && offset == 0)
317 static int pci_ea_bar2_magic = PCI_EA_BAR2_MAGIC;
318 static int pci_ea_bar4_magic = PCI_EA_BAR4_MAGIC;
320 static int sandbox_swap_case_map_physmem(struct udevice *dev,
321 phys_addr_t addr, unsigned long *lenp, void **ptrp)
323 struct swap_case_priv *priv = dev_get_priv(dev);
324 unsigned int offset, avail;
328 if (sandbox_swap_case_use_ea(dev)) {
330 * only support mapping base address in EA test for now, we
331 * don't handle mapping an offset inside a BAR. Seems good
332 * enough for the current test.
335 case (phys_addr_t)PCI_CAP_EA_BASE_LO0:
339 case (phys_addr_t)PCI_CAP_EA_BASE_LO1:
340 *ptrp = priv->mem_text;
341 *lenp = barinfo[1].size - 1;
343 case (phys_addr_t)((PCI_CAP_EA_BASE_HI2 << 32) |
344 PCI_CAP_EA_BASE_LO2):
345 *ptrp = &pci_ea_bar2_magic;
346 *lenp = PCI_CAP_EA_SIZE_LO;
348 case (phys_addr_t)((PCI_CAP_EA_BASE_HI4 << 32) |
349 PCI_CAP_EA_BASE_LO4):
350 *ptrp = &pci_ea_bar4_magic;
351 *lenp = (PCI_CAP_EA_SIZE_HI << 32) |
360 ret = sandbox_swap_case_find_bar(dev, addr, &barnum, &offset);
365 *ptrp = priv->mem_text + offset;
366 avail = barinfo[1].size - offset;
367 if (avail > barinfo[1].size)
370 *lenp = min(*lenp, (ulong)avail);
378 static int sandbox_swap_case_unmap_physmem(struct udevice *dev,
379 const void *vaddr, unsigned long len)
381 struct swap_case_priv *priv = dev_get_priv(dev);
383 sandbox_swap_case_do_op(priv->op, (void *)vaddr, len);
388 static struct dm_pci_emul_ops sandbox_swap_case_emul_ops = {
389 .read_config = sandbox_swap_case_read_config,
390 .write_config = sandbox_swap_case_write_config,
391 .read_io = sandbox_swap_case_read_io,
392 .write_io = sandbox_swap_case_write_io,
393 .map_physmem = sandbox_swap_case_map_physmem,
394 .unmap_physmem = sandbox_swap_case_unmap_physmem,
397 static const struct udevice_id sandbox_swap_case_ids[] = {
398 { .compatible = "sandbox,swap-case" },
402 U_BOOT_DRIVER(sandbox_swap_case_emul) = {
403 .name = "sandbox_swap_case_emul",
404 .id = UCLASS_PCI_EMUL,
405 .of_match = sandbox_swap_case_ids,
406 .ops = &sandbox_swap_case_emul_ops,
407 .priv_auto_alloc_size = sizeof(struct swap_case_priv),
408 .platdata_auto_alloc_size = sizeof(struct swap_case_platdata),
411 static struct pci_device_id sandbox_swap_case_supported[] = {
412 { PCI_VDEVICE(SANDBOX, SANDBOX_PCI_SWAP_CASE_EMUL_ID),
413 SWAP_CASE_DRV_DATA },
417 U_BOOT_PCI_DEVICE(sandbox_swap_case_emul, sandbox_swap_case_supported);