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 */ tc_bus_add_devices(struct tc_bus * tbus)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 */ tc_init(void)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); 209