← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to include/linux/zorro.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/linux/zorro.h
 
1
/*
 
2
 *  linux/zorro.h -- Amiga AutoConfig (Zorro) Bus Definitions
 
3
 *
 
4
 *  Copyright (C) 1995--2003 Geert Uytterhoeven
 
5
 *
 
6
 *  This file is subject to the terms and conditions of the GNU General Public
 
7
 *  License.  See the file COPYING in the main directory of this archive
 
8
 *  for more details.
 
9
 */
 
10
 
 
11
#ifndef _LINUX_ZORRO_H
 
12
#define _LINUX_ZORRO_H
 
13
 
 
14
#include <linux/device.h>
 
15
 
 
16
 
 
17
    /*
 
18
     *  Each Zorro board has a 32-bit ID of the form
 
19
     *
 
20
     *      mmmmmmmmmmmmmmmmppppppppeeeeeeee
 
21
     *
 
22
     *  with
 
23
     *
 
24
     *      mmmmmmmmmmmmmmmm    16-bit Manufacturer ID (assigned by CBM (sigh))
 
25
     *      pppppppp            8-bit Product ID (assigned by manufacturer)
 
26
     *      eeeeeeee            8-bit Extended Product ID (currently only used
 
27
     *                          for some GVP boards)
 
28
     */
 
29
 
 
30
 
 
31
#define ZORRO_MANUF(id)         ((id) >> 16)
 
32
#define ZORRO_PROD(id)          (((id) >> 8) & 0xff)
 
33
#define ZORRO_EPC(id)           ((id) & 0xff)
 
34
 
 
35
#define ZORRO_ID(manuf, prod, epc) \
 
36
    ((ZORRO_MANUF_##manuf << 16) | ((prod) << 8) | (epc))
 
37
 
 
38
typedef __u32 zorro_id;
 
39
 
 
40
 
 
41
/* Include the ID list */
 
42
#include <linux/zorro_ids.h>
 
43
 
 
44
 
 
45
    /*
 
46
     *  GVP identifies most of its products through the 'extended product code'
 
47
     *  (epc). The epc has to be ANDed with the GVP_PRODMASK before the
 
48
     *  identification.
 
49
     */
 
50
 
 
51
#define GVP_PRODMASK                    (0xf8)
 
52
#define GVP_SCSICLKMASK                 (0x01)
 
53
 
 
54
enum GVP_flags {
 
55
    GVP_IO              = 0x01,
 
56
    GVP_ACCEL           = 0x02,
 
57
    GVP_SCSI            = 0x04,
 
58
    GVP_24BITDMA        = 0x08,
 
59
    GVP_25BITDMA        = 0x10,
 
60
    GVP_NOBANK          = 0x20,
 
61
    GVP_14MHZ           = 0x40,
 
62
};
 
63
 
 
64
 
 
65
struct Node {
 
66
    struct  Node *ln_Succ;      /* Pointer to next (successor) */
 
67
    struct  Node *ln_Pred;      /* Pointer to previous (predecessor) */
 
68
    __u8    ln_Type;
 
69
    __s8    ln_Pri;             /* Priority, for sorting */
 
70
    __s8    *ln_Name;           /* ID string, null terminated */
 
71
} __attribute__ ((packed));
 
72
 
 
73
struct ExpansionRom {
 
74
    /* -First 16 bytes of the expansion ROM */
 
75
    __u8  er_Type;              /* Board type, size and flags */
 
76
    __u8  er_Product;           /* Product number, assigned by manufacturer */
 
77
    __u8  er_Flags;             /* Flags */
 
78
    __u8  er_Reserved03;        /* Must be zero ($ff inverted) */
 
79
    __u16 er_Manufacturer;      /* Unique ID, ASSIGNED BY COMMODORE-AMIGA! */
 
80
    __u32 er_SerialNumber;      /* Available for use by manufacturer */
 
81
    __u16 er_InitDiagVec;       /* Offset to optional "DiagArea" structure */
 
82
    __u8  er_Reserved0c;
 
83
    __u8  er_Reserved0d;
 
84
    __u8  er_Reserved0e;
 
85
    __u8  er_Reserved0f;
 
86
} __attribute__ ((packed));
 
87
 
 
88
/* er_Type board type bits */
 
89
#define ERT_TYPEMASK    0xc0
 
90
#define ERT_ZORROII     0xc0
 
91
#define ERT_ZORROIII    0x80
 
92
 
 
93
/* other bits defined in er_Type */
 
94
#define ERTB_MEMLIST    5               /* Link RAM into free memory list */
 
95
#define ERTF_MEMLIST    (1<<5)
 
96
 
 
97
struct ConfigDev {
 
98
    struct Node         cd_Node;
 
99
    __u8                cd_Flags;       /* (read/write) */
 
100
    __u8                cd_Pad;         /* reserved */
 
101
    struct ExpansionRom cd_Rom;         /* copy of board's expansion ROM */
 
102
    void                *cd_BoardAddr;  /* where in memory the board was placed */
 
103
    __u32               cd_BoardSize;   /* size of board in bytes */
 
104
    __u16               cd_SlotAddr;    /* which slot number (PRIVATE) */
 
105
    __u16               cd_SlotSize;    /* number of slots (PRIVATE) */
 
106
    void                *cd_Driver;     /* pointer to node of driver */
 
107
    struct ConfigDev    *cd_NextCD;     /* linked list of drivers to config */
 
108
    __u32               cd_Unused[4];   /* for whatever the driver wants */
 
109
} __attribute__ ((packed));
 
110
 
 
111
#define ZORRO_NUM_AUTO          16
 
112
 
 
113
#ifdef __KERNEL__
 
114
 
 
115
#include <linux/init.h>
 
116
#include <linux/ioport.h>
 
117
#include <linux/mod_devicetable.h>
 
118
 
 
119
#include <asm/zorro.h>
 
120
 
 
121
 
 
122
    /*
 
123
     *  Zorro devices
 
124
     */
 
125
 
 
126
struct zorro_dev {
 
127
    struct ExpansionRom rom;
 
128
    zorro_id id;
 
129
    struct zorro_driver *driver;        /* which driver has allocated this device */
 
130
    struct device dev;                  /* Generic device interface */
 
131
    u16 slotaddr;
 
132
    u16 slotsize;
 
133
    char name[64];
 
134
    struct resource resource;
 
135
};
 
136
 
 
137
#define to_zorro_dev(n) container_of(n, struct zorro_dev, dev)
 
138
 
 
139
 
 
140
    /*
 
141
     *  Zorro bus
 
142
     */
 
143
 
 
144
extern struct bus_type zorro_bus_type;
 
145
 
 
146
 
 
147
    /*
 
148
     *  Zorro device drivers
 
149
     */
 
150
 
 
151
struct zorro_driver {
 
152
    struct list_head node;
 
153
    char *name;
 
154
    const struct zorro_device_id *id_table;     /* NULL if wants all devices */
 
155
    int (*probe)(struct zorro_dev *z, const struct zorro_device_id *id);        /* New device inserted */
 
156
    void (*remove)(struct zorro_dev *z);        /* Device removed (NULL if not a hot-plug capable driver) */
 
157
    struct device_driver driver;
 
158
};
 
159
 
 
160
#define to_zorro_driver(drv)    container_of(drv, struct zorro_driver, driver)
 
161
 
 
162
 
 
163
#define zorro_for_each_dev(dev) \
 
164
        for (dev = &zorro_autocon[0]; dev < zorro_autocon+zorro_num_autocon; dev++)
 
165
 
 
166
 
 
167
/* New-style probing */
 
168
extern int zorro_register_driver(struct zorro_driver *);
 
169
extern void zorro_unregister_driver(struct zorro_driver *);
 
170
extern const struct zorro_device_id *zorro_match_device(const struct zorro_device_id *ids, const struct zorro_dev *z);
 
171
static inline struct zorro_driver *zorro_dev_driver(const struct zorro_dev *z)
 
172
{
 
173
    return z->driver;
 
174
}
 
175
 
 
176
 
 
177
extern unsigned int zorro_num_autocon;  /* # of autoconfig devices found */
 
178
extern struct zorro_dev zorro_autocon[ZORRO_NUM_AUTO];
 
179
 
 
180
 
 
181
    /*
 
182
     *  Zorro Functions
 
183
     */
 
184
 
 
185
extern struct zorro_dev *zorro_find_device(zorro_id id,
 
186
                                           struct zorro_dev *from);
 
187
 
 
188
#define zorro_resource_start(z) ((z)->resource.start)
 
189
#define zorro_resource_end(z)   ((z)->resource.end)
 
190
#define zorro_resource_len(z)   (resource_size(&(z)->resource))
 
191
#define zorro_resource_flags(z) ((z)->resource.flags)
 
192
 
 
193
#define zorro_request_device(z, name) \
 
194
    request_mem_region(zorro_resource_start(z), zorro_resource_len(z), name)
 
195
#define zorro_release_device(z) \
 
196
    release_mem_region(zorro_resource_start(z), zorro_resource_len(z))
 
197
 
 
198
/* Similar to the helpers above, these manipulate per-zorro_dev
 
199
 * driver-specific data.  They are really just a wrapper around
 
200
 * the generic device structure functions of these calls.
 
201
 */
 
202
static inline void *zorro_get_drvdata (struct zorro_dev *z)
 
203
{
 
204
        return dev_get_drvdata(&z->dev);
 
205
}
 
206
 
 
207
static inline void zorro_set_drvdata (struct zorro_dev *z, void *data)
 
208
{
 
209
        dev_set_drvdata(&z->dev, data);
 
210
}
 
211
 
 
212
 
 
213
    /*
 
214
     *  Bitmask indicating portions of available Zorro II RAM that are unused
 
215
     *  by the system. Every bit represents a 64K chunk, for a maximum of 8MB
 
216
     *  (128 chunks, physical 0x00200000-0x009fffff).
 
217
     *
 
218
     *  If you want to use (= allocate) portions of this RAM, you should clear
 
219
     *  the corresponding bits.
 
220
     */
 
221
 
 
222
extern DECLARE_BITMAP(zorro_unused_z2ram, 128);
 
223
 
 
224
#define Z2RAM_START             (0x00200000)
 
225
#define Z2RAM_END               (0x00a00000)
 
226
#define Z2RAM_SIZE              (0x00800000)
 
227
#define Z2RAM_CHUNKSIZE         (0x00010000)
 
228
#define Z2RAM_CHUNKMASK         (0x0000ffff)
 
229
#define Z2RAM_CHUNKSHIFT        (16)
 
230
 
 
231
 
 
232
#endif /* __KERNEL__ */
 
233
 
 
234
#endif /* _LINUX_ZORRO_H */