swdp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 PHYTEC Messtechnik GmbH
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_SWDP_H_
#define ZEPHYR_INCLUDE_SWDP_H_
 
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif



#define SWDP_REQUEST_APnDP                      BIT(0)
#define SWDP_REQUEST_RnW                        BIT(1)
#define SWDP_REQUEST_A2                         BIT(2)
#define SWDP_REQUEST_A3                         BIT(3)



#define SWDP_ACK_OK                             BIT(0)
#define SWDP_ACK_WAIT                           BIT(1)
#define SWDP_ACK_FAULT                          BIT(2)


#define SWDP_TRANSFER_ERROR                     BIT(3)


#define SWDP_SWCLK_PIN                  0U
#define SWDP_SWDIO_PIN                  1U
#define SWDP_nRESET_PIN                 7U


struct swdp_api {
        int (*swdp_output_sequence)(const struct device *dev,
                                    uint32_t count,
                                    const uint8_t *data);

        int (*swdp_input_sequence)(const struct device *dev,
                                   uint32_t count,
                                   uint8_t *data);

        int (*swdp_transfer)(const struct device *dev,
                             uint8_t request,
                             uint32_t *data,
                             uint8_t idle_cycles,
                             uint8_t *response);

        int (*swdp_set_pins)(const struct device *dev,
                             uint8_t pins, uint8_t value);

        int (*swdp_get_pins)(const struct device *dev, uint8_t *state);

        int (*swdp_set_clock)(const struct device *dev, uint32_t clock);

        int (*swdp_configure)(const struct device *dev,
                              uint8_t turnaround,
                              bool data_phase);

        int (*swdp_port_on)(const struct device *dev);

        int (*swdp_port_off)(const struct device *dev);
};

__syscall int swdp_output_sequence(const struct device *dev,
                                   const uint32_t count,
                                   const uint8_t *const data);
 
static inline int z_impl_swdp_output_sequence(const struct device *dev,
                                              const uint32_t count,
                                              const uint8_t *const data)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_output_sequence(dev, count, data);
}

__syscall int swdp_input_sequence(const struct device *dev,
                                  const uint32_t count,
                                  uint8_t *const buf);
 
static inline int z_impl_swdp_input_sequence(const struct device *dev,
                                             const uint32_t count,
                                             uint8_t *const buf)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_input_sequence(dev, count, buf);
}

__syscall int swdp_transfer(const struct device *dev,
                            const uint8_t request,
                            uint32_t *const data,
                            const uint8_t idle_cycles,
                            uint8_t *const response);
 
static inline int z_impl_swdp_transfer(const struct device *dev,
                                       const uint8_t request,
                                       uint32_t *const data,
                                       const uint8_t idle_cycles,
                                       uint8_t *const response)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_transfer(dev, request, data, idle_cycles, response);
}

__syscall int swdp_set_pins(const struct device *dev,
                            const uint8_t pins,
                            const uint8_t value);
 
static inline int z_impl_swdp_set_pins(const struct device *dev,
                                       const uint8_t pins,
                                       const uint8_t value)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_set_pins(dev, pins, value);
}

__syscall int swdp_get_pins(const struct device *dev,
                            uint8_t *const state);
 
static inline int z_impl_swdp_get_pins(const struct device *dev,
                                       uint8_t *const state)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_get_pins(dev, state);
}

__syscall int swdp_set_clock(const struct device *dev,
                             const uint32_t clock);
 
static inline int z_impl_swdp_set_clock(const struct device *dev,
                                         const uint32_t clock)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_set_clock(dev, clock);
}

__syscall int swdp_port_on(const struct device *dev);
 
static inline int z_impl_swdp_port_on(const struct device *dev)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_port_on(dev);
}

__syscall int swdp_port_off(const struct device *dev);
 
static inline int z_impl_swdp_port_off(const struct device *dev)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_port_off(dev);
}

__syscall int swdp_configure(const struct device *dev,
                             const uint8_t turnaround,
                             const bool data_phase);
 
static inline int z_impl_swdp_configure(const struct device *dev,
                                        const uint8_t turnaround,
                                        const bool data_phase)
{
        const struct swdp_api *api = dev->api;
 
        return api->swdp_configure(dev, turnaround, data_phase);
}
 
#ifdef __cplusplus
}
#endif

 
#include <zephyr/syscalls/swdp.h>
 
#endif /* ZEPHYR_INCLUDE_SWDP_H_ */