This source file includes following definitions.
- phy_g12a_usb3_pcie_cr_bus_addr
- phy_g12a_usb3_pcie_cr_bus_read
- phy_g12a_usb3_pcie_cr_bus_write
- phy_g12a_usb3_init
- phy_g12a_usb3_pcie_init
- phy_g12a_usb3_pcie_exit
- phy_g12a_usb3_pcie_xlate
- phy_g12a_usb3_pcie_probe
1
2
3
4
5
6
7
8
9
10 #include <linux/bitfield.h>
11 #include <linux/bitops.h>
12 #include <linux/clk.h>
13 #include <linux/module.h>
14 #include <linux/of_device.h>
15 #include <linux/phy/phy.h>
16 #include <linux/regmap.h>
17 #include <linux/reset.h>
18 #include <linux/platform_device.h>
19 #include <dt-bindings/phy/phy.h>
20
21 #define PHY_R0 0x00
22 #define PHY_R0_PCIE_POWER_STATE GENMASK(4, 0)
23 #define PHY_R0_PCIE_USB3_SWITCH GENMASK(6, 5)
24
25 #define PHY_R1 0x04
26 #define PHY_R1_PHY_TX1_TERM_OFFSET GENMASK(4, 0)
27 #define PHY_R1_PHY_TX0_TERM_OFFSET GENMASK(9, 5)
28 #define PHY_R1_PHY_RX1_EQ GENMASK(12, 10)
29 #define PHY_R1_PHY_RX0_EQ GENMASK(15, 13)
30 #define PHY_R1_PHY_LOS_LEVEL GENMASK(20, 16)
31 #define PHY_R1_PHY_LOS_BIAS GENMASK(23, 21)
32 #define PHY_R1_PHY_REF_CLKDIV2 BIT(24)
33 #define PHY_R1_PHY_MPLL_MULTIPLIER GENMASK(31, 25)
34
35 #define PHY_R2 0x08
36 #define PHY_R2_PCS_TX_DEEMPH_GEN2_6DB GENMASK(5, 0)
37 #define PHY_R2_PCS_TX_DEEMPH_GEN2_3P5DB GENMASK(11, 6)
38 #define PHY_R2_PCS_TX_DEEMPH_GEN1 GENMASK(17, 12)
39 #define PHY_R2_PHY_TX_VBOOST_LVL GENMASK(20, 18)
40
41 #define PHY_R4 0x10
42 #define PHY_R4_PHY_CR_WRITE BIT(0)
43 #define PHY_R4_PHY_CR_READ BIT(1)
44 #define PHY_R4_PHY_CR_DATA_IN GENMASK(17, 2)
45 #define PHY_R4_PHY_CR_CAP_DATA BIT(18)
46 #define PHY_R4_PHY_CR_CAP_ADDR BIT(19)
47
48 #define PHY_R5 0x14
49 #define PHY_R5_PHY_CR_DATA_OUT GENMASK(15, 0)
50 #define PHY_R5_PHY_CR_ACK BIT(16)
51 #define PHY_R5_PHY_BS_OUT BIT(17)
52
53 struct phy_g12a_usb3_pcie_priv {
54 struct regmap *regmap;
55 struct regmap *regmap_cr;
56 struct clk *clk_ref;
57 struct reset_control *reset;
58 struct phy *phy;
59 unsigned int mode;
60 };
61
62 static const struct regmap_config phy_g12a_usb3_pcie_regmap_conf = {
63 .reg_bits = 8,
64 .val_bits = 32,
65 .reg_stride = 4,
66 .max_register = PHY_R5,
67 };
68
69 static int phy_g12a_usb3_pcie_cr_bus_addr(struct phy_g12a_usb3_pcie_priv *priv,
70 unsigned int addr)
71 {
72 unsigned int val, reg;
73 int ret;
74
75 reg = FIELD_PREP(PHY_R4_PHY_CR_DATA_IN, addr);
76
77 regmap_write(priv->regmap, PHY_R4, reg);
78 regmap_write(priv->regmap, PHY_R4, reg);
79
80 regmap_write(priv->regmap, PHY_R4, reg | PHY_R4_PHY_CR_CAP_ADDR);
81
82 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
83 (val & PHY_R5_PHY_CR_ACK),
84 5, 1000);
85 if (ret)
86 return ret;
87
88 regmap_write(priv->regmap, PHY_R4, reg);
89
90 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
91 !(val & PHY_R5_PHY_CR_ACK),
92 5, 1000);
93 if (ret)
94 return ret;
95
96 return 0;
97 }
98
99 static int phy_g12a_usb3_pcie_cr_bus_read(void *context, unsigned int addr,
100 unsigned int *data)
101 {
102 struct phy_g12a_usb3_pcie_priv *priv = context;
103 unsigned int val;
104 int ret;
105
106 ret = phy_g12a_usb3_pcie_cr_bus_addr(priv, addr);
107 if (ret)
108 return ret;
109
110 regmap_write(priv->regmap, PHY_R4, 0);
111 regmap_write(priv->regmap, PHY_R4, PHY_R4_PHY_CR_READ);
112
113 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
114 (val & PHY_R5_PHY_CR_ACK),
115 5, 1000);
116 if (ret)
117 return ret;
118
119 *data = FIELD_GET(PHY_R5_PHY_CR_DATA_OUT, val);
120
121 regmap_write(priv->regmap, PHY_R4, 0);
122
123 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
124 !(val & PHY_R5_PHY_CR_ACK),
125 5, 1000);
126 if (ret)
127 return ret;
128
129 return 0;
130 }
131
132 static int phy_g12a_usb3_pcie_cr_bus_write(void *context, unsigned int addr,
133 unsigned int data)
134 {
135 struct phy_g12a_usb3_pcie_priv *priv = context;
136 unsigned int val, reg;
137 int ret;
138
139 ret = phy_g12a_usb3_pcie_cr_bus_addr(priv, addr);
140 if (ret)
141 return ret;
142
143 reg = FIELD_PREP(PHY_R4_PHY_CR_DATA_IN, data);
144
145 regmap_write(priv->regmap, PHY_R4, reg);
146 regmap_write(priv->regmap, PHY_R4, reg);
147
148 regmap_write(priv->regmap, PHY_R4, reg | PHY_R4_PHY_CR_CAP_DATA);
149
150 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
151 (val & PHY_R5_PHY_CR_ACK),
152 5, 1000);
153 if (ret)
154 return ret;
155
156 regmap_write(priv->regmap, PHY_R4, reg);
157
158 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
159 (val & PHY_R5_PHY_CR_ACK) == 0,
160 5, 1000);
161 if (ret)
162 return ret;
163
164 regmap_write(priv->regmap, PHY_R4, reg);
165
166 regmap_write(priv->regmap, PHY_R4, reg | PHY_R4_PHY_CR_WRITE);
167
168 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
169 (val & PHY_R5_PHY_CR_ACK),
170 5, 1000);
171 if (ret)
172 return ret;
173
174 regmap_write(priv->regmap, PHY_R4, reg);
175
176 ret = regmap_read_poll_timeout(priv->regmap, PHY_R5, val,
177 (val & PHY_R5_PHY_CR_ACK) == 0,
178 5, 1000);
179 if (ret)
180 return ret;
181
182 return 0;
183 }
184
185 static const struct regmap_config phy_g12a_usb3_pcie_cr_regmap_conf = {
186 .reg_bits = 16,
187 .val_bits = 16,
188 .reg_read = phy_g12a_usb3_pcie_cr_bus_read,
189 .reg_write = phy_g12a_usb3_pcie_cr_bus_write,
190 .max_register = 0xffff,
191 .disable_locking = true,
192 };
193
194 static int phy_g12a_usb3_init(struct phy *phy)
195 {
196 struct phy_g12a_usb3_pcie_priv *priv = phy_get_drvdata(phy);
197 int data, ret;
198
199
200
201 regmap_update_bits(priv->regmap, PHY_R0,
202 PHY_R0_PCIE_USB3_SWITCH,
203 PHY_R0_PCIE_USB3_SWITCH);
204
205
206
207
208
209
210
211
212 ret = regmap_update_bits(priv->regmap_cr, 0x102d, BIT(7), BIT(7));
213 if (ret)
214 return ret;
215
216 ret = regmap_update_bits(priv->regmap_cr, 0x1010, 0xff0, 20);
217 if (ret)
218 return ret;
219
220
221
222
223
224
225
226
227 ret = regmap_read(priv->regmap_cr, 0x1006, &data);
228 if (ret)
229 return ret;
230
231 data &= ~BIT(6);
232 data |= BIT(7);
233 data &= ~(0x7 << 8);
234 data |= (0x3 << 8);
235 data |= (1 << 11);
236 ret = regmap_write(priv->regmap_cr, 0x1006, data);
237 if (ret)
238 return ret;
239
240
241
242
243
244
245
246 ret = regmap_read(priv->regmap_cr, 0x1002, &data);
247 if (ret)
248 return ret;
249
250 data &= ~0x3f80;
251 data |= (0x16 << 7);
252 data &= ~0x7f;
253 data |= (0x7f | BIT(14));
254 ret = regmap_write(priv->regmap_cr, 0x1002, data);
255 if (ret)
256 return ret;
257
258
259 ret = regmap_update_bits(priv->regmap_cr, 0x30, 0xf << 4, 8 << 4);
260 if (ret)
261 return ret;
262
263 regmap_update_bits(priv->regmap, PHY_R2,
264 PHY_R2_PHY_TX_VBOOST_LVL,
265 FIELD_PREP(PHY_R2_PHY_TX_VBOOST_LVL, 0x4));
266
267 regmap_update_bits(priv->regmap, PHY_R1,
268 PHY_R1_PHY_LOS_BIAS | PHY_R1_PHY_LOS_LEVEL,
269 FIELD_PREP(PHY_R1_PHY_LOS_BIAS, 4) |
270 FIELD_PREP(PHY_R1_PHY_LOS_LEVEL, 9));
271
272 return 0;
273 }
274
275 static int phy_g12a_usb3_pcie_init(struct phy *phy)
276 {
277 struct phy_g12a_usb3_pcie_priv *priv = phy_get_drvdata(phy);
278 int ret;
279
280 ret = reset_control_reset(priv->reset);
281 if (ret)
282 return ret;
283
284 if (priv->mode == PHY_TYPE_USB3)
285 return phy_g12a_usb3_init(phy);
286
287
288
289 regmap_update_bits(priv->regmap, PHY_R0,
290 PHY_R0_PCIE_POWER_STATE,
291 FIELD_PREP(PHY_R0_PCIE_POWER_STATE, 0x1c));
292
293 return 0;
294 }
295
296 static int phy_g12a_usb3_pcie_exit(struct phy *phy)
297 {
298 struct phy_g12a_usb3_pcie_priv *priv = phy_get_drvdata(phy);
299
300 return reset_control_reset(priv->reset);
301 }
302
303 static struct phy *phy_g12a_usb3_pcie_xlate(struct device *dev,
304 struct of_phandle_args *args)
305 {
306 struct phy_g12a_usb3_pcie_priv *priv = dev_get_drvdata(dev);
307 unsigned int mode;
308
309 if (args->args_count < 1) {
310 dev_err(dev, "invalid number of arguments\n");
311 return ERR_PTR(-EINVAL);
312 }
313
314 mode = args->args[0];
315
316 if (mode != PHY_TYPE_USB3 && mode != PHY_TYPE_PCIE) {
317 dev_err(dev, "invalid phy mode select argument\n");
318 return ERR_PTR(-EINVAL);
319 }
320
321 priv->mode = mode;
322
323 return priv->phy;
324 }
325
326 static const struct phy_ops phy_g12a_usb3_pcie_ops = {
327 .init = phy_g12a_usb3_pcie_init,
328 .exit = phy_g12a_usb3_pcie_exit,
329 .owner = THIS_MODULE,
330 };
331
332 static int phy_g12a_usb3_pcie_probe(struct platform_device *pdev)
333 {
334 struct device *dev = &pdev->dev;
335 struct device_node *np = dev->of_node;
336 struct phy_g12a_usb3_pcie_priv *priv;
337 struct resource *res;
338 struct phy_provider *phy_provider;
339 void __iomem *base;
340 int ret;
341
342 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
343 if (!priv)
344 return -ENOMEM;
345
346 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
347 base = devm_ioremap_resource(dev, res);
348 if (IS_ERR(base))
349 return PTR_ERR(base);
350
351 priv->regmap = devm_regmap_init_mmio(dev, base,
352 &phy_g12a_usb3_pcie_regmap_conf);
353 if (IS_ERR(priv->regmap))
354 return PTR_ERR(priv->regmap);
355
356 priv->regmap_cr = devm_regmap_init(dev, NULL, priv,
357 &phy_g12a_usb3_pcie_cr_regmap_conf);
358 if (IS_ERR(priv->regmap_cr))
359 return PTR_ERR(priv->regmap_cr);
360
361 priv->clk_ref = devm_clk_get(dev, "ref_clk");
362 if (IS_ERR(priv->clk_ref))
363 return PTR_ERR(priv->clk_ref);
364
365 ret = clk_prepare_enable(priv->clk_ref);
366 if (ret)
367 goto err_disable_clk_ref;
368
369 priv->reset = devm_reset_control_array_get(dev, false, false);
370 if (IS_ERR(priv->reset))
371 return PTR_ERR(priv->reset);
372
373 priv->phy = devm_phy_create(dev, np, &phy_g12a_usb3_pcie_ops);
374 if (IS_ERR(priv->phy)) {
375 ret = PTR_ERR(priv->phy);
376 if (ret != -EPROBE_DEFER)
377 dev_err(dev, "failed to create PHY\n");
378
379 return ret;
380 }
381
382 phy_set_drvdata(priv->phy, priv);
383 dev_set_drvdata(dev, priv);
384
385 phy_provider = devm_of_phy_provider_register(dev,
386 phy_g12a_usb3_pcie_xlate);
387
388 return PTR_ERR_OR_ZERO(phy_provider);
389
390 err_disable_clk_ref:
391 clk_disable_unprepare(priv->clk_ref);
392
393 return ret;
394 }
395
396 static const struct of_device_id phy_g12a_usb3_pcie_of_match[] = {
397 { .compatible = "amlogic,g12a-usb3-pcie-phy", },
398 { },
399 };
400 MODULE_DEVICE_TABLE(of, phy_g12a_usb3_pcie_of_match);
401
402 static struct platform_driver phy_g12a_usb3_pcie_driver = {
403 .probe = phy_g12a_usb3_pcie_probe,
404 .driver = {
405 .name = "phy-g12a-usb3-pcie",
406 .of_match_table = phy_g12a_usb3_pcie_of_match,
407 },
408 };
409 module_platform_driver(phy_g12a_usb3_pcie_driver);
410
411 MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>");
412 MODULE_DESCRIPTION("Amlogic G12A USB3 + PCIE Combo PHY driver");
413 MODULE_LICENSE("GPL v2");