platform.c

Go to the documentation of this file.

/*
 * Microsemi Switchtec(tm) PCIe Management Library
 * Copyright (c) 2017, Microsemi Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 */

 
#include "../switchtec_priv.h"
#include "switchtec/switchtec.h"
#include "switchtec/gas.h"
#include "switchtec/gas_mrpc.h"
#include "switchtec/errors.h"
 
#include <string.h>
#include <errno.h>

struct switchtec_dev *switchtec_open_by_path(const char *path);

struct switchtec_dev *switchtec_open_by_index(int index);

struct switchtec_dev *switchtec_open_by_pci_addr(int domain, int bus,
                         int device, int func);

struct switchtec_dev *switchtec_open_i2c(const char *path, int i2c_addr);

struct switchtec_dev *switchtec_open_uart(int fd);

struct switchtec_dev *switchtec_open_eth(const char *ip, const int inst);

void switchtec_close(struct switchtec_dev *dev)
{
    if (!dev)
        return;
 
    dev->ops->close(dev);
}

int switchtec_list(struct switchtec_device_info **devlist);

int switchtec_get_fw_version(struct switchtec_dev *dev, char *buf,
                 size_t buflen)
{
    struct switchtec_fw_part_summary *sum;
    struct switchtec_fw_image_info *running_img;
 
    sum = switchtec_fw_part_summary(dev);
    if (!sum)
        return -1;
 
    if (sum->img.active && sum->img.active->running) {
        running_img = sum->img.active;
    } else if (sum->img.inactive && sum->img.inactive->running) {
        running_img = sum->img.inactive;
    } else {
        switchtec_fw_part_summary_free(sum);
        errno = EIO;
        return -1;
    }
 
    strncpy(buf, running_img->version, buflen);
    buf[buflen - 1] = '\0';
 
    switchtec_fw_part_summary_free(sum);
 
    return 0;
}

int switchtec_get_device_version(struct switchtec_dev *dev, int *res)
{
    if (!dev->ops->get_device_version)
        return 0;
 
    return dev->ops->get_device_version(dev, res);
}

int switchtec_cmd(struct switchtec_dev *dev,  uint32_t cmd,
          const void *payload, size_t payload_len, void *resp,
          size_t resp_len)
{
    int ret;
 
    cmd &= SWITCHTEC_CMD_MASK;
    cmd |= dev->pax_id << SWITCHTEC_PAX_ID_SHIFT;
 
    ret = dev->ops->cmd(dev, cmd, payload, payload_len, resp, resp_len);
    if (ret > 0) {
        mrpc_error_cmd = cmd & SWITCHTEC_CMD_MASK;
        errno |= SWITCHTEC_ERRNO_MRPC_FLAG_BIT;
    }
 
    return ret;
}

int switchtec_get_devices(struct switchtec_dev *dev,
              struct switchtec_status *status,
              int ports)
{
    if (!dev->ops->get_devices)
        return 0;
 
    return dev->ops->get_devices(dev, status, ports);
}

int switchtec_pff_to_port(struct switchtec_dev *dev, int pff,
              int *partition, int *port)
{
    return dev->ops->pff_to_port(dev, pff, partition, port);
}

int switchtec_port_to_pff(struct switchtec_dev *dev, int partition,
              int port, int *pff)
{
    return dev->ops->port_to_pff(dev, partition, port, pff);
}

gasptr_t switchtec_gas_map(struct switchtec_dev *dev, int writeable,
               size_t *map_size)
{
    return dev->ops->gas_map(dev, writeable, map_size);
}

void switchtec_gas_unmap(struct switchtec_dev *dev, gasptr_t map)
{
    if (!dev->ops->gas_unmap)
        return;
 
    dev->ops->gas_unmap(dev, map);
}

int switchtec_flash_part(struct switchtec_dev *dev,
             struct switchtec_fw_image_info *info,
             enum switchtec_fw_image_part_id_gen3 part)
{
    return dev->ops->flash_part(dev, info, part);
}

int switchtec_event_summary(struct switchtec_dev *dev,
                struct switchtec_event_summary *sum)
{
    return dev->ops->event_summary(dev, sum);
}

int switchtec_event_ctl(struct switchtec_dev *dev,
            enum switchtec_event_id e,
            int index, int flags,
            uint32_t data[5])
{
    return dev->ops->event_ctl(dev, e, index, flags, data);
}

int switchtec_event_wait(struct switchtec_dev *dev, int timeout_ms)
{
    if (!dev->ops->event_wait) {
        errno = ENOTSUP;
        return -errno;
    }
 
    return dev->ops->event_wait(dev, timeout_ms);
}

int gas_read8(struct switchtec_dev *dev, uint8_t __gas *addr, uint8_t *val)
{
    if (dev->pax_id != dev->local_pax_id)
        return gas_mrpc_read8(dev, addr, val);
    else
        *val = __gas_read8(dev, addr);
 
    return 0;
}

int gas_read16(struct switchtec_dev *dev, uint16_t __gas *addr, uint16_t *val)
{
    if (dev->pax_id != dev->local_pax_id)
        return gas_mrpc_read16(dev, addr, val);
    else
        *val = __gas_read16(dev, addr);
 
    return 0;
}

int gas_read32(struct switchtec_dev *dev, uint32_t __gas *addr, uint32_t *val)
{
    if (dev->pax_id != dev->local_pax_id)
        return gas_mrpc_read32(dev, addr, val);
    else
        *val = __gas_read32(dev, addr);
 
    return 0;
}

int gas_read64(struct switchtec_dev *dev, uint64_t __gas *addr, uint64_t *val)
{
    if (dev->pax_id != dev->local_pax_id)
        return gas_mrpc_read64(dev, addr, val);
    else
        *val = __gas_read64(dev, addr);
 
    return 0;
}

void gas_write8(struct switchtec_dev *dev, uint8_t val, uint8_t __gas *addr)
{
    if (dev->pax_id != dev->local_pax_id)
        gas_mrpc_write8(dev, val, addr);
    else
        __gas_write8(dev, val, addr);
}

void gas_write16(struct switchtec_dev *dev, uint16_t val, uint16_t __gas *addr)
{
    if (dev->pax_id != dev->local_pax_id)
        gas_mrpc_write16(dev, val, addr);
    else
        __gas_write16(dev, val, addr);
}

void gas_write32(struct switchtec_dev *dev, uint32_t val, uint32_t __gas *addr)
{
    if (dev->pax_id != dev->local_pax_id)
        gas_mrpc_write32(dev, val, addr);
    else
        __gas_write32(dev, val, addr);
}

void gas_write64(struct switchtec_dev *dev, uint64_t val, uint64_t __gas *addr)
{
    if (dev->pax_id != dev->local_pax_id)
        gas_mrpc_write64(dev, val, addr);
    else
        __gas_write64(dev, val, addr);
}

void memcpy_to_gas(struct switchtec_dev *dev, void __gas *dest,
           const void *src, size_t n)
{
    if (dev->pax_id != dev->local_pax_id)
        gas_mrpc_memcpy_to_gas(dev, dest, src, n);
    else
        __memcpy_to_gas(dev, dest, src, n);
}

int memcpy_from_gas(struct switchtec_dev *dev, void *dest,
            const void __gas *src, size_t n)
{
    if (dev->pax_id != dev->local_pax_id)
        return gas_mrpc_memcpy_from_gas(dev, dest, src, n);
    else
        __memcpy_from_gas(dev, dest, src, n);
 
    return 0;
}

ssize_t write_from_gas(struct switchtec_dev *dev, int fd,
               const void __gas *src, size_t n)
{
    if (dev->pax_id != dev->local_pax_id)
        return gas_mrpc_write_from_gas(dev, fd, src, n);
    else
        return __write_from_gas(dev, fd, src, n);
}