/*

 * (C) Copyright IBM Corporation 2006

 * All Rights Reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * on the rights to use, copy, modify, merge, publish, distribute, sub

 * license, and/or sell copies of the Software, and to permit persons to whom

 * the Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

 * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <inttypes.h>

#ifdef HAVE_ERR_H

#include <err.h>

#else

# include <errno.h>

# include <string.h>

# define err(exitcode, format, args...) \

   errx(exitcode, format ": %s", ## args, strerror(errno))

# define errx(exitcode, format, args...) \

   { warnx(format, ## args); exit(exitcode); }

# define warn(format, args...) \

   warnx(format ": %s", ## args, strerror(errno))

# define warnx(format, args...) \

   fprintf(stderr, format "\n", ## args)

#endif

#include "pciaccess.h"

#include "pciaccess_private.h"

static void

print_pci_bridge( const struct pci_bridge_info * info )

{

    printf( "  Bus: primary=%02"PRIx8", secondary=%02"PRIx8", subordinate=%02"PRIx8", "

	    "sec-latency=%"PRIu8"\n",

	    info->primary_bus,

	    info->secondary_bus,

	    info->subordinate_bus,

	    info->secondary_latency_timer );

    printf( "  I/O behind bridge: %08"PRIx32"-%08"PRIx32"\n",

	    info->io_base,

	    info->io_limit );

    printf( "  Memory behind bridge: %08"PRIx32"-%08"PRIx32"\n",

	    info->mem_base,

	    info->mem_limit );

    printf( "  Prefetchable memory behind bridge: %08"PRIx64"-%08"PRIx64"\n",

	    info->prefetch_mem_base,

	    info->prefetch_mem_limit );

}

static void

print_pci_device( struct pci_device * dev, int verbose )

{

    const char * dev_name;

    const char * vend_name;

    vend_name = pci_device_get_vendor_name( dev );

    dev_name = pci_device_get_device_name( dev );

    if ( dev_name == NULL ) {

	dev_name = "Device unknown";

    }

    printf("\npci ");

    if (dev->domain != 0)

	printf("domain 0x%04x ", dev->domain);

    printf("bus 0x%04x cardnum 0x%02x function 0x%02x:"

	   " vendor 0x%04x device 0x%04x\n",

	   dev->bus,

	   dev->dev,

	   dev->func,

	   dev->vendor_id,

	   dev->device_id );

    if ( vend_name != NULL ) {

	printf( " %s %s\n", vend_name, dev_name );

    }

    else {

	printf( " %s\n", dev_name );

    }

    if ( verbose ) {

	unsigned   i;

	uint16_t  command, status;

	uint8_t   bist;

	uint8_t   header_type;

	uint8_t   latency_timer;

	uint8_t   cache_line_size;

	uint8_t   max_latency;

	uint8_t   min_grant;

	uint8_t   int_pin;

	vend_name = pci_device_get_subvendor_name( dev );

	dev_name = pci_device_get_subdevice_name( dev );

	if ( dev_name == NULL ) {

	    dev_name = "Card unknown";

	}

	printf( " CardVendor 0x%04x card 0x%04x (",

		dev->subvendor_id,

		dev->subdevice_id );

	if ( vend_name != NULL ) {

	    printf( "%s, %s)\n", vend_name, dev_name );

	}

	else {

	    printf( "%s)\n", dev_name );

	}

	pci_device_cfg_read_u16( dev, & command, 4 );

	pci_device_cfg_read_u16( dev, & status,  6 );

	printf( "  STATUS    0x%04x  COMMAND 0x%04x\n",

		status,

		command );

	printf( "  CLASS     0x%02x 0x%02x 0x%02x  REVISION 0x%02x\n",

		(dev->device_class >> 16) & 0x0ff,

		(dev->device_class >>  8) & 0x0ff,

		(dev->device_class >>  0) & 0x0ff,

		dev->revision );

	pci_device_cfg_read_u8( dev, & cache_line_size, 12 );

	pci_device_cfg_read_u8( dev, & latency_timer, 13 );

	pci_device_cfg_read_u8( dev, & header_type, 14 );

	pci_device_cfg_read_u8( dev, & bist, 15 );

	printf( "  BIST      0x%02x  HEADER 0x%02x  LATENCY 0x%02x  CACHE 0x%02x\n",

		bist,

		header_type,

		latency_timer,

		cache_line_size );

	pci_device_probe( dev );

	for ( i = 0 ; i < 6 ; i++ ) {

	    if ( dev->regions[i].base_addr != 0 ) {

		printf( "  BASE%u     0x%0*"PRIxPTR" SIZE %zu  %s",

			i,

			dev->regions[i].is_64 ? 16 : 8,

			(intptr_t) dev->regions[i].base_addr,

			(size_t) dev->regions[i].size,

			(dev->regions[i].is_IO) ? "I/O" :

			((dev->regions[i].is_64) ? "MEM64" : "MEM"));

		if ( ! dev->regions[i].is_IO ) {

		    if ( dev->regions[i].is_prefetchable ) {

			printf( " PREFETCHABLE" );

		    }

		}

		printf( "\n" );

	    }

	}

	if ( dev->rom_size ) {

	    struct pci_device_private *priv =

		(struct pci_device_private *) dev;

		printf( "  BASEROM   0x%08"PRIxPTR" SIZE %zu\n",

			(intptr_t) priv->rom_base, (size_t) dev->rom_size);

	}

	pci_device_cfg_read_u8( dev, & int_pin, 61 );

	pci_device_cfg_read_u8( dev, & min_grant, 62 );

	pci_device_cfg_read_u8( dev, & max_latency, 63 );

	printf( "  MAX_LAT   0x%02x  MIN_GNT 0x%02x  INT_PIN 0x%02x  INT_LINE 0x%02x\n",

		max_latency,

		min_grant,

		int_pin,

		dev->irq );

	if ( (dev->device_class >> 16) == 0x06 ) {

	    const void * info;

	    if ( (info = pci_device_get_bridge_info(dev)) != NULL ) {

		print_pci_bridge( (const struct pci_bridge_info *) info );

	    }

	    else if ( (info = pci_device_get_pcmcia_bridge_info(dev)) != NULL ) {

		/* Nothing yet. */

	    }

	}

    }

}

int main( int argc, char ** argv )

{

    struct pci_device_iterator * iter;

    struct pci_device * dev;

    int ret;

    int verbose = 0;

    int c;

    int errors = 0;

    while ((c = getopt(argc, argv, "v")) != -1) {

	switch (c) {

	case 'v':

	    verbose = 1;

	    break;

	case '?':

	    errors++;

	}

    }

    if (errors != 0) {

	fprintf(stderr, "usage: %s [-v]\n", argv[0]);

	exit(2);

    }

    ret = pci_system_init();

    if (ret != 0)

	err(1, "Couldn't initialize PCI system");

    iter = pci_slot_match_iterator_create( NULL );

    while ( (dev = pci_device_next( iter )) != NULL ) {

	print_pci_device( dev, verbose );

    }

    pci_system_cleanup();

    return 0;

}