[thirdparty/pciutils.git] / setpci.c

/*
 *	Linux PCI Utilities -- Manipulate PCI Configuration Registers
 *
 *	Copyright (c) 1998--2003 Martin Mares <mj@ucw.cz>
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>

#include "pciutils.h"

static int force;			/* Don't complain if no devices match */
static int verbose;			/* Verbosity level */
static int demo_mode;			/* Only show */

static struct pci_access *pacc;

struct value {
  unsigned int value;
  unsigned int mask;
};

struct op {
  struct op *next;
  struct pci_dev **dev_vector;
  unsigned int addr;
  unsigned int width;			/* Byte width of the access */
  int num_values;			/* Number of values to write; <0=read */
  struct value values[0];
};

static struct op *first_op, **last_op = &first_op;
static unsigned int max_values[] = { 0, 0xff, 0xffff, 0, 0xffffffff };

static struct pci_dev **
select_devices(struct pci_filter *filt)
{
  struct pci_dev *z, **a, **b;
  int cnt = 1;

  for(z=pacc->devices; z; z=z->next)
    if (pci_filter_match(filt, z))
      cnt++;
  a = b = xmalloc(sizeof(struct device *) * cnt);
  for(z=pacc->devices; z; z=z->next)
    if (pci_filter_match(filt, z))
      *a++ = z;
  *a = NULL;
  return b;
}

static void
exec_op(struct op *op, struct pci_dev *dev)
{
  char *formats[] = { NULL, "%02x", "%04x", NULL, "%08x" };
  char *mask_formats[] = { NULL, "%02x->(%02x:%02x)->%02x", "%04x->(%04x:%04x)->%04x", NULL, "%08x->(%08x:%08x)->%08x" };
  unsigned int x, y;
  int i, addr;
  int width = op->width;

  if (verbose)
    printf("%02x:%02x.%x:%02x", dev->bus, dev->dev, dev->func, op->addr);
  addr = op->addr;
  if (op->num_values >= 0)
    {
      for(i=0; i<op->num_values; i++)
	{
	  if ((op->values[i].mask & max_values[width]) == max_values[width])
	    {
	      x = op->values[i].value;
	      if (verbose)
		{
		  putchar(' ');
		  printf(formats[width], op->values[i].value);
		}
	    }
	  else
	    {
	      switch (width)
		{
		case 1:
		  y = pci_read_byte(dev, addr);
		  break;
		case 2:
		  y = pci_read_word(dev, addr);
		  break;
		default:
		  y = pci_read_long(dev, addr);
		  break;
		}
	      x = (y & ~op->values[i].mask) | op->values[i].value;
	      if (verbose)
		{
		  putchar(' ');
		  printf(mask_formats[width], y, op->values[i].value, op->values[i].mask, x);
		}
	    }
	  if (!demo_mode)
	    {
	      switch (width)
		{
		case 1:
		  pci_write_byte(dev, addr, x);
		  break;
		case 2:
		  pci_write_word(dev, addr, x);
		  break;
		default:
		  pci_write_long(dev, addr, x);
		  break;
		}
	    }
	  addr += width;
	}
      if (verbose)
	putchar('\n');
    }
  else
    {
      if (verbose)
	printf(" = ");
      if (!demo_mode)
	{
	  switch (width)
	    {
	    case 1:
	      x = pci_read_byte(dev, addr);
	      break;
	    case 2:
	      x = pci_read_word(dev, addr);
	      break;
	    default:
	      x = pci_read_long(dev, addr);
	      break;
	    }
	  printf(formats[width], x);
	}
      else
	putchar('?');
      putchar('\n');
    }
}

static void
execute(struct op *op)
{
  struct pci_dev **vec = NULL;
  struct pci_dev **pdev, *dev;
  struct op *oops;

  while (op)
    {
      pdev = vec = op->dev_vector;
      while (dev = *pdev++)
	for(oops=op; oops && oops->dev_vector == vec; oops=oops->next)
	  exec_op(oops, dev);
      while (op && op->dev_vector == vec)
	op = op->next;
    }
}

static void
scan_ops(struct op *op)
{
  while (op)
    {
      if (op->num_values >= 0)
	pacc->writeable = 1;
      op = op->next;
    }
}

struct reg_name {
  unsigned int offset;
  unsigned int width;
  const char *name;
};

static const struct reg_name pci_reg_names[] = {
  { 0x00, 2, "VENDOR_ID", },
  { 0x02, 2, "DEVICE_ID", },
  { 0x04, 2, "COMMAND", },
  { 0x06, 2, "STATUS", },
  { 0x08, 1, "REVISION", },
  { 0x09, 1, "CLASS_PROG", },
  { 0x0a, 2, "CLASS_DEVICE", },
  { 0x0c, 1, "CACHE_LINE_SIZE", },
  { 0x0d, 1, "LATENCY_TIMER", },
  { 0x0e, 1, "HEADER_TYPE", },
  { 0x0f, 1, "BIST", },
  { 0x10, 4, "BASE_ADDRESS_0", },
  { 0x14, 4, "BASE_ADDRESS_1", },
  { 0x18, 4, "BASE_ADDRESS_2", },
  { 0x1c, 4, "BASE_ADDRESS_3", },
  { 0x20, 4, "BASE_ADDRESS_4", },
  { 0x24, 4, "BASE_ADDRESS_5", },
  { 0x28, 4, "CARDBUS_CIS", },
  { 0x2c, 4, "SUBSYSTEM_VENDOR_ID", },
  { 0x2e, 2, "SUBSYSTEM_ID", },
  { 0x30, 4, "ROM_ADDRESS", },
  { 0x3c, 1, "INTERRUPT_LINE", },
  { 0x3d, 1, "INTERRUPT_PIN", },
  { 0x3e, 1, "MIN_GNT", },
  { 0x3f, 1, "MAX_LAT", },
  { 0x18, 1, "PRIMARY_BUS", },
  { 0x19, 1, "SECONDARY_BUS", },
  { 0x1a, 1, "SUBORDINATE_BUS", },
  { 0x1b, 1, "SEC_LATENCY_TIMER", },
  { 0x1c, 1, "IO_BASE", },
  { 0x1d, 1, "IO_LIMIT", },
  { 0x1e, 2, "SEC_STATUS", },
  { 0x20, 2, "MEMORY_BASE", },
  { 0x22, 2, "MEMORY_LIMIT", },
  { 0x24, 2, "PREF_MEMORY_BASE", },
  { 0x26, 2, "PREF_MEMORY_LIMIT", },
  { 0x28, 4, "PREF_BASE_UPPER32", },
  { 0x2c, 4, "PREF_LIMIT_UPPER32", },
  { 0x30, 2, "IO_BASE_UPPER16", },
  { 0x32, 2, "IO_LIMIT_UPPER16", },
  { 0x38, 4, "BRIDGE_ROM_ADDRESS", },
  { 0x3e, 2, "BRIDGE_CONTROL", },
  { 0x10, 4, "CB_CARDBUS_BASE", },
  { 0x14, 2, "CB_CAPABILITIES", },
  { 0x16, 2, "CB_SEC_STATUS", },
  { 0x18, 1, "CB_BUS_NUMBER", },
  { 0x19, 1, "CB_CARDBUS_NUMBER", },
  { 0x1a, 1, "CB_SUBORDINATE_BUS", },
  { 0x1b, 1, "CB_CARDBUS_LATENCY", },
  { 0x1c, 4, "CB_MEMORY_BASE_0", },
  { 0x20, 4, "CB_MEMORY_LIMIT_0", },
  { 0x24, 4, "CB_MEMORY_BASE_1", },
  { 0x28, 4, "CB_MEMORY_LIMIT_1", },
  { 0x2c, 2, "CB_IO_BASE_0", },
  { 0x2e, 2, "CB_IO_BASE_0_HI", },
  { 0x30, 2, "CB_IO_LIMIT_0", },
  { 0x32, 2, "CB_IO_LIMIT_0_HI", },
  { 0x34, 2, "CB_IO_BASE_1", },
  { 0x36, 2, "CB_IO_BASE_1_HI", },
  { 0x38, 2, "CB_IO_LIMIT_1", },
  { 0x3a, 2, "CB_IO_LIMIT_1_HI", },
  { 0x40, 2, "CB_SUBSYSTEM_VENDOR_ID", },
  { 0x42, 2, "CB_SUBSYSTEM_ID", },
  { 0x44, 4, "CB_LEGACY_MODE_BASE", },
  { 0x00, 0, NULL }
};

static void NONRET
usage(char *msg, ...)
{
  va_list args;
  va_start(args, msg);
  if (msg)
    {
      fprintf(stderr, "setpci: ");
      vfprintf(stderr, msg, args);
      fprintf(stderr, "\n\n");
    }
  fprintf(stderr,
"Usage: setpci [<options>] (<device>+ <reg>[=<values>]*)*\n\
-f\t\tDon't complain if there's nothing to do\n\
-v\t\tBe verbose\n\
-D\t\tList changes, don't commit them\n"
GENERIC_HELP
"<device>:\t-s [[<bus>]:][<slot>][.[<func>]]\n"
"\t|\t-d [<vendor>]:[<device>]\n"
"<reg>:\t\t<number>[.(B|W|L)]\n"
"     |\t\t<name>\n"
"<values>:\t<value>[,<value>...]\n"
"<value>:\t<hex>\n"
"       |\t<hex>:<mask>\n");
  exit(1);
}

int
main(int argc, char **argv)
{
  enum { STATE_INIT, STATE_GOT_FILTER, STATE_GOT_OP } state = STATE_INIT;
  struct pci_filter filter;
  struct pci_dev **selected_devices = NULL;
  char *opts = GENERIC_OPTIONS ;

  if (argc == 2 && !strcmp(argv[1], "--version"))
    {
      puts("setpci version " PCIUTILS_VERSION);
      return 0;
    }
  argc--;
  argv++;

  pacc = pci_alloc();
  pacc->error = die;

  while (argc && argv[0][0] == '-')
    {
      char *c = argv[0]+1;
      char *d = c;
      char *e;
      while (*c)
	switch (*c)
	  {
	  case 'v':
	    verbose++;
	    c++;
	    break;
	  case 'f':
	    force++;
	    c++;
	    break;
	  case 'D':
	    demo_mode++;
	    c++;
	    break;
	  case 0:
	    break;
	  default:
	    if (e = strchr(opts, *c))
	      {
		char *arg;
		c++;
		if (e[1] == ':')
		  {
		    if (*c)
		      arg = c;
		    else if (argc > 1)
		      {
			arg = argv[1];
			argc--; argv++;
		      }
		    else
		      usage(NULL);
		    c = "";
		  }
		else
		  arg = NULL;
		if (!parse_generic_option(*e, pacc, arg))
		  usage(NULL);
	      }
	    else
	      {
		if (c != d)
		  usage(NULL);
		goto next;
	      }
	  }
      argc--;
      argv++;
    }
next:

  pci_init(pacc);
  pci_scan_bus(pacc);

  while (argc)
    {
      char *c = argv[0];
      char *d, *e, *f;
      int n, i;
      struct op *op;
      unsigned long ll;
      unsigned int lim;

      if (*c == '-')
	{
	  if (!c[1] || !strchr("sd", c[1]))
	    usage(NULL);
	  if (c[2])
	    d = (c[2] == '=') ? c+3 : c+2;
	  else if (argc > 1)
	    {
	      argc--;
	      argv++;
	      d = argv[0];
	    }
	  else
	    usage(NULL);
	  if (state != STATE_GOT_FILTER)
	    {
	      pci_filter_init(pacc, &filter);
	      state = STATE_GOT_FILTER;
	    }
	  switch (c[1])
	    {
	    case 's':
	      if (d = pci_filter_parse_slot(&filter, d))
		die("-s: %s", d);
	      break;
	    case 'd':
	      if (d = pci_filter_parse_id(&filter, d))
		die("-d: %s", d);
	      break;
	    default:
	      usage(NULL);
	    }
	}
      else if (state == STATE_INIT)
	usage(NULL);
      else
	{
	  if (state == STATE_GOT_FILTER)
	    selected_devices = select_devices(&filter);
	  if (!selected_devices[0] && !force)
	    fprintf(stderr, "setpci: Warning: No devices selected for `%s'.\n", c);
	  state = STATE_GOT_OP;
	  /* look for setting of values and count how many */
	  d = strchr(c, '=');
	  if (d)
	    {
	      *d++ = 0;
	      if (!*d)
		usage("Missing value");
	      for(e=d, n=1; *e; e++)
		if (*e == ',')
		  n++;
	      op = xmalloc(sizeof(struct op) + n*sizeof(struct value));
	    }
	  else
	    {
	      n = -1;
	      op = xmalloc(sizeof(struct op));
	    }
	  op->dev_vector = selected_devices;
	  op->num_values = n;
	  e = strchr(c, '.');
	  if (e)
	    {
	      *e++ = 0;
	      if (e[1])
		usage("Missing width");
	      switch (*e & 0xdf)
		{
		case 'B':
		  op->width = 1; break;
		case 'W':
		  op->width = 2; break;
		case 'L':
		  op->width = 4; break;
		default:
		  usage("Invalid width \"%s\"", *e);
		}
	    }
	  else
	    op->width = 1;
	  ll = strtol(c, &f, 16);
	  if (f && *f)
	    {
	      const struct reg_name *r;
	      for(r = pci_reg_names; r->name; r++)
		if (!strcasecmp(r->name, c))
		  break;
	      if (!r->name)
		usage("Unknown register \"%s\"", c);
	      if (e && op->width != r->width)
		usage("Explicit width doesn't correspond with the named register \"%s\"", c);
	      ll = r->offset;
	      op->width = r->width;
	    }
	  if (ll > 0x100 || ll + op->width*((n < 0) ? 1 : n) > 0x100)
	    die("Register number out of range!");
	  if (ll & (op->width - 1))
	    die("Unaligned register address!");
	  op->addr = ll;
	  /* read in all the values to be set */
	  for(i=0; i<n; i++)
	    {
	      e = strchr(d, ',');
	      if (e)
		*e++ = 0;
	      ll = strtoul(d, &f, 16);
	      lim = max_values[op->width];
	      if (f && *f && *f != ':')
		usage("Invalid value \"%s\"", d);
	      if (ll > lim && ll < ~0UL - lim)
		usage("Value \"%s\" is out of range", d);
	      op->values[i].value = ll;
	      if (f && *f == ':')
		{
		  d = ++f;
		  ll = strtoul(d, &f, 16);
		  if (f && *f)
		    usage("Invalid mask \"%s\"", d);
		  if (ll > lim && ll < ~0UL - lim)
		    usage("Mask \"%s\" is out of range", d);
		  op->values[i].mask = ll;
		  op->values[i].value &= ll;
		}
	      else
		op->values[i].mask = ~0U;
	      d = e;
	    }
	  *last_op = op;
	  last_op = &op->next;
	  op->next = NULL;
	}
      argc--;
      argv++;
    }
  if (state == STATE_INIT)
    usage("No operation specified");

  scan_ops(first_op);
  execute(first_op);

  return 0;
}
Commit	Line	Data
e4842ff3	1	/*
e4842ff3 MM	2	* Linux PCI Utilities -- Manipulate PCI Configuration Registers
e4842ff3 MM	3	*
b7351143	4	* Copyright (c) 1998--2003 Martin Mares <mj@ucw.cz>
e4842ff3 MM	5	*
	6	* Can be freely distributed and used under the terms of the GNU GPL.
	7	*/
	8
	9	#include <stdio.h>
	10	#include <string.h>
	11	#include <stdlib.h>
727ce158	12	#include <stdarg.h>
e4842ff3	13	#include <unistd.h>
7aad822b	14
e4842ff3 MM	15	#include "pciutils.h"
	16
	17	static int force; /* Don't complain if no devices match */
	18	static int verbose; /* Verbosity level */
b2c9b373	19	static int demo_mode; /* Only show */
e4842ff3	20
727ce158	21	static struct pci_access *pacc;
e4842ff3	22
b7351143 MM	23	struct value {
	24	unsigned int value;
	25	unsigned int mask;
	26	};
	27
e4842ff3 MM	28	struct op {
e4842ff3 MM	29	struct op *next;
727ce158	30	struct pci_dev **dev_vector;
e4842ff3 MM	31	unsigned int addr;
	32	unsigned int width; /* Byte width of the access */
	33	int num_values; /* Number of values to write; <0=read */
b7351143	34	struct value values[0];
e4842ff3 MM	35	};
	36
	37	static struct op first_op, *last_op = &first_op;
b7351143	38	static unsigned int max_values[] = { 0, 0xff, 0xffff, 0, 0xffffffff };
e4842ff3	39
727ce158	40	static struct pci_dev **
e4842ff3 MM	41	select_devices(struct pci_filter *filt)
e4842ff3 MM	42	{
727ce158	43	struct pci_dev z, a, *b;
e4842ff3 MM	44	int cnt = 1;
e4842ff3 MM	45
727ce158 MM	46	for(z=pacc->devices; z; z=z->next)
727ce158 MM	47	if (pci_filter_match(filt, z))
e4842ff3 MM	48	cnt++;
e4842ff3 MM	49	a = b = xmalloc(sizeof(struct device ) cnt);
727ce158 MM	50	for(z=pacc->devices; z; z=z->next)
727ce158 MM	51	if (pci_filter_match(filt, z))
e4842ff3 MM	52	*a++ = z;
	53	*a = NULL;
	54	return b;
	55	}
	56
	57	static void
727ce158	58	exec_op(struct op op, struct pci_dev dev)
e4842ff3	59	{
b7351143 MM	60	char *formats[] = { NULL, "%02x", "%04x", NULL, "%08x" };
	61	char *mask_formats[] = { NULL, "%02x->(%02x:%02x)->%02x", "%04x->(%04x:%04x)->%04x", NULL, "%08x->(%08x:%08x)->%08x" };
	62	unsigned int x, y;
33bc28a5	63	int i, addr;
b7351143	64	int width = op->width;
e4842ff3 MM	65
e4842ff3 MM	66	if (verbose)
727ce158	67	printf("%02x:%02x.%x:%02x", dev->bus, dev->dev, dev->func, op->addr);
33bc28a5	68	addr = op->addr;
b2c9b373	69	if (op->num_values >= 0)
b7351143 MM	70	{
	71	for(i=0; i<op->num_values; i++)
	72	{
	73	if ((op->values[i].mask & max_values[width]) == max_values[width])
	74	{
	75	x = op->values[i].value;
	76	if (verbose)
	77	{
	78	putchar(' ');
	79	printf(formats[width], op->values[i].value);
	80	}
	81	}
	82	else
	83	{
	84	switch (width)
	85	{
	86	case 1:
	87	y = pci_read_byte(dev, addr);
	88	break;
	89	case 2:
	90	y = pci_read_word(dev, addr);
	91	break;
	92	default:
	93	y = pci_read_long(dev, addr);
	94	break;
	95	}
	96	x = (y & ~op->values[i].mask) \| op->values[i].value;
	97	if (verbose)
	98	{
	99	putchar(' ');
	100	printf(mask_formats[width], y, op->values[i].value, op->values[i].mask, x);
	101	}
	102	}
	103	if (!demo_mode)
	104	{
	105	switch (width)
	106	{
	107	case 1:
	108	pci_write_byte(dev, addr, x);
	109	break;
	110	case 2:
	111	pci_write_word(dev, addr, x);
	112	break;
	113	default:
	114	pci_write_long(dev, addr, x);
	115	break;
	116	}
	117	}
	118	addr += width;
	119	}
	120	if (verbose)
	121	putchar('\n');
	122	}
e4842ff3 MM	123	else
	124	{
	125	if (verbose)
b2c9b373 MM	126	printf(" = ");
	127	if (!demo_mode)
	128	{
b7351143	129	switch (width)
b2c9b373 MM	130	{
b2c9b373 MM	131	case 1:
33bc28a5	132	x = pci_read_byte(dev, addr);
b2c9b373 MM	133	break;
b2c9b373 MM	134	case 2:
33bc28a5	135	x = pci_read_word(dev, addr);
b2c9b373 MM	136	break;
b2c9b373 MM	137	default:
33bc28a5	138	x = pci_read_long(dev, addr);
b2c9b373 MM	139	break;
b2c9b373 MM	140	}
b7351143	141	printf(formats[width], x);
b2c9b373 MM	142	}
	143	else
	144	putchar('?');
b7351143	145	putchar('\n');
e4842ff3 MM	146	}
	147	}
	148
	149	static void
	150	execute(struct op *op)
	151	{
727ce158 MM	152	struct pci_dev **vec = NULL;
727ce158 MM	153	struct pci_dev *pdev, dev;
e4842ff3 MM	154	struct op *oops;
	155
	156	while (op)
	157	{
	158	pdev = vec = op->dev_vector;
	159	while (dev = *pdev++)
	160	for(oops=op; oops && oops->dev_vector == vec; oops=oops->next)
	161	exec_op(oops, dev);
	162	while (op && op->dev_vector == vec)
	163	op = op->next;
	164	}
	165	}
	166
b2c9b373 MM	167	static void
	168	scan_ops(struct op *op)
	169	{
b2c9b373 MM	170	while (op)
	171	{
	172	if (op->num_values >= 0)
727ce158	173	pacc->writeable = 1;
b2c9b373 MM	174	op = op->next;
	175	}
	176	}
	177
	178	struct reg_name {
3fe8a38d MM	179	unsigned int offset;
3fe8a38d MM	180	unsigned int width;
b7351143	181	const char *name;
b2c9b373 MM	182	};
b2c9b373 MM	183
b7351143	184	static const struct reg_name pci_reg_names[] = {
b2c9b373 MM	185	{ 0x00, 2, "VENDOR_ID", },
	186	{ 0x02, 2, "DEVICE_ID", },
	187	{ 0x04, 2, "COMMAND", },
	188	{ 0x06, 2, "STATUS", },
	189	{ 0x08, 1, "REVISION", },
	190	{ 0x09, 1, "CLASS_PROG", },
	191	{ 0x0a, 2, "CLASS_DEVICE", },
	192	{ 0x0c, 1, "CACHE_LINE_SIZE", },
	193	{ 0x0d, 1, "LATENCY_TIMER", },
	194	{ 0x0e, 1, "HEADER_TYPE", },
	195	{ 0x0f, 1, "BIST", },
	196	{ 0x10, 4, "BASE_ADDRESS_0", },
	197	{ 0x14, 4, "BASE_ADDRESS_1", },
	198	{ 0x18, 4, "BASE_ADDRESS_2", },
	199	{ 0x1c, 4, "BASE_ADDRESS_3", },
	200	{ 0x20, 4, "BASE_ADDRESS_4", },
	201	{ 0x24, 4, "BASE_ADDRESS_5", },
	202	{ 0x28, 4, "CARDBUS_CIS", },
	203	{ 0x2c, 4, "SUBSYSTEM_VENDOR_ID", },
	204	{ 0x2e, 2, "SUBSYSTEM_ID", },
	205	{ 0x30, 4, "ROM_ADDRESS", },
	206	{ 0x3c, 1, "INTERRUPT_LINE", },
	207	{ 0x3d, 1, "INTERRUPT_PIN", },
	208	{ 0x3e, 1, "MIN_GNT", },
	209	{ 0x3f, 1, "MAX_LAT", },
	210	{ 0x18, 1, "PRIMARY_BUS", },
	211	{ 0x19, 1, "SECONDARY_BUS", },
	212	{ 0x1a, 1, "SUBORDINATE_BUS", },
	213	{ 0x1b, 1, "SEC_LATENCY_TIMER", },
	214	{ 0x1c, 1, "IO_BASE", },
	215	{ 0x1d, 1, "IO_LIMIT", },
	216	{ 0x1e, 2, "SEC_STATUS", },
	217	{ 0x20, 2, "MEMORY_BASE", },
	218	{ 0x22, 2, "MEMORY_LIMIT", },
	219	{ 0x24, 2, "PREF_MEMORY_BASE", },
	220	{ 0x26, 2, "PREF_MEMORY_LIMIT", },
	221	{ 0x28, 4, "PREF_BASE_UPPER32", },
	222	{ 0x2c, 4, "PREF_LIMIT_UPPER32", },
	223	{ 0x30, 2, "IO_BASE_UPPER16", },
	224	{ 0x32, 2, "IO_LIMIT_UPPER16", },
	225	{ 0x38, 4, "BRIDGE_ROM_ADDRESS", },
	226	{ 0x3e, 2, "BRIDGE_CONTROL", },
	227	{ 0x10, 4, "CB_CARDBUS_BASE", },
	228	{ 0x14, 2, "CB_CAPABILITIES", },
	229	{ 0x16, 2, "CB_SEC_STATUS", },
	230	{ 0x18, 1, "CB_BUS_NUMBER", },
	231	{ 0x19, 1, "CB_CARDBUS_NUMBER", },
	232	{ 0x1a, 1, "CB_SUBORDINATE_BUS", },
	233	{ 0x1b, 1, "CB_CARDBUS_LATENCY", },
	234	{ 0x1c, 4, "CB_MEMORY_BASE_0", },
	235	{ 0x20, 4, "CB_MEMORY_LIMIT_0", },
	236	{ 0x24, 4, "CB_MEMORY_BASE_1", },
	237	{ 0x28, 4, "CB_MEMORY_LIMIT_1", },
	238	{ 0x2c, 2, "CB_IO_BASE_0", },
	239	{ 0x2e, 2, "CB_IO_BASE_0_HI", },
	240	{ 0x30, 2, "CB_IO_LIMIT_0", },
	241	{ 0x32, 2, "CB_IO_LIMIT_0_HI", },
	242	{ 0x34, 2, "CB_IO_BASE_1", },
	243	{ 0x36, 2, "CB_IO_BASE_1_HI", },
	244	{ 0x38, 2, "CB_IO_LIMIT_1", },
	245	{ 0x3a, 2, "CB_IO_LIMIT_1_HI", },
	246	{ 0x40, 2, "CB_SUBSYSTEM_VENDOR_ID", },
	247	{ 0x42, 2, "CB_SUBSYSTEM_ID", },
	248	{ 0x44, 4, "CB_LEGACY_MODE_BASE", },
249	{ 0x00, 0, NULL }
250	};
251
91e37a49	252	static void NONRET
3fe8a38d	253	usage(char *msg, ...)
e4842ff3	254	{
3fe8a38d MM	255	va_list args;
	256	va_start(args, msg);
	257	if (msg)
	258	{
	259	fprintf(stderr, "setpci: ");
	260	vfprintf(stderr, msg, args);
	261	fprintf(stderr, "\n\n");
	262	}
e4842ff3	263	fprintf(stderr,
727ce158	264	"Usage: setpci [<options>] (<device>+ <reg>[=<values>])\n\
b2c9b373 MM	265	-f\t\tDon't complain if there's nothing to do\n\
b2c9b373 MM	266	-v\t\tBe verbose\n\
727ce158 MM	267	-D\t\tList changes, don't commit them\n"
727ce158 MM	268	GENERIC_HELP
b7351143 MM	269	"<device>:\t-s [[<bus>]:][<slot>][.[<func>]]\n"
	270	"\t\|\t-d [<vendor>]:[<device>]\n"
	271	"<reg>:\t\t<number>[.(B\|W\|L)]\n"
	272	" \|\t\t<name>\n"
	273	"<values>:\t<value>[,<value>...]\n"
	274	"<value>:\t<hex>\n"
	275	" \|\t<hex>:<mask>\n");
e4842ff3 MM	276	exit(1);
	277	}
	278
	279	int
	280	main(int argc, char **argv)
	281	{
	282	enum { STATE_INIT, STATE_GOT_FILTER, STATE_GOT_OP } state = STATE_INIT;
	283	struct pci_filter filter;
727ce158 MM	284	struct pci_dev **selected_devices = NULL;
727ce158 MM	285	char *opts = GENERIC_OPTIONS ;
e4842ff3	286
7aad822b MM	287	if (argc == 2 && !strcmp(argv[1], "--version"))
	288	{
	289	puts("setpci version " PCIUTILS_VERSION);
	290	return 0;
	291	}
e4842ff3 MM	292	argc--;
e4842ff3 MM	293	argv++;
727ce158 MM	294
	295	pacc = pci_alloc();
	296	pacc->error = die;
	297
e4842ff3 MM	298	while (argc && argv[0][0] == '-')
	299	{
	300	char *c = argv[0]+1;
	301	char *d = c;
727ce158	302	char *e;
e4842ff3 MM	303	while (*c)
	304	switch (*c)
	305	{
	306	case 'v':
	307	verbose++;
	308	c++;
	309	break;
	310	case 'f':
	311	force++;
	312	c++;
	313	break;
b2c9b373 MM	314	case 'D':
	315	demo_mode++;
	316	c++;
	317	break;
e4842ff3 MM	318	case 0:
	319	break;
	320	default:
727ce158 MM	321	if (e = strchr(opts, *c))
	322	{
	323	char *arg;
	324	c++;
	325	if (e[1] == ':')
	326	{
	327	if (*c)
	328	arg = c;
	329	else if (argc > 1)
	330	{
	331	arg = argv[1];
	332	argc--; argv++;
	333	}
	334	else
3fe8a38d	335	usage(NULL);
727ce158 MM	336	c = "";
	337	}
	338	else
	339	arg = NULL;
	340	if (!parse_generic_option(*e, pacc, arg))
3fe8a38d	341	usage(NULL);
727ce158 MM	342	}
	343	else
	344	{
	345	if (c != d)
3fe8a38d	346	usage(NULL);
727ce158 MM	347	goto next;
727ce158 MM	348	}
e4842ff3 MM	349	}
	350	argc--;
	351	argv++;
	352	}
	353	next:
	354
727ce158 MM	355	pci_init(pacc);
727ce158 MM	356	pci_scan_bus(pacc);
e4842ff3 MM	357
	358	while (argc)
	359	{
	360	char *c = argv[0];
	361	char d, e, *f;
	362	int n, i;
	363	struct op *op;
b7351143 MM	364	unsigned long ll;
b7351143 MM	365	unsigned int lim;
e4842ff3 MM	366
	367	if (*c == '-')
	368	{
	369	if (!c[1] \|\| !strchr("sd", c[1]))
3fe8a38d	370	usage(NULL);
e4842ff3 MM	371	if (c[2])
e4842ff3 MM	372	d = (c[2] == '=') ? c+3 : c+2;
183251d7	373	else if (argc > 1)
e4842ff3 MM	374	{
	375	argc--;
	376	argv++;
	377	d = argv[0];
	378	}
	379	else
3fe8a38d	380	usage(NULL);
e4842ff3 MM	381	if (state != STATE_GOT_FILTER)
e4842ff3 MM	382	{
727ce158	383	pci_filter_init(pacc, &filter);
e4842ff3 MM	384	state = STATE_GOT_FILTER;
	385	}
	386	switch (c[1])
	387	{
	388	case 's':
727ce158 MM	389	if (d = pci_filter_parse_slot(&filter, d))
727ce158 MM	390	die("-s: %s", d);
e4842ff3 MM	391	break;
e4842ff3 MM	392	case 'd':
727ce158 MM	393	if (d = pci_filter_parse_id(&filter, d))
727ce158 MM	394	die("-d: %s", d);
e4842ff3 MM	395	break;
e4842ff3 MM	396	default:
3fe8a38d	397	usage(NULL);
e4842ff3 MM	398	}
	399	}
	400	else if (state == STATE_INIT)
3fe8a38d	401	usage(NULL);
e4842ff3 MM	402	else
	403	{
	404	if (state == STATE_GOT_FILTER)
	405	selected_devices = select_devices(&filter);
	406	if (!selected_devices[0] && !force)
	407	fprintf(stderr, "setpci: Warning: No devices selected for `%s'.\n", c);
	408	state = STATE_GOT_OP;
b7351143	409	/* look for setting of values and count how many */
e4842ff3 MM	410	d = strchr(c, '=');
	411	if (d)
	412	{
	413	*d++ = 0;
b2c9b373	414	if (!*d)
3fe8a38d	415	usage("Missing value");
e4842ff3 MM	416	for(e=d, n=1; *e; e++)
	417	if (*e == ',')
	418	n++;
b7351143	419	op = xmalloc(sizeof(struct op) + n*sizeof(struct value));
e4842ff3 MM	420	}
	421	else
	422	{
	423	n = -1;
	424	op = xmalloc(sizeof(struct op));
	425	}
	426	op->dev_vector = selected_devices;
	427	op->num_values = n;
	428	e = strchr(c, '.');
	429	if (e)
	430	{
	431	*e++ = 0;
	432	if (e[1])
3fe8a38d	433	usage("Missing width");
e4842ff3 MM	434	switch (*e & 0xdf)
	435	{
	436	case 'B':
	437	op->width = 1; break;
	438	case 'W':
	439	op->width = 2; break;
	440	case 'L':
	441	op->width = 4; break;
	442	default:
3fe8a38d	443	usage("Invalid width \"%s\"", *e);
e4842ff3 MM	444	}
	445	}
	446	else
	447	op->width = 1;
	448	ll = strtol(c, &f, 16);
b2c9b373 MM	449	if (f && *f)
b2c9b373 MM	450	{
b7351143	451	const struct reg_name *r;
b2c9b373 MM	452	for(r = pci_reg_names; r->name; r++)
	453	if (!strcasecmp(r->name, c))
	454	break;
3fe8a38d MM	455	if (!r->name)
	456	usage("Unknown register \"%s\"", c);
	457	if (e && op->width != r->width)
	458	usage("Explicit width doesn't correspond with the named register \"%s\"", c);
b2c9b373 MM	459	ll = r->offset;
	460	op->width = r->width;
	461	}
	462	if (ll > 0x100 \|\| ll + op->width*((n < 0) ? 1 : n) > 0x100)
727ce158	463	die("Register number out of range!");
b2c9b373	464	if (ll & (op->width - 1))
727ce158	465	die("Unaligned register address!");
b2c9b373	466	op->addr = ll;
b7351143	467	/* read in all the values to be set */
e4842ff3 MM	468	for(i=0; i<n; i++)
	469	{
	470	e = strchr(d, ',');
	471	if (e)
	472	*e++ = 0;
	473	ll = strtoul(d, &f, 16);
b7351143	474	lim = max_values[op->width];
3fe8a38d MM	475	if (f && f && f != ':')
	476	usage("Invalid value \"%s\"", d);
	477	if (ll > lim && ll < ~0UL - lim)
	478	usage("Value \"%s\" is out of range", d);
	479	op->values[i].value = ll;
b7351143 MM	480	if (f && *f == ':')
b7351143 MM	481	{
b7351143 MM	482	d = ++f;
b7351143 MM	483	ll = strtoul(d, &f, 16);
3fe8a38d MM	484	if (f && *f)
	485	usage("Invalid mask \"%s\"", d);
	486	if (ll > lim && ll < ~0UL - lim)
	487	usage("Mask \"%s\" is out of range", d);
b7351143	488	op->values[i].mask = ll;
3fe8a38d	489	op->values[i].value &= ll;
b7351143 MM	490	}
b7351143 MM	491	else
3fe8a38d	492	op->values[i].mask = ~0U;
e4842ff3 MM	493	d = e;
	494	}
	495	*last_op = op;
	496	last_op = &op->next;
	497	op->next = NULL;
	498	}
	499	argc--;
	500	argv++;
	501	}
	502	if (state == STATE_INIT)
3fe8a38d	503	usage("No operation specified");
e4842ff3	504
b2c9b373	505	scan_ops(first_op);
e4842ff3 MM	506	execute(first_op);
	507
	508	return 0;
	509	}