marlin/Marlin/src/HAL/HAL_LPC1768/u8g/u8g_com_HAL_LPC1768_ssd_sw_...

/**
 * Marlin 3D Printer Firmware
 * Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
 *
 * Based on Sprinter and grbl.
 * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
 *
 * 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 3 of the License, 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/**
 * Based on U8G2 code - u8x8_byte.c
 *
 * Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
 *
 * Copyright (c) 2016, olikraus@gmail.com
 * 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.
 *
 * 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 THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS 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.
 */

/**
 * Software i2c,
 * ignores ACK response (which is anyway not provided by some displays)
 * also does not allow reading from the device
 */

#ifdef TARGET_LPC1768

#include "../../inc/MarlinConfigPre.h"

#if HAS_GRAPHICAL_LCD

#include <U8glib.h>

//void pinMode(int16_t pin, uint8_t mode);
//void digitalWrite(int16_t pin, uint8_t pin_status);


#define I2C_SLA         (0x3C*2)
//#define I2C_CMD_MODE  0x080
#define I2C_CMD_MODE    0x000
#define I2C_DATA_MODE   0x040

//static uint8_t I2C_speed; // 3 - 400KHz, 13 - 100KHz
//#define SPEED_400KHz 3
//#define SPEED_100KHz 13

//    #define U8G_I2C_OPT_FAST 16

uint8_t SCL_pin_HAL_LPC1768_sw_I2C, SCL_port_HAL_LPC1768_sw_I2C, SDA_pin_HAL_LPC1768_sw_I2C, SDA_port_HAL_LPC1768_sw_I2C;

#define SPI_SPEED 2  //20: 200KHz 5:750KHz 2:3-4MHz

uint8_t u8g_i2c_send_byte_sw(uint8_t data) {
  for (uint8_t i = 0; i < 9; i++) {   // 1 extra bit for the ack/nak

    if (val & 0x80)
      for (uint8_t j = 0; j < SPI_SPEED; j++) {
        LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
        LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
        LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
      }
    else
      for (uint8_t j = 0; j < SPI_SPEED; j++) {
        LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
        LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
        LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
      }

    for (uint8_t j = 0; j < SPI_SPEED; j++) {
      LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
      LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
      LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
      LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
      LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
    }

    for (uint8_t j = 0; j < SPI_SPEED; j++) {
      LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
      LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
    }
    val <<= 1;
  }
  return 1;
}


uint8_t u8g_i2c_start_sw(uint8_t sla) {  // assert start condition and then send slave address with write bit
  /* send the start condition, both lines go from 1 to 0 */

  LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
  LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
  DELAY_US(2);
  LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);
  DELAY_US(2);
  LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOSET = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
  DELAY_US(2);
  LPC_GPIO(SDA_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SDA_pin_HAL_LPC1768_sw_I2C);
  DELAY_US(2);
  LPC_GPIO(SCL_port_HAL_LPC1768_sw_I2C)->FIOCLR = LPC_PIN(SCL_pin_HAL_LPC1768_sw_I2C);

  u8g_i2c_send_byte_sw(I2C_SLA);  // send slave address with write bit
}


void u8g_i2c_stop_sw(void) { }

void u8g_i2c_init_sw(uint8_t clock_option) { u8g_i2c_start(0); } // send slave address and write bit

uint8_t  u8g_com_ssd_I2C_start_sequence_sw(u8g_t *u8g) {
  /* are we requested to set the a0 state? */
  if (u8g->pin_list[U8G_PI_SET_A0] == 0) return 1;

  /* setup bus, might be a repeated start */
  if (u8g_i2c_start(I2C_SLA) == 0) return 0;
  if (u8g->pin_list[U8G_PI_A0_STATE] == 0) {
    if (u8g_i2c_send_byte(I2C_CMD_MODE) == 0) return 0;
  }
  else if (u8g_i2c_send_byte(I2C_DATA_MODE) == 0) return 0;

  u8g->pin_list[U8G_PI_SET_A0] = 0;

  return 1;
}

uint8_t u8g_com_HAL_LPC1768_ssd_sw_i2c_fn(u8g_t *u8g, uint8_t msg, uint8_t arg_val, void *arg_ptr) {
  switch (msg) {
    case U8G_COM_MSG_INIT:

      #define LPC1768_PIN_PORT(pin) ((uint8_t)((pin >> 5) & 0b111))
      #define LPC1768_PIN_PIN(pin) ((uint8_t)(pin & 0b11111))
      SCL_pin_HAL_LPC1768_sw_I2C = LPC1768_PIN_PIN(u8g->pin_list[U8G_PI_SCL]);
      SCL_port_HAL_LPC1768_sw_I2C = LPC1768_PIN_PORT(u8g->pin_list[U8G_PI_SCL]);
      SDA_pin_HAL_LPC1768_sw_I2C = LPC1768_PIN_PIN(u8g->pin_list[U8G_PI_SDA]);
      SDA_port_HAL_LPC1768_sw_I2C = LPC1768_PIN_PORT(u8g->pin_list[U8G_PI_SDA]);
      // As defined by Arduino INPUT(0x0), OUTPUT(0x1), INPUT_PULLUP(0x2)
      #define OUTPUT 0x1
      u8g_SetPIOutput(u8g, U8G_PI_SCL);
      u8g_SetPIOutput(u8g, U8G_PI_SDA);
      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_CS])  u8g_SetPIOutput(u8g, U8G_PI_CS);
      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_A0])  u8g_SetPIOutput(u8g, U8G_PI_A0);
      if (U8G_PIN_NONE != u8g->pin_list[U8G_PI_RESET])  u8g_SetPIOutput(u8g, U8G_PI_RESET);

      //u8g_com_arduino_digital_write(u8g, U8G_PI_SCL, HIGH);
      //u8g_com_arduino_digital_write(u8g, U8G_PI_SDA, HIGH);
      //u8g->pin_list[U8G_PI_A0_STATE] = 0;       /* inital RS state: unknown mode */

      u8g_i2c_init_sw(u8g->pin_list[U8G_PI_I2C_OPTION]);
      u8g_com_ssd_I2C_start_sequence_sw(u8g);
      break;

    case U8G_COM_MSG_STOP: break;

    case U8G_COM_MSG_RESET: break;

    case U8G_COM_MSG_CHIP_SELECT:
      u8g->pin_list[U8G_PI_A0_STATE] = 0;
      u8g->pin_list[U8G_PI_SET_A0] = 1;   /* force a0 to set again, also forces start condition */
      if (arg_val == 0) {
        /* disable chip, send stop condition */
        u8g_i2c_stop_sw();
      }
      else {
        /* enable, do nothing: any byte writing will trigger the i2c start */
      }
      break;

    case U8G_COM_MSG_WRITE_BYTE:
      //u8g->pin_list[U8G_PI_SET_A0] = 1;
      //if (u8g_com_arduino_ssd_start_sequence(u8g) == 0)
      //  return u8g_i2c_stop(), 0;
      if (u8g_i2c_send_byte_sw(arg_val) == 0)
        return u8g_i2c_stop_sw(), 0;
        // u8g_i2c_stop();
      break;

    case U8G_COM_MSG_WRITE_SEQ: {
      //u8g->pin_list[U8G_PI_SET_A0] = 1;
      if (u8g_com_ssd_I2C_start_sequence_sw(u8g) == 0)
        return u8g_i2c_stop_sw(), 0;

        uint8_t *ptr = (uint8_t *)arg_ptr;
        while (arg_val > 0) {
          if (u8g_i2c_send_byte_sw(*ptr++) == 0)
            return u8g_i2c_stop_sw(), 0;
          arg_val--;
        }
      }
      // u8g_i2c_stop();
      break;

    case U8G_COM_MSG_WRITE_SEQ_P: {
      //u8g->pin_list[U8G_PI_SET_A0] = 1;
      if (u8g_com_ssd_I2C_start_sequence_sw(u8g) == 0)
        return u8g_i2c_stop_sw(), 0;

        uint8_t *ptr = (uint8_t *)arg_ptr;
        while (arg_val > 0) {
          if (u8g_i2c_send_byte_sw(u8g_pgm_read(ptr)) == 0) return 0;
          ptr++;
          arg_val--;
        }
      }
      // u8g_i2c_stop();
      break;

    case U8G_COM_MSG_ADDRESS:                     /* define cmd (arg_val = 0) or data mode (arg_val = 1) */
      u8g->pin_list[U8G_PI_A0_STATE] = arg_val;
      u8g->pin_list[U8G_PI_SET_A0] = 1;   /* force a0 to set again */
      u8g_i2c_start_sw(0); // send slave address and write bit
      u8g_i2c_send_byte_sw(arg_val ? 0x40 : 0x80);  // Write to ? Graphics DRAM mode : Command mode
      break;
  }
  return 1;
}

#endif // HAS_GRAPHICAL_LCD

#endif // TARGET_LPC1768