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 */ 235