Subversion Repositories test_project

/*

 * Header for Microchannel Architecture Bus

 * Written by Martin Kolinek, February 1996

 */

#ifndef _LINUX_MCA_H

#define _LINUX_MCA_H

#include <linux/device.h>

#ifdef CONFIG_MCA

#include <asm/mca.h>

extern int MCA_bus;

#else

#define MCA_bus 0

#endif

/* This sets up an information callback for /proc/mca/slot?.  The

 * function is called with the buffer, slot, and device pointer (or

 * some equally informative context information, or nothing, if you

 * prefer), and is expected to put useful information into the

 * buffer.  The adapter name, id, and POS registers get printed

 * before this is called though, so don't do it again.

 *

 * This should be called with a NULL procfn when a module

 * unregisters, thus preventing kernel crashes and other such

 * nastiness.

 */

typedef int (*MCA_ProcFn)(char* buf, int slot, void* dev);

/* Should only be called by the NMI interrupt handler, this will do some

 * fancy stuff to figure out what might have generated a NMI.

 */

extern void mca_handle_nmi(void);

enum MCA_AdapterStatus {

        MCA_ADAPTER_NORMAL = 0,

        MCA_ADAPTER_NONE = 1,

        MCA_ADAPTER_DISABLED = 2,

        MCA_ADAPTER_ERROR = 3

};

struct mca_device {

        u64                     dma_mask;

        int                     pos_id;

        int                     slot;

        /* index into id_table, set by the bus match routine */

        int                     index;

        /* is there a driver installed? 0 - No, 1 - Yes */

        int                     driver_loaded;

        /* POS registers */

        unsigned char           pos[8];

        /* if a pseudo adapter of the motherboard, this is the motherboard

         * register value to use for setup cycles */

        short                   pos_register;

        enum MCA_AdapterStatus  status;

#ifdef CONFIG_MCA_PROC_FS

        /* name of the proc/mca file */

        char                    procname[8];

        /* /proc info callback */

        MCA_ProcFn              procfn;

        /* device/context info for proc callback */

        void                    *proc_dev;

#endif

        struct device           dev;

        char                    name[32];

};

#define to_mca_device(mdev) container_of(mdev, struct mca_device, dev)

struct mca_bus_accessor_functions {

        unsigned char   (*mca_read_pos)(struct mca_device *, int reg);

        void            (*mca_write_pos)(struct mca_device *, int reg,

                                         unsigned char byte);

        int             (*mca_transform_irq)(struct mca_device *, int irq);

        int             (*mca_transform_ioport)(struct mca_device *,

                                                  int region);

        void *          (*mca_transform_memory)(struct mca_device *,

                                                void *memory);

};

struct mca_bus {

        u64                     default_dma_mask;

        int                     number;

        struct mca_bus_accessor_functions f;

        struct device           dev;

        char                    name[32];

};

#define to_mca_bus(mdev) container_of(mdev, struct mca_bus, dev)

struct mca_driver {

        const short             *id_table;

        void                    *driver_data;

        int                     integrated_id;

        struct device_driver    driver;

};

#define to_mca_driver(mdriver) container_of(mdriver, struct mca_driver, driver)

/* Ongoing supported API functions */

extern struct mca_device *mca_find_device_by_slot(int slot);

extern int mca_system_init(void);

extern struct mca_bus *mca_attach_bus(int);

extern unsigned char mca_device_read_stored_pos(struct mca_device *mca_dev,

                                                int reg);

extern unsigned char mca_device_read_pos(struct mca_device *mca_dev, int reg);

extern void mca_device_write_pos(struct mca_device *mca_dev, int reg,

                                 unsigned char byte);

extern int mca_device_transform_irq(struct mca_device *mca_dev, int irq);

extern int mca_device_transform_ioport(struct mca_device *mca_dev, int port);

extern void *mca_device_transform_memory(struct mca_device *mca_dev,

                                         void *mem);

extern int mca_device_claimed(struct mca_device *mca_dev);

extern void mca_device_set_claim(struct mca_device *mca_dev, int val);

extern void mca_device_set_name(struct mca_device *mca_dev, const char *name);

static inline char *mca_device_get_name(struct mca_device *mca_dev)

{

        return mca_dev ? mca_dev->name : NULL;

}

extern enum MCA_AdapterStatus mca_device_status(struct mca_device *mca_dev);

extern struct bus_type mca_bus_type;

extern int mca_register_driver(struct mca_driver *drv);

extern int mca_register_driver_integrated(struct mca_driver *, int);

extern void mca_unregister_driver(struct mca_driver *drv);

/* WARNING: only called by the boot time device setup */

extern int mca_register_device(int bus, struct mca_device *mca_dev);

#ifdef CONFIG_MCA_PROC_FS

extern void mca_do_proc_init(void);

extern void mca_set_adapter_procfn(int slot, MCA_ProcFn, void* dev);

#else

static inline void mca_do_proc_init(void)

{

}

static inline void mca_set_adapter_procfn(int slot, MCA_ProcFn fn, void* dev)

{

}

#endif

#endif /* _LINUX_MCA_H */