src/main/drivers/max7456.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "platform.h"
  26
  27 #ifdef USE_MAX7456
  28
  29 #include "build/debug.h"
  30
  31 #include "pg/max7456.h"
  32 #include "pg/vcd.h"
  33
  34 #include "drivers/bus_spi.h"
  35 #include "drivers/dma.h"
  36 #include "drivers/io.h"
  37 #include "drivers/light_led.h"
  38 #include "drivers/max7456.h"
  39 #include "drivers/nvic.h"
  40 #include "drivers/osd.h"
  41 #include "drivers/osd_symbols.h"
  42 #include "drivers/time.h"
  43
  44 // 10 MHz max SPI frequency
  45 #define MAX7456_MAX_SPI_CLK_HZ 10000000
  46 #define MAX7456_INIT_MAX_SPI_CLK_HZ 5000000
  47
  48 // DEBUG_MAX7456_SIGNAL
  49 #define DEBUG_MAX7456_SIGNAL_MODEREG       0
  50 #define DEBUG_MAX7456_SIGNAL_SENSE         1
  51 #define DEBUG_MAX7456_SIGNAL_REINIT        2
  52 #define DEBUG_MAX7456_SIGNAL_ROWS          3
  53
  54 // DEBUG_MAX7456_SPICLOCK
  55 #define DEBUG_MAX7456_SPICLOCK_OVERCLOCK   0
  56 #define DEBUG_MAX7456_SPICLOCK_DEVTYPE     1
  57 #define DEBUG_MAX7456_SPICLOCK_DIVISOR     2
  58 #define DEBUG_MAX7456_SPICLOCK_X100        3
  59
  60 // VM0 bits
  61 #define VIDEO_BUFFER_DISABLE        0x01
  62 #define MAX7456_RESET               0x02
  63 #define VERTICAL_SYNC_NEXT_VSYNC    0x04
  64 #define OSD_ENABLE                  0x08
  65
  66 #define SYNC_MODE_AUTO              0x00
  67 #define SYNC_MODE_INTERNAL          0x30
  68 #define SYNC_MODE_EXTERNAL          0x20
  69
  70 #define VIDEO_MODE_PAL              0x40
  71 #define VIDEO_MODE_NTSC             0x00
  72 #define VIDEO_MODE_MASK             0x40
  73 #define VIDEO_MODE_IS_PAL(val)      (((val) & VIDEO_MODE_MASK) == VIDEO_MODE_PAL)
  74 #define VIDEO_MODE_IS_NTSC(val)     (((val) & VIDEO_MODE_MASK) == VIDEO_MODE_NTSC)
  75
  76 #define VIDEO_SIGNAL_DEBOUNCE_MS    100 // Time to wait for input to stabilize
  77
  78 // VM1 bits
  79
  80 // duty cycle is on_off
  81 #define BLINK_DUTY_CYCLE_50_50 0x00
  82 #define BLINK_DUTY_CYCLE_33_66 0x01
  83 #define BLINK_DUTY_CYCLE_25_75 0x02
  84 #define BLINK_DUTY_CYCLE_75_25 0x03
  85
  86 // blinking time
  87 #define BLINK_TIME_0 0x00
  88 #define BLINK_TIME_1 0x04
  89 #define BLINK_TIME_2 0x08
  90 #define BLINK_TIME_3 0x0C
  91
  92 // background mode brightness (percent)
  93 #define BACKGROUND_BRIGHTNESS_0 0x00
  94 #define BACKGROUND_BRIGHTNESS_7 0x01
  95 #define BACKGROUND_BRIGHTNESS_14 0x02
  96 #define BACKGROUND_BRIGHTNESS_21 0x03
  97 #define BACKGROUND_BRIGHTNESS_28 0x04
  98 #define BACKGROUND_BRIGHTNESS_35 0x05
  99 #define BACKGROUND_BRIGHTNESS_42 0x06
 100 #define BACKGROUND_BRIGHTNESS_49 0x07
 101
 102 #define BACKGROUND_MODE_GRAY 0x80
 103
 104 // STAT register bits
 105
 106 #define STAT_PAL      0x01
 107 #define STAT_NTSC     0x02
 108 #define STAT_LOS      0x04
 109 #define STAT_NVR_BUSY 0x20
 110
 111 #define STAT_IS_PAL(val)  ((val) & STAT_PAL)
 112 #define STAT_IS_NTSC(val) ((val) & STAT_NTSC)
 113 #define STAT_IS_LOS(val)  ((val) & STAT_LOS)
 114
 115 #define VIN_IS_PAL(val)  (!STAT_IS_LOS(val) && STAT_IS_PAL(val))
 116 #define VIN_IS_NTSC(val)  (!STAT_IS_LOS(val) && STAT_IS_NTSC(val))
 117
 118 // DMM register bits
 119 #define DMM_AUTO_INC 0x01
 120
 121 // Kluege warning!
 122 // There are occasions that NTSC is not detected even with !LOS (AB7456 specific?)
 123 // When this happens, lower 3 bits of STAT register is read as zero.
 124 // To cope with this case, this macro defines !LOS && !PAL as NTSC.
 125 // Should be compatible with MAX7456 and non-problematic case.
 126
 127 #define VIN_IS_NTSC_alt(val)  (!STAT_IS_LOS(val) && !STAT_IS_PAL(val))
 128
 129 #define MAX7456_SIGNAL_CHECK_INTERVAL_MS 1000 // msec
 130 #define MAX7456_STALL_CHECK_INTERVAL_MS  1000 // msec
 131
 132 // DMM special bits
 133 #define CLEAR_DISPLAY 0x04
 134 #define CLEAR_DISPLAY_VERT 0x06
 135 #define INVERT_PIXEL_COLOR 0x08
 136
 137 // Special address for terminating incremental write
 138 #define END_STRING 0xff
 139
 140 #define MAX7456ADD_READ         0x80
 141 #define MAX7456ADD_VM0          0x00  //0b0011100// 00 // 00             ,0011100
 142 #define MAX7456ADD_VM1          0x01
 143 #define MAX7456ADD_HOS          0x02
 144 #define MAX7456ADD_VOS          0x03
 145 #define MAX7456ADD_DMM          0x04
 146 #define MAX7456ADD_DMAH         0x05
 147 #define MAX7456ADD_DMAL         0x06
 148 #define MAX7456ADD_DMDI         0x07
 149 #define MAX7456ADD_CMM          0x08
 150 #define MAX7456ADD_CMAH         0x09
 151 #define MAX7456ADD_CMAL         0x0a
 152 #define MAX7456ADD_CMDI         0x0b
 153 #define MAX7456ADD_OSDM         0x0c
 154 #define MAX7456ADD_RB0          0x10
 155 #define MAX7456ADD_RB1          0x11
 156 #define MAX7456ADD_RB2          0x12
 157 #define MAX7456ADD_RB3          0x13
 158 #define MAX7456ADD_RB4          0x14
 159 #define MAX7456ADD_RB5          0x15
 160 #define MAX7456ADD_RB6          0x16
 161 #define MAX7456ADD_RB7          0x17
 162 #define MAX7456ADD_RB8          0x18
 163 #define MAX7456ADD_RB9          0x19
 164 #define MAX7456ADD_RB10         0x1a
 165 #define MAX7456ADD_RB11         0x1b
 166 #define MAX7456ADD_RB12         0x1c
 167 #define MAX7456ADD_RB13         0x1d
 168 #define MAX7456ADD_RB14         0x1e
 169 #define MAX7456ADD_RB15         0x1f
 170 #define MAX7456ADD_OSDBL        0x6c
 171 #define MAX7456ADD_STAT         0xA0
 172
 173 #define NVM_RAM_SIZE            54
 174 #define WRITE_NVR               0xA0
 175
 176 // Device type
 177 #define MAX7456_DEVICE_TYPE_MAX 0
 178 #define MAX7456_DEVICE_TYPE_AT  1
 179
 180 #define CHARS_PER_LINE      30 // XXX Should be related to VIDEO_BUFFER_CHARS_*?
 181
 182 #define MAX7456_SUPPORTED_LAYER_COUNT (DISPLAYPORT_LAYER_BACKGROUND + 1)
 183
 184 typedef struct max7456Layer_s {
 185     uint8_t buffer[VIDEO_BUFFER_CHARS_PAL];
 186 } max7456Layer_t;
 187
 188 static max7456Layer_t displayLayers[MAX7456_SUPPORTED_LAYER_COUNT];
 189 static displayPortLayer_e activeLayer = DISPLAYPORT_LAYER_FOREGROUND;
 190
 191 extDevice_t max7456Device;
 192 extDevice_t *dev = &max7456Device;
 193
 194 static bool max7456DeviceDetected = false;
 195 static uint16_t max7456SpiClockDiv;
 196 static volatile bool max7456ActiveDma = false;
 197
 198 uint16_t maxScreenSize = VIDEO_BUFFER_CHARS_PAL;
 199
 200 // We write everything to the active layer and then compare
 201 // it with shadowBuffer to update only changed chars.
 202 // This solution is faster then redrawing entire screen.
 203
 204 static uint8_t shadowBuffer[VIDEO_BUFFER_CHARS_PAL];
 205
 206 //Max bytes to update in one call to max7456DrawScreen()
 207
 208 #define MAX_BYTES2SEND          250
 209 #define MAX_BYTES2SEND_POLLED   12
 210 #define MAX_ENCODE_US           20
 211 #define MAX_ENCODE_US_POLLED    10
 212
 213 static DMA_DATA uint8_t spiBuf[MAX_BYTES2SEND];
 214
 215 static uint8_t  videoSignalCfg;
 216 static uint8_t  videoSignalReg  = OSD_ENABLE; // OSD_ENABLE required to trigger first ReInit
 217 static uint8_t  displayMemoryModeReg = 0;
 218
 219 static uint8_t  hosRegValue; // HOS (Horizontal offset register) value
 220 static uint8_t  vosRegValue; // VOS (Vertical offset register) value
 221
 222 static bool fontIsLoading       = false;
 223
 224 static uint8_t max7456DeviceType;
 225
 226 static displayPortBackground_e deviceBackgroundType = DISPLAY_BACKGROUND_TRANSPARENT;
 227
 228 // previous states initialized outside the valid range to force update on first call
 229 #define INVALID_PREVIOUS_REGISTER_STATE 255
 230 static uint8_t previousBlackWhiteRegister = INVALID_PREVIOUS_REGISTER_STATE;
 231 static uint8_t previousInvertRegister = INVALID_PREVIOUS_REGISTER_STATE;
 232
 233 static uint8_t *getLayerBuffer(displayPortLayer_e layer)
 234 {
 235     return displayLayers[layer].buffer;
 236 }
 237
 238 static uint8_t *getActiveLayerBuffer(void)
 239 {
 240     return getLayerBuffer(activeLayer);
 241 }
 242
 243 static void max7456SetRegisterVM1(void)
 244 {
 245     uint8_t backgroundGray = BACKGROUND_BRIGHTNESS_28; // this is the device default background gray level
 246     uint8_t vm1Register = BLINK_TIME_1 | BLINK_DUTY_CYCLE_75_25; // device defaults
 247     if (deviceBackgroundType != DISPLAY_BACKGROUND_TRANSPARENT) {
 248         vm1Register |= BACKGROUND_MODE_GRAY;
 249         switch (deviceBackgroundType) {
 250         case DISPLAY_BACKGROUND_BLACK:
 251             backgroundGray = BACKGROUND_BRIGHTNESS_0;
 252             break;
 253         case DISPLAY_BACKGROUND_LTGRAY:
 254             backgroundGray = BACKGROUND_BRIGHTNESS_49;
 255             break;
 256         case DISPLAY_BACKGROUND_GRAY:
 257         default:
 258             backgroundGray = BACKGROUND_BRIGHTNESS_28;
 259             break;
 260         }
 261     }
 262     vm1Register |= (backgroundGray << 4);
 263     spiWriteReg(dev, MAX7456ADD_VM1, vm1Register);
 264 }
 265
 266 uint8_t max7456GetRowsCount(void)
 267 {
 268     return (videoSignalReg & VIDEO_MODE_PAL) ? VIDEO_LINES_PAL : VIDEO_LINES_NTSC;
 269 }
 270
 271 // When clearing the shadow buffer we fill with 0 so that the characters will
 272 // be flagged as changed when compared to the 0x20 used in the layer buffers.
 273 static void max7456ClearShadowBuffer(void)
 274 {
 275     memset(shadowBuffer, 0, maxScreenSize);
 276 }
 277
 278 // Buffer is filled with the whitespace character (0x20)
 279 static void max7456ClearLayer(displayPortLayer_e layer)
 280 {
 281     memset(getLayerBuffer(layer), 0x20, VIDEO_BUFFER_CHARS_PAL);
 282 }
 283
 284 void max7456ReInit(void)
 285 {
 286     uint8_t srdata = 0;
 287
 288     switch (videoSignalCfg) {
 289     case VIDEO_SYSTEM_PAL:
 290         videoSignalReg = VIDEO_MODE_PAL | OSD_ENABLE;
 291         break;
 292
 293     case VIDEO_SYSTEM_NTSC:
 294         videoSignalReg = VIDEO_MODE_NTSC | OSD_ENABLE;
 295         break;
 296
 297     case VIDEO_SYSTEM_AUTO:
 298         srdata = spiReadRegMsk(dev, MAX7456ADD_STAT);
 299
 300         if (VIN_IS_NTSC(srdata)) {
 301             videoSignalReg = VIDEO_MODE_NTSC | OSD_ENABLE;
 302         } else if (VIN_IS_PAL(srdata)) {
 303             videoSignalReg = VIDEO_MODE_PAL | OSD_ENABLE;
 304         } else {
 305             // No valid input signal, fallback to default (PAL)
 306             videoSignalReg = VIDEO_MODE_PAL | OSD_ENABLE;
 307         }
 308         break;
 309     }
 310
 311     if (videoSignalReg & VIDEO_MODE_PAL) { //PAL
 312         maxScreenSize = VIDEO_BUFFER_CHARS_PAL;
 313     } else {              // NTSC
 314         maxScreenSize = VIDEO_BUFFER_CHARS_NTSC;
 315     }
 316
 317     // Set all rows to same charactor black/white level
 318     previousBlackWhiteRegister = INVALID_PREVIOUS_REGISTER_STATE;
 319     max7456Brightness(0, 2);
 320     // Re-enable MAX7456 (last function call disables it)
 321
 322     // Make sure the Max7456 is enabled
 323     spiWriteReg(dev, MAX7456ADD_VM0, videoSignalReg);
 324     spiWriteReg(dev, MAX7456ADD_HOS, hosRegValue);
 325     spiWriteReg(dev, MAX7456ADD_VOS, vosRegValue);
 326
 327     max7456SetRegisterVM1();
 328
 329     // Clear shadow to force redraw all screen
 330     max7456ClearShadowBuffer();
 331 }
 332
 333 void max7456PreInit(const max7456Config_t *max7456Config)
 334 {
 335     spiPreinitRegister(max7456Config->csTag, max7456Config->preInitOPU ? IOCFG_OUT_PP : IOCFG_IPU, 1);
 336 }
 337
 338 // Here we init only CS and try to init MAX for first time.
 339 // Also detect device type (MAX v.s. AT)
 340
 341 max7456InitStatus_e max7456Init(const max7456Config_t *max7456Config, const vcdProfile_t *pVcdProfile, bool cpuOverclock)
 342 {
 343     max7456DeviceDetected = false;
 344     deviceBackgroundType = DISPLAY_BACKGROUND_TRANSPARENT;
 345
 346     // initialize all layers
 347     for (unsigned i = 0; i < MAX7456_SUPPORTED_LAYER_COUNT; i++) {
 348         max7456ClearLayer(i);
 349     }
 350
 351     max7456HardwareReset();
 352
 353     if (!max7456Config->csTag || !spiSetBusInstance(dev, max7456Config->spiDevice)) {
 354         return MAX7456_INIT_NOT_CONFIGURED;
 355     }
 356
 357     dev->busType_u.spi.csnPin = IOGetByTag(max7456Config->csTag);
 358
 359     if (!IOIsFreeOrPreinit(dev->busType_u.spi.csnPin)) {
 360         return MAX7456_INIT_NOT_CONFIGURED;
 361     }
 362
 363     IOInit(dev->busType_u.spi.csnPin, OWNER_OSD_CS, 0);
 364     IOConfigGPIO(dev->busType_u.spi.csnPin, SPI_IO_CS_CFG);
 365     IOHi(dev->busType_u.spi.csnPin);
 366
 367     // Detect MAX7456 existence and device type. Do this at half the speed for safety.
 368
 369     // Detect MAX7456 and compatible device by reading OSDM (OSD Insertion MUX) register.
 370     // This register is not modified in this driver, therefore ensured to remain at its default value (0x1B).
 371
 372     spiSetClkDivisor(dev, spiCalculateDivider(MAX7456_INIT_MAX_SPI_CLK_HZ));
 373
 374     // Write 0xff to conclude any current SPI transaction the MAX7456 is expecting
 375     spiWrite(dev, END_STRING);
 376
 377     uint8_t osdm = spiReadRegMsk(dev, MAX7456ADD_OSDM);
 378
 379     if (osdm != 0x1B) {
 380         IOConfigGPIO(dev->busType_u.spi.csnPin, IOCFG_IPU);
 381         return MAX7456_INIT_NOT_FOUND;
 382     }
 383
 384     // At this point, we can claim the ownership of the CS pin
 385     max7456DeviceDetected = true;
 386     IOInit(dev->busType_u.spi.csnPin, OWNER_OSD_CS, 0);
 387
 388     // Detect device type by writing and reading CA[8] bit at CMAL[6].
 389     // This is a bit for accessing second half of character glyph storage, supported only by AT variant.
 390
 391     spiWriteReg(dev, MAX7456ADD_CMAL, (1 << 6)); // CA[8] bit
 392
 393     if (spiReadRegMsk(dev, MAX7456ADD_CMAL) & (1 << 6)) {
 394         max7456DeviceType = MAX7456_DEVICE_TYPE_AT;
 395     } else {
 396         max7456DeviceType = MAX7456_DEVICE_TYPE_MAX;
 397     }
 398
 399 #if defined(USE_OVERCLOCK)
 400     // Determine SPI clock divisor based on config and the device type.
 401
 402     switch (max7456Config->clockConfig) {
 403     case MAX7456_CLOCK_CONFIG_HALF:
 404         max7456SpiClockDiv = spiCalculateDivider(MAX7456_MAX_SPI_CLK_HZ / 2);
 405         break;
 406
 407     case MAX7456_CLOCK_CONFIG_NOMINAL:
 408     default:
 409         max7456SpiClockDiv = spiCalculateDivider(MAX7456_MAX_SPI_CLK_HZ);
 410         break;
 411
 412     case MAX7456_CLOCK_CONFIG_DOUBLE:
 413         max7456SpiClockDiv = spiCalculateDivider(MAX7456_MAX_SPI_CLK_HZ * 2);
 414         break;
 415     }
 416
 417     DEBUG_SET(DEBUG_MAX7456_SPICLOCK, DEBUG_MAX7456_SPICLOCK_OVERCLOCK, cpuOverclock);
 418     DEBUG_SET(DEBUG_MAX7456_SPICLOCK, DEBUG_MAX7456_SPICLOCK_DEVTYPE, max7456DeviceType);
 419     DEBUG_SET(DEBUG_MAX7456_SPICLOCK, DEBUG_MAX7456_SPICLOCK_DIVISOR, max7456SpiClockDiv);
 420     DEBUG_SET(DEBUG_MAX7456_SPICLOCK, DEBUG_MAX7456_SPICLOCK_X100, spiCalculateClock(max7456SpiClockDiv) / 10000);
 421 #else
 422     UNUSED(max7456Config);
 423     UNUSED(cpuOverclock);
 424     max7456SpiClockDiv = spiCalculateDivider(MAX7456_MAX_SPI_CLK_HZ);
 425 #endif
 426
 427     spiSetClkDivisor(dev, max7456SpiClockDiv);
 428
 429     // force soft reset on Max7456
 430     spiWriteReg(dev, MAX7456ADD_VM0, MAX7456_RESET);
 431
 432     // Wait for 200us before polling for completion of reset
 433     delayMicroseconds(200);
 434
 435     // Wait for reset to complete
 436     while ((spiReadRegMsk(dev, MAX7456ADD_VM0) & MAX7456_RESET) != 0x00);
 437
 438     // Setup values to write to registers
 439     videoSignalCfg = pVcdProfile->video_system;
 440     hosRegValue = 32 - pVcdProfile->h_offset;
 441     vosRegValue = 16 - pVcdProfile->v_offset;
 442
 443     // Real init will be made later when driver detect idle.
 444     return MAX7456_INIT_OK;
 445 }
 446
 447 /**
 448  * Sets inversion of black and white pixels.
 449  */
 450 void max7456Invert(bool invert)
 451 {
 452     if (invert) {
 453         displayMemoryModeReg |= INVERT_PIXEL_COLOR;
 454     } else {
 455         displayMemoryModeReg &= ~INVERT_PIXEL_COLOR;
 456     }
 457
 458     if (displayMemoryModeReg != previousInvertRegister) {
 459         // clear the shadow buffer so all characters will be
 460         // redrawn with the proper invert state
 461         max7456ClearShadowBuffer();
 462         previousInvertRegister = displayMemoryModeReg;
 463         spiWriteReg(dev, MAX7456ADD_DMM, displayMemoryModeReg);
 464     }
 465 }
 466
 467 /**
 468  * Sets the brightness of black and white pixels.
 469  *
 470  * @param black Black brightness (0-3, 0 is darkest)
 471  * @param white White brightness (0-3, 0 is darkest)
 472  */
 473 void max7456Brightness(uint8_t black, uint8_t white)
 474 {
 475     const uint8_t reg = (black << 2) | (3 - white);
 476
 477     if (reg != previousBlackWhiteRegister) {
 478         previousBlackWhiteRegister = reg;
 479         STATIC_DMA_DATA_AUTO uint8_t buf[32];
 480         for (int i = MAX7456ADD_RB0, j = 0; i <= MAX7456ADD_RB15; i++) {
 481             buf[j++] = i;
 482             buf[j++] = reg;
 483         }
 484         spiReadWriteBuf(dev, buf, NULL, sizeof(buf));
 485     }
 486 }
 487
 488 void max7456ClearScreen(void)
 489 {
 490     max7456ClearLayer(activeLayer);
 491 }
 492
 493 void max7456WriteChar(uint8_t x, uint8_t y, uint8_t c)
 494 {
 495     uint8_t *buffer = getActiveLayerBuffer();
 496     if (x < CHARS_PER_LINE && y < VIDEO_LINES_PAL) {
 497         buffer[y * CHARS_PER_LINE + x] = c;
 498     }
 499 }
 500
 501 void max7456Write(uint8_t x, uint8_t y, const char *text)
 502 {
 503     if (y < VIDEO_LINES_PAL) {
 504         uint8_t *buffer = getActiveLayerBuffer();
 505         const uint32_t bufferYOffset = y * CHARS_PER_LINE;
 506         for (int i = 0, bufferXOffset = x; text[i] && bufferXOffset < CHARS_PER_LINE; i++, bufferXOffset++) {
 507             buffer[bufferYOffset + bufferXOffset] = text[i];
 508         }
 509     }
 510 }
 511
 512 bool max7456LayerSupported(displayPortLayer_e layer)
 513 {
 514     if (layer == DISPLAYPORT_LAYER_FOREGROUND) {
 515         return true;
 516     } else {
 517         return false;
 518     }
 519 }
 520
 521 bool max7456LayerSelect(displayPortLayer_e layer)
 522 {
 523     if (max7456LayerSupported(layer)) {
 524         activeLayer = layer;
 525         return true;
 526     } else {
 527         return false;
 528     }
 529 }
 530
 531 bool max7456LayerCopy(displayPortLayer_e destLayer, displayPortLayer_e sourceLayer)
 532 {
 533     if ((sourceLayer != destLayer) && max7456LayerSupported(sourceLayer) && max7456LayerSupported(destLayer)) {
 534         memcpy(getLayerBuffer(destLayer), getLayerBuffer(sourceLayer), VIDEO_BUFFER_CHARS_PAL);
 535         return true;
 536     } else {
 537         return false;
 538     }
 539 }
 540
 541 bool max7456DmaInProgress(void)
 542 {
 543     return max7456ActiveDma;
 544 }
 545
 546 bool max7456BuffersSynced(void)
 547 {
 548     for (int i = 0; i < maxScreenSize; i++) {
 549         if (displayLayers[DISPLAYPORT_LAYER_FOREGROUND].buffer[i] != shadowBuffer[i]) {
 550             return false;
 551         }
 552     }
 553     return true;
 554 }
 555
 556 bool max7456ReInitIfRequired(bool forceStallCheck)
 557 {
 558     static timeMs_t lastSigCheckMs = 0;
 559     static timeMs_t videoDetectTimeMs = 0;
 560     static uint16_t reInitCount = 0;
 561     static timeMs_t lastStallCheckMs = MAX7456_STALL_CHECK_INTERVAL_MS / 2; // offset so that it doesn't coincide with the signal check
 562
 563     const timeMs_t nowMs = millis();
 564
 565     bool stalled = false;
 566     if (forceStallCheck || (lastStallCheckMs + MAX7456_STALL_CHECK_INTERVAL_MS < nowMs)) {
 567         lastStallCheckMs = nowMs;
 568
 569         // Write 0xff to conclude any current SPI transaction the MAX7456 is expecting
 570         spiWrite(dev, END_STRING);
 571
 572         stalled = (spiReadRegMsk(dev, MAX7456ADD_VM0) != videoSignalReg);
 573     }
 574
 575     if (stalled) {
 576         max7456ReInit();
 577     } else if ((videoSignalCfg == VIDEO_SYSTEM_AUTO)
 578               && ((nowMs - lastSigCheckMs) > MAX7456_SIGNAL_CHECK_INTERVAL_MS)) {
 579
 580         // Write 0xff to conclude any current SPI transaction the MAX7456 is expecting
 581         spiWrite(dev, END_STRING);
 582
 583         // Adjust output format based on the current input format.
 584
 585         const uint8_t videoSense = spiReadRegMsk(dev, MAX7456ADD_STAT);
 586
 587         DEBUG_SET(DEBUG_MAX7456_SIGNAL, DEBUG_MAX7456_SIGNAL_MODEREG, videoSignalReg & VIDEO_MODE_MASK);
 588         DEBUG_SET(DEBUG_MAX7456_SIGNAL, DEBUG_MAX7456_SIGNAL_SENSE, videoSense & 0x7);
 589         DEBUG_SET(DEBUG_MAX7456_SIGNAL, DEBUG_MAX7456_SIGNAL_ROWS, max7456GetRowsCount());
 590
 591         if (videoSense & STAT_LOS) {
 592             videoDetectTimeMs = 0;
 593         } else {
 594             if ((VIN_IS_PAL(videoSense) && VIDEO_MODE_IS_NTSC(videoSignalReg))
 595               || (VIN_IS_NTSC_alt(videoSense) && VIDEO_MODE_IS_PAL(videoSignalReg))) {
 596                 if (videoDetectTimeMs) {
 597                     if (millis() - videoDetectTimeMs > VIDEO_SIGNAL_DEBOUNCE_MS) {
 598                         max7456ReInit();
 599                         DEBUG_SET(DEBUG_MAX7456_SIGNAL, DEBUG_MAX7456_SIGNAL_REINIT, ++reInitCount);
 600                     }
 601                 } else {
 602                     // Wait for signal to stabilize
 603                     videoDetectTimeMs = millis();
 604                 }
 605             }
 606         }
 607
 608         lastSigCheckMs = nowMs;
 609     }
 610
 611     return stalled;
 612 }
 613
 614 // Called in ISR context
 615 busStatus_e max7456_callbackReady(uint32_t arg)
 616 {
 617     UNUSED(arg);
 618
 619     max7456ActiveDma = false;
 620
 621     return BUS_READY;
 622 }
 623
 624 // Return true if screen still being transferred
 625 bool max7456DrawScreen(void)
 626 {
 627     static uint16_t pos = 0;
 628     // This routine doesn't block so need to use static data
 629     static busSegment_t segments[] = {
 630             {.u.link = {NULL, NULL}, 0, true, max7456_callbackReady},
 631             {.u.link = {NULL, NULL}, 0, true, NULL},
 632     };
 633
 634     if (!fontIsLoading) {
 635         uint8_t *buffer = getActiveLayerBuffer();
 636         int spiBufIndex = 0;
 637         int maxSpiBufStartIndex;
 638         timeDelta_t maxEncodeTime;
 639         bool setAddress = true;
 640         bool autoInc = false;
 641         int posLimit = pos + (maxScreenSize / 2);
 642
 643         maxSpiBufStartIndex = spiUseSDO_DMA(dev) ? MAX_BYTES2SEND : MAX_BYTES2SEND_POLLED;
 644         maxEncodeTime = spiUseSDO_DMA(dev) ? MAX_ENCODE_US : MAX_ENCODE_US_POLLED;
 645
 646         // Abort for now if the bus is still busy
 647         if (spiIsBusy(dev)) {
 648             // Not finished yet
 649             return true;
 650         }
 651
 652         timeUs_t startTime = micros();
 653
 654         // Allow for an ESCAPE, a reset of DMM and a two byte MAX7456ADD_DMM command at end of buffer
 655         maxSpiBufStartIndex -= 4;
 656
 657         // Initialise the transfer buffer
 658         while ((spiBufIndex < maxSpiBufStartIndex) && (pos < posLimit) && (cmpTimeUs(micros(), startTime) < maxEncodeTime)) {
 659             if (buffer[pos] != shadowBuffer[pos]) {
 660                 if (buffer[pos] == 0xff) {
 661                     buffer[pos] = ' ';
 662                 }
 663
 664                 if (setAddress || !autoInc) {
 665                     if (buffer[pos + 1] != shadowBuffer[pos + 1]) {
 666                         // It's worth auto incrementing
 667                         spiBuf[spiBufIndex++] = MAX7456ADD_DMM;
 668                         spiBuf[spiBufIndex++] = displayMemoryModeReg | DMM_AUTO_INC;
 669                         autoInc = true;
 670                     } else {
 671                         // It's not worth auto incrementing
 672                         spiBuf[spiBufIndex++] = MAX7456ADD_DMM;
 673                         spiBuf[spiBufIndex++] = displayMemoryModeReg;
 674                         autoInc = false;
 675                     }
 676
 677                     spiBuf[spiBufIndex++] = MAX7456ADD_DMAH;
 678                     spiBuf[spiBufIndex++] = pos >> 8;
 679                     spiBuf[spiBufIndex++] = MAX7456ADD_DMAL;
 680                     spiBuf[spiBufIndex++] = pos & 0xff;
 681
 682                     setAddress = false;
 683                 }
 684
 685                 spiBuf[spiBufIndex++] = MAX7456ADD_DMDI;
 686                 spiBuf[spiBufIndex++] = buffer[pos];
 687
 688                 shadowBuffer[pos] = buffer[pos];
 689             } else {
 690                 if (!setAddress) {
 691                     setAddress = true;
 692                     if (autoInc) {
 693                         spiBuf[spiBufIndex++] = MAX7456ADD_DMDI;
 694                         spiBuf[spiBufIndex++] = END_STRING;
 695                     }
 696                 }
 697             }
 698
 699             if (++pos >= maxScreenSize) {
 700                 pos = 0;
 701                 break;
 702             }
 703         }
 704
 705         if (autoInc) {
 706             if (!setAddress) {
 707                 spiBuf[spiBufIndex++] = MAX7456ADD_DMDI;
 708                 spiBuf[spiBufIndex++] = END_STRING;
 709             }
 710
 711             spiBuf[spiBufIndex++] = MAX7456ADD_DMM;
 712             spiBuf[spiBufIndex++] = displayMemoryModeReg;
 713         }
 714
 715         if (spiBufIndex) {
 716             segments[0].u.buffers.txData = spiBuf;
 717             segments[0].len = spiBufIndex;
 718
 719             max7456ActiveDma = true;
 720
 721             spiSequence(dev, &segments[0]);
 722
 723             // Non-blocking, so transfer still in progress if using DMA
 724         }
 725     }
 726
 727     return (pos != 0);
 728 }
 729
 730 // should not be used when armed
 731 void max7456RefreshAll(void)
 732 {
 733     max7456ReInitIfRequired(true);
 734     while (max7456DrawScreen());
 735 }
 736
 737 bool max7456WriteNvm(uint8_t char_address, const uint8_t *font_data)
 738 {
 739     if (!max7456DeviceDetected) {
 740         return false;
 741     }
 742
 743     // Block pending completion of any prior SPI access
 744     spiWait(dev);
 745
 746     // disable display
 747     fontIsLoading = true;
 748     spiWriteReg(dev, MAX7456ADD_VM0, 0);
 749
 750     spiWriteReg(dev, MAX7456ADD_CMAH, char_address); // set start address high
 751
 752     for (int x = 0; x < 54; x++) {
 753         spiWriteReg(dev, MAX7456ADD_CMAL, x); //set start address low
 754         spiWriteReg(dev, MAX7456ADD_CMDI, font_data[x]);
 755 #ifdef LED0_TOGGLE
 756         LED0_TOGGLE;
 757 #else
 758         LED1_TOGGLE;
 759 #endif
 760     }
 761
 762     // Transfer 54 bytes from shadow ram to NVM
 763
 764     spiWriteReg(dev, MAX7456ADD_CMM, WRITE_NVR);
 765
 766     // Wait until bit 5 in the status register returns to 0 (12ms)
 767
 768     while ((spiReadRegMsk(dev, MAX7456ADD_STAT) & STAT_NVR_BUSY) != 0x00);
 769
 770     return true;
 771 }
 772
 773 #ifdef MAX7456_NRST_PIN
 774 static IO_t max7456ResetPin        = IO_NONE;
 775 #endif
 776
 777 void max7456HardwareReset(void)
 778 {
 779 #ifdef MAX7456_NRST_PIN
 780 #define IO_RESET_CFG      IO_CONFIG(GPIO_Mode_OUT, GPIO_Speed_2MHz, GPIO_OType_PP, GPIO_PuPd_DOWN)
 781
 782     max7456ResetPin = IOGetByTag(IO_TAG(MAX7456_NRST_PIN));
 783     IOInit(max7456ResetPin, OWNER_OSD, 0);
 784     IOConfigGPIO(max7456ResetPin, IO_RESET_CFG);
 785
 786     // RESET 50ms long pulse, followed by 100us pause
 787     IOLo(max7456ResetPin);
 788     delay(50);
 789     IOHi(max7456ResetPin);
 790     delayMicroseconds(100);
 791 #else
 792     // Allow device 50ms to powerup
 793     delay(50);
 794 #endif
 795 }
 796
 797 bool max7456IsDeviceDetected(void)
 798 {
 799     return max7456DeviceDetected;
 800 }
 801
 802 void max7456SetBackgroundType(displayPortBackground_e backgroundType)
 803 {
 804     deviceBackgroundType = backgroundType;
 805
 806     max7456SetRegisterVM1();
 807 }
 808
 809 #endif // USE_MAX7456