2 * $Id: setpci.c,v 1.3 1998/06/08 07:57:54 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.
19 #include <asm/byteorder.h>
21 #include <asm/unistd.h>
23 #include <syscall-list.h>
28 static int force; /* Don't complain if no devices match */
29 static int verbose; /* Verbosity level */
30 static int demo_mode; /* Only show */
34 byte bus, devfn, mark;
39 static struct device *first_dev;
43 struct device **dev_vector;
45 unsigned int width; /* Byte width of the access */
46 int num_values; /* Number of values to write; <0=read */
47 unsigned int values[0];
50 static struct op *first_op, **last_op = &first_op;
53 xmalloc(unsigned int howmuch)
55 void *p = malloc(howmuch);
58 fprintf(stderr, "setpci: Unable to allocate %d bytes of memory\n", howmuch);
65 * As libc doesn't support pread/pwrite yet, we have to call them directly
66 * or use lseek/read/write instead.
70 pread(unsigned int fd, void *buf, size_t size, loff_t where)
72 return syscall(SYS_pread, fd, buf, size, where);
76 pwrite(unsigned int fd, void *buf, size_t size, loff_t where)
78 return syscall(SYS_pwrite, fd, buf, size, where);
81 static _syscall4(int, pread, unsigned int, fd, void *, buf, size_t, size, loff_t, where);
82 static _syscall4(int, pwrite, unsigned int, fd, void *, buf, size_t, size, loff_t, where);
88 struct device **last = &first_dev;
92 if (!(f = fopen(PROC_BUS_PCI "/devices", "r")))
94 perror(PROC_BUS_PCI "/devices");
97 while (fgets(line, sizeof(line), f))
99 struct device *d = xmalloc(sizeof(struct device));
100 unsigned int dfn, vend;
102 sscanf(line, "%x %x", &dfn, &vend);
104 d->devfn = dfn & 0xff;
105 d->vendid = vend >> 16U;
106 d->devid = vend & 0xffff;
115 static struct device **
116 select_devices(struct pci_filter *filt)
118 struct device *z, **a, **b;
121 for(z=first_dev; z; z=z->next)
122 if (z->mark = filter_match(filt, z->bus, z->devfn, z->vendid, z->devid))
124 a = b = xmalloc(sizeof(struct device *) * cnt);
125 for(z=first_dev; z; z=z->next)
133 exec_op(struct op *op, struct device *dev)
135 char *mm[] = { NULL, "%02x", "%04x", NULL, "%08x" };
136 char *m = mm[op->width];
143 if (!demo_mode && dev->fd < 0)
146 sprintf(name, PROC_BUS_PCI "/%02x/%02x.%x", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
147 if ((dev->fd = open(name, dev->need_write ? O_RDWR : O_RDONLY)) < 0)
155 printf("%02x:%02x.%x:%02x", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), op->addr);
156 if (op->num_values >= 0)
157 for(i=0; i<op->num_values; i++)
162 printf(m, op->values[i]);
170 i = pwrite(dev->fd, &x8, 1, op->addr);
173 x16 = __cpu_to_le16(op->values[i]);
174 i = pwrite(dev->fd, &x16, 2, op->addr);
177 x32 = __cpu_to_le32(op->values[i]);
178 i = pwrite(dev->fd, &x32, 4, op->addr);
181 if (i != (int) op->width)
183 fprintf(stderr, "Error writing to %02x:%02x.%d: %m", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
196 i = pread(dev->fd, &x8, 1, op->addr);
200 i = pread(dev->fd, &x16, 2, op->addr);
201 x = __le16_to_cpu(x16);
204 i = pread(dev->fd, &x32, 4, op->addr);
205 x = __le32_to_cpu(x32);
208 if (i != (int) op->width)
210 fprintf(stderr, "Error reading from %02x:%02x.%d: %m", dev->bus, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
222 execute(struct op *op)
224 struct device **vec = NULL;
225 struct device **pdev, *dev;
230 pdev = vec = op->dev_vector;
231 while (dev = *pdev++)
232 for(oops=op; oops && oops->dev_vector == vec; oops=oops->next)
234 while (op && op->dev_vector == vec)
240 scan_ops(struct op *op)
242 struct device **pdev, *dev;
246 if (op->num_values >= 0)
248 pdev = op->dev_vector;
249 while (dev = *pdev++)
262 static struct reg_name pci_reg_names[] = {
263 { 0x00, 2, "VENDOR_ID", },
264 { 0x02, 2, "DEVICE_ID", },
265 { 0x04, 2, "COMMAND", },
266 { 0x06, 2, "STATUS", },
267 { 0x08, 1, "REVISION", },
268 { 0x09, 1, "CLASS_PROG", },
269 { 0x0a, 2, "CLASS_DEVICE", },
270 { 0x0c, 1, "CACHE_LINE_SIZE", },
271 { 0x0d, 1, "LATENCY_TIMER", },
272 { 0x0e, 1, "HEADER_TYPE", },
273 { 0x0f, 1, "BIST", },
274 { 0x10, 4, "BASE_ADDRESS_0", },
275 { 0x14, 4, "BASE_ADDRESS_1", },
276 { 0x18, 4, "BASE_ADDRESS_2", },
277 { 0x1c, 4, "BASE_ADDRESS_3", },
278 { 0x20, 4, "BASE_ADDRESS_4", },
279 { 0x24, 4, "BASE_ADDRESS_5", },
280 { 0x28, 4, "CARDBUS_CIS", },
281 { 0x2c, 4, "SUBSYSTEM_VENDOR_ID", },
282 { 0x2e, 2, "SUBSYSTEM_ID", },
283 { 0x30, 4, "ROM_ADDRESS", },
284 { 0x3c, 1, "INTERRUPT_LINE", },
285 { 0x3d, 1, "INTERRUPT_PIN", },
286 { 0x3e, 1, "MIN_GNT", },
287 { 0x3f, 1, "MAX_LAT", },
288 { 0x18, 1, "PRIMARY_BUS", },
289 { 0x19, 1, "SECONDARY_BUS", },
290 { 0x1a, 1, "SUBORDINATE_BUS", },
291 { 0x1b, 1, "SEC_LATENCY_TIMER", },
292 { 0x1c, 1, "IO_BASE", },
293 { 0x1d, 1, "IO_LIMIT", },
294 { 0x1e, 2, "SEC_STATUS", },
295 { 0x20, 2, "MEMORY_BASE", },
296 { 0x22, 2, "MEMORY_LIMIT", },
297 { 0x24, 2, "PREF_MEMORY_BASE", },
298 { 0x26, 2, "PREF_MEMORY_LIMIT", },
299 { 0x28, 4, "PREF_BASE_UPPER32", },
300 { 0x2c, 4, "PREF_LIMIT_UPPER32", },
301 { 0x30, 2, "IO_BASE_UPPER16", },
302 { 0x32, 2, "IO_LIMIT_UPPER16", },
303 { 0x38, 4, "BRIDGE_ROM_ADDRESS", },
304 { 0x3e, 2, "BRIDGE_CONTROL", },
305 { 0x10, 4, "CB_CARDBUS_BASE", },
306 { 0x14, 2, "CB_CAPABILITIES", },
307 { 0x16, 2, "CB_SEC_STATUS", },
308 { 0x18, 1, "CB_BUS_NUMBER", },
309 { 0x19, 1, "CB_CARDBUS_NUMBER", },
310 { 0x1a, 1, "CB_SUBORDINATE_BUS", },
311 { 0x1b, 1, "CB_CARDBUS_LATENCY", },
312 { 0x1c, 4, "CB_MEMORY_BASE_0", },
313 { 0x20, 4, "CB_MEMORY_LIMIT_0", },
314 { 0x24, 4, "CB_MEMORY_BASE_1", },
315 { 0x28, 4, "CB_MEMORY_LIMIT_1", },
316 { 0x2c, 2, "CB_IO_BASE_0", },
317 { 0x2e, 2, "CB_IO_BASE_0_HI", },
318 { 0x30, 2, "CB_IO_LIMIT_0", },
319 { 0x32, 2, "CB_IO_LIMIT_0_HI", },
320 { 0x34, 2, "CB_IO_BASE_1", },
321 { 0x36, 2, "CB_IO_BASE_1_HI", },
322 { 0x38, 2, "CB_IO_LIMIT_1", },
323 { 0x3a, 2, "CB_IO_LIMIT_1_HI", },
324 { 0x40, 2, "CB_SUBSYSTEM_VENDOR_ID", },
325 { 0x42, 2, "CB_SUBSYSTEM_ID", },
326 { 0x44, 4, "CB_LEGACY_MODE_BASE", },
330 static void usage(void) __attribute__((noreturn));
336 "Usage: setpci [-fvD] (<device>+ <reg>[=<values>]*)*\n\
337 -f\t\tDon't complain if there's nothing to do\n\
339 -D\t\tList changes, don't commit them\n\
340 <device>:\t-s [[<bus>]:][<slot>][.[<func>]]\n\
341 \t|\t-d [<vendor>]:[<device>]\n\
342 <reg>:\t\t<number>[.(B|W|L)]\n\
344 <values>:\t<value>[,<value>...]\n\
350 main(int argc, char **argv)
352 enum { STATE_INIT, STATE_GOT_FILTER, STATE_GOT_OP } state = STATE_INIT;
353 struct pci_filter filter;
354 struct device **selected_devices = NULL;
356 if (argc == 2 && !strcmp(argv[1], "--version"))
358 puts("setpci version " PCIUTILS_VERSION);
363 while (argc && argv[0][0] == '-')
402 unsigned long ll, lim;
406 if (!c[1] || !strchr("sd", c[1]))
409 d = (c[2] == '=') ? c+3 : c+2;
418 if (state != STATE_GOT_FILTER)
420 filter_init(&filter);
421 state = STATE_GOT_FILTER;
426 if (d = filter_parse_slot(&filter, d))
428 fprintf(stderr, "setpci: -s: %s\n", d);
433 if (d = filter_parse_id(&filter, d))
435 fprintf(stderr, "setpci: -d: %s\n", d);
443 else if (state == STATE_INIT)
447 if (state == STATE_GOT_FILTER)
448 selected_devices = select_devices(&filter);
449 if (!selected_devices[0] && !force)
450 fprintf(stderr, "setpci: Warning: No devices selected for `%s'.\n", c);
451 state = STATE_GOT_OP;
458 for(e=d, n=1; *e; e++)
461 op = xmalloc(sizeof(struct op) + n*sizeof(unsigned int));
466 op = xmalloc(sizeof(struct op));
468 op->dev_vector = selected_devices;
479 op->width = 1; break;
481 op->width = 2; break;
483 op->width = 4; break;
490 ll = strtol(c, &f, 16);
494 for(r = pci_reg_names; r->name; r++)
495 if (!strcasecmp(r->name, c))
500 op->width = r->width;
502 if (ll > 0x100 || ll + op->width*((n < 0) ? 1 : n) > 0x100)
504 fprintf(stderr, "setpci: Register number out of range!\n");
507 if (ll & (op->width - 1))
509 fprintf(stderr, "setpci: Unaligned register address!\n");
518 ll = strtoul(d, &f, 16);
519 lim = (2 << ((op->width << 3) - 1)) - 1;
521 (ll > lim && ll < ~0UL - lim))
533 if (state == STATE_INIT)