Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/w1-2.6
authorLinus Torvalds <torvalds@g5.osdl.org>
Thu, 22 Jun 2006 22:08:34 +0000 (15:08 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Thu, 22 Jun 2006 22:08:34 +0000 (15:08 -0700)
* master.kernel.org:/pub/scm/linux/kernel/git/gregkh/w1-2.6:
  [PATCH] w1: warning fix
  [PATCH] w1: clean up W1_CON dependency.
  [PATCH] drivers/w1/w1.c: fix a compile error
  [PATCH] W1: fix dependencies of W1_SLAVE_DS2433_CRC
  [PATCH] W1: possible cleanups
  [PATCH] W1: cleanups
  [PATCH] w1 exports
  [PATCH] w1: Use mutexes instead of semaphores.
  [PATCH] w1: Make w1 connector notifications depend on connector.
  [PATCH] w1: netlink: Mark netlink group 1 as unused.
  [PATCH] w1: Move w1-connector definitions into linux/include/connector.h
  [PATCH] w1: Userspace communication protocol over connector.
  [PATCH] w1: Replace dscore and ds_w1_bridge with ds2490 driver.
  [PATCH] w1: Added default generic read/write operations.

328 files changed:
Documentation/keys.txt
Documentation/pci.txt
Documentation/sound/alsa/ALSA-Configuration.txt
Documentation/sound/alsa/DocBook/writing-an-alsa-driver.tmpl
arch/i386/kernel/acpi/boot.c
arch/i386/pci/common.c
arch/i386/pci/i386.c
arch/i386/pci/mmconfig.c
arch/i386/pci/pci.h
arch/ia64/kernel/irq_ia64.c
arch/ia64/sn/kernel/io_init.c
arch/ia64/sn/kernel/irq.c
arch/ia64/sn/pci/pci_dma.c
arch/ia64/sn/pci/pcibr/pcibr_dma.c
arch/ia64/sn/pci/tioca_provider.c
arch/ia64/sn/pci/tioce_provider.c
arch/powerpc/boot/Makefile
arch/ppc/boot/lib/Makefile
arch/ppc/platforms/85xx/mpc85xx_cds_common.c
arch/sparc/kernel/setup.c
arch/um/kernel/time_kern.c
arch/x86_64/Kconfig
arch/x86_64/pci/mmconfig.c
arch/xtensa/boot/lib/Makefile
drivers/char/agp/Kconfig
drivers/net/myri10ge/myri10ge.c
drivers/pci/Makefile
drivers/pci/bus.c
drivers/pci/msi-altix.c [new file with mode: 0644]
drivers/pci/msi-apic.c [new file with mode: 0644]
drivers/pci/msi.c
drivers/pci/msi.h
drivers/pci/pci-acpi.c
drivers/pci/pci-sysfs.c
drivers/pci/pci.c
drivers/pci/pci.h
drivers/pci/probe.c
drivers/pci/quirks.c
drivers/pci/remove.c
drivers/pci/search.c
drivers/pci/setup-bus.c
drivers/pci/setup-res.c
drivers/scsi/qla1280.c
drivers/scsi/sata_vsc.c
drivers/video/console/mdacon.c
drivers/video/console/vgacon.c
drivers/video/vga16fb.c
fs/binfmt_elf.c
fs/binfmt_misc.c
fs/block_dev.c
fs/dcache.c
fs/exec.c
fs/locks.c
fs/ntfs/file.c
fs/super.c
include/asm-alpha/vga.h
include/asm-arm/vga.h
include/asm-i386/msi.h
include/asm-i386/vga.h
include/asm-ia64/hw_irq.h
include/asm-ia64/machvec.h
include/asm-ia64/machvec_sn2.h
include/asm-ia64/msi.h
include/asm-ia64/sn/intr.h
include/asm-ia64/sn/pcibr_provider.h
include/asm-ia64/sn/pcibus_provider_defs.h
include/asm-ia64/sn/tiocp.h
include/asm-ia64/vga.h
include/asm-m32r/vga.h
include/asm-mips/vga.h
include/asm-powerpc/vga.h
include/asm-sparc64/vga.h
include/asm-x86_64/msi.h
include/asm-x86_64/vga.h
include/asm-xtensa/vga.h
include/linux/dcache.h
include/linux/fs.h
include/linux/key.h
include/linux/pci.h
include/linux/pci_ids.h
include/linux/pci_regs.h
include/linux/security.h
include/linux/zconf.h
include/linux/zlib.h
include/linux/zutil.h
include/sound/ac97_codec.h
include/sound/asequencer.h
include/sound/asound.h
include/sound/core.h
include/sound/emu10k1.h
include/sound/info.h
include/sound/mpu401.h
include/sound/pcm.h
include/sound/pcm_params.h
include/sound/rawmidi.h
include/sound/version.h
kernel/power/main.c
kernel/sys.c
kernel/user.c
lib/zlib_deflate/deflate.c
lib/zlib_deflate/deflate_syms.c
lib/zlib_inflate/Makefile
lib/zlib_inflate/infblock.c [deleted file]
lib/zlib_inflate/infblock.h [deleted file]
lib/zlib_inflate/infcodes.c [deleted file]
lib/zlib_inflate/infcodes.h [deleted file]
lib/zlib_inflate/inffast.c
lib/zlib_inflate/inffast.h
lib/zlib_inflate/inffixed.h [new file with mode: 0644]
lib/zlib_inflate/inflate.c
lib/zlib_inflate/inflate.h [new file with mode: 0644]
lib/zlib_inflate/inflate_syms.c
lib/zlib_inflate/inflate_sync.c [deleted file]
lib/zlib_inflate/inftrees.c
lib/zlib_inflate/inftrees.h
lib/zlib_inflate/infutil.c [deleted file]
lib/zlib_inflate/infutil.h
security/dummy.c
security/keys/key.c
security/keys/keyring.c
security/keys/process_keys.c
security/keys/request_key.c
security/keys/request_key_auth.c
security/selinux/hooks.c
security/selinux/include/av_perm_to_string.h
security/selinux/include/av_permissions.h
security/selinux/include/class_to_string.h
security/selinux/include/flask.h
security/selinux/include/objsec.h
sound/Kconfig
sound/Makefile
sound/aoa/Kconfig [new file with mode: 0644]
sound/aoa/Makefile [new file with mode: 0644]
sound/aoa/aoa-gpio.h [new file with mode: 0644]
sound/aoa/aoa.h [new file with mode: 0644]
sound/aoa/codecs/Kconfig [new file with mode: 0644]
sound/aoa/codecs/Makefile [new file with mode: 0644]
sound/aoa/codecs/snd-aoa-codec-onyx.c [new file with mode: 0644]
sound/aoa/codecs/snd-aoa-codec-onyx.h [new file with mode: 0644]
sound/aoa/codecs/snd-aoa-codec-tas-gain-table.h [new file with mode: 0644]
sound/aoa/codecs/snd-aoa-codec-tas.c [new file with mode: 0644]
sound/aoa/codecs/snd-aoa-codec-tas.h [new file with mode: 0644]
sound/aoa/codecs/snd-aoa-codec-toonie.c [new file with mode: 0644]
sound/aoa/core/Makefile [new file with mode: 0644]
sound/aoa/core/snd-aoa-alsa.c [new file with mode: 0644]
sound/aoa/core/snd-aoa-alsa.h [new file with mode: 0644]
sound/aoa/core/snd-aoa-core.c [new file with mode: 0644]
sound/aoa/core/snd-aoa-gpio-feature.c [new file with mode: 0644]
sound/aoa/core/snd-aoa-gpio-pmf.c [new file with mode: 0644]
sound/aoa/fabrics/Kconfig [new file with mode: 0644]
sound/aoa/fabrics/Makefile [new file with mode: 0644]
sound/aoa/fabrics/snd-aoa-fabric-layout.c [new file with mode: 0644]
sound/aoa/soundbus/Kconfig [new file with mode: 0644]
sound/aoa/soundbus/Makefile [new file with mode: 0644]
sound/aoa/soundbus/core.c [new file with mode: 0644]
sound/aoa/soundbus/i2sbus/Makefile [new file with mode: 0644]
sound/aoa/soundbus/i2sbus/i2sbus-control.c [new file with mode: 0644]
sound/aoa/soundbus/i2sbus/i2sbus-control.h [new file with mode: 0644]
sound/aoa/soundbus/i2sbus/i2sbus-core.c [new file with mode: 0644]
sound/aoa/soundbus/i2sbus/i2sbus-interface.h [new file with mode: 0644]
sound/aoa/soundbus/i2sbus/i2sbus-pcm.c [new file with mode: 0644]
sound/aoa/soundbus/i2sbus/i2sbus.h [new file with mode: 0644]
sound/aoa/soundbus/soundbus.h [new file with mode: 0644]
sound/aoa/soundbus/sysfs.c [new file with mode: 0644]
sound/arm/sa11xx-uda1341.c
sound/core/control.c
sound/core/device.c
sound/core/hwdep.c
sound/core/info.c
sound/core/info_oss.c
sound/core/init.c
sound/core/isadma.c
sound/core/memory.c
sound/core/misc.c
sound/core/oss/mixer_oss.c
sound/core/oss/pcm_oss.c
sound/core/pcm.c
sound/core/pcm_compat.c
sound/core/pcm_lib.c
sound/core/pcm_memory.c
sound/core/pcm_misc.c
sound/core/pcm_native.c
sound/core/rawmidi.c
sound/core/seq/oss/seq_oss.c
sound/core/seq/seq.c
sound/core/seq/seq_clientmgr.c
sound/core/seq/seq_device.c
sound/core/seq/seq_dummy.c
sound/core/seq/seq_info.c
sound/core/seq/seq_lock.c
sound/core/seq/seq_memory.c
sound/core/seq/seq_midi.c
sound/core/seq/seq_ports.c
sound/core/seq/seq_virmidi.c
sound/core/sound.c
sound/core/sound_oss.c
sound/core/timer.c
sound/drivers/dummy.c
sound/drivers/mpu401/mpu401.c
sound/drivers/mpu401/mpu401_uart.c
sound/drivers/mtpav.c
sound/drivers/opl3/opl3_lib.c
sound/drivers/opl3/opl3_oss.c
sound/drivers/opl3/opl3_seq.c
sound/drivers/opl3/opl3_synth.c
sound/drivers/opl4/opl4_lib.c
sound/drivers/opl4/opl4_seq.c
sound/drivers/serial-u16550.c
sound/drivers/virmidi.c
sound/drivers/vx/vx_core.c
sound/drivers/vx/vx_hwdep.c
sound/i2c/i2c.c
sound/i2c/l3/uda1341.c
sound/isa/gus/gus_irq.c
sound/isa/gus/gus_mem.c
sound/isa/gus/gus_synth.c
sound/isa/gus/interwave.c
sound/isa/opl3sa2.c
sound/isa/opti9xx/miro.c
sound/isa/sb/emu8000.c
sound/isa/sb/emu8000_patch.c
sound/isa/sb/sb16.c
sound/isa/sb/sb16_csp.c
sound/isa/sb/sb8_midi.c
sound/isa/sscape.c
sound/isa/wavefront/wavefront.c
sound/pci/Kconfig
sound/pci/ac97/ac97_codec.c
sound/pci/ac97/ac97_patch.c
sound/pci/ac97/ac97_pcm.c
sound/pci/ac97/ac97_proc.c
sound/pci/ac97/ak4531_codec.c
sound/pci/ad1889.c
sound/pci/ali5451/ali5451.c
sound/pci/als4000.c
sound/pci/atiixp.c
sound/pci/atiixp_modem.c
sound/pci/au88x0/au88x0.c
sound/pci/au88x0/au88x0_mpu401.c
sound/pci/au88x0/au88x0_xtalk.c
sound/pci/azt3328.c
sound/pci/azt3328.h
sound/pci/bt87x.c
sound/pci/ca0106/ca0106.h
sound/pci/ca0106/ca0106_main.c
sound/pci/ca0106/ca0106_mixer.c
sound/pci/ca0106/ca0106_proc.c
sound/pci/cmipci.c
sound/pci/cs4281.c
sound/pci/cs46xx/cs46xx.c
sound/pci/cs46xx/cs46xx_lib.c
sound/pci/cs46xx/dsp_spos.c
sound/pci/cs46xx/dsp_spos_scb_lib.c
sound/pci/cs5535audio/Makefile
sound/pci/cs5535audio/cs5535audio.c
sound/pci/cs5535audio/cs5535audio.h
sound/pci/cs5535audio/cs5535audio_pcm.c
sound/pci/cs5535audio/cs5535audio_pm.c [new file with mode: 0644]
sound/pci/emu10k1/emu10k1.c
sound/pci/emu10k1/emu10k1_main.c
sound/pci/emu10k1/emu10k1x.c
sound/pci/emu10k1/emumixer.c
sound/pci/emu10k1/emuproc.c
sound/pci/emu10k1/io.c
sound/pci/emu10k1/memory.c
sound/pci/emu10k1/p17v.h [new file with mode: 0644]
sound/pci/emu10k1/tina2.h
sound/pci/emu10k1/voice.c
sound/pci/ens1370.c
sound/pci/es1938.c
sound/pci/es1968.c
sound/pci/fm801.c
sound/pci/hda/Makefile
sound/pci/hda/hda_codec.c
sound/pci/hda/hda_intel.c
sound/pci/hda/hda_patch.h
sound/pci/hda/hda_proc.c
sound/pci/hda/patch_analog.c
sound/pci/hda/patch_atihdmi.c [new file with mode: 0644]
sound/pci/hda/patch_realtek.c
sound/pci/hda/patch_sigmatel.c
sound/pci/ice1712/aureon.c
sound/pci/ice1712/aureon.h
sound/pci/ice1712/ews.c
sound/pci/ice1712/ice1712.c
sound/pci/ice1712/ice1712.h
sound/pci/ice1712/ice1724.c
sound/pci/ice1712/pontis.c
sound/pci/intel8x0.c
sound/pci/intel8x0m.c
sound/pci/korg1212/korg1212.c
sound/pci/maestro3.c
sound/pci/mixart/mixart.c
sound/pci/pcxhr/pcxhr.c
sound/pci/riptide/riptide.c
sound/pci/rme32.c
sound/pci/rme96.c
sound/pci/rme9652/hdsp.c
sound/pci/rme9652/hdspm.c
sound/pci/rme9652/rme9652.c
sound/pci/sonicvibes.c
sound/pci/trident/trident.c
sound/pci/trident/trident_main.c
sound/pci/trident/trident_memory.c
sound/pci/trident/trident_synth.c
sound/pci/via82xx.c
sound/pci/via82xx_modem.c
sound/pci/ymfpci/ymfpci.c
sound/pci/ymfpci/ymfpci_main.c
sound/pcmcia/pdaudiocf/pdaudiocf_core.c
sound/pcmcia/vx/vxp_ops.c
sound/pcmcia/vx/vxpocket.c
sound/ppc/Makefile
sound/ppc/pmac.c
sound/ppc/pmac.h
sound/ppc/powermac.c
sound/ppc/toonie.c
sound/sparc/dbri.c
sound/synth/emux/emux.c
sound/synth/emux/emux_proc.c
sound/synth/emux/emux_seq.c
sound/synth/emux/emux_synth.c
sound/synth/emux/soundfont.c
sound/usb/usbaudio.c
sound/usb/usbaudio.h
sound/usb/usbmidi.c
sound/usb/usbmixer.c
sound/usb/usx2y/usx2yhwdeppcm.c

index aaa01b0e3ee94251476d15f2ae6574844af9bb16..3bbe157b45e470ca656c72e47e523138c9be6fe8 100644 (file)
@@ -19,6 +19,7 @@ This document has the following sections:
        - Key overview
        - Key service overview
        - Key access permissions
+       - SELinux support
        - New procfs files
        - Userspace system call interface
        - Kernel services
@@ -232,6 +233,34 @@ For changing the ownership, group ID or permissions mask, being the owner of
 the key or having the sysadmin capability is sufficient.
 
 
+===============
+SELINUX SUPPORT
+===============
+
+The security class "key" has been added to SELinux so that mandatory access
+controls can be applied to keys created within various contexts.  This support
+is preliminary, and is likely to change quite significantly in the near future.
+Currently, all of the basic permissions explained above are provided in SELinux
+as well; SE Linux is simply invoked after all basic permission checks have been
+performed.
+
+Each key is labeled with the same context as the task to which it belongs.
+Typically, this is the same task that was running when the key was created.
+The default keyrings are handled differently, but in a way that is very
+intuitive:
+
+ (*) The user and user session keyrings that are created when the user logs in
+     are currently labeled with the context of the login manager.
+
+ (*) The keyrings associated with new threads are each labeled with the context
+     of their associated thread, and both session and process keyrings are
+     handled similarly.
+
+Note, however, that the default keyrings associated with the root user are
+labeled with the default kernel context, since they are created early in the
+boot process, before root has a chance to log in.
+
+
 ================
 NEW PROCFS FILES
 ================
@@ -935,6 +964,16 @@ The structure has a number of fields, some of which are mandatory:
      It is not safe to sleep in this method; the caller may hold spinlocks.
 
 
+ (*) void (*revoke)(struct key *key);
+
+     This method is optional.  It is called to discard part of the payload
+     data upon a key being revoked.  The caller will have the key semaphore
+     write-locked.
+
+     It is safe to sleep in this method, though care should be taken to avoid
+     a deadlock against the key semaphore.
+
+
  (*) void (*destroy)(struct key *key);
 
      This method is optional. It is called to discard the payload data on a key
index 66bbbf1d1ef64e90cede27c2738290c5d6b4c2ef..3242e5c1ee9cc27330a03494a1f1d48e50cb7300 100644 (file)
@@ -213,9 +213,17 @@ have been remapped by the kernel.
 
    See Documentation/IO-mapping.txt for how to access device memory.
 
-   You still need to call request_region() for I/O regions and
-request_mem_region() for memory regions to make sure nobody else is using the
-same device.
+   The device driver needs to call pci_request_region() to make sure
+no other device is already using the same resource. The driver is expected
+to determine MMIO and IO Port resource availability _before_ calling
+pci_enable_device().  Conversely, drivers should call pci_release_region()
+_after_ calling pci_disable_device(). The idea is to prevent two devices
+colliding on the same address range.
+
+Generic flavors of pci_request_region() are request_mem_region()
+(for MMIO ranges) and request_region() (for IO Port ranges).
+Use these for address resources that are not described by "normal" PCI
+interfaces (e.g. BAR).
 
    All interrupt handlers should be registered with SA_SHIRQ and use the devid
 to map IRQs to devices (remember that all PCI interrupts are shared).
index 0ee2c7dfc4829cd0a4bd1374dd27aeb213a79a16..87d76a5c73d05742c0532d702819111681730af9 100644 (file)
@@ -366,7 +366,9 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
 
     Module for C-Media CMI8338 and 8738 PCI sound cards.
 
-    mpu_port   - 0x300,0x310,0x320,0x330, 0 = disable (default)
+    mpu_port   - 0x300,0x310,0x320,0x330 = legacy port,
+                 1 = integrated PCI port,
+                 0 = disable (default)
     fm_port     - 0x388 (default), 0 = disable (default)
     soft_ac3    - Software-conversion of raw SPDIF packets (model 033 only)
                   (default = 1)
@@ -468,7 +470,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
 
     Module for multifunction CS5535 companion PCI device
 
-    This module supports multiple cards.
+    The power-management is supported.
 
   Module snd-dt019x
   -----------------
@@ -707,8 +709,10 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
   Module snd-hda-intel
   --------------------
 
-    Module for Intel HD Audio (ICH6, ICH6M, ICH7), ATI SB450,
-              VIA VT8251/VT8237A
+    Module for Intel HD Audio (ICH6, ICH6M, ESB2, ICH7, ICH8),
+               ATI SB450, SB600, RS600,
+               VIA VT8251/VT8237A,
+               SIS966, ULI M5461
 
     model      - force the model name
     position_fix - Fix DMA pointer (0 = auto, 1 = none, 2 = POSBUF, 3 = FIFO size)
@@ -778,6 +782,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
        AD1981
          basic         3-jack (default)
          hp            HP nx6320
+         thinkpad      Lenovo Thinkpad T60/X60/Z60
 
        AD1986A
          6stack        6-jack, separate surrounds (default)
@@ -1633,9 +1638,7 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
 
     About capture IBL, see the description of snd-vx222 module.
 
-    Note: the driver is build only when CONFIG_ISA is set.
-    
-    Note2: snd-vxp440 driver is merged to snd-vxpocket driver since
+    Note: snd-vxp440 driver is merged to snd-vxpocket driver since
            ALSA 1.0.10.
 
     The power-management is supported.
@@ -1662,8 +1665,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
 
     Module for Sound Core PDAudioCF sound card.
 
-    Note: the driver is build only when CONFIG_ISA is set.
-
     The power-management is supported.
 
 
index 1faf76383babd26875c9e5d303685a29c6096531..635cbb94357cd575bc46ae3328179dc4cac5ced1 100644 (file)
@@ -4215,7 +4215,7 @@ struct _snd_pcm_runtime {
           <programlisting>
 <![CDATA[
   struct snd_rawmidi *rmidi;
-  snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, port, integrated,
+  snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, port, info_flags,
                       irq, irq_flags, &rmidi);
 ]]>
           </programlisting>
@@ -4242,15 +4242,36 @@ struct _snd_pcm_runtime {
       </para>
 
       <para>
+       The 5th argument is bitflags for additional information.
         When the i/o port address above is a part of the PCI i/o
       region, the MPU401 i/o port might have been already allocated
-      (reserved) by the driver itself. In such a case, pass non-zero
-      to the 5th argument
-      (<parameter>integrated</parameter>). Otherwise, pass 0 to it,
+      (reserved) by the driver itself. In such a case, pass a bit flag
+      <constant>MPU401_INFO_INTEGRATED</constant>,
       and 
       the mpu401-uart layer will allocate the i/o ports by itself. 
       </para>
 
+       <para>
+       When the controller supports only the input or output MIDI stream,
+       pass <constant>MPU401_INFO_INPUT</constant> or
+       <constant>MPU401_INFO_OUTPUT</constant> bitflag, respectively.
+       Then the rawmidi instance is created as a single stream.
+       </para>
+
+       <para>
+       <constant>MPU401_INFO_MMIO</constant> bitflag is used to change
+       the access method to MMIO (via readb and writeb) instead of
+       iob and outb.  In this case, you have to pass the iomapped address
+       to <function>snd_mpu401_uart_new()</function>.
+       </para>
+
+       <para>
+       When <constant>MPU401_INFO_TX_IRQ</constant> is set, the output
+       stream isn't checked in the default interrupt handler.  The driver
+       needs to call <function>snd_mpu401_uart_interrupt_tx()</function>
+       by itself to start processing the output stream in irq handler.
+       </para>
+
       <para>
         Usually, the port address corresponds to the command port and
         port + 1 corresponds to the data port. If not, you may change
@@ -5333,7 +5354,7 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
-  snd_info_set_text_ops(entry, chip, read_size, my_proc_read);
+  snd_info_set_text_ops(entry, chip, my_proc_read);
 ]]>
         </programlisting>
       </informalexample>
@@ -5394,29 +5415,12 @@ struct _snd_pcm_runtime {
       <informalexample>
         <programlisting>
 <![CDATA[
-  entry->c.text.write_size = 256;
   entry->c.text.write = my_proc_write;
 ]]>
         </programlisting>
       </informalexample>
     </para>
 
-    <para>
-    The buffer size for read is set to 1024 implicitly by
-    <function>snd_info_set_text_ops()</function>.  It should suffice
-    in most cases (the size will be aligned to
-    <constant>PAGE_SIZE</constant> anyway), but if you need to handle
-    very large text files, you can set it explicitly, too.
-
-      <informalexample>
-        <programlisting>
-<![CDATA[
-  entry->c.text.read_size = 65536;
-]]>
-        </programlisting>
-      </informalexample>
-    </para>
-
     <para>
       For the write callback, you can use
     <function>snd_info_get_line()</function> to get a text line, and
@@ -5562,7 +5566,7 @@ struct _snd_pcm_runtime {
          power status.</para></listitem>
         <listitem><para>Call <function>snd_pcm_suspend_all()</function> to suspend the running PCM streams.</para></listitem>
        <listitem><para>If AC97 codecs are used, call
-       <function>snd_ac97_resume()</function> for each codec.</para></listitem>
+       <function>snd_ac97_suspend()</function> for each codec.</para></listitem>
         <listitem><para>Save the register values if necessary.</para></listitem>
         <listitem><para>Stop the hardware if necessary.</para></listitem>
         <listitem><para>Disable the PCI device by calling
index 40e5aba3ad3d425f1545ff7e199e1356a56e38d8..fbe93084244c229b67686dec723689b90da18237 100644 (file)
@@ -202,6 +202,8 @@ int __init acpi_parse_mcfg(unsigned long phys_addr, unsigned long size)
                if (mcfg->config[i].base_reserved) {
                        printk(KERN_ERR PREFIX
                               "MMCONFIG not in low 4GB of memory\n");
+                       kfree(pci_mmcfg_config);
+                       pci_mmcfg_config_num = 0;
                        return -ENODEV;
                }
        }
index dbece776c5b281f4a95d97eab3016a069446bb60..c624b61e110455e746ac021c8f7430d1f58251cc 100644 (file)
@@ -288,6 +288,7 @@ int pcibios_enable_device(struct pci_dev *dev, int mask)
 
 void pcibios_disable_device (struct pci_dev *dev)
 {
+       pcibios_disable_resources(dev);
        if (pcibios_disable_irq)
                pcibios_disable_irq(dev);
 }
index ed2c8c899bd37b6bad02568d65d036fcad8770c0..7852827a599b07b5f6a5f053c617a7ac70259eaa 100644 (file)
@@ -242,6 +242,15 @@ int pcibios_enable_resources(struct pci_dev *dev, int mask)
        return 0;
 }
 
+void pcibios_disable_resources(struct pci_dev *dev)
+{
+       u16 cmd;
+
+       pci_read_config_word(dev, PCI_COMMAND, &cmd);
+       cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
+       pci_write_config_word(dev, PCI_COMMAND, cmd);
+}
+
 /*
  *  If we set up a device for bus mastering, we need to check the latency
  *  timer as certain crappy BIOSes forget to set it properly.
index 6b1ea0c9a570ef7e142668dd03bc6b49a471d020..e545b0992c48af9e03364330fc0fe4b6324a88f4 100644 (file)
@@ -15,7 +15,9 @@
 #include <asm/e820.h>
 #include "pci.h"
 
-#define MMCONFIG_APER_SIZE (256*1024*1024)
+/* aperture is up to 256MB but BIOS may reserve less */
+#define MMCONFIG_APER_MIN      (2 * 1024*1024)
+#define MMCONFIG_APER_MAX      (256 * 1024*1024)
 
 /* Assume systems with more busses have correct MCFG */
 #define MAX_CHECK_BUS 16
@@ -197,9 +199,10 @@ void __init pci_mmcfg_init(void)
                return;
 
        if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
-                       pci_mmcfg_config[0].base_address + MMCONFIG_APER_SIZE,
+                       pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
                        E820_RESERVED)) {
-               printk(KERN_ERR "PCI: BIOS Bug: MCFG area is not E820-reserved\n");
+               printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                               pci_mmcfg_config[0].base_address);
                printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
                return;
        }
index 12035e29108b445889006bb5aa842057ad9d5bb3..12bf3d8dda297e3f68f39dc06e996dfafedac58d 100644 (file)
@@ -35,6 +35,7 @@ extern unsigned int pcibios_max_latency;
 
 void pcibios_resource_survey(void);
 int pcibios_enable_resources(struct pci_dev *, int);
+void pcibios_disable_resources(struct pci_dev *);
 
 /* pci-pc.c */
 
index 6c4d59fd03641dbd6ec0543f0f00095e844b7a6b..ef9a2b49307ae756ac58a8fb7f8c360aa2aca53a 100644 (file)
 
 #define IRQ_DEBUG      0
 
+/* These can be overridden in platform_irq_init */
+int ia64_first_device_vector = IA64_DEF_FIRST_DEVICE_VECTOR;
+int ia64_last_device_vector = IA64_DEF_LAST_DEVICE_VECTOR;
+
 /* default base addr of IPI table */
 void __iomem *ipi_base_addr = ((void __iomem *)
                               (__IA64_UNCACHED_OFFSET | IA64_IPI_DEFAULT_BASE_ADDR));
@@ -60,7 +64,7 @@ __u8 isa_irq_to_vector_map[16] = {
 };
 EXPORT_SYMBOL(isa_irq_to_vector_map);
 
-static unsigned long ia64_vector_mask[BITS_TO_LONGS(IA64_NUM_DEVICE_VECTORS)];
+static unsigned long ia64_vector_mask[BITS_TO_LONGS(IA64_MAX_DEVICE_VECTORS)];
 
 int
 assign_irq_vector (int irq)
@@ -89,6 +93,19 @@ free_irq_vector (int vector)
                printk(KERN_WARNING "%s: double free!\n", __FUNCTION__);
 }
 
+int
+reserve_irq_vector (int vector)
+{
+       int pos;
+
+       if (vector < IA64_FIRST_DEVICE_VECTOR ||
+           vector > IA64_LAST_DEVICE_VECTOR)
+               return -EINVAL;
+
+       pos = vector - IA64_FIRST_DEVICE_VECTOR;
+       return test_and_set_bit(pos, ia64_vector_mask);
+}
+
 #ifdef CONFIG_SMP
 #      define IS_RESCHEDULE(vec)       (vec == IA64_IPI_RESCHEDULE)
 #else
index 5101ac462643361ee6bca3de5a459e8946de9c0a..dc09a6a28a37ca42ba5368944d1516375b4bedea 100644 (file)
@@ -58,7 +58,7 @@ static int max_pcibus_number = 255;   /* Default highest pci bus number */
  */
 
 static dma_addr_t
-sn_default_pci_map(struct pci_dev *pdev, unsigned long paddr, size_t size)
+sn_default_pci_map(struct pci_dev *pdev, unsigned long paddr, size_t size, int type)
 {
        return 0;
 }
@@ -457,13 +457,6 @@ void sn_pci_fixup_slot(struct pci_dev *dev)
                pcidev_info->pdi_sn_irq_info = NULL;
                kfree(sn_irq_info);
        }
-
-       /*
-        * MSI currently not supported on altix.  Remove this when
-        * the MSI abstraction patches are integrated into the kernel
-        * (sometime after 2.6.16 releases)
-        */
-       dev->no_msi = 1;
 }
 
 /*
index c265e02f50364af608f34ed53cd0d47af4eb6f1f..dc8e2b6967135f7d92f7236b9601c09cc349cc14 100644 (file)
@@ -26,11 +26,11 @@ static void unregister_intr_pda(struct sn_irq_info *sn_irq_info);
 
 int sn_force_interrupt_flag = 1;
 extern int sn_ioif_inited;
-static struct list_head **sn_irq_lh;
+struct list_head **sn_irq_lh;
 static spinlock_t sn_irq_info_lock = SPIN_LOCK_UNLOCKED; /* non-IRQ lock */
 
-static inline u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
-                                    u64 sn_irq_info,
+u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
+                                    struct sn_irq_info *sn_irq_info,
                                     int req_irq, nasid_t req_nasid,
                                     int req_slice)
 {
@@ -40,12 +40,13 @@ static inline u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
 
        SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_INTERRUPT,
                        (u64) SAL_INTR_ALLOC, (u64) local_nasid,
-                       (u64) local_widget, (u64) sn_irq_info, (u64) req_irq,
+                       (u64) local_widget, __pa(sn_irq_info), (u64) req_irq,
                        (u64) req_nasid, (u64) req_slice);
+
        return ret_stuff.status;
 }
 
-static inline void sn_intr_free(nasid_t local_nasid, int local_widget,
+void sn_intr_free(nasid_t local_nasid, int local_widget,
                                struct sn_irq_info *sn_irq_info)
 {
        struct ia64_sal_retval ret_stuff;
@@ -112,73 +113,91 @@ static void sn_end_irq(unsigned int irq)
 
 static void sn_irq_info_free(struct rcu_head *head);
 
-static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
+struct sn_irq_info *sn_retarget_vector(struct sn_irq_info *sn_irq_info,
+                                      nasid_t nasid, int slice)
 {
-       struct sn_irq_info *sn_irq_info, *sn_irq_info_safe;
-       int cpuid, cpuphys;
+       int vector;
+       int cpuphys;
+       int64_t bridge;
+       int local_widget, status;
+       nasid_t local_nasid;
+       struct sn_irq_info *new_irq_info;
+       struct sn_pcibus_provider *pci_provider;
 
-       cpuid = first_cpu(mask);
-       cpuphys = cpu_physical_id(cpuid);
+       new_irq_info = kmalloc(sizeof(struct sn_irq_info), GFP_ATOMIC);
+       if (new_irq_info == NULL)
+               return NULL;
 
-       list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
-                                sn_irq_lh[irq], list) {
-               u64 bridge;
-               int local_widget, status;
-               nasid_t local_nasid;
-               struct sn_irq_info *new_irq_info;
-               struct sn_pcibus_provider *pci_provider;
-
-               new_irq_info = kmalloc(sizeof(struct sn_irq_info), GFP_ATOMIC);
-               if (new_irq_info == NULL)
-                       break;
-               memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
-
-               bridge = (u64) new_irq_info->irq_bridge;
-               if (!bridge) {
-                       kfree(new_irq_info);
-                       break; /* irq is not a device interrupt */
-               }
+       memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
+
+       bridge = (u64) new_irq_info->irq_bridge;
+       if (!bridge) {
+               kfree(new_irq_info);
+               return NULL; /* irq is not a device interrupt */
+       }
 
-               local_nasid = NASID_GET(bridge);
+       local_nasid = NASID_GET(bridge);
 
-               if (local_nasid & 1)
-                       local_widget = TIO_SWIN_WIDGETNUM(bridge);
-               else
-                       local_widget = SWIN_WIDGETNUM(bridge);
+       if (local_nasid & 1)
+               local_widget = TIO_SWIN_WIDGETNUM(bridge);
+       else
+               local_widget = SWIN_WIDGETNUM(bridge);
 
-               /* Free the old PROM new_irq_info structure */
-               sn_intr_free(local_nasid, local_widget, new_irq_info);
-               /* Update kernels new_irq_info with new target info */
-               unregister_intr_pda(new_irq_info);
+       vector = sn_irq_info->irq_irq;
+       /* Free the old PROM new_irq_info structure */
+       sn_intr_free(local_nasid, local_widget, new_irq_info);
+       /* Update kernels new_irq_info with new target info */
+       unregister_intr_pda(new_irq_info);
 
-               /* allocate a new PROM new_irq_info struct */
-               status = sn_intr_alloc(local_nasid, local_widget,
-                                      __pa(new_irq_info), irq,
-                                      cpuid_to_nasid(cpuid),
-                                      cpuid_to_slice(cpuid));
+       /* allocate a new PROM new_irq_info struct */
+       status = sn_intr_alloc(local_nasid, local_widget,
+                              new_irq_info, vector,
+                              nasid, slice);
 
-               /* SAL call failed */
-               if (status) {
-                       kfree(new_irq_info);
-                       break;
-               }
+       /* SAL call failed */
+       if (status) {
+               kfree(new_irq_info);
+               return NULL;
+       }
 
-               new_irq_info->irq_cpuid = cpuid;
-               register_intr_pda(new_irq_info);
+       cpuphys = nasid_slice_to_cpuid(nasid, slice);
+       new_irq_info->irq_cpuid = cpuphys;
+       register_intr_pda(new_irq_info);
 
-               pci_provider = sn_pci_provider[new_irq_info->irq_bridge_type];
-               if (pci_provider && pci_provider->target_interrupt)
-                       (pci_provider->target_interrupt)(new_irq_info);
+       pci_provider = sn_pci_provider[new_irq_info->irq_bridge_type];
 
-               spin_lock(&sn_irq_info_lock);
-               list_replace_rcu(&sn_irq_info->list, &new_irq_info->list);
-               spin_unlock(&sn_irq_info_lock);
-               call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
+       /*
+        * If this represents a line interrupt, target it.  If it's
+        * an msi (irq_int_bit < 0), it's already targeted.
+        */
+       if (new_irq_info->irq_int_bit >= 0 &&
+           pci_provider && pci_provider->target_interrupt)
+               (pci_provider->target_interrupt)(new_irq_info);
+
+       spin_lock(&sn_irq_info_lock);
+       list_replace_rcu(&sn_irq_info->list, &new_irq_info->list);
+       spin_unlock(&sn_irq_info_lock);
+       call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
 
 #ifdef CONFIG_SMP
-               set_irq_affinity_info((irq & 0xff), cpuphys, 0);
+       set_irq_affinity_info((vector & 0xff), cpuphys, 0);
 #endif
-       }
+
+       return new_irq_info;
+}
+
+static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
+{
+       struct sn_irq_info *sn_irq_info, *sn_irq_info_safe;
+       nasid_t nasid;
+       int slice;
+
+       nasid = cpuid_to_nasid(first_cpu(mask));
+       slice = cpuid_to_slice(first_cpu(mask));
+
+       list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
+                                sn_irq_lh[irq], list)
+               (void)sn_retarget_vector(sn_irq_info, nasid, slice);
 }
 
 struct hw_interrupt_type irq_type_sn = {
@@ -202,6 +221,9 @@ void sn_irq_init(void)
        int i;
        irq_desc_t *base_desc = irq_desc;
 
+       ia64_first_device_vector = IA64_SN2_FIRST_DEVICE_VECTOR;
+       ia64_last_device_vector = IA64_SN2_LAST_DEVICE_VECTOR;
+
        for (i = 0; i < NR_IRQS; i++) {
                if (base_desc[i].handler == &no_irq_type) {
                        base_desc[i].handler = &irq_type_sn;
@@ -285,6 +307,7 @@ void sn_irq_fixup(struct pci_dev *pci_dev, struct sn_irq_info *sn_irq_info)
        /* link it into the sn_irq[irq] list */
        spin_lock(&sn_irq_info_lock);
        list_add_rcu(&sn_irq_info->list, sn_irq_lh[sn_irq_info->irq_irq]);
+       reserve_irq_vector(sn_irq_info->irq_irq);
        spin_unlock(&sn_irq_info_lock);
 
        register_intr_pda(sn_irq_info);
@@ -310,8 +333,11 @@ void sn_irq_unfixup(struct pci_dev *pci_dev)
        spin_lock(&sn_irq_info_lock);
        list_del_rcu(&sn_irq_info->list);
        spin_unlock(&sn_irq_info_lock);
+       if (list_empty(sn_irq_lh[sn_irq_info->irq_irq]))
+               free_irq_vector(sn_irq_info->irq_irq);
        call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
        pci_dev_put(pci_dev);
+
 }
 
 static inline void
index b4b84c269210b134495b864ecd8a40c5a22573ab..7a291a27151186abb95eefb79f16091ebb44a4b7 100644 (file)
@@ -11,7 +11,7 @@
 
 #include <linux/module.h>
 #include <asm/dma.h>
-#include <asm/sn/pcibr_provider.h>
+#include <asm/sn/intr.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/sn_sal.h>
@@ -113,7 +113,8 @@ void *sn_dma_alloc_coherent(struct device *dev, size_t size,
         * resources.
         */
 
-       *dma_handle = provider->dma_map_consistent(pdev, phys_addr, size);
+       *dma_handle = provider->dma_map_consistent(pdev, phys_addr, size,
+                                                  SN_DMA_ADDR_PHYS);
        if (!*dma_handle) {
                printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
                free_pages((unsigned long)cpuaddr, get_order(size));
@@ -176,7 +177,7 @@ dma_addr_t sn_dma_map_single(struct device *dev, void *cpu_addr, size_t size,
        BUG_ON(dev->bus != &pci_bus_type);
 
        phys_addr = __pa(cpu_addr);
-       dma_addr = provider->dma_map(pdev, phys_addr, size);
+       dma_addr = provider->dma_map(pdev, phys_addr, size, SN_DMA_ADDR_PHYS);
        if (!dma_addr) {
                printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
                return 0;
@@ -260,7 +261,8 @@ int sn_dma_map_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
        for (i = 0; i < nhwentries; i++, sg++) {
                phys_addr = SG_ENT_PHYS_ADDRESS(sg);
                sg->dma_address = provider->dma_map(pdev,
-                                                   phys_addr, sg->length);
+                                                   phys_addr, sg->length,
+                                                   SN_DMA_ADDR_PHYS);
 
                if (!sg->dma_address) {
                        printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
index 9f86bb6519aa6bbfc4511e63959d2530bfbcc867..a86c7b9459625973a06c8e0adc2a32c3af8d8549 100644 (file)
@@ -41,7 +41,7 @@ extern int sn_ioif_inited;
 
 static dma_addr_t
 pcibr_dmamap_ate32(struct pcidev_info *info,
-                  u64 paddr, size_t req_size, u64 flags)
+                  u64 paddr, size_t req_size, u64 flags, int dma_flags)
 {
 
        struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
@@ -81,9 +81,12 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
        if (IS_PCIX(pcibus_info))
                ate_flags &= ~(PCI32_ATE_PREF);
 
-       xio_addr =
-           IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-           PHYS_TO_TIODMA(paddr);
+       if (SN_DMA_ADDRTYPE(dma_flags == SN_DMA_ADDR_PHYS))
+               xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
+                                                     PHYS_TO_TIODMA(paddr);
+       else
+               xio_addr = paddr;
+
        offset = IOPGOFF(xio_addr);
        ate = ate_flags | (xio_addr - offset);
 
@@ -91,6 +94,13 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
        if (IS_PIC_SOFT(pcibus_info)) {
                ate |= (pcibus_info->pbi_hub_xid << PIC_ATE_TARGETID_SHFT);
        }
+
+       /*
+        * If we're mapping for MSI, set the MSI bit in the ATE
+        */
+       if (dma_flags & SN_DMA_MSI)
+               ate |= PCI32_ATE_MSI;
+
        ate_write(pcibus_info, ate_index, ate_count, ate);
 
        /*
@@ -105,20 +115,27 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
        if (pcibus_info->pbi_devreg[internal_device] & PCIBR_DEV_SWAP_DIR)
                ATE_SWAP_ON(pci_addr);
 
+
        return pci_addr;
 }
 
 static dma_addr_t
 pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
-                       u64 dma_attributes)
+                       u64 dma_attributes, int dma_flags)
 {
        struct pcibus_info *pcibus_info = (struct pcibus_info *)
            ((info->pdi_host_pcidev_info)->pdi_pcibus_info);
        u64 pci_addr;
 
        /* Translate to Crosstalk View of Physical Address */
-       pci_addr = (IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-                   PHYS_TO_TIODMA(paddr)) | dma_attributes;
+       if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+               pci_addr = IS_PIC_SOFT(pcibus_info) ?
+                               PHYS_TO_DMA(paddr) :
+                               PHYS_TO_TIODMA(paddr) | dma_attributes;
+       else
+               pci_addr = IS_PIC_SOFT(pcibus_info) ?
+                               paddr :
+                               paddr | dma_attributes;
 
        /* Handle Bus mode */
        if (IS_PCIX(pcibus_info))
@@ -130,7 +147,9 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
                    ((u64) pcibus_info->
                     pbi_hub_xid << PIC_PCI64_ATTR_TARG_SHFT);
        } else
-               pci_addr |= TIOCP_PCI64_CMDTYPE_MEM;
+               pci_addr |= (dma_flags & SN_DMA_MSI) ?
+                               TIOCP_PCI64_CMDTYPE_MSI :
+                               TIOCP_PCI64_CMDTYPE_MEM;
 
        /* If PCI mode, func zero uses VCHAN0, every other func uses VCHAN1 */
        if (!IS_PCIX(pcibus_info) && PCI_FUNC(info->pdi_linux_pcidev->devfn))
@@ -141,7 +160,7 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
 
 static dma_addr_t
 pcibr_dmatrans_direct32(struct pcidev_info * info,
-                       u64 paddr, size_t req_size, u64 flags)
+                       u64 paddr, size_t req_size, u64 flags, int dma_flags)
 {
        struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
        struct pcibus_info *pcibus_info = (struct pcibus_info *)pcidev_info->
@@ -156,8 +175,14 @@ pcibr_dmatrans_direct32(struct pcidev_info * info,
                return 0;
        }
 
-       xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-           PHYS_TO_TIODMA(paddr);
+       if (dma_flags & SN_DMA_MSI)
+               return 0;
+
+       if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+               xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
+                                                     PHYS_TO_TIODMA(paddr);
+       else
+               xio_addr = paddr;
 
        xio_base = pcibus_info->pbi_dir_xbase;
        offset = xio_addr - xio_base;
@@ -327,7 +352,7 @@ void sn_dma_flush(u64 addr)
  */
 
 dma_addr_t
-pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
+pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size, int dma_flags)
 {
        dma_addr_t dma_handle;
        struct pcidev_info *pcidev_info = SN_PCIDEV_INFO(hwdev);
@@ -344,11 +369,11 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
                 */
 
                dma_handle = pcibr_dmatrans_direct64(pcidev_info, phys_addr,
-                                                    PCI64_ATTR_PREF);
+                                                    PCI64_ATTR_PREF, dma_flags);
        } else {
                /* Handle 32-63 bit cards via direct mapping */
                dma_handle = pcibr_dmatrans_direct32(pcidev_info, phys_addr,
-                                                    size, 0);
+                                                    size, 0, dma_flags);
                if (!dma_handle) {
                        /*
                         * It is a 32 bit card and we cannot do direct mapping,
@@ -356,7 +381,8 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
                         */
 
                        dma_handle = pcibr_dmamap_ate32(pcidev_info, phys_addr,
-                                                       size, PCI32_ATE_PREF);
+                                                       size, PCI32_ATE_PREF,
+                                                       dma_flags);
                }
        }
 
@@ -365,18 +391,18 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
 
 dma_addr_t
 pcibr_dma_map_consistent(struct pci_dev * hwdev, unsigned long phys_addr,
-                        size_t size)
+                        size_t size, int dma_flags)
 {
        dma_addr_t dma_handle;
        struct pcidev_info *pcidev_info = SN_PCIDEV_INFO(hwdev);
 
        if (hwdev->dev.coherent_dma_mask == ~0UL) {
                dma_handle = pcibr_dmatrans_direct64(pcidev_info, phys_addr,
-                                           PCI64_ATTR_BAR);
+                                           PCI64_ATTR_BAR, dma_flags);
        } else {
                dma_handle = (dma_addr_t) pcibr_dmamap_ate32(pcidev_info,
                                                    phys_addr, size,
-                                                   PCI32_ATE_BAR);
+                                                   PCI32_ATE_BAR, dma_flags);
        }
 
        return dma_handle;
index be0176912968f93c9ed842ffce9604fbb5b1d678..20de72791b979d64791fe119f86153b9d2a93a23 100644 (file)
@@ -515,10 +515,16 @@ tioca_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  * use the GART mapped mode.
  */
 static u64
-tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
        u64 mapaddr;
 
+       /*
+        * Not supported for now ...
+        */
+       if (dma_flags & SN_DMA_MSI)
+               return 0;
+
        /*
         * If card is 64 or 48 bit addresable, use a direct mapping.  32
         * bit direct is so restrictive w.r.t. where the memory resides that
index 833295624e5df3acd2284ef8d10e7226c037c513..4cac7bdc7c7fa4cc72d6a1992f256375728294b3 100644 (file)
@@ -170,7 +170,8 @@ tioce_mmr_war_post(struct tioce_kernel *kern, void *mmr_addr)
        (ATE_PAGE((start)+(len)-1, pagesize) - ATE_PAGE(start, pagesize) + 1)
 
 #define ATE_VALID(ate) ((ate) & (1UL << 63))
-#define ATE_MAKE(addr, ps) (((addr) & ~ATE_PAGEMASK(ps)) | (1UL << 63))
+#define ATE_MAKE(addr, ps, msi) \
+       (((addr) & ~ATE_PAGEMASK(ps)) | (1UL << 63) | ((msi)?(1UL << 62):0))
 
 /*
  * Flavors of ate-based mapping supported by tioce_alloc_map()
@@ -196,15 +197,17 @@ tioce_mmr_war_post(struct tioce_kernel *kern, void *mmr_addr)
  *
  * 63    - must be 1 to indicate d64 mode to CE hardware
  * 62    - barrier bit ... controlled with tioce_dma_barrier()
- * 61    - 0 since this is not an MSI transaction
+ * 61    - msi bit ... specified through dma_flags
  * 60:54 - reserved, MBZ
  */
 static u64
-tioce_dma_d64(unsigned long ct_addr)
+tioce_dma_d64(unsigned long ct_addr, int dma_flags)
 {
        u64 bus_addr;
 
        bus_addr = ct_addr | (1UL << 63);
+       if (dma_flags & SN_DMA_MSI)
+               bus_addr |= (1UL << 61);
 
        return bus_addr;
 }
@@ -261,7 +264,7 @@ pcidev_to_tioce(struct pci_dev *pdev, struct tioce **base,
  */
 static u64
 tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
-               u64 ct_addr, int len)
+               u64 ct_addr, int len, int dma_flags)
 {
        int i;
        int j;
@@ -270,6 +273,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
        int entries;
        int nates;
        u64 pagesize;
+       int msi_capable, msi_wanted;
        u64 *ate_shadow;
        u64 *ate_reg;
        u64 addr;
@@ -291,6 +295,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                ate_reg = ce_mmr->ce_ure_ate3240;
                pagesize = ce_kern->ce_ate3240_pagesize;
                bus_base = TIOCE_M32_MIN;
+               msi_capable = 1;
                break;
        case TIOCE_ATE_M40:
                first = 0;
@@ -299,6 +304,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                ate_reg = ce_mmr->ce_ure_ate40;
                pagesize = MB(64);
                bus_base = TIOCE_M40_MIN;
+               msi_capable = 0;
                break;
        case TIOCE_ATE_M40S:
                /*
@@ -311,11 +317,16 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                ate_reg = ce_mmr->ce_ure_ate3240;
                pagesize = GB(16);
                bus_base = TIOCE_M40S_MIN;
+               msi_capable = 0;
                break;
        default:
                return 0;
        }
 
+       msi_wanted = dma_flags & SN_DMA_MSI;
+       if (msi_wanted && !msi_capable)
+               return 0;
+
        nates = ATE_NPAGES(ct_addr, len, pagesize);
        if (nates > entries)
                return 0;
@@ -344,7 +355,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
        for (j = 0; j < nates; j++) {
                u64 ate;
 
-               ate = ATE_MAKE(addr, pagesize);
+               ate = ATE_MAKE(addr, pagesize, msi_wanted);
                ate_shadow[i + j] = ate;
                tioce_mmr_storei(ce_kern, &ate_reg[i + j], ate);
                addr += pagesize;
@@ -371,7 +382,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
  * Map @paddr into 32-bit bus space of the CE associated with @pcidev_info.
  */
 static u64
-tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr)
+tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr, int dma_flags)
 {
        int dma_ok;
        int port;
@@ -381,6 +392,9 @@ tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr)
        u64 ct_lower;
        dma_addr_t bus_addr;
 
+       if (dma_flags & SN_DMA_MSI)
+               return 0;
+
        ct_upper = ct_addr & ~0x3fffffffUL;
        ct_lower = ct_addr & 0x3fffffffUL;
 
@@ -507,7 +521,7 @@ tioce_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  */
 static u64
 tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
-                int barrier)
+                int barrier, int dma_flags)
 {
        unsigned long flags;
        u64 ct_addr;
@@ -523,15 +537,18 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
        if (dma_mask < 0x7fffffffUL)
                return 0;
 
-       ct_addr = PHYS_TO_TIODMA(paddr);
+       if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+               ct_addr = PHYS_TO_TIODMA(paddr);
+       else
+               ct_addr = paddr;
 
        /*
         * If the device can generate 64 bit addresses, create a D64 map.
-        * Since this should never fail, bypass the rest of the checks.
         */
        if (dma_mask == ~0UL) {
-               mapaddr = tioce_dma_d64(ct_addr);
-               goto dma_map_done;
+               mapaddr = tioce_dma_d64(ct_addr, dma_flags);
+               if (mapaddr)
+                       goto dma_map_done;
        }
 
        pcidev_to_tioce(pdev, NULL, &ce_kern, &port);
@@ -574,18 +591,22 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
 
                if (byte_count > MB(64)) {
                        mapaddr = tioce_alloc_map(ce_kern, TIOCE_ATE_M40S,
-                                                 port, ct_addr, byte_count);
+                                                 port, ct_addr, byte_count,
+                                                 dma_flags);
                        if (!mapaddr)
                                mapaddr =
                                    tioce_alloc_map(ce_kern, TIOCE_ATE_M40, -1,
-                                                   ct_addr, byte_count);
+                                                   ct_addr, byte_count,
+                                                   dma_flags);
                } else {
                        mapaddr = tioce_alloc_map(ce_kern, TIOCE_ATE_M40, -1,
-                                                 ct_addr, byte_count);
+                                                 ct_addr, byte_count,
+                                                 dma_flags);
                        if (!mapaddr)
                                mapaddr =
                                    tioce_alloc_map(ce_kern, TIOCE_ATE_M40S,
-                                                   port, ct_addr, byte_count);
+                                                   port, ct_addr, byte_count,
+                                                   dma_flags);
                }
        }
 
@@ -593,7 +614,7 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
         * 32-bit direct is the next mode to try
         */
        if (!mapaddr && dma_mask >= 0xffffffffUL)
-               mapaddr = tioce_dma_d32(pdev, ct_addr);
+               mapaddr = tioce_dma_d32(pdev, ct_addr, dma_flags);
 
        /*
         * Last resort, try 32-bit ATE-based map.
@@ -601,7 +622,7 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
        if (!mapaddr)
                mapaddr =
                    tioce_alloc_map(ce_kern, TIOCE_ATE_M32, -1, ct_addr,
-                                   byte_count);
+                                   byte_count, dma_flags);
 
        spin_unlock_irqrestore(&ce_kern->ce_lock, flags);
 
@@ -622,9 +643,9 @@ dma_map_done:
  * in the address.
  */
 static u64
-tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
-       return tioce_do_dma_map(pdev, paddr, byte_count, 0);
+       return tioce_do_dma_map(pdev, paddr, byte_count, 0, dma_flags);
 }
 
 /**
@@ -636,9 +657,9 @@ tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count)
  * Simply call tioce_do_dma_map() to create a map with the barrier bit set
  * in the address.
  */ static u64
-tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
-       return tioce_do_dma_map(pdev, paddr, byte_count, 1);
+       return tioce_do_dma_map(pdev, paddr, byte_count, 1, dma_flags);
 }
 
 /**
@@ -696,7 +717,7 @@ tioce_reserve_m32(struct tioce_kernel *ce_kern, u64 base, u64 limit)
        while (ate_index <= last_ate) {
                u64 ate;
 
-               ate = ATE_MAKE(0xdeadbeef, ps);
+               ate = ATE_MAKE(0xdeadbeef, ps, 0);
                ce_kern->ce_ate3240_shadow[ate_index] = ate;
                tioce_mmr_storei(ce_kern, &ce_mmr->ce_ure_ate3240[ate_index],
                                 ate);
index 840ae595a6178e29c6f0089af02d3213a03369b9..d961bfeed05fccbdfbf4a1094fc7ec7a240fce8c 100644 (file)
@@ -29,8 +29,8 @@ OBJCOPYFLAGS    := contents,alloc,load,readonly,data
 OBJCOPY_COFF_ARGS := -O aixcoff-rs6000 --set-start 0x500000
 OBJCOPY_MIB_ARGS  := -O aixcoff-rs6000 -R .stab -R .stabstr -R .comment
 
-zlib       := infblock.c infcodes.c inffast.c inflate.c inftrees.c infutil.c
-zlibheader := infblock.h infcodes.h inffast.h inftrees.h infutil.h
+zlib       := inffast.c inflate.c inftrees.c
+zlibheader := inffast.h inffixed.h inflate.h inftrees.h infutil.h
 zliblinuxheader := zlib.h zconf.h zutil.h
 
 $(addprefix $(obj)/,$(zlib) main.o): $(addprefix $(obj)/,$(zliblinuxheader)) $(addprefix $(obj)/,$(zlibheader))
index 80c84d562fa4ac173b595cd22cdd4d2e02540f2c..2f995f712ec55c90857bd71539f5f34b90df64f7 100644 (file)
@@ -5,7 +5,7 @@
 CFLAGS_kbd.o   := -Idrivers/char
 CFLAGS_vreset.o := -Iarch/ppc/boot/include
 
-zlib  := infblock.c infcodes.c inffast.c inflate.c inftrees.c infutil.c
+zlib  := inffast.c inflate.c inftrees.c
         
 lib-y += $(zlib:.c=.o) div64.o
 lib-$(CONFIG_VGA_CONSOLE) += vreset.o kbd.o
index c9e0aeeca3d87d051dddc3012df8064ded1a8d42..4368dc3f3c30baae6a61a06197510200220355d2 100644 (file)
@@ -379,13 +379,12 @@ mpc85xx_cds_pcibios_fixup(void)
                                         PCI_DEVICE_ID_VIA_82C586_2, NULL))) {
                 dev->irq = 10;
                 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 10);
-               pci_dev_put(dev);
-        }
 
-       if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+               if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
                                         PCI_DEVICE_ID_VIA_82C586_2, dev))) {
-                dev->irq = 11;
-                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+                       dev->irq = 11;
+                       pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+               }
                pci_dev_put(dev);
         }
 }
index 2cbf282f0d004d9bdf2813b043fffa0f0e1f096d..a893a9cc953473a335668569407c0b8d7a35ccf1 100644 (file)
@@ -332,7 +332,7 @@ void __init setup_arch(char **cmdline_p)
        if (!root_flags)
                root_mountflags &= ~MS_RDONLY;
        ROOT_DEV = old_decode_dev(root_dev);
-#ifdef CONFIG_BLK_DEV_INITRD
+#ifdef CONFIG_BLK_DEV_RAM
        rd_image_start = ram_flags & RAMDISK_IMAGE_START_MASK;
        rd_prompt = ((ram_flags & RAMDISK_PROMPT_FLAG) != 0);
        rd_doload = ((ram_flags & RAMDISK_LOAD_FLAG) != 0);     
index 86f51d04c98df366d7a139468cf3afb08c402251..87cdbc560d360a3c62c4c144645e096225765d67 100644 (file)
@@ -87,7 +87,7 @@ void timer_irq(union uml_pt_regs *regs)
 
 void time_init_kern(void)
 {
-       unsigned long long nsecs;
+       long long nsecs;
 
        nsecs = os_nsecs();
        set_normalized_timespec(&wall_to_monotonic, -nsecs / BILLION,
index 408d44a59756f8050c4455fdbb471eb9c9881f09..7d3bc5ac5db0ab7a8fbb156e5a4a8d6c80186979 100644 (file)
@@ -389,6 +389,7 @@ config GART_IOMMU
        bool "K8 GART IOMMU support"
        default y
        select SWIOTLB
+       select AGP
        depends on PCI
        help
          Support for hardware IOMMU in AMD's Opteron/Athlon64 Processors
@@ -401,11 +402,9 @@ config GART_IOMMU
          northbridge and a software emulation used on other systems without
          hardware IOMMU.  If unsure, say Y.
 
-# need this always enabled with GART_IOMMU for the VIA workaround
+# need this always selected by GART_IOMMU for the VIA workaround
 config SWIOTLB
        bool
-       default y
-       depends on GART_IOMMU
 
 config X86_MCE
        bool "Machine check support" if EMBEDDED
index a2060e4d5de66ff613383ba0b3f8268425b9bf5b..3c55c76c6fd5de3d262e20fd7727653cc6849750 100644 (file)
 
 #include "pci.h"
 
-#define MMCONFIG_APER_SIZE (256*1024*1024)
+/* aperture is up to 256MB but BIOS may reserve less */
+#define MMCONFIG_APER_MIN      (2 * 1024*1024)
+#define MMCONFIG_APER_MAX      (256 * 1024*1024)
+
 /* Verify the first 16 busses. We assume that systems with more busses
    get MCFG right. */
 #define MAX_CHECK_BUS 16
@@ -175,9 +178,10 @@ void __init pci_mmcfg_init(void)
                return;
 
        if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
-                       pci_mmcfg_config[0].base_address + MMCONFIG_APER_SIZE,
+                       pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
                        E820_RESERVED)) {
-               printk(KERN_ERR "PCI: BIOS Bug: MCFG area is not E820-reserved\n");
+               printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                               pci_mmcfg_config[0].base_address);
                printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
                return;
        }
@@ -190,7 +194,8 @@ void __init pci_mmcfg_init(void)
        }
        for (i = 0; i < pci_mmcfg_config_num; ++i) {
                pci_mmcfg_virt[i].cfg = &pci_mmcfg_config[i];
-               pci_mmcfg_virt[i].virt = ioremap_nocache(pci_mmcfg_config[i].base_address, MMCONFIG_APER_SIZE);
+               pci_mmcfg_virt[i].virt = ioremap_nocache(pci_mmcfg_config[i].base_address,
+                                                        MMCONFIG_APER_MAX);
                if (!pci_mmcfg_virt[i].virt) {
                        printk("PCI: Cannot map mmconfig aperture for segment %d\n",
                               pci_mmcfg_config[i].pci_segment_group_number);
index 9e73bb8aeb7affb3216c8eb16b8f617f15874781..d3d2aa2d883aa6e4d9abfc7571b7e3e5eadbc30f 100644 (file)
@@ -2,7 +2,7 @@
 # Makefile for some libs needed by zImage.
 #
 
-zlib   := infblock.c infcodes.c inffast.c inflate.c inftrees.c infutil.c
+zlib   := inffast.c inflate.c inftrees.c
 
 lib-y  += $(zlib:.c=.o) zmem.o
 
index 7c88c060a9e6b3ab908660b6676aef4423488a35..46685a540772908817b10fbae775fe8099ab2bb8 100644 (file)
@@ -1,7 +1,6 @@
 config AGP
-       tristate "/dev/agpgart (AGP Support)" if !GART_IOMMU
+       tristate "/dev/agpgart (AGP Support)"
        depends on ALPHA || IA64 || PPC || X86
-       default y if GART_IOMMU
        ---help---
          AGP (Accelerated Graphics Port) is a bus system mainly used to
          connect graphics cards to the rest of the system.
index e1feb58bd6615675cbf89d23355efd63228be94f..1a2b9785e9986090e4ac5270b788411b48494421 100644 (file)
@@ -2120,7 +2120,7 @@ abort_linearize:
                goto drop;
        }
 
-       if (skb_linearize(skb, GFP_ATOMIC))
+       if (skb_linearize(skb))
                goto drop;
 
        mgp->tx_linearized++;
index 6707df9689345926ead7ed90b5f6726de6620de5..f2d152b818f0c162fdf27f66a69b564737518764 100644 (file)
@@ -26,7 +26,11 @@ obj-$(CONFIG_PPC32) += setup-irq.o
 obj-$(CONFIG_PPC64) += setup-bus.o
 obj-$(CONFIG_MIPS) += setup-bus.o setup-irq.o
 obj-$(CONFIG_X86_VISWS) += setup-irq.o
-obj-$(CONFIG_PCI_MSI) += msi.o
+
+msiobj-y := msi.o msi-apic.o
+msiobj-$(CONFIG_IA64_GENERIC) += msi-altix.o
+msiobj-$(CONFIG_IA64_SGI_SN2) += msi-altix.o
+obj-$(CONFIG_PCI_MSI) += $(msiobj-y)
 
 #
 # ACPI Related PCI FW Functions
index eed67d9e73bcd6e3e9ac684342d460a1ac77c62b..7230926820234f3c676d50397abcdf41be4a7b52 100644 (file)
@@ -81,9 +81,9 @@ void __devinit pci_bus_add_device(struct pci_dev *dev)
 {
        device_add(&dev->dev);
 
-       spin_lock(&pci_bus_lock);
+       down_write(&pci_bus_sem);
        list_add_tail(&dev->global_list, &pci_devices);
-       spin_unlock(&pci_bus_lock);
+       up_write(&pci_bus_sem);
 
        pci_proc_attach_device(dev);
        pci_create_sysfs_dev_files(dev);
@@ -125,10 +125,10 @@ void __devinit pci_bus_add_devices(struct pci_bus *bus)
                 */
                if (dev->subordinate) {
                       if (list_empty(&dev->subordinate->node)) {
-                              spin_lock(&pci_bus_lock);
+                              down_write(&pci_bus_sem);
                               list_add_tail(&dev->subordinate->node,
                                               &dev->bus->children);
-                              spin_unlock(&pci_bus_lock);
+                              up_write(&pci_bus_sem);
                       }
                        pci_bus_add_devices(dev->subordinate);
 
@@ -168,7 +168,7 @@ void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
        struct list_head *next;
 
        bus = top;
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
        next = top->devices.next;
        for (;;) {
                if (next == &bus->devices) {
@@ -180,22 +180,19 @@ void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
                        continue;
                }
                dev = list_entry(next, struct pci_dev, bus_list);
-               pci_dev_get(dev);
                if (dev->subordinate) {
                        /* this is a pci-pci bridge, do its devices next */
                        next = dev->subordinate->devices.next;
                        bus = dev->subordinate;
                } else
                        next = dev->bus_list.next;
-               spin_unlock(&pci_bus_lock);
 
-               /* Run device routines with the bus unlocked */
+               /* Run device routines with the device locked */
+               down(&dev->dev.sem);
                cb(dev, userdata);
-
-               spin_lock(&pci_bus_lock);
-               pci_dev_put(dev);
+               up(&dev->dev.sem);
        }
-       spin_unlock(&pci_bus_lock);
+       up_read(&pci_bus_sem);
 }
 EXPORT_SYMBOL_GPL(pci_walk_bus);
 
diff --git a/drivers/pci/msi-altix.c b/drivers/pci/msi-altix.c
new file mode 100644 (file)
index 0000000..bed4183
--- /dev/null
@@ -0,0 +1,210 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2006 Silicon Graphics, Inc.  All Rights Reserved.
+ */
+
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/cpumask.h>
+
+#include <asm/sn/addrs.h>
+#include <asm/sn/intr.h>
+#include <asm/sn/pcibus_provider_defs.h>
+#include <asm/sn/pcidev.h>
+#include <asm/sn/nodepda.h>
+
+#include "msi.h"
+
+struct sn_msi_info {
+       u64 pci_addr;
+       struct sn_irq_info *sn_irq_info;
+};
+
+static struct sn_msi_info *sn_msi_info;
+
+static void
+sn_msi_teardown(unsigned int vector)
+{
+       nasid_t nasid;
+       int widget;
+       struct pci_dev *pdev;
+       struct pcidev_info *sn_pdev;
+       struct sn_irq_info *sn_irq_info;
+       struct pcibus_bussoft *bussoft;
+       struct sn_pcibus_provider *provider;
+
+       sn_irq_info = sn_msi_info[vector].sn_irq_info;
+       if (sn_irq_info == NULL || sn_irq_info->irq_int_bit >= 0)
+               return;
+
+       sn_pdev = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
+       pdev = sn_pdev->pdi_linux_pcidev;
+       provider = SN_PCIDEV_BUSPROVIDER(pdev);
+
+       (*provider->dma_unmap)(pdev,
+                              sn_msi_info[vector].pci_addr,
+                              PCI_DMA_FROMDEVICE);
+       sn_msi_info[vector].pci_addr = 0;
+
+       bussoft = SN_PCIDEV_BUSSOFT(pdev);
+       nasid = NASID_GET(bussoft->bs_base);
+       widget = (nasid & 1) ?
+                       TIO_SWIN_WIDGETNUM(bussoft->bs_base) :
+                       SWIN_WIDGETNUM(bussoft->bs_base);
+
+       sn_intr_free(nasid, widget, sn_irq_info);
+       sn_msi_info[vector].sn_irq_info = NULL;
+
+       return;
+}
+
+int
+sn_msi_setup(struct pci_dev *pdev, unsigned int vector,
+            u32 *addr_hi, u32 *addr_lo, u32 *data)
+{
+       int widget;
+       int status;
+       nasid_t nasid;
+       u64 bus_addr;
+       struct sn_irq_info *sn_irq_info;
+       struct pcibus_bussoft *bussoft = SN_PCIDEV_BUSSOFT(pdev);
+       struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
+
+       if (bussoft == NULL)
+               return -EINVAL;
+
+       if (provider == NULL || provider->dma_map_consistent == NULL)
+               return -EINVAL;
+
+       /*
+        * Set up the vector plumbing.  Let the prom (via sn_intr_alloc)
+        * decide which cpu to direct this msi at by default.
+        */
+
+       nasid = NASID_GET(bussoft->bs_base);
+       widget = (nasid & 1) ?
+                       TIO_SWIN_WIDGETNUM(bussoft->bs_base) :
+                       SWIN_WIDGETNUM(bussoft->bs_base);
+
+       sn_irq_info = kzalloc(sizeof(struct sn_irq_info), GFP_KERNEL);
+       if (! sn_irq_info)
+               return -ENOMEM;
+
+       status = sn_intr_alloc(nasid, widget, sn_irq_info, vector, -1, -1);
+       if (status) {
+               kfree(sn_irq_info);
+               return -ENOMEM;
+       }
+
+       sn_irq_info->irq_int_bit = -1;          /* mark this as an MSI irq */
+       sn_irq_fixup(pdev, sn_irq_info);
+
+       /* Prom probably should fill these in, but doesn't ... */
+       sn_irq_info->irq_bridge_type = bussoft->bs_asic_type;
+       sn_irq_info->irq_bridge = (void *)bussoft->bs_base;
+
+       /*
+        * Map the xio address into bus space
+        */
+       bus_addr = (*provider->dma_map_consistent)(pdev,
+                                       sn_irq_info->irq_xtalkaddr,
+                                       sizeof(sn_irq_info->irq_xtalkaddr),
+                                       SN_DMA_MSI|SN_DMA_ADDR_XIO);
+       if (! bus_addr) {
+               sn_intr_free(nasid, widget, sn_irq_info);
+               kfree(sn_irq_info);
+               return -ENOMEM;
+       }
+
+       sn_msi_info[vector].sn_irq_info = sn_irq_info;
+       sn_msi_info[vector].pci_addr = bus_addr;
+
+       *addr_hi = (u32)(bus_addr >> 32);
+       *addr_lo = (u32)(bus_addr & 0x00000000ffffffff);
+
+       /*
+        * In the SN platform, bit 16 is a "send vector" bit which
+        * must be present in order to move the vector through the system.
+        */
+       *data = 0x100 + (unsigned int)vector;
+
+#ifdef CONFIG_SMP
+       set_irq_affinity_info((vector & 0xff), sn_irq_info->irq_cpuid, 0);
+#endif
+
+       return 0;
+}
+
+static void
+sn_msi_target(unsigned int vector, unsigned int cpu,
+             u32 *addr_hi, u32 *addr_lo)
+{
+       int slice;
+       nasid_t nasid;
+       u64 bus_addr;
+       struct pci_dev *pdev;
+       struct pcidev_info *sn_pdev;
+       struct sn_irq_info *sn_irq_info;
+       struct sn_irq_info *new_irq_info;
+       struct sn_pcibus_provider *provider;
+
+       sn_irq_info = sn_msi_info[vector].sn_irq_info;
+       if (sn_irq_info == NULL || sn_irq_info->irq_int_bit >= 0)
+               return;
+
+       /*
+        * Release XIO resources for the old MSI PCI address
+        */
+
+        sn_pdev = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
+       pdev = sn_pdev->pdi_linux_pcidev;
+       provider = SN_PCIDEV_BUSPROVIDER(pdev);
+
+       bus_addr = (u64)(*addr_hi) << 32 | (u64)(*addr_lo);
+       (*provider->dma_unmap)(pdev, bus_addr, PCI_DMA_FROMDEVICE);
+       sn_msi_info[vector].pci_addr = 0;
+
+       nasid = cpuid_to_nasid(cpu);
+       slice = cpuid_to_slice(cpu);
+
+       new_irq_info = sn_retarget_vector(sn_irq_info, nasid, slice);
+       sn_msi_info[vector].sn_irq_info = new_irq_info;
+       if (new_irq_info == NULL)
+               return;
+
+       /*
+        * Map the xio address into bus space
+        */
+
+       bus_addr = (*provider->dma_map_consistent)(pdev,
+                                       new_irq_info->irq_xtalkaddr,
+                                       sizeof(new_irq_info->irq_xtalkaddr),
+                                       SN_DMA_MSI|SN_DMA_ADDR_XIO);
+
+       sn_msi_info[vector].pci_addr = bus_addr;
+       *addr_hi = (u32)(bus_addr >> 32);
+       *addr_lo = (u32)(bus_addr & 0x00000000ffffffff);
+}
+
+struct msi_ops sn_msi_ops = {
+       .setup = sn_msi_setup,
+       .teardown = sn_msi_teardown,
+#ifdef CONFIG_SMP
+       .target = sn_msi_target,
+#endif
+};
+
+int
+sn_msi_init(void)
+{
+       sn_msi_info =
+               kzalloc(sizeof(struct sn_msi_info) * NR_VECTORS, GFP_KERNEL);
+       if (! sn_msi_info)
+               return -ENOMEM;
+
+       msi_register(&sn_msi_ops);
+       return 0;
+}
diff --git a/drivers/pci/msi-apic.c b/drivers/pci/msi-apic.c
new file mode 100644 (file)
index 0000000..0eb5fe9
--- /dev/null
@@ -0,0 +1,100 @@
+/*
+ * MSI hooks for standard x86 apic
+ */
+
+#include <linux/pci.h>
+#include <linux/irq.h>
+
+#include "msi.h"
+
+/*
+ * Shifts for APIC-based data
+ */
+
+#define MSI_DATA_VECTOR_SHIFT          0
+#define            MSI_DATA_VECTOR(v)          (((u8)v) << MSI_DATA_VECTOR_SHIFT)
+
+#define MSI_DATA_DELIVERY_SHIFT                8
+#define     MSI_DATA_DELIVERY_FIXED    (0 << MSI_DATA_DELIVERY_SHIFT)
+#define     MSI_DATA_DELIVERY_LOWPRI   (1 << MSI_DATA_DELIVERY_SHIFT)
+
+#define MSI_DATA_LEVEL_SHIFT           14
+#define     MSI_DATA_LEVEL_DEASSERT    (0 << MSI_DATA_LEVEL_SHIFT)
+#define     MSI_DATA_LEVEL_ASSERT      (1 << MSI_DATA_LEVEL_SHIFT)
+
+#define MSI_DATA_TRIGGER_SHIFT         15
+#define     MSI_DATA_TRIGGER_EDGE      (0 << MSI_DATA_TRIGGER_SHIFT)
+#define     MSI_DATA_TRIGGER_LEVEL     (1 << MSI_DATA_TRIGGER_SHIFT)
+
+/*
+ * Shift/mask fields for APIC-based bus address
+ */
+
+#define MSI_ADDR_HEADER                        0xfee00000
+
+#define MSI_ADDR_DESTID_MASK           0xfff0000f
+#define     MSI_ADDR_DESTID_CPU(cpu)   ((cpu) << MSI_TARGET_CPU_SHIFT)
+
+#define MSI_ADDR_DESTMODE_SHIFT                2
+#define     MSI_ADDR_DESTMODE_PHYS     (0 << MSI_ADDR_DESTMODE_SHIFT)
+#define            MSI_ADDR_DESTMODE_LOGIC     (1 << MSI_ADDR_DESTMODE_SHIFT)
+
+#define MSI_ADDR_REDIRECTION_SHIFT     3
+#define     MSI_ADDR_REDIRECTION_CPU   (0 << MSI_ADDR_REDIRECTION_SHIFT)
+#define     MSI_ADDR_REDIRECTION_LOWPRI        (1 << MSI_ADDR_REDIRECTION_SHIFT)
+
+
+static void
+msi_target_apic(unsigned int vector,
+               unsigned int dest_cpu,
+               u32 *address_hi,        /* in/out */
+               u32 *address_lo)        /* in/out */
+{
+       u32 addr = *address_lo;
+
+       addr &= MSI_ADDR_DESTID_MASK;
+       addr |= MSI_ADDR_DESTID_CPU(cpu_physical_id(dest_cpu));
+
+       *address_lo = addr;
+}
+
+static int
+msi_setup_apic(struct pci_dev *pdev,   /* unused in generic */
+               unsigned int vector,
+               u32 *address_hi,
+               u32 *address_lo,
+               u32 *data)
+{
+       unsigned long   dest_phys_id;
+
+       dest_phys_id = cpu_physical_id(first_cpu(cpu_online_map));
+
+       *address_hi = 0;
+       *address_lo =   MSI_ADDR_HEADER |
+                       MSI_ADDR_DESTMODE_PHYS |
+                       MSI_ADDR_REDIRECTION_CPU |
+                       MSI_ADDR_DESTID_CPU(dest_phys_id);
+
+       *data = MSI_DATA_TRIGGER_EDGE |
+               MSI_DATA_LEVEL_ASSERT |
+               MSI_DATA_DELIVERY_FIXED |
+               MSI_DATA_VECTOR(vector);
+
+       return 0;
+}
+
+static void
+msi_teardown_apic(unsigned int vector)
+{
+       return;         /* no-op */
+}
+
+/*
+ * Generic ops used on most IA archs/platforms.  Set with msi_register()
+ */
+
+struct msi_ops msi_apic_ops = {
+       .setup = msi_setup_apic,
+       .teardown = msi_teardown_apic,
+       .target = msi_target_apic,
+};
index 9855c4c920b82af7f106e0afb251f5251a5f032a..7f8429284fabe0663e4c6dc30fc6deefeaa178e3 100644 (file)
@@ -23,8 +23,6 @@
 #include "pci.h"
 #include "msi.h"
 
-#define MSI_TARGET_CPU         first_cpu(cpu_online_map)
-
 static DEFINE_SPINLOCK(msi_lock);
 static struct msi_desc* msi_desc[NR_IRQS] = { [0 ... NR_IRQS-1] = NULL };
 static kmem_cache_t* msi_cachep;
@@ -37,9 +35,17 @@ static int nr_msix_devices;
 
 #ifndef CONFIG_X86_IO_APIC
 int vector_irq[NR_VECTORS] = { [0 ... NR_VECTORS - 1] = -1};
-u8 irq_vector[NR_IRQ_VECTORS] = { FIRST_DEVICE_VECTOR , 0 };
 #endif
 
+static struct msi_ops *msi_ops;
+
+int
+msi_register(struct msi_ops *ops)
+{
+       msi_ops = ops;
+       return 0;
+}
+
 static void msi_cache_ctor(void *p, kmem_cache_t *cache, unsigned long flags)
 {
        memset(p, 0, NR_IRQS * sizeof(struct msi_desc));
@@ -92,7 +98,7 @@ static void msi_set_mask_bit(unsigned int vector, int flag)
 static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
 {
        struct msi_desc *entry;
-       struct msg_address address;
+       u32 address_hi, address_lo;
        unsigned int irq = vector;
        unsigned int dest_cpu = first_cpu(cpu_mask);
 
@@ -108,28 +114,36 @@ static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
                if (!pos)
                        return;
 
+               pci_read_config_dword(entry->dev, msi_upper_address_reg(pos),
+                       &address_hi);
                pci_read_config_dword(entry->dev, msi_lower_address_reg(pos),
-                       &address.lo_address.value);
-               address.lo_address.value &= MSI_ADDRESS_DEST_ID_MASK;
-               address.lo_address.value |= (cpu_physical_id(dest_cpu) <<
-                                                                       MSI_TARGET_CPU_SHIFT);
-               entry->msi_attrib.current_cpu = cpu_physical_id(dest_cpu);
+                       &address_lo);
+
+               msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
+
+               pci_write_config_dword(entry->dev, msi_upper_address_reg(pos),
+                       address_hi);
                pci_write_config_dword(entry->dev, msi_lower_address_reg(pos),
-                       address.lo_address.value);
+                       address_lo);
                set_native_irq_info(irq, cpu_mask);
                break;
        }
        case PCI_CAP_ID_MSIX:
        {
-               int offset = entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
-                       PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET;
-
-               address.lo_address.value = readl(entry->mask_base + offset);
-               address.lo_address.value &= MSI_ADDRESS_DEST_ID_MASK;
-               address.lo_address.value |= (cpu_physical_id(dest_cpu) <<
-                                                                       MSI_TARGET_CPU_SHIFT);
-               entry->msi_attrib.current_cpu = cpu_physical_id(dest_cpu);
-               writel(address.lo_address.value, entry->mask_base + offset);
+               int offset_hi =
+                       entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
+                               PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET;
+               int offset_lo =
+                       entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
+                               PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET;
+
+               address_hi = readl(entry->mask_base + offset_hi);
+               address_lo = readl(entry->mask_base + offset_lo);
+
+               msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
+
+               writel(address_hi, entry->mask_base + offset_hi);
+               writel(address_lo, entry->mask_base + offset_lo);
                set_native_irq_info(irq, cpu_mask);
                break;
        }
@@ -251,30 +265,6 @@ static struct hw_interrupt_type msi_irq_wo_maskbit_type = {
        .set_affinity   = set_msi_affinity
 };
 
-static void msi_data_init(struct msg_data *msi_data,
-                         unsigned int vector)
-{
-       memset(msi_data, 0, sizeof(struct msg_data));
-       msi_data->vector = (u8)vector;
-       msi_data->delivery_mode = MSI_DELIVERY_MODE;
-       msi_data->level = MSI_LEVEL_MODE;
-       msi_data->trigger = MSI_TRIGGER_MODE;
-}
-
-static void msi_address_init(struct msg_address *msi_address)
-{
-       unsigned int    dest_id;
-       unsigned long   dest_phys_id = cpu_physical_id(MSI_TARGET_CPU);
-
-       memset(msi_address, 0, sizeof(struct msg_address));
-       msi_address->hi_address = (u32)0;
-       dest_id = (MSI_ADDRESS_HEADER << MSI_ADDRESS_HEADER_SHIFT);
-       msi_address->lo_address.u.dest_mode = MSI_PHYSICAL_MODE;
-       msi_address->lo_address.u.redirection_hint = MSI_REDIRECTION_HINT_MODE;
-       msi_address->lo_address.u.dest_id = dest_id;
-       msi_address->lo_address.value |= (dest_phys_id << MSI_TARGET_CPU_SHIFT);
-}
-
 static int msi_free_vector(struct pci_dev* dev, int vector, int reassign);
 static int assign_msi_vector(void)
 {
@@ -369,13 +359,29 @@ static int msi_init(void)
                return status;
        }
 
+       status = msi_arch_init();
+       if (status < 0) {
+               pci_msi_enable = 0;
+               printk(KERN_WARNING
+                      "PCI: MSI arch init failed.  MSI disabled.\n");
+               return status;
+       }
+
+       if (! msi_ops) {
+               printk(KERN_WARNING
+                      "PCI: MSI ops not registered. MSI disabled.\n");
+               status = -EINVAL;
+               return status;
+       }
+
+       last_alloc_vector = assign_irq_vector(AUTO_ASSIGN);
        status = msi_cache_init();
        if (status < 0) {
                pci_msi_enable = 0;
                printk(KERN_WARNING "PCI: MSI cache init failed\n");
                return status;
        }
-       last_alloc_vector = assign_irq_vector(AUTO_ASSIGN);
+
        if (last_alloc_vector < 0) {
                pci_msi_enable = 0;
                printk(KERN_WARNING "PCI: No interrupt vectors available for MSI\n");
@@ -442,9 +448,11 @@ static void enable_msi_mode(struct pci_dev *dev, int pos, int type)
                /* Set enabled bits to single MSI & enable MSI_enable bit */
                msi_enable(control, 1);
                pci_write_config_word(dev, msi_control_reg(pos), control);
+               dev->msi_enabled = 1;
        } else {
                msix_enable(control);
                pci_write_config_word(dev, msi_control_reg(pos), control);
+               dev->msix_enabled = 1;
        }
        if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
                /* PCI Express Endpoint device detected */
@@ -461,9 +469,11 @@ void disable_msi_mode(struct pci_dev *dev, int pos, int type)
                /* Set enabled bits to single MSI & enable MSI_enable bit */
                msi_disable(control);
                pci_write_config_word(dev, msi_control_reg(pos), control);
+               dev->msi_enabled = 0;
        } else {
                msix_disable(control);
                pci_write_config_word(dev, msi_control_reg(pos), control);
+               dev->msix_enabled = 0;
        }
        if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
                /* PCI Express Endpoint device detected */
@@ -538,7 +548,6 @@ int pci_save_msi_state(struct pci_dev *dev)
                pci_read_config_dword(dev, pos + PCI_MSI_DATA_32, &cap[i++]);
        if (control & PCI_MSI_FLAGS_MASKBIT)
                pci_read_config_dword(dev, pos + PCI_MSI_MASK_BIT, &cap[i++]);
-       disable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
        save_state->cap_nr = PCI_CAP_ID_MSI;
        pci_add_saved_cap(dev, save_state);
        return 0;
@@ -575,6 +584,8 @@ void pci_restore_msi_state(struct pci_dev *dev)
 int pci_save_msix_state(struct pci_dev *dev)
 {
        int pos;
+       int temp;
+       int vector, head, tail = 0;
        u16 control;
        struct pci_cap_saved_state *save_state;
 
@@ -582,6 +593,7 @@ int pci_save_msix_state(struct pci_dev *dev)
        if (pos <= 0 || dev->no_msi)
                return 0;
 
+       /* save the capability */
        pci_read_config_word(dev, msi_control_reg(pos), &control);
        if (!(control & PCI_MSIX_FLAGS_ENABLE))
                return 0;
@@ -593,7 +605,38 @@ int pci_save_msix_state(struct pci_dev *dev)
        }
        *((u16 *)&save_state->data[0]) = control;
 
-       disable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
+       /* save the table */
+       temp = dev->irq;
+       if (msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+               kfree(save_state);
+               return -EINVAL;
+       }
+
+       vector = head = dev->irq;
+       while (head != tail) {
+               int j;
+               void __iomem *base;
+               struct msi_desc *entry;
+
+               entry = msi_desc[vector];
+               base = entry->mask_base;
+               j = entry->msi_attrib.entry_nr;
+
+               entry->address_lo_save =
+                       readl(base + j * PCI_MSIX_ENTRY_SIZE +
+                             PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
+               entry->address_hi_save =
+                       readl(base + j * PCI_MSIX_ENTRY_SIZE +
+                             PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
+               entry->data_save =
+                       readl(base + j * PCI_MSIX_ENTRY_SIZE +
+                             PCI_MSIX_ENTRY_DATA_OFFSET);
+
+               tail = msi_desc[vector]->link.tail;
+               vector = tail;
+       }
+       dev->irq = temp;
+
        save_state->cap_nr = PCI_CAP_ID_MSIX;
        pci_add_saved_cap(dev, save_state);
        return 0;
@@ -606,8 +649,6 @@ void pci_restore_msix_state(struct pci_dev *dev)
        int vector, head, tail = 0;
        void __iomem *base;
        int j;
-       struct msg_address address;
-       struct msg_data data;
        struct msi_desc *entry;
        int temp;
        struct pci_cap_saved_state *save_state;
@@ -633,20 +674,13 @@ void pci_restore_msix_state(struct pci_dev *dev)
                base = entry->mask_base;
                j = entry->msi_attrib.entry_nr;
 
-               msi_address_init(&address);
-               msi_data_init(&data, vector);
-
-               address.lo_address.value &= MSI_ADDRESS_DEST_ID_MASK;
-               address.lo_address.value |= entry->msi_attrib.current_cpu <<
-                                       MSI_TARGET_CPU_SHIFT;
-
-               writel(address.lo_address.value,
+               writel(entry->address_lo_save,
                        base + j * PCI_MSIX_ENTRY_SIZE +
                        PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-               writel(address.hi_address,
+               writel(entry->address_hi_save,
                        base + j * PCI_MSIX_ENTRY_SIZE +
                        PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-               writel(*(u32*)&data,
+               writel(entry->data_save,
                        base + j * PCI_MSIX_ENTRY_SIZE +
                        PCI_MSIX_ENTRY_DATA_OFFSET);
 
@@ -660,30 +694,32 @@ void pci_restore_msix_state(struct pci_dev *dev)
 }
 #endif
 
-static void msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
+static int msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
 {
-       struct msg_address address;
-       struct msg_data data;
+       int status;
+       u32 address_hi;
+       u32 address_lo;
+       u32 data;
        int pos, vector = dev->irq;
        u16 control;
 
        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
        pci_read_config_word(dev, msi_control_reg(pos), &control);
+
        /* Configure MSI capability structure */
-       msi_address_init(&address);
-       msi_data_init(&data, vector);
-       entry->msi_attrib.current_cpu = ((address.lo_address.u.dest_id >>
-                               MSI_TARGET_CPU_SHIFT) & MSI_TARGET_CPU_MASK);
-       pci_write_config_dword(dev, msi_lower_address_reg(pos),
-                       address.lo_address.value);
+       status = msi_ops->setup(dev, vector, &address_hi, &address_lo, &data);
+       if (status < 0)
+               return status;
+
+       pci_write_config_dword(dev, msi_lower_address_reg(pos), address_lo);
        if (is_64bit_address(control)) {
                pci_write_config_dword(dev,
-                       msi_upper_address_reg(pos), address.hi_address);
+                       msi_upper_address_reg(pos), address_hi);
                pci_write_config_word(dev,
-                       msi_data_reg(pos, 1), *((u32*)&data));
+                       msi_data_reg(pos, 1), data);
        } else
                pci_write_config_word(dev,
-                       msi_data_reg(pos, 0), *((u32*)&data));
+                       msi_data_reg(pos, 0), data);
        if (entry->msi_attrib.maskbit) {
                unsigned int maskbits, temp;
                /* All MSIs are unmasked by default, Mask them all */
@@ -697,6 +733,8 @@ static void msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
                        msi_mask_bits_reg(pos, is_64bit_address(control)),
                        maskbits);
        }
+
+       return 0;
 }
 
 /**
@@ -710,6 +748,7 @@ static void msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
  **/
 static int msi_capability_init(struct pci_dev *dev)
 {
+       int status;
        struct msi_desc *entry;
        int pos, vector;
        u16 control;
@@ -742,7 +781,12 @@ static int msi_capability_init(struct pci_dev *dev)
        /* Replace with MSI handler */
        irq_handler_init(PCI_CAP_ID_MSI, vector, entry->msi_attrib.maskbit);
        /* Configure MSI capability structure */
-       msi_register_init(dev, entry);
+       status = msi_register_init(dev, entry);
+       if (status != 0) {
+               dev->irq = entry->msi_attrib.default_vector;
+               kmem_cache_free(msi_cachep, entry);
+               return status;
+       }
 
        attach_msi_entry(entry, vector);
        /* Set MSI enabled bits  */
@@ -765,8 +809,10 @@ static int msix_capability_init(struct pci_dev *dev,
                                struct msix_entry *entries, int nvec)
 {
        struct msi_desc *head = NULL, *tail = NULL, *entry = NULL;
-       struct msg_address address;
-       struct msg_data data;
+       u32 address_hi;
+       u32 address_lo;
+       u32 data;
+       int status;
        int vector, pos, i, j, nr_entries, temp = 0;
        unsigned long phys_addr;
        u32 table_offset;
@@ -822,18 +868,20 @@ static int msix_capability_init(struct pci_dev *dev,
                /* Replace with MSI-X handler */
                irq_handler_init(PCI_CAP_ID_MSIX, vector, 1);
                /* Configure MSI-X capability structure */
-               msi_address_init(&address);
-               msi_data_init(&data, vector);
-               entry->msi_attrib.current_cpu =
-                       ((address.lo_address.u.dest_id >>
-                       MSI_TARGET_CPU_SHIFT) & MSI_TARGET_CPU_MASK);
-               writel(address.lo_address.value,
+               status = msi_ops->setup(dev, vector,
+                                       &address_hi,
+                                       &address_lo,
+                                       &data);
+               if (status < 0)
+                       break;
+
+               writel(address_lo,
                        base + j * PCI_MSIX_ENTRY_SIZE +
                        PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-               writel(address.hi_address,
+               writel(address_hi,
                        base + j * PCI_MSIX_ENTRY_SIZE +
                        PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-               writel(*(u32*)&data,
+               writel(data,
                        base + j * PCI_MSIX_ENTRY_SIZE +
                        PCI_MSIX_ENTRY_DATA_OFFSET);
                attach_msi_entry(entry, vector);
@@ -865,6 +913,7 @@ static int msix_capability_init(struct pci_dev *dev,
  **/
 int pci_enable_msi(struct pci_dev* dev)
 {
+       struct pci_bus *bus;
        int pos, temp, status = -EINVAL;
        u16 control;
 
@@ -874,8 +923,9 @@ int pci_enable_msi(struct pci_dev* dev)
        if (dev->no_msi)
                return status;
 
-       if (dev->bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
-               return -EINVAL;
+       for (bus = dev->bus; bus; bus = bus->parent)
+               if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
+                       return -EINVAL;
 
        temp = dev->irq;
 
@@ -887,23 +937,23 @@ int pci_enable_msi(struct pci_dev* dev)
        if (!pos)
                return -EINVAL;
 
-       pci_read_config_word(dev, msi_control_reg(pos), &control);
-       if (control & PCI_MSI_FLAGS_ENABLE)
-               return 0;                       /* Already in MSI mode */
-
        if (!msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
                /* Lookup Sucess */
                unsigned long flags;
 
+               pci_read_config_word(dev, msi_control_reg(pos), &control);
+               if (control & PCI_MSI_FLAGS_ENABLE)
+                       return 0;       /* Already in MSI mode */
                spin_lock_irqsave(&msi_lock, flags);
                if (!vector_irq[dev->irq]) {
                        msi_desc[dev->irq]->msi_attrib.state = 0;
                        vector_irq[dev->irq] = -1;
                        nr_released_vectors--;
                        spin_unlock_irqrestore(&msi_lock, flags);
-                       msi_register_init(dev, msi_desc[dev->irq]);
-                       enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
-                       return 0;
+                       status = msi_register_init(dev, msi_desc[dev->irq]);
+                       if (status == 0)
+                               enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
+                       return status;
                }
                spin_unlock_irqrestore(&msi_lock, flags);
                dev->irq = temp;
@@ -980,6 +1030,8 @@ static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
        void __iomem *base;
        unsigned long flags;
 
+       msi_ops->teardown(vector);
+
        spin_lock_irqsave(&msi_lock, flags);
        entry = msi_desc[vector];
        if (!entry || entry->dev != dev) {
@@ -1008,33 +1060,8 @@ static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
                                entry_nr * PCI_MSIX_ENTRY_SIZE +
                                PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
 
-               if (head == vector) {
-                       /*
-                        * Detect last MSI-X vector to be released.
-                        * Release the MSI-X memory-mapped table.
-                        */
-#if 0
-                       int pos, nr_entries;
-                       unsigned long phys_addr;
-                       u32 table_offset;
-                       u16 control;
-                       u8 bir;
-
-                       pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
-                       pci_read_config_word(dev, msi_control_reg(pos),
-                               &control);
-                       nr_entries = multi_msix_capable(control);
-                       pci_read_config_dword(dev, msix_table_offset_reg(pos),
-                               &table_offset);
-                       bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-                       table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
-                       phys_addr = pci_resource_start(dev, bir) + table_offset;
-/*
- * FIXME!  and what did you want to do with phys_addr?
- */
-#endif
+               if (head == vector)
                        iounmap(base);
-               }
        }
 
        return 0;
@@ -1108,6 +1135,7 @@ static int reroute_msix_table(int head, struct msix_entry *entries, int *nvec)
  **/
 int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
 {
+       struct pci_bus *bus;
        int status, pos, nr_entries, free_vectors;
        int i, j, temp;
        u16 control;
@@ -1116,6 +1144,13 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
        if (!pci_msi_enable || !dev || !entries)
                return -EINVAL;
 
+       if (dev->no_msi)
+               return -EINVAL;
+
+       for (bus = dev->bus; bus; bus = bus->parent)
+               if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
+                       return -EINVAL;
+
        status = msi_init();
        if (status < 0)
                return status;
@@ -1300,24 +1335,6 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
                }
                msi_free_vector(dev, vector, 0);
                if (warning) {
-                       /* Force to release the MSI-X memory-mapped table */
-#if 0
-                       unsigned long phys_addr;
-                       u32 table_offset;
-                       u16 control;
-                       u8 bir;
-
-                       pci_read_config_word(dev, msi_control_reg(pos),
-                               &control);
-                       pci_read_config_dword(dev, msix_table_offset_reg(pos),
-                               &table_offset);
-                       bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-                       table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
-                       phys_addr = pci_resource_start(dev, bir) + table_offset;
-/*
- * FIXME! and what did you want to do with phys_addr?
- */
-#endif
                        iounmap(base);
                        printk(KERN_WARNING "PCI: %s: msi_remove_pci_irq_vectors() "
                               "called without free_irq() on all MSI-X vectors\n",
index 4ac52d441e472d86e9e15e0f48d761e6a3c51223..56951c39d3a3e8c8d6656f2b2a2f1ac49321f475 100644 (file)
@@ -6,6 +6,68 @@
 #ifndef MSI_H
 #define MSI_H
 
+/*
+ * MSI operation vector.  Used by the msi core code (drivers/pci/msi.c)
+ * to abstract platform-specific tasks relating to MSI address generation
+ * and resource management.
+ */
+struct msi_ops {
+       /**
+        * setup - generate an MSI bus address and data for a given vector
+        * @pdev: PCI device context (in)
+        * @vector: vector allocated by the msi core (in)
+        * @addr_hi: upper 32 bits of PCI bus MSI address (out)
+        * @addr_lo: lower 32 bits of PCI bus MSI address (out)
+        * @data: MSI data payload (out)
+        *
+        * Description: The setup op is used to generate a PCI bus addres and
+        * data which the msi core will program into the card MSI capability
+        * registers.  The setup routine is responsible for picking an initial
+        * cpu to target the MSI at.  The setup routine is responsible for
+        * examining pdev to determine the MSI capabilities of the card and
+        * generating a suitable address/data.  The setup routine is
+        * responsible for allocating and tracking any system resources it
+        * needs to route the MSI to the cpu it picks, and for associating
+        * those resources with the passed in vector.
+        *
+        * Returns 0 if the MSI address/data was successfully setup.
+        **/
+
+       int     (*setup)    (struct pci_dev *pdev, unsigned int vector,
+                            u32 *addr_hi, u32 *addr_lo, u32 *data);
+
+       /**
+        * teardown - release resources allocated by setup
+        * @vector: vector context for resources (in)
+        *
+        * Description:  The teardown op is used to release any resources
+        * that were allocated in the setup routine associated with the passed
+        * in vector.
+        **/
+
+       void    (*teardown) (unsigned int vector);
+
+       /**
+        * target - retarget an MSI at a different cpu
+        * @vector: vector context for resources (in)
+        * @cpu:  new cpu to direct vector at (in)
+        * @addr_hi: new value of PCI bus upper 32 bits (in/out)
+        * @addr_lo: new value of PCI bus lower 32 bits (in/out)
+        *
+        * Description:  The target op is used to redirect an MSI vector
+        * at a different cpu.  addr_hi/addr_lo coming in are the existing
+        * values that the MSI core has programmed into the card.  The
+        * target code is responsible for freeing any resources (if any)
+        * associated with the old address, and generating a new PCI bus
+        * addr_hi/addr_lo that will redirect the vector at the indicated cpu.
+        **/
+
+       void    (*target)   (unsigned int vector, unsigned int cpu,
+                            u32 *addr_hi, u32 *addr_lo);
+};
+
+extern int msi_register(struct msi_ops *ops);
+
 #include <asm/msi.h>
 
 /*
@@ -63,67 +125,6 @@ extern int pci_vector_resources(int last, int nr_released);
 #define msix_mask(address)             (address | PCI_MSIX_FLAGS_BITMASK)
 #define msix_is_pending(address)       (address & PCI_MSIX_FLAGS_PENDMASK)
 
-/*
- * MSI Defined Data Structures
- */
-#define MSI_ADDRESS_HEADER             0xfee
-#define MSI_ADDRESS_HEADER_SHIFT       12
-#define MSI_ADDRESS_HEADER_MASK                0xfff000
-#define MSI_ADDRESS_DEST_ID_MASK       0xfff0000f
-#define MSI_TARGET_CPU_MASK            0xff
-#define MSI_DELIVERY_MODE              0
-#define MSI_LEVEL_MODE                 1       /* Edge always assert */
-#define MSI_TRIGGER_MODE               0       /* MSI is edge sensitive */
-#define MSI_PHYSICAL_MODE              0
-#define MSI_LOGICAL_MODE               1
-#define MSI_REDIRECTION_HINT_MODE      0
-
-struct msg_data {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-       __u32   vector          :  8;
-       __u32   delivery_mode   :  3;   /* 000b: FIXED | 001b: lowest prior */
-       __u32   reserved_1      :  3;
-       __u32   level           :  1;   /* 0: deassert | 1: assert */
-       __u32   trigger         :  1;   /* 0: edge | 1: level */
-       __u32   reserved_2      : 16;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-       __u32   reserved_2      : 16;
-       __u32   trigger         :  1;   /* 0: edge | 1: level */
-       __u32   level           :  1;   /* 0: deassert | 1: assert */
-       __u32   reserved_1      :  3;
-       __u32   delivery_mode   :  3;   /* 000b: FIXED | 001b: lowest prior */
-       __u32   vector          :  8;
-#else
-#error "Bitfield endianness not defined! Check your byteorder.h"
-#endif
-} __attribute__ ((packed));
-
-struct msg_address {
-       union {
-               struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                       __u32   reserved_1      :  2;
-                       __u32   dest_mode       :  1;   /*0:physic | 1:logic */
-                       __u32   redirection_hint:  1;   /*0: dedicated CPU
-                                                         1: lowest priority */
-                       __u32   reserved_2      :  4;
-                       __u32   dest_id         : 24;   /* Destination ID */
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                       __u32   dest_id         : 24;   /* Destination ID */
-                       __u32   reserved_2      :  4;
-                       __u32   redirection_hint:  1;   /*0: dedicated CPU
-                                                         1: lowest priority */
-                       __u32   dest_mode       :  1;   /*0:physic | 1:logic */
-                       __u32   reserved_1      :  2;
-#else
-#error "Bitfield endianness not defined! Check your byteorder.h"
-#endif
-               }u;
-                       __u32  value;
-       }lo_address;
-       __u32   hi_address;
-} __attribute__ ((packed));
-
 struct msi_desc {
        struct {
                __u8    type    : 5;    /* {0: unused, 5h:MSI, 11h:MSI-X} */
@@ -132,7 +133,7 @@ struct msi_desc {
                __u8    reserved: 1;    /* reserved                       */
                __u8    entry_nr;       /* specific enabled entry         */
                __u8    default_vector; /* default pre-assigned vector    */
-               __u8    current_cpu;    /* current destination cpu        */
+               __u8    unused;         /* formerly unused destination cpu*/
        }msi_attrib;
 
        struct {
@@ -142,6 +143,14 @@ struct msi_desc {
 
        void __iomem *mask_base;
        struct pci_dev *dev;
+
+#ifdef CONFIG_PM
+       /* PM save area for MSIX address/data */
+
+       u32     address_hi_save;
+       u32     address_lo_save;
+       u32     data_save;
+#endif
 };
 
 #endif /* MSI_H */
index c2ecae5ff0c17623917f0b365d7fd9e278be90a2..bb7456c1dbac54755db25a939904169bd37d4d04 100644 (file)
@@ -267,7 +267,7 @@ static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 
 
 /* ACPI bus type */
-static int pci_acpi_find_device(struct device *dev, acpi_handle *handle)
+static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
 {
        struct pci_dev * pci_dev;
        acpi_integer    addr;
@@ -281,7 +281,7 @@ static int pci_acpi_find_device(struct device *dev, acpi_handle *handle)
        return 0;
 }
 
-static int pci_acpi_find_root_bridge(struct device *dev, acpi_handle *handle)
+static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
 {
        int num;
        unsigned int seg, bus;
@@ -299,21 +299,21 @@ static int pci_acpi_find_root_bridge(struct device *dev, acpi_handle *handle)
        return 0;
 }
 
-static struct acpi_bus_type pci_acpi_bus = {
+static struct acpi_bus_type acpi_pci_bus = {
        .bus = &pci_bus_type,
-       .find_device = pci_acpi_find_device,
-       .find_bridge = pci_acpi_find_root_bridge,
+       .find_device = acpi_pci_find_device,
+       .find_bridge = acpi_pci_find_root_bridge,
 };
 
-static int __init pci_acpi_init(void)
+static int __init acpi_pci_init(void)
 {
        int ret;
 
-       ret = register_acpi_bus_type(&pci_acpi_bus);
+       ret = register_acpi_bus_type(&acpi_pci_bus);
        if (ret)
                return 0;
        platform_pci_choose_state = acpi_pci_choose_state;
        platform_pci_set_power_state = acpi_pci_set_power_state;
        return 0;
 }
-arch_initcall(pci_acpi_init);
+arch_initcall(acpi_pci_init);
index 56ac2bc003c7fdae7ab2fe47d00b7a1e2670229a..bc405c035ce34b4ae00d54a61286782e31416125 100644 (file)
@@ -43,6 +43,29 @@ pci_config_attr(subsystem_vendor, "0x%04x\n");
 pci_config_attr(subsystem_device, "0x%04x\n");
 pci_config_attr(class, "0x%06x\n");
 pci_config_attr(irq, "%u\n");
+pci_config_attr(is_enabled, "%u\n");
+
+static ssize_t broken_parity_status_show(struct device *dev,
+                                        struct device_attribute *attr,
+                                        char *buf)
+{
+       struct pci_dev *pdev = to_pci_dev(dev);
+       return sprintf (buf, "%u\n", pdev->broken_parity_status);
+}
+
+static ssize_t broken_parity_status_store(struct device *dev,
+                                         struct device_attribute *attr,
+                                         const char *buf, size_t count)
+{
+       struct pci_dev *pdev = to_pci_dev(dev);
+       ssize_t consumed = -EINVAL;
+
+       if ((count > 0) && (*buf == '0' || *buf == '1')) {
+               pdev->broken_parity_status = *buf == '1' ? 1 : 0;
+               consumed = count;
+       }
+       return consumed;
+}
 
 static ssize_t local_cpus_show(struct device *dev,
                        struct device_attribute *attr, char *buf)
@@ -90,6 +113,25 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
                       (u8)(pci_dev->class >> 16), (u8)(pci_dev->class >> 8),
                       (u8)(pci_dev->class));
 }
+static ssize_t
+is_enabled_store(struct device *dev, struct device_attribute *attr,
+               const char *buf, size_t count)
+{
+       struct pci_dev *pdev = to_pci_dev(dev);
+
+       /* this can crash the machine when done on the "wrong" device */
+       if (!capable(CAP_SYS_ADMIN))
+               return count;
+
+       if (*buf == '0')
+               pci_disable_device(pdev);
+
+       if (*buf == '1')
+               pci_enable_device(pdev);
+
+       return count;
+}
+
 
 struct device_attribute pci_dev_attrs[] = {
        __ATTR_RO(resource),
@@ -101,6 +143,9 @@ struct device_attribute pci_dev_attrs[] = {
        __ATTR_RO(irq),
        __ATTR_RO(local_cpus),
        __ATTR_RO(modalias),
+       __ATTR(enable, 0600, is_enabled_show, is_enabled_store),
+       __ATTR(broken_parity_status,(S_IRUGO|S_IWUSR),
+               broken_parity_status_show,broken_parity_status_store),
        __ATTR_NULL,
 };
 
index fde41cc147344d3faf1bca11078dc951062e01be..d408a3c3042649268922b9383005cff6a111f2b9 100644 (file)
@@ -517,7 +517,12 @@ pci_enable_device_bars(struct pci_dev *dev, int bars)
 int
 pci_enable_device(struct pci_dev *dev)
 {
-       int err = pci_enable_device_bars(dev, (1 << PCI_NUM_RESOURCES) - 1);
+       int err;
+
+       if (dev->is_enabled)
+               return 0;
+
+       err = pci_enable_device_bars(dev, (1 << PCI_NUM_RESOURCES) - 1);
        if (err)
                return err;
        pci_fixup_device(pci_fixup_enable, dev);
@@ -546,7 +551,14 @@ void
 pci_disable_device(struct pci_dev *dev)
 {
        u16 pci_command;
-       
+
+       if (dev->msi_enabled)
+               disable_msi_mode(dev, pci_find_capability(dev, PCI_CAP_ID_MSI),
+                       PCI_CAP_ID_MSI);
+       if (dev->msix_enabled)
+               disable_msi_mode(dev, pci_find_capability(dev, PCI_CAP_ID_MSI),
+                       PCI_CAP_ID_MSIX);
+
        pci_read_config_word(dev, PCI_COMMAND, &pci_command);
        if (pci_command & PCI_COMMAND_MASTER) {
                pci_command &= ~PCI_COMMAND_MASTER;
index 30630cbe2fe32c1d65465186b15ad8d083a031ff..29bdeca031a8b49c60c7de124eabc68022c3c3b2 100644 (file)
@@ -40,7 +40,7 @@ extern int pci_bus_find_capability (struct pci_bus *bus, unsigned int devfn, int
 extern void pci_remove_legacy_files(struct pci_bus *bus);
 
 /* Lock for read/write access to pci device and bus lists */
-extern spinlock_t pci_bus_lock;
+extern struct rw_semaphore pci_bus_sem;
 
 #ifdef CONFIG_X86_IO_APIC
 extern int pci_msi_quirk;
index a10ed9dab2c2d5a04327760de02e140c20ef6f2c..f89dbc3738b7d73f54142e12d598c5759fa368d7 100644 (file)
@@ -180,25 +180,31 @@ static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
                res->flags |= pci_calc_resource_flags(l);
                if ((l & (PCI_BASE_ADDRESS_SPACE | PCI_BASE_ADDRESS_MEM_TYPE_MASK))
                    == (PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64)) {
-                       pci_read_config_dword(dev, reg+4, &l);
+                       u32 szhi, lhi;
+                       pci_read_config_dword(dev, reg+4, &lhi);
+                       pci_write_config_dword(dev, reg+4, ~0);
+                       pci_read_config_dword(dev, reg+4, &szhi);
+                       pci_write_config_dword(dev, reg+4, lhi);
+                       szhi = pci_size(lhi, szhi, 0xffffffff);
                        next++;
 #if BITS_PER_LONG == 64
-                       res->start |= ((unsigned long) l) << 32;
+                       res->start |= ((unsigned long) lhi) << 32;
                        res->end = res->start + sz;
-                       pci_write_config_dword(dev, reg+4, ~0);
-                       pci_read_config_dword(dev, reg+4, &sz);
-                       pci_write_config_dword(dev, reg+4, l);
-                       sz = pci_size(l, sz, 0xffffffff);
-                       if (sz) {
+                       if (szhi) {
                                /* This BAR needs > 4GB?  Wow. */
-                               res->end |= (unsigned long)sz<<32;
+                               res->end |= (unsigned long)szhi<<32;
                        }
 #else
-                       if (l) {
-                               printk(KERN_ERR "PCI: Unable to handle 64-bit address for device %s\n", pci_name(dev));
+                       if (szhi) {
+                               printk(KERN_ERR "PCI: Unable to handle 64-bit BAR for device %s\n", pci_name(dev));
                                res->start = 0;
                                res->flags = 0;
-                               continue;
+                       } else if (lhi) {
+                               /* 64-bit wide address, treat as disabled */
+                               pci_write_config_dword(dev, reg, l & ~(u32)PCI_BASE_ADDRESS_MEM_MASK);
+                               pci_write_config_dword(dev, reg+4, 0);
+                               res->start = 0;
+                               res->end = sz;
                        }
 #endif
                }
@@ -377,9 +383,9 @@ struct pci_bus * __devinit pci_add_new_bus(struct pci_bus *parent, struct pci_de
 
        child = pci_alloc_child_bus(parent, dev, busnr);
        if (child) {
-               spin_lock(&pci_bus_lock);
+               down_write(&pci_bus_sem);
                list_add_tail(&child->node, &parent->children);
-               spin_unlock(&pci_bus_lock);
+               up_write(&pci_bus_sem);
        }
        return child;
 }
@@ -838,9 +844,9 @@ void __devinit pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
         * and the bus list for fixup functions, etc.
         */
        INIT_LIST_HEAD(&dev->global_list);
-       spin_lock(&pci_bus_lock);
+       down_write(&pci_bus_sem);
        list_add_tail(&dev->bus_list, &bus->devices);
-       spin_unlock(&pci_bus_lock);
+       up_write(&pci_bus_sem);
 }
 
 struct pci_dev * __devinit
@@ -975,9 +981,10 @@ struct pci_bus * __devinit pci_create_bus(struct device *parent,
                pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
                goto err_out;
        }
-       spin_lock(&pci_bus_lock);
+
+       down_write(&pci_bus_sem);
        list_add_tail(&b->node, &pci_root_buses);
-       spin_unlock(&pci_bus_lock);
+       up_write(&pci_bus_sem);
 
        memset(dev, 0, sizeof(*dev));
        dev->parent = parent;
@@ -1017,9 +1024,9 @@ class_dev_create_file_err:
 class_dev_reg_err:
        device_unregister(dev);
 dev_reg_err:
-       spin_lock(&pci_bus_lock);
+       down_write(&pci_bus_sem);
        list_del(&b->node);
-       spin_unlock(&pci_bus_lock);
+       up_write(&pci_bus_sem);
 err_out:
        kfree(dev);
        kfree(b);
index d378478612fb76d862b4b584aff1cc14b190f228..4364d793f73b06d8391a872ab22567b1bff41a3d 100644 (file)
 #include <linux/acpi.h>
 #include "pci.h"
 
+/* The Mellanox Tavor device gives false positive parity errors
+ * Mark this device with a broken_parity_status, to allow
+ * PCI scanning code to "skip" this now blacklisted device.
+ */
+static void __devinit quirk_mellanox_tavor(struct pci_dev *dev)
+{
+       dev->broken_parity_status = 1;  /* This device gives false positives */
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_MELLANOX,PCI_DEVICE_ID_MELLANOX_TAVOR,quirk_mellanox_tavor);
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_MELLANOX,PCI_DEVICE_ID_MELLANOX_TAVOR_BRIDGE,quirk_mellanox_tavor);
+
 /* Deal with broken BIOS'es that neglect to enable passive release,
    which can cause problems in combination with the 82441FX/PPro MTRRs */
 static void __devinit quirk_passive_release(struct pci_dev *dev)
@@ -878,27 +889,30 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82375,      quirk_e
  * when a PCI-Soundcard is added. The BIOS only gives Options
  * "Disabled" and "AUTO". This Quirk Sets the corresponding
  * Register-Value to enable the Soundcard.
+ *
+ * FIXME: Presently this quirk will run on anything that has an 8237
+ * which isn't correct, we need to check DMI tables or something in
+ * order to make sure it only runs on the MSI-K8T-Neo2Fir.  Because it
+ * runs everywhere at present we suppress the printk output in most
+ * irrelevant cases.
  */
 static void __init k8t_sound_hostbridge(struct pci_dev *dev)
 {
        unsigned char val;
 
-       printk(KERN_INFO "PCI: Quirk-MSI-K8T Soundcard On\n");
        pci_read_config_byte(dev, 0x50, &val);
        if (val == 0x88 || val == 0xc8) {
+               /* Assume it's probably a MSI-K8T-Neo2Fir */
+               printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, attempting to turn soundcard ON\n");
                pci_write_config_byte(dev, 0x50, val & (~0x40));
 
                /* Verify the Change for Status output */
                pci_read_config_byte(dev, 0x50, &val);
                if (val & 0x40)
-                       printk(KERN_INFO "PCI: MSI-K8T soundcard still off\n");
+                       printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, soundcard still off\n");
                else
-                       printk(KERN_INFO "PCI: MSI-K8T soundcard on\n");
-       } else {
-               printk(KERN_INFO "PCI: Unexpected Value in PCI-Register: "
-                                       "no Change!\n");
+                       printk(KERN_INFO "PCI: MSI-K8T-Neo2Fir, soundcard on\n");
        }
-
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237, k8t_sound_hostbridge);
 
@@ -1485,6 +1499,25 @@ static void __devinit quirk_p64h2_1k_io(struct pci_dev *dev)
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,  0x1460,         quirk_p64h2_1k_io);
 
+/* Under some circumstances, AER is not linked with extended capabilities.
+ * Force it to be linked by setting the corresponding control bit in the
+ * config space.
+ */
+static void __devinit quirk_nvidia_ck804_pcie_aer_ext_cap(struct pci_dev *dev)
+{
+       uint8_t b;
+       if (pci_read_config_byte(dev, 0xf41, &b) == 0) {
+               if (!(b & 0x20)) {
+                       pci_write_config_byte(dev, 0xf41, b | 0x20);
+                       printk(KERN_INFO
+                              "PCI: Linking AER extended capability on %s\n",
+                              pci_name(dev));
+               }
+       }
+}
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_NVIDIA,  PCI_DEVICE_ID_NVIDIA_CK804_PCIE,
+                       quirk_nvidia_ck804_pcie_aer_ext_cap);
+
 EXPORT_SYMBOL(pcie_mch_quirk);
 #ifdef CONFIG_HOTPLUG
 EXPORT_SYMBOL(pci_fixup_device);
index 1a6bf9de166fa343ff6123e10b9aecc54b106590..99ffbd478b29c5ffd74d4593ddab6625b2b7fc9d 100644 (file)
@@ -22,18 +22,18 @@ static void pci_destroy_dev(struct pci_dev *dev)
                pci_proc_detach_device(dev);
                pci_remove_sysfs_dev_files(dev);
                device_unregister(&dev->dev);
-               spin_lock(&pci_bus_lock);
+               down_write(&pci_bus_sem);
                list_del(&dev->global_list);
                dev->global_list.next = dev->global_list.prev = NULL;
-               spin_unlock(&pci_bus_lock);
+               up_write(&pci_bus_sem);
        }
 
        /* Remove the device from the device lists, and prevent any further
         * list accesses from this device */
-       spin_lock(&pci_bus_lock);
+       down_write(&pci_bus_sem);
        list_del(&dev->bus_list);
        dev->bus_list.next = dev->bus_list.prev = NULL;
-       spin_unlock(&pci_bus_lock);
+       up_write(&pci_bus_sem);
 
        pci_free_resources(dev);
        pci_dev_put(dev);
@@ -62,9 +62,9 @@ void pci_remove_bus(struct pci_bus *pci_bus)
 {
        pci_proc_detach_bus(pci_bus);
 
-       spin_lock(&pci_bus_lock);
+       down_write(&pci_bus_sem);
        list_del(&pci_bus->node);
-       spin_unlock(&pci_bus_lock);
+       up_write(&pci_bus_sem);
        pci_remove_legacy_files(pci_bus);
        class_device_remove_file(&pci_bus->class_dev,
                &class_device_attr_cpuaffinity);
index ce7dd6e7be604f733fa40d93512921c938dc4509..622b3f8ba820d25e9f6bbcf1b1d83eb9eb60a765 100644 (file)
@@ -13,7 +13,7 @@
 #include <linux/interrupt.h>
 #include "pci.h"
 
-DEFINE_SPINLOCK(pci_bus_lock);
+DECLARE_RWSEM(pci_bus_sem);
 
 static struct pci_bus * __devinit
 pci_do_find_bus(struct pci_bus* bus, unsigned char busnr)
@@ -72,11 +72,11 @@ pci_find_next_bus(const struct pci_bus *from)
        struct pci_bus *b = NULL;
 
        WARN_ON(in_interrupt());
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
        n = from ? from->node.next : pci_root_buses.next;
        if (n != &pci_root_buses)
                b = pci_bus_b(n);
-       spin_unlock(&pci_bus_lock);
+       up_read(&pci_bus_sem);
        return b;
 }
 
@@ -124,7 +124,7 @@ struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn)
        struct pci_dev *dev;
 
        WARN_ON(in_interrupt());
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
 
        list_for_each(tmp, &bus->devices) {
                dev = pci_dev_b(tmp);
@@ -135,7 +135,7 @@ struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn)
        dev = NULL;
  out:
        pci_dev_get(dev);
-       spin_unlock(&pci_bus_lock);
+       up_read(&pci_bus_sem);
        return dev;
 }
 
@@ -167,7 +167,7 @@ static struct pci_dev * pci_find_subsys(unsigned int vendor,
        struct pci_dev *dev;
 
        WARN_ON(in_interrupt());
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
        n = from ? from->global_list.next : pci_devices.next;
 
        while (n && (n != &pci_devices)) {
@@ -181,7 +181,7 @@ static struct pci_dev * pci_find_subsys(unsigned int vendor,
        }
        dev = NULL;
 exit:
-       spin_unlock(&pci_bus_lock);
+       up_read(&pci_bus_sem);
        return dev;
 }
 
@@ -232,7 +232,7 @@ pci_get_subsys(unsigned int vendor, unsigned int device,
        struct pci_dev *dev;
 
        WARN_ON(in_interrupt());
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
        n = from ? from->global_list.next : pci_devices.next;
 
        while (n && (n != &pci_devices)) {
@@ -247,7 +247,7 @@ pci_get_subsys(unsigned int vendor, unsigned int device,
        dev = NULL;
 exit:
        dev = pci_dev_get(dev);
-       spin_unlock(&pci_bus_lock);
+       up_read(&pci_bus_sem);
        pci_dev_put(from);
        return dev;
 }
@@ -292,7 +292,7 @@ pci_find_device_reverse(unsigned int vendor, unsigned int device, const struct p
        struct pci_dev *dev;
 
        WARN_ON(in_interrupt());
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
        n = from ? from->global_list.prev : pci_devices.prev;
 
        while (n && (n != &pci_devices)) {
@@ -304,7 +304,7 @@ pci_find_device_reverse(unsigned int vendor, unsigned int device, const struct p
        }
        dev = NULL;
 exit:
-       spin_unlock(&pci_bus_lock);
+       up_read(&pci_bus_sem);
        return dev;
 }
 
@@ -328,7 +328,7 @@ struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
        struct pci_dev *dev;
 
        WARN_ON(in_interrupt());
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
        n = from ? from->global_list.next : pci_devices.next;
 
        while (n && (n != &pci_devices)) {
@@ -340,7 +340,7 @@ struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
        dev = NULL;
 exit:
        dev = pci_dev_get(dev);
-       spin_unlock(&pci_bus_lock);
+       up_read(&pci_bus_sem);
        pci_dev_put(from);
        return dev;
 }
@@ -362,7 +362,7 @@ int pci_dev_present(const struct pci_device_id *ids)
        int found = 0;
 
        WARN_ON(in_interrupt());
-       spin_lock(&pci_bus_lock);
+       down_read(&pci_bus_sem);
        while (ids->vendor || ids->subvendor || ids->class_mask) {
                list_for_each_entry(dev, &pci_devices, global_list) {
                        if (pci_match_one_device(ids, dev)) {
@@ -372,8 +372,8 @@ int pci_dev_present(const struct pci_device_id *ids)
                }
                ids++;
        }
-exit:                          
-       spin_unlock(&pci_bus_lock);
+exit:
+       up_read(&pci_bus_sem);
        return found;
 }
 EXPORT_SYMBOL(pci_dev_present);
index 28ce3a7ee43450db799dd4bd7a007bcd2d7942ad..35086e80faa91a9db5ea225b5166d29f1b88e1b4 100644 (file)
@@ -55,9 +55,10 @@ pbus_assign_resources_sorted(struct pci_bus *bus)
        list_for_each_entry(dev, &bus->devices, bus_list) {
                u16 class = dev->class >> 8;
 
-               /* Don't touch classless devices and host bridges.  */
+               /* Don't touch classless devices or host bridges or ioapics.  */
                if (class == PCI_CLASS_NOT_DEFINED ||
-                   class == PCI_CLASS_BRIDGE_HOST)
+                   class == PCI_CLASS_BRIDGE_HOST ||
+                   class == PCI_CLASS_SYSTEM_PIC)
                        continue;
 
                pdev_sort_resources(dev, &head);
index ea9277b7f8994120aed0b3d058da25de31e99c57..577f4b55c46d6e37f52b5f67654ac94ecf73b0ab 100644 (file)
@@ -155,6 +155,46 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
        return ret;
 }
 
+#ifdef CONFIG_EMBEDDED
+int pci_assign_resource_fixed(struct pci_dev *dev, int resno)
+{
+       struct pci_bus *bus = dev->bus;
+       struct resource *res = dev->resource + resno;
+       unsigned int type_mask;
+       int i, ret = -EBUSY;
+
+       type_mask = IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH;
+
+       for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
+               struct resource *r = bus->resource[i];
+               if (!r)
+                       continue;
+
+               /* type_mask must match */
+               if ((res->flags ^ r->flags) & type_mask)
+                       continue;
+
+               ret = request_resource(r, res);
+
+               if (ret == 0)
+                       break;
+       }
+
+       if (ret) {
+               printk(KERN_ERR "PCI: Failed to allocate %s resource "
+                               "#%d:%llx@%llx for %s\n",
+                       res->flags & IORESOURCE_IO ? "I/O" : "mem",
+                       resno, (unsigned long long)(res->end - res->start + 1),
+                       (unsigned long long)res->start, pci_name(dev));
+       } else if (resno < PCI_BRIDGE_RESOURCES) {
+               pci_update_resource(dev, res, resno);
+       }
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(pci_assign_resource_fixed);
+#endif
+
 /* Sort resources by alignment */
 void __devinit
 pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
index 77bb2351500c47045012f2f31192ce50b15ec23e..680f6063954b2a94a3246266a68bdd830fa1fe96 100644 (file)
 #include "ql1280_fw.h"
 #include "ql1040_fw.h"
 
-
-/*
- * Missing PCI ID's
- */
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP1080
-#define PCI_DEVICE_ID_QLOGIC_ISP1080   0x1080
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP1240
-#define PCI_DEVICE_ID_QLOGIC_ISP1240   0x1240
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP1280
-#define PCI_DEVICE_ID_QLOGIC_ISP1280   0x1280
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP10160
-#define PCI_DEVICE_ID_QLOGIC_ISP10160  0x1016
-#endif
-#ifndef PCI_DEVICE_ID_QLOGIC_ISP12160
-#define PCI_DEVICE_ID_QLOGIC_ISP12160  0x1216
-#endif
-
-#ifndef PCI_VENDOR_ID_AMI
-#define PCI_VENDOR_ID_AMI               0x101e
-#endif
-
 #ifndef BITS_PER_LONG
 #error "BITS_PER_LONG not defined!"
 #endif
index 8a29ce340b472019b914e32ebfbebaa7f9463dc9..27d658704cf907224ecd42c43374d6f9bb9878f0 100644 (file)
@@ -433,13 +433,14 @@ err_out:
 
 
 /*
- * 0x1725/0x7174 is the Vitesse VSC-7174
- * 0x8086/0x3200 is the Intel 31244, which is supposed to be identical
- * compatibility is untested as of yet
+ * Intel 31244 is supposed to be identical.
+ * Compatibility is untested as of yet.
  */
 static const struct pci_device_id vsc_sata_pci_tbl[] = {
-       { 0x1725, 0x7174, PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
-       { 0x8086, 0x3200, PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
+       { PCI_VENDOR_ID_VITESSE, PCI_DEVICE_ID_VITESSE_VSC7174,
+         PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
+       { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_GD31244,
+         PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
        { }
 };
 
index 989e4d49e5bbea32cf2b04c3e85c815ad8e3c436..7f939d066a5a40151e3e35ab4316d6abe06e25b0 100644 (file)
@@ -313,8 +313,8 @@ static const char __init *mdacon_startup(void)
        mda_num_columns = 80;
        mda_num_lines   = 25;
 
-       mda_vram_base = VGA_MAP_MEM(0xb0000);
        mda_vram_len  = 0x01000;
+       mda_vram_base = VGA_MAP_MEM(0xb0000, mda_vram_len);
 
        mda_index_port  = 0x3b4;
        mda_value_port  = 0x3b5;
index d5a04b68c4d49bf8101f6c9c0b31ec8fa065fffa..e64d42e2449e4dd5ac104042000d0fe005ce09ca 100644 (file)
@@ -391,7 +391,7 @@ static const char __init *vgacon_startup(void)
                        static struct resource ega_console_resource =
                            { "ega", 0x3B0, 0x3BF };
                        vga_video_type = VIDEO_TYPE_EGAM;
-                       vga_vram_end = 0xb8000;
+                       vga_vram_size = 0x8000;
                        display_desc = "EGA+";
                        request_resource(&ioport_resource,
                                         &ega_console_resource);
@@ -401,7 +401,7 @@ static const char __init *vgacon_startup(void)
                        static struct resource mda2_console_resource =
                            { "mda", 0x3BF, 0x3BF };
                        vga_video_type = VIDEO_TYPE_MDA;
-                       vga_vram_end = 0xb2000;
+                       vga_vram_size = 0x2000;
                        display_desc = "*MDA";
                        request_resource(&ioport_resource,
                                         &mda1_console_resource);
@@ -418,7 +418,7 @@ static const char __init *vgacon_startup(void)
                if ((ORIG_VIDEO_EGA_BX & 0xff) != 0x10) {
                        int i;
 
-                       vga_vram_end = 0xc0000;
+                       vga_vram_size = 0x8000;
 
                        if (!ORIG_VIDEO_ISVGA) {
                                static struct resource ega_console_resource
@@ -443,7 +443,7 @@ static const char __init *vgacon_startup(void)
                                 * and COE=1 isn't necessarily a good idea)
                                 */
                                vga_vram_base = 0xa0000;
-                               vga_vram_end = 0xb0000;
+                               vga_vram_size = 0x10000;
                                outb_p(6, VGA_GFX_I);
                                outb_p(6, VGA_GFX_D);
 #endif
@@ -475,7 +475,7 @@ static const char __init *vgacon_startup(void)
                        static struct resource cga_console_resource =
                            { "cga", 0x3D4, 0x3D5 };
                        vga_video_type = VIDEO_TYPE_CGA;
-                       vga_vram_end = 0xba000;
+                       vga_vram_size = 0x2000;
                        display_desc = "*CGA";
                        request_resource(&ioport_resource,
                                         &cga_console_resource);
@@ -483,9 +483,8 @@ static const char __init *vgacon_startup(void)
                }
        }
 
-       vga_vram_base = VGA_MAP_MEM(vga_vram_base);
-       vga_vram_end = VGA_MAP_MEM(vga_vram_end);
-       vga_vram_size = vga_vram_end - vga_vram_base;
+       vga_vram_base = VGA_MAP_MEM(vga_vram_base, vga_vram_size);
+       vga_vram_end = vga_vram_base + vga_vram_size;
 
        /*
         *      Find out if there is a graphics card present.
@@ -1020,14 +1019,14 @@ static int vgacon_do_font_op(struct vgastate *state,char *arg,int set,int ch512)
        char *charmap;
        
        if (vga_video_type != VIDEO_TYPE_EGAM) {
-               charmap = (char *) VGA_MAP_MEM(colourmap);
+               charmap = (char *) VGA_MAP_MEM(colourmap, 0);
                beg = 0x0e;
 #ifdef VGA_CAN_DO_64KB
                if (vga_video_type == VIDEO_TYPE_VGAC)
                        beg = 0x06;
 #endif
        } else {
-               charmap = (char *) VGA_MAP_MEM(blackwmap);
+               charmap = (char *) VGA_MAP_MEM(blackwmap, 0);
                beg = 0x0a;
        }
 
index f3f16fd9f2316d32c89a2d9ae63b47864cd28fb0..4fd2a272e03d350ea3a0cec9c4b1d3c15ca63740 100644 (file)
@@ -1351,7 +1351,7 @@ static int __init vga16fb_probe(struct device *device)
        }
 
        /* XXX share VGA_FB_PHYS and I/O region with vgacon and others */
-       info->screen_base = (void __iomem *)VGA_MAP_MEM(VGA_FB_PHYS);
+       info->screen_base = (void __iomem *)VGA_MAP_MEM(VGA_FB_PHYS, 0);
 
        if (!info->screen_base) {
                printk(KERN_ERR "vga16fb: unable to map device\n");
index 537893a16014cbbdd6d72259e795030625e91a77..8a04216e8b4d37856bec43d273f24b45cadc138e 100644 (file)
@@ -759,7 +759,6 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
 
        /* Discard our unneeded old files struct */
        if (files) {
-               steal_locks(files);
                put_files_struct(files);
                files = NULL;
        }
index d73d75591a3966125003fdc8e6edebca1d7cc5e3..599f36fd0f6712669a759c996bd608872f588d13 100644 (file)
@@ -203,7 +203,6 @@ static int load_misc_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                goto _error;
 
        if (files) {
-               steal_locks(files);
                put_files_struct(files);
                files = NULL;
        }
index f5958f413bd1135787e2dc731f92b562c452d390..44aaba202f78f87083605e11030d1b7613f2ccc0 100644 (file)
@@ -414,21 +414,31 @@ EXPORT_SYMBOL(bdput);
 static struct block_device *bd_acquire(struct inode *inode)
 {
        struct block_device *bdev;
+
        spin_lock(&bdev_lock);
        bdev = inode->i_bdev;
-       if (bdev && igrab(bdev->bd_inode)) {
+       if (bdev) {
+               atomic_inc(&bdev->bd_inode->i_count);
                spin_unlock(&bdev_lock);
                return bdev;
        }
        spin_unlock(&bdev_lock);
+
        bdev = bdget(inode->i_rdev);
        if (bdev) {
                spin_lock(&bdev_lock);
-               if (inode->i_bdev)
-                       __bd_forget(inode);
-               inode->i_bdev = bdev;
-               inode->i_mapping = bdev->bd_inode->i_mapping;
-               list_add(&inode->i_devices, &bdev->bd_inodes);
+               if (!inode->i_bdev) {
+                       /*
+                        * We take an additional bd_inode->i_count for inode,
+                        * and it's released in clear_inode() of inode.
+                        * So, we can access it via ->i_mapping always
+                        * without igrab().
+                        */
+                       atomic_inc(&bdev->bd_inode->i_count);
+                       inode->i_bdev = bdev;
+                       inode->i_mapping = bdev->bd_inode->i_mapping;
+                       list_add(&inode->i_devices, &bdev->bd_inodes);
+               }
                spin_unlock(&bdev_lock);
        }
        return bdev;
@@ -438,10 +448,18 @@ static struct block_device *bd_acquire(struct inode *inode)
 
 void bd_forget(struct inode *inode)
 {
+       struct block_device *bdev = NULL;
+
        spin_lock(&bdev_lock);
-       if (inode->i_bdev)
+       if (inode->i_bdev) {
+               if (inode->i_sb != blockdev_superblock)
+                       bdev = inode->i_bdev;
                __bd_forget(inode);
+       }
        spin_unlock(&bdev_lock);
+
+       if (bdev)
+               iput(bdev->bd_inode);
 }
 
 int bd_claim(struct block_device *bdev, void *holder)
index 940d188e5d14a90730fe170b59eaa426012ef546..59dbc92c2079b88054c6f5852b5c7bd04cbd187c 100644 (file)
@@ -359,12 +359,13 @@ restart:
 }
 
 /*
- * Throw away a dentry - free the inode, dput the parent.
- * This requires that the LRU list has already been
- * removed.
+ * Throw away a dentry - free the inode, dput the parent.  This requires that
+ * the LRU list has already been removed.
+ *
  * Called with dcache_lock, drops it and then regains.
+ * Called with dentry->d_lock held, drops it.
  */
-static inline void prune_one_dentry(struct dentry * dentry)
+static void prune_one_dentry(struct dentry * dentry)
 {
        struct dentry * parent;
 
@@ -382,6 +383,8 @@ static inline void prune_one_dentry(struct dentry * dentry)
 /**
  * prune_dcache - shrink the dcache
  * @count: number of entries to try and free
+ * @sb: if given, ignore dentries for other superblocks
+ *         which are being unmounted.
  *
  * Shrink the dcache. This is done when we need
  * more memory, or simply when we need to unmount
@@ -392,16 +395,29 @@ static inline void prune_one_dentry(struct dentry * dentry)
  * all the dentries are in use.
  */
  
-static void prune_dcache(int count)
+static void prune_dcache(int count, struct super_block *sb)
 {
        spin_lock(&dcache_lock);
        for (; count ; count--) {
                struct dentry *dentry;
                struct list_head *tmp;
+               struct rw_semaphore *s_umount;
 
                cond_resched_lock(&dcache_lock);
 
                tmp = dentry_unused.prev;
+               if (unlikely(sb)) {
+                       /* Try to find a dentry for this sb, but don't try
+                        * too hard, if they aren't near the tail they will
+                        * be moved down again soon
+                        */
+                       int skip = count;
+                       while (skip && tmp != &dentry_unused &&
+                           list_entry(tmp, struct dentry, d_lru)->d_sb != sb) {
+                               skip--;
+                               tmp = tmp->prev;
+                       }
+               }
                if (tmp == &dentry_unused)
                        break;
                list_del_init(tmp);
@@ -427,7 +443,45 @@ static void prune_dcache(int count)
                        spin_unlock(&dentry->d_lock);
                        continue;
                }
-               prune_one_dentry(dentry);
+               /*
+                * If the dentry is not DCACHED_REFERENCED, it is time
+                * to remove it from the dcache, provided the super block is
+                * NULL (which means we are trying to reclaim memory)
+                * or this dentry belongs to the same super block that
+                * we want to shrink.
+                */
+               /*
+                * If this dentry is for "my" filesystem, then I can prune it
+                * without taking the s_umount lock (I already hold it).
+                */
+               if (sb && dentry->d_sb == sb) {
+                       prune_one_dentry(dentry);
+                       continue;
+               }
+               /*
+                * ...otherwise we need to be sure this filesystem isn't being
+                * unmounted, otherwise we could race with
+                * generic_shutdown_super(), and end up holding a reference to
+                * an inode while the filesystem is unmounted.
+                * So we try to get s_umount, and make sure s_root isn't NULL.
+                * (Take a local copy of s_umount to avoid a use-after-free of
+                * `dentry').
+                */
+               s_umount = &dentry->d_sb->s_umount;
+               if (down_read_trylock(s_umount)) {
+                       if (dentry->d_sb->s_root != NULL) {
+                               prune_one_dentry(dentry);
+                               up_read(s_umount);
+                               continue;
+                       }
+                       up_read(s_umount);
+               }
+               spin_unlock(&dentry->d_lock);
+               /* Cannot remove the first dentry, and it isn't appropriate
+                * to move it to the head of the list, so give up, and try
+                * later
+                */
+               break;
        }
        spin_unlock(&dcache_lock);
 }
@@ -630,7 +684,7 @@ void shrink_dcache_parent(struct dentry * parent)
        int found;
 
        while ((found = select_parent(parent)) != 0)
-               prune_dcache(found);
+               prune_dcache(found, parent->d_sb);
 }
 
 /**
@@ -643,9 +697,10 @@ void shrink_dcache_parent(struct dentry * parent)
  * done under dcache_lock.
  *
  */
-void shrink_dcache_anon(struct hlist_head *head)
+void shrink_dcache_anon(struct super_block *sb)
 {
        struct hlist_node *lp;
+       struct hlist_head *head = &sb->s_anon;
        int found;
        do {
                found = 0;
@@ -668,7 +723,7 @@ void shrink_dcache_anon(struct hlist_head *head)
                        }
                }
                spin_unlock(&dcache_lock);
-               prune_dcache(found);
+               prune_dcache(found, sb);
        } while(found);
 }
 
@@ -689,7 +744,7 @@ static int shrink_dcache_memory(int nr, gfp_t gfp_mask)
        if (nr) {
                if (!(gfp_mask & __GFP_FS))
                        return -1;
-               prune_dcache(nr);
+               prune_dcache(nr, NULL);
        }
        return (dentry_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
 }
index d07858c0b7c4e3885c2d6b31521f3e5668b94007..0b88bf646143c983a36309c3d5f425dcff7ec841 100644 (file)
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -866,7 +866,6 @@ int flush_old_exec(struct linux_binprm * bprm)
        bprm->mm = NULL;                /* We're using it now */
 
        /* This is the point of no return */
-       steal_locks(files);
        put_files_struct(files);
 
        current->sas_ss_sp = current->sas_ss_size = 0;
index ab61a8b548292c025c86a4ba87db4dcab08015d8..69435c68c1ed7a1d95618e8864787174a23f92a0 100644 (file)
@@ -2206,63 +2206,6 @@ int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
 
 EXPORT_SYMBOL(lock_may_write);
 
-static inline void __steal_locks(struct file *file, fl_owner_t from)
-{
-       struct inode *inode = file->f_dentry->d_inode;
-       struct file_lock *fl = inode->i_flock;
-
-       while (fl) {
-               if (fl->fl_file == file && fl->fl_owner == from)
-                       fl->fl_owner = current->files;
-               fl = fl->fl_next;
-       }
-}
-
-/* When getting ready for executing a binary, we make sure that current
- * has a files_struct on its own. Before dropping the old files_struct,
- * we take over ownership of all locks for all file descriptors we own.
- * Note that we may accidentally steal a lock for a file that a sibling
- * has created since the unshare_files() call.
- */
-void steal_locks(fl_owner_t from)
-{
-       struct files_struct *files = current->files;
-       int i, j;
-       struct fdtable *fdt;
-
-       if (from == files)
-               return;
-
-       lock_kernel();
-       j = 0;
-
-       /*
-        * We are not taking a ref to the file structures, so
-        * we need to acquire ->file_lock.
-        */
-       spin_lock(&files->file_lock);
-       fdt = files_fdtable(files);
-       for (;;) {
-               unsigned long set;
-               i = j * __NFDBITS;
-               if (i >= fdt->max_fdset || i >= fdt->max_fds)
-                       break;
-               set = fdt->open_fds->fds_bits[j++];
-               while (set) {
-                       if (set & 1) {
-                               struct file *file = fdt->fd[i];
-                               if (file)
-                                       __steal_locks(file, from);
-                       }
-                       i++;
-                       set >>= 1;
-               }
-       }
-       spin_unlock(&files->file_lock);
-       unlock_kernel();
-}
-EXPORT_SYMBOL(steal_locks);
-
 static int __init filelock_init(void)
 {
        filelock_cache = kmem_cache_create("file_lock_cache",
index c63a83e8da98b7d6737de1969a86f9c5ed066e35..36e1e136bb0c65bbdf21f0b8b19602c14964dfa1 100644 (file)
@@ -1484,14 +1484,15 @@ static inline void ntfs_flush_dcache_pages(struct page **pages,
                unsigned nr_pages)
 {
        BUG_ON(!nr_pages);
+       /*
+        * Warning: Do not do the decrement at the same time as the call to
+        * flush_dcache_page() because it is a NULL macro on i386 and hence the
+        * decrement never happens so the loop never terminates.
+        */
        do {
-               /*
-                * Warning: Do not do the decrement at the same time as the
-                * call because flush_dcache_page() is a NULL macro on i386
-                * and hence the decrement never happens.
-                */
+               --nr_pages;
                flush_dcache_page(pages[nr_pages]);
-       } while (--nr_pages > 0);
+       } while (nr_pages > 0);
 }
 
 /**
index a66f66bb804979a62cf6233473bdeae191884410..9d5c2add72286d531e26f0471b0e0148e5dbd6b6 100644 (file)
@@ -231,7 +231,7 @@ void generic_shutdown_super(struct super_block *sb)
        if (root) {
                sb->s_root = NULL;
                shrink_dcache_parent(root);
-               shrink_dcache_anon(&sb->s_anon);
+               shrink_dcache_anon(sb);
                dput(root);
                fsync_super(sb);
                lock_super(sb);
index 8ca4f6b2da19e87af861971b23b7b1c4778014e5..ed06f59b544d4c7c84ef7ccdb20ab56fa1444554 100644 (file)
@@ -46,6 +46,6 @@ extern void scr_memcpyw(u16 *d, const u16 *s, unsigned int count);
 #define vga_readb(a)   readb((u8 __iomem *)(a))
 #define vga_writeb(v,a)        writeb(v, (u8 __iomem *)(a))
 
-#define VGA_MAP_MEM(x) ((unsigned long) ioremap(x, 0))
+#define VGA_MAP_MEM(x,s)       ((unsigned long) ioremap(x, s))
 
 #endif
index 926e5ee128e92cdbdc91e6f5bda075cf06186014..1e0b913c3d71ce9be96847b128b3965da2672f21 100644 (file)
@@ -4,7 +4,7 @@
 #include <asm/hardware.h>
 #include <asm/io.h>
 
-#define VGA_MAP_MEM(x) (PCIMEM_BASE + (x))
+#define VGA_MAP_MEM(x,s)       (PCIMEM_BASE + (x))
 
 #define vga_readb(x)   (*((volatile unsigned char *)x))
 #define vga_writeb(x,y)        (*((volatile unsigned char *)y) = (x))
index f041d4495fafeb1a5fdc44791561415f1b673684..b11c4b7dfaeffce9833a264cadb0f484e38fee2f 100644 (file)
@@ -9,7 +9,15 @@
 #include <asm/desc.h>
 #include <mach_apic.h>
 
-#define LAST_DEVICE_VECTOR             232
+#define LAST_DEVICE_VECTOR     (FIRST_SYSTEM_VECTOR - 1)
 #define MSI_TARGET_CPU_SHIFT   12
 
+extern struct msi_ops msi_apic_ops;
+
+static inline int msi_arch_init(void)
+{
+       msi_register(&msi_apic_ops);
+       return 0;
+}
+
 #endif /* ASM_MSI_H */
index ef0c0e50cc951e898ea4f50661db2e4f1dc551fa..0ecf68ac03aa95c312a15876473d5df5a8851301 100644 (file)
@@ -12,7 +12,7 @@
  *     access the videoram directly without any black magic.
  */
 
-#define VGA_MAP_MEM(x) (unsigned long)phys_to_virt(x)
+#define VGA_MAP_MEM(x,s) (unsigned long)phys_to_virt(x)
 
 #define vga_readb(x) (*(x))
 #define vga_writeb(x,y) (*(y) = (x))
index 0cf119b42f7d5c4d1d25ce4eb0e55b9a849d52cb..ea8b8c407ab4a210f50b055c2030cb34222fdca0 100644 (file)
@@ -47,9 +47,19 @@ typedef u8 ia64_vector;
 #define IA64_CMC_VECTOR                        0x1f    /* corrected machine-check interrupt vector */
 /*
  * Vectors 0x20-0x2f are reserved for legacy ISA IRQs.
+ * Use vectors 0x30-0xe7 as the default device vector range for ia64.
+ * Platforms may choose to reduce this range in platform_irq_setup, but the
+ * platform range must fall within
+ *     [IA64_DEF_FIRST_DEVICE_VECTOR..IA64_DEF_LAST_DEVICE_VECTOR]
  */
-#define IA64_FIRST_DEVICE_VECTOR       0x30
-#define IA64_LAST_DEVICE_VECTOR                0xe7
+extern int ia64_first_device_vector;
+extern int ia64_last_device_vector;
+
+#define IA64_DEF_FIRST_DEVICE_VECTOR   0x30
+#define IA64_DEF_LAST_DEVICE_VECTOR    0xe7
+#define IA64_FIRST_DEVICE_VECTOR       ia64_first_device_vector
+#define IA64_LAST_DEVICE_VECTOR                ia64_last_device_vector
+#define IA64_MAX_DEVICE_VECTORS                (IA64_DEF_LAST_DEVICE_VECTOR - IA64_DEF_FIRST_DEVICE_VECTOR + 1)
 #define IA64_NUM_DEVICE_VECTORS                (IA64_LAST_DEVICE_VECTOR - IA64_FIRST_DEVICE_VECTOR + 1)
 
 #define IA64_MCA_RENDEZ_VECTOR         0xe8    /* MCA rendez interrupt */
@@ -83,6 +93,7 @@ extern struct hw_interrupt_type irq_type_ia64_lsapic; /* CPU-internal interrupt
 
 extern int assign_irq_vector (int irq);        /* allocate a free vector */
 extern void free_irq_vector (int vector);
+extern int reserve_irq_vector (int vector);
 extern void ia64_send_ipi (int cpu, int vector, int delivery_mode, int redirect);
 extern void register_percpu_irq (ia64_vector vec, struct irqaction *action);
 
index 0df72a134c8b80e26f2f04cc471e655ffddd3c75..15b545a897a4b6a05843f12f4691c37acad46885 100644 (file)
@@ -75,6 +75,7 @@ typedef unsigned char ia64_mv_readb_relaxed_t (const volatile void __iomem *);
 typedef unsigned short ia64_mv_readw_relaxed_t (const volatile void __iomem *);
 typedef unsigned int ia64_mv_readl_relaxed_t (const volatile void __iomem *);
 typedef unsigned long ia64_mv_readq_relaxed_t (const volatile void __iomem *);
+typedef int ia64_mv_msi_init_t (void);
 
 static inline void
 machvec_noop (void)
@@ -153,6 +154,7 @@ extern void machvec_tlb_migrate_finish (struct mm_struct *);
 #  define platform_readl_relaxed        ia64_mv.readl_relaxed
 #  define platform_readq_relaxed        ia64_mv.readq_relaxed
 #  define platform_migrate             ia64_mv.migrate
+#  define platform_msi_init            ia64_mv.msi_init
 # endif
 
 /* __attribute__((__aligned__(16))) is required to make size of the
@@ -202,6 +204,7 @@ struct ia64_machine_vector {
        ia64_mv_readl_relaxed_t *readl_relaxed;
        ia64_mv_readq_relaxed_t *readq_relaxed;
        ia64_mv_migrate_t *migrate;
+       ia64_mv_msi_init_t *msi_init;
 } __attribute__((__aligned__(16))); /* align attrib? see above comment */
 
 #define MACHVEC_INIT(name)                     \
@@ -247,6 +250,7 @@ struct ia64_machine_vector {
        platform_readl_relaxed,                 \
        platform_readq_relaxed,                 \
        platform_migrate,                       \
+       platform_msi_init,                      \
 }
 
 extern struct ia64_machine_vector ia64_mv;
@@ -400,5 +404,8 @@ extern int ia64_pci_legacy_write(struct pci_bus *bus, u16 port, u32 val, u8 size
 #ifndef platform_migrate
 # define platform_migrate machvec_noop_task
 #endif
+#ifndef platform_msi_init
+# define platform_msi_init     ((ia64_mv_msi_init_t*)NULL)
+#endif
 
 #endif /* _ASM_IA64_MACHVEC_H */
index da1d43755afea2de3730c40dbda81b09d41eda8e..cf724dc79d8c70d25b5db1f771f130f083c48a79 100644 (file)
@@ -67,6 +67,8 @@ extern ia64_mv_dma_sync_sg_for_device sn_dma_sync_sg_for_device;
 extern ia64_mv_dma_mapping_error       sn_dma_mapping_error;
 extern ia64_mv_dma_supported           sn_dma_supported;
 extern ia64_mv_migrate_t               sn_migrate;
+extern ia64_mv_msi_init_t              sn_msi_init;
+
 
 /*
  * This stuff has dual use!
@@ -117,6 +119,11 @@ extern ia64_mv_migrate_t           sn_migrate;
 #define platform_dma_mapping_error             sn_dma_mapping_error
 #define platform_dma_supported         sn_dma_supported
 #define platform_migrate               sn_migrate
+#ifdef CONFIG_PCI_MSI
+#define platform_msi_init              sn_msi_init
+#else
+#define platform_msi_init              ((ia64_mv_msi_init_t*)NULL)
+#endif
 
 #include <asm/sn/io.h>
 
index 97890f7762b338515302884b3b874a0831558ee3..bb92b0dbde2f2ef600b35c5c96c6661e333e17be 100644 (file)
@@ -14,4 +14,16 @@ static inline void set_intr_gate (int nr, void *func) {}
 #define ack_APIC_irq           ia64_eoi
 #define MSI_TARGET_CPU_SHIFT   4
 
+extern struct msi_ops msi_apic_ops;
+
+static inline int msi_arch_init(void)
+{
+       if (platform_msi_init)
+               return platform_msi_init();
+
+       /* default ops for most ia64 platforms */
+       msi_register(&msi_apic_ops);
+       return 0;
+}
+
 #endif /* ASM_MSI_H */
index 60a51a406eec5f19019d99ec01ff87f9461ef83d..12b54ddb06be2a7e1d52365d4846fbc4a0a48c4c 100644 (file)
@@ -10,6 +10,7 @@
 #define _ASM_IA64_SN_INTR_H
 
 #include <linux/rcupdate.h>
+#include <asm/sn/types.h>
 
 #define SGI_UART_VECTOR                0xe9
 
@@ -40,6 +41,7 @@ struct sn_irq_info {
        int             irq_cpuid;      /* kernel logical cpuid      */
        int             irq_irq;        /* the IRQ number */
        int             irq_int_bit;    /* Bridge interrupt pin */
+                                       /* <0 means MSI */
        u64     irq_xtalkaddr;  /* xtalkaddr IRQ is sent to  */
        int             irq_bridge_type;/* pciio asic type (pciio.h) */
        void           *irq_bridge;     /* bridge generating irq     */
@@ -53,6 +55,12 @@ struct sn_irq_info {
 };
 
 extern void sn_send_IPI_phys(int, long, int, int);
+extern u64 sn_intr_alloc(nasid_t, int,
+                             struct sn_irq_info *,
+                             int, nasid_t, int);
+extern void sn_intr_free(nasid_t, int, struct sn_irq_info *);
+extern struct sn_irq_info *sn_retarget_vector(struct sn_irq_info *, nasid_t, int);
+extern struct list_head **sn_irq_lh;
 
 #define CPU_VECTOR_TO_IRQ(cpuid,vector) (vector)
 
index 51260ab70d915f32e5b9a5d2852a9f9a96a8aee2..e3b0c3fe5eed88205682f38423e3f46ff2b93882 100644 (file)
@@ -55,6 +55,7 @@
 #define PCI32_ATE_V                     (0x1 << 0)
 #define PCI32_ATE_CO                    (0x1 << 1)
 #define PCI32_ATE_PREC                  (0x1 << 2)
+#define PCI32_ATE_MSI                   (0x1 << 2)
 #define PCI32_ATE_PREF                  (0x1 << 3)
 #define PCI32_ATE_BAR                   (0x1 << 4)
 #define PCI32_ATE_ADDR_SHFT             12
@@ -117,8 +118,8 @@ struct pcibus_info {
 
 extern int  pcibr_init_provider(void);
 extern void *pcibr_bus_fixup(struct pcibus_bussoft *, struct pci_controller *);
-extern dma_addr_t pcibr_dma_map(struct pci_dev *, unsigned long, size_t);
-extern dma_addr_t pcibr_dma_map_consistent(struct pci_dev *, unsigned long, size_t);
+extern dma_addr_t pcibr_dma_map(struct pci_dev *, unsigned long, size_t, int type);
+extern dma_addr_t pcibr_dma_map_consistent(struct pci_dev *, unsigned long, size_t, int type);
 extern void pcibr_dma_unmap(struct pci_dev *, dma_addr_t, int);
 
 /*
index ce3f6c3282414d4286ae9f3ca93961c97fda9d14..8f7c83d0f6d3937e8c9101dacdc0422d7e523cda 100644 (file)
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 1992 - 1997, 2000-2004 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 1992 - 1997, 2000-2005 Silicon Graphics, Inc. All rights reserved.
  */
 #ifndef _ASM_IA64_SN_PCI_PCIBUS_PROVIDER_H
 #define _ASM_IA64_SN_PCI_PCIBUS_PROVIDER_H
@@ -45,13 +45,24 @@ struct pci_controller;
  */
 
 struct sn_pcibus_provider {
-       dma_addr_t      (*dma_map)(struct pci_dev *, unsigned long, size_t);
-       dma_addr_t      (*dma_map_consistent)(struct pci_dev *, unsigned long, size_t);
+       dma_addr_t      (*dma_map)(struct pci_dev *, unsigned long, size_t, int flags);
+       dma_addr_t      (*dma_map_consistent)(struct pci_dev *, unsigned long, size_t, int flags);
        void            (*dma_unmap)(struct pci_dev *, dma_addr_t, int);
        void *          (*bus_fixup)(struct pcibus_bussoft *, struct pci_controller *);
        void            (*force_interrupt)(struct sn_irq_info *);
        void            (*target_interrupt)(struct sn_irq_info *);
 };
 
+/*
+ * Flags used by the map interfaces
+ * bits 3:0 specifies format of passed in address
+ * bit  4   specifies that address is to be used for MSI
+ */
+
+#define SN_DMA_ADDRTYPE(x)     ((x) & 0xf)
+#define     SN_DMA_ADDR_PHYS   1       /* address is an xio address. */
+#define     SN_DMA_ADDR_XIO    2       /* address is phys memory */
+#define SN_DMA_MSI             0x10    /* Bus address is to be used for MSI */
+
 extern struct sn_pcibus_provider *sn_pci_provider[];
 #endif                         /* _ASM_IA64_SN_PCI_PCIBUS_PROVIDER_H */
index f47c08ab483c4d732675564f449916247265cdda..e8ad0bb5b6c51c27850633b8ec093b976f61f27b 100644 (file)
@@ -3,13 +3,14 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2003-2004 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2003-2005 Silicon Graphics, Inc. All rights reserved.
  */
 #ifndef _ASM_IA64_SN_PCI_TIOCP_H
 #define _ASM_IA64_SN_PCI_TIOCP_H
 
 #define TIOCP_HOST_INTR_ADDR            0x003FFFFFFFFFFFFFUL
 #define TIOCP_PCI64_CMDTYPE_MEM         (0x1ull << 60)
+#define TIOCP_PCI64_CMDTYPE_MSI         (0x3ull << 60)
 
 
 /*****************************************************************************
index 091177cda223708f6c0a3560b58bfe775845f02a..02184ecd820822af282794071456ebba12502c07 100644 (file)
@@ -17,7 +17,7 @@
 extern unsigned long vga_console_iobase;
 extern unsigned long vga_console_membase;
 
-#define VGA_MAP_MEM(x) ((unsigned long) ioremap_nocache(vga_console_membase + (x), 0))
+#define VGA_MAP_MEM(x,s)       ((unsigned long) ioremap_nocache(vga_console_membase + (x), s))
 
 #define vga_readb(x)   (*(x))
 #define vga_writeb(x,y)        (*(y) = (x))
index d0f4b6eed7a34f0c234200ec0cb3ab81297964d7..533163447cc9d3f711d256c144bb6095b982b0f9 100644 (file)
@@ -14,7 +14,7 @@
  *     access the videoram directly without any black magic.
  */
 
-#define VGA_MAP_MEM(x) (unsigned long)phys_to_virt(x)
+#define VGA_MAP_MEM(x,s) (unsigned long)phys_to_virt(x)
 
 #define vga_readb(x) (*(x))
 #define vga_writeb(x,y) (*(y) = (x))
index 34755c0a63988e21121a33c943fbada2234bb7da..c1dd0b10bc2737ba1abb23434106b5560b78924f 100644 (file)
@@ -13,7 +13,7 @@
  *     access the videoram directly without any black magic.
  */
 
-#define VGA_MAP_MEM(x) (0xb0000000L + (unsigned long)(x))
+#define VGA_MAP_MEM(x,s)       (0xb0000000L + (unsigned long)(x))
 
 #define vga_readb(x)   (*(x))
 #define vga_writeb(x,y)        (*(y) = (x))
index eadaf2f3d03255c0eefe558138a943894cecdaf1..a2eac409c1ec2cbcd81ce48ced5b07aac04195a0 100644 (file)
@@ -41,9 +41,9 @@ static inline u16 scr_readw(volatile const u16 *addr)
 extern unsigned long vgacon_remap_base;
 
 #ifdef __powerpc64__
-#define VGA_MAP_MEM(x) ((unsigned long) ioremap((x), 0))
+#define VGA_MAP_MEM(x,s) ((unsigned long) ioremap((x), s))
 #else
-#define VGA_MAP_MEM(x) (x + vgacon_remap_base)
+#define VGA_MAP_MEM(x,s) (x + vgacon_remap_base)
 #endif
 
 #define vga_readb(x) (*(x))
index 9c57eb363b40466582d127da68f0025bac7c380f..c69d5b2ba19a488ea3abf8a75c25383edd13d562 100644 (file)
@@ -28,6 +28,6 @@ static inline u16 scr_readw(const u16 *addr)
        return *addr;
 }
 
-#define VGA_MAP_MEM(x) (x)
+#define VGA_MAP_MEM(x,s) (x)
 
 #endif
index 356e0e82f50bdbb0f21d98b168d3eb93f0a7ee2c..3ad2346624b21bf02d807a4623c501498293e32d 100644 (file)
 #include <asm/mach_apic.h>
 #include <asm/smp.h>
 
-#define LAST_DEVICE_VECTOR             232
+#define LAST_DEVICE_VECTOR     (FIRST_SYSTEM_VECTOR - 1)
 #define MSI_TARGET_CPU_SHIFT   12
 
+extern struct msi_ops msi_apic_ops;
+
+static inline int msi_arch_init(void)
+{
+       msi_register(&msi_apic_ops);
+       return 0;
+}
+
 #endif /* ASM_MSI_H */
index ef0c0e50cc951e898ea4f50661db2e4f1dc551fa..0ecf68ac03aa95c312a15876473d5df5a8851301 100644 (file)
@@ -12,7 +12,7 @@
  *     access the videoram directly without any black magic.
  */
 
-#define VGA_MAP_MEM(x) (unsigned long)phys_to_virt(x)
+#define VGA_MAP_MEM(x,s) (unsigned long)phys_to_virt(x)
 
 #define vga_readb(x) (*(x))
 #define vga_writeb(x,y) (*(y) = (x))
index 23d82f6acb572b77971e33b379ab34ea6627c8cf..1fd8cab3a297fb1446fe5081048ca737a402e900 100644 (file)
@@ -11,7 +11,7 @@
 #ifndef _XTENSA_VGA_H
 #define _XTENSA_VGA_H
 
-#define VGA_MAP_MEM(x) (unsigned long)phys_to_virt(x)
+#define VGA_MAP_MEM(x,s) (unsigned long)phys_to_virt(x)
 
 #define vga_readb(x)   (*(x))
 #define vga_writeb(x,y)        (*(y) = (x))
index 836325ee0931eef5398a304766217cc4388589f8..46d0e079735d19c01310df7200f058dd36af1401 100644 (file)
@@ -217,7 +217,7 @@ extern struct dentry * d_alloc_anon(struct inode *);
 extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
 extern void shrink_dcache_sb(struct super_block *);
 extern void shrink_dcache_parent(struct dentry *);
-extern void shrink_dcache_anon(struct hlist_head *);
+extern void shrink_dcache_anon(struct super_block *);
 extern int d_invalidate(struct dentry *);
 
 /* only used at mount-time */
index ecc8c2c3d8ca8382d5b121c7219d9f73b33baba4..73c7d6f04b31a657a9b7060ac43f5a256ce070f4 100644 (file)
@@ -782,7 +782,6 @@ extern int setlease(struct file *, long, struct file_lock **);
 extern int lease_modify(struct file_lock **, int);
 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
-extern void steal_locks(fl_owner_t from);
 
 struct fasync_struct {
        int     magic;
index cbf464ad9589526d139b369ea3c00f5b920348c9..e81ebf910d0bc3d9b1b38732f59947f1270ba99e 100644 (file)
@@ -205,6 +205,11 @@ struct key_type {
        /* match a key against a description */
        int (*match)(const struct key *key, const void *desc);
 
+       /* clear some of the data from a key on revokation (optional)
+        * - the key's semaphore will be write-locked by the caller
+        */
+       void (*revoke)(struct key *key);
+
        /* clear the data from a key (optional) */
        void (*destroy)(struct key *key);
 
@@ -241,8 +246,9 @@ extern void unregister_key_type(struct key_type *ktype);
 
 extern struct key *key_alloc(struct key_type *type,
                             const char *desc,
-                            uid_t uid, gid_t gid, key_perm_t perm,
-                            int not_in_quota);
+                            uid_t uid, gid_t gid,
+                            struct task_struct *ctx,
+                            key_perm_t perm, int not_in_quota);
 extern int key_payload_reserve(struct key *key, size_t datalen);
 extern int key_instantiate_and_link(struct key *key,
                                    const void *data,
@@ -292,7 +298,9 @@ extern int key_unlink(struct key *keyring,
                      struct key *key);
 
 extern struct key *keyring_alloc(const char *description, uid_t uid, gid_t gid,
-                                int not_in_quota, struct key *dest);
+                                struct task_struct *ctx,
+                                int not_in_quota,
+                                struct key *dest);
 
 extern int keyring_clear(struct key *keyring);
 
@@ -313,7 +321,8 @@ extern void keyring_replace_payload(struct key *key, void *replacement);
  * the userspace interface
  */
 extern struct key root_user_keyring, root_session_keyring;
-extern int alloc_uid_keyring(struct user_struct *user);
+extern int alloc_uid_keyring(struct user_struct *user,
+                            struct task_struct *ctx);
 extern void switch_uid_keyring(struct user_struct *new_user);
 extern int copy_keys(unsigned long clone_flags, struct task_struct *tsk);
 extern int copy_thread_group_keys(struct task_struct *tsk);
@@ -342,7 +351,7 @@ extern void key_init(void);
 #define make_key_ref(k)                        ({ NULL; })
 #define key_ref_to_ptr(k)              ({ NULL; })
 #define is_key_possessed(k)            0
-#define alloc_uid_keyring(u)           0
+#define alloc_uid_keyring(u,c)         0
 #define switch_uid_keyring(u)          do { } while(0)
 #define __install_session_keyring(t, k)        ({ NULL; })
 #define copy_keys(f,t)                 0
@@ -355,6 +364,10 @@ extern void key_init(void);
 #define key_fsgid_changed(t)           do { } while(0)
 #define key_init()                     do { } while(0)
 
+/* Initial keyrings */
+extern struct key root_user_keyring;
+extern struct key root_session_keyring;
+
 #endif /* CONFIG_KEYS */
 #endif /* __KERNEL__ */
 #endif /* _LINUX_KEY_H */
index 6c4bc773f7b7b91c86e23e437b6d176bc58810e5..62a8c22f5f604981970a762d780c0f9eff101165 100644 (file)
@@ -162,6 +162,9 @@ struct pci_dev {
        unsigned int    is_busmaster:1; /* device is busmaster */
        unsigned int    no_msi:1;       /* device may not use msi */
        unsigned int    block_ucfg_access:1;    /* userspace config space access is blocked */
+       unsigned int    broken_parity_status:1; /* Device generates false positive parity */
+       unsigned int    msi_enabled:1;
+       unsigned int    msix_enabled:1;
 
        u32             saved_config_space[16]; /* config space saved at suspend time */
        struct hlist_head saved_cap_space;
@@ -496,6 +499,7 @@ int pci_set_dma_mask(struct pci_dev *dev, u64 mask);
 int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask);
 void pci_update_resource(struct pci_dev *dev, struct resource *res, int resno);
 int pci_assign_resource(struct pci_dev *dev, int i);
+int pci_assign_resource_fixed(struct pci_dev *dev, int i);
 void pci_restore_bars(struct pci_dev *dev);
 
 /* ROM control related routines */
index bcfe9d4f56aea1ba730f329aaf6f7af084c05f50..fd54a9d4c3d44ddbb79a001e78d7c0443b9c8ad5 100644 (file)
 
 
 #define PCI_VENDOR_ID_QLOGIC           0x1077
+#define PCI_DEVICE_ID_QLOGIC_ISP10160  0x1016
 #define PCI_DEVICE_ID_QLOGIC_ISP1020   0x1020
+#define PCI_DEVICE_ID_QLOGIC_ISP1080   0x1080
+#define PCI_DEVICE_ID_QLOGIC_ISP12160  0x1216
+#define PCI_DEVICE_ID_QLOGIC_ISP1240   0x1240
+#define PCI_DEVICE_ID_QLOGIC_ISP1280   0x1280
 #define PCI_DEVICE_ID_QLOGIC_ISP2100   0x2100
 #define PCI_DEVICE_ID_QLOGIC_ISP2200   0x2200
 #define PCI_DEVICE_ID_QLOGIC_ISP2300   0x2300
 #define PCI_DEVICE_ID_NVIDIA_NVENET_8          0x0056
 #define PCI_DEVICE_ID_NVIDIA_NVENET_9          0x0057
 #define PCI_DEVICE_ID_NVIDIA_CK804_AUDIO       0x0059
+#define PCI_DEVICE_ID_NVIDIA_CK804_PCIE                0x005d
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS     0x0064
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2_IDE       0x0065
 #define PCI_DEVICE_ID_NVIDIA_NVENET_2          0x0066
 
 #define PCI_VENDOR_ID_MELLANOX         0x15b3
 #define PCI_DEVICE_ID_MELLANOX_TAVOR   0x5a44
+#define PCI_DEVICE_ID_MELLANOX_TAVOR_BRIDGE    0x5a46
 #define PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT 0x6278
 #define PCI_DEVICE_ID_MELLANOX_ARBEL   0x6282
 #define PCI_DEVICE_ID_MELLANOX_SINAI_OLD 0x5e8c
 #define PCI_VENDOR_ID_NETCELL          0x169c
 #define PCI_DEVICE_ID_REVOLUTION       0x0044
 
+#define PCI_VENDOR_ID_VITESSE          0x1725
+#define PCI_DEVICE_ID_VITESSE_VSC7174  0x7174
+
 #define PCI_VENDOR_ID_LINKSYS          0x1737
 #define PCI_DEVICE_ID_LINKSYS_EG1064   0x1064
 
 #define PCI_DEVICE_ID_INTEL_ICH8_4     0x2815
 #define PCI_DEVICE_ID_INTEL_ICH8_5     0x283e
 #define PCI_DEVICE_ID_INTEL_ICH8_6     0x2850
+#define PCI_DEVICE_ID_INTEL_GD31244    0x3200
 #define PCI_DEVICE_ID_INTEL_82855PM_HB 0x3340
 #define PCI_DEVICE_ID_INTEL_82830_HB   0x3575
 #define PCI_DEVICE_ID_INTEL_82830_CGC  0x3577
index d27a78b71297058158af0760aa666cd60567480f..6bce4a2403643058bcc35649654622af2ba65966 100644 (file)
 #define  PCI_CAP_ID_CHSWP      0x06    /* CompactPCI HotSwap */
 #define  PCI_CAP_ID_PCIX       0x07    /* PCI-X */
 #define  PCI_CAP_ID_HT_IRQCONF 0x08    /* HyperTransport IRQ Configuration */
+#define  PCI_CAP_ID_VNDR       0x09    /* Vendor specific capability */
 #define  PCI_CAP_ID_SHPC       0x0C    /* PCI Standard Hot-Plug Controller */
 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
 #define  PCI_CAP_ID_MSIX       0x11    /* MSI-X */
index 4dfb1b84a9b3bef236ef041b3005692462d7b51b..47722d3555320a5a5aedaa14c6feed63deacdb57 100644 (file)
@@ -1313,7 +1313,7 @@ struct security_operations {
 
        /* key management security hooks */
 #ifdef CONFIG_KEYS
-       int (*key_alloc)(struct key *key);
+       int (*key_alloc)(struct key *key, struct task_struct *tsk);
        void (*key_free)(struct key *key);
        int (*key_permission)(key_ref_t key_ref,
                              struct task_struct *context,
@@ -3008,9 +3008,10 @@ static inline int security_xfrm_policy_lookup(struct xfrm_policy *xp, u32 sk_sid
 
 #ifdef CONFIG_KEYS
 #ifdef CONFIG_SECURITY
-static inline int security_key_alloc(struct key *key)
+static inline int security_key_alloc(struct key *key,
+                                    struct task_struct *tsk)
 {
-       return security_ops->key_alloc(key);
+       return security_ops->key_alloc(key, tsk);
 }
 
 static inline void security_key_free(struct key *key)
@@ -3027,7 +3028,8 @@ static inline int security_key_permission(key_ref_t key_ref,
 
 #else
 
-static inline int security_key_alloc(struct key *key)
+static inline int security_key_alloc(struct key *key,
+                                    struct task_struct *tsk)
 {
        return 0;
 }
index f1cfd66b9554bfe27fcfbd40559222909ff1c542..0beb75e38caa6e93411879047d7c3b1b83b9fc81 100644 (file)
  */
 #ifndef MAX_WBITS
 #  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+
+/* default memLevel */
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
 #endif
 
                         /* Type declarations */
index 4fa32f0d4df8a0ad345dabc793c4105cb4094648..9e3192a7dc6fa7ca7bf6746766234cf9261ed382 100644 (file)
@@ -1,7 +1,6 @@
 /* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 1.1.3, July 9th, 1998
 
-  Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
+  Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
@@ -24,7 +23,7 @@
 
 
   The data format used by the zlib library is described by RFCs (Request for
-  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
   (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
 */
 
 
 #include <linux/zconf.h>
 
-#define ZLIB_VERSION "1.1.3"
+/* zlib deflate based on ZLIB_VERSION "1.1.3" */
+/* zlib inflate based on ZLIB_VERSION "1.2.3" */
+
+/*
+  This is a modified version of zlib for use inside the Linux kernel.
+  The main changes are to perform all memory allocation in advance.
+
+  Inflation Changes:
+    * Z_PACKET_FLUSH is added and used by ppp_deflate. Before returning
+      this checks there is no more input data available and the next data
+      is a STORED block. It also resets the mode to be read for the next
+      data, all as per PPP requirements.
+    * Addition of zlib_inflateIncomp which copies incompressible data into
+      the history window and adjusts the accoutning without calling
+      zlib_inflate itself to inflate the data.
+*/
 
 /* 
      The 'zlib' compression library provides in-memory compression and
   application must provide more input and/or consume the output
   (providing more output space) before each call.
 
+     The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
      The library also supports reading and writing files in gzip (.gz) format
   with an interface similar to that of stdio.
 
+     The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
      The library does not install any signal handler. The decoder checks
   the consistency of the compressed data, so the library should never
   crash even in case of corrupted input.
@@ -119,7 +142,8 @@ typedef z_stream *z_streamp;
 #define Z_SYNC_FLUSH    3
 #define Z_FULL_FLUSH    4
 #define Z_FINISH        5
-/* Allowed flush values; see deflate() below for details */
+#define Z_BLOCK         6 /* Only for inflate at present */
+/* Allowed flush values; see deflate() and inflate() below for details */
 
 #define Z_OK            0
 #define Z_STREAM_END    1
@@ -155,13 +179,6 @@ typedef z_stream *z_streamp;
 
                         /* basic functions */
 
-extern const char * zlib_zlibVersion (void);
-/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
-   If the first character differs, the library code actually used is
-   not compatible with the zlib.h header file used by the application.
-   This check is automatically made by deflateInit and inflateInit.
- */
-
 extern int zlib_deflate_workspacesize (void);
 /*
    Returns the number of bytes that needs to be allocated for a per-
@@ -315,9 +332,9 @@ extern int zlib_inflateInit (z_streamp strm);
 extern int zlib_inflate (z_streamp strm, int flush);
 /*
     inflate decompresses as much data as possible, and stops when the input
-  buffer becomes empty or the output buffer becomes full. It may some
-  introduce some output latency (reading input without producing any output)
-  except when forced to flush.
+  buffer becomes empty or the output buffer becomes full. It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
 
   The detailed semantics are as follows. inflate performs one or both of the
   following actions:
@@ -341,11 +358,26 @@ extern int zlib_inflate (z_streamp strm, int flush);
   must be called again after making room in the output buffer because there
   might be more output pending.
 
-    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
-  output as possible to the output buffer. The flushing behavior of inflate is
-  not specified for values of the flush parameter other than Z_SYNC_FLUSH
-  and Z_FINISH, but the current implementation actually flushes as much output
-  as possible anyway.
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
+  Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer. Z_BLOCK requests that inflate() stop
+  if and when it gets to the next deflate block boundary. When decoding the
+  zlib or gzip format, this will cause inflate() to return immediately after
+  the header and before the first block. When doing a raw inflate, inflate()
+  will go ahead and process the first block, and will return when it gets to
+  the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  Also to assist in this, on return inflate() will set strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64
+  if inflate() is currently decoding the last block in the deflate stream,
+  plus 128 if inflate() returned immediately after decoding an end-of-block
+  code or decoding the complete header up to just before the first byte of the
+  deflate stream. The end-of-block will not be indicated until all of the
+  uncompressed data from that block has been written to strm->next_out.  The
+  number of unused bits may in general be greater than seven, except when
+  bit 7 of data_type is set, in which case the number of unused bits will be
+  less than eight.
 
     inflate() should normally be called until it returns Z_STREAM_END or an
   error. However if all decompression is to be performed in a single step
@@ -355,29 +387,44 @@ extern int zlib_inflate (z_streamp strm, int flush);
   uncompressed data. (The size of the uncompressed data may have been saved
   by the compressor for this purpose.) The next operation on this stream must
   be inflateEnd to deallocate the decompression state. The use of Z_FINISH
-  is never required, but can be used to inform inflate that a faster routine
+  is never required, but can be used to inform inflate that a faster approach
   may be used for the single inflate() call.
 
-     If a preset dictionary is needed at this point (see inflateSetDictionary
-  below), inflate sets strm-adler to the adler32 checksum of the
-  dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise 
-  it sets strm->adler to the adler32 checksum of all output produced
-  so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
-  an error code as described below. At the end of the stream, inflate()
-  checks that its computed adler32 checksum is equal to that saved by the
-  compressor and returns Z_STREAM_END only if the checksum is correct.
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call. So the only effect of the flush parameter in this implementation
+  is on the return value of inflate(), as noted below, or when it returns early
+  because Z_BLOCK is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the adler32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below. At the end of the stream, inflate() checks that its computed adler32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() will decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically.  Any information
+  contained in the gzip header is not retained, so applications that need that
+  information should instead use raw inflate, see inflateInit2() below, or
+  inflateBack() and perform their own processing of the gzip header and
+  trailer.
 
     inflate() returns Z_OK if some progress has been made (more input processed
   or more output produced), Z_STREAM_END if the end of the compressed data has
   been reached and all uncompressed output has been produced, Z_NEED_DICT if a
   preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
-  corrupted (input stream not conforming to the zlib format or incorrect
-  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
-  (for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
-  enough memory, Z_BUF_ERROR if no progress is possible or if there was not
-  enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
-  case, the application may then call inflateSync to look for a good
-  compression block.
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
+  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+  output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing. If Z_DATA_ERROR is returned, the application may then
+  call inflateSync() to look for a good compression block if a partial recovery
+  of the data is desired.
 */
 
 
@@ -547,16 +594,36 @@ extern int inflateInit2 (z_streamp strm, int  windowBits);
      The windowBits parameter is the base two logarithm of the maximum window
    size (the size of the history buffer).  It should be in the range 8..15 for
    this version of the library. The default value is 15 if inflateInit is used
-   instead. If a compressed stream with a larger window size is given as
-   input, inflate() will return with the error code Z_DATA_ERROR instead of
-   trying to allocate a larger window.
-
-      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
-   memLevel). msg is set to null if there is no error message.  inflateInit2
-   does not perform any decompression apart from reading the zlib header if
-   present: this will be done by inflate(). (So next_in and avail_in may be
-   modified, but next_out and avail_out are unchanged.)
+   instead. windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used. If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
+   determines the window size. inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream. This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values. If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an adler32 or a crc32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is. Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding. Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is
+   a crc32 instead of an adler32.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
+   is set to null if there is no error message.  inflateInit2 does not perform
+   any decompression apart from reading the zlib header if present: this will
+   be done by inflate(). (So next_in and avail_in may be modified, but next_out
+   and avail_out are unchanged.)
 */
 
 extern int zlib_inflateSetDictionary (z_streamp strm,
@@ -564,16 +631,19 @@ extern int zlib_inflateSetDictionary (z_streamp strm,
                                                     uInt  dictLength);
 /*
      Initializes the decompression dictionary from the given uncompressed byte
-   sequence. This function must be called immediately after a call of inflate
-   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
-   can be determined from the Adler32 value returned by this call of
-   inflate. The compressor and decompressor must use exactly the same
-   dictionary (see deflateSetDictionary).
+   sequence. This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
+   can be determined from the adler32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called
+   immediately after inflateInit2() or inflateReset() and before any call of
+   inflate() to set the dictionary.  The application must insure that the
+   dictionary that was used for compression is provided.
 
      inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
    parameter is invalid (such as NULL dictionary) or the stream state is
    inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
-   expected one (incorrect Adler32 value). inflateSetDictionary does not
+   expected one (incorrect adler32 value). inflateSetDictionary does not
    perform any decompression: this will be done by subsequent calls of
    inflate().
 */
@@ -614,40 +684,19 @@ extern int zlib_inflateIncomp (z_stream *strm);
    containing the data at next_in (except that the data is not output).
 */
 
-                        /* various hacks, don't look :) */
-
-/* deflateInit and inflateInit are macros to allow checking the zlib version
- * and the compiler's view of z_stream:
- */
-extern int zlib_deflateInit_ (z_streamp strm, int level,
-                                     const char *version, int stream_size);
-extern int zlib_inflateInit_ (z_streamp strm,
-                                     const char *version, int stream_size);
-extern int zlib_deflateInit2_ (z_streamp strm, int  level, int  method,
-                                      int windowBits, int memLevel,
-                                      int strategy, const char *version,
-                                      int stream_size);
-extern int zlib_inflateInit2_ (z_streamp strm, int  windowBits,
-                                      const char *version, int stream_size);
 #define zlib_deflateInit(strm, level) \
-        zlib_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
+       zlib_deflateInit2((strm), (level), Z_DEFLATED, MAX_WBITS, \
+                             DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY)
 #define zlib_inflateInit(strm) \
-        zlib_inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
-#define zlib_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
-        zlib_deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
-                      (strategy), ZLIB_VERSION, sizeof(z_stream))
-#define zlib_inflateInit2(strm, windowBits) \
-        zlib_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+       zlib_inflateInit2((strm), DEF_WBITS)
 
+extern int zlib_deflateInit2(z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy);
+extern int zlib_inflateInit2(z_streamp strm, int  windowBits);
 
 #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
     struct internal_state {int dummy;}; /* hack for buggy compilers */
 #endif
 
-extern const char  * zlib_zError           (int err);
-#if 0
-extern int           zlib_inflateSyncPoint (z_streamp z);
-#endif
-extern const uLong * zlib_get_crc_table    (void);
-
 #endif /* _ZLIB_H */
index ee0c59cf2136d5c3dfc7c812bb76e1866f1c7eec..6adfa9a6ffe963dd89dcf895f65c576d1c7a7c97 100644 (file)
@@ -23,18 +23,6 @@ typedef unsigned long  ulg;
 
         /* common constants */
 
-#ifndef DEF_WBITS
-#  define DEF_WBITS MAX_WBITS
-#endif
-/* default windowBits for decompression. MAX_WBITS is for compression only */
-
-#if MAX_MEM_LEVEL >= 8
-#  define DEF_MEM_LEVEL 8
-#else
-#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#endif
-/* default memLevel */
-
 #define STORED_BLOCK 0
 #define STATIC_TREES 1
 #define DYN_TREES    2
index b45a7371274806f2c058bc7a43cb7c59a3e82124..446afc3ea27fab8b506e7f2c274311ecc0bd6c67 100644 (file)
 #define AC97_HAS_NO_MIC        (1<<15) /* no MIC volume */
 #define AC97_HAS_NO_TONE       (1<<16) /* no Tone volume */
 #define AC97_HAS_NO_STD_PCM    (1<<17) /* no standard AC97 PCM volume and mute */
+#define AC97_HAS_NO_AUX                (1<<18) /* no standard AC97 AUX volume and mute */
 
 /* rates indexes */
 #define AC97_RATES_FRONT_DAC   0
index 6691e4aa4ea7f527ca4e2074a842929b06905ed3..3f2f4042a20dddeec4b11aea909e0a2d4df94e69 100644 (file)
@@ -605,6 +605,10 @@ struct snd_seq_remove_events {
 #define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11)      /* Sampling device (support sample download) */
 #define SNDRV_SEQ_PORT_TYPE_SAMPLE     (1<<12) /* Sampling device (sample can be downloaded at any time) */
 /*...*/
+#define SNDRV_SEQ_PORT_TYPE_HARDWARE   (1<<16) /* driver for a hardware device */
+#define SNDRV_SEQ_PORT_TYPE_SOFTWARE   (1<<17) /* implemented in software */
+#define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER        (1<<18) /* generates sound */
+#define SNDRV_SEQ_PORT_TYPE_PORT       (1<<19) /* connects to other device(s) */
 #define SNDRV_SEQ_PORT_TYPE_APPLICATION        (1<<20) /* application (sequencer/editor) */
 
 /* misc. conditioning flags */
index 9cc021c7ee118e6a110163ffb35121afb8fa55f5..41885f48ad915d36c2dbed39b8c14a98283a2ba6 100644 (file)
@@ -137,7 +137,7 @@ enum {
  *                                                                           *
  *****************************************************************************/
 
-#define SNDRV_PCM_VERSION              SNDRV_PROTOCOL_VERSION(2, 0, 7)
+#define SNDRV_PCM_VERSION              SNDRV_PROTOCOL_VERSION(2, 0, 8)
 
 typedef unsigned long snd_pcm_uframes_t;
 typedef signed long snd_pcm_sframes_t;
index 5135147f20e89db0413eff0c1ee99dea305af0be..5d184be0ff728d5a0ce7b47d525d9594179d23f5 100644 (file)
@@ -233,9 +233,8 @@ int copy_from_user_toio(volatile void __iomem *dst, const void __user *src, size
 
 /* init.c */
 
-extern unsigned int snd_cards_lock;
 extern struct snd_card *snd_cards[SNDRV_CARDS];
-extern rwlock_t snd_card_rwlock;
+int snd_card_locked(int card);
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
 #define SND_MIXER_OSS_NOTIFY_REGISTER  0
 #define SND_MIXER_OSS_NOTIFY_DISCONNECT        1
index 186e00ad9e79fe8a92f0bc7eba9c6965ae74440f..884bbf54cd36115610c3604aefb26397ed6f30f2 100644 (file)
 #define A_IOCFG_GPOUT0         0x0044          /* analog/digital                               */
 #define A_IOCFG_DISABLE_ANALOG 0x0040          /* = 'enable' for Audigy2 (chiprev=4)           */
 #define A_IOCFG_ENABLE_DIGITAL 0x0004
+#define A_IOCFG_ENABLE_DIGITAL_AUDIGY4 0x0080
 #define A_IOCFG_UNKNOWN_20      0x0020
 #define A_IOCFG_DISABLE_AC97_FRONT      0x0080  /* turn off ac97 front -> front (10k2.1)       */
 #define A_IOCFG_GPOUT1         0x0002          /* IR? drive's internal bypass (?)              */
@@ -1065,6 +1066,7 @@ struct snd_emu_chip_details {
        unsigned char emu1212m;     /* EMU 1212m card */
        unsigned char spi_dac;      /* SPI interface for DAC */
        unsigned char i2c_adc;      /* I2C interface for ADC */
+       unsigned char adc_1361t;    /* Use Philips 1361T ADC */
        const char *driver;
        const char *name;
        const char *id;         /* for backward compatibility - can be NULL if not needed */
index f23d8381c216a0cfc9b9f5b2e1232c677987534d..74f6996769c7db6d706d77a60be3eabf8cec0d25 100644 (file)
@@ -27,9 +27,9 @@
 /* buffer for information */
 struct snd_info_buffer {
        char *buffer;           /* pointer to begin of buffer */
-       char *curr;             /* current position in buffer */
-       unsigned long size;     /* current size */
-       unsigned long len;      /* total length of buffer */
+       unsigned int curr;      /* current position in buffer */
+       unsigned int size;      /* current size */
+       unsigned int len;       /* total length of buffer */
        int stop;               /* stop flag */
        int error;              /* error code */
 };
@@ -40,8 +40,6 @@ struct snd_info_buffer {
 struct snd_info_entry;
 
 struct snd_info_entry_text {
-       unsigned long read_size;
-       unsigned long write_size;
        void (*read) (struct snd_info_entry *entry, struct snd_info_buffer *buffer);
        void (*write) (struct snd_info_entry *entry, struct snd_info_buffer *buffer);
 };
@@ -132,11 +130,9 @@ int snd_card_proc_new(struct snd_card *card, const char *name, struct snd_info_e
 
 static inline void snd_info_set_text_ops(struct snd_info_entry *entry, 
                                         void *private_data,
-                                        long read_size,
                                         void (*read)(struct snd_info_entry *, struct snd_info_buffer *))
 {
        entry->private_data = private_data;
-       entry->c.text.read_size = read_size;
        entry->c.text.read = read;
 }
 
@@ -167,7 +163,6 @@ static inline int snd_card_proc_new(struct snd_card *card, const char *name,
                                    struct snd_info_entry **entryp) { return -EINVAL; }
 static inline void snd_info_set_text_ops(struct snd_info_entry *entry __attribute__((unused)),
                                         void *private_data,
-                                        long read_size,
                                         void (*read)(struct snd_info_entry *, struct snd_info_buffer *)) {}
 
 static inline int snd_info_check_reserved_words(const char *str) { return 1; }
index 8e97ace78f1679b2d62501470cd2cf8439a2c8b2..ac504321ea5625775698a3735f9b5bbf252c418f 100644 (file)
 #define MPU401_HW_PC98II               18      /* Roland PC98II */
 #define MPU401_HW_AUREAL               19      /* Aureal Vortex */
 
+#define MPU401_INFO_INPUT      (1 << 0)        /* input stream */
+#define MPU401_INFO_OUTPUT     (1 << 1)        /* output stream */
+#define MPU401_INFO_INTEGRATED (1 << 2)        /* integrated h/w port */
+#define MPU401_INFO_MMIO       (1 << 3)        /* MMIO access */
+#define MPU401_INFO_TX_IRQ     (1 << 4)        /* independent TX irq */
+
 #define MPU401_MODE_BIT_INPUT          0
 #define MPU401_MODE_BIT_OUTPUT         1
 #define MPU401_MODE_BIT_INPUT_TRIGGER  2
@@ -62,6 +68,7 @@ struct snd_mpu401 {
        struct snd_rawmidi *rmidi;
 
        unsigned short hardware;        /* MPU401_HW_XXXX */
+       unsigned int info_flags;        /* MPU401_INFO_XXX */
        unsigned long port;             /* base port of MPU-401 chip */
        unsigned long cport;            /* port + 1 (usually) */
        struct resource *res;           /* port resource */
@@ -99,13 +106,16 @@ struct snd_mpu401 {
 
  */
 
-irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *regs);
+irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id,
+                                     struct pt_regs *regs);
+irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id,
+                                        struct pt_regs *regs);
 
 int snd_mpu401_uart_new(struct snd_card *card,
                        int device,
                        unsigned short hardware,
                        unsigned long port,
-                       int integrated,
+                       unsigned int info_flags,
                        int irq,
                        int irq_flags,
                        struct snd_rawmidi ** rrawmidi);
index 373425895faa30bd27db93d8d24e40209bcd4ed4..f84d84993a31e83cf9d603f3f3e88c12db9e0411 100644 (file)
@@ -300,7 +300,6 @@ struct snd_pcm_runtime {
        /* -- mmap -- */
        volatile struct snd_pcm_mmap_status *status;
        volatile struct snd_pcm_mmap_control *control;
-       atomic_t mmap_count;
 
        /* -- locking / scheduling -- */
        wait_queue_head_t sleep;
@@ -368,7 +367,9 @@ struct snd_pcm_substream {
        struct snd_pcm_group *group;            /* pointer to current group */
        /* -- assigned files -- */
        void *file;
-       struct file *ffile;
+       int ref_count;
+       atomic_t mmap_count;
+       unsigned int f_flags;
        void (*pcm_release)(struct snd_pcm_substream *);
 #if defined(CONFIG_SND_PCM_OSS) || defined(CONFIG_SND_PCM_OSS_MODULE)
        /* -- OSS things -- */
@@ -387,7 +388,7 @@ struct snd_pcm_substream {
        unsigned int hw_opened: 1;
 };
 
-#define SUBSTREAM_BUSY(substream) ((substream)->file != NULL)
+#define SUBSTREAM_BUSY(substream) ((substream)->ref_count > 0)
 
 
 struct snd_pcm_str {
@@ -825,14 +826,6 @@ int snd_interval_ratnum(struct snd_interval *i,
 
 void _snd_pcm_hw_params_any(struct snd_pcm_hw_params *params);
 void _snd_pcm_hw_param_setempty(struct snd_pcm_hw_params *params, snd_pcm_hw_param_t var);
-int snd_pcm_hw_param_near(struct snd_pcm_substream *substream, 
-                         struct snd_pcm_hw_params *params,
-                         snd_pcm_hw_param_t var, 
-                         unsigned int val, int *dir);
-int snd_pcm_hw_param_set(struct snd_pcm_substream *pcm,
-                        struct snd_pcm_hw_params *params,
-                        snd_pcm_hw_param_t var,
-                        unsigned int val, int dir);
 int snd_pcm_hw_params_choose(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
 
 int snd_pcm_hw_refine(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params);
@@ -979,13 +972,13 @@ struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigne
 static inline void snd_pcm_mmap_data_open(struct vm_area_struct *area)
 {
        struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
-       atomic_inc(&substream->runtime->mmap_count);
+       atomic_inc(&substream->mmap_count);
 }
 
 static inline void snd_pcm_mmap_data_close(struct vm_area_struct *area)
 {
        struct snd_pcm_substream *substream = (struct snd_pcm_substream *)area->vm_private_data;
-       atomic_dec(&substream->runtime->mmap_count);
+       atomic_dec(&substream->mmap_count);
 }
 
 /* mmap for io-memory area */
index fb18aef77341aa3361c136f39eabfe74a9456ad5..85cf1cf4f31a7a202e8e5faa91f992f3aa1a90ef 100644 (file)
  *
  */
 
-extern int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm, struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, const struct snd_mask *val);
-extern unsigned int snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params,
-                                              snd_pcm_hw_param_t var, int *dir);
-extern unsigned int snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
-                                              snd_pcm_hw_param_t var, int *dir);
-extern int _snd_pcm_hw_param_min(struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, unsigned int val, int dir);
-extern int _snd_pcm_hw_param_setinteger(struct snd_pcm_hw_params *params,
-                                       snd_pcm_hw_param_t var);
-extern int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
-                                snd_pcm_hw_param_t var, unsigned int val, int dir);
-
-/* To share the same code we have  alsa-lib */
-#define INLINE static inline
-#define assert(a) (void)(a)
+int snd_pcm_hw_param_first(struct snd_pcm_substream *pcm, 
+                          struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir);
+int snd_pcm_hw_param_last(struct snd_pcm_substream *pcm, 
+                         struct snd_pcm_hw_params *params,
+                         snd_pcm_hw_param_t var, int *dir);
+int snd_pcm_hw_param_value(const struct snd_pcm_hw_params *params,
+                          snd_pcm_hw_param_t var, int *dir);
 
 #define SNDRV_MASK_BITS        64      /* we use so far 64bits only */
 #define SNDRV_MASK_SIZE        (SNDRV_MASK_BITS / 32)
 #define MASK_OFS(i)    ((i) >> 5)
 #define MASK_BIT(i)    (1U << ((i) & 31))
 
-INLINE unsigned int ld2(u_int32_t v)
+static inline unsigned int ld2(u_int32_t v)
 {
         unsigned r = 0;
 
@@ -69,22 +61,22 @@ INLINE unsigned int ld2(u_int32_t v)
         return r;
 }
 
-INLINE size_t snd_mask_sizeof(void)
+static inline size_t snd_mask_sizeof(void)
 {
        return sizeof(struct snd_mask);
 }
 
-INLINE void snd_mask_none(struct snd_mask *mask)
+static inline void snd_mask_none(struct snd_mask *mask)
 {
        memset(mask, 0, sizeof(*mask));
 }
 
-INLINE void snd_mask_any(struct snd_mask *mask)
+static inline void snd_mask_any(struct snd_mask *mask)
 {
        memset(mask, 0xff, SNDRV_MASK_SIZE * sizeof(u_int32_t));
 }
 
-INLINE int snd_mask_empty(const struct snd_mask *mask)
+static inline int snd_mask_empty(const struct snd_mask *mask)
 {
        int i;
        for (i = 0; i < SNDRV_MASK_SIZE; i++)
@@ -93,10 +85,9 @@ INLINE int snd_mask_empty(const struct snd_mask *mask)
        return 1;
 }
 
-INLINE unsigned int snd_mask_min(const struct snd_mask *mask)
+static inline unsigned int snd_mask_min(const struct snd_mask *mask)
 {
        int i;
-       assert(!snd_mask_empty(mask));
        for (i = 0; i < SNDRV_MASK_SIZE; i++) {
                if (mask->bits[i])
                        return ffs(mask->bits[i]) - 1 + (i << 5);
@@ -104,10 +95,9 @@ INLINE unsigned int snd_mask_min(const struct snd_mask *mask)
        return 0;
 }
 
-INLINE unsigned int snd_mask_max(const struct snd_mask *mask)
+static inline unsigned int snd_mask_max(const struct snd_mask *mask)
 {
        int i;
-       assert(!snd_mask_empty(mask));
        for (i = SNDRV_MASK_SIZE - 1; i >= 0; i--) {
                if (mask->bits[i])
                        return ld2(mask->bits[i]) + (i << 5);
@@ -115,70 +105,68 @@ INLINE unsigned int snd_mask_max(const struct snd_mask *mask)
        return 0;
 }
 
-INLINE void snd_mask_set(struct snd_mask *mask, unsigned int val)
+static inline void snd_mask_set(struct snd_mask *mask, unsigned int val)
 {
-       assert(val <= SNDRV_MASK_BITS);
        mask->bits[MASK_OFS(val)] |= MASK_BIT(val);
 }
 
-INLINE void snd_mask_reset(struct snd_mask *mask, unsigned int val)
+static inline void snd_mask_reset(struct snd_mask *mask, unsigned int val)
 {
-       assert(val <= SNDRV_MASK_BITS);
        mask->bits[MASK_OFS(val)] &= ~MASK_BIT(val);
 }
 
-INLINE void snd_mask_set_range(struct snd_mask *mask, unsigned int from, unsigned int to)
+static inline void snd_mask_set_range(struct snd_mask *mask,
+                                     unsigned int from, unsigned int to)
 {
        unsigned int i;
-       assert(to <= SNDRV_MASK_BITS && from <= to);
        for (i = from; i <= to; i++)
                mask->bits[MASK_OFS(i)] |= MASK_BIT(i);
 }
 
-INLINE void snd_mask_reset_range(struct snd_mask *mask, unsigned int from, unsigned int to)
+static inline void snd_mask_reset_range(struct snd_mask *mask,
+                                       unsigned int from, unsigned int to)
 {
        unsigned int i;
-       assert(to <= SNDRV_MASK_BITS && from <= to);
        for (i = from; i <= to; i++)
                mask->bits[MASK_OFS(i)] &= ~MASK_BIT(i);
 }
 
-INLINE void snd_mask_leave(struct snd_mask *mask, unsigned int val)
+static inline void snd_mask_leave(struct snd_mask *mask, unsigned int val)
 {
        unsigned int v;
-       assert(val <= SNDRV_MASK_BITS);
        v = mask->bits[MASK_OFS(val)] & MASK_BIT(val);
        snd_mask_none(mask);
        mask->bits[MASK_OFS(val)] = v;
 }
 
-INLINE void snd_mask_intersect(struct snd_mask *mask, const struct snd_mask *v)
+static inline void snd_mask_intersect(struct snd_mask *mask,
+                                     const struct snd_mask *v)
 {
        int i;
        for (i = 0; i < SNDRV_MASK_SIZE; i++)
                mask->bits[i] &= v->bits[i];
 }
 
-INLINE int snd_mask_eq(const struct snd_mask *mask, const struct snd_mask *v)
+static inline int snd_mask_eq(const struct snd_mask *mask,
+                             const struct snd_mask *v)
 {
        return ! memcmp(mask, v, SNDRV_MASK_SIZE * sizeof(u_int32_t));
 }
 
-INLINE void snd_mask_copy(struct snd_mask *mask, const struct snd_mask *v)
+static inline void snd_mask_copy(struct snd_mask *mask,
+                                const struct snd_mask *v)
 {
        *mask = *v;
 }
 
-INLINE int snd_mask_test(const struct snd_mask *mask, unsigned int val)
+static inline int snd_mask_test(const struct snd_mask *mask, unsigned int val)
 {
-       assert(val <= SNDRV_MASK_BITS);
        return mask->bits[MASK_OFS(val)] & MASK_BIT(val);
 }
 
-INLINE int snd_mask_single(const struct snd_mask *mask)
+static inline int snd_mask_single(const struct snd_mask *mask)
 {
        int i, c = 0;
-       assert(!snd_mask_empty(mask));
        for (i = 0; i < SNDRV_MASK_SIZE; i++) {
                if (! mask->bits[i])
                        continue;
@@ -191,10 +179,10 @@ INLINE int snd_mask_single(const struct snd_mask *mask)
        return 1;
 }
 
-INLINE int snd_mask_refine(struct snd_mask *mask, const struct snd_mask *v)
+static inline int snd_mask_refine(struct snd_mask *mask,
+                                 const struct snd_mask *v)
 {
        struct snd_mask old;
-       assert(!snd_mask_empty(mask));
        snd_mask_copy(&old, mask);
        snd_mask_intersect(mask, v);
        if (snd_mask_empty(mask))
@@ -202,27 +190,24 @@ INLINE int snd_mask_refine(struct snd_mask *mask, const struct snd_mask *v)
        return !snd_mask_eq(mask, &old);
 }
 
-INLINE int snd_mask_refine_first(struct snd_mask *mask)
+static inline int snd_mask_refine_first(struct snd_mask *mask)
 {
-       assert(!snd_mask_empty(mask));
        if (snd_mask_single(mask))
                return 0;
        snd_mask_leave(mask, snd_mask_min(mask));
        return 1;
 }
 
-INLINE int snd_mask_refine_last(struct snd_mask *mask)
+static inline int snd_mask_refine_last(struct snd_mask *mask)
 {
-       assert(!snd_mask_empty(mask));
        if (snd_mask_single(mask))
                return 0;
        snd_mask_leave(mask, snd_mask_max(mask));
        return 1;
 }
 
-INLINE int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
+static inline int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
 {
-       assert(!snd_mask_empty(mask));
        if (snd_mask_min(mask) >= val)
                return 0;
        snd_mask_reset_range(mask, 0, val - 1);
@@ -231,9 +216,8 @@ INLINE int snd_mask_refine_min(struct snd_mask *mask, unsigned int val)
        return 1;
 }
 
-INLINE int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
+static inline int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
 {
-       assert(!snd_mask_empty(mask));
        if (snd_mask_max(mask) <= val)
                return 0;
        snd_mask_reset_range(mask, val + 1, SNDRV_MASK_BITS);
@@ -242,10 +226,9 @@ INLINE int snd_mask_refine_max(struct snd_mask *mask, unsigned int val)
        return 1;
 }
 
-INLINE int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
+static inline int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
 {
        int changed;
-       assert(!snd_mask_empty(mask));
        changed = !snd_mask_single(mask);
        snd_mask_leave(mask, val);
        if (snd_mask_empty(mask))
@@ -253,13 +236,12 @@ INLINE int snd_mask_refine_set(struct snd_mask *mask, unsigned int val)
        return changed;
 }
 
-INLINE int snd_mask_value(const struct snd_mask *mask)
+static inline int snd_mask_value(const struct snd_mask *mask)
 {
-       assert(!snd_mask_empty(mask));
        return snd_mask_min(mask);
 }
 
-INLINE void snd_interval_any(struct snd_interval *i)
+static inline void snd_interval_any(struct snd_interval *i)
 {
        i->min = 0;
        i->openmin = 0;
@@ -269,63 +251,59 @@ INLINE void snd_interval_any(struct snd_interval *i)
        i->empty = 0;
 }
 
-INLINE void snd_interval_none(struct snd_interval *i)
+static inline void snd_interval_none(struct snd_interval *i)
 {
        i->empty = 1;
 }
 
-INLINE int snd_interval_checkempty(const struct snd_interval *i)
+static inline int snd_interval_checkempty(const struct snd_interval *i)
 {
        return (i->min > i->max ||
                (i->min == i->max && (i->openmin || i->openmax)));
 }
 
-INLINE int snd_interval_empty(const struct snd_interval *i)
+static inline int snd_interval_empty(const struct snd_interval *i)
 {
        return i->empty;
 }
 
-INLINE int snd_interval_single(const struct snd_interval *i)
+static inline int snd_interval_single(const struct snd_interval *i)
 {
-       assert(!snd_interval_empty(i));
        return (i->min == i->max || 
                (i->min + 1 == i->max && i->openmax));
 }
 
-INLINE int snd_interval_value(const struct snd_interval *i)
+static inline int snd_interval_value(const struct snd_interval *i)
 {
-       assert(snd_interval_single(i));
        return i->min;
 }
 
-INLINE int snd_interval_min(const struct snd_interval *i)
+static inline int snd_interval_min(const struct snd_interval *i)
 {
-       assert(!snd_interval_empty(i));
        return i->min;
 }
 
-INLINE int snd_interval_max(const struct snd_interval *i)
+static inline int snd_interval_max(const struct snd_interval *i)
 {
        unsigned int v;
-       assert(!snd_interval_empty(i));
        v = i->max;
        if (i->openmax)
                v--;
        return v;
 }
 
-INLINE int snd_interval_test(const struct snd_interval *i, unsigned int val)
+static inline int snd_interval_test(const struct snd_interval *i, unsigned int val)
 {
        return !((i->min > val || (i->min == val && i->openmin) ||
                  i->max < val || (i->max == val && i->openmax)));
 }
 
-INLINE void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
+static inline void snd_interval_copy(struct snd_interval *d, const struct snd_interval *s)
 {
        *d = *s;
 }
 
-INLINE int snd_interval_setinteger(struct snd_interval *i)
+static inline int snd_interval_setinteger(struct snd_interval *i)
 {
        if (i->integer)
                return 0;
@@ -335,7 +313,7 @@ INLINE int snd_interval_setinteger(struct snd_interval *i)
        return 1;
 }
 
-INLINE int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
+static inline int snd_interval_eq(const struct snd_interval *i1, const struct snd_interval *i2)
 {
        if (i1->empty)
                return i2->empty;
@@ -359,8 +337,5 @@ static inline unsigned int sub(unsigned int a, unsigned int b)
        return 0;
 }
 
-#undef INLINE
-#undef assert
-
 #endif /* __SOUND_PCM_PARAMS_H */
 
index 584e73dd479319ea5034282ab107aa9d36e4a621..7dbcd10fa215d00f4f53ea37e8838046fc4b0831 100644 (file)
@@ -46,6 +46,7 @@
 
 struct snd_rawmidi;
 struct snd_rawmidi_substream;
+struct snd_seq_port_info;
 
 struct snd_rawmidi_ops {
        int (*open) (struct snd_rawmidi_substream * substream);
@@ -57,6 +58,8 @@ struct snd_rawmidi_ops {
 struct snd_rawmidi_global_ops {
        int (*dev_register) (struct snd_rawmidi * rmidi);
        int (*dev_unregister) (struct snd_rawmidi * rmidi);
+       void (*get_port_info)(struct snd_rawmidi *rmidi, int number,
+                             struct snd_seq_port_info *info);
 };
 
 struct snd_rawmidi_runtime {
index 4f0e65808cf1a29e39757244ce15509b756e39b0..2ee849d0e198dc20c4afb1b5e26d203272de2e20 100644 (file)
@@ -1,3 +1,3 @@
 /* include/version.h.  Generated by configure.  */
-#define CONFIG_SND_VERSION "1.0.11rc4"
-#define CONFIG_SND_DATE " (Wed Mar 22 10:27:24 2006 UTC)"
+#define CONFIG_SND_VERSION "1.0.12rc1"
+#define CONFIG_SND_DATE " (Thu Jun 22 13:55:50 2006 UTC)"
index 0a907f0dc56b3bc0f67e189ded38f64e8ad94ebb..cdf0f07af92f91dc58b1a441dcb66ff035b77db4 100644 (file)
@@ -15,7 +15,7 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/pm.h>
-
+#include <linux/console.h>
 
 #include "power.h"
 
index 0b6ec0e7936f02ebb92477dd12951169a2bc7218..fc9ebbbaba0c4f16d4eceb34269e7b782988a125 100644 (file)