← Back to branch summary

~ubuntu-branches/ubuntu/utopic/linux-ti-omap/utopic

« back to all changes in this revision

Viewing changes to drivers/tc/tc.c

  • Committer: Bazaar Package Importer
  • Author(s): Amit Kucheria, Amit Kucheria
  • Date: 2010-03-10 02:28:15 UTC
  • Revision ID: james.westby@ubuntu.com-20100310022815-7sd3gwvn5kenaq33
Tags: 2.6.33-500.1
[ Amit Kucheria ]

* Initial release of a 2.6.33-based OMAP kernel
* UBUNTU: [Upstream] Fix omap 1-wire driver compilation
* UBUNTU: ubuntu: AppArmor -- update to mainline 2010-03-04

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
                dev_set_name(&tdev->dev, "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", dev_name(&tdev->dev), 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
                               dev_name(&tdev->dev), 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
        dev_set_name(&tc_bus.dev, "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 - 1;
 
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 - 1;
 
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);