1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2020-2022 Marvell International Ltd.
4 *
5 * FDT Helper functions similar to those provided to U-Boot.
6 */
7
8 #include <dm.h>
9 #include <i2c.h>
10 #include <log.h>
11 #include <malloc.h>
12 #include <net.h>
13 #include <linux/delay.h>
14 #include <asm-generic/gpio.h>
15
16 #include <mach/cvmx-regs.h>
17 #include <mach/cvmx-csr.h>
18 #include <mach/cvmx-bootmem.h>
19 #include <mach/octeon-model.h>
20 #include <mach/octeon_fdt.h>
21 #include <mach/cvmx-helper.h>
22 #include <mach/cvmx-helper-board.h>
23 #include <mach/cvmx-helper-cfg.h>
24 #include <mach/cvmx-helper-fdt.h>
25
26 /**
27 * Local allocator to handle both SE and U-Boot that also zeroes out memory
28 *
29 * @param size number of bytes to allocate
30 *
31 * Return: pointer to allocated memory or NULL if out of memory.
32 * Alignment is set to 8-bytes.
33 */
cvmx_fdt_alloc(size_t size)34 static void *cvmx_fdt_alloc(size_t size)
35 {
36 return calloc(size, 1);
37 }
38
cvmx_ofnode_lookup_phandles(ofnode node,const char * prop_name,int * lenp,ofnode * nodes)39 int cvmx_ofnode_lookup_phandles(ofnode node, const char *prop_name, int *lenp,
40 ofnode *nodes)
41 {
42 const u32 *phandles;
43 int count;
44 int i;
45
46 phandles = ofnode_get_property(node, prop_name, &count);
47 if (!phandles || count < 0)
48 return -FDT_ERR_NOTFOUND;
49
50 count /= 4;
51 if (count > *lenp)
52 count = *lenp;
53
54 for (i = 0; i < count; i++)
55 nodes[i] = ofnode_get_by_phandle(fdt32_to_cpu(phandles[i]));
56
57 *lenp = count;
58 return 0;
59 }
60
61 /**
62 * Given a FDT node return the CPU node number
63 *
64 * @param[in] fdt_addr Address of FDT
65 * @param node FDT node number
66 *
67 * Return: CPU node number or error if negative
68 */
cvmx_fdt_get_cpu_node(const void * fdt_addr,int node)69 int cvmx_fdt_get_cpu_node(const void *fdt_addr, int node)
70 {
71 int parent = node;
72 const u32 *ranges;
73 int len = 0;
74
75 while (fdt_node_check_compatible(fdt_addr, parent, "simple-bus") != 0) {
76 parent = fdt_parent_offset(fdt_addr, parent);
77 if (parent < 0)
78 return parent;
79 }
80 ranges = fdt_getprop(fdt_addr, parent, "ranges", &len);
81 if (!ranges)
82 return len;
83
84 if (len == 0)
85 return 0;
86
87 if (len < 24)
88 return -FDT_ERR_TRUNCATED;
89
90 return fdt32_to_cpu(ranges[2]) / 0x10;
91 }
92
93 /**
94 * Parses all of the channels assigned to a VSC7224 device
95 *
96 * @param[in] fdt_addr Address of flat device tree
97 * @param of_offset Offset of vsc7224 node
98 * @param[in,out] vsc7224 Data structure to hold the data
99 *
100 * Return: 0 for success, -1 on error
101 */
cvmx_fdt_parse_vsc7224_channels(ofnode node,struct cvmx_vsc7224 * vsc7224)102 static int cvmx_fdt_parse_vsc7224_channels(ofnode node,
103 struct cvmx_vsc7224 *vsc7224)
104 {
105 struct ofnode_phandle_args phandle;
106 int err = 0;
107 int reg;
108 int num_chan = 0;
109 struct cvmx_vsc7224_chan *channel;
110 struct cvmx_fdt_sfp_info *sfp_info;
111 int len;
112 int num_taps;
113 int i;
114 const u32 *tap_values;
115 int of_mac;
116 int xiface, index;
117 bool is_tx;
118 bool is_qsfp;
119 const char *mac_str;
120 ofnode node_chan;
121
122 debug("%s(%x, %s)\n", __func__, ofnode_to_offset(node), vsc7224->name);
123 ofnode_for_each_compatible_node(node_chan, "vitesse,vsc7224-channel") {
124 if (!ofnode_valid(node_chan)) {
125 debug("%s: Error parsing FDT node %s\n",
126 __func__, ofnode_get_name(node));
127 break;
128 }
129
130 if (ofnode_to_offset(ofnode_get_parent(node_chan)) !=
131 ofnode_to_offset(node))
132 break;
133
134 reg = ofnode_get_addr(node_chan);
135 if (reg < 0 || reg > 3) {
136 debug("%s: channel reg is either not present or out of range\n",
137 __func__);
138 err = -1;
139 break;
140 }
141 is_tx = ofnode_read_bool(node_chan, "direction-tx");
142
143 debug("%s(%s): Adding %cx channel %d\n",
144 __func__, vsc7224->name, is_tx ? 't' : 'r',
145 reg);
146 tap_values = ofnode_get_property(node_chan, "taps", &len);
147 if (!tap_values) {
148 debug("%s: Error: no taps defined for vsc7224 channel %d\n",
149 __func__, reg);
150 err = -1;
151 break;
152 }
153
154 if (vsc7224->channel[reg]) {
155 debug("%s: Error: channel %d already assigned at %p\n",
156 __func__, reg,
157 vsc7224->channel[reg]);
158 err = -1;
159 break;
160 }
161 if (len % 16) {
162 debug("%s: Error: tap format error for channel %d\n",
163 __func__, reg);
164 err = -1;
165 break;
166 }
167 num_taps = len / 16;
168 debug("%s: Adding %d taps\n", __func__, num_taps);
169
170 channel = cvmx_fdt_alloc(sizeof(*channel) +
171 num_taps * sizeof(struct cvmx_vsc7224_tap));
172 if (!channel) {
173 debug("%s: Out of memory\n", __func__);
174 err = -1;
175 break;
176 }
177 vsc7224->channel[reg] = channel;
178 channel->num_taps = num_taps;
179 channel->lane = reg;
180 channel->of_offset = ofnode_to_offset(node_chan);
181 channel->is_tx = is_tx;
182 channel->pretap_disable = ofnode_read_bool(node_chan,
183 "pretap-disable");
184 channel->posttap_disable = ofnode_read_bool(node_chan,
185 "posttap-disable");
186 channel->vsc7224 = vsc7224;
187 /* Read all the tap values */
188 for (i = 0; i < num_taps; i++) {
189 channel->taps[i].len = fdt32_to_cpu(tap_values[i * 4 + 0]);
190 channel->taps[i].main_tap = fdt32_to_cpu(tap_values[i * 4 + 1]);
191 channel->taps[i].pre_tap = fdt32_to_cpu(tap_values[i * 4 + 2]);
192 channel->taps[i].post_tap = fdt32_to_cpu(tap_values[i * 4 + 3]);
193 debug("%s: tap %d: len: %d, main_tap: 0x%x, pre_tap: 0x%x, post_tap: 0x%x\n",
194 __func__, i, channel->taps[i].len, channel->taps[i].main_tap,
195 channel->taps[i].pre_tap, channel->taps[i].post_tap);
196 }
197 /* Now find out which interface it's mapped to */
198 channel->ipd_port = -1;
199
200 mac_str = "sfp-mac";
201 if (ofnode_get_property(node_chan, mac_str, NULL)) {
202 is_qsfp = false;
203 } else if (ofnode_get_property(node_chan, "qsfp-mac", NULL)) {
204 is_qsfp = true;
205 mac_str = "qsfp-mac";
206 } else {
207 debug("%s: Error: MAC not found for %s channel %d\n", __func__,
208 vsc7224->name, reg);
209 return -1;
210 }
211
212 err = ofnode_parse_phandle_with_args(node_chan, mac_str, NULL,
213 0, 0, &phandle);
214 if (err) {
215 debug("%s: Error %d with MAC %s phandle for %s\n", __func__, of_mac,
216 mac_str, vsc7224->name);
217 return -1;
218 }
219
220 debug("%s: Found mac at %s\n", __func__,
221 ofnode_get_name(phandle.node));
222
223 xiface = (ofnode_get_addr(ofnode_get_parent(phandle.node))
224 >> 24) & 0x0f;
225 index = ofnode_get_addr(phandle.node);
226 channel->xiface = xiface;
227 channel->index = index;
228 channel->ipd_port = cvmx_helper_get_ipd_port(xiface, index);
229
230 debug("%s: Found MAC, xiface: 0x%x, index: %d, ipd port: %d\n", __func__,
231 xiface, index, channel->ipd_port);
232 if (channel->ipd_port >= 0) {
233 cvmx_helper_cfg_set_vsc7224_chan_info(xiface, index, channel);
234 debug("%s: Storing config channel for xiface 0x%x, index %d\n",
235 __func__, xiface, index);
236 }
237 sfp_info = cvmx_helper_cfg_get_sfp_info(xiface, index);
238 if (!sfp_info) {
239 debug("%s: Warning: no (Q)SFP+ slot found for xinterface 0x%x, index %d for channel %d\n",
240 __func__, xiface, index, channel->lane);
241 continue;
242 }
243
244 /* Link it */
245 channel->next = sfp_info->vsc7224_chan;
246 if (sfp_info->vsc7224_chan)
247 sfp_info->vsc7224_chan->prev = channel;
248 sfp_info->vsc7224_chan = channel;
249 sfp_info->is_vsc7224 = true;
250 debug("%s: Registering VSC7224 %s channel %d with SFP %s\n", __func__,
251 vsc7224->name, channel->lane, sfp_info->name);
252 if (!sfp_info->mod_abs_changed) {
253 debug("%s: Registering cvmx_sfp_vsc7224_mod_abs_changed at %p for xinterface 0x%x, index %d\n",
254 __func__, &cvmx_sfp_vsc7224_mod_abs_changed, xiface, index);
255 cvmx_sfp_register_mod_abs_changed(
256 sfp_info,
257 &cvmx_sfp_vsc7224_mod_abs_changed,
258 NULL);
259 }
260
261 if (num_chan >= 4)
262 break;
263 }
264
265 return err;
266 }
267
268 /**
269 * @INTERNAL
270 * Parses all instances of the Vitesse VSC7224 reclocking chip
271 *
272 * @param[in] fdt_addr Address of flat device tree
273 *
274 * Return: 0 for success, error otherwise
275 */
__cvmx_fdt_parse_vsc7224(const void * fdt_addr)276 int __cvmx_fdt_parse_vsc7224(const void *fdt_addr)
277 {
278 struct cvmx_vsc7224 *vsc7224 = NULL;
279 ofnode node;
280 int err = 0;
281 static bool parsed;
282 const int *init_array;
283 struct udevice *dev;
284 u16 value;
285 int reg;
286 int len;
287 int ret;
288 int i;
289
290 debug("%s(%p)\n", __func__, fdt_addr);
291
292 if (parsed) {
293 debug("%s: Already parsed\n", __func__);
294 return 0;
295 }
296
297 ofnode_for_each_compatible_node(node, "vitesse,vsc7224") {
298 if (!ofnode_valid(node)) {
299 debug("%s: Error parsing FDT node %s\n",
300 __func__, ofnode_get_name(node));
301 break;
302 }
303
304 vsc7224 = cvmx_fdt_alloc(sizeof(*vsc7224));
305 if (!vsc7224) {
306 debug("%s: Out of memory!\n", __func__);
307 return -1;
308 }
309
310 vsc7224->of_offset = ofnode_to_offset(node);
311 vsc7224->i2c_addr = ofnode_get_addr(node);
312 vsc7224->i2c_bus = cvmx_ofnode_get_i2c_bus(ofnode_get_parent(node));
313 if (vsc7224->i2c_addr < 0) {
314 debug("%s: Error: reg field missing\n", __func__);
315 err = -1;
316 break;
317 }
318 if (!vsc7224->i2c_bus) {
319 debug("%s: Error getting i2c bus\n", __func__);
320 err = -1;
321 break;
322 }
323 vsc7224->name = ofnode_get_name(node);
324 debug("%s: Adding %s\n", __func__, vsc7224->name);
325
326 err = gpio_request_by_name_nodev(node, "reset", 0,
327 &vsc7224->reset_gpio,
328 GPIOD_IS_OUT);
329 if (err) {
330 printf("%s: reset GPIO not found in DT!\n", __func__);
331 return -ENODEV;
332 }
333
334 err = gpio_request_by_name_nodev(node, "los", 0,
335 &vsc7224->los_gpio,
336 GPIOD_IS_IN);
337 if (err) {
338 printf("%s: los GPIO not found in DT!\n", __func__);
339 return -ENODEV;
340 }
341
342 /*
343 * This code was taken from the NIC23 board specific code
344 * but should be better placed here in the common code
345 */
346 debug("%s: Putting device in reset\n", __func__);
347 dm_gpio_set_value(&vsc7224->reset_gpio, 1);
348 mdelay(10);
349 debug("%s: Taking device out of reset\n", __func__);
350 dm_gpio_set_value(&vsc7224->reset_gpio, 0);
351 mdelay(50);
352
353 init_array = ofnode_get_property(node, "vitesse,reg-init",
354 &len);
355 if (!init_array) {
356 debug("%s: No initialization array\n", __func__);
357 continue;
358 }
359 if ((len % 8) != 0) {
360 printf("%s: Error: register init string should be an array of reg number followed by value\n",
361 __func__);
362 return -1;
363 }
364
365 ret = i2c_get_chip(vsc7224->i2c_bus->i2c_bus,
366 vsc7224->i2c_addr, 1, &dev);
367 if (ret) {
368 debug("Cannot find I2C device: %d\n", ret);
369 return -1;
370 }
371
372 for (i = 0; i < len / sizeof(int); i += 2) {
373 u8 buffer[2];
374
375 reg = fdt32_to_cpu(init_array[i]);
376 value = fdt32_to_cpu(init_array[i + 1]);
377 buffer[0] = value >> 8;
378 buffer[1] = value & 0xff;
379 ret = dm_i2c_write(dev, reg, buffer, 2);
380 if (ret) {
381 debug("Cannot write I2C device: %d\n", ret);
382 return -1;
383 }
384
385 debug(" Wrote 0x%02x <= 0x%02x%02x\n", reg,
386 buffer[0], buffer[1]);
387 }
388
389 debug("%s: Parsing channels\n", __func__);
390 err = cvmx_fdt_parse_vsc7224_channels(node, vsc7224);
391 if (err) {
392 debug("%s: Error parsing VSC7224 channels\n", __func__);
393 break;
394 }
395 }
396
397 if (err) {
398 debug("%s(): Error\n", __func__);
399 if (vsc7224) {
400 dm_gpio_free(vsc7224->reset_gpio.dev,
401 &vsc7224->reset_gpio);
402 dm_gpio_free(vsc7224->los_gpio.dev,
403 &vsc7224->los_gpio);
404 if (vsc7224->i2c_bus)
405 cvmx_fdt_free_i2c_bus(vsc7224->i2c_bus);
406 free(vsc7224);
407 }
408 }
409 if (!err)
410 parsed = true;
411
412 return err;
413 }
414
415 /**
416 * Given the parent offset of an i2c device build up a list describing the bus
417 * which can contain i2c muxes and switches.
418 *
419 * @param[in] node ofnode of the parent node of a GPIO device in
420 * the device tree.
421 *
422 * @return pointer to list of i2c devices starting from the root which
423 * can include i2c muxes and switches or NULL if error. Note that
424 * all entries are allocated on the heap.
425 *
426 * @see cvmx_fdt_free_i2c_bus()
427 */
cvmx_ofnode_get_i2c_bus(ofnode node)428 struct cvmx_fdt_i2c_bus_info *cvmx_ofnode_get_i2c_bus(ofnode node)
429 {
430 struct cvmx_fdt_i2c_bus_info *businfo = NULL;
431 struct udevice *bus;
432 int ret;
433
434 businfo = cvmx_fdt_alloc(sizeof(*businfo));
435 if (!businfo) {
436 debug("Out of memory\n");
437 return NULL;
438 }
439
440 debug("%s: Found node %s\n", __func__, ofnode_get_name(node));
441 businfo->of_offset = ofnode_to_offset(node);
442
443 /*
444 * Get I2C bus and probe it automatically - needed for later use
445 */
446 ret = device_get_global_by_ofnode(node, &bus);
447 if (!bus || ret) {
448 printf("Cannot find a I2C bus\n");
449 return NULL;
450 }
451
452 businfo->i2c_bus = bus;
453
454 return businfo;
455 }
456
457 /**
458 * Return the Octeon bus number for a bus descriptor
459 *
460 * @param[in] bus bus descriptor
461 *
462 * @return Octeon twsi bus number or -1 on error
463 */
cvmx_fdt_i2c_get_root_bus(const struct cvmx_fdt_i2c_bus_info * bus)464 int cvmx_fdt_i2c_get_root_bus(const struct cvmx_fdt_i2c_bus_info *bus)
465 {
466 if (bus->type != CVMX_I2C_BUS_OCTEON)
467 return -1;
468 return bus->channel;
469 }
470
471 /**
472 * Frees all entries for an i2c bus descriptor
473 *
474 * @param bus bus to free
475 *
476 * @return 0
477 */
cvmx_fdt_free_i2c_bus(struct cvmx_fdt_i2c_bus_info * bus)478 int cvmx_fdt_free_i2c_bus(struct cvmx_fdt_i2c_bus_info *bus)
479 {
480 struct cvmx_fdt_i2c_bus_info *last;
481
482 while (bus) {
483 last = bus;
484 bus = bus->child;
485 free(last);
486 }
487 return 0;
488 }
489