hc
2023-08-21 fc437ccf3419c424092701f3d883215fa4552a8b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (c) 2015 Endless Mobile, Inc.
 * Author: Carlo Caione <carlo@endlessm.com>
 */
 
#ifndef __CLKC_H
#define __CLKC_H
 
#include <linux/clk-provider.h>
#include "clk-regmap.h"
 
#define PMASK(width)            GENMASK(width - 1, 0)
#define SETPMASK(width, shift)        GENMASK(shift + width - 1, shift)
#define CLRPMASK(width, shift)        (~SETPMASK(width, shift))
 
#define PARM_GET(width, shift, reg)                    \
   (((reg) & SETPMASK(width, shift)) >> (shift))
#define PARM_SET(width, shift, reg, val)                \
   (((reg) & CLRPMASK(width, shift)) | ((val) << (shift)))
 
#define MESON_PARM_APPLICABLE(p)        (!!((p)->width))
 
struct parm {
   u16    reg_off;
   u8    shift;
   u8    width;
};
 
static inline unsigned int meson_parm_read(struct regmap *map, struct parm *p)
{
   unsigned int val;
 
   regmap_read(map, p->reg_off, &val);
   return PARM_GET(p->width, p->shift, val);
}
 
static inline void meson_parm_write(struct regmap *map, struct parm *p,
                   unsigned int val)
{
   regmap_update_bits(map, p->reg_off, SETPMASK(p->width, p->shift),
              val << p->shift);
}
 
 
struct pll_rate_table {
   unsigned long    rate;
   u16        m;
   u16        n;
   u16        od;
   u16        od2;
   u16        od3;
};
 
#define PLL_RATE(_r, _m, _n, _od)                    \
   {                                \
       .rate        = (_r),                    \
       .m        = (_m),                    \
       .n        = (_n),                    \
       .od        = (_od),                \
   }
 
#define CLK_MESON_PLL_ROUND_CLOSEST    BIT(0)
 
struct meson_clk_pll_data {
   struct parm m;
   struct parm n;
   struct parm frac;
   struct parm od;
   struct parm od2;
   struct parm od3;
   struct parm l;
   struct parm rst;
   const struct reg_sequence *init_regs;
   unsigned int init_count;
   const struct pll_rate_table *table;
   u8 flags;
};
 
#define to_meson_clk_pll(_hw) container_of(_hw, struct meson_clk_pll, hw)
 
struct meson_clk_mpll_data {
   struct parm sdm;
   struct parm sdm_en;
   struct parm n2;
   struct parm ssen;
   struct parm misc;
   spinlock_t *lock;
   u8 flags;
};
 
#define CLK_MESON_MPLL_ROUND_CLOSEST    BIT(0)
 
struct meson_clk_phase_data {
   struct parm ph;
};
 
int meson_clk_degrees_from_val(unsigned int val, unsigned int width);
unsigned int meson_clk_degrees_to_val(int degrees, unsigned int width);
 
#define MESON_GATE(_name, _reg, _bit)                    \
struct clk_regmap _name = {                        \
   .data = &(struct clk_regmap_gate_data){                \
       .offset = (_reg),                    \
       .bit_idx = (_bit),                    \
   },                                \
   .hw.init = &(struct clk_init_data) {                \
       .name = #_name,                        \
       .ops = &clk_regmap_gate_ops,                \
       .parent_names = (const char *[]){ "clk81" },        \
       .num_parents = 1,                    \
       .flags = (CLK_SET_RATE_PARENT | CLK_IGNORE_UNUSED),    \
   },                                \
};
 
/* clk_ops */
extern const struct clk_ops meson_clk_pll_ro_ops;
extern const struct clk_ops meson_clk_pll_ops;
extern const struct clk_ops meson_clk_cpu_ops;
extern const struct clk_ops meson_clk_mpll_ro_ops;
extern const struct clk_ops meson_clk_mpll_ops;
extern const struct clk_ops meson_clk_phase_ops;
 
#endif /* __CLKC_H */