// SPDX-License-Identifier: GPL-2.0 /* * Copyright (C) 2020-2022 Marvell International Ltd. * * FDT Helper functions similar to those provided to U-Boot. */ #include <dm.h> #include <i2c.h> #include <log.h> #include <malloc.h> #include <net.h> #include <linux/delay.h> #include <asm-generic/gpio.h> #include <mach/cvmx-regs.h> #include <mach/cvmx-csr.h> #include <mach/cvmx-bootmem.h> #include <mach/octeon-model.h> #include <mach/octeon_fdt.h> #include <mach/cvmx-helper.h> #include <mach/cvmx-helper-board.h> #include <mach/cvmx-helper-cfg.h> #include <mach/cvmx-helper-fdt.h> /** * Local allocator to handle both SE and U-Boot that also zeroes out memory * * @param size number of bytes to allocate * * Return: pointer to allocated memory or NULL if out of memory. * Alignment is set to 8-bytes. */ static void *cvmx_fdt_alloc(size_t size) { return calloc(size, 1); } int cvmx_ofnode_lookup_phandles(ofnode node, const char *prop_name, int *lenp, ofnode *nodes) { const u32 *phandles; int count; int i; phandles = ofnode_get_property(node, prop_name, &count); if (!phandles || count < 0) return -FDT_ERR_NOTFOUND; count /= 4; if (count > *lenp) count = *lenp; for (i = 0; i < count; i++) nodes[i] = ofnode_get_by_phandle(fdt32_to_cpu(phandles[i])); *lenp = count; return 0; } /** * Given a FDT node return the CPU node number * * @param[in] fdt_addr Address of FDT * @param node FDT node number * * Return: CPU node number or error if negative */ int cvmx_fdt_get_cpu_node(const void *fdt_addr, int node) { int parent = node; const u32 *ranges; int len = 0; while (fdt_node_check_compatible(fdt_addr, parent, "simple-bus") != 0) { parent = fdt_parent_offset(fdt_addr, parent); if (parent < 0) return parent; } ranges = fdt_getprop(fdt_addr, parent, "ranges", &len); if (!ranges) return len; if (len == 0) return 0; if (len < 24) return -FDT_ERR_TRUNCATED; return fdt32_to_cpu(ranges[2]) / 0x10; } /** * Parses all of the channels assigned to a VSC7224 device * * @param[in] fdt_addr Address of flat device tree * @param of_offset Offset of vsc7224 node * @param[in,out] vsc7224 Data structure to hold the data * * Return: 0 for success, -1 on error */ static int cvmx_fdt_parse_vsc7224_channels(ofnode node, struct cvmx_vsc7224 *vsc7224) { struct ofnode_phandle_args phandle; int err = 0; int reg; int num_chan = 0; struct cvmx_vsc7224_chan *channel; struct cvmx_fdt_sfp_info *sfp_info; int len; int num_taps; int i; const u32 *tap_values; int of_mac; int xiface, index; bool is_tx; bool is_qsfp; const char *mac_str; ofnode node_chan; debug("%s(%x, %s)\n", __func__, ofnode_to_offset(node), vsc7224->name); ofnode_for_each_compatible_node(node_chan, "vitesse,vsc7224-channel") { if (!ofnode_valid(node_chan)) { debug("%s: Error parsing FDT node %s\n", __func__, ofnode_get_name(node)); break; } if (ofnode_to_offset(ofnode_get_parent(node_chan)) != ofnode_to_offset(node)) break; reg = ofnode_get_addr(node_chan); if (reg < 0 || reg > 3) { debug("%s: channel reg is either not present or out of range\n", __func__); err = -1; break; } is_tx = ofnode_read_bool(node_chan, "direction-tx"); debug("%s(%s): Adding %cx channel %d\n", __func__, vsc7224->name, is_tx ? 't' : 'r', reg); tap_values = ofnode_get_property(node_chan, "taps", &len); if (!tap_values) { debug("%s: Error: no taps defined for vsc7224 channel %d\n", __func__, reg); err = -1; break; } if (vsc7224->channel[reg]) { debug("%s: Error: channel %d already assigned at %p\n", __func__, reg, vsc7224->channel[reg]); err = -1; break; } if (len % 16) { debug("%s: Error: tap format error for channel %d\n", __func__, reg); err = -1; break; } num_taps = len / 16; debug("%s: Adding %d taps\n", __func__, num_taps); channel = cvmx_fdt_alloc(sizeof(*channel) + num_taps * sizeof(struct cvmx_vsc7224_tap)); if (!channel) { debug("%s: Out of memory\n", __func__); err = -1; break; } vsc7224->channel[reg] = channel; channel->num_taps = num_taps; channel->lane = reg; channel->of_offset = ofnode_to_offset(node_chan); channel->is_tx = is_tx; channel->pretap_disable = ofnode_read_bool(node_chan, "pretap-disable"); channel->posttap_disable = ofnode_read_bool(node_chan, "posttap-disable"); channel->vsc7224 = vsc7224; /* Read all the tap values */ for (i = 0; i < num_taps; i++) { channel->taps[i].len = fdt32_to_cpu(tap_values[i * 4 + 0]); channel->taps[i].main_tap = fdt32_to_cpu(tap_values[i * 4 + 1]); channel->taps[i].pre_tap = fdt32_to_cpu(tap_values[i * 4 + 2]); channel->taps[i].post_tap = fdt32_to_cpu(tap_values[i * 4 + 3]); debug("%s: tap %d: len: %d, main_tap: 0x%x, pre_tap: 0x%x, post_tap: 0x%x\n", __func__, i, channel->taps[i].len, channel->taps[i].main_tap, channel->taps[i].pre_tap, channel->taps[i].post_tap); } /* Now find out which interface it's mapped to */ channel->ipd_port = -1; mac_str = "sfp-mac"; if (ofnode_get_property(node_chan, mac_str, NULL)) { is_qsfp = false; } else if (ofnode_get_property(node_chan, "qsfp-mac", NULL)) { is_qsfp = true; mac_str = "qsfp-mac"; } else { debug("%s: Error: MAC not found for %s channel %d\n", __func__, vsc7224->name, reg); return -1; } err = ofnode_parse_phandle_with_args(node_chan, mac_str, NULL, 0, 0, &phandle); if (err) { debug("%s: Error %d with MAC %s phandle for %s\n", __func__, of_mac, mac_str, vsc7224->name); return -1; } debug("%s: Found mac at %s\n", __func__, ofnode_get_name(phandle.node)); xiface = (ofnode_get_addr(ofnode_get_parent(phandle.node)) >> 24) & 0x0f; index = ofnode_get_addr(phandle.node); channel->xiface = xiface; channel->index = index; channel->ipd_port = cvmx_helper_get_ipd_port(xiface, index); debug("%s: Found MAC, xiface: 0x%x, index: %d, ipd port: %d\n", __func__, xiface, index, channel->ipd_port); if (channel->ipd_port >= 0) { cvmx_helper_cfg_set_vsc7224_chan_info(xiface, index, channel); debug("%s: Storing config channel for xiface 0x%x, index %d\n", __func__, xiface, index); } sfp_info = cvmx_helper_cfg_get_sfp_info(xiface, index); if (!sfp_info) { debug("%s: Warning: no (Q)SFP+ slot found for xinterface 0x%x, index %d for channel %d\n", __func__, xiface, index, channel->lane); continue; } /* Link it */ channel->next = sfp_info->vsc7224_chan; if (sfp_info->vsc7224_chan) sfp_info->vsc7224_chan->prev = channel; sfp_info->vsc7224_chan = channel; sfp_info->is_vsc7224 = true; debug("%s: Registering VSC7224 %s channel %d with SFP %s\n", __func__, vsc7224->name, channel->lane, sfp_info->name); if (!sfp_info->mod_abs_changed) { debug("%s: Registering cvmx_sfp_vsc7224_mod_abs_changed at %p for xinterface 0x%x, index %d\n", __func__, &cvmx_sfp_vsc7224_mod_abs_changed, xiface, index); cvmx_sfp_register_mod_abs_changed( sfp_info, &cvmx_sfp_vsc7224_mod_abs_changed, NULL); } if (num_chan >= 4) break; } return err; } /** * @INTERNAL * Parses all instances of the Vitesse VSC7224 reclocking chip * * @param[in] fdt_addr Address of flat device tree * * Return: 0 for success, error otherwise */ int __cvmx_fdt_parse_vsc7224(const void *fdt_addr) { struct cvmx_vsc7224 *vsc7224 = NULL; ofnode node; int err = 0; static bool parsed; const int *init_array; struct udevice *dev; u16 value; int reg; int len; int ret; int i; debug("%s(%p)\n", __func__, fdt_addr); if (parsed) { debug("%s: Already parsed\n", __func__); return 0; } ofnode_for_each_compatible_node(node, "vitesse,vsc7224") { if (!ofnode_valid(node)) { debug("%s: Error parsing FDT node %s\n", __func__, ofnode_get_name(node)); break; } vsc7224 = cvmx_fdt_alloc(sizeof(*vsc7224)); if (!vsc7224) { debug("%s: Out of memory!\n", __func__); return -1; } vsc7224->of_offset = ofnode_to_offset(node); vsc7224->i2c_addr = ofnode_get_addr(node); vsc7224->i2c_bus = cvmx_ofnode_get_i2c_bus(ofnode_get_parent(node)); if (vsc7224->i2c_addr < 0) { debug("%s: Error: reg field missing\n", __func__); err = -1; break; } if (!vsc7224->i2c_bus) { debug("%s: Error getting i2c bus\n", __func__); err = -1; break; } vsc7224->name = ofnode_get_name(node); debug("%s: Adding %s\n", __func__, vsc7224->name); err = gpio_request_by_name_nodev(node, "reset", 0, &vsc7224->reset_gpio, GPIOD_IS_OUT); if (err) { printf("%s: reset GPIO not found in DT!\n", __func__); return -ENODEV; } err = gpio_request_by_name_nodev(node, "los", 0, &vsc7224->los_gpio, GPIOD_IS_IN); if (err) { printf("%s: los GPIO not found in DT!\n", __func__); return -ENODEV; } /* * This code was taken from the NIC23 board specific code * but should be better placed here in the common code */ debug("%s: Putting device in reset\n", __func__); dm_gpio_set_value(&vsc7224->reset_gpio, 1); mdelay(10); debug("%s: Taking device out of reset\n", __func__); dm_gpio_set_value(&vsc7224->reset_gpio, 0); mdelay(50); init_array = ofnode_get_property(node, "vitesse,reg-init", &len); if (!init_array) { debug("%s: No initialization array\n", __func__); continue; } if ((len % 8) != 0) { printf("%s: Error: register init string should be an array of reg number followed by value\n", __func__); return -1; } ret = i2c_get_chip(vsc7224->i2c_bus->i2c_bus, vsc7224->i2c_addr, 1, &dev); if (ret) { debug("Cannot find I2C device: %d\n", ret); return -1; } for (i = 0; i < len / sizeof(int); i += 2) { u8 buffer[2]; reg = fdt32_to_cpu(init_array[i]); value = fdt32_to_cpu(init_array[i + 1]); buffer[0] = value >> 8; buffer[1] = value & 0xff; ret = dm_i2c_write(dev, reg, buffer, 2); if (ret) { debug("Cannot write I2C device: %d\n", ret); return -1; } debug(" Wrote 0x%02x <= 0x%02x%02x\n", reg, buffer[0], buffer[1]); } debug("%s: Parsing channels\n", __func__); err = cvmx_fdt_parse_vsc7224_channels(node, vsc7224); if (err) { debug("%s: Error parsing VSC7224 channels\n", __func__); break; } } if (err) { debug("%s(): Error\n", __func__); if (vsc7224) { dm_gpio_free(vsc7224->reset_gpio.dev, &vsc7224->reset_gpio); dm_gpio_free(vsc7224->los_gpio.dev, &vsc7224->los_gpio); if (vsc7224->i2c_bus) cvmx_fdt_free_i2c_bus(vsc7224->i2c_bus); free(vsc7224); } } if (!err) parsed = true; return err; } /** * Given the parent offset of an i2c device build up a list describing the bus * which can contain i2c muxes and switches. * * @param[in] node ofnode of the parent node of a GPIO device in * the device tree. * * @return pointer to list of i2c devices starting from the root which * can include i2c muxes and switches or NULL if error. Note that * all entries are allocated on the heap. * * @see cvmx_fdt_free_i2c_bus() */ struct cvmx_fdt_i2c_bus_info *cvmx_ofnode_get_i2c_bus(ofnode node) { struct cvmx_fdt_i2c_bus_info *businfo = NULL; struct udevice *bus; int ret; businfo = cvmx_fdt_alloc(sizeof(*businfo)); if (!businfo) { debug("Out of memory\n"); return NULL; } debug("%s: Found node %s\n", __func__, ofnode_get_name(node)); businfo->of_offset = ofnode_to_offset(node); /* * Get I2C bus and probe it automatically - needed for later use */ ret = device_get_global_by_ofnode(node, &bus); if (!bus || ret) { printf("Cannot find a I2C bus\n"); return NULL; } businfo->i2c_bus = bus; return businfo; } /** * Return the Octeon bus number for a bus descriptor * * @param[in] bus bus descriptor * * @return Octeon twsi bus number or -1 on error */ int cvmx_fdt_i2c_get_root_bus(const struct cvmx_fdt_i2c_bus_info *bus) { if (bus->type != CVMX_I2C_BUS_OCTEON) return -1; return bus->channel; } /** * Frees all entries for an i2c bus descriptor * * @param bus bus to free * * @return 0 */ int cvmx_fdt_free_i2c_bus(struct cvmx_fdt_i2c_bus_info *bus) { struct cvmx_fdt_i2c_bus_info *last; while (bus) { last = bus; bus = bus->child; free(last); } return 0; }