Subversion Repositories shark

Compare Revisions

Regard whitespace Rev 437 → Rev 436

/shark/trunk/drivers/newpci/common.c
139,6 → 139,7
 
static int __init pcibios_init(void)
{
struct cpuinfo_x86 *c = &boot_cpu_data;
 
if (!raw_pci_ops) {
printk("PCI: System does not support PCI\n");
151,6 → 152,10
* as quite a few PCI devices do not support smaller values.
*/
pci_cache_line_size = 32 >> 2;
if (c->x86 >= 6 && c->x86_vendor == X86_VENDOR_AMD)
pci_cache_line_size = 64 >> 2; /* K7 & K8 */
else if (c->x86 > 6 && c->x86_vendor == X86_VENDOR_INTEL)
pci_cache_line_size = 128 >> 2; /* P4 */
 
pcibios_resource_survey();
 
/shark/trunk/drivers/newpci/i386.c
286,6 → 286,7
vma->vm_flags |= (VM_SHM | VM_LOCKED | VM_IO);
 
prot = pgprot_val(vma->vm_page_prot);
if (boot_cpu_data.x86 > 3)
prot |= _PAGE_PCD | _PAGE_PWT;
vma->vm_page_prot = __pgprot(prot);
 
/shark/trunk/drivers/newpci/makefile
10,7 → 10,7
 
OBJS_PATH = $(BASE)/drivers/newpci
 
OBJS = access.o bus.o names.o pci.o pci-driver.o\
OBJS = access.o bus.o names.o pci.o pci-driver.o pci-sysfs.o\
pool.o probe.o quirks.o remove.o search.o setup-res.o\
setup-irq.o setup-bus.o syscall.o i386.o common.o\
fixup.o irq.o legacy.o
/shark/trunk/drivers/newpci/bus.c
101,6 → 101,7
spin_unlock(&pci_bus_lock);
 
pci_proc_attach_device(dev);
pci_create_sysfs_dev_files(dev);
 
}
 
/shark/trunk/drivers/newpci/pci-sysfs.c
0,0 → 1,182
/*
* drivers/pci/pci-sysfs.c
*
* (C) Copyright 2002 Greg Kroah-Hartman
* (C) Copyright 2002 IBM Corp.
* (C) Copyright 2003 Matthew Wilcox
* (C) Copyright 2003 Hewlett-Packard
*
* File attributes for PCI devices
*
* Modeled after usb's driverfs.c
*
*/
 
 
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/stat.h>
 
#include "pci.h"
 
/* show configuration fields */
#define pci_config_attr(field, format_string) \
static ssize_t \
show_##field (struct device *dev, char *buf) \
{ \
struct pci_dev *pdev; \
\
pdev = to_pci_dev (dev); \
return sprintf (buf, format_string, pdev->field); \
} \
static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 
pci_config_attr(vendor, "0x%04x\n");
pci_config_attr(device, "0x%04x\n");
pci_config_attr(subsystem_vendor, "0x%04x\n");
pci_config_attr(subsystem_device, "0x%04x\n");
pci_config_attr(class, "0x%06x\n");
pci_config_attr(irq, "%u\n");
 
/* show resources */
static ssize_t
pci_show_resources(struct device * dev, char * buf)
{
struct pci_dev * pci_dev = to_pci_dev(dev);
char * str = buf;
int i;
int max = 7;
 
if (pci_dev->subordinate)
max = DEVICE_COUNT_RESOURCE;
 
for (i = 0; i < max; i++) {
str += sprintf(str,"0x%016lx 0x%016lx 0x%016lx\n",
pci_resource_start(pci_dev,i),
pci_resource_end(pci_dev,i),
pci_resource_flags(pci_dev,i));
}
return (str - buf);
}
 
static DEVICE_ATTR(resource,S_IRUGO,pci_show_resources,NULL);
 
static ssize_t
pci_read_config(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
unsigned int size = 64;
loff_t init_off = off;
 
/* Several chips lock up trying to read undefined config space */
if (capable(CAP_SYS_ADMIN)) {
size = 256;
} else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
size = 128;
}
 
if (off > size)
return 0;
if (off + count > size) {
size -= off;
count = size;
} else {
size = count;
}
 
while (off & 3) {
unsigned char val;
pci_read_config_byte(dev, off, &val);
buf[off - init_off] = val;
off++;
if (--size == 0)
break;
}
 
while (size > 3) {
unsigned int val;
pci_read_config_dword(dev, off, &val);
buf[off - init_off] = val & 0xff;
buf[off - init_off + 1] = (val >> 8) & 0xff;
buf[off - init_off + 2] = (val >> 16) & 0xff;
buf[off - init_off + 3] = (val >> 24) & 0xff;
off += 4;
size -= 4;
}
 
while (size > 0) {
unsigned char val;
pci_read_config_byte(dev, off, &val);
buf[off - init_off] = val;
off++;
--size;
}
 
return count;
}
 
static ssize_t
pci_write_config(struct kobject *kobj, char *buf, loff_t off, size_t count)
{
struct pci_dev *dev = to_pci_dev(container_of(kobj,struct device,kobj));
unsigned int size = count;
loff_t init_off = off;
 
if (off > 256)
return 0;
if (off + count > 256) {
size = 256 - off;
count = size;
}
 
while (off & 3) {
pci_write_config_byte(dev, off, buf[off - init_off]);
off++;
if (--size == 0)
break;
}
 
while (size > 3) {
unsigned int val = buf[off - init_off];
val |= (unsigned int) buf[off - init_off + 1] << 8;
val |= (unsigned int) buf[off - init_off + 2] << 16;
val |= (unsigned int) buf[off - init_off + 3] << 24;
pci_write_config_dword(dev, off, val);
off += 4;
size -= 4;
}
 
while (size > 0) {
pci_write_config_byte(dev, off, buf[off - init_off]);
off++;
--size;
}
 
return count;
}
 
static struct bin_attribute pci_config_attr = {
.attr = {
.name = "config",
.mode = S_IRUGO | S_IWUSR,
},
.size = 256,
.read = pci_read_config,
.write = pci_write_config,
};
 
void pci_create_sysfs_dev_files (struct pci_dev *pdev)
{
struct device *dev = &pdev->dev;
 
/* current configuration's attributes */
device_create_file (dev, &dev_attr_vendor);
device_create_file (dev, &dev_attr_device);
device_create_file (dev, &dev_attr_subsystem_vendor);
device_create_file (dev, &dev_attr_subsystem_device);
device_create_file (dev, &dev_attr_class);
device_create_file (dev, &dev_attr_irq);
device_create_file (dev, &dev_attr_resource);
sysfs_create_bin_file(&dev->kobj, &pci_config_attr);
}