drivers/zorro/zorro.c

   1 /*
   2  *    Zorro Bus Services
   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 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/zorro.h>
  16 #include <linux/bitops.h>
  17 #include <linux/string.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/slab.h>
  20
  21 #include <asm/setup.h>
  22 #include <asm/amigahw.h>
  23
  24 #include "zorro.h"
  25
  26
  27     /*
  28      *  Zorro Expansion Devices
  29      */
  30
  31 unsigned int zorro_num_autocon;
  32 struct zorro_dev zorro_autocon[ZORRO_NUM_AUTO];
  33
  34
  35     /*
  36      *  Zorro bus
  37      */
  38
  39 struct zorro_bus {
  40         struct list_head devices;       /* list of devices on this bus */
  41         struct device dev;
  42 };
  43
  44
  45     /*
  46      *  Find Zorro Devices
  47      */
  48
  49 struct zorro_dev *zorro_find_device(zorro_id id, struct zorro_dev *from)
  50 {
  51         struct zorro_dev *z;
  52
  53         if (!zorro_num_autocon)
  54                 return NULL;
  55
  56         for (z = from ? from+1 : &zorro_autocon[0];
  57              z < zorro_autocon+zorro_num_autocon;
  58              z++)
  59                 if (id == ZORRO_WILDCARD || id == z->id)
  60                         return z;
  61         return NULL;
  62 }
  63 EXPORT_SYMBOL(zorro_find_device);
  64
  65
  66     /*
  67      *  Bitmask indicating portions of available Zorro II RAM that are unused
  68      *  by the system. Every bit represents a 64K chunk, for a maximum of 8MB
  69      *  (128 chunks, physical 0x00200000-0x009fffff).
  70      *
  71      *  If you want to use (= allocate) portions of this RAM, you should clear
  72      *  the corresponding bits.
  73      *
  74      *  Possible uses:
  75      *      - z2ram device
  76      *      - SCSI DMA bounce buffers
  77      *
  78      *  FIXME: use the normal resource management
  79      */
  80
  81 DECLARE_BITMAP(zorro_unused_z2ram, 128);
  82 EXPORT_SYMBOL(zorro_unused_z2ram);
  83
  84
  85 static void __init mark_region(unsigned long start, unsigned long end,
  86                                int flag)
  87 {
  88         if (flag)
  89                 start += Z2RAM_CHUNKMASK;
  90         else
  91                 end += Z2RAM_CHUNKMASK;
  92         start &= ~Z2RAM_CHUNKMASK;
  93         end &= ~Z2RAM_CHUNKMASK;
  94
  95         if (end <= Z2RAM_START || start >= Z2RAM_END)
  96                 return;
  97         start = start < Z2RAM_START ? 0x00000000 : start-Z2RAM_START;
  98         end = end > Z2RAM_END ? Z2RAM_SIZE : end-Z2RAM_START;
  99         while (start < end) {
 100                 u32 chunk = start>>Z2RAM_CHUNKSHIFT;
 101                 if (flag)
 102                         set_bit(chunk, zorro_unused_z2ram);
 103                 else
 104                         clear_bit(chunk, zorro_unused_z2ram);
 105                 start += Z2RAM_CHUNKSIZE;
 106         }
 107 }
 108
 109
 110 static struct resource __init *zorro_find_parent_resource(
 111         struct platform_device *bridge, struct zorro_dev *z)
 112 {
 113         int i;
 114
 115         for (i = 0; i < bridge->num_resources; i++) {
 116                 struct resource *r = &bridge->resource[i];
 117                 if (zorro_resource_start(z) >= r->start &&
 118                     zorro_resource_end(z) <= r->end)
 119                         return r;
 120         }
 121         return &iomem_resource;
 122 }
 123
 124
 125
 126 static int __init amiga_zorro_probe(struct platform_device *pdev)
 127 {
 128         struct zorro_bus *bus;
 129         struct zorro_dev *z;
 130         struct resource *r;
 131         unsigned int i;
 132         int error;
 133
 134         /* Initialize the Zorro bus */
 135         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
 136         if (!bus)
 137                 return -ENOMEM;
 138
 139         INIT_LIST_HEAD(&bus->devices);
 140         bus->dev.parent = &pdev->dev;
 141         dev_set_name(&bus->dev, "zorro");
 142         error = device_register(&bus->dev);
 143         if (error) {
 144                 pr_err("Zorro: Error registering zorro_bus\n");
 145                 put_device(&bus->dev);
 146                 kfree(bus);
 147                 return error;
 148         }
 149         platform_set_drvdata(pdev, bus);
 150
 151         pr_info("Zorro: Probing AutoConfig expansion devices: %u device%s\n",
 152                  zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s");
 153
 154         /* First identify all devices ... */
 155         for (i = 0; i < zorro_num_autocon; i++) {
 156                 z = &zorro_autocon[i];
 157                 z->id = (z->rom.er_Manufacturer<<16) | (z->rom.er_Product<<8);
 158                 if (z->id == ZORRO_PROD_GVP_EPC_BASE) {
 159                         /* GVP quirk */
 160                         unsigned long magic = zorro_resource_start(z)+0x8000;
 161                         z->id |= *(u16 *)ZTWO_VADDR(magic) & GVP_PRODMASK;
 162                 }
 163                 sprintf(z->name, "Zorro device %08x", z->id);
 164                 zorro_name_device(z);
 165                 z->resource.name = z->name;
 166                 r = zorro_find_parent_resource(pdev, z);
 167                 error = request_resource(r, &z->resource);
 168                 if (error)
 169                         dev_err(&bus->dev,
 170                                 "Address space collision on device %s %pR\n",
 171                                 z->name, &z->resource);
 172                 dev_set_name(&z->dev, "%02x", i);
 173                 z->dev.parent = &bus->dev;
 174                 z->dev.bus = &zorro_bus_type;
 175         }
 176
 177         /* ... then register them */
 178         for (i = 0; i < zorro_num_autocon; i++) {
 179                 z = &zorro_autocon[i];
 180                 error = device_register(&z->dev);
 181                 if (error) {
 182                         dev_err(&bus->dev, "Error registering device %s\n",
 183                                 z->name);
 184                         put_device(&z->dev);
 185                         continue;
 186                 }
 187                 error = zorro_create_sysfs_dev_files(z);
 188                 if (error)
 189                         dev_err(&z->dev, "Error creating sysfs files\n");
 190         }
 191
 192         /* Mark all available Zorro II memory */
 193         zorro_for_each_dev(z) {
 194                 if (z->rom.er_Type & ERTF_MEMLIST)
 195                         mark_region(zorro_resource_start(z),
 196                                     zorro_resource_end(z)+1, 1);
 197         }
 198
 199         /* Unmark all used Zorro II memory */
 200         for (i = 0; i < m68k_num_memory; i++)
 201                 if (m68k_memory[i].addr < 16*1024*1024)
 202                         mark_region(m68k_memory[i].addr,
 203                                     m68k_memory[i].addr+m68k_memory[i].size,
 204                                     0);
 205
 206         return 0;
 207 }
 208
 209 static struct platform_driver amiga_zorro_driver = {
 210         .driver   = {
 211                 .name   = "amiga-zorro",
 212                 .owner  = THIS_MODULE,
 213         },
 214 };
 215
 216 static int __init amiga_zorro_init(void)
 217 {
 218         return platform_driver_probe(&amiga_zorro_driver, amiga_zorro_probe);
 219 }
 220
 221 module_init(amiga_zorro_init);
 222
 223 MODULE_LICENSE("GPL");