mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-06 02:26:38 +07:00
6473d160b4
I noticed that many source files include <linux/pci.h> while they do not appear to need it. Here is an attempt to clean it all up. In order to find all possibly affected files, I searched for all files including <linux/pci.h> but without any other occurence of "pci" or "PCI". I removed the include statement from all of these, then I compiled an allmodconfig kernel on both i386 and x86_64 and fixed the false positives manually. My tests covered 66% of the affected files, so there could be false positives remaining. Untested files are: arch/alpha/kernel/err_common.c arch/alpha/kernel/err_ev6.c arch/alpha/kernel/err_ev7.c arch/ia64/sn/kernel/huberror.c arch/ia64/sn/kernel/xpnet.c arch/m68knommu/kernel/dma.c arch/mips/lib/iomap.c arch/powerpc/platforms/pseries/ras.c arch/ppc/8260_io/enet.c arch/ppc/8260_io/fcc_enet.c arch/ppc/8xx_io/enet.c arch/ppc/syslib/ppc4xx_sgdma.c arch/sh64/mach-cayman/iomap.c arch/xtensa/kernel/xtensa_ksyms.c arch/xtensa/platform-iss/setup.c drivers/i2c/busses/i2c-at91.c drivers/i2c/busses/i2c-mpc.c drivers/media/video/saa711x.c drivers/misc/hdpuftrs/hdpu_cpustate.c drivers/misc/hdpuftrs/hdpu_nexus.c drivers/net/au1000_eth.c drivers/net/fec_8xx/fec_main.c drivers/net/fec_8xx/fec_mii.c drivers/net/fs_enet/fs_enet-main.c drivers/net/fs_enet/mac-fcc.c drivers/net/fs_enet/mac-fec.c drivers/net/fs_enet/mac-scc.c drivers/net/fs_enet/mii-bitbang.c drivers/net/fs_enet/mii-fec.c drivers/net/ibm_emac/ibm_emac_core.c drivers/net/lasi_82596.c drivers/parisc/hppb.c drivers/sbus/sbus.c drivers/video/g364fb.c drivers/video/platinumfb.c drivers/video/stifb.c drivers/video/valkyriefb.c include/asm-arm/arch-ixp4xx/dma.h sound/oss/au1550_ac97.c I would welcome test reports for these files. I am fine with removing the untested files from the patch if the general opinion is that these changes aren't safe. The tested part would still be nice to have. Note that this patch depends on another header fixup patch I submitted to LKML yesterday: [PATCH] scatterlist.h needs types.h http://lkml.org/lkml/2007/3/01/141 Signed-off-by: Jean Delvare <khali@linux-fr.org> Cc: Badari Pulavarty <pbadari@us.ibm.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
407 lines
9.7 KiB
C
407 lines
9.7 KiB
C
/*
|
|
* socket_sysfs.c -- most of socket-related sysfs output
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* (C) 2003 - 2004 Dominik Brodowski
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/major.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/pm.h>
|
|
#include <linux/device.h>
|
|
#include <linux/mutex.h>
|
|
#include <asm/system.h>
|
|
#include <asm/irq.h>
|
|
|
|
#define IN_CARD_SERVICES
|
|
#include <pcmcia/cs_types.h>
|
|
#include <pcmcia/ss.h>
|
|
#include <pcmcia/cs.h>
|
|
#include <pcmcia/bulkmem.h>
|
|
#include <pcmcia/cistpl.h>
|
|
#include <pcmcia/cisreg.h>
|
|
#include <pcmcia/ds.h>
|
|
#include "cs_internal.h"
|
|
|
|
#define to_socket(_dev) container_of(_dev, struct pcmcia_socket, dev)
|
|
|
|
static ssize_t pccard_show_type(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
|
|
if (!(s->state & SOCKET_PRESENT))
|
|
return -ENODEV;
|
|
if (s->state & SOCKET_CARDBUS)
|
|
return sprintf(buf, "32-bit\n");
|
|
return sprintf(buf, "16-bit\n");
|
|
}
|
|
static DEVICE_ATTR(card_type, 0444, pccard_show_type, NULL);
|
|
|
|
static ssize_t pccard_show_voltage(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
|
|
if (!(s->state & SOCKET_PRESENT))
|
|
return -ENODEV;
|
|
if (s->socket.Vcc)
|
|
return sprintf(buf, "%d.%dV\n", s->socket.Vcc / 10,
|
|
s->socket.Vcc % 10);
|
|
return sprintf(buf, "X.XV\n");
|
|
}
|
|
static DEVICE_ATTR(card_voltage, 0444, pccard_show_voltage, NULL);
|
|
|
|
static ssize_t pccard_show_vpp(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
if (!(s->state & SOCKET_PRESENT))
|
|
return -ENODEV;
|
|
return sprintf(buf, "%d.%dV\n", s->socket.Vpp / 10, s->socket.Vpp % 10);
|
|
}
|
|
static DEVICE_ATTR(card_vpp, 0444, pccard_show_vpp, NULL);
|
|
|
|
static ssize_t pccard_show_vcc(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
if (!(s->state & SOCKET_PRESENT))
|
|
return -ENODEV;
|
|
return sprintf(buf, "%d.%dV\n", s->socket.Vcc / 10, s->socket.Vcc % 10);
|
|
}
|
|
static DEVICE_ATTR(card_vcc, 0444, pccard_show_vcc, NULL);
|
|
|
|
|
|
static ssize_t pccard_store_insert(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
ssize_t ret;
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
|
|
if (!count)
|
|
return -EINVAL;
|
|
|
|
ret = pcmcia_insert_card(s);
|
|
|
|
return ret ? ret : count;
|
|
}
|
|
static DEVICE_ATTR(card_insert, 0200, NULL, pccard_store_insert);
|
|
|
|
|
|
static ssize_t pccard_show_card_pm_state(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
return sprintf(buf, "%s\n", s->state & SOCKET_SUSPEND ? "off" : "on");
|
|
}
|
|
|
|
static ssize_t pccard_store_card_pm_state(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
ssize_t ret = -EINVAL;
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
|
|
if (!count)
|
|
return -EINVAL;
|
|
|
|
if (!(s->state & SOCKET_SUSPEND) && !strncmp(buf, "off", 3))
|
|
ret = pcmcia_suspend_card(s);
|
|
else if ((s->state & SOCKET_SUSPEND) && !strncmp(buf, "on", 2))
|
|
ret = pcmcia_resume_card(s);
|
|
|
|
return ret ? -ENODEV : count;
|
|
}
|
|
static DEVICE_ATTR(card_pm_state, 0644, pccard_show_card_pm_state, pccard_store_card_pm_state);
|
|
|
|
static ssize_t pccard_store_eject(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
ssize_t ret;
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
|
|
if (!count)
|
|
return -EINVAL;
|
|
|
|
ret = pcmcia_eject_card(s);
|
|
|
|
return ret ? ret : count;
|
|
}
|
|
static DEVICE_ATTR(card_eject, 0200, NULL, pccard_store_eject);
|
|
|
|
|
|
static ssize_t pccard_show_irq_mask(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
return sprintf(buf, "0x%04x\n", s->irq_mask);
|
|
}
|
|
|
|
static ssize_t pccard_store_irq_mask(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
ssize_t ret;
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
u32 mask;
|
|
|
|
if (!count)
|
|
return -EINVAL;
|
|
|
|
ret = sscanf (buf, "0x%x\n", &mask);
|
|
|
|
if (ret == 1) {
|
|
s->irq_mask &= mask;
|
|
ret = 0;
|
|
}
|
|
|
|
return ret ? ret : count;
|
|
}
|
|
static DEVICE_ATTR(card_irq_mask, 0600, pccard_show_irq_mask, pccard_store_irq_mask);
|
|
|
|
|
|
static ssize_t pccard_show_resource(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
return sprintf(buf, "%s\n", s->resource_setup_done ? "yes" : "no");
|
|
}
|
|
|
|
static ssize_t pccard_store_resource(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
unsigned long flags;
|
|
struct pcmcia_socket *s = to_socket(dev);
|
|
|
|
if (!count)
|
|
return -EINVAL;
|
|
|
|
spin_lock_irqsave(&s->lock, flags);
|
|
if (!s->resource_setup_done)
|
|
s->resource_setup_done = 1;
|
|
spin_unlock_irqrestore(&s->lock, flags);
|
|
|
|
mutex_lock(&s->skt_mutex);
|
|
if ((s->callback) &&
|
|
(s->state & SOCKET_PRESENT) &&
|
|
!(s->state & SOCKET_CARDBUS)) {
|
|
if (try_module_get(s->callback->owner)) {
|
|
s->callback->requery(s, 0);
|
|
module_put(s->callback->owner);
|
|
}
|
|
}
|
|
mutex_unlock(&s->skt_mutex);
|
|
|
|
return count;
|
|
}
|
|
static DEVICE_ATTR(available_resources_setup_done, 0600, pccard_show_resource, pccard_store_resource);
|
|
|
|
|
|
static ssize_t pccard_extract_cis(struct pcmcia_socket *s, char *buf, loff_t off, size_t count)
|
|
{
|
|
tuple_t tuple;
|
|
int status, i;
|
|
loff_t pointer = 0;
|
|
ssize_t ret = 0;
|
|
u_char *tuplebuffer;
|
|
u_char *tempbuffer;
|
|
|
|
tuplebuffer = kmalloc(sizeof(u_char) * 256, GFP_KERNEL);
|
|
if (!tuplebuffer)
|
|
return -ENOMEM;
|
|
|
|
tempbuffer = kmalloc(sizeof(u_char) * 258, GFP_KERNEL);
|
|
if (!tempbuffer) {
|
|
ret = -ENOMEM;
|
|
goto free_tuple;
|
|
}
|
|
|
|
memset(&tuple, 0, sizeof(tuple_t));
|
|
|
|
tuple.Attributes = TUPLE_RETURN_LINK | TUPLE_RETURN_COMMON;
|
|
tuple.DesiredTuple = RETURN_FIRST_TUPLE;
|
|
tuple.TupleOffset = 0;
|
|
|
|
status = pccard_get_first_tuple(s, BIND_FN_ALL, &tuple);
|
|
while (!status) {
|
|
tuple.TupleData = tuplebuffer;
|
|
tuple.TupleDataMax = 255;
|
|
memset(tuplebuffer, 0, sizeof(u_char) * 255);
|
|
|
|
status = pccard_get_tuple_data(s, &tuple);
|
|
if (status)
|
|
break;
|
|
|
|
if (off < (pointer + 2 + tuple.TupleDataLen)) {
|
|
tempbuffer[0] = tuple.TupleCode & 0xff;
|
|
tempbuffer[1] = tuple.TupleLink & 0xff;
|
|
for (i = 0; i < tuple.TupleDataLen; i++)
|
|
tempbuffer[i + 2] = tuplebuffer[i] & 0xff;
|
|
|
|
for (i = 0; i < (2 + tuple.TupleDataLen); i++) {
|
|
if (((i + pointer) >= off) &&
|
|
(i + pointer) < (off + count)) {
|
|
buf[ret] = tempbuffer[i];
|
|
ret++;
|
|
}
|
|
}
|
|
}
|
|
|
|
pointer += 2 + tuple.TupleDataLen;
|
|
|
|
if (pointer >= (off + count))
|
|
break;
|
|
|
|
if (tuple.TupleCode == CISTPL_END)
|
|
break;
|
|
status = pccard_get_next_tuple(s, BIND_FN_ALL, &tuple);
|
|
}
|
|
|
|
kfree(tempbuffer);
|
|
free_tuple:
|
|
kfree(tuplebuffer);
|
|
|
|
return (ret);
|
|
}
|
|
|
|
static ssize_t pccard_show_cis(struct kobject *kobj, char *buf, loff_t off, size_t count)
|
|
{
|
|
unsigned int size = 0x200;
|
|
|
|
if (off >= size)
|
|
count = 0;
|
|
else {
|
|
struct pcmcia_socket *s;
|
|
cisinfo_t cisinfo;
|
|
|
|
if (off + count > size)
|
|
count = size - off;
|
|
|
|
s = to_socket(container_of(kobj, struct device, kobj));
|
|
|
|
if (!(s->state & SOCKET_PRESENT))
|
|
return -ENODEV;
|
|
if (pccard_validate_cis(s, BIND_FN_ALL, &cisinfo))
|
|
return -EIO;
|
|
if (!cisinfo.Chains)
|
|
return -ENODATA;
|
|
|
|
count = pccard_extract_cis(s, buf, off, count);
|
|
}
|
|
|
|
return (count);
|
|
}
|
|
|
|
static ssize_t pccard_store_cis(struct kobject *kobj, char *buf, loff_t off, size_t count)
|
|
{
|
|
struct pcmcia_socket *s = to_socket(container_of(kobj, struct device, kobj));
|
|
cisdump_t *cis;
|
|
int error;
|
|
|
|
if (off)
|
|
return -EINVAL;
|
|
|
|
if (count >= 0x200)
|
|
return -EINVAL;
|
|
|
|
if (!(s->state & SOCKET_PRESENT))
|
|
return -ENODEV;
|
|
|
|
cis = kzalloc(sizeof(cisdump_t), GFP_KERNEL);
|
|
if (!cis)
|
|
return -ENOMEM;
|
|
|
|
cis->Length = count + 1;
|
|
memcpy(cis->Data, buf, count);
|
|
|
|
error = pcmcia_replace_cis(s, cis);
|
|
kfree(cis);
|
|
if (error)
|
|
return -EIO;
|
|
|
|
mutex_lock(&s->skt_mutex);
|
|
if ((s->callback) && (s->state & SOCKET_PRESENT) &&
|
|
!(s->state & SOCKET_CARDBUS)) {
|
|
if (try_module_get(s->callback->owner)) {
|
|
s->callback->requery(s, 1);
|
|
module_put(s->callback->owner);
|
|
}
|
|
}
|
|
mutex_unlock(&s->skt_mutex);
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
static struct device_attribute *pccard_socket_attributes[] = {
|
|
&dev_attr_card_type,
|
|
&dev_attr_card_voltage,
|
|
&dev_attr_card_vpp,
|
|
&dev_attr_card_vcc,
|
|
&dev_attr_card_insert,
|
|
&dev_attr_card_pm_state,
|
|
&dev_attr_card_eject,
|
|
&dev_attr_card_irq_mask,
|
|
&dev_attr_available_resources_setup_done,
|
|
NULL,
|
|
};
|
|
|
|
static struct bin_attribute pccard_cis_attr = {
|
|
.attr = { .name = "cis", .mode = S_IRUGO | S_IWUSR, .owner = THIS_MODULE},
|
|
.size = 0x200,
|
|
.read = pccard_show_cis,
|
|
.write = pccard_store_cis,
|
|
};
|
|
|
|
static int __devinit pccard_sysfs_add_socket(struct device *dev,
|
|
struct class_interface *class_intf)
|
|
{
|
|
struct device_attribute **attr;
|
|
int ret = 0;
|
|
|
|
for (attr = pccard_socket_attributes; *attr; attr++) {
|
|
ret = device_create_file(dev, *attr);
|
|
if (ret)
|
|
break;
|
|
}
|
|
if (!ret)
|
|
ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void __devexit pccard_sysfs_remove_socket(struct device *dev,
|
|
struct class_interface *class_intf)
|
|
{
|
|
struct device_attribute **attr;
|
|
|
|
sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr);
|
|
for (attr = pccard_socket_attributes; *attr; attr++)
|
|
device_remove_file(dev, *attr);
|
|
}
|
|
|
|
struct class_interface pccard_sysfs_interface = {
|
|
.class = &pcmcia_socket_class,
|
|
.add_dev = &pccard_sysfs_add_socket,
|
|
.remove_dev = __devexit_p(&pccard_sysfs_remove_socket),
|
|
};
|