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 JAYLINK_API int jaylink_swd_io(struct jaylink_device_handle *devh,
  70                 const uint8_t *direction, const uint8_t *out, uint8_t *in,
  71                 uint16_t length)
  72 {
  73         int ret;
  74         struct jaylink_context *ctx;
  75         uint16_t num_bytes;
  76         uint8_t buf[4];
  77         uint8_t status;
  78
  79         if (!devh || !direction || !out || !in || !length)
  80                 return JAYLINK_ERR_ARG;
  81
  82         ctx = devh->dev->ctx;
  83         num_bytes = (length + 7) / 8;
  84
  85         ret = transport_start_write_read(devh, 4 + 2 * num_bytes,
  86                 num_bytes + 1, true);
  87
  88         if (ret != JAYLINK_OK) {
  89                 log_err(ctx, "transport_start_write_read() failed: %i.", ret);
  90                 return ret;
  91         }
  92
  93         buf[0] = CMD_SWD_IO;
  94         /* Dummy byte. */
  95         buf[1] = 0x00;
  96         buffer_set_u16(buf, length, 2);
  97
  98         ret = transport_write(devh, buf, 4);
  99
 100         if (ret != JAYLINK_OK) {
 101                 log_err(ctx, "transport_write() failed: %i.", ret);
 102                 return ret;
 103         }
 104
 105         ret = transport_write(devh, direction, num_bytes);
 106
 107         if (ret != JAYLINK_OK) {
 108                 log_err(ctx, "transport_write() failed: %i.", ret);
 109                 return ret;
 110         }
 111
 112         ret = transport_write(devh, out, num_bytes);
 113
 114         if (ret != JAYLINK_OK) {
 115                 log_err(ctx, "transport_write() failed: %i.", ret);
 116                 return ret;
 117         }
 118
 119         ret = transport_read(devh, in, num_bytes);
 120
 121         if (ret != JAYLINK_OK) {
 122                 log_err(ctx, "transport_read() failed: %i.", ret);
 123                 return ret;
 124         }
 125
 126         ret = transport_read(devh, &status, 1);
 127
 128         if (ret != JAYLINK_OK) {
 129                 log_err(ctx, "transport_read() failed: %i.", ret);
 130                 return ret;
 131         }
 132
 133         if (status == SWD_IO_ERR_NO_MEMORY) {
 134                 return JAYLINK_ERR_DEV_NO_MEMORY;
 135         } else if (status > 0) {
 136                 log_err(ctx, "SWD I/O operation failed: %02x.", status);
 137                 return JAYLINK_ERR_DEV;
 138         }
 139
 140         return JAYLINK_OK;
 141 }