drivers/tc/tc.c

   1 /*
   2  *      TURBOchannel bus services.
   3  *
   4  *      Copyright (c) Harald Koerfgen, 1998
   5  *      Copyright (c) 2001, 2003, 2005, 2006, 2018  Maciej W. Rozycki
   6  *      Copyright (c) 2005  James Simmons
   7  *
   8  *      This file is subject to the terms and conditions of the GNU
   9  *      General Public License.  See the file "COPYING" in the main
  10  *      directory of this archive for more details.
  11  */
  12 #include <linux/compiler.h>
  13 #include <linux/dma-mapping.h>
  14 #include <linux/errno.h>
  15 #include <linux/init.h>
  16 #include <linux/ioport.h>
  17 #include <linux/kernel.h>
  18 #include <linux/list.h>
  19 #include <linux/module.h>
  20 #include <linux/slab.h>
  21 #include <linux/string.h>
  22 #include <linux/tc.h>
  23 #include <linux/types.h>
  24
  25 #include <asm/io.h>
  26
  27 static struct tc_bus tc_bus = {
  28         .name = "TURBOchannel",
  29 };
  30
  31 /*
  32  * Probing for TURBOchannel modules.
  33  */
  34 static void __init tc_bus_add_devices(struct tc_bus *tbus)
  35 {
  36         resource_size_t slotsize = tbus->info.slot_size << 20;
  37         resource_size_t extslotsize = tbus->ext_slot_size;
  38         resource_size_t slotaddr;
  39         resource_size_t extslotaddr;
  40         resource_size_t devsize;
  41         void __iomem *module;
  42         struct tc_dev *tdev;
  43         int i, slot, err;
  44         u8 pattern[4];
  45         long offset;
  46
  47         for (slot = 0; slot < tbus->num_tcslots; slot++) {
  48                 slotaddr = tbus->slot_base + slot * slotsize;
  49                 extslotaddr = tbus->ext_slot_base + slot * extslotsize;
  50                 module = ioremap_nocache(slotaddr, slotsize);
  51                 BUG_ON(!module);
  52
  53                 offset = TC_OLDCARD;
  54
  55                 err = 0;
  56                 err |= tc_preadb(pattern + 0, module + offset + TC_PATTERN0);
  57                 err |= tc_preadb(pattern + 1, module + offset + TC_PATTERN1);
  58                 err |= tc_preadb(pattern + 2, module + offset + TC_PATTERN2);
  59                 err |= tc_preadb(pattern + 3, module + offset + TC_PATTERN3);
  60                 if (err)
  61                         goto out_err;
  62
  63                 if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
  64                     pattern[2] != 0xaa || pattern[3] != 0xff) {
  65                         offset = TC_NEWCARD;
  66
  67                         err = 0;
  68                         err |= tc_preadb(pattern + 0,
  69                                          module + offset + TC_PATTERN0);
  70                         err |= tc_preadb(pattern + 1,
  71                                          module + offset + TC_PATTERN1);
  72                         err |= tc_preadb(pattern + 2,
  73                                          module + offset + TC_PATTERN2);
  74                         err |= tc_preadb(pattern + 3,
  75                                          module + offset + TC_PATTERN3);
  76                         if (err)
  77                                 goto out_err;
  78                 }
  79
  80                 if (pattern[0] != 0x55 || pattern[1] != 0x00 ||
  81                     pattern[2] != 0xaa || pattern[3] != 0xff)
  82                         goto out_err;
  83
  84                 /* Found a board, allocate it an entry in the list */
  85                 tdev = kzalloc(sizeof(*tdev), GFP_KERNEL);
  86                 if (!tdev) {
  87                         pr_err("tc%x: unable to allocate tc_dev\n", slot);
  88                         goto out_err;
  89                 }
  90                 dev_set_name(&tdev->dev, "tc%x", slot);
  91                 tdev->bus = tbus;
  92                 tdev->dev.parent = &tbus->dev;
  93                 tdev->dev.bus = &tc_bus_type;
  94                 tdev->slot = slot;
  95
  96                 /* TURBOchannel has 34-bit DMA addressing (16GiB space). */
  97                 tdev->dma_mask = DMA_BIT_MASK(34);
  98                 tdev->dev.dma_mask = &tdev->dma_mask;
  99                 tdev->dev.coherent_dma_mask = DMA_BIT_MASK(34);
 100
 101                 for (i = 0; i < 8; i++) {
 102                         tdev->firmware[i] =
 103                                 readb(module + offset + TC_FIRM_VER + 4 * i);
 104                         tdev->vendor[i] =
 105                                 readb(module + offset + TC_VENDOR + 4 * i);
 106                         tdev->name[i] =
 107                                 readb(module + offset + TC_MODULE + 4 * i);
 108                 }
 109                 tdev->firmware[8] = 0;
 110                 tdev->vendor[8] = 0;
 111                 tdev->name[8] = 0;
 112
 113                 pr_info("%s: %s %s %s\n", dev_name(&tdev->dev), tdev->vendor,
 114                         tdev->name, tdev->firmware);
 115
 116                 devsize = readb(module + offset + TC_SLOT_SIZE);
 117                 devsize <<= 22;
 118                 if (devsize <= slotsize) {
 119                         tdev->resource.start = slotaddr;
 120                         tdev->resource.end = slotaddr + devsize - 1;
 121                 } else if (devsize <= extslotsize) {
 122                         tdev->resource.start = extslotaddr;
 123                         tdev->resource.end = extslotaddr + devsize - 1;
 124                 } else {
 125                         pr_err("%s: Cannot provide slot space "
 126                                "(%ldMiB required, up to %ldMiB supported)\n",
 127                                dev_name(&tdev->dev), (long)(devsize >> 20),
 128                                (long)(max(slotsize, extslotsize) >> 20));
 129                         kfree(tdev);
 130                         goto out_err;
 131                 }
 132                 tdev->resource.name = tdev->name;
 133                 tdev->resource.flags = IORESOURCE_MEM;
 134
 135                 tc_device_get_irq(tdev);
 136
 137                 if (device_register(&tdev->dev)) {
 138                         put_device(&tdev->dev);
 139                         goto out_err;
 140                 }
 141                 list_add_tail(&tdev->node, &tbus->devices);
 142
 143 out_err:
 144                 iounmap(module);
 145         }
 146 }
 147
 148 /*
 149  * The main entry.
 150  */
 151 static int __init tc_init(void)
 152 {
 153         /* Initialize the TURBOchannel bus */
 154         if (tc_bus_get_info(&tc_bus))
 155                 goto out_err;
 156
 157         INIT_LIST_HEAD(&tc_bus.devices);
 158         dev_set_name(&tc_bus.dev, "tc");
 159         if (device_register(&tc_bus.dev))
 160                 goto out_err_device;
 161
 162         if (tc_bus.info.slot_size) {
 163                 unsigned int tc_clock = tc_get_speed(&tc_bus) / 100000;
 164
 165                 pr_info("tc: TURBOchannel rev. %d at %d.%d MHz "
 166                         "(with%s parity)\n", tc_bus.info.revision,
 167                         tc_clock / 10, tc_clock % 10,
 168                         tc_bus.info.parity ? "" : "out");
 169
 170                 tc_bus.resource[0].start = tc_bus.slot_base;
 171                 tc_bus.resource[0].end = tc_bus.slot_base +
 172                                          (tc_bus.info.slot_size << 20) *
 173                                          tc_bus.num_tcslots - 1;
 174                 tc_bus.resource[0].name = tc_bus.name;
 175                 tc_bus.resource[0].flags = IORESOURCE_MEM;
 176                 if (request_resource(&iomem_resource,
 177                                      &tc_bus.resource[0]) < 0) {
 178                         pr_err("tc: Cannot reserve resource\n");
 179                         goto out_err_device;
 180                 }
 181                 if (tc_bus.ext_slot_size) {
 182                         tc_bus.resource[1].start = tc_bus.ext_slot_base;
 183                         tc_bus.resource[1].end = tc_bus.ext_slot_base +
 184                                                  tc_bus.ext_slot_size *
 185                                                  tc_bus.num_tcslots - 1;
 186                         tc_bus.resource[1].name = tc_bus.name;
 187                         tc_bus.resource[1].flags = IORESOURCE_MEM;
 188                         if (request_resource(&iomem_resource,
 189                                              &tc_bus.resource[1]) < 0) {
 190                                 pr_err("tc: Cannot reserve resource\n");
 191                                 goto out_err_resource;
 192                         }
 193                 }
 194
 195                 tc_bus_add_devices(&tc_bus);
 196         }
 197
 198         return 0;
 199
 200 out_err_resource:
 201         release_resource(&tc_bus.resource[0]);
 202 out_err_device:
 203         put_device(&tc_bus.dev);
 204 out_err:
 205         return 0;
 206 }
 207
 208 subsys_initcall(tc_init);