2 * $Id: setpci.c,v 1.2 1998/04/19 11:02:29 mj Exp $
4 * Linux PCI Utilities -- Manipulate PCI Configuration Registers
6 * Copyright (c) 1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
8 * Can be freely distributed and used under the terms of the GNU GPL.
17 #include <asm/unistd.h>
18 #include <asm/byteorder.h>
22 static int force; /* Don't complain if no devices match */
23 static int verbose; /* Verbosity level */
24 static int demo_mode; /* Only show */
28 byte bus, devfn, mark;
33 static struct device *first_dev;
37 struct device **dev_vector;
39 unsigned int width; /* Byte width of the access */
40 int num_values; /* Number of values to write; <0=read */
41 unsigned int values[0];
44 static struct op *first_op, **last_op = &first_op;
47 xmalloc(unsigned int howmuch)
49 void *p = malloc(howmuch);
52 fprintf(stderr, "setpci: Unable to allocate %d bytes of memory\n", howmuch);
59 * As libc doesn't support pread/pwrite yet, we have to call them directly
60 * or use lseek/read/write instead.
62 static _syscall4(int, pread, unsigned int, fd, void *, buf, size_t, size, loff_t, where);
63 static _syscall4(int, pwrite, unsigned int, fd, void *, buf, size_t, size, loff_t, where);
68 struct device **last = &first_dev;
72 if (!(f = fopen(PROC_BUS_PCI "/devices", "r")))
74 perror(PROC_BUS_PCI "/devices");
77 while (fgets(line, sizeof(line), f))
79 struct device *d = xmalloc(sizeof(struct device));
80 unsigned int dfn, vend;
82 sscanf(line, "%x %x", &dfn, &vend);
84 d->devfn = dfn & 0xff;
85 d->vendid = vend >> 16U;
86 d->devid = vend & 0xffff;
95 static struct device **
96 select_devices(struct pci_filter *filt)
98 struct device *z, **a, **b;
101 for(z=first_dev; z; z=z->next)
102 if (z->mark = filter_match(filt, z->bus, z->devfn, z->vendid, z->devid))
104 a = b = xmalloc(sizeof(struct device *) * cnt);
105 for(z=first_dev; z; z=z->next)
113 exec_op(struct op *op, struct device *dev)
115 char *mm[] = { NULL, "%02x", "%04x", NULL, "%08x" };
116 char *m = mm[op->width];
123 if (!demo_mode && dev->fd < 0)
126 sprintf(name, PROC_BUS_PCI "/%02x/%02x.%x", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
127 if ((dev->fd = open(name, dev->need_write ? O_RDWR : O_RDONLY)) < 0)
135 printf("%02x:%02x.%x:%02x", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), op->addr);
136 if (op->num_values >= 0)
137 for(i=0; i<op->num_values; i++)
142 printf(m, op->values[i]);
150 i = pwrite(dev->fd, &x8, 1, op->addr);
153 x16 = __cpu_to_le16(op->values[i]);
154 i = pwrite(dev->fd, &x16, 2, op->addr);
157 x32 = __cpu_to_le32(op->values[i]);
158 i = pwrite(dev->fd, &x32, 4, op->addr);
161 if (i != (int) op->width)
163 fprintf(stderr, "Error writing to %02x:%02x.%d: %m", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
176 i = pread(dev->fd, &x8, 1, op->addr);
180 i = pread(dev->fd, &x16, 2, op->addr);
181 x = __le16_to_cpu(x16);
184 i = pread(dev->fd, &x32, 4, op->addr);
185 x = __le32_to_cpu(x32);
188 if (i != (int) op->width)
190 fprintf(stderr, "Error reading from %02x:%02x.%d: %m", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
202 execute(struct op *op)
204 struct device **vec = NULL;
205 struct device **pdev, *dev;
210 pdev = vec = op->dev_vector;
211 while (dev = *pdev++)
212 for(oops=op; oops && oops->dev_vector == vec; oops=oops->next)
214 while (op && op->dev_vector == vec)
220 scan_ops(struct op *op)
222 struct device **pdev, *dev;
226 if (op->num_values >= 0)
228 pdev = op->dev_vector;
229 while (dev = *pdev++)
242 static struct reg_name pci_reg_names[] = {
243 { 0x00, 2, "VENDOR_ID", },
244 { 0x02, 2, "DEVICE_ID", },
245 { 0x04, 2, "COMMAND", },
246 { 0x06, 2, "STATUS", },
247 { 0x08, 1, "REVISION", },
248 { 0x09, 1, "CLASS_PROG", },
249 { 0x0a, 2, "CLASS_DEVICE", },
250 { 0x0c, 1, "CACHE_LINE_SIZE", },
251 { 0x0d, 1, "LATENCY_TIMER", },
252 { 0x0e, 1, "HEADER_TYPE", },
253 { 0x0f, 1, "BIST", },
254 { 0x10, 4, "BASE_ADDRESS_0", },
255 { 0x14, 4, "BASE_ADDRESS_1", },
256 { 0x18, 4, "BASE_ADDRESS_2", },
257 { 0x1c, 4, "BASE_ADDRESS_3", },
258 { 0x20, 4, "BASE_ADDRESS_4", },
259 { 0x24, 4, "BASE_ADDRESS_5", },
260 { 0x28, 4, "CARDBUS_CIS", },
261 { 0x2c, 4, "SUBSYSTEM_VENDOR_ID", },
262 { 0x2e, 2, "SUBSYSTEM_ID", },
263 { 0x30, 4, "ROM_ADDRESS", },
264 { 0x3c, 1, "INTERRUPT_LINE", },
265 { 0x3d, 1, "INTERRUPT_PIN", },
266 { 0x3e, 1, "MIN_GNT", },
267 { 0x3f, 1, "MAX_LAT", },
268 { 0x18, 1, "PRIMARY_BUS", },
269 { 0x19, 1, "SECONDARY_BUS", },
270 { 0x1a, 1, "SUBORDINATE_BUS", },
271 { 0x1b, 1, "SEC_LATENCY_TIMER", },
272 { 0x1c, 1, "IO_BASE", },
273 { 0x1d, 1, "IO_LIMIT", },
274 { 0x1e, 2, "SEC_STATUS", },
275 { 0x20, 2, "MEMORY_BASE", },
276 { 0x22, 2, "MEMORY_LIMIT", },
277 { 0x24, 2, "PREF_MEMORY_BASE", },
278 { 0x26, 2, "PREF_MEMORY_LIMIT", },
279 { 0x28, 4, "PREF_BASE_UPPER32", },
280 { 0x2c, 4, "PREF_LIMIT_UPPER32", },
281 { 0x30, 2, "IO_BASE_UPPER16", },
282 { 0x32, 2, "IO_LIMIT_UPPER16", },
283 { 0x38, 4, "BRIDGE_ROM_ADDRESS", },
284 { 0x3e, 2, "BRIDGE_CONTROL", },
285 { 0x10, 4, "CB_CARDBUS_BASE", },
286 { 0x14, 2, "CB_CAPABILITIES", },
287 { 0x16, 2, "CB_SEC_STATUS", },
288 { 0x18, 1, "CB_BUS_NUMBER", },
289 { 0x19, 1, "CB_CARDBUS_NUMBER", },
290 { 0x1a, 1, "CB_SUBORDINATE_BUS", },
291 { 0x1b, 1, "CB_CARDBUS_LATENCY", },
292 { 0x1c, 4, "CB_MEMORY_BASE_0", },
293 { 0x20, 4, "CB_MEMORY_LIMIT_0", },
294 { 0x24, 4, "CB_MEMORY_BASE_1", },
295 { 0x28, 4, "CB_MEMORY_LIMIT_1", },
296 { 0x2c, 2, "CB_IO_BASE_0", },
297 { 0x2e, 2, "CB_IO_BASE_0_HI", },
298 { 0x30, 2, "CB_IO_LIMIT_0", },
299 { 0x32, 2, "CB_IO_LIMIT_0_HI", },
300 { 0x34, 2, "CB_IO_BASE_1", },
301 { 0x36, 2, "CB_IO_BASE_1_HI", },
302 { 0x38, 2, "CB_IO_LIMIT_1", },
303 { 0x3a, 2, "CB_IO_LIMIT_1_HI", },
304 { 0x40, 2, "CB_SUBSYSTEM_VENDOR_ID", },
305 { 0x42, 2, "CB_SUBSYSTEM_ID", },
306 { 0x44, 4, "CB_LEGACY_MODE_BASE", },
310 static void usage(void) __attribute__((noreturn));
316 "Usage: setpci [-fvD] (<device>+ <reg>[=<values>]*)*\n\
317 -f\t\tDon't complain if there's nothing to do\n\
319 -D\t\tList changes, don't commit them\n\
320 <device>:\t-s [[<bus>]:][<slot>][.[<func>]]\n\
321 \t|\t-d [<vendor>]:[<device>]\n\
322 <reg>:\t\t<number>[.(B|W|L)]\n\
324 <values>:\t<value>[,<value>...]\n\
330 main(int argc, char **argv)
332 enum { STATE_INIT, STATE_GOT_FILTER, STATE_GOT_OP } state = STATE_INIT;
333 struct pci_filter filter;
334 struct device **selected_devices = NULL;
338 while (argc && argv[0][0] == '-')
377 unsigned long ll, lim;
381 if (!c[1] || !strchr("sd", c[1]))
384 d = (c[2] == '=') ? c+3 : c+2;
393 if (state != STATE_GOT_FILTER)
395 filter_init(&filter);
396 state = STATE_GOT_FILTER;
401 if (d = filter_parse_slot(&filter, d))
403 fprintf(stderr, "setpci: -s: %s\n", d);
408 if (d = filter_parse_id(&filter, d))
410 fprintf(stderr, "setpci: -d: %s\n", d);
418 else if (state == STATE_INIT)
422 if (state == STATE_GOT_FILTER)
423 selected_devices = select_devices(&filter);
424 if (!selected_devices[0] && !force)
425 fprintf(stderr, "setpci: Warning: No devices selected for `%s'.\n", c);
426 state = STATE_GOT_OP;
433 for(e=d, n=1; *e; e++)
436 op = xmalloc(sizeof(struct op) + n*sizeof(unsigned int));
441 op = xmalloc(sizeof(struct op));
443 op->dev_vector = selected_devices;
454 op->width = 1; break;
456 op->width = 2; break;
458 op->width = 4; break;
465 ll = strtol(c, &f, 16);
469 for(r = pci_reg_names; r->name; r++)
470 if (!strcasecmp(r->name, c))
475 op->width = r->width;
477 if (ll > 0x100 || ll + op->width*((n < 0) ? 1 : n) > 0x100)
479 fprintf(stderr, "setpci: Register number out of range!\n");
482 if (ll & (op->width - 1))
484 fprintf(stderr, "setpci: Unaligned register address!\n");
493 ll = strtoul(d, &f, 16);
494 lim = (2 << ((op->width << 3) - 1)) - 1;
496 (ll > lim && ll < ~0UL - lim))
508 if (state == STATE_INIT)