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(offset: slotaddr, size: slotsize); |
51 | BUG_ON(!module); |
52 | |
53 | offset = TC_OLDCARD; |
54 | |
55 | err = 0; |
56 | err |= tc_preadb(valp: pattern + 0, addr: module + offset + TC_PATTERN0); |
57 | err |= tc_preadb(valp: pattern + 1, addr: module + offset + TC_PATTERN1); |
58 | err |= tc_preadb(valp: pattern + 2, addr: module + offset + TC_PATTERN2); |
59 | err |= tc_preadb(valp: pattern + 3, addr: 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(valp: pattern + 0, |
69 | addr: module + offset + TC_PATTERN0); |
70 | err |= tc_preadb(valp: pattern + 1, |
71 | addr: module + offset + TC_PATTERN1); |
72 | err |= tc_preadb(valp: pattern + 2, |
73 | addr: module + offset + TC_PATTERN2); |
74 | err |= tc_preadb(valp: pattern + 3, |
75 | addr: 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(size: 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(dev: &tdev->dev, name: "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(addr: module + offset + TC_FIRM_VER + 4 * i); |
104 | tdev->vendor[i] = |
105 | readb(addr: module + offset + TC_VENDOR + 4 * i); |
106 | tdev->name[i] = |
107 | readb(addr: 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(addr: 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(objp: 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(dev: &tdev->dev)) { |
138 | put_device(dev: &tdev->dev); |
139 | goto out_err; |
140 | } |
141 | list_add_tail(new: &tdev->node, head: &tbus->devices); |
142 | |
143 | out_err: |
144 | iounmap(addr: 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(tbus: &tc_bus)) |
155 | goto out_err; |
156 | |
157 | INIT_LIST_HEAD(list: &tc_bus.devices); |
158 | dev_set_name(dev: &tc_bus.dev, name: "tc" ); |
159 | if (device_register(dev: &tc_bus.dev)) |
160 | goto out_err_device; |
161 | |
162 | if (tc_bus.info.slot_size) { |
163 | unsigned int tc_clock = tc_get_speed(tbus: &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(root: &iomem_resource, |
177 | new: &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(root: &iomem_resource, |
189 | new: &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(tbus: &tc_bus); |
196 | } |
197 | |
198 | return 0; |
199 | |
200 | out_err_resource: |
201 | release_resource(new: &tc_bus.resource[0]); |
202 | out_err_device: |
203 | put_device(dev: &tc_bus.dev); |
204 | out_err: |
205 | return 0; |
206 | } |
207 | |
208 | subsys_initcall(tc_init); |
209 | |