Projects/AVRISP-MKII/Lib/XPROG/XPROGTarget.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Target-related functions for the PDI Protocol decoder.
  34  */
  35
  36 #define  INCLUDE_FROM_XPROGTARGET_C
  37 #include "XPROGTarget.h"
  38
  39 #if defined(ENABLE_XPROG_PROTOCOL) || defined(__DOXYGEN__)
  40
  41 /** Flag to indicate if the USART is currently in Tx or Rx mode. */
  42 volatile bool               IsSending;
  43
  44 #if !defined(XPROG_VIA_HARDWARE_USART)
  45 /** Software USART raw frame bits for transmission/reception. */
  46 volatile uint16_t           SoftUSART_Data;
  47
  48 /** Bits remaining to be sent or received via the software USART - set as a GPIOR for speed. */
  49 #define SoftUSART_BitCount  GPIOR2
  50
  51
  52 /** ISR to manage the PDI software USART when bit-banged PDI USART mode is selected. */
  53 ISR(TIMER1_COMPA_vect, ISR_BLOCK)
  54 {
  55         /* Toggle CLOCK pin in a single cycle (see AVR datasheet) */
  56         BITBANG_PDICLOCK_PIN |= BITBANG_PDICLOCK_MASK;
  57
  58         /* If not sending or receiving, just exit */
  59         if (!(SoftUSART_BitCount))
  60           return;
  61
  62         /* Check to see if we are at a rising or falling edge of the clock */
  63         if (BITBANG_PDICLOCK_PORT & BITBANG_PDICLOCK_MASK)
  64         {
  65                 /* If at rising clock edge and we are in send mode, abort */
  66                 if (IsSending)
  67                   return;
  68
  69                 /* Wait for the start bit when receiving */
  70                 if ((SoftUSART_BitCount == BITS_IN_USART_FRAME) && (BITBANG_PDIDATA_PIN & BITBANG_PDIDATA_MASK))
  71                   return;
  72
  73                 /* Shift in the bit one less than the frame size in position, so that the start bit will eventually
  74                  * be discarded leaving the data to be byte-aligned for quick access */
  75                 if (BITBANG_PDIDATA_PIN & BITBANG_PDIDATA_MASK)
  76                   ((uint8_t*)&SoftUSART_Data)[1] |= (1 << (BITS_IN_USART_FRAME - 9));
  77
  78                 SoftUSART_Data >>= 1;
  79                 SoftUSART_BitCount--;
  80         }
  81         else
  82         {
  83                 /* If at falling clock edge and we are in receive mode, abort */
  84                 if (!IsSending)
  85                   return;
  86
  87                 /* Set the data line to the next bit value */
  88                 if (((uint8_t*)&SoftUSART_Data)[0] & 0x01)
  89                   BITBANG_PDIDATA_PORT |=  BITBANG_PDIDATA_MASK;
  90                 else
  91                   BITBANG_PDIDATA_PORT &= ~BITBANG_PDIDATA_MASK;
  92
  93                 SoftUSART_Data >>= 1;
  94                 SoftUSART_BitCount--;
  95         }
  96 }
  97
  98 /** ISR to manage the TPI software USART when bit-banged TPI USART mode is selected. */
  99 ISR(TIMER1_COMPB_vect, ISR_BLOCK)
 100 {
 101         /* Toggle CLOCK pin in a single cycle (see AVR datasheet) */
 102         BITBANG_TPICLOCK_PIN |= BITBANG_TPICLOCK_MASK;
 103
 104         /* If not sending or receiving, just exit */
 105         if (!(SoftUSART_BitCount))
 106           return;
 107
 108         /* Check to see if we are at a rising or falling edge of the clock */
 109         if (BITBANG_TPICLOCK_PORT & BITBANG_TPICLOCK_MASK)
 110         {
 111                 /* If at rising clock edge and we are in send mode, abort */
 112                 if (IsSending)
 113                   return;
 114
 115                 /* Wait for the start bit when receiving */
 116                 if ((SoftUSART_BitCount == BITS_IN_USART_FRAME) && (BITBANG_TPIDATA_PIN & BITBANG_TPIDATA_MASK))
 117                   return;
 118
 119                 /* Shift in the bit one less than the frame size in position, so that the start bit will eventually
 120                  * be discarded leaving the data to be byte-aligned for quick access */
 121                 if (BITBANG_TPIDATA_PIN & BITBANG_TPIDATA_MASK)
 122                  ((uint8_t*)&SoftUSART_Data)[1] |= (1 << (BITS_IN_USART_FRAME - 9));
 123
 124                 SoftUSART_Data >>= 1;
 125                 SoftUSART_BitCount--;
 126         }
 127         else
 128         {
 129                 /* If at falling clock edge and we are in receive mode, abort */
 130                 if (!IsSending)
 131                   return;
 132
 133                 /* Set the data line to the next bit value */
 134                 if (((uint8_t*)&SoftUSART_Data)[0] & 0x01)
 135                   BITBANG_TPIDATA_PORT |=  BITBANG_TPIDATA_MASK;
 136                 else
 137                   BITBANG_TPIDATA_PORT &= ~BITBANG_TPIDATA_MASK;
 138
 139                 SoftUSART_Data >>= 1;
 140                 SoftUSART_BitCount--;
 141         }
 142 }
 143 #endif
 144
 145 /** Enables the target's PDI interface, holding the target in reset until PDI mode is exited. */
 146 void XPROGTarget_EnableTargetPDI(void)
 147 {
 148 #if defined(XPROG_VIA_HARDWARE_USART)
 149         /* Set Tx and XCK as outputs, Rx as input */
 150         DDRD |=  (1 << 5) | (1 << 3);
 151         DDRD &= ~(1 << 2);
 152
 153         /* Set DATA line high for at least 90ns to disable /RESET functionality */
 154         PORTD |= (1 << 3);
 155         asm volatile ("NOP"::);
 156         asm volatile ("NOP"::);
 157
 158         /* Set up the synchronous USART for XMEGA communications -
 159            8 data bits, even parity, 2 stop bits */
 160         UBRR1  = (F_CPU / 1000000UL);
 161         UCSR1B = (1 << TXEN1);
 162         UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
 163
 164         /* Send two BREAKs of 12 bits each to enable PDI interface (need at least 16 idle bits) */
 165         XPROGTarget_SendBreak();
 166         XPROGTarget_SendBreak();
 167 #else
 168         /* Set DATA and CLOCK lines to outputs */
 169         BITBANG_PDIDATA_DDR  |= BITBANG_PDIDATA_MASK;
 170         BITBANG_PDICLOCK_DDR |= BITBANG_PDICLOCK_MASK;
 171
 172         /* Set DATA line high for at least 90ns to disable /RESET functionality */
 173         BITBANG_PDIDATA_PORT |= BITBANG_PDIDATA_MASK;
 174         asm volatile ("NOP"::);
 175         asm volatile ("NOP"::);
 176
 177         /* Fire timer compare channel A ISR every 90 cycles to manage the software USART */
 178         OCR1A   = 90;
 179         TCCR1B  = (1 << WGM12) | (1 << CS10);
 180         TIMSK1  = (1 << OCIE1A);
 181
 182         /* Send two BREAKs of 12 bits each to enable TPI interface (need at least 16 idle bits) */
 183         XPROGTarget_SendBreak();
 184         XPROGTarget_SendBreak();
 185 #endif
 186 }
 187
 188 /** Enables the target's TPI interface, holding the target in reset until TPI mode is exited. */
 189 void XPROGTarget_EnableTargetTPI(void)
 190 {
 191         /* Set /RESET line low for at least 90ns to enable TPI functionality */
 192         RESET_LINE_DDR  |= RESET_LINE_MASK;
 193         RESET_LINE_PORT &= ~RESET_LINE_MASK;
 194         asm volatile ("NOP"::);
 195         asm volatile ("NOP"::);
 196
 197 #if defined(XPROG_VIA_HARDWARE_USART)
 198         /* Set Tx and XCK as outputs, Rx as input */
 199         DDRD |=  (1 << 5) | (1 << 3);
 200         DDRD &= ~(1 << 2);
 201
 202         /* Set up the synchronous USART for XMEGA communications -
 203            8 data bits, even parity, 2 stop bits */
 204         UBRR1  = (F_CPU / 1000000UL);
 205         UCSR1B = (1 << TXEN1);
 206         UCSR1C = (1 << UMSEL10) | (1 << UPM11) | (1 << USBS1) | (1 << UCSZ11) | (1 << UCSZ10) | (1 << UCPOL1);
 207
 208         /* Send two BREAKs of 12 bits each to enable TPI interface (need at least 16 idle bits) */
 209         XPROGTarget_SendBreak();
 210         XPROGTarget_SendBreak();
 211 #else
 212         /* Set DATA and CLOCK lines to outputs */
 213         BITBANG_TPIDATA_DDR  |= BITBANG_TPIDATA_MASK;
 214         BITBANG_TPICLOCK_DDR |= BITBANG_TPICLOCK_MASK;
 215
 216         /* Set DATA line high for idle state */
 217         BITBANG_TPIDATA_PORT |= BITBANG_TPIDATA_MASK;
 218
 219         /* Fire timer capture channel B ISR every 90 cycles to manage the software USART */
 220         OCR1B   = 9;
 221         TCCR1B  = (1 << WGM12) | (1 << CS10);
 222         TIMSK1  = (1 << OCIE1B);
 223
 224         /* Send two BREAKs of 12 bits each to enable TPI interface (need at least 16 idle bits) */
 225         XPROGTarget_SendBreak();
 226         XPROGTarget_SendBreak();
 227 #endif
 228 }
 229
 230 /** Disables the target's PDI interface, exits programming mode and starts the target's application. */
 231 void XPROGTarget_DisableTargetPDI(void)
 232 {
 233 #if defined(XPROG_VIA_HARDWARE_USART)
 234         /* Turn off receiver and transmitter of the USART, clear settings */
 235         UCSR1A |= (1 << TXC1) | (1 << RXC1);
 236         UCSR1B  = 0;
 237         UCSR1C  = 0;
 238
 239         /* Set all USART lines as input, tristate */
 240         DDRD  &= ~((1 << 5) | (1 << 3));
 241         PORTD &= ~((1 << 5) | (1 << 3) | (1 << 2));
 242 #else
 243         /* Set DATA and CLOCK lines to inputs */
 244         BITBANG_PDIDATA_DDR   &= ~BITBANG_PDIDATA_MASK;
 245         BITBANG_PDICLOCK_DDR  &= ~BITBANG_PDICLOCK_MASK;
 246
 247         /* Tristate DATA and CLOCK lines */
 248         BITBANG_PDIDATA_PORT  &= ~BITBANG_PDIDATA_MASK;
 249         BITBANG_PDICLOCK_PORT &= ~BITBANG_PDICLOCK_MASK;
 250 #endif
 251 }
 252
 253 /** Disables the target's TPI interface, exits programming mode and starts the target's application. */
 254 void XPROGTarget_DisableTargetTPI(void)
 255 {
 256 #if defined(XPROG_VIA_HARDWARE_USART)
 257         /* Turn off receiver and transmitter of the USART, clear settings */
 258         UCSR1A |= (1 << TXC1) | (1 << RXC1);
 259         UCSR1B  = 0;
 260         UCSR1C  = 0;
 261
 262         /* Set all USART lines as input, tristate */
 263         DDRD  &= ~((1 << 5) | (1 << 3));
 264         PORTD &= ~((1 << 5) | (1 << 3) | (1 << 2));
 265 #else
 266         /* Set DATA and CLOCK lines to inputs */
 267         BITBANG_TPIDATA_DDR   &= ~BITBANG_TPIDATA_MASK;
 268         BITBANG_TPICLOCK_DDR  &= ~BITBANG_TPICLOCK_MASK;
 269
 270         /* Tristate DATA and CLOCK lines */
 271         BITBANG_TPIDATA_PORT  &= ~BITBANG_TPIDATA_MASK;
 272         BITBANG_TPICLOCK_PORT &= ~BITBANG_TPICLOCK_MASK;
 273 #endif
 274
 275         /* Tristate target /RESET line */
 276         RESET_LINE_DDR  &= ~RESET_LINE_MASK;
 277         RESET_LINE_PORT &= ~RESET_LINE_MASK;
 278 }
 279
 280 /** Sends a byte via the USART.
 281  *
 282  *  \param[in] Byte  Byte to send through the USART
 283  */
 284 void XPROGTarget_SendByte(const uint8_t Byte)
 285 {
 286 #if defined(XPROG_VIA_HARDWARE_USART)
 287         /* Switch to Tx mode if currently in Rx mode */
 288         if (!(IsSending))
 289         {
 290                 PORTD  |=  (1 << 3);
 291                 DDRD   |=  (1 << 3);
 292
 293                 UCSR1B |=  (1 << TXEN1);
 294                 UCSR1B &= ~(1 << RXEN1);
 295
 296                 IsSending = true;
 297         }
 298
 299         /* Wait until there is space in the hardware Tx buffer before writing */
 300         while (!(UCSR1A & (1 << UDRE1)));
 301         UCSR1A |= (1 << TXC1);
 302         UDR1    = Byte;
 303 #else
 304         /* Switch to Tx mode if currently in Rx mode */
 305         if (!(IsSending))
 306         {
 307                 BITBANG_PDIDATA_PORT |= BITBANG_PDIDATA_MASK;
 308                 BITBANG_PDIDATA_DDR  |= BITBANG_PDIDATA_MASK;
 309
 310                 IsSending = true;
 311         }
 312
 313         /* Calculate the new USART frame data here while while we wait for a previous byte (if any) to finish sending */
 314         uint16_t NewUSARTData = ((1 << 11) | (1 << 10) | (0 << 9) | ((uint16_t)Byte << 1) | (0 << 0));
 315
 316         /* Compute Even parity - while a bit is still set, chop off lowest bit and toggle parity bit */
 317         uint8_t ParityData    = Byte;
 318         while (ParityData)
 319         {
 320                 NewUSARTData ^= (1 << 9);
 321                 ParityData   &= (ParityData - 1);
 322         }
 323
 324         /* Wait until transmitter is idle before writing new data */
 325         while (SoftUSART_BitCount);
 326
 327         /* Data shifted out LSB first, START DATA PARITY STOP STOP */
 328         SoftUSART_Data     = NewUSARTData;
 329         SoftUSART_BitCount = BITS_IN_USART_FRAME;
 330 #endif
 331 }
 332
 333 /** Receives a byte via the software USART, blocking until data is received.
 334  *
 335  *  \return Received byte from the USART
 336  */
 337 uint8_t XPROGTarget_ReceiveByte(void)
 338 {
 339 #if defined(XPROG_VIA_HARDWARE_USART)
 340         /* Switch to Rx mode if currently in Tx mode */
 341         if (IsSending)
 342         {
 343                 while (!(UCSR1A & (1 << TXC1)));
 344                 UCSR1A |=  (1 << TXC1);
 345
 346                 UCSR1B &= ~(1 << TXEN1);
 347                 UCSR1B |=  (1 << RXEN1);
 348
 349                 DDRD   &= ~(1 << 3);
 350                 PORTD  &= ~(1 << 3);
 351
 352                 IsSending = false;
 353         }
 354
 355         /* Wait until a byte has been received before reading */
 356         while (!(UCSR1A & (1 << RXC1)) && TimeoutMSRemaining);
 357         return UDR1;
 358 #else
 359         /* Switch to Rx mode if currently in Tx mode */
 360         if (IsSending)
 361         {
 362                 while (SoftUSART_BitCount);
 363
 364                 BITBANG_PDIDATA_DDR  &= ~BITBANG_PDIDATA_MASK;
 365                 BITBANG_PDIDATA_PORT &= ~BITBANG_PDIDATA_MASK;
 366
 367                 IsSending = false;
 368         }
 369
 370         /* Wait until a byte has been received before reading */
 371         SoftUSART_BitCount = BITS_IN_USART_FRAME;
 372         while (SoftUSART_BitCount && TimeoutMSRemaining);
 373
 374         /* Throw away the parity and stop bits to leave only the data (start bit is already discarded) */
 375         return (uint8_t)SoftUSART_Data;
 376 #endif
 377 }
 378
 379 /** Sends a BREAK via the USART to the attached target, consisting of a full frame of idle bits. */
 380 void XPROGTarget_SendBreak(void)
 381 {
 382 #if defined(XPROG_VIA_HARDWARE_USART)
 383         /* Switch to Tx mode if currently in Rx mode */
 384         if (!(IsSending))
 385         {
 386                 PORTD  |=  (1 << 3);
 387                 DDRD   |=  (1 << 3);
 388
 389                 UCSR1B &= ~(1 << RXEN1);
 390                 UCSR1B |=  (1 << TXEN1);
 391
 392                 IsSending = true;
 393         }
 394
 395         /* Need to do nothing for a full frame to send a BREAK */
 396         for (uint8_t i = 0; i < BITS_IN_USART_FRAME; i++)
 397         {
 398                 /* Wait for a full cycle of the clock */
 399                 while (PIND & (1 << 5));
 400                 while (!(PIND & (1 << 5)));
 401         }
 402 #else
 403         /* Switch to Tx mode if currently in Rx mode */
 404         if (!(IsSending))
 405         {
 406                 BITBANG_PDIDATA_PORT |= BITBANG_PDIDATA_MASK;
 407                 BITBANG_PDIDATA_DDR  |= BITBANG_PDIDATA_MASK;
 408
 409                 IsSending = true;
 410         }
 411
 412         while (SoftUSART_BitCount);
 413
 414         /* Need to do nothing for a full frame to send a BREAK */
 415         SoftUSART_Data     = 0x0FFF;
 416         SoftUSART_BitCount = BITS_IN_USART_FRAME;
 417 #endif
 418 }
 419
 420 #endif