← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/linaro-patches-1.5.0/0012-hw-omap_clk.c-Add-OMAP3-clock-tree-definitions.patch/hw/misc/omap_clk.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/linaro-patches-1.5.0/0012-hw-omap_clk.c-Add-OMAP3-clock-tree-definitions.patch/hw/misc/omap_clk.c
1
 
/*
2
 
 * OMAP clocks.
3
 
 *
4
 
 * Copyright (C) 2006-2008 Andrzej Zaborowski  <balrog@zabor.org>
5
 
 *
6
 
 * Clocks data comes in part from arch/arm/mach-omap1/clock.h in Linux.
7
 
 *
8
 
 * This program is free software; you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation; either version 2 of
11
 
 * the License, or (at your option) any later version.
12
 
 *
13
 
 * This program is distributed in the hope that it will be useful,
14
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
 * GNU General Public License for more details.
17
 
 *
18
 
 * You should have received a copy of the GNU General Public License along
19
 
 * with this program; if not, see <http://www.gnu.org/licenses/>.
20
 
 */
21
 
#include "hw/hw.h"
22
 
#include "hw/arm/omap.h"
23
 
 
24
 
struct clk {
25
 
    const char *name;
26
 
    const char *alias;
27
 
    struct clk *parent;
28
 
    struct clk *child1;
29
 
    struct clk *sibling;
30
 
#define ALWAYS_ENABLED          (1 << 0)
31
 
#define CLOCK_IN_OMAP310        (1 << 10)
32
 
#define CLOCK_IN_OMAP730        (1 << 11)
33
 
#define CLOCK_IN_OMAP1510       (1 << 12)
34
 
#define CLOCK_IN_OMAP16XX       (1 << 13)
35
 
#define CLOCK_IN_OMAP242X       (1 << 14)
36
 
#define CLOCK_IN_OMAP243X       (1 << 15)
37
 
#define CLOCK_IN_OMAP343X       (1 << 16)
38
 
    uint32_t flags;
39
 
    int id;
40
 
 
41
 
    int running;                /* Is currently ticking */
42
 
    int enabled;                /* Is enabled, regardless of its input clk */
43
 
    unsigned long rate;         /* Current rate (if .running) */
44
 
    unsigned int divisor;       /* Rate relative to input (if .enabled) */
45
 
    unsigned int multiplier;    /* Rate relative to input (if .enabled) */
46
 
    qemu_irq users[16];         /* Who to notify on change */
47
 
    int usecount;               /* Automatically idle when unused */
48
 
};
49
 
 
50
 
static struct clk xtal_osc12m = {
51
 
    .name       = "xtal_osc_12m",
52
 
    .rate       = 12000000,
53
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
54
 
};
55
 
 
56
 
static struct clk xtal_osc32k = {
57
 
    .name       = "xtal_osc_32k",
58
 
    .rate       = 32768,
59
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
60
 
            CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
61
 
};
62
 
 
63
 
static struct clk ck_ref = {
64
 
    .name       = "ck_ref",
65
 
    .alias      = "clkin",
66
 
    .parent     = &xtal_osc12m,
67
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
68
 
            ALWAYS_ENABLED,
69
 
};
70
 
 
71
 
/* If a dpll is disabled it becomes a bypass, child clocks don't stop */
72
 
static struct clk dpll1 = {
73
 
    .name       = "dpll1",
74
 
    .parent     = &ck_ref,
75
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
76
 
            ALWAYS_ENABLED,
77
 
};
78
 
 
79
 
static struct clk dpll2 = {
80
 
    .name       = "dpll2",
81
 
    .parent     = &ck_ref,
82
 
    .flags      = CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
83
 
};
84
 
 
85
 
static struct clk dpll3 = {
86
 
    .name       = "dpll3",
87
 
    .parent     = &ck_ref,
88
 
    .flags      = CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
89
 
};
90
 
 
91
 
static struct clk dpll4 = {
92
 
    .name       = "dpll4",
93
 
    .parent     = &ck_ref,
94
 
    .multiplier = 4,
95
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
96
 
};
97
 
 
98
 
static struct clk apll = {
99
 
    .name       = "apll",
100
 
    .parent     = &ck_ref,
101
 
    .multiplier = 48,
102
 
    .divisor    = 12,
103
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
104
 
};
105
 
 
106
 
static struct clk ck_48m = {
107
 
    .name       = "ck_48m",
108
 
    .parent     = &dpll4,       /* either dpll4 or apll */
109
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
110
 
};
111
 
 
112
 
static struct clk ck_dpll1out = {
113
 
    .name       = "ck_dpll1out",
114
 
    .parent     = &dpll1,
115
 
    .flags      = CLOCK_IN_OMAP16XX,
116
 
};
117
 
 
118
 
static struct clk sossi_ck = {
119
 
    .name       = "ck_sossi",
120
 
    .parent     = &ck_dpll1out,
121
 
    .flags      = CLOCK_IN_OMAP16XX,
122
 
};
123
 
 
124
 
static struct clk clkm1 = {
125
 
    .name       = "clkm1",
126
 
    .alias      = "ck_gen1",
127
 
    .parent     = &dpll1,
128
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
129
 
            ALWAYS_ENABLED,
130
 
};
131
 
 
132
 
static struct clk clkm2 = {
133
 
    .name       = "clkm2",
134
 
    .alias      = "ck_gen2",
135
 
    .parent     = &dpll1,
136
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
137
 
            ALWAYS_ENABLED,
138
 
};
139
 
 
140
 
static struct clk clkm3 = {
141
 
    .name       = "clkm3",
142
 
    .alias      = "ck_gen3",
143
 
    .parent     = &dpll1,       /* either dpll1 or ck_ref */
144
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
145
 
            ALWAYS_ENABLED,
146
 
};
147
 
 
148
 
static struct clk arm_ck = {
149
 
    .name       = "arm_ck",
150
 
    .alias      = "mpu_ck",
151
 
    .parent     = &clkm1,
152
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
153
 
            ALWAYS_ENABLED,
154
 
};
155
 
 
156
 
static struct clk armper_ck = {
157
 
    .name       = "armper_ck",
158
 
    .alias      = "mpuper_ck",
159
 
    .parent     = &clkm1,
160
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
161
 
};
162
 
 
163
 
static struct clk arm_gpio_ck = {
164
 
    .name       = "arm_gpio_ck",
165
 
    .alias      = "mpu_gpio_ck",
166
 
    .parent     = &clkm1,
167
 
    .divisor    = 1,
168
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
169
 
};
170
 
 
171
 
static struct clk armxor_ck = {
172
 
    .name       = "armxor_ck",
173
 
    .alias      = "mpuxor_ck",
174
 
    .parent     = &ck_ref,
175
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
176
 
};
177
 
 
178
 
static struct clk armtim_ck = {
179
 
    .name       = "armtim_ck",
180
 
    .alias      = "mputim_ck",
181
 
    .parent     = &ck_ref,      /* either CLKIN or DPLL1 */
182
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
183
 
};
184
 
 
185
 
static struct clk armwdt_ck = {
186
 
    .name       = "armwdt_ck",
187
 
    .alias      = "mpuwd_ck",
188
 
    .parent     = &clkm1,
189
 
    .divisor    = 14,
190
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
191
 
            ALWAYS_ENABLED,
192
 
};
193
 
 
194
 
static struct clk arminth_ck16xx = {
195
 
    .name       = "arminth_ck",
196
 
    .parent     = &arm_ck,
197
 
    .flags      = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
198
 
    /* Note: On 16xx the frequency can be divided by 2 by programming
199
 
     * ARM_CKCTL:ARM_INTHCK_SEL(14) to 1
200
 
     *
201
 
     * 1510 version is in TC clocks.
202
 
     */
203
 
};
204
 
 
205
 
static struct clk dsp_ck = {
206
 
    .name       = "dsp_ck",
207
 
    .parent     = &clkm2,
208
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
209
 
};
210
 
 
211
 
static struct clk dspmmu_ck = {
212
 
    .name       = "dspmmu_ck",
213
 
    .parent     = &clkm2,
214
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
215
 
            ALWAYS_ENABLED,
216
 
};
217
 
 
218
 
static struct clk dspper_ck = {
219
 
    .name       = "dspper_ck",
220
 
    .parent     = &clkm2,
221
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
222
 
};
223
 
 
224
 
static struct clk dspxor_ck = {
225
 
    .name       = "dspxor_ck",
226
 
    .parent     = &ck_ref,
227
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
228
 
};
229
 
 
230
 
static struct clk dsptim_ck = {
231
 
    .name       = "dsptim_ck",
232
 
    .parent     = &ck_ref,
233
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
234
 
};
235
 
 
236
 
static struct clk tc_ck = {
237
 
    .name       = "tc_ck",
238
 
    .parent     = &clkm3,
239
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
240
 
            CLOCK_IN_OMAP730 | CLOCK_IN_OMAP310 |
241
 
            ALWAYS_ENABLED,
242
 
};
243
 
 
244
 
static struct clk arminth_ck15xx = {
245
 
    .name       = "arminth_ck",
246
 
    .parent     = &tc_ck,
247
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
248
 
    /* Note: On 1510 the frequency follows TC_CK
249
 
     *
250
 
     * 16xx version is in MPU clocks.
251
 
     */
252
 
};
253
 
 
254
 
static struct clk tipb_ck = {
255
 
    /* No-idle controlled by "tc_ck" */
256
 
    .name       = "tipb_ck",
257
 
    .parent     = &tc_ck,
258
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
259
 
};
260
 
 
261
 
static struct clk l3_ocpi_ck = {
262
 
    /* No-idle controlled by "tc_ck" */
263
 
    .name       = "l3_ocpi_ck",
264
 
    .parent     = &tc_ck,
265
 
    .flags      = CLOCK_IN_OMAP16XX,
266
 
};
267
 
 
268
 
static struct clk tc1_ck = {
269
 
    .name       = "tc1_ck",
270
 
    .parent     = &tc_ck,
271
 
    .flags      = CLOCK_IN_OMAP16XX,
272
 
};
273
 
 
274
 
static struct clk tc2_ck = {
275
 
    .name       = "tc2_ck",
276
 
    .parent     = &tc_ck,
277
 
    .flags      = CLOCK_IN_OMAP16XX,
278
 
};
279
 
 
280
 
static struct clk dma_ck = {
281
 
    /* No-idle controlled by "tc_ck" */
282
 
    .name       = "dma_ck",
283
 
    .parent     = &tc_ck,
284
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
285
 
            ALWAYS_ENABLED,
286
 
};
287
 
 
288
 
static struct clk dma_lcdfree_ck = {
289
 
    .name       = "dma_lcdfree_ck",
290
 
    .parent     = &tc_ck,
291
 
    .flags      = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
292
 
};
293
 
 
294
 
static struct clk api_ck = {
295
 
    .name       = "api_ck",
296
 
    .alias      = "mpui_ck",
297
 
    .parent     = &tc_ck,
298
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
299
 
};
300
 
 
301
 
static struct clk lb_ck = {
302
 
    .name       = "lb_ck",
303
 
    .parent     = &tc_ck,
304
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
305
 
};
306
 
 
307
 
static struct clk lbfree_ck = {
308
 
    .name       = "lbfree_ck",
309
 
    .parent     = &tc_ck,
310
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
311
 
};
312
 
 
313
 
static struct clk hsab_ck = {
314
 
    .name       = "hsab_ck",
315
 
    .parent     = &tc_ck,
316
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
317
 
};
318
 
 
319
 
static struct clk rhea1_ck = {
320
 
    .name       = "rhea1_ck",
321
 
    .parent     = &tc_ck,
322
 
    .flags      = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
323
 
};
324
 
 
325
 
static struct clk rhea2_ck = {
326
 
    .name       = "rhea2_ck",
327
 
    .parent     = &tc_ck,
328
 
    .flags      = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
329
 
};
330
 
 
331
 
static struct clk lcd_ck_16xx = {
332
 
    .name       = "lcd_ck",
333
 
    .parent     = &clkm3,
334
 
    .flags      = CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP730,
335
 
};
336
 
 
337
 
static struct clk lcd_ck_1510 = {
338
 
    .name       = "lcd_ck",
339
 
    .parent     = &clkm3,
340
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
341
 
};
342
 
 
343
 
static struct clk uart1_1510 = {
344
 
    .name       = "uart1_ck",
345
 
    /* Direct from ULPD, no real parent */
346
 
    .parent     = &armper_ck,   /* either armper_ck or dpll4 */
347
 
    .rate       = 12000000,
348
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
349
 
};
350
 
 
351
 
static struct clk uart1_16xx = {
352
 
    .name       = "uart1_ck",
353
 
    /* Direct from ULPD, no real parent */
354
 
    .parent     = &armper_ck,
355
 
    .rate       = 48000000,
356
 
    .flags      = CLOCK_IN_OMAP16XX,
357
 
};
358
 
 
359
 
static struct clk uart2_ck = {
360
 
    .name       = "uart2_ck",
361
 
    /* Direct from ULPD, no real parent */
362
 
    .parent     = &armper_ck,   /* either armper_ck or dpll4 */
363
 
    .rate       = 12000000,
364
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310 |
365
 
            ALWAYS_ENABLED,
366
 
};
367
 
 
368
 
static struct clk uart3_1510 = {
369
 
    .name       = "uart3_ck",
370
 
    /* Direct from ULPD, no real parent */
371
 
    .parent     = &armper_ck,   /* either armper_ck or dpll4 */
372
 
    .rate       = 12000000,
373
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310 | ALWAYS_ENABLED,
374
 
};
375
 
 
376
 
static struct clk uart3_16xx = {
377
 
    .name       = "uart3_ck",
378
 
    /* Direct from ULPD, no real parent */
379
 
    .parent     = &armper_ck,
380
 
    .rate       = 48000000,
381
 
    .flags      = CLOCK_IN_OMAP16XX,
382
 
};
383
 
 
384
 
static struct clk usb_clk0 = {  /* 6 MHz output on W4_USB_CLK0 */
385
 
    .name       = "usb_clk0",
386
 
    .alias      = "usb.clko",
387
 
    /* Direct from ULPD, no parent */
388
 
    .rate       = 6000000,
389
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
390
 
};
391
 
 
392
 
static struct clk usb_hhc_ck1510 = {
393
 
    .name       = "usb_hhc_ck",
394
 
    /* Direct from ULPD, no parent */
395
 
    .rate       = 48000000, /* Actually 2 clocks, 12MHz and 48MHz */
396
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP310,
397
 
};
398
 
 
399
 
static struct clk usb_hhc_ck16xx = {
400
 
    .name       = "usb_hhc_ck",
401
 
    /* Direct from ULPD, no parent */
402
 
    .rate       = 48000000,
403
 
    /* OTG_SYSCON_2.OTG_PADEN == 0 (not 1510-compatible) */
404
 
    .flags      = CLOCK_IN_OMAP16XX,
405
 
};
406
 
 
407
 
static struct clk usb_w2fc_mclk = {
408
 
    .name       = "usb_w2fc_mclk",
409
 
    .alias      = "usb_w2fc_ck",
410
 
    .parent     = &ck_48m,
411
 
    .rate       = 48000000,
412
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
413
 
};
414
 
 
415
 
static struct clk mclk_1510 = {
416
 
    .name       = "mclk",
417
 
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
418
 
    .rate       = 12000000,
419
 
    .flags      = CLOCK_IN_OMAP1510,
420
 
};
421
 
 
422
 
static struct clk bclk_310 = {
423
 
    .name       = "bt_mclk_out",        /* Alias midi_mclk_out? */
424
 
    .parent     = &armper_ck,
425
 
    .flags      = CLOCK_IN_OMAP310,
426
 
};
427
 
 
428
 
static struct clk mclk_310 = {
429
 
    .name       = "com_mclk_out",
430
 
    .parent     = &armper_ck,
431
 
    .flags      = CLOCK_IN_OMAP310,
432
 
};
433
 
 
434
 
static struct clk mclk_16xx = {
435
 
    .name       = "mclk",
436
 
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
437
 
    .flags      = CLOCK_IN_OMAP16XX,
438
 
};
439
 
 
440
 
static struct clk bclk_1510 = {
441
 
    .name       = "bclk",
442
 
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
443
 
    .rate       = 12000000,
444
 
    .flags      = CLOCK_IN_OMAP1510,
445
 
};
446
 
 
447
 
static struct clk bclk_16xx = {
448
 
    .name       = "bclk",
449
 
    /* Direct from ULPD, no parent. May be enabled by ext hardware. */
450
 
    .flags      = CLOCK_IN_OMAP16XX,
451
 
};
452
 
 
453
 
static struct clk mmc1_ck = {
454
 
    .name       = "mmc_ck",
455
 
    .id         = 1,
456
 
    /* Functional clock is direct from ULPD, interface clock is ARMPER */
457
 
    .parent     = &armper_ck,   /* either armper_ck or dpll4 */
458
 
    .rate       = 48000000,
459
 
    .flags      = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX | CLOCK_IN_OMAP310,
460
 
};
461
 
 
462
 
static struct clk mmc2_ck = {
463
 
    .name       = "mmc_ck",
464
 
    .id         = 2,
465
 
    /* Functional clock is direct from ULPD, interface clock is ARMPER */
466
 
    .parent     = &armper_ck,
467
 
    .rate       = 48000000,
468
 
    .flags      = CLOCK_IN_OMAP16XX,
469
 
};
470
 
 
471
 
static struct clk cam_mclk = {
472
 
    .name       = "cam.mclk",
473
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
474
 
    .rate       = 12000000,
475
 
};
476
 
 
477
 
static struct clk cam_exclk = {
478
 
    .name       = "cam.exclk",
479
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
480
 
    /* Either 12M from cam.mclk or 48M from dpll4 */
481
 
    .parent     = &cam_mclk,
482
 
};
483
 
 
484
 
static struct clk cam_lclk = {
485
 
    .name       = "cam.lclk",
486
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX,
487
 
};
488
 
 
489
 
static struct clk i2c_fck = {
490
 
    .name       = "i2c_fck",
491
 
    .id         = 1,
492
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
493
 
            ALWAYS_ENABLED,
494
 
    .parent     = &armxor_ck,
495
 
};
496
 
 
497
 
static struct clk i2c_ick = {
498
 
    .name       = "i2c_ick",
499
 
    .id         = 1,
500
 
    .flags      = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
501
 
    .parent     = &armper_ck,
502
 
};
503
 
 
504
 
static struct clk clk32k = {
505
 
    .name       = "clk32-kHz",
506
 
    .flags      = CLOCK_IN_OMAP310 | CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
507
 
            CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
508
 
    .parent     = &xtal_osc32k,
509
 
};
510
 
 
511
 
static struct clk ref_clk = {
512
 
    .name       = "ref_clk",
513
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
514
 
    .rate       = 12000000,     /* 12 MHz or 13 MHz or 19.2 MHz */
515
 
    /*.parent   = sys.xtalin */
516
 
};
517
 
 
518
 
static struct clk apll_96m = {
519
 
    .name       = "apll_96m",
520
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
521
 
    .rate       = 96000000,
522
 
    /*.parent   = ref_clk */
523
 
};
524
 
 
525
 
static struct clk apll_54m = {
526
 
    .name       = "apll_54m",
527
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
528
 
    .rate       = 54000000,
529
 
    /*.parent   = ref_clk */
530
 
};
531
 
 
532
 
static struct clk sys_clk = {
533
 
    .name       = "sys_clk",
534
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
535
 
    .rate       = 32768,
536
 
    /*.parent   = sys.xtalin */
537
 
};
538
 
 
539
 
static struct clk sleep_clk = {
540
 
    .name       = "sleep_clk",
541
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
542
 
    .rate       = 32768,
543
 
    /*.parent   = sys.xtalin */
544
 
};
545
 
 
546
 
static struct clk dpll_ck = {
547
 
    .name       = "dpll",
548
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
549
 
    .parent     = &ref_clk,
550
 
};
551
 
 
552
 
static struct clk dpll_x2_ck = {
553
 
    .name       = "dpll_x2",
554
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
555
 
    .parent     = &ref_clk,
556
 
};
557
 
 
558
 
static struct clk wdt1_sys_clk = {
559
 
    .name       = "wdt1_sys_clk",
560
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X | ALWAYS_ENABLED,
561
 
    .rate       = 32768,
562
 
    /*.parent   = sys.xtalin */
563
 
};
564
 
 
565
 
static struct clk func_96m_clk = {
566
 
    .name       = "func_96m_clk",
567
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
568
 
    .divisor    = 1,
569
 
    .parent     = &apll_96m,
570
 
};
571
 
 
572
 
static struct clk func_48m_clk = {
573
 
    .name       = "func_48m_clk",
574
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
575
 
    .divisor    = 2,
576
 
    .parent     = &apll_96m,
577
 
};
578
 
 
579
 
static struct clk func_12m_clk = {
580
 
    .name       = "func_12m_clk",
581
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
582
 
    .divisor    = 8,
583
 
    .parent     = &apll_96m,
584
 
};
585
 
 
586
 
static struct clk func_54m_clk = {
587
 
    .name       = "func_54m_clk",
588
 
    .flags      = CLOCK_IN_OMAP242X,
589
 
    .divisor    = 1,
590
 
    .parent     = &apll_54m,
591
 
};
592
 
 
593
 
static struct clk sys_clkout = {
594
 
    .name       = "clkout",
595
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
596
 
    .parent     = &sys_clk,
597
 
};
598
 
 
599
 
static struct clk sys_clkout2 = {
600
 
    .name       = "clkout2",
601
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
602
 
    .parent     = &sys_clk,
603
 
};
604
 
 
605
 
static struct clk core_clk = {
606
 
    .name       = "core_clk",
607
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
608
 
    .parent     = &dpll_x2_ck,  /* Switchable between dpll_ck and clk32k */
609
 
};
610
 
 
611
 
static struct clk l3_clk = {
612
 
    .name       = "l3_clk",
613
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
614
 
    .parent     = &core_clk,
615
 
};
616
 
 
617
 
static struct clk core_l4_iclk = {
618
 
    .name       = "core_l4_iclk",
619
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
620
 
    .parent     = &l3_clk,
621
 
};
622
 
 
623
 
static struct clk wu_l4_iclk = {
624
 
    .name       = "wu_l4_iclk",
625
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
626
 
    .parent     = &l3_clk,
627
 
};
628
 
 
629
 
static struct clk core_l3_iclk = {
630
 
    .name       = "core_l3_iclk",
631
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
632
 
    .parent     = &core_clk,
633
 
};
634
 
 
635
 
static struct clk core_l4_usb_clk = {
636
 
    .name       = "core_l4_usb_clk",
637
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
638
 
    .parent     = &l3_clk,
639
 
};
640
 
 
641
 
static struct clk wu_gpt1_clk = {
642
 
    .name       = "wu_gpt1_clk",
643
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
644
 
    .parent     = &sys_clk,
645
 
};
646
 
 
647
 
static struct clk wu_32k_clk = {
648
 
    .name       = "wu_32k_clk",
649
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
650
 
    .parent     = &sys_clk,
651
 
};
652
 
 
653
 
static struct clk uart1_fclk = {
654
 
    .name       = "uart1_fclk",
655
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
656
 
    .parent     = &func_48m_clk,
657
 
};
658
 
 
659
 
static struct clk uart1_iclk = {
660
 
    .name       = "uart1_iclk",
661
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
662
 
    .parent     = &core_l4_iclk,
663
 
};
664
 
 
665
 
static struct clk uart2_fclk = {
666
 
    .name       = "uart2_fclk",
667
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
668
 
    .parent     = &func_48m_clk,
669
 
};
670
 
 
671
 
static struct clk uart2_iclk = {
672
 
    .name       = "uart2_iclk",
673
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
674
 
    .parent     = &core_l4_iclk,
675
 
};
676
 
 
677
 
static struct clk uart3_fclk = {
678
 
    .name       = "uart3_fclk",
679
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
680
 
    .parent     = &func_48m_clk,
681
 
};
682
 
 
683
 
static struct clk uart3_iclk = {
684
 
    .name       = "uart3_iclk",
685
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
686
 
    .parent     = &core_l4_iclk,
687
 
};
688
 
 
689
 
static struct clk mpu_fclk = {
690
 
    .name       = "mpu_fclk",
691
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
692
 
    .parent     = &core_clk,
693
 
};
694
 
 
695
 
static struct clk mpu_iclk = {
696
 
    .name       = "mpu_iclk",
697
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
698
 
    .parent     = &core_clk,
699
 
};
700
 
 
701
 
static struct clk int_m_fclk = {
702
 
    .name       = "int_m_fclk",
703
 
    .alias      = "mpu_intc_fclk",
704
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
705
 
    .parent     = &core_clk,
706
 
};
707
 
 
708
 
static struct clk int_m_iclk = {
709
 
    .name       = "int_m_iclk",
710
 
    .alias      = "mpu_intc_iclk",
711
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
712
 
    .parent     = &core_clk,
713
 
};
714
 
 
715
 
static struct clk core_gpt2_clk = {
716
 
    .name       = "core_gpt2_clk",
717
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
718
 
    .parent     = &sys_clk,
719
 
};
720
 
 
721
 
static struct clk core_gpt3_clk = {
722
 
    .name       = "core_gpt3_clk",
723
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
724
 
    .parent     = &sys_clk,
725
 
};
726
 
 
727
 
static struct clk core_gpt4_clk = {
728
 
    .name       = "core_gpt4_clk",
729
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
730
 
    .parent     = &sys_clk,
731
 
};
732
 
 
733
 
static struct clk core_gpt5_clk = {
734
 
    .name       = "core_gpt5_clk",
735
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
736
 
    .parent     = &sys_clk,
737
 
};
738
 
 
739
 
static struct clk core_gpt6_clk = {
740
 
    .name       = "core_gpt6_clk",
741
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
742
 
    .parent     = &sys_clk,
743
 
};
744
 
 
745
 
static struct clk core_gpt7_clk = {
746
 
    .name       = "core_gpt7_clk",
747
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
748
 
    .parent     = &sys_clk,
749
 
};
750
 
 
751
 
static struct clk core_gpt8_clk = {
752
 
    .name       = "core_gpt8_clk",
753
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
754
 
    .parent     = &sys_clk,
755
 
};
756
 
 
757
 
static struct clk core_gpt9_clk = {
758
 
    .name       = "core_gpt9_clk",
759
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
760
 
    .parent     = &sys_clk,
761
 
};
762
 
 
763
 
static struct clk core_gpt10_clk = {
764
 
    .name       = "core_gpt10_clk",
765
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
766
 
    .parent     = &sys_clk,
767
 
};
768
 
 
769
 
static struct clk core_gpt11_clk = {
770
 
    .name       = "core_gpt11_clk",
771
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
772
 
    .parent     = &sys_clk,
773
 
};
774
 
 
775
 
static struct clk core_gpt12_clk = {
776
 
    .name       = "core_gpt12_clk",
777
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
778
 
    .parent     = &sys_clk,
779
 
};
780
 
 
781
 
static struct clk mcbsp1_clk = {
782
 
    .name       = "mcbsp1_cg",
783
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
784
 
    .divisor    = 2,
785
 
    .parent     = &func_96m_clk,
786
 
};
787
 
 
788
 
static struct clk mcbsp2_clk = {
789
 
    .name       = "mcbsp2_cg",
790
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
791
 
    .divisor    = 2,
792
 
    .parent     = &func_96m_clk,
793
 
};
794
 
 
795
 
static struct clk emul_clk = {
796
 
    .name       = "emul_ck",
797
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
798
 
    .parent     = &func_54m_clk,
799
 
};
800
 
 
801
 
static struct clk sdma_fclk = {
802
 
    .name       = "sdma_fclk",
803
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
804
 
    .parent     = &l3_clk,
805
 
};
806
 
 
807
 
static struct clk sdma_iclk = {
808
 
    .name       = "sdma_iclk",
809
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
810
 
    .parent     = &core_l3_iclk, /* core_l4_iclk for the configuration port */
811
 
};
812
 
 
813
 
static struct clk i2c1_fclk = {
814
 
    .name       = "i2c1.fclk",
815
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
816
 
    .parent     = &func_12m_clk,
817
 
    .divisor    = 1,
818
 
};
819
 
 
820
 
static struct clk i2c1_iclk = {
821
 
    .name       = "i2c1.iclk",
822
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
823
 
    .parent     = &core_l4_iclk,
824
 
};
825
 
 
826
 
static struct clk i2c2_fclk = {
827
 
    .name       = "i2c2.fclk",
828
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
829
 
    .parent     = &func_12m_clk,
830
 
    .divisor    = 1,
831
 
};
832
 
 
833
 
static struct clk i2c2_iclk = {
834
 
    .name       = "i2c2.iclk",
835
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
836
 
    .parent     = &core_l4_iclk,
837
 
};
838
 
 
839
 
static struct clk gpio_dbclk[5] = {
840
 
    {
841
 
        .name   = "gpio1_dbclk",
842
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
843
 
        .parent = &wu_32k_clk,
844
 
    }, {
845
 
        .name   = "gpio2_dbclk",
846
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
847
 
        .parent = &wu_32k_clk,
848
 
    }, {
849
 
        .name   = "gpio3_dbclk",
850
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
851
 
        .parent = &wu_32k_clk,
852
 
    }, {
853
 
        .name   = "gpio4_dbclk",
854
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
855
 
        .parent = &wu_32k_clk,
856
 
    }, {
857
 
        .name   = "gpio5_dbclk",
858
 
        .flags  = CLOCK_IN_OMAP243X,
859
 
        .parent = &wu_32k_clk,
860
 
    },
861
 
};
862
 
 
863
 
static struct clk gpio_iclk = {
864
 
    .name       = "gpio_iclk",
865
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
866
 
    .parent     = &wu_l4_iclk,
867
 
};
868
 
 
869
 
static struct clk mmc_fck = {
870
 
    .name       = "mmc_fclk",
871
 
    .flags      = CLOCK_IN_OMAP242X,
872
 
    .parent     = &func_96m_clk,
873
 
};
874
 
 
875
 
static struct clk mmc_ick = {
876
 
    .name       = "mmc_iclk",
877
 
    .flags      = CLOCK_IN_OMAP242X,
878
 
    .parent     = &core_l4_iclk,
879
 
};
880
 
 
881
 
static struct clk spi_fclk[3] = {
882
 
    {
883
 
        .name   = "spi1_fclk",
884
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
885
 
        .parent = &func_48m_clk,
886
 
    }, {
887
 
        .name   = "spi2_fclk",
888
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
889
 
        .parent = &func_48m_clk,
890
 
    }, {
891
 
        .name   = "spi3_fclk",
892
 
        .flags  = CLOCK_IN_OMAP243X,
893
 
        .parent = &func_48m_clk,
894
 
    },
895
 
};
896
 
 
897
 
static struct clk dss_clk[2] = {
898
 
    {
899
 
        .name   = "dss_clk1",
900
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
901
 
        .parent = &core_clk,
902
 
    }, {
903
 
        .name   = "dss_clk2",
904
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
905
 
        .parent = &sys_clk,
906
 
    },
907
 
};
908
 
 
909
 
static struct clk dss_54m_clk = {
910
 
    .name       = "dss_54m_clk",
911
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
912
 
    .parent     = &func_54m_clk,
913
 
};
914
 
 
915
 
static struct clk dss_l3_iclk = {
916
 
    .name       = "dss_l3_iclk",
917
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
918
 
    .parent     = &core_l3_iclk,
919
 
};
920
 
 
921
 
static struct clk dss_l4_iclk = {
922
 
    .name       = "dss_l4_iclk",
923
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
924
 
    .parent     = &core_l4_iclk,
925
 
};
926
 
 
927
 
static struct clk spi_iclk[3] = {
928
 
    {
929
 
        .name   = "spi1_iclk",
930
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
931
 
        .parent = &core_l4_iclk,
932
 
    }, {
933
 
        .name   = "spi2_iclk",
934
 
        .flags  = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
935
 
        .parent = &core_l4_iclk,
936
 
    }, {
937
 
        .name   = "spi3_iclk",
938
 
        .flags  = CLOCK_IN_OMAP243X,
939
 
        .parent = &core_l4_iclk,
940
 
    },
941
 
};
942
 
 
943
 
static struct clk omapctrl_clk = {
944
 
    .name       = "omapctrl_iclk",
945
 
    .flags      = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
946
 
    /* XXX Should be in WKUP domain */
947
 
    .parent     = &core_l4_iclk,
948
 
};
949
 
 
950
 
static struct clk *onchip_clks[] = {
951
 
    /* OMAP 1 */
952
 
 
953
 
    /* non-ULPD clocks */
954
 
    &xtal_osc12m,
955
 
    &xtal_osc32k,
956
 
    &ck_ref,
957
 
    &dpll1,
958
 
    &dpll2,
959
 
    &dpll3,
960
 
    &dpll4,
961
 
    &apll,
962
 
    &ck_48m,
963
 
    /* CK_GEN1 clocks */
964
 
    &clkm1,
965
 
    &ck_dpll1out,
966
 
    &sossi_ck,
967
 
    &arm_ck,
968
 
    &armper_ck,
969
 
    &arm_gpio_ck,
970
 
    &armxor_ck,
971
 
    &armtim_ck,
972
 
    &armwdt_ck,
973
 
    &arminth_ck15xx,  &arminth_ck16xx,
974
 
    /* CK_GEN2 clocks */
975
 
    &clkm2,
976
 
    &dsp_ck,
977
 
    &dspmmu_ck,
978
 
    &dspper_ck,
979
 
    &dspxor_ck,
980
 
    &dsptim_ck,
981
 
    /* CK_GEN3 clocks */
982
 
    &clkm3,
983
 
    &tc_ck,
984
 
    &tipb_ck,
985
 
    &l3_ocpi_ck,
986
 
    &tc1_ck,
987
 
    &tc2_ck,
988
 
    &dma_ck,
989
 
    &dma_lcdfree_ck,
990
 
    &api_ck,
991
 
    &lb_ck,
992
 
    &lbfree_ck,
993
 
    &hsab_ck,
994
 
    &rhea1_ck,
995
 
    &rhea2_ck,
996
 
    &lcd_ck_16xx,
997
 
    &lcd_ck_1510,
998
 
    /* ULPD clocks */
999
 
    &uart1_1510,
1000
 
    &uart1_16xx,
1001
 
    &uart2_ck,
1002
 
    &uart3_1510,
1003
 
    &uart3_16xx,
1004
 
    &usb_clk0,
1005
 
    &usb_hhc_ck1510, &usb_hhc_ck16xx,
1006
 
    &mclk_1510,  &mclk_16xx, &mclk_310,
1007
 
    &bclk_1510,  &bclk_16xx, &bclk_310,
1008
 
    &mmc1_ck,
1009
 
    &mmc2_ck,
1010
 
    &cam_mclk,
1011
 
    &cam_exclk,
1012
 
    &cam_lclk,
1013
 
    &clk32k,
1014
 
    &usb_w2fc_mclk,
1015
 
    /* Virtual clocks */
1016
 
    &i2c_fck,
1017
 
    &i2c_ick,
1018
 
 
1019
 
    /* OMAP 2 */
1020
 
 
1021
 
    &ref_clk,
1022
 
    &apll_96m,
1023
 
    &apll_54m,
1024
 
    &sys_clk,
1025
 
    &sleep_clk,
1026
 
    &dpll_ck,
1027
 
    &dpll_x2_ck,
1028
 
    &wdt1_sys_clk,
1029
 
    &func_96m_clk,
1030
 
    &func_48m_clk,
1031
 
    &func_12m_clk,
1032
 
    &func_54m_clk,
1033
 
    &sys_clkout,
1034
 
    &sys_clkout2,
1035
 
    &core_clk,
1036
 
    &l3_clk,
1037
 
    &core_l4_iclk,
1038
 
    &wu_l4_iclk,
1039
 
    &core_l3_iclk,
1040
 
    &core_l4_usb_clk,
1041
 
    &wu_gpt1_clk,
1042
 
    &wu_32k_clk,
1043
 
    &uart1_fclk,
1044
 
    &uart1_iclk,
1045
 
    &uart2_fclk,
1046
 
    &uart2_iclk,
1047
 
    &uart3_fclk,
1048
 
    &uart3_iclk,
1049
 
    &mpu_fclk,
1050
 
    &mpu_iclk,
1051
 
    &int_m_fclk,
1052
 
    &int_m_iclk,
1053
 
    &core_gpt2_clk,
1054
 
    &core_gpt3_clk,
1055
 
    &core_gpt4_clk,
1056
 
    &core_gpt5_clk,
1057
 
    &core_gpt6_clk,
1058
 
    &core_gpt7_clk,
1059
 
    &core_gpt8_clk,
1060
 
    &core_gpt9_clk,
1061
 
    &core_gpt10_clk,
1062
 
    &core_gpt11_clk,
1063
 
    &core_gpt12_clk,
1064
 
    &mcbsp1_clk,
1065
 
    &mcbsp2_clk,
1066
 
    &emul_clk,
1067
 
    &sdma_fclk,
1068
 
    &sdma_iclk,
1069
 
    &i2c1_fclk,
1070
 
    &i2c1_iclk,
1071
 
    &i2c2_fclk,
1072
 
    &i2c2_iclk,
1073
 
    &gpio_dbclk[0],
1074
 
    &gpio_dbclk[1],
1075
 
    &gpio_dbclk[2],
1076
 
    &gpio_dbclk[3],
1077
 
    &gpio_iclk,
1078
 
    &mmc_fck,
1079
 
    &mmc_ick,
1080
 
    &spi_fclk[0],
1081
 
    &spi_iclk[0],
1082
 
    &spi_fclk[1],
1083
 
    &spi_iclk[1],
1084
 
    &spi_fclk[2],
1085
 
    &spi_iclk[2],
1086
 
    &dss_clk[0],
1087
 
    &dss_clk[1],
1088
 
    &dss_54m_clk,
1089
 
    &dss_l3_iclk,
1090
 
    &dss_l4_iclk,
1091
 
    &omapctrl_clk,
1092
 
 
1093
 
    NULL
1094
 
};
1095
 
 
1096
 
void omap_clk_adduser(struct clk *clk, qemu_irq user)
1097
 
{
1098
 
    qemu_irq *i;
1099
 
 
1100
 
    for (i = clk->users; *i; i ++);
1101
 
    *i = user;
1102
 
}
1103
 
 
1104
 
struct clk *omap_findclk(struct omap_mpu_state_s *mpu, const char *name)
1105
 
{
1106
 
    struct clk *i;
1107
 
 
1108
 
    for (i = mpu->clks; i->name; i ++)
1109
 
        if (!strcmp(i->name, name) || (i->alias && !strcmp(i->alias, name)))
1110
 
            return i;
1111
 
    hw_error("%s: %s not found\n", __FUNCTION__, name);
1112
 
}
1113
 
 
1114
 
void omap_clk_get(struct clk *clk)
1115
 
{
1116
 
    clk->usecount ++;
1117
 
}
1118
 
 
1119
 
void omap_clk_put(struct clk *clk)
1120
 
{
1121
 
    if (!(clk->usecount --))
1122
 
        hw_error("%s: %s is not in use\n", __FUNCTION__, clk->name);
1123
 
}
1124
 
 
1125
 
static void omap_clk_update(struct clk *clk)
1126
 
{
1127
 
    int parent, running;
1128
 
    qemu_irq *user;
1129
 
    struct clk *i;
1130
 
 
1131
 
    if (clk->parent)
1132
 
        parent = clk->parent->running;
1133
 
    else
1134
 
        parent = 1;
1135
 
 
1136
 
    running = parent && (clk->enabled ||
1137
 
                    ((clk->flags & ALWAYS_ENABLED) && clk->usecount));
1138
 
    if (clk->running != running) {
1139
 
        clk->running = running;
1140
 
        for (user = clk->users; *user; user ++)
1141
 
            qemu_set_irq(*user, running);
1142
 
        for (i = clk->child1; i; i = i->sibling)
1143
 
            omap_clk_update(i);
1144
 
    }
1145
 
}
1146
 
 
1147
 
static void omap_clk_rate_update_full(struct clk *clk, unsigned long int rate,
1148
 
                unsigned long int div, unsigned long int mult)
1149
 
{
1150
 
    struct clk *i;
1151
 
    qemu_irq *user;
1152
 
 
1153
 
    clk->rate = muldiv64(rate, mult, div);
1154
 
    if (clk->running)
1155
 
        for (user = clk->users; *user; user ++)
1156
 
            qemu_irq_raise(*user);
1157
 
    for (i = clk->child1; i; i = i->sibling)
1158
 
        omap_clk_rate_update_full(i, rate,
1159
 
                        div * i->divisor, mult * i->multiplier);
1160
 
}
1161
 
 
1162
 
static void omap_clk_rate_update(struct clk *clk)
1163
 
{
1164
 
    struct clk *i;
1165
 
    unsigned long int div, mult = div = 1;
1166
 
 
1167
 
    for (i = clk; i->parent; i = i->parent) {
1168
 
        div *= i->divisor;
1169
 
        mult *= i->multiplier;
1170
 
    }
1171
 
 
1172
 
    omap_clk_rate_update_full(clk, i->rate, div, mult);
1173
 
}
1174
 
 
1175
 
void omap_clk_reparent(struct clk *clk, struct clk *parent)
1176
 
{
1177
 
    struct clk **p;
1178
 
 
1179
 
    if (clk->parent) {
1180
 
        for (p = &clk->parent->child1; *p != clk; p = &(*p)->sibling);
1181
 
        *p = clk->sibling;
1182
 
    }
1183
 
 
1184
 
    clk->parent = parent;
1185
 
    if (parent) {
1186
 
        clk->sibling = parent->child1;
1187
 
        parent->child1 = clk;
1188
 
        omap_clk_update(clk);
1189
 
        omap_clk_rate_update(clk);
1190
 
    } else
1191
 
        clk->sibling = NULL;
1192
 
}
1193
 
 
1194
 
void omap_clk_onoff(struct clk *clk, int on)
1195
 
{
1196
 
    clk->enabled = on;
1197
 
    omap_clk_update(clk);
1198
 
}
1199
 
 
1200
 
void omap_clk_canidle(struct clk *clk, int can)
1201
 
{
1202
 
    if (can)
1203
 
        omap_clk_put(clk);
1204
 
    else
1205
 
        omap_clk_get(clk);
1206
 
}
1207
 
 
1208
 
void omap_clk_setrate(struct clk *clk, int divide, int multiply)
1209
 
{
1210
 
    clk->divisor = divide;
1211
 
    clk->multiplier = multiply;
1212
 
    omap_clk_rate_update(clk);
1213
 
}
1214
 
 
1215
 
int64_t omap_clk_getrate(omap_clk clk)
1216
 
{
1217
 
    return clk->rate;
1218
 
}
1219
 
 
1220
 
void omap_clk_init(struct omap_mpu_state_s *mpu)
1221
 
{
1222
 
    struct clk **i, *j, *k;
1223
 
    int count;
1224
 
    int flag;
1225
 
 
1226
 
    if (cpu_is_omap310(mpu))
1227
 
        flag = CLOCK_IN_OMAP310;
1228
 
    else if (cpu_is_omap1510(mpu))
1229
 
        flag = CLOCK_IN_OMAP1510;
1230
 
    else if (cpu_is_omap2410(mpu) || cpu_is_omap2420(mpu))
1231
 
        flag = CLOCK_IN_OMAP242X;
1232
 
    else if (cpu_is_omap2430(mpu))
1233
 
        flag = CLOCK_IN_OMAP243X;
1234
 
    else if (cpu_is_omap3430(mpu))
1235
 
        flag = CLOCK_IN_OMAP243X;
1236
 
    else
1237
 
        return;
1238
 
 
1239
 
    for (i = onchip_clks, count = 0; *i; i ++)
1240
 
        if ((*i)->flags & flag)
1241
 
            count ++;
1242
 
    mpu->clks = (struct clk *) g_malloc0(sizeof(struct clk) * (count + 1));
1243
 
    for (i = onchip_clks, j = mpu->clks; *i; i ++)
1244
 
        if ((*i)->flags & flag) {
1245
 
            memcpy(j, *i, sizeof(struct clk));
1246
 
            for (k = mpu->clks; k < j; k ++)
1247
 
                if (j->parent && !strcmp(j->parent->name, k->name)) {
1248
 
                    j->parent = k;
1249
 
                    j->sibling = k->child1;
1250
 
                    k->child1 = j;
1251
 
                } else if (k->parent && !strcmp(k->parent->name, j->name)) {
1252
 
                    k->parent = j;
1253
 
                    k->sibling = j->child1;
1254
 
                    j->child1 = k;
1255
 
                }
1256
 
            j->divisor = j->divisor ?: 1;
1257
 
            j->multiplier = j->multiplier ?: 1;
1258
 
            j ++;
1259
 
        }
1260
 
    for (j = mpu->clks; count --; j ++) {
1261
 
        omap_clk_update(j);
1262
 
        omap_clk_rate_update(j);
1263
 
    }
1264
 
}