/******************************************************************************

Copyright (c) 2015, Oliver Schmidt
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the <organization> nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL OLIVER SCHMIDT BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

******************************************************************************/

// The W5100 has the undocumented feature to wrap around the Address Register
// on an Auto-Increment at the end of physical address space to its beginning.
//
// However, the only way to make use of that feature is to have only a single
// socket that uses all of the W5100 physical address space. But having only
// a single socket by defining SINGLE_SOCKET comes with downsides too:
//
// One mustn't call into IP65 network functions anymore after w5100_config().
// Additionally the program doesn't support 'W5100 Shared Access' anymore
// (https://github.com/a2retrosystems/uthernet2/wiki/W5100-Shared-Access).

#ifdef SINGLE_SOCKET
#define SOCK_REG(offset) (0x0400 | (offset))
#else // SINGLE_SOCKET
#define SOCK_REG(offset) (0x0500 | (offset))
#endif // SINGLE_SOCKET

// Both pragmas are obligatory to have cc65 generate code
// suitable to access the W5100 auto-increment registers.
#pragma optimize      (on)
#pragma static-locals (on)

#include <ip65.h>

#include "w5100.h"

#define MIN(a,b) (((a)<(b))?(a):(b))

static volatile uint8_t* w5100_mode;
static volatile uint8_t* w5100_addr_hi;
static volatile uint8_t* w5100_addr_lo;
       volatile uint8_t* w5100_data;

static uint16_t addr_basis[2];
static uint16_t addr_limit[2];
static uint16_t addr_mask [2];

static void set_addr(uint16_t addr)
{
  // The variables are necessary to have cc65 generate code
  // suitable to access the W5100 auto-increment registers.
  uint8_t addr_hi = addr >> 8;
  uint8_t addr_lo = addr;
  *w5100_addr_hi = addr_hi;
  *w5100_addr_lo = addr_lo;
}

static uint8_t get_byte(uint16_t addr)
{
  set_addr(addr);

  return *w5100_data;
}

static void set_byte(uint16_t addr, uint8_t data)
{
  set_addr(addr);

  *w5100_data = data;
}

static uint16_t get_word(uint16_t addr)
{
  set_addr(addr);

  {
    // The variables are necessary to have cc65 generate code
    // suitable to access the W5100 auto-increment registers.
    uint8_t data_hi = *w5100_data;
    uint8_t data_lo = *w5100_data;
    return data_hi << 8 | data_lo;
  }
}

static void set_word(uint16_t addr, uint16_t data)
{
  set_addr(addr);

  {
    // The variables are necessary to have cc65 generate code
    // suitable to access the W5100 auto-increment registers.
    uint8_t data_hi = data >> 8;
    uint8_t data_lo = data;
    *w5100_data = data_hi;
    *w5100_data = data_lo;
  }
}

static void set_quad(uint16_t addr, uint32_t data)
{
  set_addr(addr);

  {
    // The variables are necessary to have cc65 generate code
    // suitable to access the W5100 auto-increment registers.
    uint8_t data_1 = data;
    uint8_t data_2 = data >> 8;
    uint8_t data_3 = data >> 16;
    uint8_t data_4 = data >> 24;
    *w5100_data = data_1;
    *w5100_data = data_2;
    *w5100_data = data_3;
    *w5100_data = data_4;
  }
}

void w5100_config(uint8_t eth_init)
{
  w5100_mode    = (uint8_t*)(eth_init << 4 | 0xC084);
  w5100_addr_hi = w5100_mode + 1;
  w5100_addr_lo = w5100_mode + 2;
  w5100_data    = w5100_mode + 3;

#ifdef SINGLE_SOCKET

  // IP65 is inhibited so disable the W5100 Ping Block Mode.
  *w5100_mode &= ~0x10;

#endif // SINGLE_SOCKET

  // Source IP Address Register
  set_quad(0x000F, cfg_ip);

  // Subnet Mask Register
  set_quad(0x0005, cfg_netmask);

  // Gateway IP Address Register
  set_quad(0x0001, cfg_gateway);

  {
    bool do_send;
    for (do_send = false; do_send <= true; ++do_send)
    {
      static uint16_t reg[2] = {0x001A,  // RX Memory Size Register
                                0x001B}; // TX Memory Size Register

      static uint16_t addr[2] = {0x6000,  // RX Memory
                                 0x4000}; // TX Memory

      static uint16_t size[4] = {0x0400,  // 1KB Memory
                                 0x0800,  // 2KB Memory
                                 0x1000,  // 4KB Memory
                                 0x2000}; // 8KB Memory

#ifdef SINGLE_SOCKET

      set_byte(reg[do_send], 0x03);

      // Set Socket 0 Memory Size to 8KB
      addr_basis[do_send] = addr      [do_send];
      addr_limit[do_send] = addr_basis[do_send] + size[0x03];
      addr_mask [do_send] =                       size[0x03] - 1;

#else // SINGLE_SOCKET

      uint8_t sizes = get_byte(reg[do_send]);

      // Get Socket 1 Memory Size
      addr_basis[do_send] = addr      [do_send] + size[sizes      & 0x03];
      addr_limit[do_send] = addr_basis[do_send] + size[sizes >> 2 & 0x03];
      addr_mask [do_send] =                       size[sizes >> 2 & 0x03] - 1;

#endif // SINGLE_SOCKET
    }
  }
}

bool w5100_connect(uint32_t addr, uint16_t port)
{
  // Socket x Mode Register: TCP
  set_byte(SOCK_REG(0x00), 0x01);

  // Socket x Source Port Register
  set_word(SOCK_REG(0x04), ip65_random_word());

  // Socket x Command Register: OPEN
  set_byte(SOCK_REG(0x01), 0x01);

  // Socket x Status Register: SOCK_INIT ?
  while (get_byte(SOCK_REG(0x03)) != 0x13)
  {
    if (input_check_for_abort_key())
    {
      return false;
    }
  }

  // Socket x Destination IP Address Register
  set_quad(SOCK_REG(0x0C), addr);

  // Socket x Destination Port Register
  set_word(SOCK_REG(0x10), port);

  // Socket x Command Register: CONNECT
  set_byte(SOCK_REG(0x01), 0x04);

  while (true)
  {
    // Socket x Status Register
    switch (get_byte(SOCK_REG(0x03)))
    {
      case 0x00: return false; // Socket Status: SOCK_CLOSED
      case 0x17: return true;  // Socket Status: SOCK_ESTABLISHED
    }

    if (input_check_for_abort_key())
    {
      return false;
    }
  }
}

bool w5100_connected(void)
{
  // Socket x Status Register: SOCK_ESTABLISHED ?
  return get_byte(SOCK_REG(0x03)) == 0x17;
}

void w5100_disconnect(void)
{
  // Socket x Command Register: Command Pending ?
  while (get_byte(SOCK_REG(0x01)))
  {
    if (input_check_for_abort_key())
    {
      return;
    }
  }

  // Socket x Command Register: DISCON
  set_byte(SOCK_REG(0x01), 0x08);
}

uint16_t w5100_data_request(bool do_send)
{
  // Socket x Command Register: Command Pending ?
  if (get_byte(SOCK_REG(0x01)))
  {
    return 0;
  }

  {
    uint16_t size = 0;
    uint16_t prev_size;

    // Reread of nonzero RX Received Size Register / TX Free Size Register
    // until its value settles ...
    // - is present in the WIZnet driver - getSn_RX_RSR() / getSn_TX_FSR()
    // - was additionally tested on 6502 machines to be actually necessary
    do
    {
      prev_size = size;
      {
        static uint16_t reg[2] = {SOCK_REG(0x26),  // Socket x RX Received Size Register
                                  SOCK_REG(0x20)}; // Socket x TX Free     Size Register
        size = get_word(reg[do_send]);
      }
    }
    while (size != prev_size);

    if (!size)
    {
      return 0;
    }

    {
      static uint16_t reg[2] = {SOCK_REG(0x28),  // Socket x RX Read  Pointer Register
                                SOCK_REG(0x24)}; // Socket x TX Write Pointer Register

      // Calculate and set physical address
      uint16_t addr = get_word(reg[do_send]) & addr_mask [do_send]
                                             | addr_basis[do_send];
      set_addr(addr);

#ifdef SINGLE_SOCKET

      // The W5100 has the undocumented feature to wrap around the Address Register
      // on an Auto-Increment at the end of physical address space to its beginning.
      return size;

#else // SINGLE_SOCKET

      // Access to *w5100_data is limited both by ...
      // - size of received / free space
      // - end of physical address space
      return MIN(size, addr_limit[do_send] - addr);

#endif // SINGLE_SOCKET
    }
  }
}

void w5100_data_commit(bool do_send, uint16_t size)
{
  {
    static uint16_t reg[2] = {SOCK_REG(0x28),  // Socket x RX Read  Pointer Register
                              SOCK_REG(0x24)}; // Socket x TX Write Pointer Register
    set_word(reg[do_send], get_word(reg[do_send]) + size);
  }

  {
    static uint8_t cmd[2] = {0x40,  // Socket Command: RECV
                             0x20}; // Socket Command: SEND
    // Socket x Command Register
    set_byte(SOCK_REG(0x01), cmd[do_send]);
  }

  // Do NOT wait for command completion here, rather
  // let W5100 operation overlap with 6502 operation
}