libjaylink/swd.c

   1 /*
   2  * This file is part of the libjaylink project.
   3  *
   4  * Copyright (C) 2014-2015 Marc Schink <jaylink-dev@marcschink.de>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <stdint.h>
  21 #include <stdbool.h>
  22
  23 #include "libjaylink.h"
  24 #include "libjaylink-internal.h"
  25
  26 /**
  27  * @file
  28  *
  29  * Serial Wire Debug (SWD) functions.
  30  */
  31
  32 /** @cond PRIVATE */
  33 #define CMD_SWD_IO 0xcf
  34
  35 /**
  36  * Error code indicating that there is not enough free memory on the device to
  37  * perform the SWD I/O operation.
  38  */
  39 #define SWD_IO_ERR_NO_MEMORY    0x06
  40 /** @endcond */
  41
  42 /**
  43  * Perform a SWD I/O operation.
  44  *
  45  * @note This function must only be used if the #JAYLINK_TIF_SWD interface is
  46  *       available and selected.
  47  *
  48  * @param[in,out] devh Device handle.
  49  * @param[in] direction Buffer to read the transfer direction from.
  50  * @param[in] out Buffer to read host-to-target data from.
  51  * @param[out] in Buffer to store target-to-host data on success. Its content is
  52  *                undefined on failure. The buffer must be large enough to
  53  *                contain at least the specified number of bits to transfer.
  54  * @param[in] length Total number of bits to transfer from host to target and
  55  *                   vice versa.
  56  *
  57  * @retval JAYLINK_OK Success.
  58  * @retval JAYLINK_ERR_ARG Invalid arguments.
  59  * @retval JAYLINK_ERR_TIMEOUT A timeout occurred.
  60  * @retval JAYLINK_ERR_DEV Unspecified device error.
  61  * @retval JAYLINK_ERR_DEV_NO_MEMORY Not enough memory on the device to perform
  62  *                                   the operation.
  63  * @retval JAYLINK_ERR Other error conditions.
  64  *
  65  * @see jaylink_select_interface() to select the target interface.
  66  * @see jaylink_get_available_interfaces() to retrieve the available target
  67  *                                         interfaces.
  68  *
  69  * @since 0.1.0
  70  */
  71 JAYLINK_API int jaylink_swd_io(struct jaylink_device_handle *devh,
  72                 const uint8_t *direction, const uint8_t *out, uint8_t *in,
  73                 uint16_t length)
  74 {
  75         int ret;
  76         struct jaylink_context *ctx;
  77         uint16_t num_bytes;
  78         uint8_t buf[4];
  79         uint8_t status;
  80
  81         if (!devh || !direction || !out || !in || !length)
  82                 return JAYLINK_ERR_ARG;
  83
  84         ctx = devh->dev->ctx;
  85         num_bytes = (length + 7) / 8;
  86
  87         ret = transport_start_write_read(devh, 4 + 2 * num_bytes,
  88                 num_bytes + 1, true);
  89
  90         if (ret != JAYLINK_OK) {
  91                 log_err(ctx, "transport_start_write_read() failed: %i.", ret);
  92                 return ret;
  93         }
  94
  95         buf[0] = CMD_SWD_IO;
  96         buf[1] = 0x00;
  97         buffer_set_u16(buf, length, 2);
  98
  99         ret = transport_write(devh, buf, 4);
 100
 101         if (ret != JAYLINK_OK) {
 102                 log_err(ctx, "transport_write() failed: %i.", ret);
 103                 return ret;
 104         }
 105
 106         ret = transport_write(devh, direction, num_bytes);
 107
 108         if (ret != JAYLINK_OK) {
 109                 log_err(ctx, "transport_write() failed: %i.", ret);
 110                 return ret;
 111         }
 112
 113         ret = transport_write(devh, out, num_bytes);
 114
 115         if (ret != JAYLINK_OK) {
 116                 log_err(ctx, "transport_write() failed: %i.", ret);
 117                 return ret;
 118         }
 119
 120         ret = transport_read(devh, in, num_bytes);
 121
 122         if (ret != JAYLINK_OK) {
 123                 log_err(ctx, "transport_read() failed: %i.", ret);
 124                 return ret;
 125         }
 126
 127         ret = transport_read(devh, &status, 1);
 128
 129         if (ret != JAYLINK_OK) {
 130                 log_err(ctx, "transport_read() failed: %i.", ret);
 131                 return ret;
 132         }
 133
 134         if (status == SWD_IO_ERR_NO_MEMORY) {
 135                 return JAYLINK_ERR_DEV_NO_MEMORY;
 136         } else if (status > 0) {
 137                 log_err(ctx, "SWD I/O operation failed: %02x.", status);
 138                 return JAYLINK_ERR_DEV;
 139         }
 140
 141         return JAYLINK_OK;
 142 }