Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 7 Jan 2009 01:02:07 +0000 (17:02 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 7 Jan 2009 01:02:07 +0000 (17:02 -0800)
* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6: (60 commits)
  uio: make uio_info's name and version const
  UIO: Documentation for UIO ioport info handling
  UIO: Pass information about ioports to userspace (V2)
  UIO: uio_pdrv_genirq: allow custom irq_flags
  UIO: use pci_ioremap_bar() in drivers/uio
  arm: struct device - replace bus_id with dev_name(), dev_set_name()
  libata: struct device - replace bus_id with dev_name(), dev_set_name()
  avr: struct device - replace bus_id with dev_name(), dev_set_name()
  block: struct device - replace bus_id with dev_name(), dev_set_name()
  chris: struct device - replace bus_id with dev_name(), dev_set_name()
  dmi: struct device - replace bus_id with dev_name(), dev_set_name()
  gadget: struct device - replace bus_id with dev_name(), dev_set_name()
  gpio: struct device - replace bus_id with dev_name(), dev_set_name()
  gpu: struct device - replace bus_id with dev_name(), dev_set_name()
  hwmon: struct device - replace bus_id with dev_name(), dev_set_name()
  i2o: struct device - replace bus_id with dev_name(), dev_set_name()
  IA64: struct device - replace bus_id with dev_name(), dev_set_name()
  i7300_idle: struct device - replace bus_id with dev_name(), dev_set_name()
  infiniband: struct device - replace bus_id with dev_name(), dev_set_name()
  ISDN: struct device - replace bus_id with dev_name(), dev_set_name()
  ...

129 files changed:
Documentation/DocBook/uio-howto.tmpl
Documentation/kobject.txt
arch/arm/kernel/ecard.c
arch/arm/mach-aaec2000/core.c
arch/arm/mach-ep93xx/core.c
arch/arm/mach-integrator/core.c
arch/arm/mach-integrator/integrator_cp.c
arch/arm/mach-lh7a40x/clcd.c
arch/arm/mach-netx/fb.c
arch/arm/mach-realview/core.h
arch/arm/mach-versatile/core.h
arch/arm/plat-omap/include/mach/memory.h
arch/avr32/mach-at32ap/clock.c
arch/cris/arch-v32/drivers/iop_fw_load.c
arch/ia64/kernel/pci-dma.c
arch/ia64/sn/kernel/tiocx.c
arch/mips/kernel/vpe.c
arch/s390/include/asm/s390_rdev.h [deleted file]
block/bsg.c
block/genhd.c
drivers/ata/libata-scsi.c
drivers/base/attribute_container.c
drivers/base/base.h
drivers/base/bus.c
drivers/base/core.c
drivers/base/dd.c
drivers/base/driver.c
drivers/base/firmware_class.c
drivers/base/isa.c
drivers/base/platform.c
drivers/base/power/main.c
drivers/base/power/trace.c
drivers/char/mwave/mwavedd.c
drivers/firmware/dmi-id.c
drivers/gpio/gpiolib.c
drivers/gpu/drm/drm_sysfs.c
drivers/hwmon/hwmon.c
drivers/hwmon/lm75.c
drivers/idle/i7300_idle.c
drivers/infiniband/core/sysfs.c
drivers/infiniband/core/ucm.c
drivers/infiniband/ulp/srp/ib_srp.c
drivers/isdn/mISDN/dsp_pipeline.c
drivers/lguest/lguest_device.c
drivers/macintosh/macio_asic.c
drivers/memstick/core/memstick.c
drivers/memstick/core/mspro_block.c
drivers/memstick/host/tifm_ms.c
drivers/message/i2o/device.c
drivers/message/i2o/i2o_proc.c
drivers/message/i2o/iop.c
drivers/misc/sgi-gru/grumain.c
drivers/misc/sgi-xp/xp_main.c
drivers/misc/sgi-xp/xpc_main.c
drivers/misc/sgi-xp/xpnet.c
drivers/misc/tifm_7xx1.c
drivers/misc/tifm_core.c
drivers/mtd/devices/m25p80.c
drivers/mtd/devices/mtd_dataflash.c
drivers/mtd/maps/integrator-flash.c
drivers/mtd/maps/ixp2000.c
drivers/mtd/maps/ixp4xx.c
drivers/mtd/maps/omap_nor.c
drivers/mtd/maps/physmap.c
drivers/mtd/maps/physmap_of.c
drivers/mtd/mtdconcat.c
drivers/mtd/nand/fsl_upm.c
drivers/mtd/nand/plat_nand.c
drivers/mtd/nand/tmio_nand.c
drivers/mtd/onenand/generic.c
drivers/mtd/onenand/omap2.c
drivers/mtd/ubi/build.c
drivers/mtd/ubi/vmt.c
drivers/pci/pci-driver.c
drivers/pnp/card.c
drivers/pnp/core.c
drivers/pnp/system.c
drivers/power/ds2760_battery.c
drivers/s390/Makefile
drivers/s390/block/dcssblk.c
drivers/s390/crypto/ap_bus.c
drivers/s390/kvm/kvm_virtio.c
drivers/s390/net/cu3088.c
drivers/s390/net/qeth_core_main.c
drivers/s390/net/qeth_l2_main.c
drivers/s390/net/qeth_l3_main.c
drivers/s390/s390_rdev.c [deleted file]
drivers/serial/serial_core.c
drivers/spi/spi.c
drivers/spi/spi_bitbang.c
drivers/spi/spi_butterfly.c
drivers/spi/spi_lm70llp.c
drivers/thermal/thermal_sys.c
drivers/uio/uio.c
drivers/uio/uio_cif.c
drivers/uio/uio_pdrv_genirq.c
drivers/usb/core/usb.c
drivers/usb/gadget/at91_udc.c
drivers/usb/gadget/atmel_usba_udc.c
drivers/usb/gadget/fsl_qe_udc.c
drivers/usb/gadget/lh7a40x_udc.c
drivers/usb/gadget/pxa25x_udc.c
drivers/usb/gadget/pxa27x_udc.c
drivers/usb/gadget/s3c2410_udc.c
drivers/video/backlight/backlight.c
drivers/video/backlight/lcd.c
drivers/video/output.c
drivers/virtio/virtio_pci.c
drivers/w1/w1.c
drivers/w1/w1_int.c
drivers/xen/xenbus/xenbus_probe.c
drivers/xen/xenbus/xenbus_probe.h
fs/partitions/check.c
include/linux/device.h
include/linux/kernel.h
include/linux/klist.h
include/linux/mtd/concat.h
include/linux/pci.h
include/linux/platform_device.h
include/linux/pm.h
include/linux/uio_driver.h
init/Kconfig
kernel/ksysfs.c
kernel/power/main.c
lib/dynamic_printk.c
lib/klist.c
lib/kobject_uevent.c
lib/swiotlb.c
net/iucv/iucv.c

index df87d1b93605ac54cf400bd7b8d44b0866d0789a..b787e4721c90d4134f2e579ecd46006a16ea4e4a 100644 (file)
@@ -41,6 +41,12 @@ GPL version 2.
 </abstract>
 
 <revhistory>
+       <revision>
+       <revnumber>0.6</revnumber>
+       <date>2008-12-05</date>
+       <authorinitials>hjk</authorinitials>
+       <revremark>Added description of portio sysfs attributes.</revremark>
+       </revision>
        <revision>
        <revnumber>0.5</revnumber>
        <date>2008-05-22</date>
@@ -318,6 +324,54 @@ interested in translating it, please email me
 offset = N * getpagesize();
 </programlisting>
 
+<para>
+       Sometimes there is hardware with memory-like regions that can not be
+       mapped with the technique described here, but there are still ways to
+       access them from userspace. The most common example are x86 ioports.
+       On x86 systems, userspace can access these ioports using
+       <function>ioperm()</function>, <function>iopl()</function>,
+       <function>inb()</function>, <function>outb()</function>, and similar
+       functions.
+</para>
+<para>
+       Since these ioport regions can not be mapped, they will not appear under
+       <filename>/sys/class/uio/uioX/maps/</filename> like the normal memory
+       described above. Without information about the port regions a hardware
+       has to offer, it becomes difficult for the userspace part of the
+       driver to find out which ports belong to which UIO device.
+</para>
+<para>
+       To address this situation, the new directory
+       <filename>/sys/class/uio/uioX/portio/</filename> was added. It only
+       exists if the driver wants to pass information about one or more port
+       regions to userspace. If that is the case, subdirectories named
+       <filename>port0</filename>, <filename>port1</filename>, and so on,
+       will appear underneath
+       <filename>/sys/class/uio/uioX/portio/</filename>.
+</para>
+<para>
+       Each <filename>portX/</filename> directory contains three read-only
+       files that show start, size, and type of the port region:
+</para>
+<itemizedlist>
+<listitem>
+       <para>
+       <filename>start</filename>: The first port of this region.
+       </para>
+</listitem>
+<listitem>
+       <para>
+       <filename>size</filename>: The number of ports in this region.
+       </para>
+</listitem>
+<listitem>
+       <para>
+       <filename>porttype</filename>: A string describing the type of port.
+       </para>
+</listitem>
+</itemizedlist>
+
+
 </sect1>
 </chapter>
 
@@ -339,12 +393,12 @@ offset = N * getpagesize();
 
 <itemizedlist>
 <listitem><para>
-<varname>char *name</varname>: Required. The name of your driver as
+<varname>const char *name</varname>: Required. The name of your driver as
 it will appear in sysfs. I recommend using the name of your module for this.
 </para></listitem>
 
 <listitem><para>
-<varname>char *version</varname>: Required. This string appears in
+<varname>const char *version</varname>: Required. This string appears in
 <filename>/sys/class/uio/uioX/version</filename>.
 </para></listitem>
 
@@ -355,6 +409,13 @@ mapping you need to fill one of the <varname>uio_mem</varname> structures.
 See the description below for details.
 </para></listitem>
 
+<listitem><para>
+<varname>struct uio_port port[ MAX_UIO_PORTS_REGIONS ]</varname>: Required
+if you want to pass information about ioports to userspace. For each port
+region you need to fill one of the <varname>uio_port</varname> structures.
+See the description below for details.
+</para></listitem>
+
 <listitem><para>
 <varname>long irq</varname>: Required. If your hardware generates an
 interrupt, it's your modules task to determine the irq number during
@@ -448,6 +509,42 @@ Please do not touch the <varname>kobj</varname> element of
 <varname>struct uio_mem</varname>! It is used by the UIO framework
 to set up sysfs files for this mapping. Simply leave it alone.
 </para>
+
+<para>
+Sometimes, your device can have one or more port regions which can not be
+mapped to userspace. But if there are other possibilities for userspace to
+access these ports, it makes sense to make information about the ports
+available in sysfs. For each region, you have to set up a
+<varname>struct uio_port</varname> in the <varname>port[]</varname> array.
+Here's a description of the fields of <varname>struct uio_port</varname>:
+</para>
+
+<itemizedlist>
+<listitem><para>
+<varname>char *porttype</varname>: Required. Set this to one of the predefined
+constants. Use <varname>UIO_PORT_X86</varname> for the ioports found in x86
+architectures.
+</para></listitem>
+
+<listitem><para>
+<varname>unsigned long start</varname>: Required if the port region is used.
+Fill in the number of the first port of this region.
+</para></listitem>
+
+<listitem><para>
+<varname>unsigned long size</varname>: Fill in the number of ports in this
+region. If <varname>size</varname> is zero, the region is considered unused.
+Note that you <emphasis>must</emphasis> initialize <varname>size</varname>
+with zero for all unused regions.
+</para></listitem>
+</itemizedlist>
+
+<para>
+Please do not touch the <varname>portio</varname> element of
+<varname>struct uio_port</varname>! It is used internally by the UIO
+framework to set up sysfs files for this region. Simply leave it alone.
+</para>
+
 </sect1>
 
 <sect1 id="adding_irq_handler">
index f5d2aad65a672ce65082769b835d621bac11e59a..b2e374586bd8627719167011a992ec3eb81a1c96 100644 (file)
@@ -118,8 +118,8 @@ the name of the kobject, call kobject_rename():
 
     int kobject_rename(struct kobject *kobj, const char *new_name);
 
-Note kobject_rename does perform any locking or have a solid notion of
-what names are valid so the provide must provide their own sanity checking
+kobject_rename does not perform any locking or have a solid notion of
+what names are valid so the caller must provide their own sanity checking
 and serialization.
 
 There is a function called kobject_set_name() but that is legacy cruft and
index 60c079d8535528d6aa755b6d8fd488a13eaad560..eed2f795e1b32be8dd539b9cecb0436d013ade5f 100644 (file)
@@ -817,7 +817,7 @@ static struct expansion_card *__init ecard_alloc_card(int type, int slot)
        ec->dma = NO_DMA;
        ec->ops = &ecard_default_ops;
 
-       snprintf(ec->dev.bus_id, sizeof(ec->dev.bus_id), "ecard%d", slot);
+       dev_set_name(&ec->dev, "ecard%d", slot);
        ec->dev.parent = NULL;
        ec->dev.bus = &ecard_bus_type;
        ec->dev.dma_mask = &ec->dma_mask;
index 50e13965dfed159e3f4b0009b60c29353e31ceef..b5c5fc6ba3a9d32d39a0d6e4379c8de5d2ffbd42 100644 (file)
@@ -212,7 +212,7 @@ static struct clcd_board clcd_plat_data = {
 
 static struct amba_device clcd_device = {
        .dev            = {
-               .bus_id                 = "mb:16",
+               .init_name              = "mb:16",
                .coherent_dma_mask      = ~0,
                .platform_data          = &clcd_plat_data,
        },
index 4781f323703bdcf782914999ad576acc9a2227e9..6d9152de6074f1744965b2274d25a2ea02340bf5 100644 (file)
@@ -409,7 +409,7 @@ static struct amba_pl010_data ep93xx_uart_data = {
 
 static struct amba_device uart1_device = {
        .dev            = {
-               .bus_id         = "apb:uart1",
+               .init_name      = "apb:uart1",
                .platform_data  = &ep93xx_uart_data,
        },
        .res            = {
@@ -423,7 +423,7 @@ static struct amba_device uart1_device = {
 
 static struct amba_device uart2_device = {
        .dev            = {
-               .bus_id         = "apb:uart2",
+               .init_name      = "apb:uart2",
                .platform_data  = &ep93xx_uart_data,
        },
        .res            = {
@@ -437,7 +437,7 @@ static struct amba_device uart2_device = {
 
 static struct amba_device uart3_device = {
        .dev            = {
-               .bus_id         = "apb:uart3",
+               .init_name      = "apb:uart3",
                .platform_data  = &ep93xx_uart_data,
        },
        .res            = {
index c89c949b4d459930fc7ed6d0098cbe8e7126f3fa..6f8872913073f9ba8b4527ed0ffd50d22cafa84e 100644 (file)
@@ -37,7 +37,7 @@ static struct amba_pl010_data integrator_uart_data;
 
 static struct amba_device rtc_device = {
        .dev            = {
-               .bus_id = "mb:15",
+               .init_name = "mb:15",
        },
        .res            = {
                .start  = INTEGRATOR_RTC_BASE,
@@ -50,7 +50,7 @@ static struct amba_device rtc_device = {
 
 static struct amba_device uart0_device = {
        .dev            = {
-               .bus_id = "mb:16",
+               .init_name = "mb:16",
                .platform_data = &integrator_uart_data,
        },
        .res            = {
@@ -64,7 +64,7 @@ static struct amba_device uart0_device = {
 
 static struct amba_device uart1_device = {
        .dev            = {
-               .bus_id = "mb:17",
+               .init_name = "mb:17",
                .platform_data = &integrator_uart_data,
        },
        .res            = {
@@ -78,7 +78,7 @@ static struct amba_device uart1_device = {
 
 static struct amba_device kmi0_device = {
        .dev            = {
-               .bus_id = "mb:18",
+               .init_name = "mb:18",
        },
        .res            = {
                .start  = KMI0_BASE,
@@ -91,7 +91,7 @@ static struct amba_device kmi0_device = {
 
 static struct amba_device kmi1_device = {
        .dev            = {
-               .bus_id = "mb:19",
+               .init_name = "mb:19",
        },
        .res            = {
                .start  = KMI1_BASE,
index 427c2d8dc1239bc835121f4b3e19956c5b0721c8..4ac04055c2eadaefbffc0bdfa28372ab8d718ec9 100644 (file)
@@ -407,7 +407,7 @@ static struct mmc_platform_data mmc_data = {
 
 static struct amba_device mmc_device = {
        .dev            = {
-               .bus_id = "mb:1c",
+               .init_name = "mb:1c",
                .platform_data = &mmc_data,
        },
        .res            = {
@@ -421,7 +421,7 @@ static struct amba_device mmc_device = {
 
 static struct amba_device aaci_device = {
        .dev            = {
-               .bus_id = "mb:1d",
+               .init_name = "mb:1d",
        },
        .res            = {
                .start  = INTCP_PA_AACI_BASE,
@@ -532,7 +532,7 @@ static struct clcd_board clcd_data = {
 
 static struct amba_device clcd_device = {
        .dev            = {
-               .bus_id = "mb:c0",
+               .init_name = "mb:c0",
                .coherent_dma_mask = ~0,
                .platform_data = &clcd_data,
        },
index a2a543258fc371d5d36123ca394b4f3774866f34..c472b9e8b37cd3bf6710ae555b0e356b3ab9f01d 100644 (file)
@@ -207,7 +207,7 @@ static struct clcd_board clcd_platform_data = {
 static struct amba_device name##_device = {                    \
        .dev = {                                                \
                .coherent_dma_mask = ~0,                        \
-               .bus_id = busid,                                \
+               .init_name = busid,                             \
                .platform_data = plat,                          \
                },                                              \
        .res = {                                                \
index 8f1f992f002ee6804e19edf7cfd552a993f2f58d..ea8fa8898fe8570455d499705f6cba8fd5c68c74 100644 (file)
@@ -91,7 +91,7 @@ void clk_put(struct clk *clk)
 
 static struct amba_device fb_device = {
        .dev            = {
-               .bus_id = "fb",
+               .init_name = "fb",
                .coherent_dma_mask = ~0,
        },
        .res            = {
index 63be2abdc19ce299d52556ef4e68a28de6edabd8..44269b162d4918e468542ab58a3627cda43c014d 100644 (file)
@@ -31,7 +31,7 @@
 static struct amba_device name##_device = {                    \
        .dev            = {                                     \
                .coherent_dma_mask = ~0,                        \
-               .bus_id = busid,                                \
+               .init_name = busid,                             \
                .platform_data = plat,                          \
        },                                                      \
        .res            = {                                     \
index afcaa858eb1f916df6d40c5c916878447c296398..9d39886a8351d360dac960830f1fa870e31bc7be 100644 (file)
@@ -34,7 +34,7 @@ extern unsigned int mmc_status(struct device *dev);
 static struct amba_device name##_device = {                    \
        .dev            = {                                     \
                .coherent_dma_mask = ~0,                        \
-               .bus_id = busid,                                \
+               .init_name = busid,                             \
                .platform_data = plat,                          \
        },                                                      \
        .res            = {                                     \
index 211c9f6619e991f4b434a88a4ae94bb85215d7c7..d6b5ca6c7da20bf7790cd8497616aa1d6f4cc66f 100644 (file)
@@ -59,7 +59,7 @@
 
 #define virt_to_lbus(x)                ((x) - PAGE_OFFSET + OMAP1510_LB_OFFSET)
 #define lbus_to_virt(x)                ((x) - OMAP1510_LB_OFFSET + PAGE_OFFSET)
-#define is_lbus_device(dev)    (cpu_is_omap15xx() && dev && (strncmp(dev->bus_id, "ohci", 4) == 0))
+#define is_lbus_device(dev)    (cpu_is_omap15xx() && dev && (strncmp(dev_name(dev), "ohci", 4) == 0))
 
 #define __arch_page_to_dma(dev, page)  ({is_lbus_device(dev) ? \
                                        (dma_addr_t)virt_to_lbus(page_address(page)) : \
index 138a00a2a2d0c5c833723a0a6610e8baf6d42a5c..442f08c5e6415f198df5c7843b69d144fa336ed6 100644 (file)
@@ -198,7 +198,7 @@ dump_clock(struct clk *parent, struct clkinf *r)
        unsigned        i;
 
        /* skip clocks coupled to devices that aren't registered */
-       if (parent->dev && !parent->dev->bus_id[0] && !parent->users)
+       if (parent->dev && !dev_name(parent->dev) && !parent->users)
                return;
 
        /* <nest spaces> name <pad to end> */
@@ -214,7 +214,7 @@ dump_clock(struct clk *parent, struct clkinf *r)
                parent->users ? "on" : "off",   /* NOTE: not-paranoid!! */
                clk_get_rate(parent));
        if (parent->dev)
-               seq_printf(r->s, ", for %s", parent->dev->bus_id);
+               seq_printf(r->s, ", for %s", dev_name(parent->dev));
        seq_printf(r->s, "\n");
 
        /* cost of this scan is small, but not linear... */
index 3b3857ec1f15f6753d0b2c2ff6c690f619a54890..2f8ea0f7a63c30e77f7948b404bc74618cc6e421 100644 (file)
 #error "Please contact <greg@kroah.com> for details on how to fix it properly."
 
 static struct device iop_spu_device[2] = {
-       { .bus_id =     "iop-spu0", },
-       { .bus_id =     "iop-spu1", },
+       { .init_name =     "iop-spu0", },
+       { .init_name =     "iop-spu1", },
 };
 
 static struct device iop_mpu_device = {
-       .bus_id =       "iop-mpu",
+       .init_name =       "iop-mpu",
 };
 
 static int wait_mpu_idle(void)
index 2a92f637431d77f0ddeba81c89643c332a3ddac4..d0ada067a4af52bd83fdac763b862d3b62e2ed13 100644 (file)
@@ -39,7 +39,7 @@ int iommu_detected __read_mostly;
    be probably a smaller DMA mask, but this is bug-to-bug compatible
    to i386. */
 struct device fallback_dev = {
-       .bus_id = "fallback device",
+       .init_name = "fallback device",
        .coherent_dma_mask = DMA_32BIT_MASK,
        .dma_mask = &fallback_dev.coherent_dma_mask,
 };
index a88eba3314d7fb02b812c7b8cf5055788da90fa4..3f864238566d5aa1ae92c854dac9f783985978c4 100644 (file)
@@ -206,8 +206,7 @@ cx_device_register(nasid_t nasid, int part_num, int mfg_num,
        cx_dev->dev.parent = NULL;
        cx_dev->dev.bus = &tiocx_bus_type;
        cx_dev->dev.release = tiocx_bus_release;
-       snprintf(cx_dev->dev.bus_id, BUS_ID_SIZE, "%d",
-                cx_dev->cx_id.nasid);
+       dev_set_name(&cx_dev->dev, "%d", cx_dev->cx_id.nasid);
        device_register(&cx_dev->dev);
        get_device(&cx_dev->dev);
 
index 010b27e01f7bf9c03dd1b55c64fe15ca69c14100..3ca5f42e819dc3ab4a6793510216d38218b6bc72 100644 (file)
@@ -1454,7 +1454,7 @@ static int __init vpe_module_init(void)
        device_initialize(&vpe_device);
        vpe_device.class        = &vpe_class,
        vpe_device.parent       = NULL,
-       strlcpy(vpe_device.bus_id, "vpe1", BUS_ID_SIZE);
+       dev_set_name(&vpe_device, "vpe1");
        vpe_device.devt = MKDEV(major, minor);
        err = device_add(&vpe_device);
        if (err) {
diff --git a/arch/s390/include/asm/s390_rdev.h b/arch/s390/include/asm/s390_rdev.h
deleted file mode 100644 (file)
index 6fa2044..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- *  include/asm-s390/ccwdev.h
- *
- *    Copyright (C) 2002,2005 IBM Deutschland Entwicklung GmbH, IBM Corporation
- *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
- *               Carsten Otte  <cotte@de.ibm.com>
- *
- *  Interface for s390 root device
- */
-
-#ifndef _S390_RDEV_H_
-#define _S390_RDEV_H_
-extern struct device *s390_root_dev_register(const char *);
-extern void s390_root_dev_unregister(struct device *);
-#endif /* _S390_RDEV_H_ */
index e73e50daf3d0a36df8977cad29b550e3139fbef0..d414bb5607e89f4e3a05466b2a488db5e79c98a3 100644 (file)
@@ -42,7 +42,7 @@ struct bsg_device {
        int done_cmds;
        wait_queue_head_t wq_done;
        wait_queue_head_t wq_free;
-       char name[BUS_ID_SIZE];
+       char name[20];
        int max_queue;
        unsigned long flags;
 };
@@ -781,7 +781,7 @@ static struct bsg_device *bsg_add_device(struct inode *inode,
        mutex_lock(&bsg_mutex);
        hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
 
-       strncpy(bd->name, rq->bsg_dev.class_dev->bus_id, sizeof(bd->name) - 1);
+       strncpy(bd->name, dev_name(rq->bsg_dev.class_dev), sizeof(bd->name) - 1);
        dprintk("bound to <%s>, max queue %d\n",
                format_dev_t(buf, inode->i_rdev), bd->max_queue);
 
@@ -992,7 +992,7 @@ int bsg_register_queue(struct request_queue *q, struct device *parent,
        if (name)
                devname = name;
        else
-               devname = parent->bus_id;
+               devname = dev_name(parent);
 
        /*
         * we need a proper transport to send commands, not a stacked device
index d84a7df1e2a094e663f7e1683bb941f1c3562e2d..397960cf26afcd61fc7c2bba2365944c8485c767 100644 (file)
@@ -1084,7 +1084,7 @@ dev_t blk_lookup_devt(const char *name, int partno)
                struct gendisk *disk = dev_to_disk(dev);
                struct hd_struct *part;
 
-               if (strcmp(dev->bus_id, name))
+               if (strcmp(dev_name(dev), name))
                        continue;
 
                part = disk_get_part(disk, partno);
index 4040d8b532165b791fef71902b44a5905e21303a..9e92107691f2ff0f606e5272347d7a98afe2516b 100644 (file)
@@ -3369,7 +3369,7 @@ static void ata_scsi_remove_dev(struct ata_device *dev)
 
        if (sdev) {
                ata_dev_printk(dev, KERN_INFO, "detaching (SCSI %s)\n",
-                              sdev->sdev_gendev.bus_id);
+                              dev_name(&sdev->sdev_gendev));
 
                scsi_remove_device(sdev);
                scsi_device_put(sdev);
index f57652db0a2a1261ef79e0c59326be6163bcaa1c..b9cda053d3c0c20182a264c6da5424fe872c6e5e 100644 (file)
@@ -167,7 +167,7 @@ attribute_container_add_device(struct device *dev,
                ic->classdev.parent = get_device(dev);
                ic->classdev.class = cont->class;
                cont->class->dev_release = attribute_container_release;
-               strcpy(ic->classdev.bus_id, dev->bus_id);
+               dev_set_name(&ic->classdev, dev_name(dev));
                if (fn)
                        fn(cont, dev, &ic->classdev);
                else
index 0a5f055dffbaa389fd8f4b2f0bfe81fe5a352241..b676f8f801f8c5adde6577bcd45632470ece691d 100644 (file)
@@ -63,6 +63,32 @@ struct class_private {
 #define to_class(obj)  \
        container_of(obj, struct class_private, class_subsys.kobj)
 
+/**
+ * struct device_private - structure to hold the private to the driver core portions of the device structure.
+ *
+ * @klist_children - klist containing all children of this device
+ * @knode_parent - node in sibling list
+ * @knode_driver - node in driver list
+ * @knode_bus - node in bus list
+ * @device - pointer back to the struct class that this structure is
+ * associated with.
+ *
+ * Nothing outside of the driver core should ever touch these fields.
+ */
+struct device_private {
+       struct klist klist_children;
+       struct klist_node knode_parent;
+       struct klist_node knode_driver;
+       struct klist_node knode_bus;
+       struct device *device;
+};
+#define to_device_private_parent(obj)  \
+       container_of(obj, struct device_private, knode_parent)
+#define to_device_private_driver(obj)  \
+       container_of(obj, struct device_private, knode_driver)
+#define to_device_private_bus(obj)     \
+       container_of(obj, struct device_private, knode_bus)
+
 /* initialisation functions */
 extern int devices_init(void);
 extern int buses_init(void);
index 5aee1c0169eafed102c699281b5bb4875fefd20c..0f0a5044467223b4ac4379565b289d8033d451b1 100644 (file)
@@ -253,7 +253,14 @@ static ssize_t store_drivers_probe(struct bus_type *bus,
 static struct device *next_device(struct klist_iter *i)
 {
        struct klist_node *n = klist_next(i);
-       return n ? container_of(n, struct device, knode_bus) : NULL;
+       struct device *dev = NULL;
+       struct device_private *dev_prv;
+
+       if (n) {
+               dev_prv = to_device_private_bus(n);
+               dev = dev_prv->device;
+       }
+       return dev;
 }
 
 /**
@@ -286,7 +293,7 @@ int bus_for_each_dev(struct bus_type *bus, struct device *start,
                return -EINVAL;
 
        klist_iter_init_node(&bus->p->klist_devices, &i,
-                            (start ? &start->knode_bus : NULL));
+                            (start ? &start->p->knode_bus : NULL));
        while ((dev = next_device(&i)) && !error)
                error = fn(dev, data);
        klist_iter_exit(&i);
@@ -320,7 +327,7 @@ struct device *bus_find_device(struct bus_type *bus,
                return NULL;
 
        klist_iter_init_node(&bus->p->klist_devices, &i,
-                            (start ? &start->knode_bus : NULL));
+                            (start ? &start->p->knode_bus : NULL));
        while ((dev = next_device(&i)))
                if (match(dev, data) && get_device(dev))
                        break;
@@ -333,7 +340,7 @@ static int match_name(struct device *dev, void *data)
 {
        const char *name = data;
 
-       return sysfs_streq(name, dev->bus_id);
+       return sysfs_streq(name, dev_name(dev));
 }
 
 /**
@@ -461,12 +468,12 @@ int bus_add_device(struct device *dev)
        int error = 0;
 
        if (bus) {
-               pr_debug("bus: '%s': add device %s\n", bus->name, dev->bus_id);
+               pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
                error = device_add_attrs(bus, dev);
                if (error)
                        goto out_put;
                error = sysfs_create_link(&bus->p->devices_kset->kobj,
-                                               &dev->kobj, dev->bus_id);
+                                               &dev->kobj, dev_name(dev));
                if (error)
                        goto out_id;
                error = sysfs_create_link(&dev->kobj,
@@ -482,7 +489,7 @@ int bus_add_device(struct device *dev)
 out_deprecated:
        sysfs_remove_link(&dev->kobj, "subsystem");
 out_subsys:
-       sysfs_remove_link(&bus->p->devices_kset->kobj, dev->bus_id);
+       sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
 out_id:
        device_remove_attrs(bus, dev);
 out_put:
@@ -507,7 +514,8 @@ void bus_attach_device(struct device *dev)
                        ret = device_attach(dev);
                WARN_ON(ret < 0);
                if (ret >= 0)
-                       klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);
+                       klist_add_tail(&dev->p->knode_bus,
+                                      &bus->p->klist_devices);
        }
 }
 
@@ -526,13 +534,13 @@ void bus_remove_device(struct device *dev)
                sysfs_remove_link(&dev->kobj, "subsystem");
                remove_deprecated_bus_links(dev);
                sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
-                                 dev->bus_id);
+                                 dev_name(dev));
                device_remove_attrs(dev->bus, dev);
-               if (klist_node_attached(&dev->knode_bus))
-                       klist_del(&dev->knode_bus);
+               if (klist_node_attached(&dev->p->knode_bus))
+                       klist_del(&dev->p->knode_bus);
 
                pr_debug("bus: '%s': remove device %s\n",
-                        dev->bus->name, dev->bus_id);
+                        dev->bus->name, dev_name(dev));
                device_release_driver(dev);
                bus_put(dev->bus);
        }
@@ -831,14 +839,16 @@ static void bus_remove_attrs(struct bus_type *bus)
 
 static void klist_devices_get(struct klist_node *n)
 {
-       struct device *dev = container_of(n, struct device, knode_bus);
+       struct device_private *dev_prv = to_device_private_bus(n);
+       struct device *dev = dev_prv->device;
 
        get_device(dev);
 }
 
 static void klist_devices_put(struct klist_node *n)
 {
-       struct device *dev = container_of(n, struct device, knode_bus);
+       struct device_private *dev_prv = to_device_private_bus(n);
+       struct device *dev = dev_prv->device;
 
        put_device(dev);
 }
@@ -993,18 +1003,20 @@ static void device_insertion_sort_klist(struct device *a, struct list_head *list
 {
        struct list_head *pos;
        struct klist_node *n;
+       struct device_private *dev_prv;
        struct device *b;
 
        list_for_each(pos, list) {
                n = container_of(pos, struct klist_node, n_node);
-               b = container_of(n, struct device, knode_bus);
+               dev_prv = to_device_private_bus(n);
+               b = dev_prv->device;
                if (compare(a, b) <= 0) {
-                       list_move_tail(&a->knode_bus.n_node,
-                                      &b->knode_bus.n_node);
+                       list_move_tail(&a->p->knode_bus.n_node,
+                                      &b->p->knode_bus.n_node);
                        return;
                }
        }
-       list_move_tail(&a->knode_bus.n_node, list);
+       list_move_tail(&a->p->knode_bus.n_node, list);
 }
 
 void bus_sort_breadthfirst(struct bus_type *bus,
@@ -1014,6 +1026,7 @@ void bus_sort_breadthfirst(struct bus_type *bus,
        LIST_HEAD(sorted_devices);
        struct list_head *pos, *tmp;
        struct klist_node *n;
+       struct device_private *dev_prv;
        struct device *dev;
        struct klist *device_klist;
 
@@ -1022,7 +1035,8 @@ void bus_sort_breadthfirst(struct bus_type *bus,
        spin_lock(&device_klist->k_lock);
        list_for_each_safe(pos, tmp, &device_klist->k_list) {
                n = container_of(pos, struct klist_node, n_node);
-               dev = container_of(n, struct device, knode_bus);
+               dev_prv = to_device_private_bus(n);
+               dev = dev_prv->device;
                device_insertion_sort_klist(dev, &sorted_devices, compare);
        }
        list_splice(&sorted_devices, &device_klist->k_list);
index 8c2cc2648f5a5c0ec330df4991f75b6be07131ae..61df508fa62bfef83754e143c4f20cdd6fdbe2e3 100644 (file)
@@ -109,6 +109,7 @@ static struct sysfs_ops dev_sysfs_ops = {
 static void device_release(struct kobject *kobj)
 {
        struct device *dev = to_dev(kobj);
+       struct device_private *p = dev->p;
 
        if (dev->release)
                dev->release(dev);
@@ -119,7 +120,8 @@ static void device_release(struct kobject *kobj)
        else
                WARN(1, KERN_ERR "Device '%s' does not have a release() "
                        "function, it is broken and must be fixed.\n",
-                       dev->bus_id);
+                       dev_name(dev));
+       kfree(p);
 }
 
 static struct kobj_type device_ktype = {
@@ -209,7 +211,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
                retval = dev->bus->uevent(dev, env);
                if (retval)
                        pr_debug("device: '%s': %s: bus uevent() returned %d\n",
-                                dev->bus_id, __func__, retval);
+                                dev_name(dev), __func__, retval);
        }
 
        /* have the class specific function add its stuff */
@@ -217,7 +219,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
                retval = dev->class->dev_uevent(dev, env);
                if (retval)
                        pr_debug("device: '%s': %s: class uevent() "
-                                "returned %d\n", dev->bus_id,
+                                "returned %d\n", dev_name(dev),
                                 __func__, retval);
        }
 
@@ -226,7 +228,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
                retval = dev->type->uevent(dev, env);
                if (retval)
                        pr_debug("device: '%s': %s: dev_type uevent() "
-                                "returned %d\n", dev->bus_id,
+                                "returned %d\n", dev_name(dev),
                                 __func__, retval);
        }
 
@@ -507,14 +509,16 @@ EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
 
 static void klist_children_get(struct klist_node *n)
 {
-       struct device *dev = container_of(n, struct device, knode_parent);
+       struct device_private *p = to_device_private_parent(n);
+       struct device *dev = p->device;
 
        get_device(dev);
 }
 
 static void klist_children_put(struct klist_node *n)
 {
-       struct device *dev = container_of(n, struct device, knode_parent);
+       struct device_private *p = to_device_private_parent(n);
+       struct device *dev = p->device;
 
        put_device(dev);
 }
@@ -536,9 +540,15 @@ static void klist_children_put(struct klist_node *n)
  */
 void device_initialize(struct device *dev)
 {
+       dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
+       if (!dev->p) {
+               WARN_ON(1);
+               return;
+       }
+       dev->p->device = dev;
        dev->kobj.kset = devices_kset;
        kobject_init(&dev->kobj, &device_ktype);
-       klist_init(&dev->klist_children, klist_children_get,
+       klist_init(&dev->p->klist_children, klist_children_get,
                   klist_children_put);
        INIT_LIST_HEAD(&dev->dma_pools);
        init_MUTEX(&dev->sem);
@@ -672,7 +682,7 @@ static int device_add_class_symlinks(struct device *dev)
        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
            device_is_not_partition(dev)) {
                error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
-                                         &dev->kobj, dev->bus_id);
+                                         &dev->kobj, dev_name(dev));
                if (error)
                        goto out_subsys;
        }
@@ -712,11 +722,11 @@ out_busid:
        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
            device_is_not_partition(dev))
                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
-                                 dev->bus_id);
+                                 dev_name(dev));
 #else
        /* link in the class directory pointing to the device */
        error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
-                                 &dev->kobj, dev->bus_id);
+                                 &dev->kobj, dev_name(dev));
        if (error)
                goto out_subsys;
 
@@ -729,7 +739,7 @@ out_busid:
        return 0;
 
 out_busid:
-       sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev->bus_id);
+       sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
 #endif
 
 out_subsys:
@@ -758,12 +768,12 @@ static void device_remove_class_symlinks(struct device *dev)
        if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
            device_is_not_partition(dev))
                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
-                                 dev->bus_id);
+                                 dev_name(dev));
 #else
        if (dev->parent && device_is_not_partition(dev))
                sysfs_remove_link(&dev->kobj, "device");
 
-       sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev->bus_id);
+       sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
 #endif
 
        sysfs_remove_link(&dev->kobj, "subsystem");
@@ -866,7 +876,7 @@ int device_add(struct device *dev)
        if (!strlen(dev->bus_id))
                goto done;
 
-       pr_debug("device: '%s': %s\n", dev->bus_id, __func__);
+       pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
 
        parent = get_device(dev->parent);
        setup_parent(dev, parent);
@@ -876,7 +886,7 @@ int device_add(struct device *dev)
                set_dev_node(dev, dev_to_node(parent));
 
        /* first, register with generic layer. */
-       error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev->bus_id);
+       error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev_name(dev));
        if (error)
                goto Error;
 
@@ -884,11 +894,6 @@ int device_add(struct device *dev)
        if (platform_notify)
                platform_notify(dev);
 
-       /* notify clients of device entry (new way) */
-       if (dev->bus)
-               blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
-                                            BUS_NOTIFY_ADD_DEVICE, dev);
-
        error = device_create_file(dev, &uevent_attr);
        if (error)
                goto attrError;
@@ -916,10 +921,19 @@ int device_add(struct device *dev)
        if (error)
                goto DPMError;
        device_pm_add(dev);
+
+       /* Notify clients of device addition.  This call must come
+        * after dpm_sysf_add() and before kobject_uevent().
+        */
+       if (dev->bus)
+               blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
+                                            BUS_NOTIFY_ADD_DEVICE, dev);
+
        kobject_uevent(&dev->kobj, KOBJ_ADD);
        bus_attach_device(dev);
        if (parent)
-               klist_add_tail(&dev->knode_parent, &parent->klist_children);
+               klist_add_tail(&dev->p->knode_parent,
+                              &parent->p->klist_children);
 
        if (dev->class) {
                mutex_lock(&dev->class->p->class_mutex);
@@ -940,9 +954,6 @@ done:
  DPMError:
        bus_remove_device(dev);
  BusError:
-       if (dev->bus)
-               blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
-                                            BUS_NOTIFY_DEL_DEVICE, dev);
        device_remove_attrs(dev);
  AttrsError:
        device_remove_class_symlinks(dev);
@@ -1027,10 +1038,16 @@ void device_del(struct device *dev)
        struct device *parent = dev->parent;
        struct class_interface *class_intf;
 
+       /* Notify clients of device removal.  This call must come
+        * before dpm_sysfs_remove().
+        */
+       if (dev->bus)
+               blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
+                                            BUS_NOTIFY_DEL_DEVICE, dev);
        device_pm_remove(dev);
        dpm_sysfs_remove(dev);
        if (parent)
-               klist_del(&dev->knode_parent);
+               klist_del(&dev->p->knode_parent);
        if (MAJOR(dev->devt)) {
                device_remove_sys_dev_entry(dev);
                device_remove_file(dev, &devt_attr);
@@ -1064,9 +1081,6 @@ void device_del(struct device *dev)
         */
        if (platform_notify_remove)
                platform_notify_remove(dev);
-       if (dev->bus)
-               blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
-                                            BUS_NOTIFY_DEL_DEVICE, dev);
        kobject_uevent(&dev->kobj, KOBJ_REMOVE);
        cleanup_device_parent(dev);
        kobject_del(&dev->kobj);
@@ -1086,7 +1100,7 @@ void device_del(struct device *dev)
  */
 void device_unregister(struct device *dev)
 {
-       pr_debug("device: '%s': %s\n", dev->bus_id, __func__);
+       pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
        device_del(dev);
        put_device(dev);
 }
@@ -1094,7 +1108,14 @@ void device_unregister(struct device *dev)
 static struct device *next_device(struct klist_iter *i)
 {
        struct klist_node *n = klist_next(i);
-       return n ? container_of(n, struct device, knode_parent) : NULL;
+       struct device *dev = NULL;
+       struct device_private *p;
+
+       if (n) {
+               p = to_device_private_parent(n);
+               dev = p->device;
+       }
+       return dev;
 }
 
 /**
@@ -1116,7 +1137,7 @@ int device_for_each_child(struct device *parent, void *data,
        struct device *child;
        int error = 0;
 
-       klist_iter_init(&parent->klist_children, &i);
+       klist_iter_init(&parent->p->klist_children, &i);
        while ((child = next_device(&i)) && !error)
                error = fn(child, data);
        klist_iter_exit(&i);
@@ -1147,7 +1168,7 @@ struct device *device_find_child(struct device *parent, void *data,
        if (!parent)
                return NULL;
 
-       klist_iter_init(&parent->klist_children, &i);
+       klist_iter_init(&parent->p->klist_children, &i);
        while ((child = next_device(&i)))
                if (match(child, data) && get_device(child))
                        break;
@@ -1196,10 +1217,101 @@ EXPORT_SYMBOL_GPL(put_device);
 EXPORT_SYMBOL_GPL(device_create_file);
 EXPORT_SYMBOL_GPL(device_remove_file);
 
+struct root_device
+{
+       struct device dev;
+       struct module *owner;
+};
+
+#define to_root_device(dev) container_of(dev, struct root_device, dev)
+
+static void root_device_release(struct device *dev)
+{
+       kfree(to_root_device(dev));
+}
+
+/**
+ * __root_device_register - allocate and register a root device
+ * @name: root device name
+ * @owner: owner module of the root device, usually THIS_MODULE
+ *
+ * This function allocates a root device and registers it
+ * using device_register(). In order to free the returned
+ * device, use root_device_unregister().
+ *
+ * Root devices are dummy devices which allow other devices
+ * to be grouped under /sys/devices. Use this function to
+ * allocate a root device and then use it as the parent of
+ * any device which should appear under /sys/devices/{name}
+ *
+ * The /sys/devices/{name} directory will also contain a
+ * 'module' symlink which points to the @owner directory
+ * in sysfs.
+ *
+ * Note: You probably want to use root_device_register().
+ */
+struct device *__root_device_register(const char *name, struct module *owner)
+{
+       struct root_device *root;
+       int err = -ENOMEM;
+
+       root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
+       if (!root)
+               return ERR_PTR(err);
+
+       err = dev_set_name(&root->dev, name);
+       if (err) {
+               kfree(root);
+               return ERR_PTR(err);
+       }
+
+       root->dev.release = root_device_release;
+
+       err = device_register(&root->dev);
+       if (err) {
+               put_device(&root->dev);
+               return ERR_PTR(err);
+       }
+
+#ifdef CONFIG_MODULE   /* gotta find a "cleaner" way to do this */
+       if (owner) {
+               struct module_kobject *mk = &owner->mkobj;
+
+               err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
+               if (err) {
+                       device_unregister(&root->dev);
+                       return ERR_PTR(err);
+               }
+               root->owner = owner;
+       }
+#endif
+
+       return &root->dev;
+}
+EXPORT_SYMBOL_GPL(__root_device_register);
+
+/**
+ * root_device_unregister - unregister and free a root device
+ * @root: device going away.
+ *
+ * This function unregisters and cleans up a device that was created by
+ * root_device_register().
+ */
+void root_device_unregister(struct device *dev)
+{
+       struct root_device *root = to_root_device(dev);
+
+       if (root->owner)
+               sysfs_remove_link(&root->dev.kobj, "module");
+
+       device_unregister(dev);
+}
+EXPORT_SYMBOL_GPL(root_device_unregister);
+
 
 static void device_create_release(struct device *dev)
 {
-       pr_debug("device: '%s': %s\n", dev->bus_id, __func__);
+       pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
        kfree(dev);
 }
 
@@ -1344,7 +1456,7 @@ int device_rename(struct device *dev, char *new_name)
        if (!dev)
                return -EINVAL;
 
-       pr_debug("device: '%s': %s: renaming to '%s'\n", dev->bus_id,
+       pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
                 __func__, new_name);
 
 #ifdef CONFIG_SYSFS_DEPRECATED
@@ -1381,7 +1493,7 @@ int device_rename(struct device *dev, char *new_name)
 #else
        if (dev->class) {
                error = sysfs_create_link_nowarn(&dev->class->p->class_subsys.kobj,
-                                                &dev->kobj, dev->bus_id);
+                                                &dev->kobj, dev_name(dev));
                if (error)
                        goto out;
                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
@@ -1459,8 +1571,8 @@ int device_move(struct device *dev, struct device *new_parent)
        new_parent = get_device(new_parent);
        new_parent_kobj = get_device_parent(dev, new_parent);
 
-       pr_debug("device: '%s': %s: moving to '%s'\n", dev->bus_id,
-                __func__, new_parent ? new_parent->bus_id : "<NULL>");
+       pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
+                __func__, new_parent ? dev_name(new_parent) : "<NULL>");
        error = kobject_move(&dev->kobj, new_parent_kobj);
        if (error) {
                cleanup_glue_dir(dev, new_parent_kobj);
@@ -1470,9 +1582,10 @@ int device_move(struct device *dev, struct device *new_parent)
        old_parent = dev->parent;
        dev->parent = new_parent;
        if (old_parent)
-               klist_remove(&dev->knode_parent);
+               klist_remove(&dev->p->knode_parent);
        if (new_parent) {
-               klist_add_tail(&dev->knode_parent, &new_parent->klist_children);
+               klist_add_tail(&dev->p->knode_parent,
+                              &new_parent->p->klist_children);
                set_dev_node(dev, dev_to_node(new_parent));
        }
 
@@ -1484,11 +1597,11 @@ int device_move(struct device *dev, struct device *new_parent)
                device_move_class_links(dev, new_parent, old_parent);
                if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
                        if (new_parent)
-                               klist_remove(&dev->knode_parent);
+                               klist_remove(&dev->p->knode_parent);
                        dev->parent = old_parent;
                        if (old_parent) {
-                               klist_add_tail(&dev->knode_parent,
-                                              &old_parent->klist_children);
+                               klist_add_tail(&dev->p->knode_parent,
+                                              &old_parent->p->klist_children);
                                set_dev_node(dev, dev_to_node(old_parent));
                        }
                }
index 20febc00a5258e253aeb9a309a9447660df40a38..6fdaf76f033fcc4704b879189db3828884b56544 100644 (file)
 
 static void driver_bound(struct device *dev)
 {
-       if (klist_node_attached(&dev->knode_driver)) {
+       if (klist_node_attached(&dev->p->knode_driver)) {
                printk(KERN_WARNING "%s: device %s already bound\n",
                        __func__, kobject_name(&dev->kobj));
                return;
        }
 
-       pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->bus_id,
+       pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),
                 __func__, dev->driver->name);
 
        if (dev->bus)
                blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
                                             BUS_NOTIFY_BOUND_DRIVER, dev);
 
-       klist_add_tail(&dev->knode_driver, &dev->driver->p->klist_devices);
+       klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
 }
 
 static int driver_sysfs_add(struct device *dev)
@@ -104,13 +104,13 @@ static int really_probe(struct device *dev, struct device_driver *drv)
 
        atomic_inc(&probe_count);
        pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
-                drv->bus->name, __func__, drv->name, dev->bus_id);
+                drv->bus->name, __func__, drv->name, dev_name(dev));
        WARN_ON(!list_empty(&dev->devres_head));
 
        dev->driver = drv;
        if (driver_sysfs_add(dev)) {
                printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
-                       __func__, dev->bus_id);
+                       __func__, dev_name(dev));
                goto probe_failed;
        }
 
@@ -127,7 +127,7 @@ static int really_probe(struct device *dev, struct device_driver *drv)
        driver_bound(dev);
        ret = 1;
        pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
-                drv->bus->name, __func__, dev->bus_id, drv->name);
+                drv->bus->name, __func__, dev_name(dev), drv->name);
        goto done;
 
 probe_failed:
@@ -139,7 +139,7 @@ probe_failed:
                /* driver matched but the probe failed */
                printk(KERN_WARNING
                       "%s: probe of %s failed with error %d\n",
-                      drv->name, dev->bus_id, ret);
+                      drv->name, dev_name(dev), ret);
        }
        /*
         * Ignore errors returned by ->probe so that the next driver can try
@@ -194,7 +194,7 @@ int driver_probe_device(struct device_driver *drv, struct device *dev)
                goto done;
 
        pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
-                drv->bus->name, __func__, dev->bus_id, drv->name);
+                drv->bus->name, __func__, dev_name(dev), drv->name);
 
        ret = really_probe(dev, drv);
 
@@ -298,7 +298,6 @@ static void __device_release_driver(struct device *dev)
        drv = dev->driver;
        if (drv) {
                driver_sysfs_remove(dev);
-               sysfs_remove_link(&dev->kobj, "driver");
 
                if (dev->bus)
                        blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
@@ -311,7 +310,7 @@ static void __device_release_driver(struct device *dev)
                        drv->remove(dev);
                devres_release_all(dev);
                dev->driver = NULL;
-               klist_remove(&dev->knode_driver);
+               klist_remove(&dev->p->knode_driver);
        }
 }
 
@@ -341,6 +340,7 @@ EXPORT_SYMBOL_GPL(device_release_driver);
  */
 void driver_detach(struct device_driver *drv)
 {
+       struct device_private *dev_prv;
        struct device *dev;
 
        for (;;) {
@@ -349,8 +349,10 @@ void driver_detach(struct device_driver *drv)
                        spin_unlock(&drv->p->klist_devices.k_lock);
                        break;
                }
-               dev = list_entry(drv->p->klist_devices.k_list.prev,
-                               struct device, knode_driver.n_node);
+               dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
+                                    struct device_private,
+                                    knode_driver.n_node);
+               dev = dev_prv->device;
                get_device(dev);
                spin_unlock(&drv->p->klist_devices.k_lock);
 
index 1e2bda780e48268eb38b834f7078644689b5dc7b..b76cc69f11067801e85f830573d098561eb97727 100644 (file)
 static struct device *next_device(struct klist_iter *i)
 {
        struct klist_node *n = klist_next(i);
-       return n ? container_of(n, struct device, knode_driver) : NULL;
+       struct device *dev = NULL;
+       struct device_private *dev_prv;
+
+       if (n) {
+               dev_prv = to_device_private_driver(n);
+               dev = dev_prv->device;
+       }
+       return dev;
 }
 
 /**
@@ -42,7 +49,7 @@ int driver_for_each_device(struct device_driver *drv, struct device *start,
                return -EINVAL;
 
        klist_iter_init_node(&drv->p->klist_devices, &i,
-                            start ? &start->knode_driver : NULL);
+                            start ? &start->p->knode_driver : NULL);
        while ((dev = next_device(&i)) && !error)
                error = fn(dev, data);
        klist_iter_exit(&i);
@@ -76,7 +83,7 @@ struct device *driver_find_device(struct device_driver *drv,
                return NULL;
 
        klist_iter_init_node(&drv->p->klist_devices, &i,
-                            (start ? &start->knode_driver : NULL));
+                            (start ? &start->p->knode_driver : NULL));
        while ((dev = next_device(&i)))
                if (match(dev, data) && get_device(dev))
                        break;
index b7e571031ecd144e12b7b8c361a9e6fb6ffd4961..44699d9dd85c8de9c81d5aa1bc7807d69b370103 100644 (file)
@@ -291,12 +291,6 @@ firmware_class_timeout(u_long data)
        fw_load_abort(fw_priv);
 }
 
-static inline void fw_setup_device_id(struct device *f_dev, struct device *dev)
-{
-       /* XXX warning we should watch out for name collisions */
-       strlcpy(f_dev->bus_id, dev->bus_id, BUS_ID_SIZE);
-}
-
 static int fw_register_device(struct device **dev_p, const char *fw_name,
                              struct device *device)
 {
@@ -321,7 +315,7 @@ static int fw_register_device(struct device **dev_p, const char *fw_name,
        fw_priv->timeout.data = (u_long) fw_priv;
        init_timer(&fw_priv->timeout);
 
-       fw_setup_device_id(f_dev, device);
+       dev_set_name(f_dev, dev_name(device));
        f_dev->parent = device;
        f_dev->class = &firmware_class;
        dev_set_drvdata(f_dev, fw_priv);
index efd5775749485d8ec6bfafa998cd9c6fff53f812..479694b6cbe3995a59bb5a89faf4ca7edffa8d56 100644 (file)
@@ -11,7 +11,7 @@
 #include <linux/isa.h>
 
 static struct device isa_bus = {
-       .bus_id         = "isa"
+       .init_name      = "isa"
 };
 
 struct isa_dev {
@@ -135,9 +135,8 @@ int isa_register_driver(struct isa_driver *isa_driver, unsigned int ndev)
                isa_dev->dev.parent     = &isa_bus;
                isa_dev->dev.bus        = &isa_bus_type;
 
-               snprintf(isa_dev->dev.bus_id, BUS_ID_SIZE, "%s.%u",
-                               isa_driver->driver.name, id);
-
+               dev_set_name(&isa_dev->dev, "%s.%u",
+                            isa_driver->driver.name, id);
                isa_dev->dev.platform_data      = isa_driver;
                isa_dev->dev.release            = isa_dev_release;
                isa_dev->id                     = id;
index dfcbfe504867e9db43ea944c55cda9eae9328556..349a1013603fdb2485b3d82b2454ad1c3b2b3002 100644 (file)
@@ -24,7 +24,7 @@
                                 driver))
 
 struct device platform_bus = {
-       .bus_id         = "platform",
+       .init_name      = "platform",
 };
 EXPORT_SYMBOL_GPL(platform_bus);
 
@@ -242,16 +242,15 @@ int platform_device_add(struct platform_device *pdev)
        pdev->dev.bus = &platform_bus_type;
 
        if (pdev->id != -1)
-               snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%d", pdev->name,
-                        pdev->id);
+               dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
        else
-               strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);
+               dev_set_name(&pdev->dev, pdev->name);
 
        for (i = 0; i < pdev->num_resources; i++) {
                struct resource *p, *r = &pdev->resource[i];
 
                if (r->name == NULL)
-                       r->name = pdev->dev.bus_id;
+                       r->name = dev_name(&pdev->dev);
 
                p = r->parent;
                if (!p) {
@@ -264,14 +263,14 @@ int platform_device_add(struct platform_device *pdev)
                if (p && insert_resource(p, r)) {
                        printk(KERN_ERR
                               "%s: failed to claim resource %d\n",
-                              pdev->dev.bus_id, i);
+                              dev_name(&pdev->dev), i);
                        ret = -EBUSY;
                        goto failed;
                }
        }
 
        pr_debug("Registering platform device '%s'. Parent at %s\n",
-                pdev->dev.bus_id, pdev->dev.parent->bus_id);
+                dev_name(&pdev->dev), dev_name(pdev->dev.parent));
 
        ret = device_add(&pdev->dev);
        if (ret == 0)
@@ -503,8 +502,6 @@ int platform_driver_register(struct platform_driver *drv)
                drv->driver.suspend = platform_drv_suspend;
        if (drv->resume)
                drv->driver.resume = platform_drv_resume;
-       if (drv->pm)
-               drv->driver.pm = &drv->pm->base;
        return driver_register(&drv->driver);
 }
 EXPORT_SYMBOL_GPL(platform_driver_register);
@@ -609,7 +606,7 @@ static int platform_match(struct device *dev, struct device_driver *drv)
        struct platform_device *pdev;
 
        pdev = container_of(dev, struct platform_device, dev);
-       return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
+       return (strcmp(pdev->name, drv->name) == 0);
 }
 
 #ifdef CONFIG_PM_SLEEP
@@ -686,7 +683,10 @@ static int platform_pm_suspend(struct device *dev)
        struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (drv && drv->pm) {
+       if (!drv)
+               return 0;
+
+       if (drv->pm) {
                if (drv->pm->suspend)
                        ret = drv->pm->suspend(dev);
        } else {
@@ -698,16 +698,15 @@ static int platform_pm_suspend(struct device *dev)
 
 static int platform_pm_suspend_noirq(struct device *dev)
 {
-       struct platform_driver *pdrv;
+       struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (!dev->driver)
+       if (!drv)
                return 0;
 
-       pdrv = to_platform_driver(dev->driver);
-       if (pdrv->pm) {
-               if (pdrv->pm->suspend_noirq)
-                       ret = pdrv->pm->suspend_noirq(dev);
+       if (drv->pm) {
+               if (drv->pm->suspend_noirq)
+                       ret = drv->pm->suspend_noirq(dev);
        } else {
                ret = platform_legacy_suspend_late(dev, PMSG_SUSPEND);
        }
@@ -720,7 +719,10 @@ static int platform_pm_resume(struct device *dev)
        struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (drv && drv->pm) {
+       if (!drv)
+               return 0;
+
+       if (drv->pm) {
                if (drv->pm->resume)
                        ret = drv->pm->resume(dev);
        } else {
@@ -732,16 +734,15 @@ static int platform_pm_resume(struct device *dev)
 
 static int platform_pm_resume_noirq(struct device *dev)
 {
-       struct platform_driver *pdrv;
+       struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (!dev->driver)
+       if (!drv)
                return 0;
 
-       pdrv = to_platform_driver(dev->driver);
-       if (pdrv->pm) {
-               if (pdrv->pm->resume_noirq)
-                       ret = pdrv->pm->resume_noirq(dev);
+       if (drv->pm) {
+               if (drv->pm->resume_noirq)
+                       ret = drv->pm->resume_noirq(dev);
        } else {
                ret = platform_legacy_resume_early(dev);
        }
@@ -780,16 +781,15 @@ static int platform_pm_freeze(struct device *dev)
 
 static int platform_pm_freeze_noirq(struct device *dev)
 {
-       struct platform_driver *pdrv;
+       struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (!dev->driver)
+       if (!drv)
                return 0;
 
-       pdrv = to_platform_driver(dev->driver);
-       if (pdrv->pm) {
-               if (pdrv->pm->freeze_noirq)
-                       ret = pdrv->pm->freeze_noirq(dev);
+       if (drv->pm) {
+               if (drv->pm->freeze_noirq)
+                       ret = drv->pm->freeze_noirq(dev);
        } else {
                ret = platform_legacy_suspend_late(dev, PMSG_FREEZE);
        }
@@ -802,7 +802,10 @@ static int platform_pm_thaw(struct device *dev)
        struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (drv && drv->pm) {
+       if (!drv)
+               return 0;
+
+       if (drv->pm) {
                if (drv->pm->thaw)
                        ret = drv->pm->thaw(dev);
        } else {
@@ -814,16 +817,15 @@ static int platform_pm_thaw(struct device *dev)
 
 static int platform_pm_thaw_noirq(struct device *dev)
 {
-       struct platform_driver *pdrv;
+       struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (!dev->driver)
+       if (!drv)
                return 0;
 
-       pdrv = to_platform_driver(dev->driver);
-       if (pdrv->pm) {
-               if (pdrv->pm->thaw_noirq)
-                       ret = pdrv->pm->thaw_noirq(dev);
+       if (drv->pm) {
+               if (drv->pm->thaw_noirq)
+                       ret = drv->pm->thaw_noirq(dev);
        } else {
                ret = platform_legacy_resume_early(dev);
        }
@@ -836,7 +838,10 @@ static int platform_pm_poweroff(struct device *dev)
        struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (drv && drv->pm) {
+       if (!drv)
+               return 0;
+
+       if (drv->pm) {
                if (drv->pm->poweroff)
                        ret = drv->pm->poweroff(dev);
        } else {
@@ -848,16 +853,15 @@ static int platform_pm_poweroff(struct device *dev)
 
 static int platform_pm_poweroff_noirq(struct device *dev)
 {
-       struct platform_driver *pdrv;
+       struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (!dev->driver)
+       if (!drv)
                return 0;
 
-       pdrv = to_platform_driver(dev->driver);
-       if (pdrv->pm) {
-               if (pdrv->pm->poweroff_noirq)
-                       ret = pdrv->pm->poweroff_noirq(dev);
+       if (drv->pm) {
+               if (drv->pm->poweroff_noirq)
+                       ret = drv->pm->poweroff_noirq(dev);
        } else {
                ret = platform_legacy_suspend_late(dev, PMSG_HIBERNATE);
        }
@@ -870,7 +874,10 @@ static int platform_pm_restore(struct device *dev)
        struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (drv && drv->pm) {
+       if (!drv)
+               return 0;
+
+       if (drv->pm) {
                if (drv->pm->restore)
                        ret = drv->pm->restore(dev);
        } else {
@@ -882,16 +889,15 @@ static int platform_pm_restore(struct device *dev)
 
 static int platform_pm_restore_noirq(struct device *dev)
 {
-       struct platform_driver *pdrv;
+       struct device_driver *drv = dev->driver;
        int ret = 0;
 
-       if (!dev->driver)
+       if (!drv)
                return 0;
 
-       pdrv = to_platform_driver(dev->driver);
-       if (pdrv->pm) {
-               if (pdrv->pm->restore_noirq)
-                       ret = pdrv->pm->restore_noirq(dev);
+       if (drv->pm) {
+               if (drv->pm->restore_noirq)
+                       ret = drv->pm->restore_noirq(dev);
        } else {
                ret = platform_legacy_resume_early(dev);
        }
@@ -912,17 +918,15 @@ static int platform_pm_restore_noirq(struct device *dev)
 
 #endif /* !CONFIG_HIBERNATION */
 
-static struct pm_ext_ops platform_pm_ops = {
-       .base = {
-               .prepare = platform_pm_prepare,
-               .complete = platform_pm_complete,
-               .suspend = platform_pm_suspend,
-               .resume = platform_pm_resume,
-               .freeze = platform_pm_freeze,
-               .thaw = platform_pm_thaw,
-               .poweroff = platform_pm_poweroff,
-               .restore = platform_pm_restore,
-       },
+static struct dev_pm_ops platform_dev_pm_ops = {
+       .prepare = platform_pm_prepare,
+       .complete = platform_pm_complete,
+       .suspend = platform_pm_suspend,
+       .resume = platform_pm_resume,
+       .freeze = platform_pm_freeze,
+       .thaw = platform_pm_thaw,
+       .poweroff = platform_pm_poweroff,
+       .restore = platform_pm_restore,
        .suspend_noirq = platform_pm_suspend_noirq,
        .resume_noirq = platform_pm_resume_noirq,
        .freeze_noirq = platform_pm_freeze_noirq,
@@ -931,7 +935,7 @@ static struct pm_ext_ops platform_pm_ops = {
        .restore_noirq = platform_pm_restore_noirq,
 };
 
-#define PLATFORM_PM_OPS_PTR    &platform_pm_ops
+#define PLATFORM_PM_OPS_PTR    (&platform_dev_pm_ops)
 
 #else /* !CONFIG_PM_SLEEP */
 
index 692c20ba51444acaafe4ca2e1c63237afa3e42bf..670c9d6c140743a7fac01bcfada07254d4da5016 100644 (file)
@@ -76,7 +76,7 @@ void device_pm_add(struct device *dev)
        if (dev->parent) {
                if (dev->parent->power.status >= DPM_SUSPENDING)
                        dev_warn(dev, "parent %s should not be sleeping\n",
-                               dev->parent->bus_id);
+                                dev_name(dev->parent));
        } else if (transition_started) {
                /*
                 * We refuse to register parentless devices while a PM
@@ -112,7 +112,8 @@ void device_pm_remove(struct device *dev)
  *     @ops:   PM operations to choose from.
  *     @state: PM transition of the system being carried out.
  */
-static int pm_op(struct device *dev, struct pm_ops *ops, pm_message_t state)
+static int pm_op(struct device *dev, struct dev_pm_ops *ops,
+                       pm_message_t state)
 {
        int error = 0;
 
@@ -174,7 +175,7 @@ static int pm_op(struct device *dev, struct pm_ops *ops, pm_message_t state)
  *     The operation is executed with interrupts disabled by the only remaining
  *     functional CPU in the system.
  */
-static int pm_noirq_op(struct device *dev, struct pm_ext_ops *ops,
+static int pm_noirq_op(struct device *dev, struct dev_pm_ops *ops,
                        pm_message_t state)
 {
        int error = 0;
@@ -354,7 +355,7 @@ static int resume_device(struct device *dev, pm_message_t state)
        if (dev->bus) {
                if (dev->bus->pm) {
                        pm_dev_dbg(dev, state, "");
-                       error = pm_op(dev, &dev->bus->pm->base, state);
+                       error = pm_op(dev, dev->bus->pm, state);
                } else if (dev->bus->resume) {
                        pm_dev_dbg(dev, state, "legacy ");
                        error = dev->bus->resume(dev);
@@ -451,9 +452,9 @@ static void complete_device(struct device *dev, pm_message_t state)
                dev->type->pm->complete(dev);
        }
 
-       if (dev->bus && dev->bus->pm && dev->bus->pm->base.complete) {
+       if (dev->bus && dev->bus->pm && dev->bus->pm->complete) {
                pm_dev_dbg(dev, state, "completing ");
-               dev->bus->pm->base.complete(dev);
+               dev->bus->pm->complete(dev);
        }
 
        up(&dev->sem);
@@ -624,7 +625,7 @@ static int suspend_device(struct device *dev, pm_message_t state)
        if (dev->bus) {
                if (dev->bus->pm) {
                        pm_dev_dbg(dev, state, "");
-                       error = pm_op(dev, &dev->bus->pm->base, state);
+                       error = pm_op(dev, dev->bus->pm, state);
                } else if (dev->bus->suspend) {
                        pm_dev_dbg(dev, state, "legacy ");
                        error = dev->bus->suspend(dev, state);
@@ -685,10 +686,10 @@ static int prepare_device(struct device *dev, pm_message_t state)
 
        down(&dev->sem);
 
-       if (dev->bus && dev->bus->pm && dev->bus->pm->base.prepare) {
+       if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
                pm_dev_dbg(dev, state, "preparing ");
-               error = dev->bus->pm->base.prepare(dev);
-               suspend_report_result(dev->bus->pm->base.prepare, error);
+               error = dev->bus->pm->prepare(dev);
+               suspend_report_result(dev->bus->pm->prepare, error);
                if (error)
                        goto End;
        }
index 2aa6e8fc4defff41ffaa63745baa3a54029ece80..0a1a2c4dbc6e75e5647117b97ae1f055c2fdb080 100644 (file)
@@ -140,7 +140,7 @@ static unsigned int hash_string(unsigned int seed, const char *data, unsigned in
 
 void set_trace_device(struct device *dev)
 {
-       dev_hash_value = hash_string(DEVSEED, dev->bus_id, DEVHASH);
+       dev_hash_value = hash_string(DEVSEED, dev_name(dev), DEVHASH);
 }
 EXPORT_SYMBOL(set_trace_device);
 
@@ -192,7 +192,7 @@ static int show_dev_hash(unsigned int value)
 
        while (entry != &dpm_list) {
                struct device * dev = to_device(entry);
-               unsigned int hash = hash_string(DEVSEED, dev->bus_id, DEVHASH);
+               unsigned int hash = hash_string(DEVSEED, dev_name(dev), DEVHASH);
                if (hash == value) {
                        dev_info(dev, "hash matches\n");
                        match++;
index 4f8d67fed292bfc6a9423a975fb08265dd78f69e..94ad2c3bfc4a290d025bffbbf14481fa1b8dd39d 100644 (file)
@@ -663,7 +663,7 @@ static int __init mwave_init(void)
 #if 0
        /* sysfs */
        memset(&mwave_device, 0, sizeof (struct device));
-       snprintf(mwave_device.bus_id, BUS_ID_SIZE, "mwave");
+       dev_set_name(&mwave_device, "mwave");
 
        if (device_register(&mwave_device))
                goto cleanup_error;
index e880d6c8d8965d88e9fcc9674006cf6b4206a215..5a76d056b9d0d0b1fe9770d9d272413d054afb8b 100644 (file)
@@ -223,7 +223,7 @@ static int __init dmi_id_init(void)
        }
 
        dmi_dev->class = &dmi_class;
-       strcpy(dmi_dev->bus_id, "id");
+       dev_set_name(dmi_dev, "id");
        dmi_dev->groups = sys_dmi_attribute_groups;
 
        ret = device_register(dmi_dev);
index 82020abc329efab1d95f56a1d67e71db2122dc1b..35e7aea4222c478ffc9b93263a339fd0526ab201 100644 (file)
@@ -1213,7 +1213,7 @@ static int gpiolib_show(struct seq_file *s, void *unused)
                if (dev)
                        seq_printf(s, ", %s/%s",
                                dev->bus ? dev->bus->name : "no-bus",
-                               dev->bus_id);
+                               dev_name(dev));
                if (chip->label)
                        seq_printf(s, ", %s", chip->label);
                if (chip->can_sleep)
index 65d72d094c81803757c00133bc9bd58895a2d03a..5aa6780652aa8d920d3591e8f99370a2d677c770 100644 (file)
@@ -488,7 +488,7 @@ int drm_sysfs_device_add(struct drm_minor *minor)
         else
                 minor_str = "card%d";
 
-       snprintf(minor->kdev.bus_id, BUS_ID_SIZE, minor_str, minor->index);
+       dev_set_name(&minor->kdev, minor_str, minor->index);
 
        err = device_register(&minor->kdev);
        if (err) {
index 076a59cdabe9f7a205cedd3883d40416e2e9b9c7..e15c3e7b07e9a1e2314e29090750fd51abadfde7 100644 (file)
@@ -76,7 +76,7 @@ void hwmon_device_unregister(struct device *dev)
 {
        int id;
 
-       if (likely(sscanf(dev->bus_id, HWMON_ID_FORMAT, &id) == 1)) {
+       if (likely(sscanf(dev_name(dev), HWMON_ID_FORMAT, &id) == 1)) {
                device_unregister(dev);
                spin_lock(&idr_lock);
                idr_remove(&hwmon_idr, id);
index 8f9595f2fb5322692e1144dea338c390da73946a..55bd87c15c9a56bf55971ab31d4173fe1b6842d9 100644 (file)
@@ -190,7 +190,7 @@ lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
        }
 
        dev_info(&client->dev, "%s: sensor '%s'\n",
-               data->hwmon_dev->bus_id, client->name);
+                dev_name(data->hwmon_dev), client->name);
 
        return 0;
 
index fb176f6ef9f8a153f4c53c8787dbaef18af5862a..17e8ddd013347623c39d8ecb8e150b99aaa29094 100644 (file)
@@ -177,7 +177,7 @@ static int __init i7300_idle_ioat_selftest(u8 *ctl,
 }
 
 static struct device dummy_dma_dev = {
-       .bus_id = "fallback device",
+       .init_name = "fallback device",
        .coherent_dma_mask = DMA_64BIT_MASK,
        .dma_mask = &dummy_dma_dev.coherent_dma_mask,
 };
index 4f4d1bb9f069fa6a8f61c0027eb1f07c377d3664..b43f7d3682d387eb4de8bf3581a9499660cd97db 100644 (file)
@@ -778,7 +778,7 @@ int ib_device_register_sysfs(struct ib_device *device)
        class_dev->class      = &ib_class;
        class_dev->driver_data = device;
        class_dev->parent     = device->dma_device;
-       strlcpy(class_dev->bus_id, device->name, BUS_ID_SIZE);
+       dev_set_name(class_dev, device->name);
 
        INIT_LIST_HEAD(&device->port_list);
 
index e603736682bfc6e52fbc6f4802375bd329aa7850..51bd9669cb1f7697c0be4e1b4b0c38dc4ee05499 100644 (file)
@@ -1266,8 +1266,7 @@ static void ib_ucm_add_one(struct ib_device *device)
        ucm_dev->dev.parent = device->dma_device;
        ucm_dev->dev.devt = ucm_dev->cdev.dev;
        ucm_dev->dev.release = ib_ucm_release_dev;
-       snprintf(ucm_dev->dev.bus_id, BUS_ID_SIZE, "ucm%d",
-                ucm_dev->devnum);
+       dev_set_name(&ucm_dev->dev, "ucm%d", ucm_dev->devnum);
        if (device_register(&ucm_dev->dev))
                goto err_cdev;
 
index 7c13db885bf67defc836d8d60552865ff0041a62..54c8fe25c4236c07db75d8b0ab4b727cb84593b1 100644 (file)
@@ -1949,8 +1949,7 @@ static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
 
        host->dev.class = &srp_class;
        host->dev.parent = device->dev->dma_device;
-       snprintf(host->dev.bus_id, BUS_ID_SIZE, "srp-%s-%d",
-                device->dev->name, port);
+       dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port);
 
        if (device_register(&host->dev))
                goto free_host;
index 5ee6651b45b903c3e1931fe316956e1166ce5d40..83639be7f7add0a17df3400ae7a8070891ef6154 100644 (file)
@@ -91,7 +91,7 @@ int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
 
        entry->dev.class = elements_class;
        dev_set_drvdata(&entry->dev, elem);
-       snprintf(entry->dev.bus_id, BUS_ID_SIZE, elem->name);
+       dev_set_name(&entry->dev, elem->name);
        ret = device_register(&entry->dev);
        if (ret) {
                printk(KERN_ERR "%s: failed to register %s\n",
index 915da6b8c924a87baeaab1edd924baff7a213f10..b4d44e571d76efca7a3a2f52ccdcecacf2bbe23f 100644 (file)
@@ -321,10 +321,7 @@ static struct virtio_config_ops lguest_config_ops = {
 
 /* The root device for the lguest virtio devices.  This makes them appear as
  * /sys/devices/lguest/0,1,2 not /sys/devices/0,1,2. */
-static struct device lguest_root = {
-       .parent = NULL,
-       .bus_id = "lguest",
-};
+static struct device *lguest_root;
 
 /*D:120 This is the core of the lguest bus: actually adding a new device.
  * It's a separate function because it's neater that way, and because an
@@ -351,7 +348,7 @@ static void add_lguest_device(struct lguest_device_desc *d,
        }
 
        /* This devices' parent is the lguest/ dir. */
-       ldev->vdev.dev.parent = &lguest_root;
+       ldev->vdev.dev.parent = lguest_root;
        /* We have a unique device index thanks to the dev_index counter. */
        ldev->vdev.id.device = d->type;
        /* We have a simple set of routines for querying the device's
@@ -407,7 +404,8 @@ static int __init lguest_devices_init(void)
        if (strcmp(pv_info.name, "lguest") != 0)
                return 0;
 
-       if (device_register(&lguest_root) != 0)
+       lguest_root = root_device_register("lguest");
+       if (IS_ERR(lguest_root))
                panic("Could not register lguest root");
 
        /* Devices are in a single page above top of "normal" mem */
index ec9e5f32f0ae3d3cf9c2ecc1cc34ce35d8a183d9..6e149f4a1fff6d1b21decd90fe5109cdc06fa2db 100644 (file)
@@ -33,7 +33,7 @@
 
 #undef DEBUG
 
-#define MAX_NODE_NAME_SIZE (BUS_ID_SIZE - 12)
+#define MAX_NODE_NAME_SIZE (20 - 12)
 
 static struct macio_chip      *macio_on_hold;
 
@@ -240,7 +240,7 @@ static void macio_create_fixup_irq(struct macio_dev *dev, int index,
        if (irq != NO_IRQ) {
                dev->interrupt[index].start = irq;
                dev->interrupt[index].flags = IORESOURCE_IRQ;
-               dev->interrupt[index].name = dev->ofdev.dev.bus_id;
+               dev->interrupt[index].name = dev_name(&dev->ofdev.dev);
        }
        if (dev->n_interrupts <= index)
                dev->n_interrupts = index + 1;
@@ -303,7 +303,7 @@ static void macio_setup_interrupts(struct macio_dev *dev)
                        break;
                res->start = irq;
                res->flags = IORESOURCE_IRQ;
-               res->name = dev->ofdev.dev.bus_id;
+               res->name = dev_name(&dev->ofdev.dev);
                if (macio_resource_quirks(np, res, i - 1)) {
                        memset(res, 0, sizeof(struct resource));
                        continue;
@@ -325,7 +325,7 @@ static void macio_setup_resources(struct macio_dev *dev,
                if (index >= MACIO_DEV_COUNT_RESOURCES)
                        break;
                *res = r;
-               res->name = dev->ofdev.dev.bus_id;
+               res->name = dev_name(&dev->ofdev.dev);
 
                if (macio_resource_quirks(np, res, index)) {
                        memset(res, 0, sizeof(struct resource));
@@ -338,7 +338,7 @@ static void macio_setup_resources(struct macio_dev *dev,
                if (insert_resource(parent_res, res)) {
                        printk(KERN_WARNING "Can't request resource "
                               "%d for MacIO device %s\n",
-                              index, dev->ofdev.dev.bus_id);
+                              index, dev_name(&dev->ofdev.dev));
                }
        }
        dev->n_resources = index;
@@ -385,8 +385,8 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
 
        /* MacIO itself has a different reg, we use it's PCI base */
        if (np == chip->of_node) {
-               sprintf(dev->ofdev.dev.bus_id, "%1d.%08x:%.*s",
-                       chip->lbus.index,
+               dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
+                            chip->lbus.index,
 #ifdef CONFIG_PCI
                        (unsigned int)pci_resource_start(chip->lbus.pdev, 0),
 #else
@@ -395,9 +395,9 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
                        MAX_NODE_NAME_SIZE, np->name);
        } else {
                reg = of_get_property(np, "reg", NULL);
-               sprintf(dev->ofdev.dev.bus_id, "%1d.%08x:%.*s",
-                       chip->lbus.index,
-                       reg ? *reg : 0, MAX_NODE_NAME_SIZE, np->name);
+               dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
+                            chip->lbus.index,
+                            reg ? *reg : 0, MAX_NODE_NAME_SIZE, np->name);
        }
 
        /* Setup interrupts & resources */
@@ -408,7 +408,7 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
        /* Register with core */
        if (of_device_register(&dev->ofdev) != 0) {
                printk(KERN_DEBUG"macio: device registration error for %s!\n",
-                      dev->ofdev.dev.bus_id);
+                      dev_name(&dev->ofdev.dev));
                kfree(dev);
                return NULL;
        }
@@ -558,7 +558,7 @@ err_out:
                resource_no,
                macio_resource_len(dev, resource_no),
                macio_resource_start(dev, resource_no),
-               dev->ofdev.dev.bus_id);
+               dev_name(&dev->ofdev.dev));
        return -EBUSY;
 }
 
index cea46906408ecbc090aa988b51d7abe1fbf1b666..a5b448ea4eab54372a2263688cf04d2243775356 100644 (file)
@@ -385,8 +385,7 @@ static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
 
        if (card) {
                card->host = host;
-               snprintf(card->dev.bus_id, sizeof(card->dev.bus_id),
-                        "%s", host->dev.bus_id);
+               dev_set_name(&card->dev, "%s", dev_name(&host->dev));
                card->dev.parent = &host->dev;
                card->dev.bus = &memstick_bus_type;
                card->dev.release = memstick_free_card;
@@ -519,7 +518,7 @@ int memstick_add_host(struct memstick_host *host)
        if (rc)
                return rc;
 
-       snprintf(host->dev.bus_id, BUS_ID_SIZE, "memstick%u", host->id);
+       dev_set_name(&host->dev, "memstick%u", host->id);
 
        rc = device_add(&host->dev);
        if (rc) {
index 7911151e56a34f2873d21aa45661d5a80252cd35..1f1e3982b1aa9499dcc996f08f084c3b20cebc17 100644 (file)
@@ -887,14 +887,14 @@ try_again:
        if (rc) {
                printk(KERN_WARNING
                       "%s: could not switch to 4-bit mode, error %d\n",
-                      card->dev.bus_id, rc);
+                      dev_name(&card->dev), rc);
                return 0;
        }
 
        msb->system = MEMSTICK_SYS_PAR4;
        host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_PAR4);
        printk(KERN_INFO "%s: switching to 4-bit parallel mode\n",
-              card->dev.bus_id);
+              dev_name(&card->dev));
 
        if (msb->caps & MEMSTICK_CAP_PAR8) {
                rc = mspro_block_set_interface(card, MEMSTICK_SYS_PAR8);
@@ -905,11 +905,11 @@ try_again:
                                        MEMSTICK_PAR8);
                        printk(KERN_INFO
                               "%s: switching to 8-bit parallel mode\n",
-                              card->dev.bus_id);
+                              dev_name(&card->dev));
                } else
                        printk(KERN_WARNING
                               "%s: could not switch to 8-bit mode, error %d\n",
-                              card->dev.bus_id, rc);
+                              dev_name(&card->dev), rc);
        }
 
        card->next_request = h_mspro_block_req_init;
@@ -922,7 +922,7 @@ try_again:
        if (rc) {
                printk(KERN_WARNING
                       "%s: interface error, trying to fall back to serial\n",
-                      card->dev.bus_id);
+                      dev_name(&card->dev));
                msb->system = MEMSTICK_SYS_SERIAL;
                host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_OFF);
                msleep(10);
@@ -992,14 +992,14 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
 
        if (be16_to_cpu(attr->signature) != MSPRO_BLOCK_SIGNATURE) {
                printk(KERN_ERR "%s: unrecognized device signature %x\n",
-                      card->dev.bus_id, be16_to_cpu(attr->signature));
+                      dev_name(&card->dev), be16_to_cpu(attr->signature));
                rc = -ENODEV;
                goto out_free_attr;
        }
 
        if (attr->count > MSPRO_BLOCK_MAX_ATTRIBUTES) {
                printk(KERN_WARNING "%s: way too many attribute entries\n",
-                      card->dev.bus_id);
+                      dev_name(&card->dev));
                attr_count = MSPRO_BLOCK_MAX_ATTRIBUTES;
        } else
                attr_count = attr->count;
index d32d6ad8f3fc5ab51017a6350c7d68aa4c42736b..03f71a431c8207f403fcf1924ffe3b9f3ce36659 100644 (file)
@@ -546,7 +546,7 @@ static void tifm_ms_abort(unsigned long data)
        printk(KERN_ERR
               "%s : card failed to respond for a long period of time "
               "(%x, %x)\n",
-              host->dev->dev.bus_id, host->req ? host->req->tpc : 0,
+              dev_name(&host->dev->dev), host->req ? host->req->tpc : 0,
               host->cmd_flags);
 
        tifm_eject(host->dev);
@@ -561,7 +561,7 @@ static int tifm_ms_probe(struct tifm_dev *sock)
        if (!(TIFM_SOCK_STATE_OCCUPIED
              & readl(sock->addr + SOCK_PRESENT_STATE))) {
                printk(KERN_WARNING "%s : card gone, unexpectedly\n",
-                      sock->dev.bus_id);
+                      dev_name(&sock->dev));
                return rc;
        }
 
index c455da4ff4116dfc727741786a08ade1b822ffda..0ee4264f5db772a6cb27594b5ce51906901fe3cf 100644 (file)
@@ -132,7 +132,7 @@ static void i2o_device_release(struct device *dev)
 {
        struct i2o_device *i2o_dev = to_i2o_device(dev);
 
-       pr_debug("i2o: device %s released\n", dev->bus_id);
+       pr_debug("i2o: device %s released\n", dev_name(dev));
 
        kfree(i2o_dev);
 }
@@ -227,8 +227,8 @@ static int i2o_device_add(struct i2o_controller *c, i2o_lct_entry *entry)
 
        i2o_dev->lct_data = *entry;
 
-       snprintf(i2o_dev->device.bus_id, BUS_ID_SIZE, "%d:%03x", c->unit,
-                i2o_dev->lct_data.tid);
+       dev_set_name(&i2o_dev->device, "%d:%03x", c->unit,
+                    i2o_dev->lct_data.tid);
 
        i2o_dev->iop = c;
        i2o_dev->device.parent = &c->device;
@@ -279,7 +279,7 @@ static int i2o_device_add(struct i2o_controller *c, i2o_lct_entry *entry)
 
        i2o_driver_notify_device_add_all(i2o_dev);
 
-       pr_debug("i2o: device %s added\n", i2o_dev->device.bus_id);
+       pr_debug("i2o: device %s added\n", dev_name(&i2o_dev->device));
 
        return 0;
 
index 54a3016ff45de24afd2430ff538c6d3bb9bf6484..9a36b5a7de5736365f356190877a6947f2048246 100644 (file)
@@ -1300,7 +1300,7 @@ static int i2o_seq_show_dev_name(struct seq_file *seq, void *v)
 {
        struct i2o_device *d = (struct i2o_device *)seq->private;
 
-       seq_printf(seq, "%s\n", d->device.bus_id);
+       seq_printf(seq, "%s\n", dev_name(&d->device));
 
        return 0;
 }
index 35c67d1f255e8c168f2ecc0dd11422be33fe2b73..27cf4af0e13d425ae4af648e31372a7eb09b6025 100644 (file)
@@ -1072,7 +1072,7 @@ struct i2o_controller *i2o_iop_alloc(void)
 
        c->device.release = &i2o_iop_release;
 
-       snprintf(c->device.bus_id, BUS_ID_SIZE, "iop%d", c->unit);
+       dev_set_name(&c->device, "iop%d", c->unit);
 
 #if BITS_PER_LONG == 64
        spin_lock_init(&c->context_list_lock);
index e11e1ac509002c862553744d606e4582b2bf3238..3d2fc216bae5b561dea357cd86d1661803a0377d 100644 (file)
@@ -29,7 +29,7 @@ static struct device_driver gru_driver = {
 };
 
 static struct device gru_device = {
-       .bus_id = {0},
+       .init_name = "",
        .driver = &gru_driver,
 };
 
index 9a2e77172d942f548402e9ce8ccce25d9e3bf935..16f8dcab2da4ba9c63342ed7766a6c741da2b020 100644 (file)
@@ -25,7 +25,7 @@ struct device_driver xp_dbg_name = {
 };
 
 struct device xp_dbg_subname = {
-       .bus_id = {0},          /* set to "" */
+       .init_name = "",                /* set to "" */
        .driver = &xp_dbg_name
 };
 
index e8d5cfbd32c21946238c92b0517f8c2aca6827b7..89218f7cfaa72e272aba75ebb99ab43c87359e71 100644 (file)
@@ -59,12 +59,12 @@ struct device_driver xpc_dbg_name = {
 };
 
 struct device xpc_part_dbg_subname = {
-       .bus_id = {0},          /* set to "part" at xpc_init() time */
+       .init_name = "",        /* set to "part" at xpc_init() time */
        .driver = &xpc_dbg_name
 };
 
 struct device xpc_chan_dbg_subname = {
-       .bus_id = {0},          /* set to "chan" at xpc_init() time */
+       .init_name = "",        /* set to "chan" at xpc_init() time */
        .driver = &xpc_dbg_name
 };
 
@@ -1258,8 +1258,8 @@ xpc_init(void)
        int ret;
        struct task_struct *kthread;
 
-       snprintf(xpc_part->bus_id, BUS_ID_SIZE, "part");
-       snprintf(xpc_chan->bus_id, BUS_ID_SIZE, "chan");
+       dev_set_name(xpc_part, "part");
+       dev_set_name(xpc_chan, "chan");
 
        if (is_shub()) {
                /*
index 8e6aa9508f4603dd2f4fa3f986e2612693da78f7..81152b3e360c759fa354caee56e00f09c0b3d2be 100644 (file)
@@ -138,7 +138,7 @@ struct device_driver xpnet_dbg_name = {
 };
 
 struct device xpnet_dbg_subname = {
-       .bus_id = {0},          /* set to "" */
+       .init_name = "",        /* set to "" */
        .driver = &xpnet_dbg_name
 };
 
index af6173319e070c9f041506bced6e38c7edac701a..be5672a98702615bb21585871ad0b2deefc8efdb 100644 (file)
@@ -164,7 +164,7 @@ static void tifm_7xx1_switch_media(struct work_struct *work)
                if (sock) {
                        printk(KERN_INFO
                               "%s : demand removing card from socket %u:%u\n",
-                              fm->dev.bus_id, fm->id, cnt);
+                              dev_name(&fm->dev), fm->id, cnt);
                        fm->sockets[cnt] = NULL;
                        sock_addr = sock->addr;
                        spin_unlock_irqrestore(&fm->lock, flags);
index 82dc72a1484f888b29665151d61fb35e7aa169e3..98bcba521da2ab6c8d658f07a547476a51b3326c 100644 (file)
@@ -203,7 +203,7 @@ int tifm_add_adapter(struct tifm_adapter *fm)
        if (rc)
                return rc;
 
-       snprintf(fm->dev.bus_id, BUS_ID_SIZE, "tifm%u", fm->id);
+       dev_set_name(&fm->dev, "tifm%u", fm->id);
        rc = device_add(&fm->dev);
        if (rc) {
                spin_lock(&tifm_adapter_lock);
@@ -266,9 +266,8 @@ struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id,
                sock->dev.dma_mask = fm->dev.parent->dma_mask;
                sock->dev.release = tifm_free_device;
 
-               snprintf(sock->dev.bus_id, BUS_ID_SIZE,
-                        "tifm_%s%u:%u", tifm_media_type_name(type, 2),
-                        fm->id, id);
+               dev_set_name(&sock->dev, "tifm_%s%u:%u",
+                            tifm_media_type_name(type, 2), fm->id, id);
                printk(KERN_INFO DRIVER_NAME
                       ": %s card detected in socket %u:%u\n",
                       tifm_media_type_name(type, 0), fm->id, id);
index 6659b2275c0c6a5ce150906c25ac1d106700065a..5733f0643843a78e129e0c83a0ba6c9bd368ff7b 100644 (file)
@@ -170,7 +170,7 @@ static int wait_till_ready(struct m25p *flash)
 static int erase_chip(struct m25p *flash)
 {
        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %dKiB\n",
-                       flash->spi->dev.bus_id, __func__,
+                       dev_name(&flash->spi->dev), __func__,
                        flash->mtd.size / 1024);
 
        /* Wait until finished previous write command. */
@@ -197,7 +197,7 @@ static int erase_chip(struct m25p *flash)
 static int erase_sector(struct m25p *flash, u32 offset)
 {
        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %dKiB at 0x%08x\n",
-                       flash->spi->dev.bus_id, __func__,
+                       dev_name(&flash->spi->dev), __func__,
                        flash->mtd.erasesize / 1024, offset);
 
        /* Wait until finished previous write command. */
@@ -234,7 +234,7 @@ static int m25p80_erase(struct mtd_info *mtd, struct erase_info *instr)
        u32 addr,len;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %d\n",
-                       flash->spi->dev.bus_id, __func__, "at",
+                       dev_name(&flash->spi->dev), __func__, "at",
                        (u32)instr->addr, instr->len);
 
        /* sanity checks */
@@ -295,7 +295,7 @@ static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
        struct spi_message m;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
-                       flash->spi->dev.bus_id, __func__, "from",
+                       dev_name(&flash->spi->dev), __func__, "from",
                        (u32)from, len);
 
        /* sanity checks */
@@ -367,7 +367,7 @@ static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
        struct spi_message m;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
-                       flash->spi->dev.bus_id, __func__, "to",
+                       dev_name(&flash->spi->dev), __func__, "to",
                        (u32)to, len);
 
        if (retlen)
@@ -563,7 +563,7 @@ static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
        tmp = spi_write_then_read(spi, &code, 1, id, 5);
        if (tmp < 0) {
                DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
-                       spi->dev.bus_id, tmp);
+                       dev_name(&spi->dev), tmp);
                return NULL;
        }
        jedec = id[0];
@@ -617,7 +617,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
                /* unrecognized chip? */
                if (i == ARRAY_SIZE(m25p_data)) {
                        DEBUG(MTD_DEBUG_LEVEL0, "%s: unrecognized id %s\n",
-                                       spi->dev.bus_id, data->type);
+                                       dev_name(&spi->dev), data->type);
                        info = NULL;
 
                /* recognized; is that chip really what's there? */
@@ -658,7 +658,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
        if (data && data->name)
                flash->mtd.name = data->name;
        else
-               flash->mtd.name = spi->dev.bus_id;
+               flash->mtd.name = dev_name(&spi->dev);
 
        flash->mtd.type = MTD_NORFLASH;
        flash->mtd.writesize = 1;
index 6dd9aff8bb2d37181fb711c98f9d839f1fd52a15..65126cd668ff3fbdeaf1437a4a1aeb7168ad4cd5 100644 (file)
@@ -128,7 +128,7 @@ static int dataflash_waitready(struct spi_device *spi)
                status = dataflash_status(spi);
                if (status < 0) {
                        DEBUG(MTD_DEBUG_LEVEL1, "%s: status %d?\n",
-                                       spi->dev.bus_id, status);
+                                       dev_name(&spi->dev), status);
                        status = 0;
                }
 
@@ -154,7 +154,7 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
        uint8_t                 *command;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: erase addr=0x%x len 0x%x\n",
-                       spi->dev.bus_id,
+                       dev_name(&spi->dev),
                        instr->addr, instr->len);
 
        /* Sanity checks */
@@ -197,7 +197,7 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
 
                if (status < 0) {
                        printk(KERN_ERR "%s: erase %x, err %d\n",
-                               spi->dev.bus_id, pageaddr, status);
+                               dev_name(&spi->dev), pageaddr, status);
                        /* REVISIT:  can retry instr->retries times; or
                         * giveup and instr->fail_addr = instr->addr;
                         */
@@ -239,7 +239,7 @@ static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,
        int                     status;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: read 0x%x..0x%x\n",
-               priv->spi->dev.bus_id, (unsigned)from, (unsigned)(from + len));
+               dev_name(&priv->spi->dev), (unsigned)from, (unsigned)(from + len));
 
        *retlen = 0;
 
@@ -288,7 +288,7 @@ static int dataflash_read(struct mtd_info *mtd, loff_t from, size_t len,
                status = 0;
        } else
                DEBUG(MTD_DEBUG_LEVEL1, "%s: read %x..%x --> %d\n",
-                       priv->spi->dev.bus_id,
+                       dev_name(&priv->spi->dev),
                        (unsigned)from, (unsigned)(from + len),
                        status);
        return status;
@@ -315,7 +315,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
        uint8_t                 *command;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: write 0x%x..0x%x\n",
-               spi->dev.bus_id, (unsigned)to, (unsigned)(to + len));
+               dev_name(&spi->dev), (unsigned)to, (unsigned)(to + len));
 
        *retlen = 0;
 
@@ -374,7 +374,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
                        status = spi_sync(spi, &msg);
                        if (status < 0)
                                DEBUG(MTD_DEBUG_LEVEL1, "%s: xfer %u -> %d \n",
-                                       spi->dev.bus_id, addr, status);
+                                       dev_name(&spi->dev), addr, status);
 
                        (void) dataflash_waitready(priv->spi);
                }
@@ -396,7 +396,7 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
                spi_transfer_del(x + 1);
                if (status < 0)
                        DEBUG(MTD_DEBUG_LEVEL1, "%s: pgm %u/%u -> %d \n",
-                               spi->dev.bus_id, addr, writelen, status);
+                               dev_name(&spi->dev), addr, writelen, status);
 
                (void) dataflash_waitready(priv->spi);
 
@@ -416,14 +416,14 @@ static int dataflash_write(struct mtd_info *mtd, loff_t to, size_t len,
                status = spi_sync(spi, &msg);
                if (status < 0)
                        DEBUG(MTD_DEBUG_LEVEL1, "%s: compare %u -> %d \n",
-                               spi->dev.bus_id, addr, status);
+                               dev_name(&spi->dev), addr, status);
 
                status = dataflash_waitready(priv->spi);
 
                /* Check result of the compare operation */
                if (status & (1 << 6)) {
                        printk(KERN_ERR "%s: compare page %u, err %d\n",
-                               spi->dev.bus_id, pageaddr, status);
+                               dev_name(&spi->dev), pageaddr, status);
                        remaining = 0;
                        status = -EIO;
                        break;
@@ -779,7 +779,7 @@ static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
        tmp = spi_write_then_read(spi, &code, 1, id, 3);
        if (tmp < 0) {
                DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
-                       spi->dev.bus_id, tmp);
+                       dev_name(&spi->dev), tmp);
                return ERR_PTR(tmp);
        }
        if (id[0] != 0x1f)
@@ -869,7 +869,7 @@ static int __devinit dataflash_probe(struct spi_device *spi)
        status = dataflash_status(spi);
        if (status <= 0 || status == 0xff) {
                DEBUG(MTD_DEBUG_LEVEL1, "%s: status error %d\n",
-                               spi->dev.bus_id, status);
+                               dev_name(&spi->dev), status);
                if (status == 0 || status == 0xff)
                        status = -ENODEV;
                return status;
@@ -905,13 +905,13 @@ static int __devinit dataflash_probe(struct spi_device *spi)
        /* obsolete AT45DB1282 not (yet?) supported */
        default:
                DEBUG(MTD_DEBUG_LEVEL1, "%s: unsupported device (%x)\n",
-                               spi->dev.bus_id, status & 0x3c);
+                               dev_name(&spi->dev), status & 0x3c);
                status = -ENODEV;
        }
 
        if (status < 0)
                DEBUG(MTD_DEBUG_LEVEL1, "%s: add_dataflash --> %d\n",
-                               spi->dev.bus_id, status);
+                               dev_name(&spi->dev), status);
 
        return status;
 }
@@ -921,7 +921,7 @@ static int __devexit dataflash_remove(struct spi_device *spi)
        struct dataflash        *flash = dev_get_drvdata(&spi->dev);
        int                     status;
 
-       DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", spi->dev.bus_id);
+       DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", dev_name(&spi->dev));
 
        if (mtd_has_partitions() && flash->partitioned)
                status = del_mtd_partitions(&flash->mtd);
index 7100ee3c7b01fa0e8caf00a969c2c78449a2d3d5..d2ec262666c7135fc245aa90f0a0b4dc404350b7 100644 (file)
@@ -105,7 +105,7 @@ static int armflash_probe(struct platform_device *dev)
        info->map.bankwidth     = plat->width;
        info->map.phys          = res->start;
        info->map.virt          = base;
-       info->map.name          = dev->dev.bus_id;
+       info->map.name          = dev_name(&dev->dev);
        info->map.set_vpp       = armflash_set_vpp;
 
        simple_map_init(&info->map);
index 3ea1de9be7203aedb92ae1014db058eba4d3620e..d4fb9a3ab4dfd88bd4c7a9d456f25d7613b449cc 100644 (file)
@@ -188,7 +188,7 @@ static int ixp2000_flash_probe(struct platform_device *dev)
         */
        info->map.map_priv_2 = (unsigned long) ixp_data->bank_setup;
 
-       info->map.name = dev->dev.bus_id;
+       info->map.name = dev_name(&dev->dev);
        info->map.read = ixp2000_flash_read8;
        info->map.write = ixp2000_flash_write8;
        info->map.copy_from = ixp2000_flash_copy_from;
@@ -196,7 +196,7 @@ static int ixp2000_flash_probe(struct platform_device *dev)
 
        info->res = request_mem_region(dev->resource->start,
                        dev->resource->end - dev->resource->start + 1,
-                       dev->dev.bus_id);
+                       dev_name(&dev->dev));
        if (!info->res) {
                dev_err(&dev->dev, "Could not reserve memory region\n");
                err = -ENOMEM;
index 16555cbeaea4572e383189ea88f3f153338431b8..7214b876febaea91e339e5964a0d6c1cb463899f 100644 (file)
@@ -218,7 +218,7 @@ static int ixp4xx_flash_probe(struct platform_device *dev)
         * handle that.
         */
        info->map.bankwidth = 2;
-       info->map.name = dev->dev.bus_id;
+       info->map.name = dev_name(&dev->dev);
        info->map.read = ixp4xx_read16,
        info->map.write = ixp4xx_probe_write16,
        info->map.copy_from = ixp4xx_copy_from,
index 05f276af15da39043f0c5f7ee893e70a7f9df826..7e50e9b1b781fa964893d2a44b017c6a84facfde 100644 (file)
@@ -101,7 +101,7 @@ static int __init omapflash_probe(struct platform_device *pdev)
                err = -ENOMEM;
                goto out_release_mem_region;
        }
-       info->map.name          = pdev->dev.bus_id;
+       info->map.name          = dev_name(&pdev->dev);
        info->map.phys          = res->start;
        info->map.size          = size;
        info->map.bankwidth     = pdata->width;
index dfbf3f270cea9441a7261b69ca3c9f8aa9c87770..1db16e549e38422ddb9cc6dee3707a1f00b5195a 100644 (file)
@@ -108,13 +108,13 @@ static int physmap_flash_probe(struct platform_device *dev)
                if (!devm_request_mem_region(&dev->dev,
                        dev->resource[i].start,
                        dev->resource[i].end - dev->resource[i].start + 1,
-                       dev->dev.bus_id)) {
+                       dev_name(&dev->dev))) {
                        dev_err(&dev->dev, "Could not reserve memory region\n");
                        err = -ENOMEM;
                        goto err_out;
                }
 
-               info->map[i].name = dev->dev.bus_id;
+               info->map[i].name = dev_name(&dev->dev);
                info->map[i].phys = dev->resource[i].start;
                info->map[i].size = dev->resource[i].end - dev->resource[i].start + 1;
                info->map[i].bankwidth = physmap_data->width;
@@ -150,7 +150,7 @@ static int physmap_flash_probe(struct platform_device *dev)
                 * We detected multiple devices. Concatenate them together.
                 */
 #ifdef CONFIG_MTD_CONCAT
-               info->cmtd = mtd_concat_create(info->mtd, devices_found, dev->dev.bus_id);
+               info->cmtd = mtd_concat_create(info->mtd, devices_found, dev_name(&dev->dev));
                if (info->cmtd == NULL)
                        err = -ENXIO;
 #else
index 5fcfec034a9466819f83fb5ae00670e1c7fa976a..fbf0ca939d723ba7121f2ca14c4d85a2a603a0ef 100644 (file)
@@ -183,7 +183,7 @@ static int __devinit of_flash_probe(struct of_device *dev,
 
        err = -EBUSY;
        info->res = request_mem_region(res.start, res.end - res.start + 1,
-                                      dev->dev.bus_id);
+                                      dev_name(&dev->dev));
        if (!info->res)
                goto err_out;
 
@@ -194,7 +194,7 @@ static int __devinit of_flash_probe(struct of_device *dev,
                goto err_out;
        }
 
-       info->map.name = dev->dev.bus_id;
+       info->map.name = dev_name(&dev->dev);
        info->map.phys = res.start;
        info->map.size = res.end - res.start + 1;
        info->map.bankwidth = *width;
index 789842d0e6f21352023729c4037327205dccc067..1a05cf37851e137177708a1874ae1053cb963bc1 100644 (file)
@@ -691,7 +691,7 @@ static int concat_block_markbad(struct mtd_info *mtd, loff_t ofs)
  */
 struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],  /* subdevices to concatenate */
                                   int num_devs,        /* number of subdevices      */
-                                  char *name)
+                                  const char *name)
 {                              /* name for the new device   */
        int i;
        size_t size;
index a83192f80eba5176b6bbad4649bd5996159b086a..7815a404a63287a04ec4c25e4a77afbc8a1b6a8e 100644 (file)
@@ -222,7 +222,7 @@ static int __devinit fun_probe(struct of_device *ofdev,
 
        fun->rnb_gpio = of_get_gpio(ofdev->node, 0);
        if (fun->rnb_gpio >= 0) {
-               ret = gpio_request(fun->rnb_gpio, ofdev->dev.bus_id);
+               ret = gpio_request(fun->rnb_gpio, dev_name(&ofdev->dev));
                if (ret) {
                        dev_err(&ofdev->dev, "can't request RNB gpio\n");
                        goto err2;
index f674c5427b17c5a7783a38f1b178848070705de9..75f9f4874ecfad57195220f720181b18c486862f 100644 (file)
@@ -54,7 +54,7 @@ static int __init plat_nand_probe(struct platform_device *pdev)
        data->chip.priv = &data;
        data->mtd.priv = &data->chip;
        data->mtd.owner = THIS_MODULE;
-       data->mtd.name = pdev->dev.bus_id;
+       data->mtd.name = dev_name(&pdev->dev);
 
        data->chip.IO_ADDR_R = data->io_base;
        data->chip.IO_ADDR_W = data->io_base;
index edb1e322113d20905e9d02f7fac26489748d6480..daa6a4c3b8cecc885a32a328a5cc71cc93907b73 100644 (file)
@@ -433,7 +433,7 @@ static int tmio_probe(struct platform_device *dev)
        nand_chip->chip_delay = 15;
 
        retval = request_irq(irq, &tmio_irq,
-                               IRQF_DISABLED, dev->dev.bus_id, tmio);
+                               IRQF_DISABLED, dev_name(&dev->dev), tmio);
        if (retval) {
                dev_err(&dev->dev, "request_irq error %d\n", retval);
                goto err_irq;
index ad81ab8e95e2ca5f3d9cdea4e2b50472c282e202..5b69e7773c6c2a826ac8b3983913e5df749db549 100644 (file)
@@ -63,7 +63,7 @@ static int __devinit generic_onenand_probe(struct device *dev)
        info->onenand.mmcontrol = pdata->mmcontrol;
        info->onenand.irq = platform_get_irq(pdev, 0);
 
-       info->mtd.name = pdev->dev.bus_id;
+       info->mtd.name = dev_name(&pdev->dev);
        info->mtd.priv = &info->onenand;
        info->mtd.owner = THIS_MODULE;
 
index d1e0b8e7224bfa32a87aa8d5dabb37c657b8ae34..96ecc1766fa80346ebf825b42ad8f5cff1cb13be 100644 (file)
@@ -668,7 +668,7 @@ static int __devinit omap2_onenand_probe(struct platform_device *pdev)
                 c->onenand.base);
 
        c->pdev = pdev;
-       c->mtd.name = pdev->dev.bus_id;
+       c->mtd.name = dev_name(&pdev->dev);
        c->mtd.priv = &c->onenand;
        c->mtd.owner = THIS_MODULE;
 
index ba0bd3d5775be9933a0e3da5e15cf8caf366bf6d..7caf22cd5ad0e724919dd4157b4c218505a622b7 100644 (file)
@@ -280,7 +280,7 @@ static int ubi_sysfs_init(struct ubi_device *ubi)
        ubi->dev.release = dev_release;
        ubi->dev.devt = ubi->cdev.dev;
        ubi->dev.class = ubi_class;
-       sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num);
+       dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
        err = device_register(&ubi->dev);
        if (err)
                return err;
index 3531ca9a1e24e9ec4721b21eea4a7c77244d7db8..22e1d7398fce36b83166940f085fae37126a3d18 100644 (file)
@@ -329,7 +329,7 @@ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
        vol->dev.devt = dev;
        vol->dev.class = ubi_class;
 
-       sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
+       dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
        err = device_register(&vol->dev);
        if (err) {
                ubi_err("cannot register device");
@@ -678,7 +678,7 @@ int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
        vol->dev.parent = &ubi->dev;
        vol->dev.devt = dev;
        vol->dev.class = ubi_class;
-       sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
+       dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
        err = device_register(&vol->dev);
        if (err)
                goto out_gluebi;
index b4cdd690ae71ca9d05811a6ce6cd9bcd0de15b20..99d867bcf22aba89ba52e911b641757f6d971fc9 100644 (file)
@@ -300,6 +300,14 @@ static void pci_device_shutdown(struct device *dev)
 
 #ifdef CONFIG_PM_SLEEP
 
+static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
+{
+       struct pci_driver *drv = pci_dev->driver;
+
+       return drv && (drv->suspend || drv->suspend_late || drv->resume
+               || drv->resume_early);
+}
+
 /*
  * Default "suspend" method for devices that have no driver provided suspend,
  * or not even a driver at all.
@@ -317,14 +325,22 @@ static void pci_default_pm_suspend(struct pci_dev *pci_dev)
 
 /*
  * Default "resume" method for devices that have no driver provided resume,
- * or not even a driver at all.
+ * or not even a driver at all (first part).
  */
-static int pci_default_pm_resume(struct pci_dev *pci_dev)
+static void pci_default_pm_resume_early(struct pci_dev *pci_dev)
 {
-       int retval = 0;
-
        /* restore the PCI config space */
        pci_restore_state(pci_dev);
+}
+
+/*
+ * Default "resume" method for devices that have no driver provided resume,
+ * or not even a driver at all (second part).
+ */
+static int pci_default_pm_resume_late(struct pci_dev *pci_dev)
+{
+       int retval;
+
        /* if the device was enabled before suspend, reenable */
        retval = pci_reenable_device(pci_dev);
        /*
@@ -371,10 +387,12 @@ static int pci_legacy_resume(struct device *dev)
        struct pci_dev * pci_dev = to_pci_dev(dev);
        struct pci_driver * drv = pci_dev->driver;
 
-       if (drv && drv->resume)
+       if (drv && drv->resume) {
                error = drv->resume(pci_dev);
-       else
-               error = pci_default_pm_resume(pci_dev);
+       } else {
+               pci_default_pm_resume_early(pci_dev);
+               error = pci_default_pm_resume_late(pci_dev);
+       }
        return error;
 }
 
@@ -420,10 +438,8 @@ static int pci_pm_suspend(struct device *dev)
                if (drv->pm->suspend) {
                        error = drv->pm->suspend(dev);
                        suspend_report_result(drv->pm->suspend, error);
-               } else {
-                       pci_default_pm_suspend(pci_dev);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend(dev, PMSG_SUSPEND);
        }
        pci_fixup_device(pci_fixup_suspend, pci_dev);
@@ -434,7 +450,7 @@ static int pci_pm_suspend(struct device *dev)
 static int pci_pm_suspend_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
@@ -442,8 +458,10 @@ static int pci_pm_suspend_noirq(struct device *dev)
                        error = drv->pm->suspend_noirq(dev);
                        suspend_report_result(drv->pm->suspend_noirq, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend_late(dev, PMSG_SUSPEND);
+       } else {
+               pci_default_pm_suspend(pci_dev);
        }
 
        return error;
@@ -453,15 +471,17 @@ static int pci_pm_resume(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
-       int error;
+       int error = 0;
 
        pci_fixup_device(pci_fixup_resume, pci_dev);
 
        if (drv && drv->pm) {
-               error = drv->pm->resume ? drv->pm->resume(dev) :
-                       pci_default_pm_resume(pci_dev);
-       } else {
+               if (drv->pm->resume)
+                       error = drv->pm->resume(dev);
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume(dev);
+       } else {
+               error = pci_default_pm_resume_late(pci_dev);
        }
 
        return error;
@@ -470,16 +490,18 @@ static int pci_pm_resume(struct device *dev)
 static int pci_pm_resume_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
-       pci_fixup_device(pci_fixup_resume_early, pci_dev);
+       pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
 
        if (drv && drv->pm) {
                if (drv->pm->resume_noirq)
                        error = drv->pm->resume_noirq(dev);
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume_early(dev);
+       } else {
+               pci_default_pm_resume_early(pci_dev);
        }
 
        return error;
@@ -506,10 +528,8 @@ static int pci_pm_freeze(struct device *dev)
                if (drv->pm->freeze) {
                        error = drv->pm->freeze(dev);
                        suspend_report_result(drv->pm->freeze, error);
-               } else {
-                       pci_default_pm_suspend(pci_dev);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend(dev, PMSG_FREEZE);
                pci_fixup_device(pci_fixup_suspend, pci_dev);
        }
@@ -520,7 +540,7 @@ static int pci_pm_freeze(struct device *dev)
 static int pci_pm_freeze_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
@@ -528,8 +548,10 @@ static int pci_pm_freeze_noirq(struct device *dev)
                        error = drv->pm->freeze_noirq(dev);
                        suspend_report_result(drv->pm->freeze_noirq, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend_late(dev, PMSG_FREEZE);
+       } else {
+               pci_default_pm_suspend(pci_dev);
        }
 
        return error;
@@ -537,14 +559,15 @@ static int pci_pm_freeze_noirq(struct device *dev)
 
 static int pci_pm_thaw(struct device *dev)
 {
+       struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
                if (drv->pm->thaw)
                        error =  drv->pm->thaw(dev);
-       } else {
-               pci_fixup_device(pci_fixup_resume, to_pci_dev(dev));
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
+               pci_fixup_device(pci_fixup_resume, pci_dev);
                error = pci_legacy_resume(dev);
        }
 
@@ -554,14 +577,14 @@ static int pci_pm_thaw(struct device *dev)
 static int pci_pm_thaw_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
                if (drv->pm->thaw_noirq)
                        error = drv->pm->thaw_noirq(dev);
-       } else {
-               pci_fixup_device(pci_fixup_resume_early, pci_dev);
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
+               pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
                error = pci_legacy_resume_early(dev);
        }
 
@@ -570,17 +593,18 @@ static int pci_pm_thaw_noirq(struct device *dev)
 
 static int pci_pm_poweroff(struct device *dev)
 {
+       struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
        int error = 0;
 
-       pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
+       pci_fixup_device(pci_fixup_suspend, pci_dev);
 
        if (drv && drv->pm) {
                if (drv->pm->poweroff) {
                        error = drv->pm->poweroff(dev);
                        suspend_report_result(drv->pm->poweroff, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
        }
 
@@ -589,8 +613,7 @@ static int pci_pm_poweroff(struct device *dev)
 
 static int pci_pm_poweroff_noirq(struct device *dev)
 {
-       struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        if (drv && drv->pm) {
@@ -598,7 +621,7 @@ static int pci_pm_poweroff_noirq(struct device *dev)
                        error = drv->pm->poweroff_noirq(dev);
                        suspend_report_result(drv->pm->poweroff_noirq, error);
                }
-       } else {
+       } else if (pci_has_legacy_pm_support(to_pci_dev(dev))) {
                error = pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
        }
 
@@ -609,13 +632,15 @@ static int pci_pm_restore(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
        struct device_driver *drv = dev->driver;
-       int error;
+       int error = 0;
 
        if (drv && drv->pm) {
-               error = drv->pm->restore ? drv->pm->restore(dev) :
-                       pci_default_pm_resume(pci_dev);
-       } else {
+               if (drv->pm->restore)
+                       error = drv->pm->restore(dev);
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume(dev);
+       } else {
+               error = pci_default_pm_resume_late(pci_dev);
        }
        pci_fixup_device(pci_fixup_resume, pci_dev);
 
@@ -625,7 +650,7 @@ static int pci_pm_restore(struct device *dev)
 static int pci_pm_restore_noirq(struct device *dev)
 {
        struct pci_dev *pci_dev = to_pci_dev(dev);
-       struct pci_driver *drv = pci_dev->driver;
+       struct device_driver *drv = dev->driver;
        int error = 0;
 
        pci_fixup_device(pci_fixup_resume, pci_dev);
@@ -633,8 +658,10 @@ static int pci_pm_restore_noirq(struct device *dev)
        if (drv && drv->pm) {
                if (drv->pm->restore_noirq)
                        error = drv->pm->restore_noirq(dev);
-       } else {
+       } else if (pci_has_legacy_pm_support(pci_dev)) {
                error = pci_legacy_resume_early(dev);
+       } else {
+               pci_default_pm_resume_early(pci_dev);
        }
        pci_fixup_device(pci_fixup_resume_early, pci_dev);
 
@@ -654,17 +681,15 @@ static int pci_pm_restore_noirq(struct device *dev)
 
 #endif /* !CONFIG_HIBERNATION */
 
-struct pm_ext_ops pci_pm_ops = {
-       .base = {
-               .prepare = pci_pm_prepare,
-               .complete = pci_pm_complete,
-               .suspend = pci_pm_suspend,
-               .resume = pci_pm_resume,
-               .freeze = pci_pm_freeze,
-               .thaw = pci_pm_thaw,
-               .poweroff = pci_pm_poweroff,
-               .restore = pci_pm_restore,
-       },
+struct dev_pm_ops pci_dev_pm_ops = {
+       .prepare = pci_pm_prepare,
+       .complete = pci_pm_complete,
+       .suspend = pci_pm_suspend,
+       .resume = pci_pm_resume,
+       .freeze = pci_pm_freeze,
+       .thaw = pci_pm_thaw,
+       .poweroff = pci_pm_poweroff,
+       .restore = pci_pm_restore,
        .suspend_noirq = pci_pm_suspend_noirq,
        .resume_noirq = pci_pm_resume_noirq,
        .freeze_noirq = pci_pm_freeze_noirq,
@@ -673,7 +698,7 @@ struct pm_ext_ops pci_pm_ops = {
        .restore_noirq = pci_pm_restore_noirq,
 };
 
-#define PCI_PM_OPS_PTR &pci_pm_ops
+#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
 
 #else /* !CONFIG_PM_SLEEP */
 
@@ -703,9 +728,6 @@ int __pci_register_driver(struct pci_driver *drv, struct module *owner,
        drv->driver.owner = owner;
        drv->driver.mod_name = mod_name;
 
-       if (drv->pm)
-               drv->driver.pm = &drv->pm->base;
-
        spin_lock_init(&drv->dynids.lock);
        INIT_LIST_HEAD(&drv->dynids.list);
 
index e75b060daa955231af4d52a79816fa4824a17d5b..efea128f02daa22bd59db27064bd58e574ffeee3 100644 (file)
@@ -165,8 +165,7 @@ struct pnp_card *pnp_alloc_card(struct pnp_protocol *protocol, int id, char *pnp
        card->number = id;
 
        card->dev.parent = &card->protocol->dev;
-       sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number,
-               card->number);
+       dev_set_name(&card->dev, "%02x:%02x", card->protocol->number, card->number);
 
        card->dev.coherent_dma_mask = DMA_24BIT_MASK;
        card->dev.dma_mask = &card->dev.coherent_dma_mask;
@@ -295,8 +294,8 @@ int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev)
 {
        dev->dev.parent = &card->dev;
        dev->card_link = NULL;
-       snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%02x:%02x.%02x",
-                dev->protocol->number, card->number, dev->number);
+       dev_set_name(&dev->dev, "%02x:%02x.%02x",
+                    dev->protocol->number, card->number, dev->number);
        spin_lock(&pnp_lock);
        dev->card = card;
        list_add_tail(&dev->card_list, &card->devices);
index 16c01c6fa7c589b92e0b827cd36d65fb5fbccad7..14814f231739fcfb975be5bda1b47b1a29fceb0c 100644 (file)
@@ -70,7 +70,7 @@ int pnp_register_protocol(struct pnp_protocol *protocol)
        spin_unlock(&pnp_lock);
 
        protocol->number = nodenum;
-       sprintf(protocol->dev.bus_id, "pnp%d", nodenum);
+       dev_set_name(&protocol->dev, "pnp%d", nodenum);
        return device_register(&protocol->dev);
 }
 
@@ -145,8 +145,7 @@ struct pnp_dev *pnp_alloc_dev(struct pnp_protocol *protocol, int id, char *pnpid
        dev->dev.coherent_dma_mask = dev->dma_mask;
        dev->dev.release = &pnp_release_device;
 
-       sprintf(dev->dev.bus_id, "%02x:%02x", dev->protocol->number,
-               dev->number);
+       dev_set_name(&dev->dev, "%02x:%02x", dev->protocol->number, dev->number);
 
        dev_id = pnp_add_id(dev, pnpid);
        if (!dev_id) {
index 764f3a3106854056d3acec26ce77068908b0eb58..59b90922da8c324529c4d198c23b54211168f23f 100644 (file)
@@ -26,7 +26,7 @@ static void reserve_range(struct pnp_dev *dev, resource_size_t start,
                          resource_size_t end, int port)
 {
        char *regionid;
-       const char *pnpid = dev->dev.bus_id;
+       const char *pnpid = dev_name(&dev->dev);
        struct resource *res;
 
        regionid = kmalloc(16, GFP_KERNEL);
index 308ddb201b660da9d84e21279eef011eb87907af..1d768928e0bbaf0c9fe61923bcaa0f10b139062c 100644 (file)
@@ -354,7 +354,7 @@ static int ds2760_battery_probe(struct platform_device *pdev)
        pdata = pdev->dev.platform_data;
        di->dev         = &pdev->dev;
        di->w1_dev           = pdev->dev.parent;
-       di->bat.name       = pdev->dev.bus_id;
+       di->bat.name       = dev_name(&pdev->dev);
        di->bat.type       = POWER_SUPPLY_TYPE_BATTERY;
        di->bat.properties     = ds2760_battery_props;
        di->bat.num_properties = ARRAY_SIZE(ds2760_battery_props);
@@ -371,7 +371,7 @@ static int ds2760_battery_probe(struct platform_device *pdev)
        }
 
        INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work);
-       di->monitor_wqueue = create_singlethread_workqueue(pdev->dev.bus_id);
+       di->monitor_wqueue = create_singlethread_workqueue(dev_name(&pdev->dev));
        if (!di->monitor_wqueue) {
                retval = -ESRCH;
                goto workqueue_failed;
index 4f4e7cf105d4985c425aedf30f79a72ed3fb3ab6..d0eae59bc3667ce8d2ee56d484777d7cb5d32ccd 100644 (file)
@@ -4,7 +4,7 @@
 
 CFLAGS_sysinfo.o += -Iinclude/math-emu -Iarch/s390/math-emu -w
 
-obj-y += s390mach.o sysinfo.o s390_rdev.o
+obj-y += s390mach.o sysinfo.o
 obj-y += cio/ block/ char/ crypto/ net/ scsi/ kvm/
 
 drivers-y += drivers/s390/built-in.o
index 26ffc6ab441d95ab6ed21ec79a820a34db41245a..cfdcf1aed33c282115e50cf2d6dddd0b96ff5b42 100644 (file)
@@ -18,7 +18,6 @@
 #include <asm/io.h>
 #include <linux/completion.h>
 #include <linux/interrupt.h>
-#include <asm/s390_rdev.h>
 
 #define DCSSBLK_NAME "dcssblk"
 #define DCSSBLK_MINORS_PER_DISK 1
@@ -946,7 +945,7 @@ dcssblk_check_params(void)
 static void __exit
 dcssblk_exit(void)
 {
-       s390_root_dev_unregister(dcssblk_root_dev);
+       root_device_unregister(dcssblk_root_dev);
        unregister_blkdev(dcssblk_major, DCSSBLK_NAME);
 }
 
@@ -955,22 +954,22 @@ dcssblk_init(void)
 {
        int rc;
 
-       dcssblk_root_dev = s390_root_dev_register("dcssblk");
+       dcssblk_root_dev = root_device_register("dcssblk");
        if (IS_ERR(dcssblk_root_dev))
                return PTR_ERR(dcssblk_root_dev);
        rc = device_create_file(dcssblk_root_dev, &dev_attr_add);
        if (rc) {
-               s390_root_dev_unregister(dcssblk_root_dev);
+               root_device_unregister(dcssblk_root_dev);
                return rc;
        }
        rc = device_create_file(dcssblk_root_dev, &dev_attr_remove);
        if (rc) {
-               s390_root_dev_unregister(dcssblk_root_dev);
+               root_device_unregister(dcssblk_root_dev);
                return rc;
        }
        rc = register_blkdev(0, DCSSBLK_NAME);
        if (rc < 0) {
-               s390_root_dev_unregister(dcssblk_root_dev);
+               root_device_unregister(dcssblk_root_dev);
                return rc;
        }
        dcssblk_major = rc;
index 1f5f5d2d87d94b8fb3123f5c1d9855492b22b122..9c148406b9804a764756564954d87ab2d4339ba1 100644 (file)
@@ -36,7 +36,6 @@
 #include <linux/notifier.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
-#include <asm/s390_rdev.h>
 #include <asm/reset.h>
 #include <asm/airq.h>
 #include <asm/atomic.h>
@@ -1522,7 +1521,7 @@ int __init ap_module_init(void)
        }
 
        /* Create /sys/devices/ap. */
-       ap_root_device = s390_root_dev_register("ap");
+       ap_root_device = root_device_register("ap");
        rc = IS_ERR(ap_root_device) ? PTR_ERR(ap_root_device) : 0;
        if (rc)
                goto out_bus;
@@ -1565,7 +1564,7 @@ out_work:
        hrtimer_cancel(&ap_poll_timer);
        destroy_workqueue(ap_work_queue);
 out_root:
-       s390_root_dev_unregister(ap_root_device);
+       root_device_unregister(ap_root_device);
 out_bus:
        while (i--)
                bus_remove_file(&ap_bus_type, ap_bus_attrs[i]);
@@ -1600,7 +1599,7 @@ void ap_module_exit(void)
        hrtimer_cancel(&ap_poll_timer);
        destroy_workqueue(ap_work_queue);
        tasklet_kill(&ap_tasklet);
-       s390_root_dev_unregister(ap_root_device);
+       root_device_unregister(ap_root_device);
        while ((dev = bus_find_device(&ap_bus_type, NULL, NULL,
                    __ap_match_all)))
        {
index 28c90b89f2b464d48e9781e2cd904fdf8a6800f5..cbc8566fab705f954aae795f18ff58744b93b9c7 100644 (file)
@@ -24,7 +24,6 @@
 #include <asm/kvm_virtio.h>
 #include <asm/setup.h>
 #include <asm/s390_ext.h>
-#include <asm/s390_rdev.h>
 
 #define VIRTIO_SUBCODE_64 0x0D00
 
@@ -335,7 +334,7 @@ static int __init kvm_devices_init(void)
        if (!MACHINE_IS_KVM)
                return -ENODEV;
 
-       kvm_root = s390_root_dev_register("kvm_s390");
+       kvm_root = root_device_register("kvm_s390");
        if (IS_ERR(kvm_root)) {
                rc = PTR_ERR(kvm_root);
                printk(KERN_ERR "Could not register kvm_s390 root device");
@@ -344,7 +343,7 @@ static int __init kvm_devices_init(void)
 
        rc = vmem_add_mapping(real_memory_size, PAGE_SIZE);
        if (rc) {
-               s390_root_dev_unregister(kvm_root);
+               root_device_unregister(kvm_root);
                return rc;
        }
 
index f4a32375c037410d78935033aa047f1ccdb8b2e9..48383459e99be7cee09bbb1fbaeb90bbce8b7f8e 100644 (file)
@@ -25,7 +25,6 @@
 #include <linux/module.h>
 #include <linux/err.h>
 
-#include <asm/s390_rdev.h>
 #include <asm/ccwdev.h>
 #include <asm/ccwgroup.h>
 
@@ -120,12 +119,12 @@ cu3088_init (void)
 {
        int rc;
 
-       cu3088_root_dev = s390_root_dev_register("cu3088");
+       cu3088_root_dev = root_device_register("cu3088");
        if (IS_ERR(cu3088_root_dev))
                return PTR_ERR(cu3088_root_dev);
        rc = ccw_driver_register(&cu3088_driver);
        if (rc)
-               s390_root_dev_unregister(cu3088_root_dev);
+               root_device_unregister(cu3088_root_dev);
 
        return rc;
 }
@@ -134,7 +133,7 @@ static void __exit
 cu3088_exit (void)
 {
        ccw_driver_unregister(&cu3088_driver);
-       s390_root_dev_unregister(cu3088_root_dev);
+       root_device_unregister(cu3088_root_dev);
 }
 
 MODULE_DEVICE_TABLE(ccw,cu3088_ids);
index 6811dd529f48ca32029ca32f879869f365573951..d1b5bebea7fbb3a36ad29b5eff6f231ce2a3f4d5 100644 (file)
@@ -24,7 +24,6 @@
 
 #include <asm/ebcdic.h>
 #include <asm/io.h>
-#include <asm/s390_rdev.h>
 
 #include "qeth_core.h"
 #include "qeth_core_offl.h"
@@ -4525,7 +4524,7 @@ static int __init qeth_core_init(void)
                                &driver_attr_group);
        if (rc)
                goto driver_err;
-       qeth_core_root_dev = s390_root_dev_register("qeth");
+       qeth_core_root_dev = root_device_register("qeth");
        rc = IS_ERR(qeth_core_root_dev) ? PTR_ERR(qeth_core_root_dev) : 0;
        if (rc)
                goto register_err;
@@ -4539,7 +4538,7 @@ static int __init qeth_core_init(void)
 
        return 0;
 slab_err:
-       s390_root_dev_unregister(qeth_core_root_dev);
+       root_device_unregister(qeth_core_root_dev);
 register_err:
        driver_remove_file(&qeth_core_ccwgroup_driver.driver,
                           &driver_attr_group);
@@ -4557,7 +4556,7 @@ out_err:
 
 static void __exit qeth_core_exit(void)
 {
-       s390_root_dev_unregister(qeth_core_root_dev);
+       root_device_unregister(qeth_core_root_dev);
        driver_remove_file(&qeth_core_ccwgroup_driver.driver,
                           &driver_attr_group);
        ccwgroup_driver_unregister(&qeth_core_ccwgroup_driver);
index 21627ba3093be6aec8d4718afba2ca4e91248b62..591a2b3ae4cb06b65b01014ee7d365cba6b94679 100644 (file)
@@ -20,8 +20,6 @@
 #include <linux/mii.h>
 #include <linux/ip.h>
 
-#include <asm/s390_rdev.h>
-
 #include "qeth_core.h"
 #include "qeth_core_offl.h"
 
index cfda1ecffdf24db5e60122706f514c23c2ef2db0..4693ee4e7b9852586eee3be8f9686288974f009a 100644 (file)
@@ -26,8 +26,6 @@
 #include <net/ip.h>
 #include <net/arp.h>
 
-#include <asm/s390_rdev.h>
-
 #include "qeth_l3.h"
 #include "qeth_core_offl.h"
 
diff --git a/drivers/s390/s390_rdev.c b/drivers/s390/s390_rdev.c
deleted file mode 100644 (file)
index 64371c0..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- *  drivers/s390/s390_rdev.c
- *  s390 root device
- *
- *    Copyright (C) 2002, 2005 IBM Deutschland Entwicklung GmbH,
- *                      IBM Corporation
- *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
- *               Carsten Otte  (cotte@de.ibm.com)
- */
-
-#include <linux/slab.h>
-#include <linux/err.h>
-#include <linux/device.h>
-#include <asm/s390_rdev.h>
-
-static void
-s390_root_dev_release(struct device *dev)
-{
-       kfree(dev);
-}
-
-struct device *
-s390_root_dev_register(const char *name)
-{
-       struct device *dev;
-       int ret;
-
-       if (!strlen(name))
-               return ERR_PTR(-EINVAL);
-       dev = kzalloc(sizeof(struct device), GFP_KERNEL);
-       if (!dev)
-               return ERR_PTR(-ENOMEM);
-       dev_set_name(dev, name);
-       dev->release = s390_root_dev_release;
-       ret = device_register(dev);
-       if (ret) {
-               kfree(dev);
-               return ERR_PTR(ret);
-       }
-       return dev;
-}
-
-void
-s390_root_dev_unregister(struct device *dev)
-{
-       if (dev)
-               device_unregister(dev);
-}
-
-EXPORT_SYMBOL(s390_root_dev_register);
-EXPORT_SYMBOL(s390_root_dev_unregister);
index dc68b7e0c93049d9fe360b587fafe5a94230bfea..42f4e66fccafeb40cb9b97833d2a3e9da522fa89 100644 (file)
@@ -2030,7 +2030,7 @@ int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)
                if (!tries)
                        printk(KERN_ERR "%s%s%s%d: Unable to drain "
                                        "transmitter\n",
-                              port->dev ? port->dev->bus_id : "",
+                              port->dev ? dev_name(port->dev) : "",
                               port->dev ? ": " : "",
                               drv->dev_name,
                               drv->tty_driver->name_base + port->line);
@@ -2156,7 +2156,7 @@ uart_report_port(struct uart_driver *drv, struct uart_port *port)
        }
 
        printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",
-              port->dev ? port->dev->bus_id : "",
+              port->dev ? dev_name(port->dev) : "",
               port->dev ? ": " : "",
               drv->dev_name,
               drv->tty_driver->name_base + port->line,
index 3734dc9708e12669070ab984cc2fe9f0fbee1b70..643908b74bc0cdd262cbc949a21644728aa1549c 100644 (file)
@@ -47,7 +47,7 @@ modalias_show(struct device *dev, struct device_attribute *a, char *buf)
 {
        const struct spi_device *spi = to_spi_device(dev);
 
-       return snprintf(buf, BUS_ID_SIZE + 1, "%s\n", spi->modalias);
+       return sprintf(buf, "%s\n", spi->modalias);
 }
 
 static struct device_attribute spi_dev_attrs[] = {
@@ -63,7 +63,7 @@ static int spi_match_device(struct device *dev, struct device_driver *drv)
 {
        const struct spi_device *spi = to_spi_device(dev);
 
-       return strncmp(spi->modalias, drv->name, BUS_ID_SIZE) == 0;
+       return strcmp(spi->modalias, drv->name) == 0;
 }
 
 static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
@@ -243,8 +243,7 @@ int spi_add_device(struct spi_device *spi)
        }
 
        /* Set the bus ID string */
-       snprintf(spi->dev.bus_id, sizeof spi->dev.bus_id,
-                       "%s.%u", spi->master->dev.bus_id,
+       dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
                        spi->chip_select);
 
 
@@ -254,7 +253,7 @@ int spi_add_device(struct spi_device *spi)
         */
        mutex_lock(&spi_add_lock);
 
-       if (bus_find_device_by_name(&spi_bus_type, NULL, spi->dev.bus_id)
+       if (bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev))
                        != NULL) {
                dev_err(dev, "chipselect %d already in use\n",
                                spi->chip_select);
@@ -269,7 +268,7 @@ int spi_add_device(struct spi_device *spi)
        status = spi->master->setup(spi);
        if (status < 0) {
                dev_err(dev, "can't %s %s, status %d\n",
-                               "setup", spi->dev.bus_id, status);
+                               "setup", dev_name(&spi->dev), status);
                goto done;
        }
 
@@ -277,9 +276,9 @@ int spi_add_device(struct spi_device *spi)
        status = device_add(&spi->dev);
        if (status < 0)
                dev_err(dev, "can't %s %s, status %d\n",
-                               "add", spi->dev.bus_id, status);
+                               "add", dev_name(&spi->dev), status);
        else
-               dev_dbg(dev, "registered child %s\n", spi->dev.bus_id);
+               dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
 
 done:
        mutex_unlock(&spi_add_lock);
@@ -504,12 +503,11 @@ int spi_register_master(struct spi_master *master)
        /* register the device, then userspace will see it.
         * registration fails if the bus ID is in use.
         */
-       snprintf(master->dev.bus_id, sizeof master->dev.bus_id,
-               "spi%u", master->bus_num);
+       dev_set_name(&master->dev, "spi%u", master->bus_num);
        status = device_add(&master->dev);
        if (status < 0)
                goto done;
-       dev_dbg(dev, "registered master %s%s\n", master->dev.bus_id,
+       dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
                        dynamic ? " (dynamic)" : "");
 
        /* populate children from any spi device tables */
index 96cc39ecb6e234f7340fbeb62322ea1831ba9e0d..85e61f451218418849eb35376aeccc7f09094c9d 100644 (file)
@@ -475,7 +475,7 @@ int spi_bitbang_start(struct spi_bitbang *bitbang)
        /* this task is the only thing to touch the SPI bits */
        bitbang->busy = 0;
        bitbang->workqueue = create_singlethread_workqueue(
-                       bitbang->master->dev.parent->bus_id);
+                       dev_name(bitbang->master->dev.parent));
        if (bitbang->workqueue == NULL) {
                status = -EBUSY;
                goto err1;
index 0ee2b2090252999f7df59f8704ff5e2bcea2ce9a..c2184866fa9cffc76c5f5af96f34c8956d9e8967 100644 (file)
@@ -287,7 +287,7 @@ static void butterfly_attach(struct parport *p)
        pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]);
        if (pp->dataflash)
                pr_debug("%s: dataflash at %s\n", p->name,
-                               pp->dataflash->dev.bus_id);
+                               dev_name(&pp->dataflash->dev));
 
        // dev_info(_what?_, ...)
        pr_info("%s: AVR Butterfly\n", p->name);
index 39d8d8ad65c0a2ef11c4bf81d752f8f20e7aeeaa..af6526767e2acd80c870a239d33e2afb16917e1a 100644 (file)
@@ -287,7 +287,7 @@ static void spi_lm70llp_attach(struct parport *p)
        pp->spidev_lm70 = spi_new_device(pp->bitbang.master, &pp->info);
        if (pp->spidev_lm70)
                dev_dbg(&pp->spidev_lm70->dev, "spidev_lm70 at %s\n",
-                               pp->spidev_lm70->dev.bus_id);
+                               dev_name(&pp->spidev_lm70->dev));
        else {
                printk(KERN_WARNING "%s: spi_new_device failed\n", DRVNAME);
                status = -ENODEV;
index fe07462d5947fec44a4eb559a552670e84744a08..8171ca17b936f7203261f0b3b45bd82a3e4ce1c1 100644 (file)
@@ -579,7 +579,7 @@ static void thermal_release(struct device *dev)
        struct thermal_zone_device *tz;
        struct thermal_cooling_device *cdev;
 
-       if (!strncmp(dev->bus_id, "thermal_zone", sizeof "thermal_zone" - 1)) {
+       if (!strncmp(dev_name(dev), "thermal_zone", sizeof "thermal_zone" - 1)) {
                tz = to_thermal_zone(dev);
                kfree(tz);
        } else {
@@ -630,7 +630,7 @@ struct thermal_cooling_device *thermal_cooling_device_register(char *type,
        cdev->ops = ops;
        cdev->device.class = &thermal_class;
        cdev->devdata = devdata;
-       sprintf(cdev->device.bus_id, "cooling_device%d", cdev->id);
+       dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
        result = device_register(&cdev->device);
        if (result) {
                release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
@@ -769,7 +769,7 @@ struct thermal_zone_device *thermal_zone_device_register(char *type,
        tz->device.class = &thermal_class;
        tz->devdata = devdata;
        tz->trips = trips;
-       sprintf(tz->device.bus_id, "thermal_zone%d", tz->id);
+       dev_set_name(&tz->device, "thermal_zone%d", tz->id);
        result = device_register(&tz->device);
        if (result) {
                release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
index 2d2440cd57a947d195d1f099d1a0ac64bdd56031..4ca85a113aa251e03387da5402e6a9d65a43a421 100644 (file)
@@ -35,6 +35,7 @@ struct uio_device {
        int                     vma_count;
        struct uio_info         *info;
        struct kobject          *map_dir;
+       struct kobject          *portio_dir;
 };
 
 static int uio_major;
@@ -75,17 +76,17 @@ static ssize_t map_offset_show(struct uio_mem *mem, char *buf)
        return sprintf(buf, "0x%lx\n", mem->addr & ~PAGE_MASK);
 }
 
-struct uio_sysfs_entry {
+struct map_sysfs_entry {
        struct attribute attr;
        ssize_t (*show)(struct uio_mem *, char *);
        ssize_t (*store)(struct uio_mem *, const char *, size_t);
 };
 
-static struct uio_sysfs_entry addr_attribute =
+static struct map_sysfs_entry addr_attribute =
        __ATTR(addr, S_IRUGO, map_addr_show, NULL);
-static struct uio_sysfs_entry size_attribute =
+static struct map_sysfs_entry size_attribute =
        __ATTR(size, S_IRUGO, map_size_show, NULL);
-static struct uio_sysfs_entry offset_attribute =
+static struct map_sysfs_entry offset_attribute =
        __ATTR(offset, S_IRUGO, map_offset_show, NULL);
 
 static struct attribute *attrs[] = {
@@ -106,9 +107,9 @@ static ssize_t map_type_show(struct kobject *kobj, struct attribute *attr,
 {
        struct uio_map *map = to_map(kobj);
        struct uio_mem *mem = map->mem;
-       struct uio_sysfs_entry *entry;
+       struct map_sysfs_entry *entry;
 
-       entry = container_of(attr, struct uio_sysfs_entry, attr);
+       entry = container_of(attr, struct map_sysfs_entry, attr);
 
        if (!entry->show)
                return -EIO;
@@ -116,16 +117,93 @@ static ssize_t map_type_show(struct kobject *kobj, struct attribute *attr,
        return entry->show(mem, buf);
 }
 
-static struct sysfs_ops uio_sysfs_ops = {
+static struct sysfs_ops map_sysfs_ops = {
        .show = map_type_show,
 };
 
 static struct kobj_type map_attr_type = {
        .release        = map_release,
-       .sysfs_ops      = &uio_sysfs_ops,
+       .sysfs_ops      = &map_sysfs_ops,
        .default_attrs  = attrs,
 };
 
+struct uio_portio {
+       struct kobject kobj;
+       struct uio_port *port;
+};
+#define to_portio(portio) container_of(portio, struct uio_portio, kobj)
+
+static ssize_t portio_start_show(struct uio_port *port, char *buf)
+{
+       return sprintf(buf, "0x%lx\n", port->start);
+}
+
+static ssize_t portio_size_show(struct uio_port *port, char *buf)
+{
+       return sprintf(buf, "0x%lx\n", port->size);
+}
+
+static ssize_t portio_porttype_show(struct uio_port *port, char *buf)
+{
+       const char *porttypes[] = {"none", "x86", "gpio", "other"};
+
+       if ((port->porttype < 0) || (port->porttype > UIO_PORT_OTHER))
+               return -EINVAL;
+
+       return sprintf(buf, "port_%s\n", porttypes[port->porttype]);
+}
+
+struct portio_sysfs_entry {
+       struct attribute attr;
+       ssize_t (*show)(struct uio_port *, char *);
+       ssize_t (*store)(struct uio_port *, const char *, size_t);
+};
+
+static struct portio_sysfs_entry portio_start_attribute =
+       __ATTR(start, S_IRUGO, portio_start_show, NULL);
+static struct portio_sysfs_entry portio_size_attribute =
+       __ATTR(size, S_IRUGO, portio_size_show, NULL);
+static struct portio_sysfs_entry portio_porttype_attribute =
+       __ATTR(porttype, S_IRUGO, portio_porttype_show, NULL);
+
+static struct attribute *portio_attrs[] = {
+       &portio_start_attribute.attr,
+       &portio_size_attribute.attr,
+       &portio_porttype_attribute.attr,
+       NULL,
+};
+
+static void portio_release(struct kobject *kobj)
+{
+       struct uio_portio *portio = to_portio(kobj);
+       kfree(portio);
+}
+
+static ssize_t portio_type_show(struct kobject *kobj, struct attribute *attr,
+                            char *buf)
+{
+       struct uio_portio *portio = to_portio(kobj);
+       struct uio_port *port = portio->port;
+       struct portio_sysfs_entry *entry;
+
+       entry = container_of(attr, struct portio_sysfs_entry, attr);
+
+       if (!entry->show)
+               return -EIO;
+
+       return entry->show(port, buf);
+}
+
+static struct sysfs_ops portio_sysfs_ops = {
+       .show = portio_type_show,
+};
+
+static struct kobj_type portio_attr_type = {
+       .release        = portio_release,
+       .sysfs_ops      = &portio_sysfs_ops,
+       .default_attrs  = portio_attrs,
+};
+
 static ssize_t show_name(struct device *dev,
                         struct device_attribute *attr, char *buf)
 {
@@ -177,10 +255,13 @@ static struct attribute_group uio_attr_grp = {
 static int uio_dev_add_attributes(struct uio_device *idev)
 {
        int ret;
-       int mi;
+       int mi, pi;
        int map_found = 0;
+       int portio_found = 0;
        struct uio_mem *mem;
        struct uio_map *map;
+       struct uio_port *port;
+       struct uio_portio *portio;
 
        ret = sysfs_create_group(&idev->dev->kobj, &uio_attr_grp);
        if (ret)
@@ -195,25 +276,58 @@ static int uio_dev_add_attributes(struct uio_device *idev)
                        idev->map_dir = kobject_create_and_add("maps",
                                                        &idev->dev->kobj);
                        if (!idev->map_dir)
-                               goto err;
+                               goto err_map;
                }
                map = kzalloc(sizeof(*map), GFP_KERNEL);
                if (!map)
-                       goto err;
+                       goto err_map;
                kobject_init(&map->kobj, &map_attr_type);
                map->mem = mem;
                mem->map = map;
                ret = kobject_add(&map->kobj, idev->map_dir, "map%d", mi);
                if (ret)
-                       goto err;
+                       goto err_map;
                ret = kobject_uevent(&map->kobj, KOBJ_ADD);
                if (ret)
-                       goto err;
+                       goto err_map;
+       }
+
+       for (pi = 0; pi < MAX_UIO_PORT_REGIONS; pi++) {
+               port = &idev->info->port[pi];
+               if (port->size == 0)
+                       break;
+               if (!portio_found) {
+                       portio_found = 1;
+                       idev->portio_dir = kobject_create_and_add("portio",
+                                                       &idev->dev->kobj);
+                       if (!idev->portio_dir)
+                               goto err_portio;
+               }
+               portio = kzalloc(sizeof(*portio), GFP_KERNEL);
+               if (!portio)
+                       goto err_portio;
+               kobject_init(&portio->kobj, &portio_attr_type);
+               portio->port = port;
+               port->portio = portio;
+               ret = kobject_add(&portio->kobj, idev->portio_dir,
+                                                       "port%d", pi);
+               if (ret)
+                       goto err_portio;
+               ret = kobject_uevent(&portio->kobj, KOBJ_ADD);
+               if (ret)
+                       goto err_portio;
        }
 
        return 0;
 
-err:
+err_portio:
+       for (pi--; pi >= 0; pi--) {
+               port = &idev->info->port[pi];
+               portio = port->portio;
+               kobject_put(&portio->kobj);
+       }
+       kobject_put(idev->portio_dir);
+err_map:
        for (mi--; mi>=0; mi--) {
                mem = &idev->info->mem[mi];
                map = mem->map;
@@ -228,15 +342,26 @@ err_group:
 
 static void uio_dev_del_attributes(struct uio_device *idev)
 {
-       int mi;
+       int i;
        struct uio_mem *mem;
-       for (mi = 0; mi < MAX_UIO_MAPS; mi++) {
-               mem = &idev->info->mem[mi];
+       struct uio_port *port;
+
+       for (i = 0; i < MAX_UIO_MAPS; i++) {
+               mem = &idev->info->mem[i];
                if (mem->size == 0)
                        break;
                kobject_put(&mem->map->kobj);
        }
        kobject_put(idev->map_dir);
+
+       for (i = 0; i < MAX_UIO_PORT_REGIONS; i++) {
+               port = &idev->info->port[i];
+               if (port->size == 0)
+                       break;
+               kobject_put(&port->portio->kobj);
+       }
+       kobject_put(idev->portio_dir);
+
        sysfs_remove_group(&idev->dev->kobj, &uio_attr_grp);
 }
 
index 57376060b97858d3afb10fa9f1ab494cf8a8f34f..c60b8fcf0e3e484043afdcb94d872002431e7d0d 100644 (file)
@@ -57,8 +57,7 @@ static int __devinit hilscher_pci_probe(struct pci_dev *dev,
        info->mem[0].addr = pci_resource_start(dev, 0);
        if (!info->mem[0].addr)
                goto out_release;
-       info->mem[0].internal_addr = ioremap(pci_resource_start(dev, 0),
-                                            pci_resource_len(dev, 0));
+       info->mem[0].internal_addr = pci_ioremap_bar(dev, 0);
        if (!info->mem[0].internal_addr)
                goto out_release;
 
index 1f82c83a92aeb64aebc61071427fb80b4f4c3e32..3f06818cf9fa3dc1628f794ec80fc2c2e22d88eb 100644 (file)
@@ -81,7 +81,8 @@ static int uio_pdrv_genirq_probe(struct platform_device *pdev)
                goto bad0;
        }
 
-       if (uioinfo->handler || uioinfo->irqcontrol || uioinfo->irq_flags) {
+       if (uioinfo->handler || uioinfo->irqcontrol ||
+           uioinfo->irq_flags & IRQF_SHARED) {
                dev_err(&pdev->dev, "interrupt configuration error\n");
                goto bad0;
        }
@@ -132,7 +133,7 @@ static int uio_pdrv_genirq_probe(struct platform_device *pdev)
         * Interrupt sharing is not supported.
         */
 
-       uioinfo->irq_flags = IRQF_DISABLED;
+       uioinfo->irq_flags |= IRQF_DISABLED;
        uioinfo->handler = uio_pdrv_genirq_handler;
        uioinfo->irqcontrol = uio_pdrv_genirq_irqcontrol;
        uioinfo->priv = priv;
index be1fa0723f2c662a058040e8878e7ffb5c12c3df..399e15fc505244056d0f276f3f378525ff95c8e1 100644 (file)
@@ -286,7 +286,7 @@ static int usb_dev_restore(struct device *dev)
        return usb_resume(dev);
 }
 
-static struct pm_ops usb_device_pm_ops = {
+static struct dev_pm_ops usb_device_pm_ops = {
        .prepare =      usb_dev_prepare,
        .complete =     usb_dev_complete,
        .suspend =      usb_dev_suspend,
@@ -301,7 +301,7 @@ static struct pm_ops usb_device_pm_ops = {
 
 #define ksuspend_usb_init()    0
 #define ksuspend_usb_cleanup() do {} while (0)
-#define usb_device_pm_ops      (*(struct pm_ops *)0)
+#define usb_device_pm_ops      (*(struct dev_pm_ops *)0)
 
 #endif /* CONFIG_PM */
 
index a8a1de41332135907ab27718f07633b155dc83ef..0b2bb8f0706df6ec99a6f357a6cb58a86ca25ba6 100644 (file)
@@ -1474,7 +1474,7 @@ static struct at91_udc controller = {
                .ep0    = &controller.ep[0].ep,
                .name   = driver_name,
                .dev    = {
-                       .bus_id = "gadget",
+                       .init_name = "gadget",
                        .release = nop_release,
                }
        },
index ae30ab1d264f46c6b45aafeca88f1491781b3c42..65b03e3445a1784535098d942bb120034d7363d4 100644 (file)
@@ -1034,7 +1034,7 @@ static struct usba_udc the_udc = {
                .is_dualspeed   = 1,
                .name           = "atmel_usba_udc",
                .dev    = {
-                       .bus_id         = "gadget",
+                       .init_name      = "gadget",
                        .release        = nop_release,
                },
        },
index b3408ff39fba07d8e289a9d69f28cc2b6b296512..f402725650988e6275ac307dc0de69ecfd6324cd 100644 (file)
@@ -2545,7 +2545,7 @@ static int __devinit qe_udc_probe(struct of_device *ofdev,
 
        device_initialize(&udc_controller->gadget.dev);
 
-       strcpy(udc_controller->gadget.dev.bus_id, "gadget");
+       dev_set_name(&udc_controller->gadget.dev, "gadget");
 
        udc_controller->gadget.dev.release = qe_udc_release;
        udc_controller->gadget.dev.parent = &ofdev->dev;
index c6e7df04c69ac36be2e32369a7d0fdb6738d1cf3..d554b08956031c15c6bb633ec99005239d5529ce 100644 (file)
@@ -1981,7 +1981,7 @@ static struct lh7a40x_udc memory = {
                   .ep0 = &memory.ep[0].ep,
                   .name = driver_name,
                   .dev = {
-                          .bus_id = "gadget",
+                          .init_name = "gadget",
                           .release = nop_release,
                           },
                   },
index 8c5026be79d49af6253d1b45f638badd74c596b0..697a0ca349bf09b66cfadab7f87ffc1176e08b61 100644 (file)
@@ -1833,7 +1833,7 @@ static struct pxa25x_udc memory = {
                .ep0            = &memory.ep[0].ep,
                .name           = driver_name,
                .dev = {
-                       .bus_id         = "gadget",
+                       .init_name      = "gadget",
                        .release        = nop_release,
                },
        },
index 944e4ff641dfc68b814501dc5a92065593f71198..65110d02a206f958c1b8088feadcb1a25e48c3a7 100644 (file)
@@ -2162,7 +2162,7 @@ static struct pxa_udc memory = {
                .ep0            = &memory.udc_usb_ep[0].usb_ep,
                .name           = driver_name,
                .dev = {
-                       .bus_id         = "gadget",
+                       .init_name      = "gadget",
                },
        },
 
index 8d8d651659836d3a9cc5fbef228effc78e994179..c7e255636803bc0721052e01e1875b39d9463d43 100644 (file)
@@ -1727,7 +1727,7 @@ static struct s3c2410_udc memory = {
                .ep0            = &memory.ep[0].ep,
                .name           = gadget_name,
                .dev = {
-                       .bus_id         = "gadget",
+                       .init_name      = "gadget",
                },
        },
 
index fab0bc874b58d46992b64b90d47be82677b2f543..0664fc032235d37903e14f607e0e798214e89abf 100644 (file)
@@ -217,7 +217,7 @@ struct backlight_device *backlight_device_register(const char *name,
        new_bd->dev.class = backlight_class;
        new_bd->dev.parent = parent;
        new_bd->dev.release = bl_device_release;
-       strlcpy(new_bd->dev.bus_id, name, BUS_ID_SIZE);
+       dev_set_name(&new_bd->dev, name);
        dev_set_drvdata(&new_bd->dev, devdata);
 
        rc = device_register(&new_bd->dev);
index 680e57b616cdeb3f0f11748aff79f9483f41c247..b6449470106cd47e8db704edfd074c53dde8ec4b 100644 (file)
@@ -208,7 +208,7 @@ struct lcd_device *lcd_device_register(const char *name, struct device *parent,
        new_ld->dev.class = lcd_class;
        new_ld->dev.parent = parent;
        new_ld->dev.release = lcd_device_release;
-       strlcpy(new_ld->dev.bus_id, name, BUS_ID_SIZE);
+       dev_set_name(&new_ld->dev, name);
        dev_set_drvdata(&new_ld->dev, devdata);
 
        rc = device_register(&new_ld->dev);
index f2df5519c9c455557bf039b899e0d45a123054c0..5e6439ae739471386ea54fda7e603003dff8eb4f 100644 (file)
@@ -96,7 +96,7 @@ struct output_device *video_output_register(const char *name,
        new_dev->props = op;
        new_dev->dev.class = &video_output_class;
        new_dev->dev.parent = dev;
-       strlcpy(new_dev->dev.bus_id,name, BUS_ID_SIZE);
+       dev_set_name(&new_dev->dev, name);
        dev_set_drvdata(&new_dev->dev, devdata);
        ret_code = device_register(&new_dev->dev);
        if (ret_code) {
index 265fdf2d1276f41884366179eaea1fbceaa153a7..bef6b45e8a5ce4baaa0e1373338d5f02e879bbb0 100644 (file)
@@ -73,10 +73,7 @@ MODULE_DEVICE_TABLE(pci, virtio_pci_id_table);
 /* A PCI device has it's own struct device and so does a virtio device so
  * we create a place for the virtio devices to show up in sysfs.  I think it
  * would make more sense for virtio to not insist on having it's own device. */
-static struct device virtio_pci_root = {
-       .parent         = NULL,
-       .init_name      = "virtio-pci",
-};
+static struct device *virtio_pci_root;
 
 /* Convert a generic virtio device to our structure */
 static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev)
@@ -343,7 +340,7 @@ static int __devinit virtio_pci_probe(struct pci_dev *pci_dev,
        if (vp_dev == NULL)
                return -ENOMEM;
 
-       vp_dev->vdev.dev.parent = &virtio_pci_root;
+       vp_dev->vdev.dev.parent = virtio_pci_root;
        vp_dev->vdev.dev.release = virtio_pci_release_dev;
        vp_dev->vdev.config = &virtio_pci_config_ops;
        vp_dev->pci_dev = pci_dev;
@@ -437,13 +434,13 @@ static int __init virtio_pci_init(void)
 {
        int err;
 
-       err = device_register(&virtio_pci_root);
-       if (err)
-               return err;
+       virtio_pci_root = root_device_register("virtio-pci");
+       if (IS_ERR(virtio_pci_root))
+               return PTR_ERR(virtio_pci_root);
 
        err = pci_register_driver(&virtio_pci_driver);
        if (err)
-               device_unregister(&virtio_pci_root);
+               device_unregister(virtio_pci_root);
 
        return err;
 }
@@ -452,8 +449,8 @@ module_init(virtio_pci_init);
 
 static void __exit virtio_pci_exit(void)
 {
-       device_unregister(&virtio_pci_root);
        pci_unregister_driver(&virtio_pci_driver);
+       root_device_unregister(virtio_pci_root);
 }
 
 module_exit(virtio_pci_exit);
index 3b615d4022ee98f8abd155d33301220a51386cae..acc7e3b7fe17bbbe37e024bde8db85ba738f4672 100644 (file)
@@ -197,7 +197,7 @@ struct device_driver w1_master_driver = {
 struct device w1_master_device = {
        .parent = NULL,
        .bus = &w1_bus_type,
-       .bus_id = "w1 bus master",
+       .init_name = "w1 bus master",
        .driver = &w1_master_driver,
        .release = &w1_master_release
 };
@@ -211,7 +211,7 @@ static struct device_driver w1_slave_driver = {
 struct device w1_slave_device = {
        .parent = NULL,
        .bus = &w1_bus_type,
-       .bus_id = "w1 bus slave",
+       .init_name = "w1 bus slave",
        .driver = &w1_slave_driver,
        .release = &w1_slave_release
 };
@@ -573,7 +573,7 @@ static int w1_uevent(struct device *dev, struct kobj_uevent_env *env)
        }
 
        dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n",
-                       event_owner, name, dev->bus_id);
+                       event_owner, name, dev_name(dev));
 
        if (dev->driver != &w1_slave_driver || !sl)
                return 0;
@@ -605,8 +605,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
        sl->dev.bus = &w1_bus_type;
        sl->dev.release = &w1_slave_release;
 
-       snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id),
-                "%02x-%012llx",
+       dev_set_name(&sl->dev, "%02x-%012llx",
                 (unsigned int) sl->reg_num.family,
                 (unsigned long long) sl->reg_num.id);
        snprintf(&sl->name[0], sizeof(sl->name),
@@ -615,13 +614,13 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
                 (unsigned long long) sl->reg_num.id);
 
        dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__,
-               &sl->dev.bus_id[0], sl);
+               dev_name(&sl->dev), sl);
 
        err = device_register(&sl->dev);
        if (err < 0) {
                dev_err(&sl->dev,
                        "Device registration [%s] failed. err=%d\n",
-                       sl->dev.bus_id, err);
+                       dev_name(&sl->dev), err);
                return err;
        }
 
@@ -630,7 +629,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
        if (err < 0) {
                dev_err(&sl->dev,
                        "sysfs file creation for [%s] failed. err=%d\n",
-                       sl->dev.bus_id, err);
+                       dev_name(&sl->dev), err);
                goto out_unreg;
        }
 
@@ -639,7 +638,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
        if (err < 0) {
                dev_err(&sl->dev,
                        "sysfs file creation for [%s] failed. err=%d\n",
-                       sl->dev.bus_id, err);
+                       dev_name(&sl->dev), err);
                goto out_rem1;
        }
 
@@ -648,7 +647,7 @@ static int __w1_attach_slave_device(struct w1_slave *sl)
            ((err = sl->family->fops->add_slave(sl)) < 0)) {
                dev_err(&sl->dev,
                        "sysfs file creation for [%s] failed. err=%d\n",
-                       sl->dev.bus_id, err);
+                       dev_name(&sl->dev), err);
                goto out_rem2;
        }
 
index a3a54567bfba87f041b8d0735aa7d96996a604d8..4a46ed58ece938621ea3dc3c016efff9f053379f 100644 (file)
@@ -75,8 +75,7 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
        mutex_init(&dev->mutex);
 
        memcpy(&dev->dev, device, sizeof(struct device));
-       snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
-                 "w1_bus_master%u", dev->id);
+       dev_set_name(&dev->dev, "w1_bus_master%u", dev->id);
        snprintf(dev->name, sizeof(dev->name), "w1_bus_master%u", dev->id);
 
        dev->driver = driver;
index 7f24a98a446f53e0a7fd2bd0ec518494ca7e72cd..b2a03184a2461af2544bd686a0ed4148d76f3d17 100644 (file)
@@ -99,15 +99,15 @@ static int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env)
 }
 
 /* device/<type>/<id> => <type>-<id> */
-static int frontend_bus_id(char bus_id[BUS_ID_SIZE], const char *nodename)
+static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename)
 {
        nodename = strchr(nodename, '/');
-       if (!nodename || strlen(nodename + 1) >= BUS_ID_SIZE) {
+       if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) {
                printk(KERN_WARNING "XENBUS: bad frontend %s\n", nodename);
                return -EINVAL;
        }
 
-       strlcpy(bus_id, nodename + 1, BUS_ID_SIZE);
+       strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);
        if (!strchr(bus_id, '/')) {
                printk(KERN_WARNING "XENBUS: bus_id %s no slash\n", bus_id);
                return -EINVAL;
@@ -460,6 +460,7 @@ int xenbus_probe_node(struct xen_bus_type *bus,
                      const char *type,
                      const char *nodename)
 {
+       char devname[XEN_BUS_ID_SIZE];
        int err;
        struct xenbus_device *xendev;
        size_t stringlen;
@@ -494,10 +495,12 @@ int xenbus_probe_node(struct xen_bus_type *bus,
        xendev->dev.bus = &bus->bus;
        xendev->dev.release = xenbus_dev_release;
 
-       err = bus->get_bus_id(xendev->dev.bus_id, xendev->nodename);
+       err = bus->get_bus_id(devname, xendev->nodename);
        if (err)
                goto fail;
 
+       dev_set_name(&xendev->dev, devname);
+
        /* Register with generic device framework. */
        err = device_register(&xendev->dev);
        if (err)
@@ -611,7 +614,7 @@ void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
 {
        int exists, rootlen;
        struct xenbus_device *dev;
-       char type[BUS_ID_SIZE];
+       char type[XEN_BUS_ID_SIZE];
        const char *p, *root;
 
        if (char_count(node, '/') < 2)
@@ -625,8 +628,8 @@ void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
 
        /* backend/<type>/... or device/<type>/... */
        p = strchr(node, '/') + 1;
-       snprintf(type, BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p);
-       type[BUS_ID_SIZE-1] = '\0';
+       snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p);
+       type[XEN_BUS_ID_SIZE-1] = '\0';
 
        rootlen = strsep_len(node, '/', bus->levels);
        if (rootlen < 0)
@@ -674,7 +677,7 @@ static int suspend_dev(struct device *dev, void *data)
                err = drv->suspend(xdev);
        if (err)
                printk(KERN_WARNING
-                      "xenbus: suspend %s failed: %i\n", dev->bus_id, err);
+                      "xenbus: suspend %s failed: %i\n", dev_name(dev), err);
        return 0;
 }
 
@@ -695,7 +698,7 @@ static int suspend_cancel_dev(struct device *dev, void *data)
        if (err)
                printk(KERN_WARNING
                       "xenbus: suspend_cancel %s failed: %i\n",
-                      dev->bus_id, err);
+                      dev_name(dev), err);
        return 0;
 }
 
@@ -717,7 +720,7 @@ static int resume_dev(struct device *dev, void *data)
        if (err) {
                printk(KERN_WARNING
                       "xenbus: resume (talk_to_otherend) %s failed: %i\n",
-                      dev->bus_id, err);
+                      dev_name(dev), err);
                return err;
        }
 
@@ -728,7 +731,7 @@ static int resume_dev(struct device *dev, void *data)
                if (err) {
                        printk(KERN_WARNING
                               "xenbus: resume %s failed: %i\n",
-                              dev->bus_id, err);
+                              dev_name(dev), err);
                        return err;
                }
        }
@@ -737,7 +740,7 @@ static int resume_dev(struct device *dev, void *data)
        if (err) {
                printk(KERN_WARNING
                       "xenbus_probe: resume (watch_otherend) %s failed: "
-                      "%d.\n", dev->bus_id, err);
+                      "%d.\n", dev_name(dev), err);
                return err;
        }
 
index e09b19415a400efad09c0b0c5ad1f7ca1dfc6b80..6c5e3185a6a24d7edb317106d252fb2e08eafd07 100644 (file)
@@ -34,6 +34,8 @@
 #ifndef _XENBUS_PROBE_H
 #define _XENBUS_PROBE_H
 
+#define XEN_BUS_ID_SIZE                        20
+
 #ifdef CONFIG_XEN_BACKEND
 extern void xenbus_backend_suspend(int (*fn)(struct device *, void *));
 extern void xenbus_backend_resume(int (*fn)(struct device *, void *));
@@ -52,7 +54,7 @@ struct xen_bus_type
 {
        char *root;
        unsigned int levels;
-       int (*get_bus_id)(char bus_id[BUS_ID_SIZE], const char *nodename);
+       int (*get_bus_id)(char bus_id[XEN_BUS_ID_SIZE], const char *nodename);
        int (*probe)(const char *type, const char *dir);
        struct bus_type bus;
 };
index 6d5b213b8a9b4b6e834ca9be99ae6c15a3dc0d13..5198ada67398f83019066002a733fdc54a5b8f90 100644 (file)
@@ -384,9 +384,9 @@ struct hd_struct *add_partition(struct gendisk *disk, int partno,
 
        dname = dev_name(ddev);
        if (isdigit(dname[strlen(dname) - 1]))
-               snprintf(pdev->bus_id, BUS_ID_SIZE, "%sp%d", dname, partno);
+               dev_set_name(pdev, "%sp%d", dname, partno);
        else
-               snprintf(pdev->bus_id, BUS_ID_SIZE, "%s%d", dname, partno);
+               dev_set_name(pdev, "%s%d", dname, partno);
 
        device_initialize(pdev);
        pdev->class = &block_class;
@@ -447,16 +447,11 @@ void register_disk(struct gendisk *disk)
        struct block_device *bdev;
        struct disk_part_iter piter;
        struct hd_struct *part;
-       char *s;
        int err;
 
        ddev->parent = disk->driverfs_dev;
 
-       strlcpy(ddev->bus_id, disk->disk_name, BUS_ID_SIZE);
-       /* ewww... some of these buggers have / in the name... */
-       s = strchr(ddev->bus_id, '/');
-       if (s)
-               *s = '!';
+       dev_set_name(ddev, disk->disk_name);
 
        /* delay uevents, until we scanned partition table */
        ddev->uevent_suppress = 1;
index 1a3686d15f98f4877dcaad25b393201f6c95640b..7d9da4b4993feae592388717bff9ffedb0e60531 100644 (file)
@@ -28,6 +28,7 @@
 #define BUS_ID_SIZE            20
 
 struct device;
+struct device_private;
 struct device_driver;
 struct driver_private;
 struct class;
@@ -65,7 +66,7 @@ struct bus_type {
        int (*resume_early)(struct device *dev);
        int (*resume)(struct device *dev);
 
-       struct pm_ext_ops *pm;
+       struct dev_pm_ops *pm;
 
        struct bus_type_private *p;
 };
@@ -133,7 +134,7 @@ struct device_driver {
        int (*resume) (struct device *dev);
        struct attribute_group **groups;
 
-       struct pm_ops *pm;
+       struct dev_pm_ops *pm;
 
        struct driver_private *p;
 };
@@ -198,7 +199,7 @@ struct class {
        int (*suspend)(struct device *dev, pm_message_t state);
        int (*resume)(struct device *dev);
 
-       struct pm_ops *pm;
+       struct dev_pm_ops *pm;
        struct class_private *p;
 };
 
@@ -291,7 +292,7 @@ struct device_type {
        int (*suspend)(struct device *dev, pm_message_t state);
        int (*resume)(struct device *dev);
 
-       struct pm_ops *pm;
+       struct dev_pm_ops *pm;
 };
 
 /* interface for exporting device attributes */
@@ -365,17 +366,15 @@ struct device_dma_parameters {
 };
 
 struct device {
-       struct klist            klist_children;
-       struct klist_node       knode_parent;   /* node in sibling list */
-       struct klist_node       knode_driver;
-       struct klist_node       knode_bus;
        struct device           *parent;
 
+       struct device_private   *p;
+
        struct kobject kobj;
        char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
+       unsigned                uevent_suppress:1;
        const char              *init_name; /* initial name of the device */
        struct device_type      *type;
-       unsigned                uevent_suppress:1;
 
        struct semaphore        sem;    /* semaphore to synchronize calls to
                                         * its driver.
@@ -408,12 +407,13 @@ struct device {
        /* arch specific additions */
        struct dev_archdata     archdata;
 
+       dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
+
        spinlock_t              devres_lock;
        struct list_head        devres_head;
 
        struct klist_node       knode_class;
        struct class            *class;
-       dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
        struct attribute_group  **groups;       /* optional groups */
 
        void    (*release)(struct device *dev);
@@ -482,6 +482,17 @@ extern struct device *device_find_child(struct device *dev, void *data,
 extern int device_rename(struct device *dev, char *new_name);
 extern int device_move(struct device *dev, struct device *new_parent);
 
+/*
+ * Root device objects for grouping under /sys/devices
+ */
+extern struct device *__root_device_register(const char *name,
+                                            struct module *owner);
+static inline struct device *root_device_register(const char *name)
+{
+       return __root_device_register(name, THIS_MODULE);
+}
+extern void root_device_unregister(struct device *root);
+
 /*
  * Manual binding of a device to driver. See drivers/base/bus.c
  * for information on use.
@@ -553,13 +564,13 @@ extern const char *dev_driver_string(const struct device *dev);
 #define dev_info(dev, format, arg...)          \
        dev_printk(KERN_INFO , dev , format , ## arg)
 
-#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
+#if defined(DEBUG)
+#define dev_dbg(dev, format, arg...)           \
+       dev_printk(KERN_DEBUG , dev , format , ## arg)
+#elif defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
 #define dev_dbg(dev, format, ...) do { \
        dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
        } while (0)
-#elif defined(DEBUG)
-#define dev_dbg(dev, format, arg...)           \
-       dev_printk(KERN_DEBUG , dev , format , ## arg)
 #else
 #define dev_dbg(dev, format, arg...)           \
        ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
index 721984844c94c2939d0515de1678101bee89edfd..6b8e2027165eb9e810978dfaaf363174ab767cf4 100644 (file)
@@ -355,13 +355,13 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
         printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
 
 /* If you are writing a driver, please use dev_dbg instead */
-#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
+#if defined(DEBUG)
+#define pr_debug(fmt, ...) \
+       printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
+#elif defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
 #define pr_debug(fmt, ...) do { \
        dynamic_pr_debug(pr_fmt(fmt), ##__VA_ARGS__); \
        } while (0)
-#elif defined(DEBUG)
-#define pr_debug(fmt, ...) \
-       printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
 #else
 #define pr_debug(fmt, ...) \
        ({ if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); 0; })
index 8ea98db223e567db691efb28fe1153d60d2f6d78..d5a27af9dba514508047f5945d4394f0d1440801 100644 (file)
@@ -13,7 +13,6 @@
 #define _LINUX_KLIST_H
 
 #include <linux/spinlock.h>
-#include <linux/completion.h>
 #include <linux/kref.h>
 #include <linux/list.h>
 
@@ -41,7 +40,6 @@ struct klist_node {
        void                    *n_klist;       /* never access directly */
        struct list_head        n_node;
        struct kref             n_ref;
-       struct completion       n_removed;
 };
 
 extern void klist_add_tail(struct klist_node *n, struct klist *k);
index c02f3d264ecf8d24181463497aafddaa66197447..e80c674daeb38c8385c55d7e89b87f3909dcc201 100644 (file)
@@ -13,7 +13,7 @@
 struct mtd_info *mtd_concat_create(
     struct mtd_info *subdev[],  /* subdevices to concatenate */
     int num_devs,               /* number of subdevices      */
-    char *name);                /* name for the new device   */
+    const char *name);          /* name for the new device   */
 
 void mtd_concat_destroy(struct mtd_info *mtd);
 
index 03b0b8c3c81b5858282004b60ba9a0893d39a6b5..4bb156ba854aaf8fa61ddd68039c0d38cf84aa0e 100644 (file)
@@ -421,7 +421,6 @@ struct pci_driver {
        int  (*resume_early) (struct pci_dev *dev);
        int  (*resume) (struct pci_dev *dev);                   /* Device woken up */
        void (*shutdown) (struct pci_dev *dev);
-       struct pm_ext_ops *pm;
        struct pci_error_handlers *err_handler;
        struct device_driver    driver;
        struct pci_dynids dynids;
index 4b8cc6a324797682d08e487d314cb4ce647e2d7c..9a342699c6075a946f947bea3298cd8e86f65b37 100644 (file)
@@ -55,7 +55,6 @@ struct platform_driver {
        int (*suspend_late)(struct platform_device *, pm_message_t state);
        int (*resume_early)(struct platform_device *);
        int (*resume)(struct platform_device *);
-       struct pm_ext_ops *pm;
        struct device_driver driver;
 };
 
index 42de4003c4ee10a52599ea95d7ae9d53964a0bf9..de2e0a8f6728c668a2005ee3b36147a3b3caeec6 100644 (file)
@@ -41,7 +41,7 @@ typedef struct pm_message {
 } pm_message_t;
 
 /**
- * struct pm_ops - device PM callbacks
+ * struct dev_pm_ops - device PM callbacks
  *
  * Several driver power state transitions are externally visible, affecting
  * the state of pending I/O queues and (for drivers that touch hardware)
@@ -126,46 +126,6 @@ typedef struct pm_message {
  *     On most platforms, there are no restrictions on availability of
  *     resources like clocks during @restore().
  *
- * All of the above callbacks, except for @complete(), return error codes.
- * However, the error codes returned by the resume operations, @resume(),
- * @thaw(), and @restore(), do not cause the PM core to abort the resume
- * transition during which they are returned.  The error codes returned in
- * that cases are only printed by the PM core to the system logs for debugging
- * purposes.  Still, it is recommended that drivers only return error codes
- * from their resume methods in case of an unrecoverable failure (i.e. when the
- * device being handled refuses to resume and becomes unusable) to allow us to
- * modify the PM core in the future, so that it can avoid attempting to handle
- * devices that failed to resume and their children.
- *
- * It is allowed to unregister devices while the above callbacks are being
- * executed.  However, it is not allowed to unregister a device from within any
- * of its own callbacks.
- */
-
-struct pm_ops {
-       int (*prepare)(struct device *dev);
-       void (*complete)(struct device *dev);
-       int (*suspend)(struct device *dev);
-       int (*resume)(struct device *dev);
-       int (*freeze)(struct device *dev);
-       int (*thaw)(struct device *dev);
-       int (*poweroff)(struct device *dev);
-       int (*restore)(struct device *dev);
-};
-
-/**
- * struct pm_ext_ops - extended device PM callbacks
- *
- * Some devices require certain operations related to suspend and hibernation
- * to be carried out with interrupts disabled.  Thus, 'struct pm_ext_ops' below
- * is defined, adding callbacks to be executed with interrupts disabled to
- * 'struct pm_ops'.
- *
- * The following callbacks included in 'struct pm_ext_ops' are executed with
- * the nonboot CPUs switched off and with interrupts disabled on the only
- * functional CPU.  They also are executed with the PM core list of devices
- * locked, so they must NOT unregister any devices.
- *
  * @suspend_noirq: Complete the operations of ->suspend() by carrying out any
  *     actions required for suspending the device that need interrupts to be
  *     disabled
@@ -190,18 +150,32 @@ struct pm_ops {
  *     actions required for restoring the operations of the device that need
  *     interrupts to be disabled
  *
- * All of the above callbacks return error codes, but the error codes returned
- * by the resume operations, @resume_noirq(), @thaw_noirq(), and
- * @restore_noirq(), do not cause the PM core to abort the resume transition
- * during which they are returned.  The error codes returned in that cases are
- * only printed by the PM core to the system logs for debugging purposes.
- * Still, as stated above, it is recommended that drivers only return error
- * codes from their resume methods if the device being handled fails to resume
- * and is not usable any more.
+ * All of the above callbacks, except for @complete(), return error codes.
+ * However, the error codes returned by the resume operations, @resume(),
+ * @thaw(), @restore(), @resume_noirq(), @thaw_noirq(), and @restore_noirq() do
+ * not cause the PM core to abort the resume transition during which they are
+ * returned.  The error codes returned in that cases are only printed by the PM
+ * core to the system logs for debugging purposes.  Still, it is recommended
+ * that drivers only return error codes from their resume methods in case of an
+ * unrecoverable failure (i.e. when the device being handled refuses to resume
+ * and becomes unusable) to allow us to modify the PM core in the future, so
+ * that it can avoid attempting to handle devices that failed to resume and
+ * their children.
+ *
+ * It is allowed to unregister devices while the above callbacks are being
+ * executed.  However, it is not allowed to unregister a device from within any
+ * of its own callbacks.
  */
 
-struct pm_ext_ops {
-       struct pm_ops base;
+struct dev_pm_ops {
+       int (*prepare)(struct device *dev);
+       void (*complete)(struct device *dev);
+       int (*suspend)(struct device *dev);
+       int (*resume)(struct device *dev);
+       int (*freeze)(struct device *dev);
+       int (*thaw)(struct device *dev);
+       int (*poweroff)(struct device *dev);
+       int (*restore)(struct device *dev);
        int (*suspend_noirq)(struct device *dev);
        int (*resume_noirq)(struct device *dev);
        int (*freeze_noirq)(struct device *dev);
@@ -278,7 +252,7 @@ struct pm_ext_ops {
 #define PM_EVENT_SLEEP         (PM_EVENT_SUSPEND | PM_EVENT_HIBERNATE)
 #define PM_EVENT_USER_SUSPEND  (PM_EVENT_USER | PM_EVENT_SUSPEND)
 #define PM_EVENT_USER_RESUME   (PM_EVENT_USER | PM_EVENT_RESUME)
-#define PM_EVENT_REMOTE_WAKEUP (PM_EVENT_REMOTE | PM_EVENT_RESUME)
+#define PM_EVENT_REMOTE_RESUME (PM_EVENT_REMOTE | PM_EVENT_RESUME)
 #define PM_EVENT_AUTO_SUSPEND  (PM_EVENT_AUTO | PM_EVENT_SUSPEND)
 #define PM_EVENT_AUTO_RESUME   (PM_EVENT_AUTO | PM_EVENT_RESUME)
 
@@ -291,15 +265,15 @@ struct pm_ext_ops {
 #define PMSG_THAW      ((struct pm_message){ .event = PM_EVENT_THAW, })
 #define PMSG_RESTORE   ((struct pm_message){ .event = PM_EVENT_RESTORE, })
 #define PMSG_RECOVER   ((struct pm_message){ .event = PM_EVENT_RECOVER, })
-#define PMSG_USER_SUSPEND      ((struct pm_messge) \
+#define PMSG_USER_SUSPEND      ((struct pm_message) \
                                        { .event = PM_EVENT_USER_SUSPEND, })
-#define PMSG_USER_RESUME       ((struct pm_messge) \
+#define PMSG_USER_RESUME       ((struct pm_message) \
                                        { .event = PM_EVENT_USER_RESUME, })
-#define PMSG_REMOTE_RESUME     ((struct pm_messge) \
+#define PMSG_REMOTE_RESUME     ((struct pm_message) \
                                        { .event = PM_EVENT_REMOTE_RESUME, })
-#define PMSG_AUTO_SUSPEND      ((struct pm_messge) \
+#define PMSG_AUTO_SUSPEND      ((struct pm_message) \
                                        { .event = PM_EVENT_AUTO_SUSPEND, })
-#define PMSG_AUTO_RESUME               ((struct pm_messge) \
+#define PMSG_AUTO_RESUME       ((struct pm_message) \
                                        { .event = PM_EVENT_AUTO_RESUME, })
 
 /**
index cdf338d94b7f450b42fbb1a12779cdbc7c920248..a0bb6bd2e5c1795bfdbebe75f672c5c439b5be53 100644 (file)
@@ -38,6 +38,24 @@ struct uio_mem {
 
 #define MAX_UIO_MAPS   5
 
+struct uio_portio;
+
+/**
+ * struct uio_port - description of a UIO port region
+ * @start:             start of port region
+ * @size:              size of port region
+ * @porttype:          type of port (see UIO_PORT_* below)
+ * @portio:            for use by the UIO core only.
+ */
+struct uio_port {
+       unsigned long           start;
+       unsigned long           size;
+       int                     porttype;
+       struct uio_portio       *portio;
+};
+
+#define MAX_UIO_PORT_REGIONS   5
+
 struct uio_device;
 
 /**
@@ -46,6 +64,7 @@ struct uio_device;
  * @name:              device name
  * @version:           device driver version
  * @mem:               list of mappable memory regions, size==0 for end of list
+ * @port:              list of port regions, size==0 for end of list
  * @irq:               interrupt number or UIO_IRQ_CUSTOM
  * @irq_flags:         flags for request_irq()
  * @priv:              optional private data
@@ -57,9 +76,10 @@ struct uio_device;
  */
 struct uio_info {
        struct uio_device       *uio_dev;
-       char                    *name;
-       char                    *version;
+       const char              *name;
+       const char              *version;
        struct uio_mem          mem[MAX_UIO_MAPS];
+       struct uio_port         port[MAX_UIO_PORT_REGIONS];
        long                    irq;
        unsigned long           irq_flags;
        void                    *priv;
@@ -92,4 +112,10 @@ extern void uio_event_notify(struct uio_info *info);
 #define UIO_MEM_LOGICAL        2
 #define UIO_MEM_VIRTUAL 3
 
+/* defines for uio_port->porttype */
+#define UIO_PORT_NONE  0
+#define UIO_PORT_X86   1
+#define UIO_PORT_GPIO  2
+#define UIO_PORT_OTHER 3
+
 #endif /* _LINUX_UIO_DRIVER_H_ */
index 315a6114bf87b976888fa76cca3151af090113fe..e7893b1d3e425767b5f765b8c829c401d7a4dea7 100644 (file)
@@ -423,27 +423,37 @@ config SYSFS_DEPRECATED
        bool
 
 config SYSFS_DEPRECATED_V2
-       bool "Create deprecated sysfs files"
+       bool "Create deprecated sysfs layout for older userspace tools"
        depends on SYSFS
        default y
        select SYSFS_DEPRECATED
        help
-         This option creates deprecated symlinks such as the
-         "device"-link, the <subsystem>:<name>-link, and the
-         "bus"-link. It may also add deprecated key in the
-         uevent environment.
-         None of these features or values should be used today, as
-         they export driver core implementation details to userspace
-         or export properties which can't be kept stable across kernel
-         releases.
-
-         If enabled, this option will also move any device structures
-         that belong to a class, back into the /sys/class hierarchy, in
-         order to support older versions of udev and some userspace
-         programs.
-
-         If you are using a distro with the most recent userspace
-         packages, it should be safe to say N here.
+         This option switches the layout of sysfs to the deprecated
+         version.
+
+         The current sysfs layout features a unified device tree at
+         /sys/devices/, which is able to express a hierarchy between
+         class devices. If the deprecated option is set to Y, the
+         unified device tree is split into a bus device tree at
+         /sys/devices/ and several individual class device trees at
+         /sys/class/. The class and bus devices will be connected by
+         "<subsystem>:<name>" and the "device" links. The "block"
+         class devices, will not show up in /sys/class/block/. Some
+         subsystems will suppress the creation of some devices which
+         depend on the unified device tree.
+
+         This option is not a pure compatibility option that can
+         be safely enabled on newer distributions. It will change the
+         layout of sysfs to the non-extensible deprecated version,
+         and disable some features, which can not be exported without
+         confusing older userspace tools. Since 2007/2008 all major
+         distributions do not enable this option, and ship no tools which
+         depend on the deprecated layout or this option.
+
+         If you are using a new kernel on an older distribution, or use
+         older userspace tools, you might need to say Y here. Do not say Y,
+         if the original kernel, that came with your distribution, has
+         this option set to N.
 
 config PROC_PID_CPUSET
        bool "Include legacy /proc/<pid>/cpuset file"
index 08dd8ed86c77a7f7d05316a794f2eaf2f378c058..528dd78e7e7e94595106d70c6eefb35d3a5b89aa 100644 (file)
@@ -24,7 +24,7 @@ static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
 static struct kobj_attribute _name##_attr = \
        __ATTR(_name, 0644, _name##_show, _name##_store)
 
-#if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
+#if defined(CONFIG_HOTPLUG)
 /* current uevent sequence number */
 static ssize_t uevent_seqnum_show(struct kobject *kobj,
                                  struct kobj_attribute *attr, char *buf)
@@ -137,7 +137,7 @@ struct kobject *kernel_kobj;
 EXPORT_SYMBOL_GPL(kernel_kobj);
 
 static struct attribute * kernel_attrs[] = {
-#if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
+#if defined(CONFIG_HOTPLUG)
        &uevent_seqnum_attr.attr,
        &uevent_helper_attr.attr,
 #endif
index 613f16941b853a4ef949eadc2bc9e54668162e70..239988873971fed7fde593ab2ad28a3523bd66f5 100644 (file)
@@ -615,7 +615,7 @@ static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state)
        /* this may fail if the RTC hasn't been initialized */
        status = rtc_read_time(rtc, &alm.time);
        if (status < 0) {
-               printk(err_readtime, rtc->dev.bus_id, status);
+               printk(err_readtime, dev_name(&rtc->dev), status);
                return;
        }
        rtc_tm_to_time(&alm.time, &now);
@@ -626,7 +626,7 @@ static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state)
 
        status = rtc_set_alarm(rtc, &alm);
        if (status < 0) {
-               printk(err_wakealarm, rtc->dev.bus_id, status);
+               printk(err_wakealarm, dev_name(&rtc->dev), status);
                return;
        }
 
@@ -660,7 +660,7 @@ static int __init has_wakealarm(struct device *dev, void *name_ptr)
        if (!device_may_wakeup(candidate->dev.parent))
                return 0;
 
-       *(char **)name_ptr = dev->bus_id;
+       *(const char **)name_ptr = dev_name(dev);
        return 1;
 }
 
index 8e30295e8566579515ca8126a694150e290107aa..165a19763dc985fd8a53e0b7626ecd8c9cc04629 100644 (file)
@@ -277,40 +277,34 @@ static ssize_t pr_debug_write(struct file *file, const char __user *buf,
                                dynamic_enabled = DYNAMIC_ENABLED_NONE;
                        }
                        err = 0;
-               } else {
-                       if (elem) {
-                               if (value && (elem->enable == 0)) {
-                                       dynamic_printk_enabled |=
-                                                       (1LL << elem->hash1);
-                                       dynamic_printk_enabled2 |=
-                                                       (1LL << elem->hash2);
-                                       elem->enable = 1;
-                                       num_enabled++;
-                                       dynamic_enabled = DYNAMIC_ENABLED_SOME;
-                                       err = 0;
-                                       printk(KERN_DEBUG
-                                              "debugging enabled for module %s\n",
-                                              elem->name);
-                               } else if (!value && (elem->enable == 1)) {
-                                       elem->enable = 0;
-                                       num_enabled--;
-                                       if (disabled_hash(elem->hash1, true))
-                                               dynamic_printk_enabled &=
+               } else if (elem) {
+                       if (value && (elem->enable == 0)) {
+                               dynamic_printk_enabled |= (1LL << elem->hash1);
+                               dynamic_printk_enabled2 |= (1LL << elem->hash2);
+                               elem->enable = 1;
+                               num_enabled++;
+                               dynamic_enabled = DYNAMIC_ENABLED_SOME;
+                               err = 0;
+                               printk(KERN_DEBUG
+                                       "debugging enabled for module %s\n",
+                                       elem->name);
+                       } else if (!value && (elem->enable == 1)) {
+                               elem->enable = 0;
+                               num_enabled--;
+                               if (disabled_hash(elem->hash1, true))
+                                       dynamic_printk_enabled &=
                                                        ~(1LL << elem->hash1);
-                                       if (disabled_hash(elem->hash2, false))
-                                               dynamic_printk_enabled2 &=
+                               if (disabled_hash(elem->hash2, false))
+                                       dynamic_printk_enabled2 &=
                                                        ~(1LL << elem->hash2);
-                                       if (num_enabled)
-                                               dynamic_enabled =
-                                                       DYNAMIC_ENABLED_SOME;
-                                       else
-                                               dynamic_enabled =
-                                                       DYNAMIC_ENABLED_NONE;
-                                       err = 0;
-                                       printk(KERN_DEBUG
-                                              "debugging disabled for module "
-                                              "%s\n", elem->name);
-                               }
+                               if (num_enabled)
+                                       dynamic_enabled = DYNAMIC_ENABLED_SOME;
+                               else
+                                       dynamic_enabled = DYNAMIC_ENABLED_NONE;
+                               err = 0;
+                               printk(KERN_DEBUG
+                                       "debugging disabled for module %s\n",
+                                       elem->name);
                        }
                }
        }
index bbdd3015c2c787430acfb64f1802919619da6399..573d6068a42e4377dcb26851175423d1864957ff 100644 (file)
@@ -36,6 +36,7 @@
 
 #include <linux/klist.h>
 #include <linux/module.h>
+#include <linux/sched.h>
 
 /*
  * Use the lowest bit of n_klist to mark deleted nodes and exclude
@@ -108,7 +109,6 @@ static void add_tail(struct klist *k, struct klist_node *n)
 static void klist_node_init(struct klist *k, struct klist_node *n)
 {
        INIT_LIST_HEAD(&n->n_node);
-       init_completion(&n->n_removed);
        kref_init(&n->n_ref);
        knode_set_klist(n, k);
        if (k->get)
@@ -171,13 +171,34 @@ void klist_add_before(struct klist_node *n, struct klist_node *pos)
 }
 EXPORT_SYMBOL_GPL(klist_add_before);
 
+struct klist_waiter {
+       struct list_head list;
+       struct klist_node *node;
+       struct task_struct *process;
+       int woken;
+};
+
+static DEFINE_SPINLOCK(klist_remove_lock);
+static LIST_HEAD(klist_remove_waiters);
+
 static void klist_release(struct kref *kref)
 {
+       struct klist_waiter *waiter, *tmp;
        struct klist_node *n = container_of(kref, struct klist_node, n_ref);
 
        WARN_ON(!knode_dead(n));
        list_del(&n->n_node);
-       complete(&n->n_removed);
+       spin_lock(&klist_remove_lock);
+       list_for_each_entry_safe(waiter, tmp, &klist_remove_waiters, list) {
+               if (waiter->node != n)
+                       continue;
+
+               waiter->woken = 1;
+               mb();
+               wake_up_process(waiter->process);
+               list_del(&waiter->list);
+       }
+       spin_unlock(&klist_remove_lock);
        knode_set_klist(n, NULL);
 }
 
@@ -217,8 +238,24 @@ EXPORT_SYMBOL_GPL(klist_del);
  */
 void klist_remove(struct klist_node *n)
 {
+       struct klist_waiter waiter;
+
+       waiter.node = n;
+       waiter.process = current;
+       waiter.woken = 0;
+       spin_lock(&klist_remove_lock);
+       list_add(&waiter.list, &klist_remove_waiters);
+       spin_unlock(&klist_remove_lock);
+
        klist_del(n);
-       wait_for_completion(&n->n_removed);
+
+       for (;;) {
+               set_current_state(TASK_UNINTERRUPTIBLE);
+               if (waiter.woken)
+                       break;
+               schedule();
+       }
+       __set_current_state(TASK_RUNNING);
 }
 EXPORT_SYMBOL_GPL(klist_remove);
 
index 3f914725bda8ae6b278070b52258940bc4b68489..318328ddbd1cf57b89cc84dc63b2818b480231d9 100644 (file)
@@ -165,7 +165,7 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
        /* keys passed in from the caller */
        if (envp_ext) {
                for (i = 0; envp_ext[i]; i++) {
-                       retval = add_uevent_var(env, envp_ext[i]);
+                       retval = add_uevent_var(env, "%s", envp_ext[i]);
                        if (retval)
                                goto exit;
                }
@@ -225,8 +225,10 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
                        }
 
                        NETLINK_CB(skb).dst_group = 1;
-                       netlink_broadcast(uevent_sock, skb, 0, 1, GFP_KERNEL);
-               }
+                       retval = netlink_broadcast(uevent_sock, skb, 0, 1,
+                                                  GFP_KERNEL);
+               } else
+                       retval = -ENOMEM;
        }
 #endif
 
index 7f5e21b9c16b90ffaa7fffd3cee96a65a511302b..c2a4e640145620a964d2f4e6c7dd82c522124980 100644 (file)
@@ -647,7 +647,7 @@ swiotlb_full(struct device *dev, size_t size, int dir, int do_panic)
         * the damage, or panic when the transfer is too big.
         */
        printk(KERN_ERR "DMA: Out of SW-IOMMU space for %zu bytes at "
-              "device %s\n", size, dev ? dev->bus_id : "?");
+              "device %s\n", size, dev ? dev_name(dev) : "?");
 
        if (size > io_tlb_overflow && do_panic) {
                if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL)
index 032f61e985951bc85e1825a1e42529e660406713..a35240f61ec3bad362fed2da6378920b3f4fcd99 100644 (file)
@@ -50,7 +50,6 @@
 #include <asm/ebcdic.h>
 #include <asm/io.h>
 #include <asm/s390_ext.h>
-#include <asm/s390_rdev.h>
 #include <asm/smp.h>
 
 /*
@@ -1696,7 +1695,7 @@ static int __init iucv_init(void)
        rc = register_external_interrupt(0x4000, iucv_external_interrupt);
        if (rc)
                goto out;
-       iucv_root = s390_root_dev_register("iucv");
+       iucv_root = root_device_register("iucv");
        if (IS_ERR(iucv_root)) {
                rc = PTR_ERR(iucv_root);
                goto out_int;
@@ -1740,7 +1739,7 @@ out_free:
                kfree(iucv_irq_data[cpu]);
                iucv_irq_data[cpu] = NULL;
        }
-       s390_root_dev_unregister(iucv_root);
+       root_device_unregister(iucv_root);
 out_int:
        unregister_external_interrupt(0x4000, iucv_external_interrupt);
 out:
@@ -1770,7 +1769,7 @@ static void __exit iucv_exit(void)
                kfree(iucv_irq_data[cpu]);
                iucv_irq_data[cpu] = NULL;
        }
-       s390_root_dev_unregister(iucv_root);
+       root_device_unregister(iucv_root);
        bus_unregister(&iucv_bus);
        unregister_external_interrupt(0x4000, iucv_external_interrupt);
 }