2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* ioport.h Definitions of routines for detecting, reserving and
|
|
|
|
* allocating system resources.
|
|
|
|
*
|
|
|
|
* Authors: Linus Torvalds
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _LINUX_IOPORT_H
|
|
|
|
#define _LINUX_IOPORT_H
|
|
|
|
|
2008-01-30 05:30:32 -07:00
|
|
|
#ifndef __ASSEMBLY__
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/compiler.h>
|
2006-06-12 16:49:31 -06:00
|
|
|
#include <linux/types.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Resources are tree-like, allowing
|
|
|
|
* nesting etc..
|
|
|
|
*/
|
|
|
|
struct resource {
|
2006-06-12 16:49:31 -06:00
|
|
|
resource_size_t start;
|
|
|
|
resource_size_t end;
|
2005-04-16 16:20:36 -06:00
|
|
|
const char *name;
|
|
|
|
unsigned long flags;
|
|
|
|
struct resource *parent, *sibling, *child;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct resource_list {
|
|
|
|
struct resource_list *next;
|
|
|
|
struct resource *res;
|
|
|
|
struct pci_dev *dev;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IO resources have these defined flags.
|
|
|
|
*/
|
|
|
|
#define IORESOURCE_BITS 0x000000ff /* Bus-specific bits */
|
|
|
|
|
2008-10-15 23:05:15 -06:00
|
|
|
#define IORESOURCE_TYPE_BITS 0x00000f00 /* Resource type */
|
|
|
|
#define IORESOURCE_IO 0x00000100
|
2005-04-16 16:20:36 -06:00
|
|
|
#define IORESOURCE_MEM 0x00000200
|
|
|
|
#define IORESOURCE_IRQ 0x00000400
|
|
|
|
#define IORESOURCE_DMA 0x00000800
|
|
|
|
|
|
|
|
#define IORESOURCE_PREFETCH 0x00001000 /* No side effects */
|
|
|
|
#define IORESOURCE_READONLY 0x00002000
|
|
|
|
#define IORESOURCE_CACHEABLE 0x00004000
|
|
|
|
#define IORESOURCE_RANGELENGTH 0x00008000
|
|
|
|
#define IORESOURCE_SHADOWABLE 0x00010000
|
PCI: clean up resource alignment management
Done per Linus' request and suggestions. Linus has explained that
better than I'll be able to explain:
On Thu, Mar 27, 2008 at 10:12:10AM -0700, Linus Torvalds wrote:
> Actually, before we go any further, there might be a less intrusive
> alternative: add just a couple of flags to the resource flags field (we
> still have something like 8 unused bits on 32-bit), and use those to
> implement a generic "resource_alignment()" routine.
>
> Two flags would do it:
>
> - IORESOURCE_SIZEALIGN: size indicates alignment (regular PCI device
> resources)
>
> - IORESOURCE_STARTALIGN: start field is alignment (PCI bus resources
> during probing)
>
> and then the case of both flags zero (or both bits set) would actually be
> "invalid", and we would also clear the IORESOURCE_STARTALIGN flag when we
> actually allocate the resource (so that we don't use the "start" field as
> alignment incorrectly when it no longer indicates alignment).
>
> That wouldn't be totally generic, but it would have the nice property of
> automatically at least add sanity checking for that whole "res->start has
> the odd meaning of 'alignment' during probing" and remove the need for a
> new field, and it would allow us to have a generic "resource_alignment()"
> routine that just gets a resource pointer.
Besides, I removed IORESOURCE_BUS_HAS_VGA flag which was unused for ages.
Signed-off-by: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Gary Hade <garyhade@us.ibm.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-03-30 09:50:14 -06:00
|
|
|
|
|
|
|
#define IORESOURCE_SIZEALIGN 0x00020000 /* size indicates alignment */
|
|
|
|
#define IORESOURCE_STARTALIGN 0x00040000 /* start field is alignment */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-23 21:48:32 -06:00
|
|
|
#define IORESOURCE_MEM_64 0x00100000
|
|
|
|
|
2008-10-22 20:55:31 -06:00
|
|
|
#define IORESOURCE_EXCLUSIVE 0x08000000 /* Userland may not map this resource */
|
2005-04-16 16:20:36 -06:00
|
|
|
#define IORESOURCE_DISABLED 0x10000000
|
|
|
|
#define IORESOURCE_UNSET 0x20000000
|
|
|
|
#define IORESOURCE_AUTO 0x40000000
|
|
|
|
#define IORESOURCE_BUSY 0x80000000 /* Driver has marked this resource busy */
|
|
|
|
|
2008-06-09 17:52:04 -06:00
|
|
|
/* PnP IRQ specific bits (IORESOURCE_BITS) */
|
2005-04-16 16:20:36 -06:00
|
|
|
#define IORESOURCE_IRQ_HIGHEDGE (1<<0)
|
|
|
|
#define IORESOURCE_IRQ_LOWEDGE (1<<1)
|
|
|
|
#define IORESOURCE_IRQ_HIGHLEVEL (1<<2)
|
|
|
|
#define IORESOURCE_IRQ_LOWLEVEL (1<<3)
|
2006-07-03 01:24:10 -06:00
|
|
|
#define IORESOURCE_IRQ_SHAREABLE (1<<4)
|
2008-06-27 16:57:14 -06:00
|
|
|
#define IORESOURCE_IRQ_OPTIONAL (1<<5)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-09 17:52:04 -06:00
|
|
|
/* PnP DMA specific bits (IORESOURCE_BITS) */
|
2005-04-16 16:20:36 -06:00
|
|
|
#define IORESOURCE_DMA_TYPE_MASK (3<<0)
|
|
|
|
#define IORESOURCE_DMA_8BIT (0<<0)
|
|
|
|
#define IORESOURCE_DMA_8AND16BIT (1<<0)
|
|
|
|
#define IORESOURCE_DMA_16BIT (2<<0)
|
|
|
|
|
|
|
|
#define IORESOURCE_DMA_MASTER (1<<2)
|
|
|
|
#define IORESOURCE_DMA_BYTE (1<<3)
|
|
|
|
#define IORESOURCE_DMA_WORD (1<<4)
|
|
|
|
|
|
|
|
#define IORESOURCE_DMA_SPEED_MASK (3<<6)
|
|
|
|
#define IORESOURCE_DMA_COMPATIBLE (0<<6)
|
|
|
|
#define IORESOURCE_DMA_TYPEA (1<<6)
|
|
|
|
#define IORESOURCE_DMA_TYPEB (2<<6)
|
|
|
|
#define IORESOURCE_DMA_TYPEF (3<<6)
|
|
|
|
|
2008-06-09 17:52:04 -06:00
|
|
|
/* PnP memory I/O specific bits (IORESOURCE_BITS) */
|
2005-04-16 16:20:36 -06:00
|
|
|
#define IORESOURCE_MEM_WRITEABLE (1<<0) /* dup: IORESOURCE_READONLY */
|
|
|
|
#define IORESOURCE_MEM_CACHEABLE (1<<1) /* dup: IORESOURCE_CACHEABLE */
|
|
|
|
#define IORESOURCE_MEM_RANGELENGTH (1<<2) /* dup: IORESOURCE_RANGELENGTH */
|
|
|
|
#define IORESOURCE_MEM_TYPE_MASK (3<<3)
|
|
|
|
#define IORESOURCE_MEM_8BIT (0<<3)
|
|
|
|
#define IORESOURCE_MEM_16BIT (1<<3)
|
|
|
|
#define IORESOURCE_MEM_8AND16BIT (2<<3)
|
|
|
|
#define IORESOURCE_MEM_32BIT (3<<3)
|
|
|
|
#define IORESOURCE_MEM_SHADOWABLE (1<<5) /* dup: IORESOURCE_SHADOWABLE */
|
|
|
|
#define IORESOURCE_MEM_EXPANSIONROM (1<<6)
|
|
|
|
|
2008-06-27 16:57:03 -06:00
|
|
|
/* PnP I/O specific bits (IORESOURCE_BITS) */
|
|
|
|
#define IORESOURCE_IO_16BIT_ADDR (1<<0)
|
|
|
|
#define IORESOURCE_IO_FIXED (1<<1)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* PCI ROM control bits (IORESOURCE_BITS) */
|
|
|
|
#define IORESOURCE_ROM_ENABLE (1<<0) /* ROM is enabled, same as PCI_ROM_ADDRESS_ENABLE */
|
|
|
|
#define IORESOURCE_ROM_SHADOW (1<<1) /* ROM is copy at C000:0 */
|
|
|
|
#define IORESOURCE_ROM_COPY (1<<2) /* ROM is alloc'd copy, resource field overlaid */
|
2006-10-04 15:49:52 -06:00
|
|
|
#define IORESOURCE_ROM_BIOS_COPY (1<<3) /* ROM is BIOS copy, resource field overlaid */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-19 14:12:08 -07:00
|
|
|
/* PCI control bits. Shares IORESOURCE_BITS with above PCI ROM. */
|
|
|
|
#define IORESOURCE_PCI_FIXED (1<<4) /* Do not move resource */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* PC/ISA/whatever - the normal PC address spaces: IO and memory */
|
|
|
|
extern struct resource ioport_resource;
|
|
|
|
extern struct resource iomem_resource;
|
|
|
|
|
|
|
|
extern int request_resource(struct resource *root, struct resource *new);
|
|
|
|
extern int release_resource(struct resource *new);
|
2008-09-04 13:02:44 -06:00
|
|
|
extern void reserve_region_with_split(struct resource *root,
|
|
|
|
resource_size_t start, resource_size_t end,
|
|
|
|
const char *name);
|
2006-06-30 03:15:42 -06:00
|
|
|
extern int insert_resource(struct resource *parent, struct resource *new);
|
2008-08-29 21:18:31 -06:00
|
|
|
extern void insert_resource_expand_to_fit(struct resource *root, struct resource *new);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern int allocate_resource(struct resource *root, struct resource *new,
|
2006-06-12 17:09:23 -06:00
|
|
|
resource_size_t size, resource_size_t min,
|
|
|
|
resource_size_t max, resource_size_t align,
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*alignf)(void *, struct resource *,
|
2006-06-12 17:09:23 -06:00
|
|
|
resource_size_t, resource_size_t),
|
2005-04-16 16:20:36 -06:00
|
|
|
void *alignf_data);
|
2006-06-12 17:09:23 -06:00
|
|
|
int adjust_resource(struct resource *res, resource_size_t start,
|
|
|
|
resource_size_t size);
|
PCI: clean up resource alignment management
Done per Linus' request and suggestions. Linus has explained that
better than I'll be able to explain:
On Thu, Mar 27, 2008 at 10:12:10AM -0700, Linus Torvalds wrote:
> Actually, before we go any further, there might be a less intrusive
> alternative: add just a couple of flags to the resource flags field (we
> still have something like 8 unused bits on 32-bit), and use those to
> implement a generic "resource_alignment()" routine.
>
> Two flags would do it:
>
> - IORESOURCE_SIZEALIGN: size indicates alignment (regular PCI device
> resources)
>
> - IORESOURCE_STARTALIGN: start field is alignment (PCI bus resources
> during probing)
>
> and then the case of both flags zero (or both bits set) would actually be
> "invalid", and we would also clear the IORESOURCE_STARTALIGN flag when we
> actually allocate the resource (so that we don't use the "start" field as
> alignment incorrectly when it no longer indicates alignment).
>
> That wouldn't be totally generic, but it would have the nice property of
> automatically at least add sanity checking for that whole "res->start has
> the odd meaning of 'alignment' during probing" and remove the need for a
> new field, and it would allow us to have a generic "resource_alignment()"
> routine that just gets a resource pointer.
Besides, I removed IORESOURCE_BUS_HAS_VGA flag which was unused for ages.
Signed-off-by: Ivan Kokshaysky <ink@jurassic.park.msu.ru>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Gary Hade <garyhade@us.ibm.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2008-03-30 09:50:14 -06:00
|
|
|
resource_size_t resource_alignment(struct resource *res);
|
2009-12-15 17:48:21 -07:00
|
|
|
static inline resource_size_t resource_size(const struct resource *res)
|
2008-07-29 23:32:57 -06:00
|
|
|
{
|
|
|
|
return res->end - res->start + 1;
|
|
|
|
}
|
2009-12-15 17:48:21 -07:00
|
|
|
static inline unsigned long resource_type(const struct resource *res)
|
2008-10-15 23:05:15 -06:00
|
|
|
{
|
|
|
|
return res->flags & IORESOURCE_TYPE_BITS;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Convenience shorthand with allocation */
|
2008-10-22 20:55:31 -06:00
|
|
|
#define request_region(start,n,name) __request_region(&ioport_resource, (start), (n), (name), 0)
|
|
|
|
#define __request_mem_region(start,n,name, excl) __request_region(&iomem_resource, (start), (n), (name), excl)
|
|
|
|
#define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name), 0)
|
|
|
|
#define request_mem_region_exclusive(start,n,name) \
|
|
|
|
__request_region(&iomem_resource, (start), (n), (name), IORESOURCE_EXCLUSIVE)
|
2005-04-16 16:20:36 -06:00
|
|
|
#define rename_region(region, newname) do { (region)->name = (newname); } while (0)
|
|
|
|
|
2006-06-12 17:09:23 -06:00
|
|
|
extern struct resource * __request_region(struct resource *,
|
|
|
|
resource_size_t start,
|
2009-01-15 14:51:01 -07:00
|
|
|
resource_size_t n,
|
|
|
|
const char *name, int flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Compatibility cruft */
|
|
|
|
#define release_region(start,n) __release_region(&ioport_resource, (start), (n))
|
|
|
|
#define check_mem_region(start,n) __check_region(&iomem_resource, (start), (n))
|
|
|
|
#define release_mem_region(start,n) __release_region(&iomem_resource, (start), (n))
|
|
|
|
|
2006-06-12 17:09:23 -06:00
|
|
|
extern int __check_region(struct resource *, resource_size_t, resource_size_t);
|
|
|
|
extern void __release_region(struct resource *, resource_size_t,
|
|
|
|
resource_size_t);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-12 17:09:23 -06:00
|
|
|
static inline int __deprecated check_region(resource_size_t s,
|
|
|
|
resource_size_t n)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return __check_region(&ioport_resource, s, n);
|
|
|
|
}
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 00:00:26 -07:00
|
|
|
|
|
|
|
/* Wrappers for managed devices */
|
|
|
|
struct device;
|
|
|
|
#define devm_request_region(dev,start,n,name) \
|
|
|
|
__devm_request_region(dev, &ioport_resource, (start), (n), (name))
|
|
|
|
#define devm_request_mem_region(dev,start,n,name) \
|
|
|
|
__devm_request_region(dev, &iomem_resource, (start), (n), (name))
|
|
|
|
|
|
|
|
extern struct resource * __devm_request_region(struct device *dev,
|
|
|
|
struct resource *parent, resource_size_t start,
|
|
|
|
resource_size_t n, const char *name);
|
|
|
|
|
2008-09-13 03:33:07 -06:00
|
|
|
#define devm_release_region(dev, start, n) \
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 00:00:26 -07:00
|
|
|
__devm_release_region(dev, &ioport_resource, (start), (n))
|
2008-09-13 03:33:07 -06:00
|
|
|
#define devm_release_mem_region(dev, start, n) \
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 00:00:26 -07:00
|
|
|
__devm_release_region(dev, &iomem_resource, (start), (n))
|
|
|
|
|
|
|
|
extern void __devm_release_region(struct device *dev, struct resource *parent,
|
|
|
|
resource_size_t start, resource_size_t n);
|
2008-09-25 19:43:34 -06:00
|
|
|
extern int iomem_map_sanity_check(resource_size_t addr, unsigned long size);
|
2008-10-22 20:55:31 -06:00
|
|
|
extern int iomem_is_exclusive(u64 addr);
|
devres: device resource management
Implement device resource management, in short, devres. A device
driver can allocate arbirary size of devres data which is associated
with a release function. On driver detach, release function is
invoked on the devres data, then, devres data is freed.
devreses are typed by associated release functions. Some devreses are
better represented by single instance of the type while others need
multiple instances sharing the same release function. Both usages are
supported.
devreses can be grouped using devres group such that a device driver
can easily release acquired resources halfway through initialization
or selectively release resources (e.g. resources for port 1 out of 4
ports).
This patch adds devres core including documentation and the following
managed interfaces.
* alloc/free : devm_kzalloc(), devm_kzfree()
* IO region : devm_request_region(), devm_release_region()
* IRQ : devm_request_irq(), devm_free_irq()
* DMA : dmam_alloc_coherent(), dmam_free_coherent(),
dmam_declare_coherent_memory(), dmam_pool_create(),
dmam_pool_destroy()
* PCI : pcim_enable_device(), pcim_pin_device(), pci_is_managed()
* iomap : devm_ioport_map(), devm_ioport_unmap(), devm_ioremap(),
devm_ioremap_nocache(), devm_iounmap(), pcim_iomap_table(),
pcim_iomap(), pcim_iounmap()
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-01-20 00:00:26 -07:00
|
|
|
|
2009-09-22 17:45:46 -06:00
|
|
|
extern int
|
|
|
|
walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
|
|
|
|
void *arg, int (*func)(unsigned long, unsigned long, void *));
|
|
|
|
|
2008-01-30 05:30:32 -07:00
|
|
|
#endif /* __ASSEMBLY__ */
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* _LINUX_IOPORT_H */
|