avr/trutcomm.c

   1 /*
   2  * Copyright (C) 2007 Anton Blad
   3  * Copyright (C) 2007 Fredrik Kuivinen
   4  * Copyright (C) 2007 Jakob Rosén
   5  *
   6  * This file is licensed under GPL v2.
   7  */
   8
   9 #include <string.h>
  10
  11 #include "trutcomm.h"
  12
  13 #include "avrusb.h"
  14 #include "debugleds.h"
  15 #include "usbdescriptors.h"
  16 #include "dbuf.h"
  17 #include "buffer.h"
  18
  19 uint8_t trut_flags = 0;
  20
  21 // Common logic for messages. Checks if message transmission is enabled,
  22 // and if the previous message has been sent in case blocking is disabled.
  23 static inline uint8_t trut_msg_start()
  24 {
  25         // Select the endpoint.
  26         usb_select_ep(TRUT_EP_MSG);
  27
  28         // If not blocking and the previous message has not been sent, do not
  29         // send this message.
  30         if(!usb_transin_canstart())
  31                 return 1;
  32
  33         // Signal the start of a transaction.
  34         usb_transin_start();
  35
  36         return 0;
  37 }
  38
  39 static inline void trut_msg_end()
  40 {
  41         // Signal the end of a transaction.
  42         usb_transin_end();
  43 }
  44
  45 void trut_msg_str(const char* str)
  46 {
  47         uint8_t written;
  48         uint8_t len = strlen(str);
  49
  50         if(!trut_msgenabled())
  51                 return;
  52
  53         while(trut_msg_start());
  54
  55         // Write the message type: STR message
  56         usb_writebyte(TRUT_MSG_STR);
  57
  58         // Write the length of the message.
  59         usb_writebyte(len);
  60
  61         while(len)
  62         {
  63                 written = usb_transin_block(str, len, 0);
  64                 str += written;
  65                 len -= written;
  66         }
  67
  68         trut_msg_end();
  69 }
  70
  71 void trut_msg_hex(const uint8_t* data, uint8_t len)
  72 {
  73         uint8_t written;
  74
  75         if(!trut_msgenabled())
  76                 return;
  77
  78         while(trut_msg_start());
  79
  80         // Write the message type: HEX message
  81         usb_writebyte(TRUT_MSG_HEX);
  82
  83         // Write the length of the message.
  84         usb_writebyte(len);
  85
  86         while(len)
  87         {
  88                 written = usb_transin_block(data, len, 0);
  89                 data += written;
  90                 len -= written;
  91         }
  92
  93         trut_msg_end();
  94 }
  95
  96 void trutcomm_task()
  97 {
  98         uint8_t len;
  99
 100         // Return if messages are not enabled.
 101         if(!trut_msgenabled())
 102                 return;
 103
 104         // Return if there are no messages in the buffer.
 105         if(msgbuffer_isempty())
 106                 return;
 107
 108         // Return if the previous message has not been sent.
 109         if(trut_msg_start())
 110                 return;
 111
 112         // Get the message length.
 113         len = msgbuffer_getbyte();
 114
 115         // Write the message.
 116         while(len--)
 117                 usb_writebyte(msgbuffer_getbyte());
 118
 119         // Send the packet.
 120         trut_msg_end();
 121 }
 122
 123 uint8_t trut_has_cmd()
 124 {
 125         usb_select_ep(TRUT_EP_CMD);
 126
 127         return usb_pktout_received();
 128 }
 129
 130 uint8_t trut_cmd_read(uint8_t* cmd, uint8_t* data, uint8_t* len)
 131 {
 132         uint8_t l = 0;
 133
 134         // Select the endpoint.
 135         usb_select_ep(TRUT_EP_CMD);
 136
 137         // Return if there is no packet received.
 138         if(!usb_pktout_received())
 139                 return 1;
 140
 141         // Acknowledge packet reception.
 142         usb_pktout_start();
 143
 144         // Read the type of the received command.
 145         if(!usb_pktout_byte(cmd))
 146         {
 147                 usb_pktout_end();
 148                 return 1;
 149         }
 150
 151         // Read the length of the received command data.
 152         if(!usb_pktout_byte(&l))
 153         {
 154                 usb_pktout_end();
 155                 return 1;
 156         }
 157
 158         *len = l;
 159
 160         // Read the command arguments. Return if the length does not match the
 161         // specified.
 162         if(!(usb_pktout_block(data, l) == l))
 163         {
 164                 usb_pktout_end();
 165                 return 1;
 166         }
 167
 168         // Clear the receive buffer.
 169         usb_pktout_end();
 170
 171         return 0;
 172 }
 173
 174 uint8_t trut_has_data()
 175 {
 176         usb_select_ep(TRUT_EP_DATA);
 177
 178         return usb_pktout_received();
 179 }
 180
 181 uint8_t trut_read_data_to_buffer()
 182 {
 183         uint16_t w;
 184
 185         // Select the endpoint.
 186         usb_select_ep(TRUT_EP_DATA);
 187
 188         // Return if there is no packet received.
 189         if(!usb_pktout_received())
 190                 return 1;
 191
 192         // Acknowledge packet reception.
 193         usb_pktout_start();
 194
 195         // While there are words left in the usb fifo, write them to the buffer.
 196         while(usb_pktout_byte(((uint8_t*) &w)+1))
 197         {
 198                 if(!usb_pktout_byte(((uint8_t*) &w)))
 199                 {
 200                         usb_pktout_end();
 201                         return 1;
 202                 }
 203
 204                 buffer_addword(w);
 205         }
 206
 207         // Clear the receive buffer.
 208         usb_pktout_end();
 209
 210         return 0;
 211 }
 212
 213 uint8_t trut_can_send_data()
 214 {
 215         usb_select_ep(TRUT_EP_DATA);
 216
 217         return usb_fifofree();
 218 }
 219
 220 uint8_t trut_send_buffer_data()
 221 {
 222         uint16_t w;
 223
 224         usb_select_ep(TRUT_EP_DATA);
 225
 226         if(!usb_fifofree())
 227                 return 1;
 228
 229         usb_cleartxini();
 230
 231         while(!buffer_isempty() && usb_rwal())
 232         {
 233                 w = buffer_getword();
 234
 235                 usb_writebyte(w >> 8);
 236                 usb_writebyte(w & 0x00ff);
 237         }
 238
 239         usb_sendpacket();
 240
 241         return 0;
 242 }