← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to arch/powerpc/sysdev/scom.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/powerpc/sysdev/scom.c
 
1
/*
 
2
 * Copyright 2010 Benjamin Herrenschmidt, IBM Corp
 
3
 *                <benh@kernel.crashing.org>
 
4
 *     and        David Gibson, IBM Corporation.
 
5
 *
 
6
 *   This program is free software;  you can redistribute it and/or modify
 
7
 *   it under the terms of the GNU General Public License as published by
 
8
 *   the Free Software Foundation; either version 2 of the License, or
 
9
 *   (at your option) any later version.
 
10
 *
 
11
 *   This program is distributed in the hope that it will be useful,
 
12
 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 
14
 *   the GNU General Public License for more details.
 
15
 *
 
16
 *   You should have received a copy of the GNU General Public License
 
17
 *   along with this program;  if not, write to the Free Software
 
18
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
19
 */
 
20
 
 
21
#include <linux/kernel.h>
 
22
#include <linux/debugfs.h>
 
23
#include <linux/slab.h>
 
24
#include <asm/prom.h>
 
25
#include <asm/scom.h>
 
26
 
 
27
const struct scom_controller *scom_controller;
 
28
EXPORT_SYMBOL_GPL(scom_controller);
 
29
 
 
30
struct device_node *scom_find_parent(struct device_node *node)
 
31
{
 
32
        struct device_node *par, *tmp;
 
33
        const u32 *p;
 
34
 
 
35
        for (par = of_node_get(node); par;) {
 
36
                if (of_get_property(par, "scom-controller", NULL))
 
37
                        break;
 
38
                p = of_get_property(par, "scom-parent", NULL);
 
39
                tmp = par;
 
40
                if (p == NULL)
 
41
                        par = of_get_parent(par);
 
42
                else
 
43
                        par = of_find_node_by_phandle(*p);
 
44
                of_node_put(tmp);
 
45
        }
 
46
        return par;
 
47
}
 
48
EXPORT_SYMBOL_GPL(scom_find_parent);
 
49
 
 
50
scom_map_t scom_map_device(struct device_node *dev, int index)
 
51
{
 
52
        struct device_node *parent;
 
53
        unsigned int cells, size;
 
54
        const u32 *prop;
 
55
        u64 reg, cnt;
 
56
        scom_map_t ret;
 
57
 
 
58
        parent = scom_find_parent(dev);
 
59
 
 
60
        if (parent == NULL)
 
61
                return 0;
 
62
 
 
63
        prop = of_get_property(parent, "#scom-cells", NULL);
 
64
        cells = prop ? *prop : 1;
 
65
 
 
66
        prop = of_get_property(dev, "scom-reg", &size);
 
67
        if (!prop)
 
68
                return 0;
 
69
        size >>= 2;
 
70
 
 
71
        if (index >= (size / (2*cells)))
 
72
                return 0;
 
73
 
 
74
        reg = of_read_number(&prop[index * cells * 2], cells);
 
75
        cnt = of_read_number(&prop[index * cells * 2 + cells], cells);
 
76
 
 
77
        ret = scom_map(parent, reg, cnt);
 
78
        of_node_put(parent);
 
79
 
 
80
        return ret;
 
81
}
 
82
EXPORT_SYMBOL_GPL(scom_map_device);
 
83
 
 
84
#ifdef CONFIG_SCOM_DEBUGFS
 
85
struct scom_debug_entry {
 
86
        struct device_node *dn;
 
87
        unsigned long addr;
 
88
        scom_map_t map;
 
89
        spinlock_t lock;
 
90
        char name[8];
 
91
        struct debugfs_blob_wrapper blob;
 
92
};
 
93
 
 
94
static int scom_addr_set(void *data, u64 val)
 
95
{
 
96
        struct scom_debug_entry *ent = data;
 
97
 
 
98
        ent->addr = 0;
 
99
        scom_unmap(ent->map);
 
100
 
 
101
        ent->map = scom_map(ent->dn, val, 1);
 
102
        if (scom_map_ok(ent->map))
 
103
                ent->addr = val;
 
104
        else
 
105
                return -EFAULT;
 
106
 
 
107
        return 0;
 
108
}
 
109
 
 
110
static int scom_addr_get(void *data, u64 *val)
 
111
{
 
112
        struct scom_debug_entry *ent = data;
 
113
        *val = ent->addr;
 
114
        return 0;
 
115
}
 
116
DEFINE_SIMPLE_ATTRIBUTE(scom_addr_fops, scom_addr_get, scom_addr_set,
 
117
                        "0x%llx\n");
 
118
 
 
119
static int scom_val_set(void *data, u64 val)
 
120
{
 
121
        struct scom_debug_entry *ent = data;
 
122
 
 
123
        if (!scom_map_ok(ent->map))
 
124
                return -EFAULT;
 
125
 
 
126
        scom_write(ent->map, 0, val);
 
127
 
 
128
        return 0;
 
129
}
 
130
 
 
131
static int scom_val_get(void *data, u64 *val)
 
132
{
 
133
        struct scom_debug_entry *ent = data;
 
134
 
 
135
        if (!scom_map_ok(ent->map))
 
136
                return -EFAULT;
 
137
 
 
138
        *val = scom_read(ent->map, 0);
 
139
        return 0;
 
140
}
 
141
DEFINE_SIMPLE_ATTRIBUTE(scom_val_fops, scom_val_get, scom_val_set,
 
142
                        "0x%llx\n");
 
143
 
 
144
static int scom_debug_init_one(struct dentry *root, struct device_node *dn,
 
145
                               int i)
 
146
{
 
147
        struct scom_debug_entry *ent;
 
148
        struct dentry *dir;
 
149
 
 
150
        ent = kzalloc(sizeof(*ent), GFP_KERNEL);
 
151
        if (!ent)
 
152
                return -ENOMEM;
 
153
 
 
154
        ent->dn = of_node_get(dn);
 
155
        ent->map = SCOM_MAP_INVALID;
 
156
        spin_lock_init(&ent->lock);
 
157
        snprintf(ent->name, 8, "scom%d", i);
 
158
        ent->blob.data = dn->full_name;
 
159
        ent->blob.size = strlen(dn->full_name);
 
160
 
 
161
        dir = debugfs_create_dir(ent->name, root);
 
162
        if (!dir) {
 
163
                of_node_put(dn);
 
164
                kfree(ent);
 
165
                return -1;
 
166
        }
 
167
 
 
168
        debugfs_create_file("addr", 0600, dir, ent, &scom_addr_fops);
 
169
        debugfs_create_file("value", 0600, dir, ent, &scom_val_fops);
 
170
        debugfs_create_blob("path", 0400, dir, &ent->blob);
 
171
 
 
172
        return 0;
 
173
}
 
174
 
 
175
static int scom_debug_init(void)
 
176
{
 
177
        struct device_node *dn;
 
178
        struct dentry *root;
 
179
        int i, rc;
 
180
 
 
181
        root = debugfs_create_dir("scom", powerpc_debugfs_root);
 
182
        if (!root)
 
183
                return -1;
 
184
 
 
185
        i = rc = 0;
 
186
        for_each_node_with_property(dn, "scom-controller")
 
187
                rc |= scom_debug_init_one(root, dn, i++);
 
188
 
 
189
        return rc;
 
190
}
 
191
device_initcall(scom_debug_init);
 
192
#endif /* CONFIG_SCOM_DEBUGFS */