1 /* 2 * Copyright (C) 2010 ST-Ericsson 3 * Copyright (C) 2009 STMicroelectronics 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 */ 9 10 /** 11 * struct clkops - ux500 clock operations 12 * @enable: function to enable the clock 13 * @disable: function to disable the clock 14 * @get_rate: function to get the current clock rate 15 * 16 * This structure contains function pointers to functions that will be used to 17 * control the clock. All of these functions are optional. If get_rate is 18 * NULL, the rate in the struct clk will be used. 19 */ 20 struct clkops { 21 void (*enable) (struct clk *); 22 void (*disable) (struct clk *); 23 unsigned long (*get_rate) (struct clk *); 24 int (*set_parent)(struct clk *, struct clk *); 25 }; 26 27 /** 28 * struct clk - ux500 clock structure 29 * @ops: pointer to clkops struct used to control this clock 30 * @name: name, for debugging 31 * @enabled: refcount. positive if enabled, zero if disabled 32 * @get_rate: custom callback for getting the clock rate 33 * @data: custom per-clock data for example for the get_rate 34 * callback 35 * @rate: fixed rate for clocks which don't implement 36 * ops->getrate 37 * @prcmu_cg_off: address offset of the combined enable/disable register 38 * (used on u8500v1) 39 * @prcmu_cg_bit: bit in the combined enable/disable register (used on 40 * u8500v1) 41 * @prcmu_cg_mgt: address of the enable/disable register (used on 42 * u8500ed) 43 * @cluster: peripheral cluster number 44 * @prcc_bus: bit for the bus clock in the peripheral's CLKRST 45 * @prcc_kernel: bit for the kernel clock in the peripheral's CLKRST. 46 * -1 if no kernel clock exists. 47 * @parent_cluster: pointer to parent's cluster clk struct 48 * @parent_periph: pointer to parent's peripheral clk struct 49 * 50 * Peripherals are organised into clusters, and each cluster has an associated 51 * bus clock. Some peripherals also have a parent peripheral clock. 52 * 53 * In order to enable a clock for a peripheral, we need to enable: 54 * (1) the parent cluster (bus) clock at the PRCMU level 55 * (2) the parent peripheral clock (if any) at the PRCMU level 56 * (3) the peripheral's bus & kernel clock at the PRCC level 57 * 58 * (1) and (2) are handled by defining clk structs (DEFINE_PRCMU_CLK) for each 59 * of the cluster and peripheral clocks, and hooking these as the parents of 60 * the individual peripheral clocks. 61 * 62 * (3) is handled by specifying the bits in the PRCC control registers required 63 * to enable these clocks and modifying them in the ->enable and 64 * ->disable callbacks of the peripheral clocks (DEFINE_PRCC_CLK). 65 * 66 * This structure describes both the PRCMU-level clocks and PRCC-level clocks. 67 * The prcmu_* fields are only used for the PRCMU clocks, and the cluster, 68 * prcc, and parent pointers are only used for the PRCC-level clocks. 69 */ 70 struct clk { 71 const struct clkops *ops; 72 const char *name; 73 unsigned int enabled; 74 unsigned long (*get_rate)(struct clk *); 75 void *data; 76 77 unsigned long rate; 78 struct list_head list; 79 80 /* These three are only for PRCMU clks */ 81 82 unsigned int prcmu_cg_off; 83 unsigned int prcmu_cg_bit; 84 unsigned int prcmu_cg_mgt; 85 86 /* The rest are only for PRCC clks */ 87 88 int cluster; 89 unsigned int prcc_bus; 90 unsigned int prcc_kernel; 91 92 struct clk *parent_cluster; 93 struct clk *parent_periph; 94 #if defined(CONFIG_DEBUG_FS) 95 struct dentry *dent; /* For visible tree hierarchy */ 96 struct dentry *dent_bus; /* For visible tree hierarchy */ 97 #endif 98 }; 99 100 #define DEFINE_PRCMU_CLK(_name, _cg_off, _cg_bit, _reg) \ 101 struct clk clk_##_name = { \ 102 .name = #_name, \ 103 .ops = &clk_prcmu_ops, \ 104 .prcmu_cg_off = _cg_off, \ 105 .prcmu_cg_bit = _cg_bit, \ 106 .prcmu_cg_mgt = PRCM_##_reg##_MGT \ 107 } 108 109 #define DEFINE_PRCMU_CLK_RATE(_name, _cg_off, _cg_bit, _reg, _rate) \ 110 struct clk clk_##_name = { \ 111 .name = #_name, \ 112 .ops = &clk_prcmu_ops, \ 113 .prcmu_cg_off = _cg_off, \ 114 .prcmu_cg_bit = _cg_bit, \ 115 .rate = _rate, \ 116 .prcmu_cg_mgt = PRCM_##_reg##_MGT \ 117 } 118 119 #define DEFINE_PRCC_CLK(_pclust, _name, _bus_en, _kernel_en, _kernclk) \ 120 struct clk clk_##_name = { \ 121 .name = #_name, \ 122 .ops = &clk_prcc_ops, \ 123 .cluster = _pclust, \ 124 .prcc_bus = _bus_en, \ 125 .prcc_kernel = _kernel_en, \ 126 .parent_cluster = &clk_per##_pclust##clk, \ 127 .parent_periph = _kernclk \ 128 } 129 130 #define DEFINE_PRCC_CLK_CUSTOM(_pclust, _name, _bus_en, _kernel_en, _kernclk, _callback, _data) \ 131 struct clk clk_##_name = { \ 132 .name = #_name, \ 133 .ops = &clk_prcc_ops, \ 134 .cluster = _pclust, \ 135 .prcc_bus = _bus_en, \ 136 .prcc_kernel = _kernel_en, \ 137 .parent_cluster = &clk_per##_pclust##clk, \ 138 .parent_periph = _kernclk, \ 139 .get_rate = _callback, \ 140 .data = (void *) _data \ 141 } 142 143 144 #define CLK(_clk, _devname, _conname) \ 145 { \ 146 .clk = &clk_##_clk, \ 147 .dev_id = _devname, \ 148 .con_id = _conname, \ 149 } 150 151 int __init clk_db8500_ed_fixup(void); 152 int __init clk_init(void); 153