df/module-src/df.c

/*
 * Turbo Programmer Utilities, turbo-prog-utils, www.bladox.com 
 *
 * Copyright (C) 2004 BLADOX, s.r.o.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */

#include <config.h>
#include <tprog/tprog.h>
#include <stdlib.h>
#include <avr/interrupt.h>

#include "df.h"
#include "dflash.h"

extern u8 df_id;
extern u16 df_pages;
extern u8 df_blocks;
extern u8 df_off;

void init_df_port ()
{
  led_on (LED_MMC);

  // CLKosc/4 SPI clock (with SPI2X /2)
  outb (SPCR, 0x50);

  // Disable double SPI clock
  cbi (SPSR, SPI2X);

  //DEBUG_SS_MCU change direction to output 
  sbi (DEBUG_SS_MCU_DDR, DEBUG_SS_MCU_DDR_DD);

  delayMs (10);

  // SCK pin will be output and set it to log.0
  cbi (PROG_SCK_PORT, PROG_SCK_PORT_PIN);
  sbi (PROG_SCK_DDR, PROG_SCK_DDR_DD);

  // MOSI pin is output and set it to log.1
  sbi (DEBUG_MOSI_PORT, DEBUG_MOSI_PORT_PIN);
  sbi (DEBUG_MOSI_DDR, DEBUG_MOSI_DDR_DD);

  // MISO is input
  cbi (DEBUG_MISO_DDR, DEBUG_MISO_DDR_DD);

  delayMs (10);
}

void turbo_handler (u8 action, USB_Data * data)
{
  u8 *buf = buf_A ();

  switch (action)
  {
    case ACTION_APP_VERSION:
      buf[0] = 2;
      buf[1] = 0;
      buf[2] = 0;
      usb_send (NO_ERROR, 3, buf);
      break;

    case ACTION_DF_INIT:
      init_df_port ();
      dataFlashInit ();
      buf[0] = df_id;
      buf[1] = df_pages & 0xFF;
      buf[2] = df_pages >> 8;
      buf[3] = df_blocks;
      buf[4] = df_off;
      usb_send (NO_ERROR, 5, buf);
      break;

    case ACTION_DF_READ_STATUS:
      buf[0] = dataFlashStatusRegisterRead ();
      usb_send (NO_ERROR, 1, buf);
      break;

    case ACTION_DF_ERASE_PAGE:
      {
        u16 i16, i;
        u16 block = (u16) ((u16) data->buf[1] << 8) | data->buf[0];
        u16 page;

        for (i16 = 0; i16 < 264; i16++)
          buf[i16] = 0xFF;
        for (i = 0; i < df_blocks; i++)
          dataFlashBufferWrite (0, buf, i * 264, 264);

        for (i16 = 0; i16 < 256; i16++)
        {
          page = block * 256 + i16;
          buf[0] = page;
          buf[1] = page >> 8;
          dataFlashBufferWrite (0, buf, 262, 2);
          dataFlashBufferToMemoryProgramWithErase (0, page);
        }
        usb_send (NO_ERROR, 0, NULL);
      }
      break;

    case ACTION_DF_ERASE_BLOCK:
      dataFlashBlockErase ((u16) ((u16) data->buf[1] << 8) | data->buf[0]);
      usb_send (NO_ERROR, 0, NULL);
      break;

    case ACTION_DF_BUFFER_WRITE:
      {
        u16 i;

        for (i = 0; i < ((u16) ((u16) data->buf[4] << 8) | data->buf[3]); i++)
          buf[i] = data->buf[5 + i];

        dataFlashBufferWrite (data->buf[0], buf,
                              (u16) ((u16) data->buf[2] << 8) | data->buf[1],
                              (u16) ((u16) data->buf[4] << 8) | data->buf[3]);

        usb_send (NO_ERROR, 0, NULL);
      }
      break;

    case ACTION_DF_BUFFER_TO_MEMORY_PROGRAM_WITH_ERASE:
      dataFlashBufferToMemoryProgramWithErase (data->buf[0],
                                               (u16) ((u16) data->
                                                      buf[2] << 8) | data->
                                               buf[1]);
      usb_send (NO_ERROR, 0, NULL);
      break;

    case ACTION_DF_BUFFER_READ:
      {
        u16 len = (u16) ((u16) data->buf[4] << 8) | data->buf[3];

        dataFlashBufferRead (data->buf[0], buf,
                             (u16) ((u16) data->buf[2] << 8) | data->buf[1],
                             len);
        usb_send (NO_ERROR, len, buf);
      }
      break;

    case ACTION_DF_MEMORY_TO_BUFFER_READ:
      dataFlashMemoryToBufferRead (data->buf[0],
                                   (u16) ((u16) data->buf[2] << 8) | data->
                                   buf[1]);
      usb_send (NO_ERROR, 0, NULL);
      break;

    default:
      break;
  }
}