← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to arch/arm/mach-mx1/clock.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno, Martin Michlmayr
  • Date: 2011-04-06 13:53:30 UTC
  • mfrom: (43.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20110406135330-wjufxhd0tvn3zx4z
Tags: 2.6.38-3
http://bugs.debian.org/620124
http://bugs.debian.org/620284
http://bugs.debian.org/620204
[ Ben Hutchings ]
* [ppc64] Add to linux-tools package architectures (Closes: #620124)
* [amd64] Save cr4 to mmu_cr4_features at boot time (Closes: #620284)
* appletalk: Fix bugs introduced when removing use of BKL
* ALSA: Fix yet another race in disconnection
* cciss: Fix lost command issue
* ath9k: Fix kernel panic in AR2427
* ses: Avoid kernel panic when lun 0 is not mapped
* PCI/ACPI: Report ASPM support to BIOS if not disabled from command line

[ Aurelien Jarno ]
* rtlwifi: fix build when PCI is not enabled.

[ Martin Michlmayr ]
* rtlwifi: Eliminate udelay calls with too large values (Closes: #620204)

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/arm/mach-mx1/clock.c
1
 
/*
2
 
 *  Copyright (C) 2008 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
3
 
 *
4
 
 * This program is free software; you can redistribute it and/or modify
5
 
 * it under the terms of the GNU General Public License as published by
6
 
 * the Free Software Foundation; either version 2 of the License, or
7
 
 * (at your option) any later version.
8
 
 *
9
 
 * This program is distributed in the hope that it will be useful,
10
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
 * GNU General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU General Public License
15
 
 * along with this program; if not, write to the Free Software
16
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 */
18
 
 
19
 
#include <linux/kernel.h>
20
 
#include <linux/init.h>
21
 
#include <linux/list.h>
22
 
#include <linux/math64.h>
23
 
#include <linux/err.h>
24
 
#include <linux/clk.h>
25
 
#include <linux/io.h>
26
 
 
27
 
#include <asm/clkdev.h>
28
 
 
29
 
#include <mach/clock.h>
30
 
#include <mach/hardware.h>
31
 
#include <mach/common.h>
32
 
#include "crm_regs.h"
33
 
 
34
 
static int _clk_enable(struct clk *clk)
35
 
{
36
 
        unsigned int reg;
37
 
 
38
 
        reg = __raw_readl(clk->enable_reg);
39
 
        reg |= 1 << clk->enable_shift;
40
 
        __raw_writel(reg, clk->enable_reg);
41
 
 
42
 
        return 0;
43
 
}
44
 
 
45
 
static void _clk_disable(struct clk *clk)
46
 
{
47
 
        unsigned int reg;
48
 
 
49
 
        reg = __raw_readl(clk->enable_reg);
50
 
        reg &= ~(1 << clk->enable_shift);
51
 
        __raw_writel(reg, clk->enable_reg);
52
 
}
53
 
 
54
 
static int _clk_can_use_parent(const struct clk *clk_arr[], unsigned int size,
55
 
                               struct clk *parent)
56
 
{
57
 
        int i;
58
 
 
59
 
        for (i = 0; i < size; i++)
60
 
                if (parent == clk_arr[i])
61
 
                        return i;
62
 
 
63
 
        return -EINVAL;
64
 
}
65
 
 
66
 
static unsigned long
67
 
_clk_simple_round_rate(struct clk *clk, unsigned long rate, unsigned int limit)
68
 
{
69
 
        int div;
70
 
        unsigned long parent_rate;
71
 
 
72
 
        parent_rate = clk_get_rate(clk->parent);
73
 
 
74
 
        div = parent_rate / rate;
75
 
        if (parent_rate % rate)
76
 
                div++;
77
 
 
78
 
        if (div > limit)
79
 
                div = limit;
80
 
 
81
 
        return parent_rate / div;
82
 
}
83
 
 
84
 
static unsigned long _clk_parent_round_rate(struct clk *clk, unsigned long rate)
85
 
{
86
 
        return clk->parent->round_rate(clk->parent, rate);
87
 
}
88
 
 
89
 
static int _clk_parent_set_rate(struct clk *clk, unsigned long rate)
90
 
{
91
 
        return clk->parent->set_rate(clk->parent, rate);
92
 
}
93
 
 
94
 
static unsigned long clk16m_get_rate(struct clk *clk)
95
 
{
96
 
        return 16000000;
97
 
}
98
 
 
99
 
static struct clk clk16m = {
100
 
        .get_rate = clk16m_get_rate,
101
 
        .enable = _clk_enable,
102
 
        .enable_reg = CCM_CSCR,
103
 
        .enable_shift = CCM_CSCR_OSC_EN_SHIFT,
104
 
        .disable = _clk_disable,
105
 
};
106
 
 
107
 
/* in Hz */
108
 
static unsigned long clk32_rate;
109
 
 
110
 
static unsigned long clk32_get_rate(struct clk *clk)
111
 
{
112
 
        return clk32_rate;
113
 
}
114
 
 
115
 
static struct clk clk32 = {
116
 
        .get_rate = clk32_get_rate,
117
 
};
118
 
 
119
 
static unsigned long clk32_premult_get_rate(struct clk *clk)
120
 
{
121
 
        return clk_get_rate(clk->parent) * 512;
122
 
}
123
 
 
124
 
static struct clk clk32_premult = {
125
 
        .parent = &clk32,
126
 
        .get_rate = clk32_premult_get_rate,
127
 
};
128
 
 
129
 
static const struct clk *prem_clk_clocks[] = {
130
 
        &clk32_premult,
131
 
        &clk16m,
132
 
};
133
 
 
134
 
static int prem_clk_set_parent(struct clk *clk, struct clk *parent)
135
 
{
136
 
        int i;
137
 
        unsigned int reg = __raw_readl(CCM_CSCR);
138
 
 
139
 
        i = _clk_can_use_parent(prem_clk_clocks, ARRAY_SIZE(prem_clk_clocks),
140
 
                                parent);
141
 
 
142
 
        switch (i) {
143
 
        case 0:
144
 
                reg &= ~CCM_CSCR_SYSTEM_SEL;
145
 
                break;
146
 
        case 1:
147
 
                reg |= CCM_CSCR_SYSTEM_SEL;
148
 
                break;
149
 
        default:
150
 
                return i;
151
 
        }
152
 
 
153
 
        __raw_writel(reg, CCM_CSCR);
154
 
 
155
 
        return 0;
156
 
}
157
 
 
158
 
static struct clk prem_clk = {
159
 
        .set_parent = prem_clk_set_parent,
160
 
};
161
 
 
162
 
static unsigned long system_clk_get_rate(struct clk *clk)
163
 
{
164
 
        return mxc_decode_pll(__raw_readl(CCM_SPCTL0),
165
 
                              clk_get_rate(clk->parent));
166
 
}
167
 
 
168
 
static struct clk system_clk = {
169
 
        .parent = &prem_clk,
170
 
        .get_rate = system_clk_get_rate,
171
 
};
172
 
 
173
 
static unsigned long mcu_clk_get_rate(struct clk *clk)
174
 
{
175
 
        return mxc_decode_pll(__raw_readl(CCM_MPCTL0),
176
 
                              clk_get_rate(clk->parent));
177
 
}
178
 
 
179
 
static struct clk mcu_clk = {
180
 
        .parent = &clk32_premult,
181
 
        .get_rate = mcu_clk_get_rate,
182
 
};
183
 
 
184
 
static unsigned long fclk_get_rate(struct clk *clk)
185
 
{
186
 
        unsigned long fclk = clk_get_rate(clk->parent);
187
 
 
188
 
        if (__raw_readl(CCM_CSCR) & CCM_CSCR_PRESC)
189
 
                fclk /= 2;
190
 
 
191
 
        return fclk;
192
 
}
193
 
 
194
 
static struct clk fclk = {
195
 
        .parent = &mcu_clk,
196
 
        .get_rate = fclk_get_rate,
197
 
};
198
 
 
199
 
/*
200
 
 *  get hclk ( SDRAM, CSI, Memory Stick, I2C, DMA )
201
 
 */
202
 
static unsigned long hclk_get_rate(struct clk *clk)
203
 
{
204
 
        return clk_get_rate(clk->parent) / (((__raw_readl(CCM_CSCR) &
205
 
                        CCM_CSCR_BCLK_MASK) >> CCM_CSCR_BCLK_OFFSET) + 1);
206
 
}
207
 
 
208
 
static unsigned long hclk_round_rate(struct clk *clk, unsigned long rate)
209
 
{
210
 
        return _clk_simple_round_rate(clk, rate, 16);
211
 
}
212
 
 
213
 
static int hclk_set_rate(struct clk *clk, unsigned long rate)
214
 
{
215
 
        unsigned int div;
216
 
        unsigned int reg;
217
 
        unsigned long parent_rate;
218
 
 
219
 
        parent_rate = clk_get_rate(clk->parent);
220
 
 
221
 
        div = parent_rate / rate;
222
 
 
223
 
        if (div > 16 || div < 1 || ((parent_rate / div) != rate))
224
 
                return -EINVAL;
225
 
 
226
 
        div--;
227
 
 
228
 
        reg = __raw_readl(CCM_CSCR);
229
 
        reg &= ~CCM_CSCR_BCLK_MASK;
230
 
        reg |= div << CCM_CSCR_BCLK_OFFSET;
231
 
        __raw_writel(reg, CCM_CSCR);
232
 
 
233
 
        return 0;
234
 
}
235
 
 
236
 
static struct clk hclk = {
237
 
        .parent = &system_clk,
238
 
        .get_rate = hclk_get_rate,
239
 
        .round_rate = hclk_round_rate,
240
 
        .set_rate = hclk_set_rate,
241
 
};
242
 
 
243
 
static unsigned long clk48m_get_rate(struct clk *clk)
244
 
{
245
 
        return clk_get_rate(clk->parent) / (((__raw_readl(CCM_CSCR) &
246
 
                        CCM_CSCR_USB_MASK) >> CCM_CSCR_USB_OFFSET) + 1);
247
 
}
248
 
 
249
 
static unsigned long clk48m_round_rate(struct clk *clk, unsigned long rate)
250
 
{
251
 
        return _clk_simple_round_rate(clk, rate, 8);
252
 
}
253
 
 
254
 
static int clk48m_set_rate(struct clk *clk, unsigned long rate)
255
 
{
256
 
        unsigned int div;
257
 
        unsigned int reg;
258
 
        unsigned long parent_rate;
259
 
 
260
 
        parent_rate = clk_get_rate(clk->parent);
261
 
 
262
 
        div = parent_rate / rate;
263
 
 
264
 
        if (div > 8 || div < 1 || ((parent_rate / div) != rate))
265
 
                return -EINVAL;
266
 
 
267
 
        div--;
268
 
 
269
 
        reg = __raw_readl(CCM_CSCR);
270
 
        reg &= ~CCM_CSCR_USB_MASK;
271
 
        reg |= div << CCM_CSCR_USB_OFFSET;
272
 
        __raw_writel(reg, CCM_CSCR);
273
 
 
274
 
        return 0;
275
 
}
276
 
 
277
 
static struct clk clk48m = {
278
 
        .parent = &system_clk,
279
 
        .get_rate = clk48m_get_rate,
280
 
        .round_rate = clk48m_round_rate,
281
 
        .set_rate = clk48m_set_rate,
282
 
};
283
 
 
284
 
/*
285
 
 *  get peripheral clock 1 ( UART[12], Timer[12], PWM )
286
 
 */
287
 
static unsigned long perclk1_get_rate(struct clk *clk)
288
 
{
289
 
        return clk_get_rate(clk->parent) / (((__raw_readl(CCM_PCDR) &
290
 
                        CCM_PCDR_PCLK1_MASK) >> CCM_PCDR_PCLK1_OFFSET) + 1);
291
 
}
292
 
 
293
 
static unsigned long perclk1_round_rate(struct clk *clk, unsigned long rate)
294
 
{
295
 
        return _clk_simple_round_rate(clk, rate, 16);
296
 
}
297
 
 
298
 
static int perclk1_set_rate(struct clk *clk, unsigned long rate)
299
 
{
300
 
        unsigned int div;
301
 
        unsigned int reg;
302
 
        unsigned long parent_rate;
303
 
 
304
 
        parent_rate = clk_get_rate(clk->parent);
305
 
 
306
 
        div = parent_rate / rate;
307
 
 
308
 
        if (div > 16 || div < 1 || ((parent_rate / div) != rate))
309
 
                return -EINVAL;
310
 
 
311
 
        div--;
312
 
 
313
 
        reg = __raw_readl(CCM_PCDR);
314
 
        reg &= ~CCM_PCDR_PCLK1_MASK;
315
 
        reg |= div << CCM_PCDR_PCLK1_OFFSET;
316
 
        __raw_writel(reg, CCM_PCDR);
317
 
 
318
 
        return 0;
319
 
}
320
 
 
321
 
/*
322
 
 *  get peripheral clock 2 ( LCD, SD, SPI[12] )
323
 
 */
324
 
static unsigned long perclk2_get_rate(struct clk *clk)
325
 
{
326
 
        return clk_get_rate(clk->parent) / (((__raw_readl(CCM_PCDR) &
327
 
                        CCM_PCDR_PCLK2_MASK) >> CCM_PCDR_PCLK2_OFFSET) + 1);
328
 
}
329
 
 
330
 
static unsigned long perclk2_round_rate(struct clk *clk, unsigned long rate)
331
 
{
332
 
        return _clk_simple_round_rate(clk, rate, 16);
333
 
}
334
 
 
335
 
static int perclk2_set_rate(struct clk *clk, unsigned long rate)
336
 
{
337
 
        unsigned int div;
338
 
        unsigned int reg;
339
 
        unsigned long parent_rate;
340
 
 
341
 
        parent_rate = clk_get_rate(clk->parent);
342
 
 
343
 
        div = parent_rate / rate;
344
 
 
345
 
        if (div > 16 || div < 1 || ((parent_rate / div) != rate))
346
 
                return -EINVAL;
347
 
 
348
 
        div--;
349
 
 
350
 
        reg = __raw_readl(CCM_PCDR);
351
 
        reg &= ~CCM_PCDR_PCLK2_MASK;
352
 
        reg |= div << CCM_PCDR_PCLK2_OFFSET;
353
 
        __raw_writel(reg, CCM_PCDR);
354
 
 
355
 
        return 0;
356
 
}
357
 
 
358
 
/*
359
 
 *  get peripheral clock 3 ( SSI )
360
 
 */
361
 
static unsigned long perclk3_get_rate(struct clk *clk)
362
 
{
363
 
        return clk_get_rate(clk->parent) / (((__raw_readl(CCM_PCDR) &
364
 
                        CCM_PCDR_PCLK3_MASK) >> CCM_PCDR_PCLK3_OFFSET) + 1);
365
 
}
366
 
 
367
 
static unsigned long perclk3_round_rate(struct clk *clk, unsigned long rate)
368
 
{
369
 
        return _clk_simple_round_rate(clk, rate, 128);
370
 
}
371
 
 
372
 
static int perclk3_set_rate(struct clk *clk, unsigned long rate)
373
 
{
374
 
        unsigned int div;
375
 
        unsigned int reg;
376
 
        unsigned long parent_rate;
377
 
 
378
 
        parent_rate = clk_get_rate(clk->parent);
379
 
 
380
 
        div = parent_rate / rate;
381
 
 
382
 
        if (div > 128 || div < 1 || ((parent_rate / div) != rate))
383
 
                return -EINVAL;
384
 
 
385
 
        div--;
386
 
 
387
 
        reg = __raw_readl(CCM_PCDR);
388
 
        reg &= ~CCM_PCDR_PCLK3_MASK;
389
 
        reg |= div << CCM_PCDR_PCLK3_OFFSET;
390
 
        __raw_writel(reg, CCM_PCDR);
391
 
 
392
 
        return 0;
393
 
}
394
 
 
395
 
static struct clk perclk[] = {
396
 
        {
397
 
                .id = 0,
398
 
                .parent = &system_clk,
399
 
                .get_rate = perclk1_get_rate,
400
 
                .round_rate = perclk1_round_rate,
401
 
                .set_rate = perclk1_set_rate,
402
 
        }, {
403
 
                .id = 1,
404
 
                .parent = &system_clk,
405
 
                .get_rate = perclk2_get_rate,
406
 
                .round_rate = perclk2_round_rate,
407
 
                .set_rate = perclk2_set_rate,
408
 
        }, {
409
 
                .id = 2,
410
 
                .parent = &system_clk,
411
 
                .get_rate = perclk3_get_rate,
412
 
                .round_rate = perclk3_round_rate,
413
 
                .set_rate = perclk3_set_rate,
414
 
        }
415
 
};
416
 
 
417
 
static const struct clk *clko_clocks[] = {
418
 
        &perclk[0],
419
 
        &hclk,
420
 
        &clk48m,
421
 
        &clk16m,
422
 
        &prem_clk,
423
 
        &fclk,
424
 
};
425
 
 
426
 
static int clko_set_parent(struct clk *clk, struct clk *parent)
427
 
{
428
 
        int i;
429
 
        unsigned int reg;
430
 
 
431
 
        i = _clk_can_use_parent(clko_clocks, ARRAY_SIZE(clko_clocks), parent);
432
 
        if (i < 0)
433
 
                return i;
434
 
 
435
 
        reg = __raw_readl(CCM_CSCR) & ~CCM_CSCR_CLKO_MASK;
436
 
        reg |= i << CCM_CSCR_CLKO_OFFSET;
437
 
        __raw_writel(reg, CCM_CSCR);
438
 
 
439
 
        if (clko_clocks[i]->set_rate && clko_clocks[i]->round_rate) {
440
 
                clk->set_rate = _clk_parent_set_rate;
441
 
                clk->round_rate = _clk_parent_round_rate;
442
 
        } else {
443
 
                clk->set_rate = NULL;
444
 
                clk->round_rate = NULL;
445
 
        }
446
 
 
447
 
        return 0;
448
 
}
449
 
 
450
 
static struct clk clko_clk = {
451
 
        .set_parent = clko_set_parent,
452
 
};
453
 
 
454
 
static struct clk dma_clk = {
455
 
        .parent = &hclk,
456
 
        .round_rate = _clk_parent_round_rate,
457
 
        .set_rate = _clk_parent_set_rate,
458
 
        .enable = _clk_enable,
459
 
        .enable_reg = SCM_GCCR,
460
 
        .enable_shift = SCM_GCCR_DMA_CLK_EN_OFFSET,
461
 
        .disable = _clk_disable,
462
 
};
463
 
 
464
 
static struct clk csi_clk = {
465
 
        .parent = &hclk,
466
 
        .round_rate = _clk_parent_round_rate,
467
 
        .set_rate = _clk_parent_set_rate,
468
 
        .enable = _clk_enable,
469
 
        .enable_reg = SCM_GCCR,
470
 
        .enable_shift = SCM_GCCR_CSI_CLK_EN_OFFSET,
471
 
        .disable = _clk_disable,
472
 
};
473
 
 
474
 
static struct clk mma_clk = {
475
 
        .parent = &hclk,
476
 
        .round_rate = _clk_parent_round_rate,
477
 
        .set_rate = _clk_parent_set_rate,
478
 
        .enable = _clk_enable,
479
 
        .enable_reg = SCM_GCCR,
480
 
        .enable_shift = SCM_GCCR_MMA_CLK_EN_OFFSET,
481
 
        .disable = _clk_disable,
482
 
};
483
 
 
484
 
static struct clk usbd_clk = {
485
 
        .parent = &clk48m,
486
 
        .round_rate = _clk_parent_round_rate,
487
 
        .set_rate = _clk_parent_set_rate,
488
 
        .enable = _clk_enable,
489
 
        .enable_reg = SCM_GCCR,
490
 
        .enable_shift = SCM_GCCR_USBD_CLK_EN_OFFSET,
491
 
        .disable = _clk_disable,
492
 
};
493
 
 
494
 
static struct clk gpt_clk = {
495
 
        .parent = &perclk[0],
496
 
        .round_rate = _clk_parent_round_rate,
497
 
        .set_rate = _clk_parent_set_rate,
498
 
};
499
 
 
500
 
static struct clk uart_clk = {
501
 
        .parent = &perclk[0],
502
 
        .round_rate = _clk_parent_round_rate,
503
 
        .set_rate = _clk_parent_set_rate,
504
 
};
505
 
 
506
 
static struct clk i2c_clk = {
507
 
        .parent = &hclk,
508
 
        .round_rate = _clk_parent_round_rate,
509
 
        .set_rate = _clk_parent_set_rate,
510
 
};
511
 
 
512
 
static struct clk spi_clk = {
513
 
        .parent = &perclk[1],
514
 
        .round_rate = _clk_parent_round_rate,
515
 
        .set_rate = _clk_parent_set_rate,
516
 
};
517
 
 
518
 
static struct clk sdhc_clk = {
519
 
        .parent = &perclk[1],
520
 
        .round_rate = _clk_parent_round_rate,
521
 
        .set_rate = _clk_parent_set_rate,
522
 
};
523
 
 
524
 
static struct clk lcdc_clk = {
525
 
        .parent = &perclk[1],
526
 
        .round_rate = _clk_parent_round_rate,
527
 
        .set_rate = _clk_parent_set_rate,
528
 
};
529
 
 
530
 
static struct clk mshc_clk = {
531
 
        .parent = &hclk,
532
 
        .round_rate = _clk_parent_round_rate,
533
 
        .set_rate = _clk_parent_set_rate,
534
 
};
535
 
 
536
 
static struct clk ssi_clk = {
537
 
        .parent = &perclk[2],
538
 
        .round_rate = _clk_parent_round_rate,
539
 
        .set_rate = _clk_parent_set_rate,
540
 
};
541
 
 
542
 
static struct clk rtc_clk = {
543
 
        .parent = &clk32,
544
 
};
545
 
 
546
 
#define _REGISTER_CLOCK(d, n, c) \
547
 
        { \
548
 
                .dev_id = d, \
549
 
                .con_id = n, \
550
 
                .clk = &c, \
551
 
        },
552
 
static struct clk_lookup lookups[] __initdata = {
553
 
        _REGISTER_CLOCK(NULL, "dma", dma_clk)
554
 
        _REGISTER_CLOCK("mx1-camera.0", NULL, csi_clk)
555
 
        _REGISTER_CLOCK(NULL, "mma", mma_clk)
556
 
        _REGISTER_CLOCK("imx_udc.0", NULL, usbd_clk)
557
 
        _REGISTER_CLOCK(NULL, "gpt", gpt_clk)
558
 
        _REGISTER_CLOCK("imx-uart.0", NULL, uart_clk)
559
 
        _REGISTER_CLOCK("imx-uart.1", NULL, uart_clk)
560
 
        _REGISTER_CLOCK("imx-uart.2", NULL, uart_clk)
561
 
        _REGISTER_CLOCK("imx-i2c.0", NULL, i2c_clk)
562
 
        _REGISTER_CLOCK("spi_imx.0", NULL, spi_clk)
563
 
        _REGISTER_CLOCK("imx-mmc.0", NULL, sdhc_clk)
564
 
        _REGISTER_CLOCK("imx-fb.0", NULL, lcdc_clk)
565
 
        _REGISTER_CLOCK(NULL, "mshc", mshc_clk)
566
 
        _REGISTER_CLOCK(NULL, "ssi", ssi_clk)
567
 
        _REGISTER_CLOCK("mxc_rtc.0", NULL, rtc_clk)
568
 
};
569
 
 
570
 
int __init mx1_clocks_init(unsigned long fref)
571
 
{
572
 
        unsigned int reg;
573
 
        int i;
574
 
 
575
 
        /* disable clocks we are able to */
576
 
        __raw_writel(0, SCM_GCCR);
577
 
 
578
 
        clk32_rate = fref;
579
 
        reg = __raw_readl(CCM_CSCR);
580
 
 
581
 
        /* detect clock reference for system PLL */
582
 
        if (reg & CCM_CSCR_SYSTEM_SEL) {
583
 
                prem_clk.parent = &clk16m;
584
 
        } else {
585
 
                /* ensure that oscillator is disabled */
586
 
                reg &= ~(1 << CCM_CSCR_OSC_EN_SHIFT);
587
 
                __raw_writel(reg, CCM_CSCR);
588
 
                prem_clk.parent = &clk32_premult;
589
 
        }
590
 
 
591
 
        /* detect reference for CLKO */
592
 
        reg = (reg & CCM_CSCR_CLKO_MASK) >> CCM_CSCR_CLKO_OFFSET;
593
 
        clko_clk.parent = (struct clk *)clko_clocks[reg];
594
 
 
595
 
        for (i = 0; i < ARRAY_SIZE(lookups); i++)
596
 
                clkdev_add(&lookups[i]);
597
 
 
598
 
        clk_enable(&hclk);
599
 
        clk_enable(&fclk);
600
 
 
601
 
        mxc_timer_init(&gpt_clk, IO_ADDRESS(TIM1_BASE_ADDR), TIM1_INT);
602
 
 
603
 
        return 0;
604
 
}