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