Skip to content

L
linux
Commit 3935761c authored by Linus Torvalds's avatar Linus Torvalds
Browse files
Options

Merge bk://kernel.bkbits.net/gregkh/linux/pci-2.5 

into home.transmeta.com:/home/torvalds/v2.5/linux
parents 65458f96 c1cdc0d2
Show whitespace changes
Inline Side-by-side
Showing with 1501 additions and 970 deletions
Makefile
View file @ 3935761c
......@@ -204,7 +204,7 @@ GENKSYMS = scripts/genksyms/genksyms
DEPMOD = /sbin/depmod
KALLSYMS = scripts/kallsyms
PERL = perl
CHECK = /home/torvalds/parser/check
CHECK = sparse
MODFLAGS = -DMODULE
CFLAGS_MODULE = $(MODFLAGS)
AFLAGS_MODULE = $(MODFLAGS)
......
arch/arm/kernel/pm.c
View file @ 3935761c
......@@ -11,7 +11,6 @@
#include <linux/config.h>
#include <linux/pm.h>
#include <linux/device.h>
#include <linux/cpufreq.h>
#include <asm/leds.h>
#include <asm/system.h>
......@@ -66,13 +65,6 @@ int suspend(void)
*/
device_resume(RESUME_POWER_ON);
/*
* Restore the CPU frequency settings.
*/
#ifdef CONFIG_CPU_FREQ
cpufreq_restore();
#endif
/*
* Resume LDM devices.
*/
......
arch/i386/kernel/apic.c
View file @ 3935761c
......@@ -25,6 +25,9 @@
#include <linux/interrupt.h>
#include <linux/mc146818rtc.h>
#include <linux/kernel_stat.h>
#include <linux/sysdev.h>
#include <linux/module.h>
#include <asm/atomic.h>
#include <asm/smp.h>
......@@ -460,9 +463,6 @@ void __init setup_local_APIC (void)
#ifdef CONFIG_PM
#include <linux/device.h>
#include <linux/module.h>
static struct {
/* 'active' is true if the local APIC was enabled by us and
not the BIOS; this signifies that we are also responsible
......@@ -484,13 +484,11 @@ static struct {
unsigned int apic_thmr;
} apic_pm_state;
static int lapic_suspend(struct device *dev, u32 state, u32 level)
static int lapic_suspend(struct sys_device *dev, u32 state)
{
unsigned int l, h;
unsigned long flags;
if (level != SUSPEND_POWER_DOWN)
return 0;
if (!apic_pm_state.active)
return 0;
......@@ -517,13 +515,11 @@ static int lapic_suspend(struct device *dev, u32 state, u32 level)
return 0;
}
static int lapic_resume(struct device *dev, u32 level)
static int lapic_resume(struct sys_device *dev)
{
unsigned int l, h;
unsigned long flags;
if (level != RESUME_POWER_ON)
return 0;
if (!apic_pm_state.active)
return 0;
......@@ -557,38 +553,37 @@ static int lapic_resume(struct device *dev, u32 level)
return 0;
}
static struct device_driver lapic_driver = {
.name = "lapic",
.bus = &system_bus_type,
static struct sysdev_class lapic_sysclass = {
set_kset_name("lapic"),
.resume = lapic_resume,
.suspend = lapic_suspend,
};
/* not static, needed by child devices */
struct sys_device device_lapic = {
.name = "lapic",
static struct sys_device device_lapic = {
.id = 0,
.dev = {
.name = "lapic",
.driver = &lapic_driver,
},
.cls = &lapic_sysclass,
};
EXPORT_SYMBOL(device_lapic);
static void __init apic_pm_activate(void)
{
apic_pm_state.active = 1;
}
static int __init init_lapic_devicefs(void)
static int __init init_lapic_sysfs(void)
{
int error;
if (!cpu_has_apic)
return 0;
/* XXX: remove suspend/resume procs if !apic_pm_state.active? */
driver_register(&lapic_driver);
return sys_device_register(&device_lapic);
error = sysdev_class_register(&lapic_sysclass);
if (!error)
error = sys_device_register(&device_lapic);
return error;
}
device_initcall(init_lapic_devicefs);
device_initcall(init_lapic_sysfs);
#else /* CONFIG_PM */
......
arch/i386/kernel/cpu/mtrr/main.c
View file @ 3935761c
......@@ -35,6 +35,7 @@
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/smp.h>
#include <linux/cpu.h>
#include <asm/mtrr.h>
......@@ -546,6 +547,58 @@ static void init_other_cpus(void)
}
}
struct mtrr_value {
mtrr_type ltype;
unsigned long lbase;
unsigned int lsize;
};
static struct mtrr_value * mtrr_state;
static int mtrr_save(struct sys_device * sysdev, u32 state)
{
int i;
int size = num_var_ranges * sizeof(struct mtrr_value);
mtrr_state = kmalloc(size,GFP_KERNEL);
if (mtrr_state)
memset(mtrr_state,0,size);
else
return -ENOMEM;
for (i = 0; i < num_var_ranges; i++) {
mtrr_if->get(i,
&mtrr_state[i].lbase,
&mtrr_state[i].lsize,
&mtrr_state[i].ltype);
}
return 0;
}
static int mtrr_restore(struct sys_device * sysdev)
{
int i;
for (i = 0; i < num_var_ranges; i++) {
if (mtrr_state[i].lsize)
set_mtrr(i,
mtrr_state[i].lbase,
mtrr_state[i].lsize,
mtrr_state[i].ltype);
}
kfree(mtrr_state);
return 0;
}
static struct sysdev_driver mtrr_sysdev_driver = {
.save = mtrr_save,
.restore = mtrr_restore,
};
/**
* mtrr_init - initialie mtrrs on the boot CPU
*
......@@ -630,8 +683,11 @@ static int __init mtrr_init(void)
set_num_var_ranges();
init_table();
init_other_cpus();
return sysdev_driver_register(&cpu_sysdev_class,
&mtrr_sysdev_driver);
}
return mtrr_if ? -ENXIO : 0;
return -ENXIO;
}
char *mtrr_strings[MTRR_NUM_TYPES] =
......@@ -645,5 +701,5 @@ char *mtrr_strings[MTRR_NUM_TYPES] =
"write-back", /* 6 */
};
core_initcall(mtrr_init);
subsys_initcall(mtrr_init);
arch/i386/kernel/i8259.c
View file @ 3935761c
......@@ -10,7 +10,7 @@
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <linux/kernel_stat.h>
#include <linux/device.h>
#include <linux/sysdev.h>
#include <asm/atomic.h>
#include <asm/system.h>
......@@ -238,35 +238,31 @@ void mask_and_ack_8259A(unsigned int irq)
}
}
static int i8259A_resume(struct device *dev, u32 level)
static int i8259A_resume(struct sys_device *dev)
{
if (level == RESUME_POWER_ON)
init_8259A(0);
return 0;
}
static struct device_driver i8259A_driver = {
.name = "pic",
.bus = &system_bus_type,
static struct sysdev_class i8259_sysdev_class = {
set_kset_name("i8259"),
.resume = i8259A_resume,
};
static struct sys_device device_i8259A = {
.name = "pic",
.id = 0,
.dev = {
.name = "i8259A PIC",
.driver = &i8259A_driver,
},
.cls = &i8259_sysdev_class,
};
static int __init init_8259A_devicefs(void)
static int __init i8259A_init_sysfs(void)
{
driver_register(&i8259A_driver);
return sys_device_register(&device_i8259A);
int error = sysdev_class_register(&i8259_sysdev_class);
if (!error)
error = sys_device_register(&device_i8259A);
return error;
}
device_initcall(init_8259A_devicefs);
device_initcall(i8259A_init_sysfs);
void init_8259A(int auto_eoi)
{
......@@ -385,35 +381,31 @@ static void setup_timer(void)
spin_unlock_irqrestore(&i8253_lock, flags);
}
static int timer_resume(struct device *dev, u32 level)
static int timer_resume(struct sys_device *dev)
{
if (level == RESUME_POWER_ON)
setup_timer();
return 0;
}
static struct device_driver timer_driver = {
.name = "timer",
.bus = &system_bus_type,
static struct sysdev_class timer_sysclass = {
set_kset_name("timer"),
.resume = timer_resume,
};
static struct sys_device device_timer = {
.name = "timer",
.id = 0,
.dev = {
.name = "timer",
.driver = &timer_driver,
},
.cls = &timer_sysclass,
};
static int __init init_timer_devicefs(void)
static int __init init_timer_sysfs(void)
{
driver_register(&timer_driver);
return sys_device_register(&device_timer);
int error = sysdev_class_register(&timer_sysclass);
if (!error)
error = sys_device_register(&device_timer);
return error;
}
device_initcall(init_timer_devicefs);
device_initcall(init_timer_sysfs);
void __init init_IRQ(void)
{
......
arch/i386/kernel/nmi.c
View file @ 3935761c
......@@ -23,6 +23,7 @@
#include <linux/mc146818rtc.h>
#include <linux/kernel_stat.h>
#include <linux/module.h>
#include <linux/sysdev.h>
#include <asm/smp.h>
#include <asm/mtrr.h>
......@@ -180,53 +181,48 @@ void enable_lapic_nmi_watchdog(void)
#ifdef CONFIG_PM
#include <linux/device.h>
static int nmi_pm_active; /* nmi_active before suspend */
static int lapic_nmi_suspend(struct device *dev, u32 state, u32 level)
static int lapic_nmi_suspend(struct sys_device *dev, u32 state)
{
if (level != SUSPEND_POWER_DOWN)
return 0;
nmi_pm_active = nmi_active;
disable_lapic_nmi_watchdog();
return 0;
}
static int lapic_nmi_resume(struct device *dev, u32 level)
static int lapic_nmi_resume(struct sys_device *dev)
{
if (level != RESUME_POWER_ON)
return 0;
if (nmi_pm_active > 0)
enable_lapic_nmi_watchdog();
return 0;
}
static struct device_driver lapic_nmi_driver = {
.name = "lapic_nmi",
.bus = &system_bus_type,
static struct sysdev_class nmi_sysclass = {
set_kset_name("lapic_nmi"),
.resume = lapic_nmi_resume,
.suspend = lapic_nmi_suspend,
};
static struct sys_device device_lapic_nmi = {
.name = "lapic_nmi",
.id = 0,
.dev = {
.name = "lapic_nmi",
.driver = &lapic_nmi_driver,
.parent = &device_lapic.dev,
},
.cls = &nmi_sysclass,
};
static int __init init_lapic_nmi_devicefs(void)
static int __init init_lapic_nmi_sysfs(void)
{
int error;
if (nmi_active == 0)
return 0;
driver_register(&lapic_nmi_driver);
return sys_device_register(&device_lapic_nmi);
error = sysdev_class_register(&nmi_sysclass);
if (!error)
error = sys_device_register(&device_lapic_nmi);
return error;
}
/* must come after the local APIC's device_initcall() */
late_initcall(init_lapic_nmi_devicefs);
late_initcall(init_lapic_nmi_sysfs);
#endif /* CONFIG_PM */
......
arch/i386/kernel/time.c
View file @ 3935761c
......@@ -42,7 +42,7 @@
#include <linux/init.h>
#include <linux/smp.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/sysdev.h>
#include <linux/bcd.h>
#include <asm/io.h>
......@@ -278,18 +278,22 @@ unsigned long get_cmos_time(void)
return retval;
}
static struct sysdev_class rtc_sysclass = {
set_kset_name("rtc"),
};
/* XXX this driverfs stuff should probably go elsewhere later -john */
static struct sys_device device_i8253 = {
.name = "rtc",
.id = 0,
.dev = {
.name = "i8253 Real Time Clock",
},
.cls = &rtc_sysclass,
};
static int time_init_device(void)
{
return sys_device_register(&device_i8253);
int error = sysdev_class_register(&rtc_sysclass);
if (!error)
error = sys_device_register(&device_i8253);
return error;
}
device_initcall(time_init_device);
......
arch/i386/oprofile/nmi_int.c
View file @ 3935761c
......@@ -11,7 +11,7 @@
#include <linux/notifier.h>
#include <linux/smp.h>
#include <linux/oprofile.h>
#include <linux/device.h>
#include <linux/sysdev.h>
#include <asm/nmi.h>
#include <asm/msr.h>
#include <asm/apic.h>
......@@ -31,53 +31,48 @@ static int nmi_enabled = 0;
#ifdef CONFIG_PM
static int nmi_suspend(struct device *dev, u32 state, u32 level)
static int nmi_suspend(struct sys_device *dev, u32 state)
{
if (level != SUSPEND_POWER_DOWN)
return 0;
if (nmi_enabled == 1)
nmi_stop();
return 0;
}
static int nmi_resume(struct device *dev, u32 level)
static int nmi_resume(struct sys_device *dev)
{
if (level != RESUME_POWER_ON)
return 0;
if (nmi_enabled == 1)
nmi_start();
return 0;
}
static struct device_driver nmi_driver = {
.name = "oprofile",
.bus = &system_bus_type,
static struct sysdev_class oprofile_sysclass = {
set_kset_name("oprofile"),
.resume = nmi_resume,
.suspend = nmi_suspend,
};
static struct device device_nmi = {
.name = "oprofile",
.bus_id = "oprofile",
.driver = &nmi_driver,
.parent = &device_lapic.dev,
static struct sys_device device_oprofile = {
.id = 0,
.cls = &oprofile_sysclass,
};
static int __init init_driverfs(void)
{
driver_register(&nmi_driver);
return device_register(&device_nmi);
int error;
if (!(error = sysdev_class_register(&oprofile_sysclass)))
error = sys_device_register(&device_oprofile);
return error;
}
static void __exit exit_driverfs(void)
{
device_unregister(&device_nmi);
driver_unregister(&nmi_driver);
sys_device_unregister(&device_oprofile);
sysdev_class_unregister(&oprofile_sysclass);
}
#else
......
arch/x86_64/kernel/i8259.c
View file @ 3935761c
......@@ -11,7 +11,7 @@
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <linux/kernel_stat.h>
#include <linux/device.h>
#include <linux/sysdev.h>
#include <asm/atomic.h>
#include <asm/system.h>
......@@ -413,35 +413,31 @@ static void setup_timer(void)
outb(LATCH >> 8 , 0x40); /* MSB */
}
static int timer_resume(struct device *dev, u32 level)
static int timer_resume(struct sys_device *dev)
{
if (level == RESUME_POWER_ON)
setup_timer();
return 0;
}
static struct device_driver timer_driver = {
.name = "timer",
.bus = &system_bus_type,
static struct sysdev_class timer_sysclass = {
set_kset_name("timer"),
.resume = timer_resume,
};
static struct sys_device device_timer = {
.name = "timer",
.id = 0,
.dev = {
.name = "timer",
.driver = &timer_driver,
},
.cls &timer_sysclass,
};
static int __init init_timer_devicefs(void)
static int __init init_timer_sysfs(void)
{
driver_register(&timer_driver);
return sys_device_register(&device_timer);
int error = sysdev_class_register(&timer_sysclass);
if (!error)
error = sys_device_register(&device_timer);
return error;
}
device_initcall(init_timer_devicefs);
device_initcall(init_timer_sysfs);
void __init init_IRQ(void)
{
......
drivers/base/cpu.c
View file @ 3935761c
......@@ -2,23 +2,18 @@
* drivers/base/cpu.c - basic CPU class support
*/
#include <linux/device.h>
#include <linux/sysdev.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cpu.h>
#include <linux/topology.h>
struct class cpu_class = {
.name = "cpu",
struct sysdev_class cpu_sysdev_class = {
set_kset_name("cpu"),
};
struct device_driver cpu_driver = {
.name = "cpu",
.bus = &system_bus_type,
};
/*
* register_cpu - Setup a driverfs device for a CPU.
* @num - CPU number to use when creating the device.
......@@ -27,42 +22,15 @@ struct device_driver cpu_driver = {
*/
int __init register_cpu(struct cpu *cpu, int num, struct node *root)
{
int retval;
cpu->node_id = cpu_to_node(num);
cpu->sysdev.name = "cpu";
cpu->sysdev.id = num;
if (root)
cpu->sysdev.root = &root->sysroot;
snprintf(cpu->sysdev.dev.name, DEVICE_NAME_SIZE, "CPU %u", num);
cpu->sysdev.dev.driver = &cpu_driver;
retval = sys_device_register(&cpu->sysdev);
if (retval)
return retval;
memset(&cpu->sysdev.class_dev, 0x00, sizeof(struct class_device));
cpu->sysdev.class_dev.dev = &cpu->sysdev.dev;
cpu->sysdev.class_dev.class = &cpu_class;
snprintf(cpu->sysdev.class_dev.class_id, BUS_ID_SIZE, "cpu%d", num);
retval = class_device_register(&cpu->sysdev.class_dev);
if (retval) {
sys_device_unregister(&cpu->sysdev);
return retval;
}
return 0;
cpu->sysdev.cls = &cpu_sysdev_class;
return sys_device_register(&cpu->sysdev);
}
int __init cpu_dev_init(void)
{
int error;
error = class_register(&cpu_class);
if (error)
goto out;
error = driver_register(&cpu_driver);
if (error)
class_unregister(&cpu_class);
out:
return error;
return sysdev_class_register(&cpu_sysdev_class);
}
drivers/base/memblk.c
View file @ 3935761c
......@@ -2,7 +2,6 @@
* drivers/base/memblk.c - basic Memory Block class support
*/
#include <linux/device.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/memblk.h>
......@@ -10,8 +9,8 @@
#include <linux/topology.h>
static struct class memblk_class = {
.name = "memblk",
static struct sysdev_class memblk_class = {
set_kset_name("memblk"),
};
......@@ -29,27 +28,23 @@ static struct device_driver memblk_driver = {
*/
int __init register_memblk(struct memblk *memblk, int num, struct node *root)
{
int error;
memblk->node_id = memblk_to_node(num);
memblk->sysdev.name = "memblk";
memblk->sysdev.cls = &memblk_class,
memblk->sysdev.id = num;
if (root)
memblk->sysdev.root = &root->sysroot;
snprintf(memblk->sysdev.dev.name, DEVICE_NAME_SIZE, "Memory Block %u", num);
memblk->sysdev.dev.driver = &memblk_driver;
return sys_device_register(&memblk->sysdev);
error = sys_device_register(&memblk->sysdev);
if (!error)
error = sysfs_create_link(&root->sysdev.kobj,
&memblk->sysdev,kobj,
memblk->sysdev.kobj.name);
return error;
}
int __init register_memblk_type(void)
{
int error;
error = class_register(&memblk_class);
if (!error) {
error = driver_register(&memblk_driver);
if (error)
class_unregister(&memblk_class);
}
return error;
return sysdev_class_register(&memblk_class);
}
postcore_initcall(register_memblk_type);
drivers/base/node.c
View file @ 3935761c
......@@ -9,15 +9,8 @@
#include <linux/node.h>
#include <linux/topology.h>
static struct class node_class = {
.name = "node",
};
static struct device_driver node_driver = {
.name = "node",
.bus = &system_bus_type,
static struct sysdev_class node_class = {
set_kset_name("node"),
};
......@@ -26,7 +19,7 @@ static ssize_t node_read_cpumap(struct device * dev, char * buf)
struct node *node_dev = to_node(to_root(dev));
return sprintf(buf,"%lx\n",node_dev->cpumap);
}
static DEVICE_ATTR(cpumap,S_IRUGO,node_read_cpumap,NULL);
static SYSDEV_ATTR(cpumap,S_IRUGO,node_read_cpumap,NULL);
#define K(x) ((x) << (PAGE_SHIFT - 10))
static ssize_t node_read_meminfo(struct device * dev, char * buf)
......@@ -52,7 +45,7 @@ static ssize_t node_read_meminfo(struct device * dev, char * buf)
nid, K(i.freeram-i.freehigh));
}
#undef K
static DEVICE_ATTR(meminfo,S_IRUGO,node_read_meminfo,NULL);
static SYSDEV_ATTR(meminfo,S_IRUGO,node_read_meminfo,NULL);
/*
......@@ -66,17 +59,13 @@ int __init register_node(struct node *node, int num, struct node *parent)
int error;
node->cpumap = node_to_cpumask(num);
node->sysroot.id = num;
if (parent)
node->sysroot.dev.parent = &parent->sysroot.sysdev;
snprintf(node->sysroot.dev.name, DEVICE_NAME_SIZE, "Node %u", num);
snprintf(node->sysroot.dev.bus_id, BUS_ID_SIZE, "node%u", num);
node->sysroot.dev.driver = &node_driver;
node->sysroot.dev.bus = &system_bus_type;
error = sys_register_root(&node->sysroot);
node->sysdev.id = num;
node->sysdev.cls = &node_class;
error = sys_device_register(&node->sysdev);
if (!error){
device_create_file(&node->sysroot.dev, &dev_attr_cpumap);
device_create_file(&node->sysroot.dev, &dev_attr_meminfo);
sys_device_create_file(&node->sysroot.dev, &attr_cpumap);
sys_device_create_file(&node->sysroot.dev, &attr_meminfo);
}
return error;
}
......@@ -84,14 +73,6 @@ int __init register_node(struct node *node, int num, struct node *parent)
int __init register_node_type(void)
{
int error;
error = class_register(&node_class);
if (!error) {
error = driver_register(&node_driver);
if (error)
class_unregister(&node_class);
}
return error;
return sysdev_class_register(&node_class);
}
postcore_initcall(register_node_type);
drivers/base/power.c
View file @ 3935761c
......@@ -21,6 +21,21 @@
extern struct subsystem devices_subsys;
/**
* We handle system devices differently - we suspend and shut them
* down first and resume them first. That way, we do anything stupid like
* shutting down the interrupt controller before any devices..
*
* Note that there are not different stages for power management calls -
* they only get one called once when interrupts are disabled.
*/
extern int sysdev_shutdown(void);
extern int sysdev_save(u32 state);
extern int sysdev_suspend(u32 state);
extern int sysdev_resume(void);
extern int sysdev_restore(void);
/**
* device_suspend - suspend/remove all devices on the device ree
* @state: state we're entering
......@@ -50,6 +65,21 @@ int device_suspend(u32 state, u32 level)
}
}
up_write(&devices_subsys.rwsem);
/*
* Make sure system devices are suspended.
*/
switch(level) {
case SUSPEND_SAVE_STATE:
sysdev_save(state);
break;
case SUSPEND_POWER_DOWN:
sysdev_suspend(state);
break;
default:
break;
}
return error;
}
......@@ -65,6 +95,17 @@ void device_resume(u32 level)
{
struct list_head * node;
switch (level) {
case RESUME_POWER_ON:
sysdev_resume();
break;
case RESUME_RESTORE_STATE:
sysdev_restore();
break;
default:
break;
}
down_write(&devices_subsys.rwsem);
list_for_each_prev(node,&devices_subsys.kset.list) {
struct device * dev = to_dev(node);
......@@ -98,6 +139,8 @@ void device_shutdown(void)
pr_debug("Ignored.\n");
}
up_write(&devices_subsys.rwsem);
sysdev_shutdown();
}
EXPORT_SYMBOL(device_suspend);
......
drivers/base/sys.c
View file @ 3935761c
......@@ -12,9 +12,9 @@
* add themselves as children of the system bus.
*/
#undef DEBUG
#define DEBUG
#include <linux/device.h>
#include <linux/sysdev.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/kernel.h>
......@@ -22,130 +22,435 @@
#include <linux/slab.h>
#include <linux/string.h>
/* The default system device parent. */
static struct device system_bus = {
.name = "System Bus",
.bus_id = "sys",
extern struct subsystem devices_subsys;
#define to_sysdev(k) container_of(k,struct sys_device,kobj)
#define to_sysdev_attr(a) container_of(a,struct sysdev_attribute,attr)
static ssize_t
sysdev_show(struct kobject * kobj, struct attribute * attr, char * buffer)
{
struct sys_device * sysdev = to_sysdev(kobj);
struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
if (sysdev_attr->show)
return sysdev_attr->show(sysdev,buffer);
return 0;
}
static ssize_t
sysdev_store(struct kobject * kobj, struct attribute * attr,
const char * buffer, size_t count)
{
struct sys_device * sysdev = to_sysdev(kobj);
struct sysdev_attribute * sysdev_attr = to_sysdev_attr(attr);
if (sysdev_attr->store)
return sysdev_attr->store(sysdev,buffer,count);
return 0;
}
static struct sysfs_ops sysfs_ops = {
.show = sysdev_show,
.store = sysdev_store,
};
static struct kobj_type ktype_sysdev = {
.sysfs_ops = &sysfs_ops,
};
/*
* declare system_subsys
*/
decl_subsys(system,&ktype_sysdev,NULL);
int sysdev_class_register(struct sysdev_class * cls)
{
pr_debug("Registering sysdev class '%s'\n",cls->kset.kobj.name);
INIT_LIST_HEAD(&cls->drivers);
cls->kset.subsys = &system_subsys;
kset_set_kset_s(cls,system_subsys);
return kset_register(&cls->kset);
}
void sysdev_class_unregister(struct sysdev_class * cls)
{
pr_debug("Unregistering sysdev class '%s'\n",cls->kset.kobj.name);
kset_unregister(&cls->kset);
}
EXPORT_SYMBOL(sysdev_class_register);
EXPORT_SYMBOL(sysdev_class_unregister);
static LIST_HEAD(global_drivers);
/**
* sys_register_root - add a subordinate system root
* @root: new root
*
* This is for NUMA-like systems so they can accurately
* represent the topology of the entire system.
* As boards are discovered, a new struct sys_root should
* be allocated and registered.
* The discovery mechanism should initialize the id field
* of the struture, as well as much of the embedded device
* structure as possible, inlcuding the name, the bus_id
* and parent fields.
* sysdev_driver_register - Register auxillary driver
* @cls: Device class driver belongs to.
* @drv: Driver.
*
* This simply calls device_register on the embedded device.
* On success, it will use the struct @root->sysdev
* device to create a pseudo-parent for system devices
* on that board.
* If @cls is valid, then @drv is inserted into @cls->drivers to be
* called on each operation on devices of that class. The refcount
* of @cls is incremented.
* Otherwise, @drv is inserted into global_drivers, and called for
* each device.
*/
int sysdev_driver_register(struct sysdev_class * cls,
struct sysdev_driver * drv)
{
down_write(&system_subsys.rwsem);
if (cls && kset_get(&cls->kset))
list_add_tail(&drv->entry,&cls->drivers);
else
list_add_tail(&drv->entry,&global_drivers);
up_write(&system_subsys.rwsem);
return 0;
}
/**
* sysdev_driver_unregister - Remove an auxillary driver.
* @cls: Class driver belongs to.
* @drv: Driver.
*/
void sysdev_driver_unregister(struct sysdev_class * cls,
struct sysdev_driver * drv)
{
down_write(&system_subsys.rwsem);
list_del_init(&drv->entry);
if (cls)
kset_put(&cls->kset);
up_write(&system_subsys.rwsem);
}
/**
* sys_device_register - add a system device to the tree
* @sysdev: device in question
*
* The platform code can then use @root to specifiy the
* controlling board when discovering and registering
* system devices.
*/
int sys_register_root(struct sys_root * root)
int sys_device_register(struct sys_device * sysdev)
{
int error = 0;
int error;
struct sysdev_class * cls = sysdev->cls;
if (!root)
if (!cls)
return -EINVAL;
if (!root->dev.parent)
root->dev.parent = &system_bus;
/* Make sure the kset is set */
sysdev->kobj.kset = &cls->kset;
/* set the kobject name */
snprintf(sysdev->kobj.name,KOBJ_NAME_LEN,"%s%d",
cls->kset.kobj.name,sysdev->id);
pr_debug("Registering sys device '%s'\n",sysdev->kobj.name);
pr_debug("Registering system board %d\n",root->id);
/* Register the object */
error = kobject_register(&sysdev->kobj);
error = device_register(&root->dev);
if (!error) {
strlcpy(root->sysdev.bus_id,"sys",BUS_ID_SIZE);
strlcpy(root->sysdev.name,"System Bus",DEVICE_NAME_SIZE);
root->sysdev.parent = &root->dev;
error = device_register(&root->sysdev);
};
struct sysdev_driver * drv;
down_read(&system_subsys.rwsem);
/* Generic notification is implicit, because it's that
* code that should have called us.
*/
/* Notify global drivers */
list_for_each_entry(drv,&global_drivers,entry) {
if (drv->add)
drv->add(sysdev);
}
/* Notify class auxillary drivers */
list_for_each_entry(drv,&cls->drivers,entry) {
if (drv->add)
drv->add(sysdev);
}
up_read(&system_subsys.rwsem);
}
return error;
}
void sys_device_unregister(struct sys_device * sysdev)
{
struct sysdev_driver * drv;
down_read(&system_subsys.rwsem);
list_for_each_entry(drv,&global_drivers,entry) {
if (drv->remove)
drv->remove(sysdev);
}
list_for_each_entry(drv,&sysdev->cls->drivers,entry) {
if (drv->remove)
drv->remove(sysdev);
}
up_read(&system_subsys.rwsem);
kobject_unregister(&sysdev->kobj);
}
/**
* sys_unregister_root - remove subordinate root from tree
* @root: subordinate root in question.
* sysdev_shutdown - Shut down all system devices.
*
* Loop over each class of system devices, and the devices in each
* of those classes. For each device, we call the shutdown method for
* each driver registered for the device - the globals, the auxillaries,
* and the class driver.
*
* We only decrement the reference count on @root->sysdev
* and @root->dev.
* If both are 0, they will be cleaned up by the core.
* Note: The list is iterated in reverse order, so that we shut down
* child devices before we shut down thier parents. The list ordering
* is guaranteed by virtue of the fact that child devices are registered
* after their parents.
*/
void sys_unregister_root(struct sys_root *root)
void sysdev_shutdown(void)
{
device_unregister(&root->sysdev);
device_unregister(&root->dev);
struct sysdev_class * cls;
pr_debug("Shutting Down System Devices\n");
down_write(&system_subsys.rwsem);
list_for_each_entry_reverse(cls,&system_subsys.kset.list,
kset.kobj.entry) {
struct sys_device * sysdev;
pr_debug("Shutting down type '%s':\n",cls->kset.kobj.name);
list_for_each_entry(sysdev,&cls->kset.list,kobj.entry) {
struct sysdev_driver * drv;
pr_debug(" %s\n",sysdev->kobj.name);
/* Call global drivers first. */
list_for_each_entry(drv,&global_drivers,entry) {
if (drv->shutdown)
drv->shutdown(sysdev);
}
/* Call auxillary drivers next. */
list_for_each_entry(drv,&cls->drivers,entry) {
if (drv->shutdown)
drv->shutdown(sysdev);
}
/* Now call the generic one */
if (cls->shutdown)
cls->shutdown(sysdev);
}
}
up_write(&system_subsys.rwsem);
}
/**
* sys_device_register - add a system device to the tree
* @sysdev: device in question
* sysdev_save - Save system device state
* @state: Power state we're entering.
*
* The hardest part about this is getting the ancestry right.
* If the device has a parent - super! We do nothing.
* If the device doesn't, but @dev->root is set, then we're
* dealing with a NUMA like architecture where each root
* has a system pseudo-bus to foster the device.
* If not, then we fallback to system_bus (at the top of
* this file).
* This is called when the system is going to sleep, but before interrupts
* have been disabled. This allows system device drivers to allocate and
* save device state, including sleeping during the process..
*/
int sysdev_save(u32 state)
{
struct sysdev_class * cls;
pr_debug("Saving System Device State\n");
down_write(&system_subsys.rwsem);
list_for_each_entry_reverse(cls,&system_subsys.kset.list,
kset.kobj.entry) {
struct sys_device * sysdev;
pr_debug("Saving state for type '%s':\n",cls->kset.kobj.name);
list_for_each_entry(sysdev,&cls->kset.list,kobj.entry) {
struct sysdev_driver * drv;
pr_debug(" %s\n",sysdev->kobj.name);
list_for_each_entry(drv,&global_drivers,entry) {
if (drv->save)
drv->save(sysdev,state);
}
list_for_each_entry(drv,&cls->drivers,entry) {
if (drv->save)
drv->save(sysdev,state);
}
if (cls->save)
cls->save(sysdev,state);
}
}
up_write(&system_subsys.rwsem);
return 0;
}
/**
* sysdev_suspend - Suspend all system devices.
* @state: Power state to enter.
*
* One way or another, we call device_register() on it and
* are done.
* We perform an almost identical operation as sys_device_shutdown()
* above, though calling ->suspend() instead.
*
* The caller is also responsible for initializing the bus_id
* and name fields of @sysdev->dev.
* Note: Interrupts are disabled when called, so we can't sleep when
* trying to get the subsystem's rwsem. If that happens, print a nasty
* warning and return an error.
*/
int sys_device_register(struct sys_device * sysdev)
int sysdev_suspend(u32 state)
{
if (!sysdev)
return -EINVAL;
struct sysdev_class * cls;
if (!sysdev->dev.parent) {
if (sysdev->root)
sysdev->dev.parent = &sysdev->root->sysdev;
else
sysdev->dev.parent = &system_bus;
pr_debug("Suspending System Devices\n");
if (!down_write_trylock(&system_subsys.rwsem)) {
printk("%s: Cannot acquire semaphore; Failing\n",__FUNCTION__);
return -EFAULT;
}
/* make sure bus type is set */
if (!sysdev->dev.bus)
sysdev->dev.bus = &system_bus_type;
list_for_each_entry_reverse(cls,&system_subsys.kset.list,
kset.kobj.entry) {
struct sys_device * sysdev;
/* construct bus_id */
snprintf(sysdev->dev.bus_id,BUS_ID_SIZE,"%s%u",sysdev->name,sysdev->id);
pr_debug("Suspending type '%s':\n",cls->kset.kobj.name);
pr_debug("Registering system device %s\n", sysdev->dev.bus_id);
list_for_each_entry(sysdev,&cls->kset.list,kobj.entry) {
struct sysdev_driver * drv;
pr_debug(" %s\n",sysdev->kobj.name);
return device_register(&sysdev->dev);
/* Call global drivers first. */
list_for_each_entry(drv,&global_drivers,entry) {
if (drv->suspend)
drv->suspend(sysdev,state);
}
/* Call auxillary drivers next. */
list_for_each_entry(drv,&cls->drivers,entry) {
if (drv->suspend)
drv->suspend(sysdev,state);
}
/* Now call the generic one */
if (cls->suspend)
cls->suspend(sysdev,state);
}
}
up_write(&system_subsys.rwsem);
return 0;
}
void sys_device_unregister(struct sys_device * sysdev)
/**
* sysdev_resume - Bring system devices back to life.
*
* Similar to sys_device_suspend(), but we iterate the list forwards
* to guarantee that parent devices are resumed before their children.
*
* Note: Interrupts are disabled when called.
*/
int sysdev_resume(void)
{
if (sysdev)
device_unregister(&sysdev->dev);
struct sysdev_class * cls;
pr_debug("Resuming System Devices\n");
if(!down_write_trylock(&system_subsys.rwsem))
return -EFAULT;
list_for_each_entry(cls,&system_subsys.kset.list,kset.kobj.entry) {
struct sys_device * sysdev;
pr_debug("Resuming type '%s':\n",cls->kset.kobj.name);
list_for_each_entry(sysdev,&cls->kset.list,kobj.entry) {
struct sysdev_driver * drv;
pr_debug(" %s\n",sysdev->kobj.name);
/* First, call the class-specific one */
if (cls->resume)
cls->resume(sysdev);
/* Call auxillary drivers next. */
list_for_each_entry(drv,&cls->drivers,entry) {
if (drv->resume)
drv->resume(sysdev);
}
/* Call global drivers. */
list_for_each_entry(drv,&global_drivers,entry) {
if (drv->resume)
drv->resume(sysdev);
}
}
}
up_write(&system_subsys.rwsem);
return 0;
}
/**
* sysdev_restore - Restore system device state
*
* This is called during a suspend/resume cycle last, after interrupts
* have been re-enabled. This is intended for auxillary drivers, etc,
* that may sleep when restoring state.
*/
int sysdev_restore(void)
{
struct sysdev_class * cls;
down_write(&system_subsys.rwsem);
pr_debug("Restoring System Device State\n");
list_for_each_entry(cls,&system_subsys.kset.list,kset.kobj.entry) {
struct sys_device * sysdev;
pr_debug("Restoring state for type '%s':\n",cls->kset.kobj.name);
list_for_each_entry(sysdev,&cls->kset.list,kobj.entry) {
struct sysdev_driver * drv;
pr_debug(" %s\n",sysdev->kobj.name);
if (cls->restore)
cls->restore(sysdev);
list_for_each_entry(drv,&cls->drivers,entry) {
if (drv->restore)
drv->restore(sysdev);
}
list_for_each_entry(drv,&global_drivers,entry) {
if (drv->restore)
drv->restore(sysdev);
}
}
}
up_write(&system_subsys.rwsem);
return 0;
}
struct bus_type system_bus_type = {
.name = "system",
};
int __init sys_bus_init(void)
{
bus_register(&system_bus_type);
return device_register(&system_bus);
system_subsys.kset.kobj.parent = &devices_subsys.kset.kobj;
return subsystem_register(&system_subsys);
}
EXPORT_SYMBOL(system_bus_type);
EXPORT_SYMBOL(sys_device_register);
EXPORT_SYMBOL(sys_device_unregister);
drivers/s390/block/xpram.c
View file @ 3935761c
......@@ -34,7 +34,7 @@
#include <linux/blk.h>
#include <linux/blkpg.h>
#include <linux/hdreg.h> /* HDIO_GETGEO */
#include <linux/device.h>
#include <linux/sysdev.h>
#include <linux/bio.h>
#include <linux/devfs_fs_kernel.h>
#include <asm/uaccess.h>
......@@ -48,12 +48,14 @@
#define PRINT_WARN(x...) printk(KERN_WARNING XPRAM_NAME " warning:" x)
#define PRINT_ERR(x...) printk(KERN_ERR XPRAM_NAME " error:" x)
static struct sysdev_class xpram_sysclass = {
set_kset_name("xpram"),
};
static struct sys_device xpram_sys_device = {
.name = "S/390 expanded memory RAM disk",
.dev = {
.name = "S/390 expanded memory RAM disk",
.bus_id = "xpram",
},
.id = 0,
.cls = &xpram_sysclass,
};
typedef struct {
......@@ -485,6 +487,7 @@ static void __exit xpram_exit(void)
unregister_blkdev(XPRAM_MAJOR, XPRAM_NAME);
devfs_remove("slram");
sys_device_unregister(&xpram_sys_device);
sysdev_class_unregister(&xpram_sys_class);
}
static int __init xpram_init(void)
......@@ -502,9 +505,15 @@ static int __init xpram_init(void)
rc = xpram_setup_sizes(xpram_pages);
if (rc)
return rc;
rc = sys_device_register(&xpram_sys_device);
rc = sysdev_class_register(&xpram_sysclass);
if (rc)
return rc;
rc = sys_device_register(&xpram_sys_device);
if (rc) {
sysdev_class_unregister(&xpram_syclass);
return rc;
}
rc = xpram_setup_blkdev();
if (rc)
sys_device_unregister(&xpram_sys_device);
......
drivers/usb/core/devices.c
View file @ 3935761c
......@@ -444,7 +444,7 @@ static char *usb_dump_string(char *start, char *end, const struct usb_device *de
* skip_bytes - the number of bytes to skip before writing anything
* file_offset - the offset into the devices file on completion
*/
static ssize_t usb_device_dump(char **buffer, size_t *nbytes, loff_t *skip_bytes, loff_t *file_offset,
static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes, loff_t *skip_bytes, loff_t *file_offset,
struct usb_device *usbdev, struct usb_bus *bus, int level, int index, int count)
{
int chix;
......@@ -554,7 +554,7 @@ static ssize_t usb_device_dump(char **buffer, size_t *nbytes, loff_t *skip_bytes
return total_written;
}
static ssize_t usb_device_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
static ssize_t usb_device_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
{
struct list_head *buslist;
struct usb_bus *bus;
......
drivers/usb/core/devio.c
View file @ 3935761c
......@@ -54,8 +54,8 @@ struct async {
struct task_struct *task;
unsigned int signr;
unsigned int intf;
void *userbuffer;
void *userurb;
void __user *userbuffer;
void __user *userurb;
struct urb *urb;
};
......@@ -83,7 +83,7 @@ static loff_t usbdev_lseek(struct file *file, loff_t offset, int orig)
return ret;
}
static ssize_t usbdev_read(struct file *file, char * buf, size_t nbytes, loff_t *ppos)
static ssize_t usbdev_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
{
struct dev_state *ps = (struct dev_state *)file->private_data;
ssize_t ret = 0;
......@@ -235,7 +235,7 @@ extern __inline__ struct async *async_getcompleted(struct dev_state *ps)
return as;
}
extern __inline__ struct async *async_getpending(struct dev_state *ps, void *userurb)
extern __inline__ struct async *async_getpending(struct dev_state *ps, void __user *userurb)
{
unsigned long flags;
struct async *as;
......@@ -265,7 +265,7 @@ static void async_completed(struct urb *urb, struct pt_regs *regs)
sinfo.si_signo = as->signr;
sinfo.si_errno = as->urb->status;
sinfo.si_code = SI_ASYNCIO;
sinfo.si_addr = as->userurb;
sinfo.si_addr = (void *)as->userurb;
send_sig_info(as->signr, &sinfo, as->task);
}
}
......@@ -536,7 +536,7 @@ static int usbdev_release(struct inode *inode, struct file *file)
return 0;
}
static int proc_control(struct dev_state *ps, void *arg)
static int proc_control(struct dev_state *ps, void __user *arg)
{
struct usb_device *dev = ps->dev;
struct usbdevfs_ctrltransfer ctrl;
......@@ -544,7 +544,7 @@ static int proc_control(struct dev_state *ps, void *arg)
unsigned char *tbuf;
int i, ret;
if (copy_from_user(&ctrl, (void *)arg, sizeof(ctrl)))
if (copy_from_user(&ctrl, arg, sizeof(ctrl)))
return -EFAULT;
if ((ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.wIndex)))
return ret;
......@@ -578,13 +578,15 @@ static int proc_control(struct dev_state *ps, void *arg)
}
free_page((unsigned long)tbuf);
if (i<0) {
printk(KERN_DEBUG "usbfs: USBDEVFS_CONTROL failed dev %d rqt %u rq %u len %u ret %d\n",
printk(KERN_DEBUG "usbfs: USBDEVFS_CONTROL failed "
"cmd %s dev %d rqt %u rq %u len %u ret %d\n",
current->comm,
dev->devnum, ctrl.bRequestType, ctrl.bRequest, ctrl.wLength, i);
}
return i;
}
static int proc_bulk(struct dev_state *ps, void *arg)
static int proc_bulk(struct dev_state *ps, void __user *arg)
{
struct usb_device *dev = ps->dev;
struct usbdevfs_bulktransfer bulk;
......@@ -593,7 +595,7 @@ static int proc_bulk(struct dev_state *ps, void *arg)
unsigned char *tbuf;
int i, ret;
if (copy_from_user(&bulk, (void *)arg, sizeof(bulk)))
if (copy_from_user(&bulk, arg, sizeof(bulk)))
return -EFAULT;
if ((ret = findintfep(ps->dev, bulk.ep)) < 0)
return ret;
......@@ -639,12 +641,12 @@ static int proc_bulk(struct dev_state *ps, void *arg)
return len2;
}
static int proc_resetep(struct dev_state *ps, void *arg)
static int proc_resetep(struct dev_state *ps, void __user *arg)
{
unsigned int ep;
int ret;
if (get_user(ep, (unsigned int *)arg))
if (get_user(ep, (unsigned int __user *)arg))
return -EFAULT;
if ((ret = findintfep(ps->dev, ep)) < 0)
return ret;
......@@ -654,13 +656,13 @@ static int proc_resetep(struct dev_state *ps, void *arg)
return 0;
}
static int proc_clearhalt(struct dev_state *ps, void *arg)
static int proc_clearhalt(struct dev_state *ps, void __user *arg)
{
unsigned int ep;
int pipe;
int ret;
if (get_user(ep, (unsigned int *)arg))
if (get_user(ep, (unsigned int __user *)arg))
return -EFAULT;
if ((ret = findintfep(ps->dev, ep)) < 0)
return ret;
......@@ -675,7 +677,7 @@ static int proc_clearhalt(struct dev_state *ps, void *arg)
}
static int proc_getdriver(struct dev_state *ps, void *arg)
static int proc_getdriver(struct dev_state *ps, void __user *arg)
{
struct usbdevfs_getdriver gd;
struct usb_interface *interface;
......@@ -696,7 +698,7 @@ static int proc_getdriver(struct dev_state *ps, void *arg)
return 0;
}
static int proc_connectinfo(struct dev_state *ps, void *arg)
static int proc_connectinfo(struct dev_state *ps, void __user *arg)
{
struct usbdevfs_connectinfo ci;
......@@ -731,7 +733,7 @@ static int proc_resetdevice(struct dev_state *ps)
return 0;
}
static int proc_setintf(struct dev_state *ps, void *arg)
static int proc_setintf(struct dev_state *ps, void __user *arg)
{
struct usbdevfs_setinterface setintf;
struct usb_interface *interface;
......@@ -753,18 +755,18 @@ static int proc_setintf(struct dev_state *ps, void *arg)
return 0;
}
static int proc_setconfig(struct dev_state *ps, void *arg)
static int proc_setconfig(struct dev_state *ps, void __user *arg)
{
unsigned int u;
if (get_user(u, (unsigned int *)arg))
if (get_user(u, (unsigned int __user *)arg))
return -EFAULT;
if (usb_set_configuration(ps->dev, u) < 0)
return -EINVAL;
return 0;
}
static int proc_submiturb(struct dev_state *ps, void *arg)
static int proc_submiturb(struct dev_state *ps, void __user *arg)
{
struct usbdevfs_urb uurb;
struct usbdevfs_iso_packet_desc *isopkt = NULL;
......@@ -802,7 +804,7 @@ static int proc_submiturb(struct dev_state *ps, void *arg)
return -EINVAL;
if (!(dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
return -ENOMEM;
if (copy_from_user(dr, (unsigned char*)uurb.buffer, 8)) {
if (copy_from_user(dr, uurb.buffer, 8)) {
kfree(dr);
return -EFAULT;
}
......@@ -928,7 +930,7 @@ static int proc_submiturb(struct dev_state *ps, void *arg)
return 0;
}
static int proc_unlinkurb(struct dev_state *ps, void *arg)
static int proc_unlinkurb(struct dev_state *ps, void __user *arg)
{
struct async *as;
......@@ -970,11 +972,11 @@ static int processcompl(struct async *as)
return 0;
}
static int proc_reapurb(struct dev_state *ps, void *arg)
static int proc_reapurb(struct dev_state *ps, void __user *arg)
{
DECLARE_WAITQUEUE(wait, current);
struct async *as = NULL;
void *addr;
void __user *addr;
int ret;
add_wait_queue(&ps->wait, &wait);
......@@ -1005,10 +1007,10 @@ static int proc_reapurb(struct dev_state *ps, void *arg)
return -EIO;
}
static int proc_reapurbnonblock(struct dev_state *ps, void *arg)
static int proc_reapurbnonblock(struct dev_state *ps, void __user *arg)
{
struct async *as;
void *addr;
void __user *addr;
int ret;
if (!(as = async_getcompleted(ps)))
......@@ -1023,7 +1025,7 @@ static int proc_reapurbnonblock(struct dev_state *ps, void *arg)
return 0;
}
static int proc_disconnectsignal(struct dev_state *ps, void *arg)
static int proc_disconnectsignal(struct dev_state *ps, void __user *arg)
{
struct usbdevfs_disconnectsignal ds;
......@@ -1036,24 +1038,24 @@ static int proc_disconnectsignal(struct dev_state *ps, void *arg)
return 0;
}
static int proc_claiminterface(struct dev_state *ps, void *arg)
static int proc_claiminterface(struct dev_state *ps, void __user *arg)
{
unsigned int intf;
int ret;
if (get_user(intf, (unsigned int *)arg))
if (get_user(intf, (unsigned int __user *)arg))
return -EFAULT;
if ((ret = findintfif(ps->dev, intf)) < 0)
return ret;
return claimintf(ps, ret);
}
static int proc_releaseinterface(struct dev_state *ps, void *arg)
static int proc_releaseinterface(struct dev_state *ps, void __user *arg)
{
unsigned int intf;
int ret;
if (get_user(intf, (unsigned int *)arg))
if (get_user(intf, (unsigned int __user *)arg))
return -EFAULT;
if ((ret = findintfif(ps->dev, intf)) < 0)
return ret;
......@@ -1063,7 +1065,7 @@ static int proc_releaseinterface(struct dev_state *ps, void *arg)
return 0;
}
static int proc_ioctl (struct dev_state *ps, void *arg)
static int proc_ioctl (struct dev_state *ps, void __user *arg)
{
struct usbdevfs_ioctl ctrl;
int size;
......@@ -1073,7 +1075,7 @@ static int proc_ioctl (struct dev_state *ps, void *arg)
struct usb_driver *driver = 0;
/* get input parameters and alloc buffer */
if (copy_from_user(&ctrl, (void *) arg, sizeof (ctrl)))
if (copy_from_user(&ctrl, arg, sizeof (ctrl)))
return -EFAULT;
if ((size = _IOC_SIZE (ctrl.ioctl_code)) > 0) {
if ((buf = kmalloc (size, GFP_KERNEL)) == 0)
......@@ -1171,19 +1173,19 @@ static int usbdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
}
switch (cmd) {
case USBDEVFS_CONTROL:
ret = proc_control(ps, (void *)arg);
ret = proc_control(ps, (void __user *)arg);
if (ret >= 0)
inode->i_mtime = CURRENT_TIME;
break;
case USBDEVFS_BULK:
ret = proc_bulk(ps, (void *)arg);
ret = proc_bulk(ps, (void __user *)arg);
if (ret >= 0)
inode->i_mtime = CURRENT_TIME;
break;
case USBDEVFS_RESETEP:
ret = proc_resetep(ps, (void *)arg);
ret = proc_resetep(ps, (void __user *)arg);
if (ret >= 0)
inode->i_mtime = CURRENT_TIME;
break;
......@@ -1193,59 +1195,59 @@ static int usbdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
break;
case USBDEVFS_CLEAR_HALT:
ret = proc_clearhalt(ps, (void *)arg);
ret = proc_clearhalt(ps, (void __user *)arg);
if (ret >= 0)
inode->i_mtime = CURRENT_TIME;
break;
case USBDEVFS_GETDRIVER:
ret = proc_getdriver(ps, (void *)arg);
ret = proc_getdriver(ps, (void __user *)arg);
break;
case USBDEVFS_CONNECTINFO:
ret = proc_connectinfo(ps, (void *)arg);
ret = proc_connectinfo(ps, (void __user *)arg);
break;
case USBDEVFS_SETINTERFACE:
ret = proc_setintf(ps, (void *)arg);
ret = proc_setintf(ps, (void __user *)arg);
break;
case USBDEVFS_SETCONFIGURATION:
ret = proc_setconfig(ps, (void *)arg);
ret = proc_setconfig(ps, (void __user *)arg);
break;
case USBDEVFS_SUBMITURB:
ret = proc_submiturb(ps, (void *)arg);
ret = proc_submiturb(ps, (void __user *)arg);
if (ret >= 0)
inode->i_mtime = CURRENT_TIME;
break;
case USBDEVFS_DISCARDURB:
ret = proc_unlinkurb(ps, (void *)arg);
ret = proc_unlinkurb(ps, (void __user *)arg);
break;
case USBDEVFS_REAPURB:
ret = proc_reapurb(ps, (void *)arg);
ret = proc_reapurb(ps, (void __user *)arg);
break;
case USBDEVFS_REAPURBNDELAY:
ret = proc_reapurbnonblock(ps, (void *)arg);
ret = proc_reapurbnonblock(ps, (void __user *)arg);
break;
case USBDEVFS_DISCSIGNAL:
ret = proc_disconnectsignal(ps, (void *)arg);
ret = proc_disconnectsignal(ps, (void __user *)arg);
break;
case USBDEVFS_CLAIMINTERFACE:
ret = proc_claiminterface(ps, (void *)arg);
ret = proc_claiminterface(ps, (void __user *)arg);
break;
case USBDEVFS_RELEASEINTERFACE:
ret = proc_releaseinterface(ps, (void *)arg);
ret = proc_releaseinterface(ps, (void __user *)arg);
break;
case USBDEVFS_IOCTL:
ret = proc_ioctl(ps, (void *) arg);
ret = proc_ioctl(ps, (void __user *) arg);
break;
}
up_read(&ps->devsem);
......
drivers/usb/core/hub.c
View file @ 3935761c
......@@ -64,17 +64,17 @@ static inline struct device *hubdev (struct usb_device *dev)
}
/* USB 2.0 spec Section 11.24.4.5 */
static int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
static int get_hub_descriptor(struct usb_device *dev, void *data, int size)
{
return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
USB_DT_HUB << 8, 0, data, size, HZ);
USB_DT_HUB << 8, 0, data, size, HZ * USB_CTRL_GET_TIMEOUT);
}
/*
* USB 2.0 spec Section 11.24.2.1
*/
static int usb_clear_hub_feature(struct usb_device *dev, int feature)
static int clear_hub_feature(struct usb_device *dev, int feature)
{
return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, HZ);
......@@ -84,7 +84,7 @@ static int usb_clear_hub_feature(struct usb_device *dev, int feature)
* USB 2.0 spec Section 11.24.2.2
* BUG: doesn't handle port indicator selector in high byte of wIndex
*/
static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
static int clear_port_feature(struct usb_device *dev, int port, int feature)
{
return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);
......@@ -94,7 +94,7 @@ static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
* USB 2.0 spec Section 11.24.2.13
* BUG: doesn't handle port indicator selector in high byte of wIndex
*/
static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
static int set_port_feature(struct usb_device *dev, int port, int feature)
{
return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, HZ);
......@@ -103,21 +103,23 @@ static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
/*
* USB 2.0 spec Section 11.24.2.6
*/
static int usb_get_hub_status(struct usb_device *dev, void *data)
static int get_hub_status(struct usb_device *dev,
struct usb_hub_status *data)
{
return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
data, sizeof(struct usb_hub_status), HZ);
data, sizeof(*data), HZ * USB_CTRL_GET_TIMEOUT);
}
/*
* USB 2.0 spec Section 11.24.2.7
*/
static int usb_get_port_status(struct usb_device *dev, int port, void *data)
static int get_port_status(struct usb_device *dev, int port,
struct usb_port_status *data)
{
return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
data, sizeof(struct usb_hub_status), HZ);
data, sizeof(*data), HZ * USB_CTRL_GET_TIMEOUT);
}
/* completion function, fires on port status changes and various faults */
......@@ -256,7 +258,7 @@ void usb_hub_tt_clear_buffer (struct usb_device *dev, int pipe)
spin_unlock_irqrestore (&tt->lock, flags);
}
static void usb_hub_power_on(struct usb_hub *hub)
static void hub_power_on(struct usb_hub *hub)
{
struct usb_device *dev;
int i;
......@@ -266,22 +268,55 @@ static void usb_hub_power_on(struct usb_hub *hub)
"enabling power on all ports\n");
dev = interface_to_usbdev(hub->intf);
for (i = 0; i < hub->descriptor->bNbrPorts; i++)
usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
/* Wait for power to be enabled */
wait_ms(hub->descriptor->bPwrOn2PwrGood * 2);
}
static int usb_hub_configure(struct usb_hub *hub,
static int hub_hub_status(struct usb_hub *hub,
u16 *status, u16 *change)
{
struct usb_device *dev = interface_to_usbdev (hub->intf);
int ret;
ret = get_hub_status(dev, &hub->status->hub);
if (ret < 0)
dev_err (hubdev (dev),
"%s failed (err = %d)\n", __FUNCTION__, ret);
else {
*status = le16_to_cpu(hub->status->hub.wHubStatus);
*change = le16_to_cpu(hub->status->hub.wHubChange);
ret = 0;
}
return ret;
}
static int hub_configure(struct usb_hub *hub,
struct usb_endpoint_descriptor *endpoint)
{
struct usb_device *dev = interface_to_usbdev (hub->intf);
struct device *hub_dev;
struct usb_hub_status hubstatus;
u16 hubstatus, hubchange;
unsigned int pipe;
int maxp, ret;
char *message;
hub->buffer = usb_buffer_alloc(dev, sizeof(*hub->buffer), GFP_KERNEL,
&hub->buffer_dma);
if (!hub->buffer) {
message = "can't allocate hub irq buffer";
ret = -ENOMEM;
goto fail;
}
hub->status = kmalloc(sizeof(*hub->status), GFP_KERNEL);
if (!hub->status) {
message = "can't kmalloc hub status buffer";
ret = -ENOMEM;
goto fail;
}
hub->descriptor = kmalloc(sizeof(*hub->descriptor), GFP_KERNEL);
if (!hub->descriptor) {
message = "can't kmalloc hub descriptor";
......@@ -293,7 +328,7 @@ static int usb_hub_configure(struct usb_hub *hub,
* hub->descriptor can handle USB_MAXCHILDREN ports,
* but the hub can/will return fewer bytes here.
*/
ret = usb_get_hub_descriptor(dev, hub->descriptor,
ret = get_hub_descriptor(dev, hub->descriptor,
sizeof(*hub->descriptor));
if (ret < 0) {
message = "can't read hub descriptor";
......@@ -396,27 +431,25 @@ static int usb_hub_configure(struct usb_hub *hub,
dev_dbg(hub_dev, "hub controller current requirement: %dmA\n",
hub->descriptor->bHubContrCurrent);
ret = usb_get_hub_status(dev, &hubstatus);
ret = hub_hub_status(hub, &hubstatus, &hubchange);
if (ret < 0) {
message = "can't get hub status";
goto fail;
}
le16_to_cpus(&hubstatus.wHubStatus);
dev_dbg(hub_dev, "local power source is %s\n",
(hubstatus.wHubStatus & HUB_STATUS_LOCAL_POWER)
(hubstatus & HUB_STATUS_LOCAL_POWER)
? "lost (inactive)" : "good");
dev_dbg(hub_dev, "%sover-current condition exists\n",
(hubstatus.wHubStatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
(hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
/* Start the interrupt endpoint */
pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
if (maxp > sizeof(hub->buffer))
maxp = sizeof(hub->buffer);
if (maxp > sizeof(*hub->buffer))
maxp = sizeof(*hub->buffer);
hub->urb = usb_alloc_urb(0, GFP_KERNEL);
if (!hub->urb) {
......@@ -425,8 +458,10 @@ static int usb_hub_configure(struct usb_hub *hub,
goto fail;
}
usb_fill_int_urb(hub->urb, dev, pipe, hub->buffer, maxp, hub_irq,
usb_fill_int_urb(hub->urb, dev, pipe, *hub->buffer, maxp, hub_irq,
hub, endpoint->bInterval);
hub->urb->transfer_dma = hub->buffer_dma;
hub->urb->transfer_flags |= URB_NO_DMA_MAP;
ret = usb_submit_urb(hub->urb, GFP_KERNEL);
if (ret) {
message = "couldn't submit status urb";
......@@ -436,7 +471,7 @@ static int usb_hub_configure(struct usb_hub *hub,
/* Wake up khubd */
wake_up(&khubd_wait);
usb_hub_power_on(hub);
hub_power_on(hub);
return 0;
......@@ -484,6 +519,18 @@ static void hub_disconnect(struct usb_interface *intf)
hub->descriptor = NULL;
}
if (hub->status) {
kfree(hub->status);
hub->status = NULL;
}
if (hub->buffer) {
usb_buffer_free(interface_to_usbdev(intf),
sizeof(*hub->buffer), hub->buffer,
hub->buffer_dma);
hub->buffer = NULL;
}
/* Free the memory */
kfree(hub);
}
......@@ -550,7 +597,7 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
usb_set_intfdata (intf, hub);
if (usb_hub_configure(hub, endpoint) >= 0) {
if (hub_configure(hub, endpoint) >= 0) {
strcpy (intf->dev.name, "Hub");
return 0;
}
......@@ -594,7 +641,7 @@ hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
}
}
static int usb_hub_reset(struct usb_hub *hub)
static int hub_reset(struct usb_hub *hub)
{
struct usb_device *dev = interface_to_usbdev(hub->intf);
int i;
......@@ -618,12 +665,12 @@ static int usb_hub_reset(struct usb_hub *hub)
if (usb_submit_urb(hub->urb, GFP_KERNEL))
return -1;
usb_hub_power_on(hub);
hub_power_on(hub);
return 0;
}
static void usb_hub_disconnect(struct usb_device *dev)
static void hub_start_disconnect(struct usb_device *dev)
{
struct usb_device *parent = dev->parent;
int i;
......@@ -641,26 +688,21 @@ static void usb_hub_disconnect(struct usb_device *dev)
err("cannot disconnect hub %s", dev->devpath);
}
static int usb_hub_port_status(struct usb_device *hub, int port,
static int hub_port_status(struct usb_device *dev, int port,
u16 *status, u16 *change)
{
struct usb_port_status *portsts;
int ret = -ENOMEM;
struct usb_hub *hub = usb_get_intfdata (dev->actconfig->interface);
int ret;
portsts = kmalloc(sizeof(*portsts), GFP_NOIO);
if (portsts) {
ret = usb_get_port_status(hub, port + 1, portsts);
ret = get_port_status(dev, port + 1, &hub->status->port);
if (ret < 0)
dev_err (hubdev (hub),
"%s failed (err = %d)\n", __FUNCTION__,
ret);
dev_err (hubdev (dev),
"%s failed (err = %d)\n", __FUNCTION__, ret);
else {
*status = le16_to_cpu(portsts->wPortStatus);
*change = le16_to_cpu(portsts->wPortChange);
*status = le16_to_cpu(hub->status->port.wPortStatus);
*change = le16_to_cpu(hub->status->port.wPortChange);
ret = 0;
}
kfree(portsts);
}
return ret;
}
......@@ -671,7 +713,7 @@ static int usb_hub_port_status(struct usb_device *hub, int port,
#define HUB_RESET_TIMEOUT 500
/* return: -1 on error, 0 on success, 1 on disconnect. */
static int usb_hub_port_wait_reset(struct usb_device *hub, int port,
static int hub_port_wait_reset(struct usb_device *hub, int port,
struct usb_device *dev, unsigned int delay)
{
int delay_time, ret;
......@@ -685,7 +727,7 @@ static int usb_hub_port_wait_reset(struct usb_device *hub, int port,
wait_ms(delay);
/* read and decode port status */
ret = usb_hub_port_status(hub, port, &portstatus, &portchange);
ret = hub_port_status(hub, port, &portstatus, &portchange);
if (ret < 0) {
return -1;
}
......@@ -723,19 +765,19 @@ static int usb_hub_port_wait_reset(struct usb_device *hub, int port,
}
/* return: -1 on error, 0 on success, 1 on disconnect. */
static int usb_hub_port_reset(struct usb_device *hub, int port,
static int hub_port_reset(struct usb_device *hub, int port,
struct usb_device *dev, unsigned int delay)
{
int i, status;
/* Reset the port */
for (i = 0; i < HUB_RESET_TRIES; i++) {
usb_set_port_feature(hub, port + 1, USB_PORT_FEAT_RESET);
set_port_feature(hub, port + 1, USB_PORT_FEAT_RESET);
/* return on disconnect or reset */
status = usb_hub_port_wait_reset(hub, port, dev, delay);
status = hub_port_wait_reset(hub, port, dev, delay);
if (status != -1) {
usb_clear_port_feature(hub,
clear_port_feature(hub,
port + 1, USB_PORT_FEAT_C_RESET);
dev->state = status
? USB_STATE_NOTATTACHED
......@@ -756,11 +798,11 @@ static int usb_hub_port_reset(struct usb_device *hub, int port,
return -1;
}
int usb_hub_port_disable(struct usb_device *hub, int port)
int hub_port_disable(struct usb_device *hub, int port)
{
int ret;
ret = usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_ENABLE);
ret = clear_port_feature(hub, port + 1, USB_PORT_FEAT_ENABLE);
if (ret)
dev_err(hubdev(hub), "cannot disable port %d (err = %d)\n",
port + 1, ret);
......@@ -787,7 +829,7 @@ int usb_hub_port_disable(struct usb_device *hub, int port)
#define HUB_DEBOUNCE_STABLE 4
/* return: -1 on error, 0 on success, 1 on disconnect. */
static int usb_hub_port_debounce(struct usb_device *hub, int port)
static int hub_port_debounce(struct usb_device *hub, int port)
{
int ret;
int delay_time, stable_count;
......@@ -799,7 +841,7 @@ static int usb_hub_port_debounce(struct usb_device *hub, int port)
for (delay_time = 0; delay_time < HUB_DEBOUNCE_TIMEOUT; delay_time += HUB_DEBOUNCE_STEP) {
wait_ms(HUB_DEBOUNCE_STEP);
ret = usb_hub_port_status(hub, port, &portstatus, &portchange);
ret = hub_port_status(hub, port, &portstatus, &portchange);
if (ret < 0)
return -1;
......@@ -814,7 +856,7 @@ static int usb_hub_port_debounce(struct usb_device *hub, int port)
connection = portstatus & USB_PORT_STAT_CONNECTION;
if ((portchange & USB_PORT_STAT_C_CONNECTION)) {
usb_clear_port_feature(hub, port+1, USB_PORT_FEAT_C_CONNECTION);
clear_port_feature(hub, port+1, USB_PORT_FEAT_C_CONNECTION);
}
}
......@@ -826,7 +868,7 @@ static int usb_hub_port_debounce(struct usb_device *hub, int port)
return ((portstatus&USB_PORT_STAT_CONNECTION)) ? 0 : 1;
}
static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
static void hub_port_connect_change(struct usb_hub *hubstate, int port,
u16 portstatus, u16 portchange)
{
struct usb_device *hub = interface_to_usbdev(hubstate->intf);
......@@ -839,7 +881,7 @@ static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
port + 1, portstatus, portchange, portspeed (portstatus));
/* Clear the connection change status */
usb_clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_CONNECTION);
clear_port_feature(hub, port + 1, USB_PORT_FEAT_C_CONNECTION);
/* Disconnect any existing devices under this port */
if (hub->children[port])
......@@ -848,16 +890,16 @@ static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
/* Return now if nothing is connected */
if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
if (portstatus & USB_PORT_STAT_ENABLE)
usb_hub_port_disable(hub, port);
hub_port_disable(hub, port);
return;
}
if (usb_hub_port_debounce(hub, port)) {
if (hub_port_debounce(hub, port)) {
dev_err (&hubstate->intf->dev,
"connect-debounce failed, port %d disabled\n",
port+1);
usb_hub_port_disable(hub, port);
hub_port_disable(hub, port);
return;
}
......@@ -884,7 +926,7 @@ static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
dev->state = USB_STATE_POWERED;
/* Reset the device, and detect its speed */
if (usb_hub_port_reset(hub, port, dev, delay)) {
if (hub_port_reset(hub, port, dev, delay)) {
usb_put_dev(dev);
break;
}
......@@ -944,18 +986,17 @@ static void usb_hub_port_connect_change(struct usb_hub *hubstate, int port,
}
hub->children[port] = NULL;
usb_hub_port_disable(hub, port);
hub_port_disable(hub, port);
done:
up(&usb_address0_sem);
}
static void usb_hub_events(void)
static void hub_events(void)
{
unsigned long flags;
struct list_head *tmp;
struct usb_device *dev;
struct usb_hub *hub;
struct usb_hub_status hubsts;
u16 hubstatus;
u16 hubchange;
u16 portstatus;
......@@ -991,11 +1032,11 @@ static void usb_hub_events(void)
dev_dbg (&hub->intf->dev, "resetting for error %d\n",
hub->error);
if (usb_hub_reset(hub)) {
if (hub_reset(hub)) {
dev_dbg (&hub->intf->dev,
"can't reset; disconnecting\n");
up(&hub->khubd_sem);
usb_hub_disconnect(dev);
hub_start_disconnect(dev);
continue;
}
......@@ -1004,18 +1045,18 @@ static void usb_hub_events(void)
}
for (i = 0; i < hub->descriptor->bNbrPorts; i++) {
ret = usb_hub_port_status(dev, i, &portstatus, &portchange);
ret = hub_port_status(dev, i, &portstatus, &portchange);
if (ret < 0) {
continue;
}
if (portchange & USB_PORT_STAT_C_CONNECTION) {
usb_hub_port_connect_change(hub, i, portstatus, portchange);
hub_port_connect_change(hub, i, portstatus, portchange);
} else if (portchange & USB_PORT_STAT_C_ENABLE) {
dev_dbg (hubdev (dev),
"port %d enable change, status %x\n",
i + 1, portstatus);
usb_clear_port_feature(dev,
clear_port_feature(dev,
i + 1, USB_PORT_FEAT_C_ENABLE);
/*
......@@ -1032,7 +1073,7 @@ static void usb_hub_events(void)
"disabled by hub (EMI?), "
"re-enabling...",
i + 1);
usb_hub_port_connect_change(hub,
hub_port_connect_change(hub,
i, portstatus, portchange);
}
}
......@@ -1041,7 +1082,7 @@ static void usb_hub_events(void)
dev_dbg (&hub->intf->dev,
"suspend change on port %d\n",
i + 1);
usb_clear_port_feature(dev,
clear_port_feature(dev,
i + 1, USB_PORT_FEAT_C_SUSPEND);
}
......@@ -1049,35 +1090,33 @@ static void usb_hub_events(void)
dev_err (&hub->intf->dev,
"over-current change on port %d\n",
i + 1);
usb_clear_port_feature(dev,
clear_port_feature(dev,
i + 1, USB_PORT_FEAT_C_OVER_CURRENT);
usb_hub_power_on(hub);
hub_power_on(hub);
}
if (portchange & USB_PORT_STAT_C_RESET) {
dev_dbg (&hub->intf->dev,
"reset change on port %d\n",
i + 1);
usb_clear_port_feature(dev,
clear_port_feature(dev,
i + 1, USB_PORT_FEAT_C_RESET);
}
} /* end for i */
/* deal with hub status changes */
if (usb_get_hub_status(dev, &hubsts) < 0)
if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
dev_err (&hub->intf->dev, "get_hub_status failed\n");
else {
hubstatus = le16_to_cpup(&hubsts.wHubStatus);
hubchange = le16_to_cpup(&hubsts.wHubChange);
if (hubchange & HUB_CHANGE_LOCAL_POWER) {
dev_dbg (&hub->intf->dev, "power change\n");
usb_clear_hub_feature(dev, C_HUB_LOCAL_POWER);
clear_hub_feature(dev, C_HUB_LOCAL_POWER);
}
if (hubchange & HUB_CHANGE_OVERCURRENT) {
dev_dbg (&hub->intf->dev, "overcurrent change\n");
wait_ms(500); /* Cool down */
usb_clear_hub_feature(dev, C_HUB_OVER_CURRENT);
usb_hub_power_on(hub);
clear_hub_feature(dev, C_HUB_OVER_CURRENT);
hub_power_on(hub);
}
}
up(&hub->khubd_sem);
......@@ -1086,7 +1125,7 @@ static void usb_hub_events(void)
spin_unlock_irqrestore(&hub_event_lock, flags);
}
static int usb_hub_thread(void *__hub)
static int hub_thread(void *__hub)
{
/*
* This thread doesn't need any user-level access,
......@@ -1098,13 +1137,13 @@ static int usb_hub_thread(void *__hub)
/* Send me a signal to get me die (for debugging) */
do {
usb_hub_events();
hub_events();
wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list));
if (current->flags & PF_FREEZE)
refrigerator(PF_IOTHREAD);
} while (!signal_pending(current));
dbg("usb_hub_thread exiting");
dbg("hub_thread exiting");
complete_and_exit(&khubd_exited, 0);
}
......@@ -1139,7 +1178,7 @@ int usb_hub_init(void)
return -1;
}
pid = kernel_thread(usb_hub_thread, NULL,
pid = kernel_thread(hub_thread, NULL,
CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
if (pid >= 0) {
khubd_pid = pid;
......@@ -1149,7 +1188,7 @@ int usb_hub_init(void)
/* Fall through if kernel_thread failed */
usb_deregister(&hub_driver);
err("failed to start usb_hub_thread");
err("failed to start hub_thread");
return -1;
}
......@@ -1212,8 +1251,8 @@ int usb_physical_reset_device(struct usb_device *dev)
down(&usb_address0_sem);
/* Send a reset to the device */
if (usb_hub_port_reset(parent, port, dev, HUB_SHORT_RESET_TIME)) {
usb_hub_port_disable(parent, port);
if (hub_port_reset(parent, port, dev, HUB_SHORT_RESET_TIME)) {
hub_port_disable(parent, port);
up(&usb_address0_sem);
kfree(descriptor);
return(-ENODEV);
......@@ -1223,7 +1262,7 @@ int usb_physical_reset_device(struct usb_device *dev)
ret = usb_set_address(dev);
if (ret < 0) {
err("USB device not accepting new address (error=%d)", ret);
usb_hub_port_disable(parent, port);
hub_port_disable(parent, port);
up(&usb_address0_sem);
kfree(descriptor);
return ret;
......
drivers/usb/core/hub.h
View file @ 3935761c
......@@ -174,7 +174,12 @@ struct usb_hub {
struct urb *urb; /* for interrupt polling pipe */
/* buffer for urb ... 1 bit each for hub and children, rounded up */
char buffer[(USB_MAXCHILDREN + 1 + 7) / 8];
char (*buffer)[(USB_MAXCHILDREN + 1 + 7) / 8];
dma_addr_t buffer_dma; /* DMA address for buffer */
union {
struct usb_hub_status hub;
struct usb_port_status port;
} *status; /* buffer for status reports */
int error; /* last reported error */
int nerrors; /* track consecutive errors */
......
drivers/usb/core/inode.c
View file @ 3935761c
......@@ -282,13 +282,13 @@ static int usbfs_rmdir(struct inode *dir, struct dentry *dentry)
/* default file operations */
static ssize_t default_read_file (struct file *file, char *buf,
static ssize_t default_read_file (struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
return 0;
}
static ssize_t default_write_file (struct file *file, const char *buf,
static ssize_t default_write_file (struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
return count;
......
drivers/usb/gadget/net2280.c
View file @ 3935761c
......@@ -20,10 +20,12 @@
* short OUT transfers happen.) Drivers can use the req->no_interrupt
* hint to completely eliminate some IRQs, if a later IRQ is guaranteed
* and DMA chaining is enabled.
*
* Note that almost all the errata workarounds here are only needed for
* rev1 chips. Rev1a silicon (0110) fixes almost all of them.
*/
// #define NET2280_DMA_OUT_WORKAROUND
// #define USE_DMA_CHAINING
#define USE_DMA_CHAINING
/*
......@@ -180,6 +182,13 @@ net2280_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
* kicking in the "toggle-irrelevant" mode.
*/
tmp = USB_ENDPOINT_XFER_BULK;
} else if (tmp == USB_ENDPOINT_XFER_BULK) {
/* catch some particularly blatant driver bugs */
if ((dev->gadget.speed == USB_SPEED_HIGH
&& max != 512)
|| (dev->gadget.speed == USB_SPEED_FULL
&& max > 64))
return -ERANGE;
}
ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC) ? 1 : 0;
tmp <<= ENDPOINT_TYPE;
......@@ -252,9 +261,6 @@ static int handshake (u32 *ptr, u32 mask, u32 done, int usec)
udelay (1);
usec--;
} while (usec > 0);
#ifdef DEBUG
if (done == 0) dump_stack (); /* ignore out_flush timeout */
#endif
return -ETIMEDOUT;
}
......@@ -917,6 +923,8 @@ net2280_queue (struct usb_ep *_ep, struct usb_request *_req, int gfp_flags)
*/
if (read_fifo (ep, req)) {
done (ep, req, 0);
if (ep->num == 0)
allow_status (ep);
/* don't queue it */
req = 0;
} else
......@@ -1194,9 +1202,12 @@ net2280_set_halt (struct usb_ep *_ep, int value)
VDEBUG (ep->dev, "%s %s halt\n", _ep->name, value ? "set" : "clear");
/* set/clear, then synch memory views with the device */
if (value)
set_halt (ep);
if (value) {
if (ep->num == 0)
ep->dev->protocol_stall = 1;
else
set_halt (ep);
} else
clear_halt (ep);
(void) readl (&ep->regs->ep_rsp);
......@@ -2042,6 +2053,7 @@ static void handle_ep_small (struct net2280_ep *ep)
* can decide to stall ep0 after that done() returns,
* from non-irq context
*/
if (!ep->stopped)
allow_status (ep);
req = 0;
} else {
......
drivers/usb/host/ohci-q.c
View file @ 3935761c
......@@ -377,12 +377,8 @@ static struct ed *ed_get (
ed->type = type;
}
/* FIXME: Don't do this without knowing it's safe to clobber this
* state/mode info. Currently the upper layers don't support such
* guarantees; we're lucky changing config/altsetting is rare.
* The state/mode info also changes during enumeration: set_address
* uses the 'wrong' device address, and ep0 maxpacketsize will often
* improve on the initial value.
/* NOTE: only ep0 currently needs this "re"init logic, during
* enumeration (after set_address, or if ep0 maxpacket >8).
*/
if (ed->state == ED_IDLE) {
u32 info;
......
drivers/usb/image/hpusbscsi.c
View file @ 3935761c
......@@ -45,7 +45,7 @@ hpusbscsi_usb_probe(struct usb_interface *intf,
struct usb_host_interface *altsetting = intf->altsetting;
struct hpusbscsi *new;
int error = -ENOMEM;
int i, result;
int i;
if (altsetting->desc.bNumEndpoints != 3) {
printk (KERN_ERR "Wrong number of endpoints\n");
......
drivers/usb/media/vicam.c
View file @ 3935761c
......@@ -1101,6 +1101,52 @@ static int vicam_read_proc_gain(char *page, char **start, off_t off,
((struct vicam_camera *)data)->gain);
}
static int
vicam_write_proc_shutter(struct file *file, const char *buffer,
unsigned long count, void *data)
{
u16 stmp;
char kbuf[8];
struct vicam_camera *cam = (struct vicam_camera *) data;
if (count > 6)
return -EINVAL;
if (copy_from_user(kbuf, buffer, count))
return -EFAULT;
stmp = (u16) simple_strtoul(kbuf, NULL, 10);
if (stmp < 4 || stmp > 32000)
return -EINVAL;
cam->shutter_speed = stmp;
return count;
}
static int
vicam_write_proc_gain(struct file *file, const char *buffer,
unsigned long count, void *data)
{
u16 gtmp;
char kbuf[8];
struct vicam_camera *cam = (struct vicam_camera *) data;
if (count > 4)
return -EINVAL;
if (copy_from_user(kbuf, buffer, count))
return -EFAULT;
gtmp = (u16) simple_strtoul(kbuf, NULL, 10);
if (gtmp > 255)
return -EINVAL;
cam->gain = gtmp;
return count;
}
static void
vicam_create_proc_root(void)
{
......@@ -1142,18 +1188,21 @@ vicam_create_proc_entry(struct vicam_camera *cam)
if ( !cam->proc_dir )
return; // FIXME: We should probably return an error here
ent =
create_proc_entry("shutter", S_IFREG | S_IRUGO, cam->proc_dir);
ent = create_proc_entry("shutter", S_IFREG | S_IRUGO | S_IWUSR,
cam->proc_dir);
if (ent) {
ent->data = cam;
ent->read_proc = vicam_read_proc_shutter;
ent->write_proc = vicam_write_proc_shutter;
ent->size = 64;
}
ent = create_proc_entry("gain", S_IFREG | S_IRUGO , cam->proc_dir);
if ( ent ) {
ent = create_proc_entry("gain", S_IFREG | S_IRUGO | S_IWUSR,
cam->proc_dir);
if (ent) {
ent->data = cam;
ent->read_proc = vicam_read_proc_gain;
ent->write_proc = vicam_write_proc_gain;
ent->size = 64;
}
}
......
drivers/usb/net/catc.c
View file @ 3935761c
......@@ -63,6 +63,8 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
static const char driver_name[] = "catc";
/*
* Some defines.
*/
......@@ -677,7 +679,7 @@ static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
/* get driver info */
case ETHTOOL_GDRVINFO: {
struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
strncpy(info.driver, SHORT_DRIVER_DESC, ETHTOOL_BUSINFO_LEN);
strncpy(info.driver, driver_name, ETHTOOL_BUSINFO_LEN);
strncpy(info.version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
usb_make_path (catc->usbdev, info.bus_info, sizeof info.bus_info);
if (copy_to_user(useraddr, &info, sizeof(info)))
......@@ -978,7 +980,7 @@ MODULE_DEVICE_TABLE(usb, catc_id_table);
static struct usb_driver catc_driver = {
.owner = THIS_MODULE,
.name = "catc",
.name = driver_name,
.probe = catc_probe,
.disconnect = catc_disconnect,
.id_table = catc_id_table,
......
drivers/usb/net/kaweth.c
View file @ 3935761c
......@@ -114,6 +114,8 @@ MODULE_AUTHOR("Michael Zappe <zapman@interlan.net>, Stephane Alnet <stephane@u-p
MODULE_DESCRIPTION("KL5USB101 USB Ethernet driver");
MODULE_LICENSE("GPL");
static const char driver_name[] = "kaweth";
static int kaweth_probe(
struct usb_interface *intf,
const struct usb_device_id *id /* from id_table */
......@@ -169,7 +171,7 @@ MODULE_DEVICE_TABLE (usb, usb_klsi_table);
****************************************************************/
static struct usb_driver kaweth_driver = {
.owner = THIS_MODULE,
.name = "kaweth",
.name = driver_name,
.probe = kaweth_probe,
.disconnect = kaweth_disconnect,
.id_table = usb_klsi_table,
......@@ -670,7 +672,7 @@ static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
switch (ethcmd) {
case ETHTOOL_GDRVINFO: {
struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
strlcpy(info.driver, "kaweth", sizeof(info.driver));
strlcpy(info.driver, driver_name, sizeof(info.driver));
if (copy_to_user(useraddr, &info, sizeof(info)))
return -EFAULT;
return 0;
......
drivers/usb/net/pegasus.c
View file @ 3935761c
/*
* Copyright (c) 1999-2002 Petko Manolov (petkan@users.sourceforge.net)
* Copyright (c) 1999-2003 Petko Manolov (petkan@users.sourceforge.net)
*
* 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
......@@ -45,7 +45,7 @@
/*
* Version Information
*/
#define DRIVER_VERSION "v0.5.10 (2003/04/01)"
#define DRIVER_VERSION "v0.5.12 (2003/06/06)"
#define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
#define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"
......@@ -564,7 +564,14 @@ static void read_bulk_callback(struct urb *urb, struct pt_regs *regs)
dbg("%s: reset MAC", net->name);
pegasus->flags &= ~PEGASUS_RX_BUSY;
break;
case -EPIPE: /* stall, or disconnect from TT */
/* FIXME schedule work to clear the halt */
warn("%s: no rx stall recovery", net->name);
return;
case -ENOENT:
case -ECONNRESET:
case -ESHUTDOWN:
dbg("%s: rx unlink, %d", net->name, urb->status);
return;
default:
dbg("%s: RX status %d", net->name, urb->status);
......@@ -604,6 +611,9 @@ static void read_bulk_callback(struct urb *urb, struct pt_regs *regs)
pegasus->stats.rx_packets++;
pegasus->stats.rx_bytes += pkt_len;
if (pegasus->flags & PEGASUS_UNPLUG)
return;
spin_lock(&pegasus->rx_pool_lock);
pegasus->rx_skb = pull_skb(pegasus);
spin_unlock(&pegasus->rx_pool_lock);
......@@ -631,24 +641,24 @@ static void read_bulk_callback(struct urb *urb, struct pt_regs *regs)
static void rx_fixup(unsigned long data)
{
pegasus_t *pegasus;
unsigned long flags;
pegasus = (pegasus_t *) data;
if (pegasus->flags & PEGASUS_UNPLUG)
return;
spin_lock_irq(&pegasus->rx_pool_lock);
spin_lock_irqsave(&pegasus->rx_pool_lock, flags);
fill_skb_pool(pegasus);
spin_unlock_irq(&pegasus->rx_pool_lock);
if (pegasus->flags & PEGASUS_RX_URB_FAIL)
if (pegasus->rx_skb)
goto try_again;
if (pegasus->rx_skb == NULL) {
spin_lock_irq(&pegasus->rx_pool_lock);
pegasus->rx_skb = pull_skb(pegasus);
spin_unlock_irq(&pegasus->rx_pool_lock);
}
if (pegasus->rx_skb == NULL) {
warn("wow, low on memory");
tasklet_schedule(&pegasus->rx_tl);
return;
goto done;
}
usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
usb_rcvbulkpipe(pegasus->usb, 1),
......@@ -661,23 +671,41 @@ static void rx_fixup(unsigned long data)
} else {
pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
}
done:
spin_unlock_irqrestore(&pegasus->rx_pool_lock, flags);
}
static void write_bulk_callback(struct urb *urb, struct pt_regs *regs)
{
pegasus_t *pegasus = urb->context;
struct net_device *net = pegasus->net;
if (!pegasus || !(pegasus->flags & PEGASUS_RUNNING))
return;
if (!netif_device_present(pegasus->net))
if (!netif_device_present(net))
return;
if (urb->status)
info("%s: TX status %d", pegasus->net->name, urb->status);
switch (urb->status) {
case -EPIPE:
/* FIXME schedule_work() to clear the tx halt */
netif_stop_queue(net);
warn("%s: no tx stall recovery", net->name);
return;
case -ENOENT:
case -ECONNRESET:
case -ESHUTDOWN:
dbg("%s: tx unlink, %d", net->name, urb->status);
return;
default:
info("%s: TX status %d", net->name, urb->status);
/* FALL THROUGH */
case 0:
break;
}
pegasus->net->trans_start = jiffies;
netif_wake_queue(pegasus->net);
net->trans_start = jiffies;
netif_wake_queue(net);
}
static void intr_callback(struct urb *urb, struct pt_regs *regs)
......@@ -754,8 +782,16 @@ static int pegasus_start_xmit(struct sk_buff *skb, struct net_device *net)
write_bulk_callback, pegasus);
if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) {
warn("failed tx_urb %d", res);
switch (res) {
case -EPIPE: /* stall, or disconnect from TT */
/* cleanup should already have been scheduled */
break;
case -ENODEV: /* disconnect() upcoming */
break;
default:
pegasus->stats.tx_errors++;
netif_start_queue(net);
}
} else {
pegasus->stats.tx_packets++;
pegasus->stats.tx_bytes += skb->len;
......@@ -903,6 +939,7 @@ static int pegasus_close(struct net_device *net)
netif_stop_queue(net);
if (!(pegasus->flags & PEGASUS_UNPLUG))
disable_net_traffic(pegasus);
tasklet_kill(&pegasus->rx_tl);
unlink_all_urbs(pegasus);
return 0;
......@@ -920,11 +957,15 @@ static int pegasus_ethtool_ioctl(struct net_device *dev, void *useraddr)
switch (ethcmd) {
/* get driver-specific version/etc. info */
case ETHTOOL_GDRVINFO:{
struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
strlcpy(info.driver, driver_name,
sizeof (info.driver));
strlcpy(info.version, DRIVER_VERSION,
sizeof (info.version));
struct ethtool_drvinfo info;
memset (&info, 0, sizeof (info));
info.cmd = ETHTOOL_GDRVINFO;
strncpy(info.driver, driver_name,
sizeof (info.driver) - 1);
strncpy(info.version, DRIVER_VERSION,
sizeof (info.version) - 1);
usb_make_path(pegasus->usb, info.bus_info,
sizeof (info.bus_info));
if (copy_to_user(useraddr, &info, sizeof (info)))
return -EFAULT;
return 0;
......@@ -993,12 +1034,15 @@ static int pegasus_ethtool_ioctl(struct net_device *net, void *uaddr)
return -EFAULT;
switch (cmd) {
case ETHTOOL_GDRVINFO:{
struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
strncpy(info.driver, driver_name, sizeof info.driver);
struct ethtool_drvinfo info;
memset (&info, 0, sizeof (info));
info.cmd = ETHTOOL_GDRVINFO;
strncpy(info.driver, driver_name,
sizeof (info.driver) - 1);
strncpy(info.version, DRIVER_VERSION,
ETHTOOL_BUSINFO_LEN);
sizeof (info.version) - 1);
usb_make_path(pegasus->usb, info.bus_info,
sizeof info.bus_info);
sizeof (info.bus_info));
if (copy_to_user(uaddr, &info, sizeof (info)))
return -EFAULT;
return 0;
......@@ -1006,14 +1050,19 @@ static int pegasus_ethtool_ioctl(struct net_device *net, void *uaddr)
case ETHTOOL_GSET:{
struct ethtool_cmd ecmd;
short lpa, bmcr;
u8 port;
memset(&ecmd, 0, sizeof ecmd);
memset(&ecmd, 0, sizeof (ecmd));
ecmd.supported = (SUPPORTED_10baseT_Half |
SUPPORTED_10baseT_Full |
SUPPORTED_100baseT_Half |
SUPPORTED_100baseT_Full |
SUPPORTED_Autoneg |
SUPPORTED_TP | SUPPORTED_MII);
get_registers(pegasus, Reg7b, 1, &port);
if (port == 0)
ecmd.port = PORT_MII;
else
ecmd.port = PORT_TP;
ecmd.transceiver = XCVR_INTERNAL;
ecmd.phy_address = pegasus->phy;
......@@ -1132,6 +1181,9 @@ static inline void setup_pegasus_II(pegasus_t * pegasus)
set_register(pegasus, Reg1d, 0);
set_register(pegasus, Reg7b, 1);
mdelay(100);
if ((pegasus->features & HAS_HOME_PNA) && mii_mode)
set_register(pegasus, Reg7b, 0);
else
set_register(pegasus, Reg7b, 2);
set_register(pegasus, 0x83, data);
......@@ -1253,7 +1305,6 @@ static void pegasus_disconnect(struct usb_interface *intf)
pegasus->flags |= PEGASUS_UNPLUG;
unregister_netdev(pegasus->net);
usb_put_dev(interface_to_usbdev(intf));
unlink_all_urbs(pegasus);
free_all_urbs(pegasus);
free_skb_pool(pegasus);
if (pegasus->rx_skb)
......@@ -1263,7 +1314,6 @@ static void pegasus_disconnect(struct usb_interface *intf)
}
static struct usb_driver pegasus_driver = {
.owner = THIS_MODULE,
.name = driver_name,
.probe = pegasus_probe,
.disconnect = pegasus_disconnect,
......
drivers/usb/net/pegasus.h
View file @ 3935761c
/*
* Copyright (c) 1999-2002 Petko Manolov - Petkan (petkan@users.sourceforge.net)
* Copyright (c) 1999-2003 Petko Manolov - Petkan (petkan@users.sourceforge.net)
*
* 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
......@@ -129,6 +129,7 @@ struct usb_eth_dev {
#define VENDOR_ELCON 0x0db7
#define VENDOR_ELSA 0x05cc
#define VENDOR_HAWKING 0x0e66
#define VENDOR_HP 0x03f0
#define VENDOR_IODATA 0x04bb
#define VENDOR_KINGSTON 0x0951
#define VENDOR_LANEED 0x056e
......@@ -223,6 +224,8 @@ PEGASUS_DEV( "Elsa Micolink USB2Ethernet", VENDOR_ELSA, 0x3000,
DEFAULT_GPIO_RESET )
PEGASUS_DEV( "Hawking UF100 10/100 Ethernet", VENDOR_HAWKING, 0x400c,
DEFAULT_GPIO_RESET | PEGASUS_II )
PEGASUS_DEV( "HP hn210c Ethernet USB", VENDOR_HP, 0x811c,
DEFAULT_GPIO_RESET | PEGASUS_II )
PEGASUS_DEV( "IO DATA USB ET/TX", VENDOR_IODATA, 0x0904,
DEFAULT_GPIO_RESET )
PEGASUS_DEV( "IO DATA USB ET/TX-S", VENDOR_IODATA, 0x0913,
......
drivers/usb/net/rtl8150.c
View file @ 3935761c
......@@ -113,9 +113,11 @@ static void rtl8150_disconnect(struct usb_interface *intf);
static int rtl8150_probe(struct usb_interface *intf,
const struct usb_device_id *id);
static const char driver_name [] = "rtl8150";
static struct usb_driver rtl8150_driver = {
.owner = THIS_MODULE,
.name = "rtl8150",
.name = driver_name,
.probe = rtl8150_probe,
.disconnect = rtl8150_disconnect,
.id_table = rtl8150_table,
......@@ -684,7 +686,7 @@ static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
case ETHTOOL_GDRVINFO:{
struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
strncpy(info.driver, DRIVER_DESC, ETHTOOL_BUSINFO_LEN);
strncpy(info.driver, driver_name, ETHTOOL_BUSINFO_LEN);
strncpy(info.version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
usb_make_path(dev->udev, info.bus_info, sizeof info.bus_info);
if (copy_to_user(uaddr, &info, sizeof(info)))
......
drivers/usb/storage/transport.c
View file @ 3935761c
......@@ -48,6 +48,7 @@
#include <linux/config.h>
#include "transport.h"
#include "protocol.h"
#include "scsiglue.h"
#include "usb.h"
#include "debug.h"
......@@ -303,6 +304,11 @@ static int interpret_urb_result(struct us_data *us, unsigned int pipe,
US_DEBUGP("-- device NAKed\n");
return USB_STOR_XFER_ERROR;
/* babble - the device tried to send more than we wanted to read */
case -EOVERFLOW:
US_DEBUGP("-- Babble\n");
return USB_STOR_XFER_LONG;
/* the transfer was cancelled, presumably by an abort */
case -ECONNRESET:
US_DEBUGP("-- transfer cancelled\n");
......@@ -525,6 +531,12 @@ void usb_stor_invoke_transport(Scsi_Cmnd *srb, struct us_data *us)
return;
}
/* if the transport provided its own sense data, don't auto-sense */
if (result == USB_STOR_TRANSPORT_NO_SENSE) {
srb->result = SAM_STAT_CHECK_CONDITION;
return;
}
/* Determine if we need to auto-sense
*
* I normally don't use a flag like this, but it's almost impossible
......@@ -764,7 +776,7 @@ int usb_stor_CBI_transport(Scsi_Cmnd *srb, struct us_data *us)
srb->request_buffer, transfer_length,
srb->use_sg, &srb->resid);
US_DEBUGP("CBI data stage result is 0x%x\n", result);
if (result == USB_STOR_XFER_ERROR)
if (result > USB_STOR_XFER_STALLED)
return USB_STOR_TRANSPORT_ERROR;
}
......@@ -854,7 +866,7 @@ int usb_stor_CB_transport(Scsi_Cmnd *srb, struct us_data *us)
srb->request_buffer, transfer_length,
srb->use_sg, &srb->resid);
US_DEBUGP("CB data stage result is 0x%x\n", result);
if (result == USB_STOR_XFER_ERROR)
if (result > USB_STOR_XFER_STALLED)
return USB_STOR_TRANSPORT_ERROR;
}
......@@ -899,6 +911,7 @@ int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us)
struct bulk_cs_wrap bcs;
unsigned int transfer_length = srb->request_bufflen;
int result;
int fake_sense = 0;
/* set up the command wrapper */
bcb.Signature = cpu_to_le32(US_BULK_CB_SIGN);
......@@ -936,6 +949,15 @@ int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us)
US_DEBUGP("Bulk data transfer result 0x%x\n", result);
if (result == USB_STOR_XFER_ERROR)
return USB_STOR_TRANSPORT_ERROR;
/* If the device tried to send back more data than the
* amount requested, the spec requires us to transfer
* the CSW anyway. Since there's no point retrying the
* the command, we'll return fake sense data indicating
* Illegal Request, Invalid Field in CDB.
*/
if (result == USB_STOR_XFER_LONG)
fake_sense = 1;
}
/* See flow chart on pg 15 of the Bulk Only Transport spec for
......@@ -975,6 +997,14 @@ int usb_stor_Bulk_transport(Scsi_Cmnd *srb, struct us_data *us)
/* based on the status code, we report good or bad */
switch (bcs.Status) {
case US_BULK_STAT_OK:
/* device babbled -- return fake sense data */
if (fake_sense) {
memcpy(srb->sense_buffer,
usb_stor_sense_invalidCDB,
sizeof(usb_stor_sense_invalidCDB));
return USB_STOR_TRANSPORT_NO_SENSE;
}
/* command good -- note that data could be short */
return USB_STOR_TRANSPORT_GOOD;
......
drivers/usb/storage/transport.h
View file @ 3935761c
......@@ -122,7 +122,8 @@ struct bulk_cs_wrap {
#define USB_STOR_XFER_GOOD 0 /* good transfer */
#define USB_STOR_XFER_SHORT 1 /* transferred less than expected */
#define USB_STOR_XFER_STALLED 2 /* endpoint stalled */
#define USB_STOR_XFER_ERROR 3 /* transfer died in the middle */
#define USB_STOR_XFER_LONG 3 /* device tried to send too much */
#define USB_STOR_XFER_ERROR 4 /* transfer died in the middle */
/*
* Transport return codes
......@@ -130,7 +131,8 @@ struct bulk_cs_wrap {
#define USB_STOR_TRANSPORT_GOOD 0 /* Transport good, command good */
#define USB_STOR_TRANSPORT_FAILED 1 /* Transport good, command failed */
#define USB_STOR_TRANSPORT_ERROR 2 /* Transport bad (i.e. device dead) */
#define USB_STOR_TRANSPORT_NO_SENSE 2 /* Command failed, no auto-sense */
#define USB_STOR_TRANSPORT_ERROR 3 /* Transport bad (i.e. device dead) */
/*
* We used to have USB_STOR_XFER_ABORTED and USB_STOR_TRANSPORT_ABORTED
......
drivers/usb/storage/usb.c
View file @ 3935761c
......@@ -3,10 +3,11 @@
* $Id: usb.c,v 1.75 2002/04/22 03:39:43 mdharm Exp $
*
* Current development and maintenance by:
* (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
* (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
*
* Developed with the assistance of:
* (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
* (c) 2003 Alan Stern (stern@rowland.harvard.edu)
*
* Initial work by:
* (c) 1999 Michael Gee (michael@linuxspecific.com)
......@@ -297,7 +298,7 @@ static int usb_stor_control_thread(void * __us)
/*
* This thread doesn't need any user-level access,
* so get rid of all our resources..
* so get rid of all our resources.
*/
daemonize("usb-storage");
......@@ -305,9 +306,6 @@ static int usb_stor_control_thread(void * __us)
unlock_kernel();
/* set up for wakeups by new commands */
init_MUTEX_LOCKED(&us->sema);
/* signal that we've started the thread */
complete(&(us->notify));
......@@ -366,17 +364,6 @@ static int usb_stor_control_thread(void * __us)
us->srb->result = DID_BAD_TARGET << 16;
}
/* handle requests for EVPD, which most USB devices do
* not support */
else if((us->srb->cmnd[0] == INQUIRY) &&
(us->srb->cmnd[1] & 0x1)) {
US_DEBUGP("Faking INQUIRY command for EVPD\n");
memcpy(us->srb->sense_buffer,
usb_stor_sense_invalidCDB,
sizeof(usb_stor_sense_invalidCDB));
us->srb->result = SAM_STAT_CHECK_CONDITION;
}
/* Handle those devices which need us to fake
* their inquiry data */
else if ((us->srb->cmnd[0] == INQUIRY) &&
......@@ -432,272 +419,60 @@ static int usb_stor_control_thread(void * __us)
return 0;
}
/* Set up the URB and the usb_ctrlrequest.
* us->dev_semaphore must already be locked.
* Note that this function assumes that all the data in the us_data
* structure is current.
* Returns non-zero on failure, zero on success
*/
static int usb_stor_allocate_urbs(struct us_data *us)
{
/* calculate and store the pipe values */
us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, us->ep_out);
us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, us->ep_in);
us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, us->ep_int);
/* allocate the usb_ctrlrequest for control packets */
US_DEBUGP("Allocating usb_ctrlrequest\n");
us->dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
if (!us->dr) {
US_DEBUGP("allocation failed\n");
return 1;
}
/* allocate the URB we're going to use */
US_DEBUGP("Allocating URB\n");
us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!us->current_urb) {
US_DEBUGP("allocation failed\n");
return 2;
}
US_DEBUGP("Allocating scatter-gather request block\n");
us->current_sg = kmalloc(sizeof(*us->current_sg), GFP_KERNEL);
if (!us->current_sg) {
US_DEBUGP("allocation failed\n");
return 5;
}
return 0; /* success */
}
/***********************************************************************
* Device probing and disconnecting
***********************************************************************/
/* Deallocate the URB, the usb_ctrlrequest, and the IRQ pipe.
* us->dev_semaphore must already be locked.
*/
static void usb_stor_deallocate_urbs(struct us_data *us)
/* Get the unusual_devs entries and the string descriptors */
static void get_device_info(struct us_data *us,
struct us_unusual_dev *unusual_dev)
{
/* free the scatter-gather request block */
if (us->current_sg) {
kfree(us->current_sg);
us->current_sg = NULL;
}
/* free up the main URB for this device */
if (us->current_urb) {
US_DEBUGP("-- releasing main URB\n");
usb_free_urb(us->current_urb);
us->current_urb = NULL;
}
struct usb_device *dev = us->pusb_dev;
/* free the usb_ctrlrequest buffer */
if (us->dr) {
kfree(us->dr);
us->dr = NULL;
}
/* mark the device as gone */
usb_put_dev(us->pusb_dev);
us->pusb_dev = NULL;
}
/* Probe to see if a new device is actually a SCSI device */
static int storage_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev(intf);
int ifnum = intf->altsetting->desc.bInterfaceNumber;
int i;
const int id_index = id - storage_usb_ids;
char mf[USB_STOR_STRING_LEN]; /* manufacturer */
char prod[USB_STOR_STRING_LEN]; /* product */
char serial[USB_STOR_STRING_LEN]; /* serial number */
unsigned int flags;
struct us_unusual_dev *unusual_dev;
struct us_data *us = NULL;
int result;
/* these are temporary copies -- we test on these, then put them
* in the us-data structure
*/
struct usb_endpoint_descriptor *ep_in = NULL;
struct usb_endpoint_descriptor *ep_out = NULL;
struct usb_endpoint_descriptor *ep_int = NULL;
u8 subclass = 0;
u8 protocol = 0;
/* the altsetting on the interface we're probing that matched our
* usb_match_id table
*/
struct usb_host_interface *altsetting =
intf[ifnum].altsetting + intf[ifnum].act_altsetting;
US_DEBUGP("act_altsetting is %d\n", intf[ifnum].act_altsetting);
/* clear the temporary strings */
memset(mf, 0, sizeof(mf));
memset(prod, 0, sizeof(prod));
memset(serial, 0, sizeof(serial));
/*
* Can we support this device, either because we know about it
* from our unusual device list, or because it advertises that it's
* compliant to the specification?
*
* id_index is calculated in the declaration to be the index number
* of the match from the usb_device_id table, so we can find the
* corresponding entry in the private table.
*/
US_DEBUGP("id_index calculated to be: %d\n", id_index);
US_DEBUGP("Array length appears to be: %d\n", sizeof(us_unusual_dev_list) / sizeof(us_unusual_dev_list[0]));
if (id_index <
sizeof(us_unusual_dev_list) / sizeof(us_unusual_dev_list[0])) {
unusual_dev = &us_unusual_dev_list[id_index];
if (unusual_dev->vendorName)
US_DEBUGP("Vendor: %s\n", unusual_dev->vendorName);
if (unusual_dev->productName)
US_DEBUGP("Product: %s\n", unusual_dev->productName);
} else
/* no, we can't support it */
return -EIO;
/* At this point, we know we've got a live one */
US_DEBUGP("USB Mass Storage device detected\n");
/* Determine subclass and protocol, or copy from the interface */
subclass = unusual_dev->useProtocol;
protocol = unusual_dev->useTransport;
flags = unusual_dev->flags;
/*
* Find the endpoints we need
* We are expecting a minimum of 2 endpoints - in and out (bulk).
* An optional interrupt is OK (necessary for CBI protocol).
* We will ignore any others.
*/
for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
struct usb_endpoint_descriptor *ep;
ep = &altsetting->endpoint[i].desc;
/* is it an BULK endpoint? */
if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
== USB_ENDPOINT_XFER_BULK) {
/* BULK in or out? */
if (ep->bEndpointAddress & USB_DIR_IN)
ep_in = ep;
else
ep_out = ep;
}
/* is it an interrupt endpoint? */
else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
== USB_ENDPOINT_XFER_INT) {
ep_int = ep;
}
}
US_DEBUGP("Endpoints: In: 0x%p Out: 0x%p Int: 0x%p (Period %d)\n",
ep_in, ep_out, ep_int, ep_int ? ep_int->bInterval : 0);
#ifdef CONFIG_USB_STORAGE_SDDR09
if (protocol == US_PR_EUSB_SDDR09 || protocol == US_PR_DPCM_USB) {
/* set the configuration -- STALL is an acceptable response here */
result = usb_set_configuration(dev, 1);
US_DEBUGP("Result from usb_set_configuration is %d\n", result);
if (result == -EPIPE) {
US_DEBUGP("-- stall on control interface\n");
} else if (result != 0) {
/* it's not a stall, but another error -- time to bail */
US_DEBUGP("-- Unknown error. Rejecting device\n");
return -EIO;
}
}
#endif
/* Do some basic sanity checks, and bail if we find a problem */
if (!ep_in || !ep_out || (protocol == US_PR_CBI && !ep_int)) {
US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
return -EIO;
}
/* At this point, we've decided to try to use the device */
usb_get_dev(dev);
/* Store the entries */
us->unusual_dev = unusual_dev;
us->subclass = unusual_dev->useProtocol;
us->protocol = unusual_dev->useTransport;
us->flags = unusual_dev->flags;
/* fetch the strings */
/* Read the device's string descriptors */
if (dev->descriptor.iManufacturer)
usb_string(dev, dev->descriptor.iManufacturer,
mf, sizeof(mf));
us->vendor, sizeof(us->vendor));
if (dev->descriptor.iProduct)
usb_string(dev, dev->descriptor.iProduct,
prod, sizeof(prod));
if (dev->descriptor.iSerialNumber && !(flags & US_FL_IGNORE_SER))
us->product, sizeof(us->product));
if (dev->descriptor.iSerialNumber && !(us->flags & US_FL_IGNORE_SER))
usb_string(dev, dev->descriptor.iSerialNumber,
serial, sizeof(serial));
/* New device -- allocate memory and initialize */
if ((us = (struct us_data *)kmalloc(sizeof(struct us_data),
GFP_KERNEL)) == NULL) {
printk(KERN_WARNING USB_STORAGE "Out of memory\n");
usb_put_dev(dev);
return -ENOMEM;
}
memset(us, 0, sizeof(struct us_data));
/* Initialize the mutexes only when the struct is new */
init_completion(&(us->notify));
init_MUTEX_LOCKED(&(us->dev_semaphore));
/* copy over the subclass and protocol data */
us->subclass = subclass;
us->protocol = protocol;
us->flags = flags;
us->unusual_dev = unusual_dev;
us->serial, sizeof(us->serial));
/* copy over the endpoint data */
us->ep_in = ep_in->bEndpointAddress &
USB_ENDPOINT_NUMBER_MASK;
us->ep_out = ep_out->bEndpointAddress &
USB_ENDPOINT_NUMBER_MASK;
if (ep_int) {
us->ep_int = ep_int->bEndpointAddress &
USB_ENDPOINT_NUMBER_MASK;
us->ep_bInterval = ep_int->bInterval;
}
else
us->ep_int = us->ep_bInterval = 0;
/* establish the connection to the new device */
us->ifnum = ifnum;
us->pusb_dev = dev;
/* copy over the identifiying strings */
strncpy(us->vendor, mf, USB_STOR_STRING_LEN);
strncpy(us->product, prod, USB_STOR_STRING_LEN);
strncpy(us->serial, serial, USB_STOR_STRING_LEN);
/* Use the unusual_dev strings if the device didn't provide them */
if (strlen(us->vendor) == 0) {
if (unusual_dev->vendorName)
strncpy(us->vendor, unusual_dev->vendorName,
USB_STOR_STRING_LEN);
sizeof(us->vendor) - 1);
else
strncpy(us->vendor, "Unknown",
USB_STOR_STRING_LEN);
strcpy(us->vendor, "Unknown");
}
if (strlen(us->product) == 0) {
if (unusual_dev->productName)
strncpy(us->product, unusual_dev->productName,
USB_STOR_STRING_LEN);
sizeof(us->product) - 1);
else
strncpy(us->product, "Unknown",
USB_STOR_STRING_LEN);
strcpy(us->product, "Unknown");
}
if (strlen(us->serial) == 0)
strncpy(us->serial, "None", USB_STOR_STRING_LEN);
strcpy(us->serial, "None");
}
/*
* Set the handler pointers based on the protocol
* Again, this data is persistent across reattachments
*/
/* Get the transport settings */
static int get_transport(struct us_data *us)
{
switch (us->protocol) {
case US_PR_CB:
us->transport_name = "Control/Bulk";
......@@ -783,15 +558,19 @@ static int storage_probe(struct usb_interface *intf,
#endif
default:
/* us->transport_name = "Unknown"; */
goto BadDevice;
return -EIO;
}
US_DEBUGP("Transport: %s\n", us->transport_name);
/* fix for single-lun devices */
if (us->flags & US_FL_SINGLE_LUN)
us->max_lun = 0;
return 0;
}
/* Get the protocol settings */
static int get_protocol(struct us_data *us)
{
switch (us->subclass) {
case US_SC_RBC:
us->protocol_name = "Reduced Block Commands (RBC)";
......@@ -834,173 +613,335 @@ static int storage_probe(struct usb_interface *intf,
#endif
default:
/* us->protocol_name = "Unknown"; */
goto BadDevice;
return -EIO;
}
US_DEBUGP("Protocol: %s\n", us->protocol_name);
return 0;
}
/* allocate the URB, the usb_ctrlrequest, and the IRQ URB */
if (usb_stor_allocate_urbs(us))
goto BadDevice;
/* Get the pipe settings */
static int get_pipes(struct us_data *us)
{
struct usb_host_interface *altsetting =
&us->pusb_intf->altsetting[us->pusb_intf->act_altsetting];
int i;
struct usb_endpoint_descriptor *ep;
struct usb_endpoint_descriptor *ep_in = NULL;
struct usb_endpoint_descriptor *ep_out = NULL;
struct usb_endpoint_descriptor *ep_int = NULL;
/*
* Find the endpoints we need.
* We are expecting a minimum of 2 endpoints - in and out (bulk).
* An optional interrupt is OK (necessary for CBI protocol).
* We will ignore any others.
*/
for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
ep = &altsetting->endpoint[i].desc;
/* Is it a BULK endpoint? */
if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
== USB_ENDPOINT_XFER_BULK) {
/* BULK in or out? */
if (ep->bEndpointAddress & USB_DIR_IN)
ep_in = ep;
else
ep_out = ep;
}
/* Is it an interrupt endpoint? */
else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
== USB_ENDPOINT_XFER_INT) {
ep_int = ep;
}
}
US_DEBUGP("Endpoints: In: 0x%p Out: 0x%p Int: 0x%p (Period %d)\n",
ep_in, ep_out, ep_int, ep_int ? ep_int->bInterval : 0);
if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
return -EIO;
}
/* Calculate and store the pipe values */
us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
if (ep_int) {
us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
us->ep_bInterval = ep_int->bInterval;
}
return 0;
}
/* Initialize all the dynamic resources we need */
static int usb_stor_acquire_resources(struct us_data *us)
{
int p;
/* Allocate the USB control blocks */
US_DEBUGP("Allocating usb_ctrlrequest\n");
us->dr = kmalloc(sizeof(*us->dr), GFP_KERNEL);
if (!us->dr) {
US_DEBUGP("allocation failed\n");
return -ENOMEM;
}
US_DEBUGP("Allocating URB\n");
us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!us->current_urb) {
US_DEBUGP("allocation failed\n");
return -ENOMEM;
}
US_DEBUGP("Allocating scatter-gather request block\n");
us->current_sg = kmalloc(sizeof(*us->current_sg), GFP_KERNEL);
if (!us->current_sg) {
US_DEBUGP("allocation failed\n");
return -ENOMEM;
}
/* Lock the device while we carry out the next two operations */
down(&us->dev_semaphore);
/* For bulk-only devices, determine the max LUN value */
if (us->protocol == US_PR_BULK)
us->max_lun = usb_stor_Bulk_max_lun(us);
/*
* Since this is a new device, we need to generate a scsi
* host definition, and register with the higher SCSI layers
*/
/* Just before we start our control thread, initialize
* the device if it needs initialization */
if (unusual_dev && unusual_dev->initFunction)
unusual_dev->initFunction(us);
if (us->unusual_dev->initFunction)
us->unusual_dev->initFunction(us);
/* start up our control thread */
up(&us->dev_semaphore);
/* Start up our control thread */
atomic_set(&us->sm_state, US_STATE_IDLE);
us->pid = kernel_thread(usb_stor_control_thread, us,
CLONE_VM);
if (us->pid < 0) {
p = kernel_thread(usb_stor_control_thread, us, CLONE_VM);
if (p < 0) {
printk(KERN_WARNING USB_STORAGE
"Unable to start control thread\n");
goto BadDevice;
return p;
}
us->pid = p;
/* wait for the thread to start */
/* Wait for the thread to start */
wait_for_completion(&(us->notify));
/* unlock the device pointers */
up(&(us->dev_semaphore));
/* now register */
/*
* Since this is a new device, we need to register a SCSI
* host definition with the higher SCSI layers.
*/
us->host = scsi_register(&usb_stor_host_template, sizeof(us));
if (!us->host) {
printk(KERN_WARNING USB_STORAGE
"Unable to register the scsi host\n");
return -EBUSY;
}
/* tell the control thread to exit */
us->srb = NULL;
up(&us->sema);
wait_for_completion(&us->notify);
/* Set the hostdata to prepare for scanning */
us->host->hostdata[0] = (unsigned long) us;
return 0;
}
/* re-lock the device pointers */
/* Dissociate from the USB device */
static void dissociate_dev(struct us_data *us)
{
US_DEBUGP("-- %s\n", __FUNCTION__);
down(&us->dev_semaphore);
usb_set_intfdata(us->pusb_intf, NULL);
usb_put_dev(us->pusb_dev);
us->pusb_dev = NULL;
us->pusb_intf = NULL;
up(&us->dev_semaphore);
}
/* Release all our static and dynamic resources */
void usb_stor_release_resources(struct us_data *us)
{
/*
* The host must already have been removed
* and dissociate_dev() must have been called.
*/
/* Finish the SCSI host removal sequence */
if (us->host) {
(struct us_data *) us->host->hostdata[0] = NULL;
scsi_unregister(us->host);
}
/* Kill the control thread
*
* Enqueue the command, wake up the thread, and wait for
* notification that it has exited.
*/
if (us->pid) {
US_DEBUGP("-- sending exit command to thread\n");
BUG_ON(atomic_read(&us->sm_state) != US_STATE_IDLE);
us->srb = NULL;
up(&(us->sema));
wait_for_completion(&(us->notify));
}
/* Call the destructor routine, if it exists */
if (us->extra_destructor) {
US_DEBUGP("-- calling extra_destructor()\n");
us->extra_destructor(us->extra);
}
/* Destroy the extra data */
if (us->extra) {
kfree(us->extra);
}
/* Free the USB control blocks */
if (us->current_sg)
kfree(us->current_sg);
if (us->current_urb)
usb_free_urb(us->current_urb);
if (us->dr)
kfree(us->dr);
/* Free the structure itself */
kfree(us);
US_DEBUGP("-- %s finished\n", __FUNCTION__);
}
/* Probe to see if we can drive a newly-connected USB device */
static int storage_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct us_data *us;
const int id_index = id - storage_usb_ids;
int result;
US_DEBUGP("USB Mass Storage device detected\n");
US_DEBUGP("act_altsetting is %d, id_index is %d\n",
intf->act_altsetting, id_index);
/* Allocate the us_data structure and initialize the mutexes */
us = (struct us_data *) kmalloc(sizeof(*us), GFP_KERNEL);
if (!us) {
printk(KERN_WARNING USB_STORAGE "Out of memory\n");
return -ENOMEM;
}
memset(us, 0, sizeof(struct us_data));
init_MUTEX(&(us->dev_semaphore));
init_MUTEX_LOCKED(&(us->sema));
init_completion(&(us->notify));
/* Fill in the device-related fields */
us->pusb_dev = interface_to_usbdev(intf);
us->pusb_intf = intf;
us->ifnum = intf->altsetting->desc.bInterfaceNumber;
/* Store our private data in the interface and increment the
* device's reference count */
usb_set_intfdata(intf, us);
usb_get_dev(us->pusb_dev);
/*
* Get the unusual_devs entries and the descriptors
*
* id_index is calculated in the declaration to be the index number
* of the match from the usb_device_id table, so we can find the
* corresponding entry in the private table.
*/
get_device_info(us, &us_unusual_dev_list[id_index]);
#ifdef CONFIG_USB_STORAGE_SDDR09
if (us->protocol == US_PR_EUSB_SDDR09 ||
us->protocol == US_PR_DPCM_USB) {
/* set the configuration -- STALL is an acceptable response here */
result = usb_set_configuration(us->pusb_dev, 1);
US_DEBUGP("Result from usb_set_configuration is %d\n", result);
if (result == -EPIPE) {
US_DEBUGP("-- stall on control interface\n");
} else if (result != 0) {
/* it's not a stall, but another error -- time to bail */
US_DEBUGP("-- Unknown error. Rejecting device\n");
goto BadDevice;
}
}
#endif
/* set the hostdata to prepare for scanning */
us->host->hostdata[0] = (unsigned long)us;
/* Get the transport, protocol, and pipe settings */
result = get_transport(us);
if (result)
goto BadDevice;
result = get_protocol(us);
if (result)
goto BadDevice;
result = get_pipes(us);
if (result)
goto BadDevice;
/* Acquire all the other resources */
result = usb_stor_acquire_resources(us);
if (result)
goto BadDevice;
/* now add the host */
/* Finally, add the host (this does SCSI device scanning) */
result = scsi_add_host(us->host, &intf->dev);
if (result) {
printk(KERN_WARNING USB_STORAGE
"Unable to add the scsi host\n");
/* tell the control thread to exit */
us->srb = NULL;
up(&us->sema);
wait_for_completion(&us->notify);
/* re-lock the device pointers */
down(&us->dev_semaphore);
goto BadDevice;
}
printk(KERN_DEBUG
"WARNING: USB Mass Storage data integrity not assured\n");
printk(KERN_DEBUG
"USB Mass Storage device found at %d\n", dev->devnum);
/* save a pointer to our structure */
usb_set_intfdata(intf, us);
"USB Mass Storage device found at %d\n", us->pusb_dev->devnum);
return 0;
/* we come here if there are any problems */
/* us->dev_semaphore must be locked */
/* We come here if there are any problems */
BadDevice:
US_DEBUGP("storage_probe() failed\n");
usb_stor_deallocate_urbs(us);
up(&us->dev_semaphore);
kfree(us);
return -EIO;
dissociate_dev(us);
usb_stor_release_resources(us);
return result;
}
/* Handle a disconnect event from the USB core */
static void storage_disconnect(struct usb_interface *intf)
{
struct us_data *us;
struct us_data *us = usb_get_intfdata(intf);
struct scsi_device *sdev;
US_DEBUGP("storage_disconnect() called\n");
us = usb_get_intfdata(intf);
usb_set_intfdata(intf, NULL);
/* set devices offline -- need host lock for this */
/* Set devices offline -- need host lock for this */
scsi_lock(us->host);
list_for_each_entry(sdev, &us->host->my_devices, siblings)
sdev->online = 0;
scsi_unlock(us->host);
/* prevent new USB transfers and stop the current command */
/* Prevent new USB transfers and stop the current command */
set_bit(US_FLIDX_DISCONNECTING, &us->flags);
usb_stor_stop_transport(us);
/* lock device access -- no need to unlock, as we're going away */
down(&(us->dev_semaphore));
/* TODO: somehow, wait for the device to
* be 'idle' (tasklet completion) */
/* remove the pointer to the data structure we were using */
(struct us_data*)us->host->hostdata[0] = NULL;
/* Dissociate from the USB device */
dissociate_dev(us);
/* begin SCSI host removal sequence */
if(scsi_remove_host(us->host)) {
US_DEBUGP("-- SCSI refused to unregister\n");
/* Begin the SCSI host removal sequence */
if (scsi_remove_host(us->host)) {
US_DEBUGP("-- SCSI refused to remove the host\n");
BUG();
return;
};
/* finish SCSI host removal sequence */
scsi_unregister(us->host);
/* Kill the control threads
*
* Enqueue the command, wake up the thread, and wait for
* notification that it has exited.
*/
US_DEBUGP("-- sending exit command to thread\n");
BUG_ON(atomic_read(&us->sm_state) != US_STATE_IDLE);
us->srb = NULL;
up(&(us->sema));
wait_for_completion(&(us->notify));
/* free allocated urbs */
usb_stor_deallocate_urbs(us);
/* If there's extra data in the us_data structure then
* free that first */
if (us->extra) {
/* call the destructor routine, if it exists */
if (us->extra_destructor) {
US_DEBUGP("-- calling extra_destructor()\n");
us->extra_destructor(us->extra);
}
/* destroy the extra data */
US_DEBUGP("-- freeing the data structure\n");
kfree(us->extra);
}
/* up the semaphore so auto-code-checkers won't complain about
* the down/up imbalance */
up(&(us->dev_semaphore));
/* TODO: somehow, wait for the device to
* be 'idle' (tasklet completion) */
/* free the structure itself */
kfree (us);
/* Release all our other resources */
usb_stor_release_resources(us);
}
/***********************************************************************
......
drivers/usb/storage/usb.h
View file @ 3935761c
......@@ -107,6 +107,7 @@ struct us_data {
*/
struct semaphore dev_semaphore; /* protect pusb_dev */
struct usb_device *pusb_dev; /* this usb_device */
struct usb_interface *pusb_intf; /* this interface */
unsigned long flags; /* from filter initially */
unsigned int send_bulk_pipe; /* cached pipe values */
unsigned int recv_bulk_pipe;
......@@ -114,7 +115,7 @@ struct us_data {
unsigned int recv_ctrl_pipe;
unsigned int recv_intr_pipe;
/* information about the device -- always good */
/* information about the device */
char vendor[USB_STOR_STRING_LEN];
char product[USB_STOR_STRING_LEN];
char serial[USB_STOR_STRING_LEN];
......@@ -124,11 +125,7 @@ struct us_data {
u8 protocol;
u8 max_lun;
/* information about the device -- only good if device is attached */
u8 ifnum; /* interface number */
u8 ep_in; /* bulk in endpoint */
u8 ep_out; /* bulk out endpoint */
u8 ep_int; /* interrupt endpoint */
u8 ep_bInterval; /* interrupt interval */
/* function pointers for this device */
......
fs/sysfs/file.c
View file @ 3935761c
......@@ -84,7 +84,7 @@ static int fill_read_buffer(struct file * file, struct sysfs_buffer * buffer)
ssize_t count;
if (!buffer->page)
buffer->page = (char *) __get_free_page(GFP_KERNEL);
buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
if (!buffer->page)
return -ENOMEM;
......@@ -174,7 +174,7 @@ fill_write_buffer(struct sysfs_buffer * buffer, const char * buf, size_t count)
int error;
if (!buffer->page)
buffer->page = (char *)__get_free_page(GFP_KERNEL);
buffer->page = (char *)get_zeroed_page(GFP_KERNEL);
if (!buffer->page)
return -ENOMEM;
......
include/linux/cpu.h
View file @ 3935761c
......@@ -19,7 +19,7 @@
#ifndef _LINUX_CPU_H_
#define _LINUX_CPU_H_
#include <linux/device.h>
#include <linux/sysdev.h>
#include <linux/node.h>
#include <asm/semaphore.h>
......@@ -29,8 +29,6 @@ struct cpu {
};
extern int register_cpu(struct cpu *, int, struct node *);
extern struct class cpu_class;
struct notifier_block;
#ifdef CONFIG_SMP
......@@ -48,6 +46,7 @@ static inline void unregister_cpu_notifier(struct notifier_block *nb)
{
}
#endif /* CONFIG_SMP */
extern struct sysdev_class cpu_sysdev_class;
/* Stop CPUs going up and down. */
extern struct semaphore cpucontrol;
......
include/linux/cpufreq.h
View file @ 3935761c
......@@ -205,10 +205,6 @@ struct freq_attr {
int cpufreq_set_policy(struct cpufreq_policy *policy);
int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
#ifdef CONFIG_PM
int cpufreq_restore(void);
#endif
/* the proc_intf.c needs this */
int cpufreq_parse_governor (char *str_governor, unsigned int *policy, struct cpufreq_governor **governor);
......
include/linux/device.h
View file @ 3935761c
......@@ -351,30 +351,6 @@ extern int (*platform_notify_remove)(struct device * dev);
extern struct device * get_device(struct device * dev);
extern void put_device(struct device * dev);
/* drivers/base/sys.c */
struct sys_root {
u32 id;
struct device dev;
struct device sysdev;
};
extern int sys_register_root(struct sys_root *);
extern void sys_unregister_root(struct sys_root *);
struct sys_device {
char * name;
u32 id;
struct sys_root * root;
struct device dev;
struct class_device class_dev;
};
extern int sys_device_register(struct sys_device *);
extern void sys_device_unregister(struct sys_device *);
extern struct bus_type system_bus_type;
/* drivers/base/platform.c */
......
include/linux/kobject.h
View file @ 3935761c
......@@ -118,6 +118,14 @@ static inline struct kobj_type * get_ktype(struct kobject * k)
extern struct kobject * kset_find_obj(struct kset *, const char *);
/**
* Use this when initializing an embedded kset with no other
* fields to initialize.
*/
#define set_kset_name(str) .kset = { .kobj = { .name = str } }
struct subsystem {
struct kset kset;
struct rw_semaphore rwsem;
......
include/linux/list.h
View file @ 3935761c
......@@ -309,6 +309,20 @@ static inline void list_splice_init(struct list_head *list,
pos = list_entry(pos->member.next, typeof(*pos), member), \
prefetch(pos->member.next))
/**
* list_for_each_entry_reverse - iterate backwards over list of given type.
* @pos: the type * to use as a loop counter.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
#define list_for_each_entry_reverse(pos, head, member) \
for (pos = list_entry((head)->prev, typeof(*pos), member), \
prefetch(pos->member.prev); \
&pos->member != (head); \
pos = list_entry(pos->member.prev, typeof(*pos), member), \
prefetch(pos->member.prev))
/**
* list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @pos: the type * to use as a loop counter.
......
include/linux/node.h
View file @ 3935761c
......@@ -19,11 +19,11 @@
#ifndef _LINUX_NODE_H_
#define _LINUX_NODE_H_
#include <linux/device.h>
#include <linux/sysdev.h>
struct node {
unsigned long cpumap; /* Bitmap of CPUs on the Node */
struct sys_root sysroot;
struct sys_device sysdev;
};
extern int register_node(struct node *, int, struct node *);
......
include/linux/sysdev.h 0 → 100644
View file @ 3935761c
/**
* System devices follow a slightly different driver model.
* They don't need to do dynammic driver binding, can't be probed,
* and don't reside on any type of peripheral bus.
* So, we represent and treat them a little differently.
*
* We still have a notion of a driver for a system device, because we still
* want to perform basic operations on these devices.
*
* We also support auxillary drivers binding to devices of a certain class.
*
* This allows configurable drivers to register themselves for devices of
* a certain type. And, it allows class definitions to reside in generic
* code while arch-specific code can register specific drivers.
*
* Auxillary drivers registered with a NULL cls are registered as drivers
* for all system devices, and get notification calls for each device.
*/
#ifndef _SYSDEV_H_
#define _SYSDEV_H_
#include <linux/kobject.h>
struct sys_device;
struct sysdev_class {
struct list_head drivers;
/* Default operations for these types of devices */
int (*shutdown)(struct sys_device *);
int (*save)(struct sys_device *, u32 state);
int (*suspend)(struct sys_device *, u32 state);
int (*resume)(struct sys_device *);
int (*restore)(struct sys_device *);
struct kset kset;
};
extern int sysdev_class_register(struct sysdev_class *);
extern void sysdev_class_unregister(struct sysdev_class *);
/**
* Auxillary system device drivers.
*/
struct sysdev_driver {
struct list_head entry;
int (*add)(struct sys_device *);
int (*remove)(struct sys_device *);
int (*shutdown)(struct sys_device *);
int (*save)(struct sys_device *, u32 state);
int (*suspend)(struct sys_device *, u32 state);
int (*resume)(struct sys_device *);
int (*restore)(struct sys_device *);
};
extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);
/**
* sys_devices can be simplified a lot from regular devices, because they're
* simply not as versatile.
*/
struct sys_device {
u32 id;
struct sysdev_class * cls;
struct kobject kobj;
};
extern int sys_device_register(struct sys_device *);
extern void sys_device_unregister(struct sys_device *);
struct sysdev_attribute {
struct attribute attr;
ssize_t (*show)(struct sys_device *, char *);
ssize_t (*store)(struct sys_device *, const char *, size_t);
};
#define SYSDEV_ATTR(_name,_mode,_show,_store) \
struct sysdev_attribute attr_##_name = { \
.attr = {.name = __stringify(_name), .mode = _mode }, \
.show = _show, \
.store = _store, \
};
extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
#endif /* _SYSDEV_H_ */
include/linux/usb.h
View file @ 3935761c
......@@ -136,7 +136,7 @@ static inline void *usb_get_intfdata (struct usb_interface *intf)
static inline void usb_set_intfdata (struct usb_interface *intf, void *data)
{
return dev_set_drvdata (&intf->dev, data);
dev_set_drvdata(&intf->dev, data);
}
/* USB_DT_CONFIG: Configuration descriptor information.
......
include/linux/usbdevice_fs.h
View file @ 3935761c
......@@ -46,14 +46,14 @@ struct usbdevfs_ctrltransfer {
__u16 wIndex;
__u16 wLength;
__u32 timeout; /* in milliseconds */
void *data;
void __user *data;
};
struct usbdevfs_bulktransfer {
unsigned int ep;
unsigned int len;
unsigned int timeout; /* in milliseconds */
void *data;
void __user *data;
};
struct usbdevfs_setinterface {
......@@ -97,7 +97,7 @@ struct usbdevfs_urb {
unsigned char endpoint;
int status;
unsigned int flags;
void *buffer;
void __user *buffer;
int buffer_length;
int actual_length;
int start_frame;
......@@ -113,7 +113,7 @@ struct usbdevfs_ioctl {
int ifno; /* interface 0..N ; negative numbers reserved */
int ioctl_code; /* MUST encode size + direction of data so the
* macros in <asm/ioctl.h> give correct values */
void *data; /* param buffer (in, or out) */
void __user *data; /* param buffer (in, or out) */
};
/* You can do most things with hubs just through control messages,
......
kernel/cpufreq.c
View file @ 3935761c
......@@ -49,8 +49,6 @@ static DECLARE_RWSEM (cpufreq_notifier_rwsem);
static LIST_HEAD(cpufreq_governor_list);
static DECLARE_MUTEX (cpufreq_governor_sem);
static struct class_interface cpufreq_interface;
static int cpufreq_cpu_get(unsigned int cpu)
{
if (cpu >= NR_CPUS)
......@@ -113,24 +111,8 @@ int cpufreq_parse_governor (char *str_governor, unsigned int *policy,
EXPORT_SYMBOL_GPL(cpufreq_parse_governor);
/* forward declarations */
static int cpufreq_add_dev (struct class_device * dev);
static void cpufreq_remove_dev (struct class_device * dev);
/* drivers/base/cpu.c */
extern struct device_class cpu_devclass;
static struct class_interface cpufreq_interface = {
.class = &cpu_class,
.add = &cpufreq_add_dev,
.remove = &cpufreq_remove_dev,
};
static inline int to_cpu_nr (struct class_device *dev)
{
struct sys_device * cpu_sys_dev = container_of(dev->dev, struct sys_device, dev);
return (cpu_sys_dev->id);
}
extern struct sysdev_class cpu_sysdev_class;
/**
......@@ -331,9 +313,9 @@ static struct kobj_type ktype_cpufreq = {
*
* Adds the cpufreq interface for a CPU device.
*/
static int cpufreq_add_dev (struct class_device * class_dev)
static int cpufreq_add_dev (struct sys_device * sys_dev)
{
unsigned int cpu = to_cpu_nr(class_dev);
unsigned int cpu = sys_dev->id;
int ret = 0;
struct cpufreq_policy new_policy;
struct cpufreq_policy *policy;
......@@ -358,14 +340,12 @@ static int cpufreq_add_dev (struct class_device * class_dev)
memcpy(&new_policy,
policy,
sizeof(struct cpufreq_policy));
class_set_devdata(class_dev, policy);
up(&cpufreq_driver_sem);
init_MUTEX(&policy->lock);
/* prepare interface data */
policy->kobj.parent = &class_dev->kobj;
policy->kobj.parent = &sys_dev->kobj;
policy->kobj.ktype = &ktype_cpufreq;
// policy->dev = dev->dev;
strlcpy(policy->kobj.name, "cpufreq", KOBJ_NAME_LEN);
ret = kobject_register(&policy->kobj);
......@@ -396,12 +376,12 @@ static int cpufreq_add_dev (struct class_device * class_dev)
*
* Removes the cpufreq interface for a CPU device.
*/
static void cpufreq_remove_dev (struct class_device * class_dev)
static int cpufreq_remove_dev (struct sys_device * sys_dev)
{
unsigned int cpu = to_cpu_nr(class_dev);
unsigned int cpu = sys_dev->id;
if (!kobject_get(&cpufreq_driver->policy[cpu].kobj))
return;
return -EFAULT;
down(&cpufreq_driver_sem);
if ((cpufreq_driver->target) &&
......@@ -421,9 +401,17 @@ static void cpufreq_remove_dev (struct class_device * class_dev)
up(&cpufreq_driver_sem);
kobject_put(&cpufreq_driver->policy[cpu].kobj);
return;
return 0;
}
static int cpufreq_restore(struct sys_device *);
static struct sysdev_driver cpufreq_sysdev_driver = {
.add = cpufreq_add_dev,
.remove = cpufreq_remove_dev,
.restore = cpufreq_restore,
};
/*********************************************************************
* NOTIFIER LISTS INTERFACE *
......@@ -843,7 +831,7 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data)
memset(cpufreq_driver->policy, 0, NR_CPUS * sizeof(struct cpufreq_policy));
return class_interface_register(&cpufreq_interface);
return sysdev_driver_register(&cpu_sysdev_class,&cpufreq_sysdev_driver);
}
EXPORT_SYMBOL_GPL(cpufreq_register_driver);
......@@ -861,7 +849,7 @@ int cpufreq_unregister_driver(struct cpufreq_driver *driver)
if (!cpufreq_driver || (driver != cpufreq_driver))
return -EINVAL;
class_interface_unregister(&cpufreq_interface);
sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
down(&cpufreq_driver_sem);
kfree(cpufreq_driver->policy);
......@@ -874,41 +862,34 @@ EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
#ifdef CONFIG_PM
/**
* cpufreq_restore - restore the CPU clock frequency after resume
*
* Restore the CPU clock frequency so that our idea of the current
* frequency reflects the actual hardware.
*/
int cpufreq_restore(void)
static int cpufreq_restore(struct sys_device * sysdev)
{
struct cpufreq_policy policy;
unsigned int i;
int cpu = sysdev->id;
unsigned int ret = 0;
struct cpufreq_policy policy;
if (in_interrupt())
panic("cpufreq_restore() called from interrupt context!");
if (!try_module_get(cpufreq_driver->owner))
goto error_out;
for (i=0;i<NR_CPUS;i++) {
if (!cpu_online(i) || !cpufreq_cpu_get(i))
continue;
if (cpu_online(cpu) && cpufreq_cpu_get(cpu)) {
down(&cpufreq_driver_sem);
memcpy(&policy, &cpufreq_driver->policy[i], sizeof(struct cpufreq_policy));
memcpy(&policy, &cpufreq_driver->policy[cpu],
sizeof(struct cpufreq_policy));
up(&cpufreq_driver_sem);
ret += cpufreq_set_policy(&policy);
cpufreq_cpu_put(i);
ret = cpufreq_set_policy(&policy);
cpufreq_cpu_put(cpu);
}
module_put(cpufreq_driver->owner);
error_out:
return ret;
}
EXPORT_SYMBOL_GPL(cpufreq_restore);
#else
#define cpufreq_restore() do {} while (0)
static int cpufreq_restore(struct sys_device * sysdev)
{
return 0;
}
#endif /* CONFIG_PM */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7