linux-imx

/*

 * Copyright 2015 IBM Corp.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version

 * 2 of the License, or (at your option) any later version.

 */

​

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/of_address.h>

#include <linux/of_platform.h>

​

#include "cxl.h"

​

​

static const __be32 *read_prop_string(const struct device_node *np,

                const char *prop_name)

{

    const __be32 *prop;

​

    prop = of_get_property(np, prop_name, NULL);

    if (cxl_verbose && prop)

        pr_info("%s: %s\n", prop_name, (char *) prop);

    return prop;

}

​

static const __be32 *read_prop_dword(const struct device_node *np,

                const char *prop_name, u32 *val)

{

    const __be32 *prop;

​

    prop = of_get_property(np, prop_name, NULL);

    if (prop)

        *val = be32_to_cpu(prop[0]);

    if (cxl_verbose && prop)

        pr_info("%s: %#x (%u)\n", prop_name, *val, *val);

    return prop;

}

​

static const __be64 *read_prop64_dword(const struct device_node *np,

                const char *prop_name, u64 *val)

{

    const __be64 *prop;

​

    prop = of_get_property(np, prop_name, NULL);

    if (prop)

        *val = be64_to_cpu(prop[0]);

    if (cxl_verbose && prop)

        pr_info("%s: %#llx (%llu)\n", prop_name, *val, *val);

    return prop;

}

​

​

static int read_handle(struct device_node *np, u64 *handle)

{

    const __be32 *prop;

    u64 size;

​

    /* Get address and size of the node */

    prop = of_get_address(np, 0, &size, NULL);

    if (size)

        return -EINVAL;

​

    /* Helper to read a big number; size is in cells (not bytes) */

    *handle = of_read_number(prop, of_n_addr_cells(np));

    return 0;

}

​

static int read_phys_addr(struct device_node *np, char *prop_name,

            struct cxl_afu *afu)

{

    int i, len, entry_size, naddr, nsize, type;

    u64 addr, size;

    const __be32 *prop;

​

    naddr = of_n_addr_cells(np);

    nsize = of_n_size_cells(np);

​

    prop = of_get_property(np, prop_name, &len);

    if (prop) {

        entry_size = naddr + nsize;

        for (i = 0; i < (len / 4); i += entry_size, prop += entry_size) {

            type = be32_to_cpu(prop[0]);

            addr = of_read_number(prop, naddr);

            size = of_read_number(&prop[naddr], nsize);

            switch (type) {

            case 0: /* unit address */

                afu->guest->handle = addr;