← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-linaro-omap/trusty

« back to all changes in this revision

Viewing changes to arch/arm/mach-ns9xxx/clock.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-57i0gl3v99b3lkfg
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/arm/mach-ns9xxx/clock.c
1
 
/*
2
 
 * arch/arm/mach-ns9xxx/clock.c
3
 
 *
4
 
 * Copyright (C) 2007 by Digi International Inc.
5
 
 * All rights reserved.
6
 
 *
7
 
 * This program is free software; you can redistribute it and/or modify it
8
 
 * under the terms of the GNU General Public License version 2 as published by
9
 
 * the Free Software Foundation.
10
 
 */
11
 
#include <linux/err.h>
12
 
#include <linux/module.h>
13
 
#include <linux/list.h>
14
 
#include <linux/clk.h>
15
 
#include <linux/string.h>
16
 
#include <linux/platform_device.h>
17
 
#include <linux/semaphore.h>
18
 
 
19
 
#include "clock.h"
20
 
 
21
 
static LIST_HEAD(clocks);
22
 
static DEFINE_SPINLOCK(clk_lock);
23
 
 
24
 
struct clk *clk_get(struct device *dev, const char *id)
25
 
{
26
 
        struct clk *p, *ret = NULL, *retgen = NULL;
27
 
        unsigned long flags;
28
 
        int idno;
29
 
 
30
 
        if (dev == NULL || dev->bus != &platform_bus_type)
31
 
                idno = -1;
32
 
        else
33
 
                idno = to_platform_device(dev)->id;
34
 
 
35
 
        spin_lock_irqsave(&clk_lock, flags);
36
 
        list_for_each_entry(p, &clocks, node) {
37
 
                if (strcmp(id, p->name) == 0) {
38
 
                        if (p->id == idno) {
39
 
                                if (!try_module_get(p->owner))
40
 
                                        continue;
41
 
                                ret = p;
42
 
                                break;
43
 
                        } else if (p->id == -1)
44
 
                                /* remember match with id == -1 in case there is
45
 
                                 * no clock for idno */
46
 
                                retgen = p;
47
 
                }
48
 
        }
49
 
 
50
 
        if (!ret && retgen && try_module_get(retgen->owner))
51
 
                ret = retgen;
52
 
 
53
 
        if (ret)
54
 
                ++ret->refcount;
55
 
 
56
 
        spin_unlock_irqrestore(&clk_lock, flags);
57
 
 
58
 
        return ret ? ret : ERR_PTR(-ENOENT);
59
 
}
60
 
EXPORT_SYMBOL(clk_get);
61
 
 
62
 
void clk_put(struct clk *clk)
63
 
{
64
 
        module_put(clk->owner);
65
 
        --clk->refcount;
66
 
}
67
 
EXPORT_SYMBOL(clk_put);
68
 
 
69
 
static int clk_enable_unlocked(struct clk *clk)
70
 
{
71
 
        int ret = 0;
72
 
        if (clk->parent) {
73
 
                ret = clk_enable_unlocked(clk->parent);
74
 
                if (ret)
75
 
                        return ret;
76
 
        }
77
 
 
78
 
        if (clk->usage++ == 0 && clk->endisable)
79
 
                ret = clk->endisable(clk, 1);
80
 
 
81
 
        return ret;
82
 
}
83
 
 
84
 
int clk_enable(struct clk *clk)
85
 
{
86
 
        int ret;
87
 
        unsigned long flags;
88
 
 
89
 
        spin_lock_irqsave(&clk_lock, flags);
90
 
 
91
 
        ret = clk_enable_unlocked(clk);
92
 
 
93
 
        spin_unlock_irqrestore(&clk_lock, flags);
94
 
 
95
 
        return ret;
96
 
}
97
 
EXPORT_SYMBOL(clk_enable);
98
 
 
99
 
static void clk_disable_unlocked(struct clk *clk)
100
 
{
101
 
        if (--clk->usage == 0 && clk->endisable)
102
 
                clk->endisable(clk, 0);
103
 
 
104
 
        if (clk->parent)
105
 
                clk_disable_unlocked(clk->parent);
106
 
}
107
 
 
108
 
void clk_disable(struct clk *clk)
109
 
{
110
 
        unsigned long flags;
111
 
 
112
 
        spin_lock_irqsave(&clk_lock, flags);
113
 
 
114
 
        clk_disable_unlocked(clk);
115
 
 
116
 
        spin_unlock_irqrestore(&clk_lock, flags);
117
 
}
118
 
EXPORT_SYMBOL(clk_disable);
119
 
 
120
 
unsigned long clk_get_rate(struct clk *clk)
121
 
{
122
 
        if (clk->get_rate)
123
 
                return clk->get_rate(clk);
124
 
 
125
 
        if (clk->rate)
126
 
                return clk->rate;
127
 
 
128
 
        if (clk->parent)
129
 
                return clk_get_rate(clk->parent);
130
 
 
131
 
        return 0;
132
 
}
133
 
EXPORT_SYMBOL(clk_get_rate);
134
 
 
135
 
int clk_register(struct clk *clk)
136
 
{
137
 
        unsigned long flags;
138
 
 
139
 
        spin_lock_irqsave(&clk_lock, flags);
140
 
 
141
 
        list_add(&clk->node, &clocks);
142
 
 
143
 
        if (clk->parent)
144
 
                ++clk->parent->refcount;
145
 
 
146
 
        spin_unlock_irqrestore(&clk_lock, flags);
147
 
 
148
 
        return 0;
149
 
}
150
 
 
151
 
int clk_unregister(struct clk *clk)
152
 
{
153
 
        int ret = 0;
154
 
        unsigned long flags;
155
 
 
156
 
        spin_lock_irqsave(&clk_lock, flags);
157
 
 
158
 
        if (clk->usage || clk->refcount)
159
 
                ret = -EBUSY;
160
 
        else
161
 
                list_del(&clk->node);
162
 
 
163
 
        if (clk->parent)
164
 
                --clk->parent->refcount;
165
 
 
166
 
        spin_unlock_irqrestore(&clk_lock, flags);
167
 
 
168
 
        return ret;
169
 
}
170
 
 
171
 
#if defined CONFIG_DEBUG_FS
172
 
 
173
 
#include <linux/debugfs.h>
174
 
#include <linux/seq_file.h>
175
 
 
176
 
static int clk_debugfs_show(struct seq_file *s, void *null)
177
 
{
178
 
        unsigned long flags;
179
 
        struct clk *p;
180
 
 
181
 
        spin_lock_irqsave(&clk_lock, flags);
182
 
 
183
 
        list_for_each_entry(p, &clocks, node)
184
 
                seq_printf(s, "%s.%d: usage=%lu refcount=%lu rate=%lu\n",
185
 
                                p->name, p->id, p->usage, p->refcount,
186
 
                                p->usage ? clk_get_rate(p) : 0);
187
 
 
188
 
        spin_unlock_irqrestore(&clk_lock, flags);
189
 
 
190
 
        return 0;
191
 
}
192
 
 
193
 
static int clk_debugfs_open(struct inode *inode, struct file *file)
194
 
{
195
 
        return single_open(file, clk_debugfs_show, NULL);
196
 
}
197
 
 
198
 
static const struct file_operations clk_debugfs_operations = {
199
 
        .open = clk_debugfs_open,
200
 
        .read = seq_read,
201
 
        .llseek = seq_lseek,
202
 
        .release = single_release,
203
 
};
204
 
 
205
 
static int __init clk_debugfs_init(void)
206
 
{
207
 
        struct dentry *dentry;
208
 
 
209
 
        dentry = debugfs_create_file("clk", S_IFREG | S_IRUGO, NULL, NULL,
210
 
                        &clk_debugfs_operations);
211
 
        return IS_ERR(dentry) ? PTR_ERR(dentry) : 0;
212
 
}
213
 
subsys_initcall(clk_debugfs_init);
214
 
 
215
 
#endif /* if defined CONFIG_DEBUG_FS */