Porting the Arduino camera and display ecosytem to Zephyr

[josuah]

The Arduino hardware ecosystem supports cameras modules such as those sold by Arducam as well as others from 3rd-party.

These cameras can be used on Zephyr, including using the ArduinoCore-Zephyr.

This is thread is there to aggregate all progress and information useful to get Arduino camera working again on Arduino Sketches on top of the Zephyr core.

Related issues:

• drivers: video: video_stm32_dcmi: Detect and recover from: HAL_DCMI_ErrorCallback #92354
• Improve the ov5640 video driver to provide parallel interface (DVP) support. #74353

[mjs513]

@CharlesDias = @KurtE
Since we are keeping this together now on the OV5640 I measured both xclk and pixclk per #92354 (comment) both seem to be running at 12.5 mhz - not pwm setting is 12mhz. So close

PIXCLK

XLCK

[mjs513]

@KurtE

I update the overlay and made the changes you suggested in post #74353 (comment) but using still no luck in getting a descent image to the ST7796 using your library.

[mjs513]

@josuah - @KurtE

Since you made this thread decided to run through the cameras I have using the giga and the giga display shield.

Running the OV7670 at 12 mhz it runs for quite a bit (~5mins) at 320x240 and then I see several

 <wrn> input: Event dropped, queue full, not blocking in syswq

and eventually a Bus fault occurs ( imprecise data bus error) and I see this at the end

[00:06:01.988,000] <err> os: Faulting instruction address (r15/pc): 0x08065310
[00:06:01.996,000] <err> os: >>> ZEPHYR FATAL ERROR 26: Unknown error on CPU 0
[00:06:02.004,000] <err> os: Fault during interrupt handling

[00:06:02.010,000] <err> os: Current thread: 0x24003610 (sysworkq)
[00:06:02.017,000] <err> os: Halting system

Not sure where or why yet but going to try the 2640 next to see if I get the same thing.

NOTE: to get the display working @KurtE and I developed custom libraries to support graphics on the giga display:
https://github.com/mjs513/Arduino_GigaDisplay_GFX/tree/Arduino_GigaDisplay_GFX_zephyr
and
https://github.com/mjs513/Arduino_GigaDisplay/tree/Arduino_GigaDisplay_Zephyr

so we can run the following sketch to test the cameras

#include <elapsedMillis.h>

#include "Arduino_GigaDisplay_GFX.h"
#define GC9A01A_CYAN 0x07FF
#define GC9A01A_RED 0xf800
#define GC9A01A_BLUE 0x001F
#define GC9A01A_GREEN 0x07E0
#define GC9A01A_MAGENTA 0xF81F
#define GC9A01A_WHITE 0xffff
#define GC9A01A_BLACK 0x0000
#define GC9A01A_YELLOW 0xFFE0
#define ALIGN_PTR(p, a) ((p & (a - 1)) ? (((uintptr_t)p + a) & ~(uintptr_t)(a - 1)) : p)

#define CANVAS_ROTATION 0
uint16_t color565(uint8_t r, uint8_t g, uint8_t b) {
  return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

#define CAMERA_WIDTH 320
#define CAMERA_HEIGHT 240
#define SCALE 2

#include <camera.h>
 
Camera cam;

// The buffer used to capture the frame
FrameBuffer fb;

#ifdef ROTATE_CAMERA_IMAGE
uint16_t *rotate_buffer = nullptr;
#endif


// The buffer used to rotate and resize the frame
GigaDisplay_GFX display;

void blinkLED(uint32_t count = 0xFFFFFFFF) {
  pinMode(LED_BUILTIN, OUTPUT);
  while (count--) {
    digitalWrite(LED_BUILTIN, LOW);   // turn the LED on (HIGH is the voltage level)
    delay(50);                        // wait for a second
    digitalWrite(LED_BUILTIN, HIGH);  // turn the LED off by making the voltage LOW
    delay(50);                        // wait for a second
  }
}

void fatal_error(const char *msg) {
  Serial.println(msg);
  pinMode(LED_BUILTIN, OUTPUT);
  while (1) {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(100);
    digitalWrite(LED_BUILTIN, LOW);
    delay(100);
  }
}



void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  while (!Serial && millis() < 5000) {}
  Serial.begin(115200);

  // Init the cam QVGA, 30FPS
  Serial.println("Before camera start");
  Serial.flush();
  //cam.debug(Serial);
  if (!cam.begin(CAMERA_WIDTH, CAMERA_HEIGHT, CAMERA_RGB565, true)) {
    fatal_error("Camera begin failed");
  }
  //Serial.println("Before setRotation");
  //Serial.flush();

  display.begin();
  elapsedMicros em;
  display.setRotation(1);
  display.fillScreen(GC9A01A_BLUE);
  Serial.println(em, DEC);
  Serial.print("Camera Width: "); Serial.print(CAMERA_WIDTH);
  Serial.print(" Height: "); Serial.println(CAMERA_HEIGHT);
  Serial.print("Screen Width: "); Serial.print(display.width());
  Serial.print(" Height: "); Serial.println(display.height());
  Serial.print("Scale: "); Serial.println(SCALE);
  Serial.println("end setup");
  Serial.flush();
}

inline uint16_t HTONS(uint16_t x) {
  return ((x >> 8) & 0x00FF) | ((x << 8) & 0xFF00);
}
//#define HTONS(x) (((x >> 8) & 0x00FF) | ((x << 8) & 0xFF00))


uint32_t display_time_sum = 0;
uint8_t display_time_count = 0;

void loop() {

  // Grab frame and write to another framebuffer
  if (cam.grabFrame(fb)) {
    //Serial.println("Camera frame received");
    if (Serial.available()) {
      while (Serial.read() != -1) {}
//      cam.printRegs();
      //MemoryHexDump(Serial, fb.getBuffer(), 1024, true, "Start of Camera Buffer\n");
      Serial.println("*** Paused ***");
      while (Serial.read() == -1) {}
      while (Serial.read() != -1) {}
    }

    uint16_t *pixels = (uint16_t *)fb.getBuffer();
    elapsedMicros emDisplay;
    //for (int i = 0; i < CAMERA_WIDTH*CAMERA_HEIGHT; i++) pixels[i] = HTONS(pixels[i]);
    #if defined(SCALE) && SCALE > 1
    // Quick and dirty scale.
    int yDisplay = (display.height() - (CAMERA_HEIGHT * SCALE)) / 2;
    display.startBuffering();
    for (int yCamera = 0; yCamera < CAMERA_HEIGHT; yCamera++) {
      int xDisplay = (display.width() - (CAMERA_WIDTH * SCALE)) / 2;
      for (int xCamera = 0; xCamera < CAMERA_WIDTH; xCamera++) {
        display.fillRect(xDisplay, yDisplay, SCALE, SCALE, *pixels++);
        xDisplay += SCALE;
      }
      yDisplay += SCALE;
    }
    display.endBuffering();
    #else  
    display.drawRGBBitmap((display.width() - CAMERA_WIDTH) / 2, (display.height() - CAMERA_HEIGHT) / 2, pixels, CAMERA_WIDTH, CAMERA_HEIGHT);
    #endif

    cam.releaseFrame(fb);

    display_time_sum += emDisplay;
    display_time_count++;
    if (display_time_count == 128) {
      Serial.print("Avg display Time: ");
      Serial.print(display_time_sum / display_time_count);
      Serial.print(" fps:");
      Serial.println(128000000.0 / float(display_time_sum), 2);
      display_time_sum = 0;
      display_time_count = 0;
    }

  } else {

    digitalWrite(LED_BUILTIN, digitalRead(LED_BUILTIN)? LOW : HIGH);
  }
  delay(1);
}

[CharlesDias]

Hi @mjs513,

My suggestion is to start testing with the capture sample application (likely you will need a .conf and .overlay files for your board), since it has already been validated on many boards and sensors. Once your setup works with this application, it will be better to test other code.

I've been running the capture on mini_stm32h743 with weact_ov2640_cam_module for more than 17 minutes without any problem. As seen, the message video_stm32_dcmi: HAL_DCMI_FrameEventCallback: Failed to get buffer from fifo is printed to indicate that a frame was dropped, but this does not interrupt the code execution.

I also tested on stm32h7b3i_dk with st_b_cams_omv_mb1683 for more than 20 minutes without any problem. Since the display communication is better, no video frames are missed.

[josuah]

cc @zacck who might be interested in seeing this part:

Running the OV7670 at 12 mhz it runs for quite a bit (~5mins) at 320x240 and then I see several

[zacck]

Sorry, I'm late to the party, @mjs513 so are you getting frames with the 0v7670? I cant quite make it out if you are getting frames then it fails or you wait for long then it fails. Thank you.

[mjs513]

Running the OV2640 at 24 mhz at 320x240 with no errors for about 20 minutes so going to move on to different camera.

Ran the OV5640 at 12Mhz at 320x240 still shows the same type images as before whether I do a byte swap or not so something else going on. Then after a dozen or so frames will get

<wrn> video_stm32_dcmi: HAL_DCMI_ErrorCallback

[mjs513]

Hi @CharlesDias

@KurtE has been primarily testing with the Capture app while I have been using the Arduino IDE.

Seems like the different cameras are behaving differently between zephy app and the IDE. For instance, @KurtE got good results with the 5640 on a ILI9341 display while I am having image issues through the ArduinoCore could be that sdram is too slow.

Funny you should mention that you were testing with the OV2640 - just posted above that I ran that camera for about 20 minutes with no issues but having varying issues with different cameras.

EDIT: FOrgot to mention the current version of zephyr is at 4.1 so probably doesn't have all the latest changes to video api

[CharlesDias]

Hi @mjs513,

The st_b_cams_omv_mb1683 shield is an OV5640. So, I've tested the OV2640 and OV5640 without any problem.

Since you were able to run the capture sample successfully, one step would be dump the OV5640 register values and compare them to ArduinoCore.

[KurtE]

@mjs513 @CharlesDias - As mentioned I am currently hacking it on using Zephyr direct, currently outputting to an ILI9341 display....

My zephyr app, has the ability print out at least some of the registers... I took this code from our version of the code that runs
on a Teensy... (teensy_camera) that is in @mjs513 github...

*** Camera Registers ***
	0x3008: 2(2)	//SYSTEM_CTROL0
	0x302C: 2(2)	//DRIVE_CAPABILITY
	0x303A: 0(0)	//SC_PLLS_CTRL0
	0x303B: 25(19)	//SC_PLLS_CTRL1
	0x303C: 17(11)	//SC_PLLS_CTRL2
	0x303D: 48(30)	//SC_PLLS_CTRL3
	0x3503: 0(0)	//AEC_PK_MANUAL
	0x3800: 0(0)	//X_ADDR_ST_H
	0x3801: 8(8)	//X_ADDR_ST_L
	0x3802: 0(0)	//Y_ADDR_ST_H
	0x3803: 2(2)	//Y_ADDR_ST_L
	0x3804: 10(a)	//X_ADDR_END_H
	0x3805: 55(37)	//X_ADDR_END_L
	0x3806: 7(7)	//Y_ADDR_END_H
	0x3807: 161(a1)	//Y_ADDR_END_L
	0x3808: 1(1)	//X_OUTPUT_SIZE_H
	0x3809: 64(40)	//X_OUTPUT_SIZE_L
	0x380A: 0(0)	//Y_OUTPUT_SIZE_H
	0x380B: 240(f0)	//Y_OUTPUT_SIZE_L
	0x380C: 6(6)	//X_TOTAL_SIZE_H
	0x380D: 20(14)	//X_TOTAL_SIZE_L
	0x380E: 3(3)	//Y_TOTAL_SIZE_H
	0x380F: 232(e8)	//Y_TOTAL_SIZE_L
	0x3810: 0(0)	//X_OFFSET_H
	0x3811: 4(4)	//X_OFFSET_L
	0x3812: 0(0)	//Y_OFFSET_H
	0x3813: 2(2)	//Y_OFFSET_L
	0x3814: 49(31)	//X_INCREMENT
	0x3815: 49(31)	//Y_INCREMENT
	0x3820: 71(47)	//TIMING_TC_REG20
	0x3821: 1(1)	//TIMING_TC_REG21
	0x3824: 2(2)	//PCLK_RATIO
	0x4201: 0(0)	//FRAME_CTRL01
	0x4202: 0(0)	//FRAME_CTRL02
	0x4300: 111(6f)	//FORMAT_CTRL00
	0x4740: 33(21)	//CLOCK_POL_CONTROL
	0x5001: 163(a3)	//ISP_CONTROL_01
	0x501F: 1(1)	//FORMAT_CTRL
	0x503D: 0(0)	//PRE_ISP_TEST_SETTING_1
	0x5601: 0(0)	//SCALE_CTRL_1
	0x5602: 2(2)	//SCALE_CTRL_2
	0x5603: 0(0)	//SCALE_CTRL_3
	0x5604: 2(2)	//SCALE_CTRL_4
	0x5605: 0(0)	//SCALE_CTRL_5
	0x5606: 0(0)	//SCALE_CTRL_6
	0x5680: 0(0)	//X_START_H
	0x5681: 0(0)	//X_START_L
	0x5682: 0(0)	//Y_START_H
	0x5683: 0(0)	//Y_START_L
	0x5684: 16(10)	//X_WINDOW_H
	0x5685: 160(a0)	//X_WINDOW_L
	0x5686: 12(c)	//Y_WINDOW_H
	0x5687: 120(78)	//Y_WINDOW_L
	0x460C: 34(22)	//VFIFO_CTRL0C
	0x4602: 1(1)	//VFIFO_X_SIZE_H
	0x4603: 64(40)	//VFIFO_X_SIZE_L
	0x4604: 0(0)	//VFIFO_Y_SIZE_H
	0x4605: 240(f0)	//VFIFO_Y_SIZE_L
	0x4400: 129(81)	//COMPRESSION_CTRL00
	0x4401: 1(1)	//COMPRESSION_CTRL01
	0x4402: 16(10)	//COMPRESSION_CTRL02
	0x4403: 51(33)	//COMPRESSION_CTRL03
	0x4404: 36(24)	//COMPRESSION_CTRL04
	0x4405: 64(40)	//COMPRESSION_CTRL05
	0x4406: 64(40)	//COMPRESSION_CTRL06
	0x4407: 4(4)	//COMPRESSION_CTRL07
	0x4408: 0(0)	//COMPRESSION_ISI_CTRL
	0x4409: 0(0)	//COMPRESSION_CTRL09
	0x440A: 78(4e)	//COMPRESSION_CTRL0a
	0x440B: 22(16)	//COMPRESSION_CTRL0b
	0x440C: 0(0)	//COMPRESSION_CTRL0c
	0x440D: 10(a)	//COMPRESSION_CTRL0d
	0x440E: 9(9)	//COMPRESSION_CTRL0E

Note: yesterday had runs on OV5640, that maybe made it through
about 160+ frames before it dies with the error callback...
[00:00:25.651,000] <wrn> video_stm32_dcmi: HAL_DCMI_ErrorCallback
As mentioned in other places, I could avoid this in my app, where I hack up the first buffer that the camera holds on to
to not be in SDRAM, but in processor memory.

My not so good zephyr code is up at: https://github.com/KurtE/zephyr_test_sketches. Still learning, like how do I
define what the DC and Reset pins are on a compatible = "vnd,spi-device";
device, not great what I am doing but...

Will play more later.

[KurtE]

Quick note: I was hacking on one of my other sketch/app in my zephyer_test_sketches: camera_to_ili9341, which I hacked up to allow
me to output to either an ILI9341 or ST77XX in my case ST7796 display... This sketch is setup currently for the GC2145 camera.
Configured for 12mhz. If I run it normal where the camera buffer is in SDRAM, it dies typically within maybe 10-30 frames.
However if I define it to use a hack that puts the camera buffer in processor memory. It runs for a long time
Currently in this run I am at 3700 frames. So I am pretty sure it is SDRAM issue of being on the edge of if it works fast enough or not...

Next test is I have a hacked up version of: video_stm32_dcmi.c and gc2145.c get_selection and set_selection, that I want to test to
see if I can get it to output 480x320....

[mjs513]

@KurtE - @CharlesDias - @josuah

spent the last few days hacking up @KurtE's app to display frames on the ILI9341 in zephyr to run under the arduino ide / core. Results were the same for the OV5640 and indicated before when using SDRAM - however it doesn't seem that the arduino have enough memory to run a separate framebuffer in memory - get need another 160k on the giga.

So I then spent the day to hack up the video_capture example in zephyr to run under arduino core/ide. I also added a couple features to use memory other than SDRAM and to reverse bytes. If interested I am attaching it:

zephyr_capture_app-250716a.zip

I started with the GC2145 and managed to actually get 1 good frame before getting the callback error:

Capture started
Got frame 0! size: 153600; timestamp 8629 ms
[00:00:08.682,000] <wrn> video_stm32_dcmi: HAL_DCMI_ErrorCallback

Using the OV5640 at 320x240

1. Using revers bytes I am still getting corrupted frames but will get a dozen or more before getting the call back error

Got frame 44! size: 153600; timestamp 12193 ms
Got frame 45! size: 153600; timestamp 12306 ms
[00:00:12.490,000] <wrn> video_stm32_dcmi: HAL_DCMI_ErrorCallback
Got frame 46! size: 153600; timestamp 12423 ms
Got frame 47! size: 153600; timestamp 12457 ms

2. without reverse bytes: still corrputed images

Capture started
Got frame 0! size: 153600; timestamp 7663 ms
Got frame 1! size: 153600; timestamp 7776 ms
Got frame 2! size: 153600; timestamp 7889 ms
Got frame 3! size: 153600; timestamp 8002 ms
[00:00:08.187,000] <wrn> video_stm32_dcmi: HAL_DCMI_ErrorCallback
Got frame 4! size: 153600; timestamp 8120 ms
Got frame 5! size: 153600; timestamp 8153 ms

3. If I used a fixed buffer at 160x120 so it would fix in memory and I am still getting corruted frames but its still running after 1k frames with no callback error. Same for whether I reverse the bytes or not. @KurtE might be worth it if you can give it a try under zephyr if you get a chance after the dma test.

[josuah]

So it seems like the buffer size is not the only issue.

To give a bit of context, the GC2145 driver was developed for the Arduino Nicla Vision which has very short path between the sensor and the STM32H747, so that makes a good path for the signals.

On the Arduino Giga R1 or Portenta H7, that is a lot longer path, so maybe the DVP signal frequencies need to be tuned down a bit.

[mjs513]

@josuah - @KurtE
Finally got back to the camera stuff after playing around with getting DMA working. Out of curiosity decided to change the default regs for the GC2145 to the ones we use for our Teensy_camera libray which I believe @KurtE mentioned a few times also changed xclk to 10mhz and it seems to be working like a charm right now its ups to

Got frame 4941! size: 153600; timestamp 1029358 ms
Got frame 4942! size: 153600; timestamp 1029564 ms
Got frame 4943! size: 153600; timestamp 1029771 ms

and still going strong - not sure what the differences are yet. And since I dont have a Nicala Vision cant try it. But for now here is what I am using:
gc2145.zip

UPDATE: just tried the changes with the arduino camera library and our arduino gfx display library and that is working as well!

[mjs513]

Just a quick update - just tried it on the H7 and doesn't seem to be workings. Back to not getting any frames using @KurtE's that sends images to the 7796. Grabframe keeps returning false. Well it was too good to expect it work on the h7

[KurtE]

To give a bit of context, the GC2145 driver was developed for the Arduino Nicla Vision which has very short path between the sensor and the STM32H747, so that makes a good path for the signals.

That is probably somewhat true. But I think the biggest difference is in that AFAIK the Nikla Vision has no SDRAM, So you are not dealing with that. When I hacked up the code to have the camera always talking to standard processor memory, it run well... (most of the time)

[CharlesDias]

Hi @mjs513 and @KurtE ,

Great to know!

If you have time, could you set up an SDRAM stress test that doesn't involve a camera sensor or display? The goal is to verify whether it uses DMA to continuously read and write a 153,600-byte block (which represents 320 × 240 pixels at 2 bytes per pixel) and logs the number of cycles or transfers before an error occurs.

[KurtE]

Will try, when I get a chance. Not sure what all that will take.
My gut is that we probably need to setup a couple of buffers in SDRAM,
Have an operation that sets a buffer to some known contents, have it then use DMA to copy it to another location,
And when that completes, have the completion code do something with it and have something in the main loop also
accessing the SDRAM...
Not sure for example how hard it is to setup different types of DMA operations. For example straight memory to memory...
like wise maybe memory to memory that is clocked off of some timer...

[KurtE]

@CharlesDias and all, So far I am not having a lot of luck building a sample/simple sketch/app that copies memory to memory using DMA on the Portenta H7. Note: This is with the M7 processor.

Does anyone have a simple DMA memory to memory test app? I looked at a few examples like one for ESP32 I found up on github.
But my attempts to emulate it so far has not worked for me. Some simply crash and others don't appear to actually copy the
memory.

I have tried many different variations of ones that have code like:

void dma_callback(const struct device *dma_dev, void *arg, uint32_t channel, int status)
{
    if (status == 0) {
//        LOG_INF("DMA transfer complete on channel %d", channel);
    } else {
        LOG_ERR("DMA transfer failed with status %d on channel %d", status, channel);
    }
    dma_completed = true;
}


int configure_dma_transfer(const struct device *dma_dev, uint8_t *src, uint8_t *dest, size_t size, uint8_t channel)
{
	struct dma_config dma_cfg = {0};
	struct dma_block_config block_cfg = {0};
	//static bool fConfigured = false;
	static bool first_time = true;
	if (first_time) {
		first_time = false;
		printk("configure_dma_transfer(%p, %p, %p, %u %u)\n", dma_dev, src, dest, size, channel);
	}
	int ret = 0;
	//if (!fConfigured) {

		block_cfg.source_address = (uint32_t)src;
		block_cfg.dest_address = (uint32_t)dest;
		block_cfg.block_size = size;

		LOG_DBG("source: 0x%x, dest: 0x%x", block_cfg.source_address, block_cfg.dest_address);

		dma_cfg.channel_direction = MEMORY_TO_MEMORY;
		dma_cfg.source_burst_length = 1;  // Assuming 4 bytes per burst
		dma_cfg.dest_burst_length = 1;
		dma_cfg.source_data_size = 1;  // 4 bytes (32 bits)
		dma_cfg.dest_data_size = 1;
		dma_cfg.block_count = 1;
		dma_cfg.head_block = &block_cfg;
		dma_cfg.dma_callback = dma_callback;
		dma_cfg.

	//	LOG_INF("Configuring DMA...");

		ret = dma_config(dma_dev, channel, &dma_cfg);
		if (ret != 0) {
			LOG_ERR("DMA configuration failed with error %d\n", ret);
			return ret;
		}
		//fConfigured = true;
	//}
//	LOG_INF("DMA configured");

    dma_completed = false;
	ret = dma_start(dma_dev, channel);
	if (ret != 0) {
		LOG_ERR("Failed to start DMA transfer with error %d\n", ret);
	}

//	LOG_INF("DMA started");

	return ret;
}

I have tried with different sizes and burst sizes, etc.

@mjs513 found some sketches as well, like:

#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/drivers/dma.h>
#include <zephyr/sys/printk.h>

#define DMA_DEVICE_NAME DT_LABEL(DT_NODELABEL(dma1)) // Adjust based on your STM32 device tree
#define DMA_CHANNEL 1                               // DMA channel to use
#define DMA_SLOT 0                                  // DMA slot (specific to your hardware)

#define BUFFER_SIZE 16

static const uint32_t src_buffer[BUFFER_SIZE] = {
    0xDEADBEEF, 0xCAFEBABE, 0x12345678, 0x87654321,
    0x0BADF00D, 0xFEEDFACE, 0xABCDEF01, 0x10FEDCBA,
    0x11223344, 0x55667788, 0x99AABBCC, 0xDDEEFF00,
    0x13579BDF, 0x2468ACE0, 0xFACEB00C, 0xC0FFEE00
};

static uint32_t dest_buffer[BUFFER_SIZE] = {0};

static struct dma_config dma_cfg;
static struct dma_block_config dma_block_cfg;

void main(void)
{
    const struct device *dma_dev;
    int ret;

    printk("Starting DMA Memory-to-Memory Transfer Example\n");

    // Get the DMA device
    dma_dev = device_get_binding(DMA_DEVICE_NAME);
    if (!dma_dev) {
        printk("Error: Unable to find DMA device %s\n", DMA_DEVICE_NAME);
        return;
    }

    // Configure the DMA block
    dma_block_cfg.source_address = (uint32_t)src_buffer;
    dma_block_cfg.dest_address = (uint32_t)dest_buffer;
    dma_block_cfg.block_size = sizeof(src_buffer);
    dma_block_cfg.source_addr_adj = DMA_ADDR_ADJ_INCREMENT;
    dma_block_cfg.dest_addr_adj = DMA_ADDR_ADJ_INCREMENT;

    // Configure the DMA transfer
    dma_cfg.channel_direction = MEMORY_TO_MEMORY;
    dma_cfg.source_data_size = 4; // 4 bytes (32-bit)
    dma_cfg.dest_data_size = 4;   // 4 bytes (32-bit)
    dma_cfg.block_count = 1;
    dma_cfg.head_block = &dma_block_cfg;

    // Start the DMA transfer
    ret = dma_config(dma_dev, DMA_CHANNEL, &dma_cfg);
    if (ret != 0) {
        printk("Error: DMA configuration failed (%d)\n", ret);
        return;
    }

    ret = dma_start(dma_dev, DMA_CHANNEL);
    if (ret != 0) {
        printk("Error: DMA start failed (%d)\n", ret);
        return;
    }

    printk("DMA transfer started. Waiting for completion...\n");

    // Wait for the transfer to complete (polling or interrupt-based)
    k_sleep(K_MSEC(100)); // Adjust based on your transfer size and speed

    printk("DMA transfer completed. Verifying data...\n");

    // Verify the data
    for (int i = 0; i < BUFFER_SIZE; i++) {
        if (src_buffer[i] != dest_buffer[i]) {
            printk("Error: Data mismatch at index %d (src: 0x%08X, dest: 0x%08X)\n",
                   i, src_buffer[i], dest_buffer[i]);
            return;
        }
    }

    printk("DMA transfer successful! Data verified.\n");
}

Which I had to make a few edits, like int main() instead of void main()...
But this one crashed the processor.

Looking around at different DMA examples on the STM32H77... I see the camera driver: video_stm32_dcmi.c
But with this I noticed that they appear to do a lot of the work within HAL DMA code:

static int stm32_dma_init(const struct device *dev)
{
	struct video_stm32_dcmi_data *data = dev->data;
	const struct video_stm32_dcmi_config *config = dev->config;
	int ret;

	/* Check if the DMA device is ready */
	if (!device_is_ready(config->dma.dma_dev)) {
		LOG_ERR("%s DMA device not ready", config->dma.dma_dev->name);
		return -ENODEV;
	}

	/*
	 * DMA configuration
	 * Due to use of DMA HAL API in current driver,
	 * both HAL and Zephyr DMA drivers should be configured.
	 * The required configuration for Zephyr DMA driver should only provide
	 * the minimum information to inform the DMA slot will be in used and
	 * how to route callbacks.
	 */
	struct dma_config dma_cfg = config->dma.cfg;
	static DMA_HandleTypeDef hdma;

	/* Proceed to the minimum Zephyr DMA driver init */
	dma_cfg.user_data = &hdma;
	/* HACK: This field is used to inform driver that it is overridden */
	dma_cfg.linked_channel = STM32_DMA_HAL_OVERRIDE;
	/* Because of the STREAM OFFSET, the DMA channel given here is from 1 - 8 */
	ret = dma_config(config->dma.dma_dev,
			config->dma.channel + STM32_DMA_STREAM_OFFSET, &dma_cfg);
	if (ret != 0) {
		LOG_ERR("Failed to configure DMA channel %d",
			config->dma.channel + STM32_DMA_STREAM_OFFSET);
		return ret;
	}

	/*** Configure the DMA ***/
	/* Set the parameters to be configured */
	hdma.Init.Request		= DMA_REQUEST_DCMI;
	hdma.Init.Direction		= DMA_PERIPH_TO_MEMORY;
	hdma.Init.PeriphInc		= DMA_PINC_DISABLE;
	hdma.Init.MemInc		= DMA_MINC_ENABLE;
	hdma.Init.PeriphDataAlignment	= DMA_PDATAALIGN_WORD;
	hdma.Init.MemDataAlignment	= DMA_MDATAALIGN_WORD;
	hdma.Init.Mode			= DMA_CIRCULAR;
	hdma.Init.Priority		= DMA_PRIORITY_HIGH;
#if defined(CONFIG_SOC_SERIES_STM32F7X) || defined(CONFIG_SOC_SERIES_STM32H7X)
	hdma.Init.FIFOMode		= DMA_FIFOMODE_DISABLE;
#endif

#if defined(CONFIG_SOC_SERIES_STM32F7X) || defined(CONFIG_SOC_SERIES_STM32H7X)
	hdma.Instance = __LL_DMA_GET_STREAM_INSTANCE(config->dma.reg,
						config->dma.channel);
#elif defined(CONFIG_SOC_SERIES_STM32L4X)
	hdma.Instance = __LL_DMA_GET_CHANNEL_INSTANCE(config->dma.reg, config->dma.channel);
#endif

	/* Initialize DMA HAL */
	__HAL_LINKDMA(&data->hdcmi, DMA_Handle, hdma);

	if (HAL_DMA_Init(&hdma) != HAL_OK) {
		LOG_ERR("DCMI DMA Init failed");
		return -EIO;
	}

	return 0;
}

So wondering if this is necessary with these? Suggestions?
Thanks
Kurt

[mjs513]

@KurtE
managed to get a variation of the dma sketch working:

#include <zephyr/kernel.h>
#include <zephyr/drivers/dma.h>
#include <zephyr/device.h>
#include <core_cm7.h>

#define DMA_NODE DT_NODELABEL(dma1)
#define DMA_CHANNEL 1
#define ARRAY_SIZE 128

static const struct device *dma_dev;
__aligned(32) static uint8_t src_array[ARRAY_SIZE];
__aligned(32) static uint8_t dst_array[ARRAY_SIZE];

static void dma_callback(const struct device *dev, void *user_data, uint32_t channel, int status)
{
    printk("DMA completed. Status: %d\n", status);

    if (status == 0) {
        __DSB(); // Data Synchronization Barrier
        SCB_InvalidateDCache_by_Addr((uint32_t *)dst_array, sizeof(dst_array));

        for (int i = 0; i < ARRAY_SIZE; i++) {
            if (src_array[i] != dst_array[i]) {
                printk("Mismatch at index %d, %d, %d\n", i, src_array[i], dst_array[i]);
                printk("         at index %d, %d, %d\n", i+1, src_array[i+1], dst_array[i+1]);
                while(1);
            }
        }
        printk("Transfer verified successfully!\n");
            printk("DEST ARRAY\n");
        for (int i = 0; i < 5; i++) {
            printk("Src/dest: %d, %d\n", src_array[i], dst_array[i]);
        }
    }
}

void setup(void)
{
  delay(2000);

    dma_dev = DEVICE_DT_GET(DMA_NODE);  // nned to ensure dma steam is stopped first, just in case

    dma_stop(dma_dev, DMA_CHANNEL);

    if (!device_is_ready(dma_dev)) {
        printk("DMA device not ready\n");
        while(1){};
    }

    for (int i = 0; i < ARRAY_SIZE; i++) {
        src_array[i] = i;
    }

    struct dma_block_config block_cfg = {
        .source_address = (uint32_t)src_array,
        .dest_address = (uint32_t)dst_array,
        .block_size = sizeof(dst_array),
    };

    struct dma_config dma_cfg = {
        .dma_slot = 0,
        .channel_direction = MEMORY_TO_MEMORY,
        .complete_callback_en = true,
        .source_data_size = 1,
        .dest_data_size = 1,
        .source_burst_length = 1,
        .dest_burst_length = 1,
        .block_count = 1,
        .head_block = &block_cfg,
        .dma_callback = dma_callback,
    };

    int ret = dma_config(dma_dev, DMA_CHANNEL, &dma_cfg);
    if (ret) {
        printk("DMA config error: %d\n", ret);
        return;
    }

    SCB_CleanDCache_by_Addr((uint32_t *)src_array, sizeof(src_array));
    ret = dma_start(dma_dev, DMA_CHANNEL);
    if (ret) {
        printk("DMA start error: %d\n", ret);
    }
/*
    ret = dma_stop(dma_dev, DMA_CHANNEL);
    if (ret) {
        printk("DMA stop error: %d\n", ret);
    }
*/
    printk("DEST ARRAY\n");
    for (int i = 0; i < 2; i++) {
        printk("%d\n", dst_array[i]);
    }

}

void loop() {
  // put your main code here, to run repeatedly:

}

results

DMA completed. Status: 0
Transfer verified successfully!
DEST ARRAY
Src/dest: 0, 0
Src/dest: 1, 1
Src/dest: 2, 2
Src/dest: 3, 3
Src/dest: 4, 4
...

Probably can now use the single transfer?

Had issues until I added the invalidate cache and had to align32 arrays.  Yes I asked copilot.  Have fun modifing.  PS I stopped dma first since the stream was showing busy.  Once I did that then was able to reconfigure.  PRobably because dma1 is used for dcmi in the overlay for the giga.

CHeers

[zacck]

Oh wow , amazing dig @mjs513 , @CharlesDias with the above, do you see any blockers to moving the m7 especially the GIGA to completely zephyr DMA config. @KurtE if you aren't already pushing on this I am willing to work on getting it over the line.

[KurtE]

Thanks again @mjs513,

As we discussed on other channels, that helped a lot in finding some of the last sticking points in the code we have been playing with. It started working for one iteration, but not on subsequent iterations. Although maybe caused by other bugs I had.

Got that working by using the dma_reload, instead of doing another call to dma_config.

So then @mjs513 converted to an Arduino sketch and it hung. I figured it out that we are/were hard coding the test to run on
channel 1. Turns out there is already someone else using Channel 1... (USB I am pretty sure).

Looks like zephyr has an api that maybe helps with that:
int dma_request_channel ( const struct device * dev, void * filter_param );
Not sure what to use for filter_param , so passed NULL. The API returned -22...
Doing a search through the zephyr code I only found a few examples of using this api and it looked like most of them
were specific to some specific boards...

So for now in the sketch I added:

  for (uint8_t channel = 1; channel <= 7; channel++) {
    dma_status dmastat;
    memset(&dmastat, 0, sizeof(dmastat));
    ret = dma_get_status(dma_dev, channel, &dmastat);
    printk("ch:%u stat:%d - %u %u %u %u %u %u %u\n", channel, ret,
           dmastat.busy, dmastat.dir, dmastat.pending_length,
           dmastat.free, dmastat.write_position, dmastat.read_position, dmastat.total_copied);
		if ((tx_dma_channel == 0) && (ret == 0) && (!dmastat.busy)) tx_dma_channel = channel;
  }

Which output:

SDRAM test...
ch:1 stat:0 - 1 0 0 0 0 0 0
ch:2 stat:0 - 0 0 0 0 0 0 0
ch:3 stat:0 - 0 0 0 0 0 0 0
ch:4 stat:0 - 0 0 0 0 0 0 0
ch:5 stat:0 - 0 0 0 0 0 0 0
ch:6 stat:0 - 0 0 0 0 0 0 0
ch:7 stat:0 - 0 0 0 0 0 0 0
DMA Channel allocated 2

Next issue to try: It appears like the DMA operation will only allow you to output 64K per block (or maybe 64K-1), so
need to see if I can chain blocks together to logically transfer a full camera buffer like 320x240x2... (or more)

Back to testing

Edit: Looks like the reload code may not be needed, there was a different bug that that worked around.

[KurtE]

Next issue to try: It appears like the DMA operation will only allow you to output 64K per block (or maybe 64K-1), so
need to see if I can chain blocks together to logically transfer a full camera buffer like 320x240x2... (or more)

Again I could be wrong, but I don't thin the STM32 implementation does not support any of the gather, scatter stuff, nor the
multiple buffers blocks chained to each other. For example I setup a chain of 3 blocks (first two were setup to output
65536-16 bytes each and the third was the left over. And when I started it up it only transferred the stuff in the first
block and then called the callback...

Looking at the STM32 SPI stuff, I did not see anything that looks at the next pointer, nor looks for scatter/gather. Likewise
I don't see anything in the Reference manual mentioning this capability.

First thing I need to check is how the sizes and counts work with each other:
That is currently I have:

		struct dma_config dma_cfg = {
	 		.dma_slot = 0,
	        .channel_direction = MEMORY_TO_MEMORY,
	        .complete_callback_en = true,
	        .source_data_size = 1,
	        .dest_data_size = 1,
	        .source_burst_length = 1,
	        .dest_burst_length = 1,
	        .block_count = block_index,
	        .head_block = &g_block_cfgs[0],
	        .user_data = dest,
	        .dma_callback = dma_callback,
	    };
		//static bool fConfigured = false;
		//if (!fConfigured) {

And each of the dma_block_config objects set a: source pointer, destination pointer and a block_size member.
Question to self to look at again tomorrow, is the block_size in bytes or in source_data_size... size.
So question is, if the camera is 3202402 bytes or 153600, which won't currently fit into one block, but
if the size are 4 = 38400 which would fit.

If this does not work. Then another approach would be to output (or input from camera) the first block, get the
block complete interrupt, where you then try to restart a DMA operation, by updating the Sourc/Dest/Count variables
to try to get the next block... But this can be problematic if for example the ISR is not serviced quick enough before the
camera needs to send the next set of data...

[mjs513]

@KurtE - @josuah

Regarding the GC2145 on the portenta H7 found that I had an error in the overlay for the gc2145 so reran with the same clock and updates to the GC 2145 registers. Also changed to using the ILI9341 spi driver.

With this configuration was able to get up to 100 frames before getting the

<wrn> video_stm32_dcmi: HAL_DCMI_ErrorCallback

and frames stop coming through,

Also once in while on reset I would get:

[00:00:08.461,000] <err> os: ***** BUS FAULT *****
[00:00:08.468,000] <err> os:   Imprecise data bus error
[00:00:08.476,000] <err> os: r0/a1:  0xfc1d9128  r1/a2:  0xc0000083  r2/a3:  0x038f1cd5
[00:00:08.487,000] <err> os: r3/a4:  0xfc1d912a r12/ip:  0x0000210d r14/lr:  0x0807d141
[00:00:08.498,000] <err> os:  xpsr:  0xa100005e
[00:00:08.505,000] <err> os: s[ 0]:  0x240013dc  s[ 1]:  0x0807d141  s[ 2]:  0x48020000  s[ 3]:  0x240013dc
[00:00:08.518,000] <err> os: s[ 4]:  0x00000019  s[ 5]:  0x080600db  s[ 6]:  0x0000004e  s[ 7]:  0x00000000
[00:00:08.531,000] <err> os: s[ 8]:  0x40003800  s[ 9]:  0x0804a853  s[10]:  0x24005340  s[11]:  0xffffffed
[00:00:08.543,000] <err> os: s[12]:  0x1eb7eebf  s[13]:  0xb5a50fa2  s[14]:  0x9b1a08b3  s[15]:  0x951a4cdb
[00:00:08.556,000] <err> os: fpscr:  0x9d2a5b5f
[00:00:08.563,000] <err> os: Faulting instruction address (r15/pc): 0x08083830
[00:00:08.573,000] <err> os: >>> ZEPHYR FATAL ERROR 26: Unknown error on CPU 0
[00:00:08.583,000] <err> os: Fault during interrupt handling

[00:00:08.592,000] <err> os: Current thread: 0x24005340 (main)
[00:00:08.601,000] <err> os: Halting system

EDIT: Since I am using the 9341 I am also using a framebuffer. It seems that if I add a 1mllisecond delay after updating the screen I am not seeing the bus faults and now getting between 100 and 200 frames before the callback error.

[josuah]

Regarding the "bus fault", you can get the line of code back from the address using addr2line. My flag cocktail:

addr2line -afip -e build/zephyr/zephyr.elf 0x08083830

You would need the .elf file that generated the build to access all the debug symbols.

Thank you for running these tests! It seems like different sensors have slightly different behavior but eventually come across this same DMA-related error.

@mjs513 and @KurtE I think you have been doing a lot of investigation on this driver, it could be interesting for Zephyr developers looking into this if you had a git diff output on the Zephyr repository, or even a draft PR showing all the modifications you did in order to improve the behavior.

Or is this all running with unmodified DCMI driver from Zephyr?

[KurtE]

Regarding the "bus fault", you can get the line of code back from the address using addr2line. My flag cocktail:

addr2line -afip -e build/zephyr/zephyr.elf 0x08083830

You would need the .elf file that generated the build to access all the debug symbols.
The one complexity with the Arduino environment, is that often times, the crash might be within Arduino area, and when
you use the addr2line command or look at map files, it ends up being some offset from the start of ltext...

@facchinm and @pillo79 are adding in a way where you can load the ltext using hard linkages instead of jump tables, But so
far they have only added in to Portenta C33 which so far does not support camera, nor DMA...

Thoughts on Cameras:
Will try to summarize soon, what changes we have done so far soon. Right now I am in the process of seeing what state
we are in with updating my Arduino environment to the latest stuff. Mostly running with very little changed within zephyr (yet). Other than maybe some tweaks within some drivers.

On the Camera side: Some things that a few of us have looked at or wonder about:

Changing Camera: - Depending on library/libraries, to change from one camera to another might be as simple as changing an include file, and maybe change which object is defined in your sketch. In ArduinoCore-zephyr/zephyr not sure how one easily changes
from from GC2145 to OV5640 or OV2640... Or change Clock Speed or which pin is used for XCLK...

Example: With Portenta H7 - If I use the Portenta Vision shield It is hard coded to a specific camera (HM01B0 maybe HM0360 later?),
but if instead I use the Mid Carrier board, I can use several different Arducam cameras. Note: I believe the pin numbers for things
like the XLK is different between two carriers. And I have not even looked at the MIPI connection on the MID.

One option, might be to define a generic "Arduino Camera" object, which an Arduino object can register with, the Arduino camera
just puts in the glue...

Continuous vs Snaphot mode: I believe some maybe most of the Camera code on the Arduino may typically run in
Snaphot mode... That is I ask it for an image and it captures and returns one image to me and stops, until I ask it for the
next one.

For me, most of the time I would prefer to run in this mode. Especially with these processors which don't have a lot of fast memory. Continuous mode also eats up processor and data buses.
Theory, most of our data crashing
[00:00:14.776,000] <wrn> video_stm32_dcmi: HAL_DCMI_ErrorCallback
Is caused or more prominent when are running in continuous mode. As we are continuously writing data to the camera buffer, while
at least one other buffer is setup to be used by the client. And we memcpy between the two, and often times switch byte
orders, etc... So this keeps DMA busy, the data bus, etc.

Also side effect of running in continuous mode, requiring two full buffers, is it probably restricts how big of an image we can
capture. For example with the Nicla Vision, it may only have enough memory to read in a 320x240 image, whereas the Camera
can capture 1600x1200 image.

ResolutionWithZoom - With the DCIMP it looks like Zephyr is adding some support to set a viewport. Still need to
play more with this. Trying to add that in through the DCI interface... Hopefully will have reasonable control, where
we can for example with the different cameras set the output to specific sizes, For example to match the size of a display.

Also will play more to see about panning within the zoom... We did some of this in the Teensy camera library.
I have not tried any Camera stuff on a Teensy within Zephyr. So far I don't believe there are any drivers setup for CSI or
FlexIO, although I believe I see some that were setup within the HAL code.

Probably enough for now.

[mjs513]

@josuah - @KurtE

Think I isolated the reg block that gets the GC2145 working properly with the GigaDisplay on the Arduino GIGA R1. Going through the reg settings I eventually added to the current default regs in GC2145.c the change is at the end:

    {GC2145_REG_RESET, GC2145_REG_RESET_P0_REGS},
    //////////////frame rate   50Hz
    {0xfe, 0x00},

    {0xf7, 0x1d},
    {0xf8, 0x84},
    {0xfa, 0x00},

    {0x05, 0x01}, // hb
    {0x06, 0x3b},
    {0x07, 0x01}, // Vb
    {0x08, 0x0b},

    {0xfe, 0x01},
    {0x25, 0x01},
    {0x26, 0x32}, // step
    {0x27, 0x03}, // 8.15fps
    {0x28, 0x96},
    {0x29, 0x03}, // 8.15fps
    {0x2a, 0x96},
    {0x2b, 0x03}, // 8.15fps
    {0x2c, 0x96},
    {0x2d, 0x04}, // 8.15fps
    {0x2e, 0x62},
    {0x3c, 0x00},
    {0xfe, 0x00},
    {0x00, 0x00},
};

with this change I am seeing the following with the giga display for a resolution of 320x240

Avg display Time: 21090 fps:47.41
Avg display Time: 21047 fps:47.51

I am using one of @KurtE sketches that uses our arduino graphic libraries. If i change to scale 2 (upscale programatically in the sketch:

Avg display Time: 50216 fps:19.91
Avg display Time: 50214 fps:19.91

and getting and callback errors

The H7 with the ILI9341 via spi not as much luck. Getting about 50-60 frames before the DCMI callback error.

Note is is based on using 4.2.0-rc3/

[KurtE]

@josuah @mjs513 - Quick note:
I hacked up the ArduinoCore-zephyr camera library: To reallocate the first buffer using malloc:

bool Camera::begin(uint32_t width, uint32_t height, uint32_t pixformat, bool byte_swap) {
    #if DT_HAS_CHOSEN(zephyr_camera)
    this->vdev = DEVICE_DT_GET(DT_CHOSEN(zephyr_camera));
    #endif

    if (!this->vdev || !device_is_ready(this->vdev)) {
        return false;
    }

    switch (pixformat) {
        case CAMERA_RGB565:
            this->byte_swap = byte_swap;
            pixformat = VIDEO_PIX_FMT_RGB565;
            break;
        case CAMERA_GRAYSCALE:
            // There's no support for mono sensors.
            this->yuv_to_gray = true;
            pixformat = VIDEO_PIX_FMT_YUYV;
            break;
        default:
            break;
    }

    // Get capabilities
    struct video_caps caps;
    if (video_get_caps(this->vdev, &caps)) {
        return false;
    }

    for (size_t i=0; caps.format_caps[i].pixelformat != NULL; i++) {
        const struct video_format_cap *fcap = &caps.format_caps[i];
        if (fcap->width_min == width &&
            fcap->height_min == height &&
            fcap->pixelformat == pixformat) {
            break;
        }
        if (caps.format_caps[i+1].pixelformat == NULL) {
            Serial.println("The specified format is not supported");
            return false;
        }
    }

    // Set format.
    static struct video_format fmt = {
        .pixelformat = pixformat,
        .width = width,
        .height = height,
        .pitch = width * 2,
    };

	if (video_set_format(this->vdev, &fmt)) {
        Serial.println("Failed to set video format");
		return false;
	}

	// Allocate video buffers.
	for (size_t i = 0; i < ARRAY_SIZE(this->vbuf); i++) {
		this->vbuf[i] = video_buffer_aligned_alloc(fmt.pitch * fmt.height,
                                                   CONFIG_VIDEO_BUFFER_POOL_ALIGN,
                                                   K_FOREVER);
		if (this->vbuf[i] == NULL) {
            Serial.println("Failed to allocate video buffers");
			return false;
		}
#define TRY_FIXED_CAMERA_BUFFER
#ifdef TRY_FIXED_CAMERA_BUFFER
        if (i == 0) {
            // REAL hack change the buffer over to our fixed buffer...
            uint8_t *pb = (uint8_t*)malloc(fmt.pitch * fmt.height + 15);
            if (pb == nullptr) {
                Serial.println("Failed to allocate fixed video buffers");
            } else {
                // release the SDRAM
                //k_heap_free(&video_buffer_pool,this->vbuf[i]->buffer);
                #define ALIGN_UP(num, align) (((num) + ((align) - 1)) & ~((align) - 1))
                this->vbuf[i]->buffer = (uint8_t*)ALIGN_UP((uint32_t)pb, 32);
            }
        }
#endif
		video_enqueue(this->vdev, this->vbuf[i]);
	}

	// Start video capture
	if (video_stream_start(this->vdev, VIDEO_BUF_TYPE_OUTPUT)) {
        Serial.println("Failed to start capture");
		return false;
	}

    return true;
}

Note: I also turned off video debug in the config file...
Updated the Zephyr_GigaCameraDisplay_GFX sketch now to output at SCALE 2... Still reads 320x240 but the display
code draws it at 640x480

It has been running now for awhile. I think now going on about 5000 frames at about 18 frames per second.

Again reinforces that the issue is the DMA to SDRAM.
At this resolution

[mjs513]

@KurtE
Tried your changes to the camera library using the GIGA and H7 using a 7796 and both are now working with SPI (very slow probably because of that SPI open issue) displays. Getting the same frame rate as you on the giga. On the H7 it is about 5 fps using the GC2145.

Also since I am a glutton for punishment I tried the 5640 on the H7 using the 7796 display and success it working to get multiple frames displayed but framerates are:

Avg display Time: 257503 fps:3.88
Avg display Time: 257279 fps:3.89
Avg display Time: 335214 fps:2.98
Avg display Time: 257287 fps:3.89
Avg display Time: 257382 fps:3.89
Avg display Time: 257468 fps:3.88

So issue is not the cameras but probably as you said the DMA to SDRAM transfer.

[KurtE]

@josuah @mjs513 - and all Doing some hacking to see how possible it is to do snapshots...

So right now working on zephyrproject: My current changes are:

diff --git a/drivers/video/gc2145.c b/drivers/video/gc2145.c
index 28bdcdc1f1c..7cb9f804ebb 100644
--- a/drivers/video/gc2145.c
+++ b/drivers/video/gc2145.c
@@ -706,10 +706,18 @@ static const struct video_reg8 default_regs[] = {
 	{0x46, 0xcf},
 
 	{GC2145_REG_RESET, GC2145_REG_RESET_P0_REGS},
+#if 1
+    {0x05, 0x01}, // hb  from teensy_camera
+    {0x06, 0x3b},
+    {0x07, 0x01}, // Vb
+    {0x08, 0x0b},
+
+#else	
 	{0x05, 0x01},
 	{0x06, 0x1C},
 	{0x07, 0x00},
 	{0x08, 0x32},
+#endif	
 	{0x11, 0x00},
 	{0x12, 0x1D},
 	{0x13, 0x00},
@@ -768,6 +776,7 @@ struct gc2145_ctrls {
 struct gc2145_data {
 	struct gc2145_ctrls ctrls;
 	struct video_format fmt;
+	struct video_rect clip_rect;
 };
 
 #define GC2145_VIDEO_FORMAT_CAP(width, height, format)                                             \
@@ -789,6 +798,12 @@ static const struct video_format_cap fmts[] = {
 	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_QVGA_W, RESOLUTION_QVGA_H, VIDEO_PIX_FMT_RGB565),
 	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_VGA_W, RESOLUTION_VGA_H, VIDEO_PIX_FMT_RGB565),
 	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_UXGA_W, RESOLUTION_UXGA_H, VIDEO_PIX_FMT_RGB565),
+	/* Add some full size possible resolutions */
+	GC2145_VIDEO_FORMAT_CAP(800, 600, VIDEO_PIX_FMT_RGB565),	/* div 2 */
+	GC2145_VIDEO_FORMAT_CAP(533, 400, VIDEO_PIX_FMT_RGB565),	/* div 3 */
+	GC2145_VIDEO_FORMAT_CAP(400, 300, VIDEO_PIX_FMT_RGB565),	/* div 4 */
+	GC2145_VIDEO_FORMAT_CAP(320, 240, VIDEO_PIX_FMT_RGB565),	/* div 5 */
+
 	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_QVGA_W, RESOLUTION_QVGA_H, VIDEO_PIX_FMT_YUYV),
 	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_VGA_W, RESOLUTION_VGA_H, VIDEO_PIX_FMT_YUYV),
 	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_UXGA_W, RESOLUTION_UXGA_H, VIDEO_PIX_FMT_YUYV),
@@ -846,6 +861,8 @@ static int gc2145_set_output_format(const struct device *dev, int output_format)
 static int gc2145_set_resolution(const struct device *dev, uint32_t w, uint32_t h)
 {
 	const struct gc2145_config *cfg = dev->config;
+	struct gc2145_data *drv_data = dev->data;
+	struct video_rect *clip_rect = &drv_data->clip_rect;
 	int ret;
 
 	uint16_t win_w;
@@ -879,11 +896,19 @@ static int gc2145_set_resolution(const struct device *dev, uint32_t w, uint32_t
 	/* Calculates the window boundaries to obtain the desired resolution */
 	win_w = w * c_ratio;
 	win_h = h * r_ratio;
-	x = (((win_w / c_ratio) - w) / 2);
-	y = (((win_h / r_ratio) - h) / 2);
 	win_x = ((UXGA_HSIZE - win_w) / 2);
 	win_y = ((UXGA_VSIZE - win_h) / 2);
 
+	x = (((win_w / c_ratio) - w) / 2);
+	y = (((win_h / r_ratio) - h) / 2);
+	if ((clip_rect->width != 0) && (clip_rect->height != 0) && 
+			(clip_rect->width <= win_w) && (clip_rect->height <= win_h) ) {
+		w = clip_rect->width;
+		h = clip_rect->height;
+		x = (clip_rect->left != (uint32_t)-1)? clip_rect->left : (((win_w / c_ratio) - w) / 2);
+		y = (clip_rect->top != (uint32_t)-1)? clip_rect->top : (((win_h / c_ratio) - h) / 2);
+	}
+
 	ret = video_write_cci_reg(&cfg->i2c, GC2145_REG8(GC2145_REG_RESET),
 				  GC2145_REG_RESET_P0_REGS);
 	if (ret < 0) {
@@ -1171,12 +1196,64 @@ static int gc2145_set_ctrl(const struct device *dev, uint32_t id)
 	}
 }
 
+static int gc2145_set_selection(const struct device *dev, struct video_selection *sel)
+{
+	printk("gc2145_set_selection(%p, %p: %u %u)\n", dev, sel, sel->type, sel->target);
+	if (sel->type != VIDEO_BUF_TYPE_OUTPUT) {
+		return -EINVAL;
+	}
+
+	struct gc2145_data *drv_data = dev->data;
+
+	switch (sel->target) {
+	case VIDEO_SEL_TGT_CROP:
+		drv_data->clip_rect = sel->rect;
+		return gc2145_set_resolution(dev, drv_data->fmt.width, drv_data->fmt.height);
+		break;
+
+	default:
+		return -EINVAL;
+	};
+
+	return 0;
+}
+
+static int gc2145_get_selection(const struct device *dev, struct video_selection *sel)
+{
+	printk("gc2145_get_selection(%p, %p: %u %u)\n", dev, sel, sel->type, sel->target);
+	if (sel->type != VIDEO_BUF_TYPE_OUTPUT) {
+		return -EINVAL;
+	}
+
+	struct gc2145_data *drv_data = dev->data;
+
+	switch (sel->target) {
+	case VIDEO_SEL_TGT_CROP:
+		sel->rect = drv_data->clip_rect;
+		break;
+
+	case VIDEO_SEL_TGT_NATIVE_SIZE:
+		sel->rect.top = 0;
+		sel->rect.left = 0;
+		sel->rect.width = drv_data->fmt.width;
+		sel->rect.height = drv_data->fmt.height;
+		break;
+	default:
+		return -EINVAL;
+	};
+
+	return 0;
+}
+
+
 static DEVICE_API(video, gc2145_driver_api) = {
 	.set_format = gc2145_set_fmt,
 	.get_format = gc2145_get_fmt,
 	.get_caps = gc2145_get_caps,
 	.set_stream = gc2145_set_stream,
 	.set_ctrl = gc2145_set_ctrl,
+	.set_selection = gc2145_set_selection,
+	.get_selection = gc2145_get_selection,
 };
 
 static int gc2145_init_controls(const struct device *dev)
@@ -1272,6 +1349,15 @@ static int gc2145_init(const struct device *dev)
 		return ret;
 	}
 
+	/* initialize clip rectangle */
+	struct gc2145_data *drv_data = dev->data;
+	drv_data->clip_rect.top = 0;
+	drv_data->clip_rect.left = 0;
+	drv_data->clip_rect.width = 0;
+	drv_data->clip_rect.height = 0;
+
+
+
 	ret = gc2145_set_fmt(dev, &fmt);
 	if (ret) {
 		LOG_ERR("Unable to configure default format");
diff --git a/drivers/video/ov5640.c b/drivers/video/ov5640.c
index 664d99b9543..b1ff9324b6e 100644
--- a/drivers/video/ov5640.c
+++ b/drivers/video/ov5640.c
@@ -867,6 +867,7 @@ static int ov5640_set_fmt(const struct device *dev, struct video_format *fmt)
 	drv_data->fmt = *fmt;
 
 	/* Set resolution */
+	printk("Is DVP? %c\n", ov5640_is_dvp(dev)? 'y' :'n');
 	for (i = 0; i < array_size_modes; i++) {
 		if (fmt->width == modes[i].width && fmt->height == modes[i].height) {
 			ret = ov5640_write_multi_regs(&cfg->i2c, modes[i].res_params,
@@ -1324,10 +1325,18 @@ static int ov5640_init_controls(const struct device *dev)
 static int ov5640_init(const struct device *dev)
 {
 	const struct ov5640_config *cfg = dev->config;
-	struct video_format fmt = {0};
+	//struct video_format fmt = {0};
+	// make sure we have a setting.
+	struct video_format fmt = {
+		.pixelformat = VIDEO_PIX_FMT_RGB565,
+		.width = 320,
+		.height = 240,
+	};
+
 	uint16_t chip_id;
 	int ret;
 
+	LOG_INF("ov5640_init called");
 	if (!device_is_ready(cfg->i2c.bus)) {
 		LOG_ERR("Bus device is not ready");
 		return -ENODEV;
@@ -1370,7 +1379,7 @@ static int ov5640_init(const struct device *dev)
 
 #if DT_ANY_INST_HAS_PROP_STATUS_OKAY(powerdown_gpios)
 	if (cfg->powerdown_gpio.port != NULL) {
-		gpio_pin_set_dt(&cfg->powerdown_gpio, 0);
+		gpio_pin_set_dt(&cfg->powerdown_gpio, 1);
 	}
 #endif
 
@@ -1449,6 +1458,7 @@ static int ov5640_init(const struct device *dev)
 		fmt.width = 1280;
 		fmt.height = 720;
 	}
+	LOG_INF("Set Default format: %u %u", fmt.width, fmt.height);
 	ret = ov5640_set_fmt(dev, &fmt);
 	if (ret) {
 		LOG_ERR("Unable to configure default format");
@@ -1480,8 +1490,10 @@ static int ov5640_init(const struct device *dev)
 		.i2c = I2C_DT_SPEC_INST_GET(n),                                                    \
 		OV5640_GET_RESET_GPIO(n)							   \
 		OV5640_GET_POWERDOWN_GPIO(n)							   \
-		.bus_type = DT_PROP_OR(DT_CHILD(DT_INST_CHILD(n, port), endpoint), bus_type,       \
-				       VIDEO_BUS_TYPE_CSI2_DPHY),                                  \
+		/*.bus_type = DT_PROP_OR(DT_CHILD(DT_INST_CHILD(n, port), endpoint), bus_type, */       \
+		/*		       VIDEO_BUS_TYPE_CSI2_DPHY), */                                 \
+		.bus_type = DT_PROP_OR(DT_INST_ENDPOINT_BY_ID(n, 0, 0), bus_type,		\
+				       VIDEO_BUS_TYPE_PARALLEL),				\
 	};                                                                                         \
                                                                                                    \
 	DEVICE_DT_INST_DEFINE(n, &ov5640_init, NULL, &ov5640_data_##n, &ov5640_cfg_##n,            \
diff --git a/drivers/video/video_stm32_dcmi.c b/drivers/video/video_stm32_dcmi.c
index 363de09717b..b537ac4dc59 100644
--- a/drivers/video/video_stm32_dcmi.c
+++ b/drivers/video/video_stm32_dcmi.c
@@ -45,6 +45,7 @@ struct video_stm32_dcmi_data {
 	struct k_fifo fifo_in;
 	struct k_fifo fifo_out;
 	struct video_buffer *vbuf;
+	volatile bool snapshot_active;
 };
 
 struct video_stm32_dcmi_config {
@@ -66,8 +67,17 @@ void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi)
 			CONTAINER_OF(hdcmi, struct video_stm32_dcmi_data, hdcmi);
 	struct video_buffer *vbuf;
 
+	if (dev_data->snapshot_active) {
+		dev_data->snapshot_active = false;
+		return;
+	}
 	HAL_DCMI_Suspend(hdcmi);
 
+	if ((dev_data->vbuf == NULL) || (dev_data->vbuf->buffer == NULL)) {
+		LOG_DBG("NULL buffer");
+		return;
+	}
+
 	vbuf = k_fifo_get(&dev_data->fifo_in, K_NO_WAIT);
 
 	if (vbuf == NULL) {
@@ -417,6 +427,58 @@ static int video_stm32_dcmi_get_frmival(const struct device *dev, struct video_f
 	return 0;
 }
 
+static int video_stm32_dcmi_set_selection(const struct device *dev, struct video_selection *sel)
+{
+	const struct video_stm32_dcmi_config *config = dev->config;
+	return video_set_selection(config->sensor_dev, sel);
+}
+
+static int video_stm32_dcmi_get_selection(const struct device *dev, struct video_selection *sel)
+{
+	const struct video_stm32_dcmi_config *config = dev->config;
+	return video_get_selection(config->sensor_dev, sel);
+}
+
+static int video_stm32_dcmi_capture_snapshot(const struct device *dev, void *buffer, size_t buffer_size, k_timeout_t timeout)
+{
+	struct video_stm32_dcmi_data *data = dev->data;
+	const struct video_stm32_dcmi_config *config = dev->config;
+    
+    // Start the Camera Snapshot Capture.
+	data->hdcmi.Instance->CR &= ~(DCMI_CR_FCRC_0 | DCMI_CR_FCRC_1);
+	data->hdcmi.Instance->CR |= STM32_DCMI_GET_CAPTURE_RATE(data->capture_rate);
+
+	data->snapshot_active = true;
+    if (HAL_DCMI_Start_DMA(&data->hdcmi, DCMI_MODE_SNAPSHOT,
+                (uint32_t) buffer, buffer_size / 4) != HAL_OK) {
+		LOG_WRN("Snapshot: HAL_DCMI_Start_DMA FAILED!");
+		return -EIO;
+    }
+
+	video_stream_start(config->sensor_dev, VIDEO_BUF_TYPE_OUTPUT);
+    // Wait until camera frame is ready.
+
+    for (int64_t start_time = k_uptime_get(); data->snapshot_active == true;) {
+        __WFI();
+        if (k_uptime_delta(&start_time) > timeout.ticks) {
+			LOG_DBG("Timeout expired!");
+	        HAL_DCMI_Stop(&data->hdcmi);
+        	return -EIO;
+        }
+    }
+	video_stream_stop(config->sensor_dev, VIDEO_BUF_TYPE_OUTPUT);
+
+    HAL_DCMI_Stop(&data->hdcmi);
+
+    #if defined(__CORTEX_M7)  // only invalidate buffer for Cortex M7
+    // Invalidate buffer after DMA transfer.
+    SCB_InvalidateDCache_by_Addr((uint32_t*) framebuffer, framesize);
+    #endif
+    return 0;
+
+}
+
+
 static DEVICE_API(video, video_stm32_dcmi_driver_api) = {
 	.set_format = video_stm32_dcmi_set_fmt,
 	.get_format = video_stm32_dcmi_get_fmt,
@@ -427,6 +489,9 @@ static DEVICE_API(video, video_stm32_dcmi_driver_api) = {
 	.enum_frmival = video_stm32_dcmi_enum_frmival,
 	.set_frmival = video_stm32_dcmi_set_frmival,
 	.get_frmival = video_stm32_dcmi_get_frmival,
+	.set_selection = video_stm32_dcmi_set_selection,
+	.get_selection = video_stm32_dcmi_get_selection,
+	.capture_snapshot = video_stm32_dcmi_capture_snapshot,
 };
 
 static void video_stm32_dcmi_irq_config_func(const struct device *dev)
diff --git a/include/zephyr/drivers/video.h b/include/zephyr/drivers/video.h
index 0744219a769..7f859005696 100644
--- a/include/zephyr/drivers/video.h
+++ b/include/zephyr/drivers/video.h
@@ -390,6 +390,17 @@ typedef int (*video_api_set_signal_t)(const struct device *dev, struct k_poll_si
  */
 typedef int (*video_api_selection_t)(const struct device *dev, struct video_selection *sel);
 
+/**
+ * @typedef video_api_capture_snapshot_t
+ * @brief start, capture one frame and stop
+ *
+ * @param dev Pointer to the device structure.
+ * @param buffer Buffer to receive the frame.
+ * @param buffer_size size of the buffer in bytes.
+ * @param timeout Timout for frame to be received.
+ */
+typedef int (*video_api_capture_snapshot_t)(const struct device *dev, void *buffer, size_t buffer_size, k_timeout_t timeout);
+
 __subsystem struct video_driver_api {
 	/* mandatory callbacks */
 	video_api_format_t set_format;
@@ -408,6 +419,7 @@ __subsystem struct video_driver_api {
 	video_api_enum_frmival_t enum_frmival;
 	video_api_selection_t set_selection;
 	video_api_selection_t get_selection;
+	video_api_capture_snapshot_t capture_snapshot;
 };
 
 /**
@@ -885,6 +897,30 @@ static inline int video_get_selection(const struct device *dev, struct video_sel
 	return api->get_selection(dev, sel);
 }
 
+
+/**
+ * @brief start, capture one frame and stop
+ *
+ * @param dev Pointer to the device structure.
+ * @param buffer Buffer to receive the frame.
+ * @param buffer_size size of the buffer in bytes.
+ */
+static inline int video_capture_snapshot(const struct device *dev, void *buffer, size_t buffer_size, k_timeout_t timeout) 
+{	
+	const struct video_driver_api *api;
+
+	__ASSERT_NO_MSG(dev != NULL);
+	__ASSERT_NO_MSG(buffer != NULL);
+
+	api = (const struct video_driver_api *)dev->api;
+	if (api->capture_snapshot == NULL) {
+		return -ENOSYS;
+	}
+
+	return api->capture_snapshot(dev, buffer, buffer_size, timeout);
+}
+
+
 /**
  * @brief Allocate aligned video buffer.
  *

I have a hacked up version of my camera_to_ili9341, that is configured to use it and ST7796,''
This is the main.cpp:
main.zip

it appears to be somewhat working:

[josuah]

There are multiple things that could help there, like switching from memcpy() to just swap the buffer, or adjusting the image frame size to the display size... but it looks like with this balance, most/all of the issues are avoided?

This can be some good reference to improve DCMI drivers and add support for video_set_selection() in GC2145.

If you wish to have DCMI changes upstream in Zephyr then feel invited to open pull request for it, so that you do not have to maintain STM32 peripherals on top of Arduino but can use it through the video APIs.

Nice to see all of what you and @mjs513 are doing with the Portenta H7 and other Arduino platforms!

A discussion for how to get all of this exposed to Arduino users is also happening here: arduino/ArduinoCore-zephyr#127 (not exclusively about UVC)

[KurtE]

Thanks @josuah - Currently we are still experimenting with things to get a decent handle on how things work and then some specific
recommendations.

Currently the Camera code in Zephyr works in a different way than the current Arduino MBED way. In particular: Zephyr is geared
around:

	err = HAL_DCMI_Start_DMA(&data->hdcmi, DCMI_MODE_CONTINUOUS,
			(uint32_t)data->vbuf->buffer, data->vbuf->bytesused / 4);

where as MBED uses:

    if (HAL_DCMI_Start_DMA(&hdcmi, DCMI_MODE_SNAPSHOT,
                (uint32_t) framebuffer, framesize / 4) != HAL_OK) {

Both have their advantages and disadvantages. The zephyr setup is good to do a video on boards with lots of fast memory, etc.
The Arduino library was setup (I think) more for lower memory boards. With Giga/Portenta sort of in the middle if you include
the SDRAM. As mentioned many times, have found SDRAM memory to be problematic with multiple access and speed... Not only
with these boards, but for example with some Custom Teensy boards, where users added SDRAM or Teensy 4.1 where you can
add up to 16mb of PSRAM or maybe now 32mb... With some of these boards, we were able to reduce the problem by driving
the memory at a higher speed then what was the default.

Some possible things I believe might help:

a) An API, that allows me to specify the camera buffer. At least with current code with the camera buffer held on to...
something like: camera_set_framebuffer(...buffer, size); Allows me to specify faster memory if that is what I desire...

b) An API (or APIs) that allow me to use it in snapshot mode. The one I added for this test, simply reflects the MBED version that GIGA uses and Portenta uses:
Mbed version:

int Camera::grabFrame(FrameBuffer &fb, uint32_t timeout)
{
    if (this->sensor == NULL
            || this->pixformat == -1
            || this->resolution == -1) {
        return -1;
    }

    uint32_t framesize = frameSize();

    if (fb.isAllocated()) {
        //A buffer has already been allocated
        //Check buffer size
        if (fb.hasFixedSize()) {
            uint32_t fbSize = fb.getBufferSize();
            if (_debug) {
                _debug->print("fbSize: ");
                _debug->println(fbSize);
            }
            if (fbSize < framesize) {
                if (_debug) {
                    _debug->println("The allocated buffer is too small!");
                }
                return -1;
            }
        }
    } else {
        uint8_t *buffer = (uint8_t *) malloc(framesize + FB_ALIGNMENT);
        uint8_t *aligned_buffer = (uint8_t *) ALIGN_PTR((uintptr_t) buffer, FB_ALIGNMENT);
        fb.setBuffer(aligned_buffer);
    }

    uint8_t *framebuffer = fb.getBuffer();

    // Ensure that the framebuffer is aligned.
    if ((uint32_t) framebuffer & (FB_ALIGNMENT - 1)) {
        if (_debug) {
            _debug->println("The framebuffer memory is not aligned!");
        }
        return -1;
    }

    // Start the Camera Snapshot Capture.
    if (HAL_DCMI_Start_DMA(&hdcmi, DCMI_MODE_SNAPSHOT,
                (uint32_t) framebuffer, framesize / 4) != HAL_OK) {
        if (_debug) {
            _debug->println("HAL_DCMI_Start_DMA FAILED!");
        }
    }

    // Wait until camera frame is ready.
    for (uint32_t start = millis(); (hdcmi.Instance->CR & DCMI_CR_CAPTURE);) {
        __WFI();
        if ((millis() - start) > timeout) {
            if (_debug) {
                _debug->println("Timeout expired!");
            }
            HAL_DCMI_Stop(&hdcmi);
            return -1;
        }
    }

    HAL_DCMI_Stop(&hdcmi);

    #if defined(__CORTEX_M7)  // only invalidate buffer for Cortex M7
    // Invalidate buffer after DMA transfer.
    SCB_InvalidateDCache_by_Addr((uint32_t*) framebuffer, framesize);
    #endif
    return 0;
}

The Zephyr code I added: In the video.h added it as API

 * @brief start, capture one frame and stop
 *
 * @param dev Pointer to the device structure.
 * @param buffer Buffer to receive the frame.
 * @param buffer_size size of the buffer in bytes.
 */
static inline int video_capture_snapshot(const struct device *dev, void *buffer, size_t buffer_size, k_timeout_t timeout) 
{	
	const struct video_driver_api *api;

	__ASSERT_NO_MSG(dev != NULL);
	__ASSERT_NO_MSG(buffer != NULL);

	api = (const struct video_driver_api *)dev->api;
	if (api->capture_snapshot == NULL) {
		return -ENOSYS;
	}

	return api->capture_snapshot(dev, buffer, buffer_size, timeout);
}

In the STM32 code I added it more or less the same as the MBED plus some extra calls
for zephyr... Also the callback function detects it and switches a bool to say it completed:

static int video_stm32_dcmi_capture_snapshot(const struct device *dev, void *buffer, size_t buffer_size, k_timeout_t timeout)
{
	struct video_stm32_dcmi_data *data = dev->data;
	const struct video_stm32_dcmi_config *config = dev->config;
    
    // Start the Camera Snapshot Capture.
	data->hdcmi.Instance->CR &= ~(DCMI_CR_FCRC_0 | DCMI_CR_FCRC_1);
	data->hdcmi.Instance->CR |= STM32_DCMI_GET_CAPTURE_RATE(data->capture_rate);

	data->snapshot_active = true;
    if (HAL_DCMI_Start_DMA(&data->hdcmi, DCMI_MODE_SNAPSHOT,
                (uint32_t) buffer, buffer_size / 4) != HAL_OK) {
		LOG_WRN("Snapshot: HAL_DCMI_Start_DMA FAILED!");
		return -EIO;
    }

	video_stream_start(config->sensor_dev, VIDEO_BUF_TYPE_OUTPUT);
    // Wait until camera frame is ready.

    for (int64_t start_time = k_uptime_get(); data->snapshot_active == true;) {
        __WFI();
        if (k_uptime_delta(&start_time) > timeout.ticks) {
			LOG_DBG("Timeout expired!");
	        HAL_DCMI_Stop(&data->hdcmi);
        	return -EIO;
        }
    }
	video_stream_stop(config->sensor_dev, VIDEO_BUF_TYPE_OUTPUT);

    HAL_DCMI_Stop(&data->hdcmi);

    #if defined(__CORTEX_M7)  // only invalidate buffer for Cortex M7
    // Invalidate buffer after DMA transfer.
    SCB_InvalidateDCache_by_Addr((uint32_t*) framebuffer, framesize);
    #endif
    return 0;

}

Note: I do not believe this should be the actual API nor implementation. I can see a few alternatives to this:

1. something similar, except, maybe not all of the code resides in one function: Maybe a start snapshot, wait for snapshot...
2. Maybe a set of modifications, to current API, where can tell it to run in snapshot mode, and stops, If it has multiple frames it could
   stop and the next time you start it, it alternates... ...

c) Frame sizes: -

This can be some good reference to improve DCMI drivers and add support for video_set_selection() in GC2145.

I have some start to this in the current code:
In the video_stm32_dcmi.c I have:

static int video_stm32_dcmi_set_selection(const struct device *dev, struct video_selection *sel)
{
	const struct video_stm32_dcmi_config *config = dev->config;
	return video_set_selection(config->sensor_dev, sel);
}

static int video_stm32_dcmi_get_selection(const struct device *dev, struct video_selection *sel)
{
	const struct video_stm32_dcmi_config *config = dev->config;
	return video_get_selection(config->sensor_dev, sel);
}

Plus the links in the API structure.

In GC2145 I have mostly a stub for these, I started adding a crop:

static int gc2145_set_selection(const struct device *dev, struct video_selection *sel)
{
	printk("gc2145_set_selection(%p, %p: %u %u)\n", dev, sel, sel->type, sel->target);
	if (sel->type != VIDEO_BUF_TYPE_OUTPUT) {
		return -EINVAL;
	}

	struct gc2145_data *drv_data = dev->data;

	switch (sel->target) {
	case VIDEO_SEL_TGT_CROP:
		drv_data->clip_rect = sel->rect;
		return gc2145_set_resolution(dev, drv_data->fmt.width, drv_data->fmt.height);
		break;

	default:
		return -EINVAL;
	};

	return 0;
}

static int gc2145_get_selection(const struct device *dev, struct video_selection *sel)
{
	printk("gc2145_get_selection(%p, %p: %u %u)\n", dev, sel, sel->type, sel->target);
	if (sel->type != VIDEO_BUF_TYPE_OUTPUT) {
		return -EINVAL;
	}

	struct gc2145_data *drv_data = dev->data;

	switch (sel->target) {
	case VIDEO_SEL_TGT_CROP:
		sel->rect = drv_data->clip_rect;
		break;

	case VIDEO_SEL_TGT_NATIVE_SIZE:
		sel->rect.top = 0;
		sel->rect.left = 0;
		sel->rect.width = drv_data->fmt.width;
		sel->rect.height = drv_data->fmt.height;
		break;
	default:
		return -EINVAL;
	};

	return 0;
}

(and the glue in the API structure).

However with this, I still believe we should add some more entries into the table:

static const struct video_format_cap fmts[] = {
	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_QVGA_W, RESOLUTION_QVGA_H, VIDEO_PIX_FMT_RGB565),
	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_VGA_W, RESOLUTION_VGA_H, VIDEO_PIX_FMT_RGB565),
	GC2145_VIDEO_FORMAT_CAP(RESOLUTION_UXGA_W, RESOLUTION_UXGA_H, VIDEO_PIX_FMT_RGB565),
...
	{0},
};

Edited out the YUV ones. But suppose right now I want an 800x600. Which is a natural one for this camera. How do I do
it? Ask for 640x480 knowing that it has ratio 2? And then ask for a viewport of 800 by 600? Or will the code error that
out as viewport can not be bigger than the resolution?

What is the: VIDEO_SEL_TGT_NATIVE_SIZE if I ask for 640x480? Currently I return 640x480, but to me it is a short cut
to setting it to 800x600 with a viewport... So native size maybe should be 800 by 600?

Also unclear to me: if I ask for QVGA(320x240) the gc2145_set_resolution code sets the ratio to 3
yet 1600/320 = 5 and 1200/240 = 5... So why is it using 3? Maybe so it allows the rotation
where 1200/320 = 3?

So wondering how Pan and zoom might work here. That is for 320x240, I might use ratios 1-5...

Sorry I know more questions than suggestions. Need to play more and understand more.

[KurtE]

Sorry yet another update.

I hacked up the sketch mentioned, and added code to set the CONFIG_VIDEO_WIDTH/HEIGHT to 640x480

CONFIG_VIDEO_WIDTH=640
CONFIG_VIDEO_HEIGHT=480

CONFIG_VIDEO_CROP_WIDTH=480
CONFIG_VIDEO_CROP_HEIGHT=320

Added the code setup the buffer... Note: Not enough memory in normal memory for 480x320 so setup SDRAM...
Setup on ST7796 display and it comes up full screen (SLOW)

With this I run into SDRAM errors. But it times out after about 1/4th of a second ...

video_capture_snapshot: -5 3182 2515376
video_capture_snapshot: 0 3183 53572
video_capture_snapshot: 0 3184 110412
video_capture_snapshot: 0 3185 110372
[00:29:03.650,000] <err> dma_stm32_v1: FiFo error.
[00:29:03.657,000] <inf> dma_stm32_v1: tc: 0, ht: 1, te: 0, dme: 0, fe: 1
[00:29:03.666,000] <err> dma_stm32: Unexpected irq happened.
[00:29:03.675,000] <err> video_stm32_dcmi: DMA callback error with channel 0.
video_capture_snapshot: -5 3219 2515351
video_capture_snapshot: 0 3220 53570
video_capture_snapshot: 0 3221 110427
video_capture_snapshot: 0 3222 110374
[00:29:46.512,000] <err> dma_stm32_v1: FiFo error.
[00:29:46.519,000] <inf> dma_stm32_v1: tc: 0, ht: 1, te: 0, dme: 0, fe: 1
[00:29:46.528,000] <err> dma_stm32: Unexpected irq happened.
[00:29:46.537,000] <err> video_stm32_dcmi: DMA callback error with channel 0.
video_capture_snapshot: -5 3296 2515342
video_capture_snapshot: 0 3297 53601
video_capture_snapshot: 0 3298 110430
video_capture_snapshot: 0 3299 110335
[00:38:32.617,000] <err> dma_stm32_v1: FiFo error.
[00:38:32.624,000] <inf> dma_stm32_v1: tc: 0, ht: 1, te: 0, dme: 0, fe: 1
[00:38:32.634,000] <err> dma_stm32: Unexpected irq happened.
[00:38:32.642,000] <err> video_stm32_dcmi: DMA callback error with channel 0.

Current zephyr code up at:
https://github.com/KurtE/zephyr/tree/camera_snapshot

Sketch with this is up at:
https://github.com/KurtE/zephyr_test_sketches/tree/master/camera_to_tft

[mjs513]

Been trying to add in a driver for the OV7675 loosely based on the OV7670 and using the video_common commands. Configuration is based on the Arducam_dvp library used for the Arduino giga. Managed to get everything configured but failing when I try to set registers for rgb format after configuring default registers. My ov7675.c file looks like:

/*
 * Copyright 2024 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#define DT_DRV_COMPAT ovti_ov7675

#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/video.h>
#include <zephyr/drivers/video-controls.h>
#include <zephyr/logging/log.h>

#include "video_common.h"
#include "video_ctrls.h"
#include "video_device.h"

LOG_MODULE_REGISTER(video_ov7675, CONFIG_VIDEO_LOG_LEVEL);

struct ov7675_config {
	struct i2c_dt_spec bus;
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(reset_gpios)
	struct gpio_dt_spec reset;
#endif
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(pwdn_gpios)
	struct gpio_dt_spec pwdn;
#endif
};

struct ov7675_ctrls {
	struct video_ctrl hflip;
	struct video_ctrl vflip;
};

struct ov7675_data {
	struct ov7675_ctrls ctrls;
	struct video_format fmt;
};

/* ov7675 registers */
#ifndef OMV_OV7670_CLKRC
#define OMV_OV7670_CLKRC   (0x00)
#endif

#define GAIN                    0x00 /* AGC - Gain control gain setting     */
#define BLUE                    0x01 /* AWB - Blue channel gain setting     */
#define RED                     0x02 /* AWB - Red channel gain setting      */
#define VREF                    0x03 /* Vertical Frame Control              */
#define COM1                    0x04 /* Common Control 1                    */
#define BAVE                    0x05 /* U/B Average Level                   */
#define GBAVE                   0x06 /* Y/Gb Average Level                  */
#define AECHH                   0x07 /* Exposure Value - AEC MSB 5 bits     */
#define RAVE                    0x08 /* V/R Average Level                   */

#define COM2                    0x09 /* Common Control 2            */
#define COM2_SOFT_SLEEP         0x10 /* Soft sleep mode             */
#define COM2_OUT_DRIVE_1x       0x00 /* Output drive capability 1x  */
#define COM2_OUT_DRIVE_2x       0x01 /* Output drive capability 2x  */
#define COM2_OUT_DRIVE_3x       0x02 /* Output drive capability 3x  */
#define COM2_OUT_DRIVE_4x       0x03 /* Output drive capability 4x  */

#define OV7675_PID              0x0A /* Product ID Number MSB */
#define VER                     0x0B /* Product ID Number LSB */

#define COM3                    0x0C /* Common Control 3                                       */
#define COM3_SWAP_MSB           0x40 /* Output data MSB and LSB swap                           */
#define COM3_TRI_CLOCK          0x20 /* Tri-state option for output clock at power-down period */
#define COM3_TRI_DATA           0x10 /* Tri-state option for output data at power-down period  */
#define COM3_SCALE_EN           0x08 /* Scale enable                                           */
#define COM3_DCW_EN             0x04 /* DCW enable                                             */

#define COM4                    0x0D /* Common Control 4         */
#define COM4_AEC_FULL           0x00 /* AEC evaluate full window */
#define COM4_AEC_1_2            0x10 /* AEC evaluate 1/2 window  */
#define COM4_AEC_1_4            0x20 /* AEC evaluate 1/4 window  */
#define COM4_AEC_2_3            0x30 /* AEC evaluate 2/3 window  */

#define COM5                    0x0E /* Reserved                 */

#define COM6                    0x0F /* Common Control 6                     */
#define COM6_HREF_BLACK_EN      0x80 /* Enable HREF at optical black         */
#define COM6_RESET_TIMING       0x02 /* Reset all timing when format changes */

#define AECH                    0x10 /* AEC[9:2] (see registers AECHH for AEC[15:10] and COM1 for AEC[1:0]) */

#define CLKRC                   0x11 /* Internal Clock              */
#define CLKRC_PRESCALER_BYPASS  0x40 /* Use external clock directly */
#define CLKRC_PRESCALER         0x3F /* Internal clock pre-scaler   */

#define COM7                    0x12 /* Common Control 7         */
#define COM7_RESET              0x80 /* SCCB Register Reset      */
#define COM7_RES_VGA            0x00 /* Resolution VGA           */
#define COM7_RES_CIF            0x20 /* Resolution CIF           */
#define COM7_RES_QVGA           0x10 /* Resolution QVGA          */
#define COM7_RES_QCIF           0x08 /* Resolution QCIF          */
#define COM7_RGB_FMT            0x04 /* Output format RGB        */
#define COM7_CBAR_EN            0x02 /* Color bar selection      */
#define COM7_FMT_RAW            0x01 /* Output format Bayer RAW  */

#define COM8                    0x13 /* Common Control 8                            */
#define COM8_FAST_AEC           0x80 /* Enable fast AGC/AEC algorithm               */
#define COM8_AEC_STEP           0x40 /* AEC - Step size unlimited step size         */
#define COM8_BANDF_EN           0x20 /* Banding filter ON/OFF                       */
#define COM8_AGC_EN             0x04 /* AGC Enable                                  */
#define COM8_AWB_EN             0x02 /* AWB Enable                                  */
#define COM8_AEC_EN             0x01 /* AEC Enable                                  */

#define COM9                    0x14 /* Common Control 9            */
#define COM9_AGC_GAIN_2x        0x00 /* Automatic Gain Ceiling 2x   */
#define COM9_AGC_GAIN_4x        0x10 /* Automatic Gain Ceiling 4x   */
#define COM9_AGC_GAIN_8x        0x20 /* Automatic Gain Ceiling 8x   */
#define COM9_AGC_GAIN_16x       0x30 /* Automatic Gain Ceiling 16x  */
#define COM9_AGC_GAIN_32x       0x40 /* Automatic Gain Ceiling 32x  */
#define COM9_AGC_GAIN_64x       0x50 /* Automatic Gain Ceiling 64x  */
#define COM9_AGC_GAIN_128x      0x60 /* Automatic Gain Ceiling 128x */
#define COM9_SET_AGC(r, x)      ((r&0x8F)|((x&0x07)<<4))

#define COM10                   0x15 /* Common Control 10                                   */
#define COM10_HSYNC_EN          0x40 /* HREF changes to HSYNC                               */
#define COM10_PCLK_FREE         0x00 /* PCLK output option: free running PCLK               */
#define COM10_PCLK_MASK         0x20 /* PCLK output option: masked during horizontal blank  */
#define COM10_PCLK_REV          0x10 /* PCLK reverse                                        */
#define COM10_HREF_REV          0x08 /* HREF reverse                                        */
#define COM10_VSYNC_FALLING     0x00 /* VSYNC changes on falling edge of PCLK               */
#define COM10_VSYNC_RISING      0x04 /* VSYNC changes on rising edge of PCLK                */
#define COM10_VSYNC_NEG         0x02 /* VSYNC negative                                      */
#define COM10_HSYNC_NEG         0x01 /* HSYNC negative                                      */

#define HSTART                  0x17 /* Output Format - Horizontal Frame (HREF column) start high 8-bit */
#define HSTOP                   0x18 /* Output Format - Horizontal Frame (HREF column) end high 8-bit   */
#define VSTART                  0x19 /* Output Format - Vertical Frame (row) start high 8-bit           */
#define VSTOP                   0x1A /* Output Format - Vertical Frame (row) end high 8-bit             */
#define PSHFT                   0x1B /* Data Format - Pixel Delay Select (delays timing of the D[7:0])  */
#define MIDH                    0x1C /* Manufacturer ID Byte - High                                     */
#define MIDL                    0x1D /* Manufacturer ID Byte - Low                                      */

#define MVFP                    0x1E /* Mirror/VFlip Enable */
#define MVFP_MIRROR             0x20 /* Mirror image        */
#define MVFP_VFLIP              0x10 /* VFlip image         */
#define MVFP_BLACK_SUN_EN       0x04 /* Black sun enable    */

#define LAEC                    0x1F /* Reserved */

#define ADCCTR0                 0x20 /* ADC Control                     */
#define ADCCTR0_ADC_RANGE_1X    0x00 /* ADC range adjustment 1x range   */
#define ADCCTR0_ADC_RANGE_1_5X  0x08 /* ADC range adjustment 1.5x range */
#define ADCCTR0_ADC_REF_0_8     0x00 /* ADC reference adjustment 0.8x   */
#define ADCCTR0_ADC_REF_1_0     0x04 /* ADC reference adjustment 1.0x   */
#define ADCCTR0_ADC_REF_1_2     0x07 /* ADC reference adjustment 1.2x   */

#define ADCCTR1                 0x21 /* Reserved */
#define ADCCTR2                 0x22 /* Reserved */
#define ADCCTR3                 0x23 /* Reserved */

#define AEW                     0x24 /* AGC/AEC - Stable Operating Region (Upper Limit)                 */
#define AEB                     0x25 /* AGC/AEC - Stable Operating Region (Lower Limit)                 */
#define VPT                     0x26 /* AGC/AEC Fast Mode Operating Region                              */
#define BBIAS                   0x27 /* B Channel Signal Output Bias (effective only when COM6[3] = 1)  */
#define GBIAS                   0x28 /* Gb Channel Signal Output Bias (effective only when COM6[3] = 1) */
#define EXHCH                   0x2A /* Dummy Pixel Insert MSB                                          */
#define EXHCL                   0x2B /* Dummy Pixel Insert LSB                                          */
#define RBIAS                   0x2C /* R Channel Signal Output Bias (effective only when COM6[3] = 1)  */
#define ADVFL                   0x2D /* LSB of insert dummy lines in vertical direction (1 bit equals 1 line) */
#define ADVFH                   0x2E /* MSB of insert dummy lines in vertical direction                 */
#define YAVE                    0x2F /* Y/G Channel Average Value                                       */

#define HSYST                   0x30 /* HSYNC Rising Edge Delay (low 8 bits)    */
#define HSYEN                   0x31 /* HSYNC Falling Edge Delay (low 8 bits)   */
#define HREF                    0x32 /* HREF Control                            */
#define CHLF                    0x33 /* Array Current Control                   */
#define ARBLM                   0x34 /* Array Reference Control                 */
#define ADC                     0x37 /* ADC Control                             */
#define ACOM                    0x38 /* ADC and Analog Common Mode Control      */
#define OFON                    0x39 /* ADC Offset Control                      */

#define TSLB                    0x3A /* Line Buffer Test Option                         */
#define TSLB_NEGATIVE           0x20 /* Negative image enable                           */
#define TSLB_UV_NORMAL          0x00 /* UV output value normal                          */
#define TSLB_UV_FIXED           0x10 /* UV output value set in registers MANU and MANV  */
#define TSLB_AUTO_WINDOW        0x01 /* automatically sets output window when resolution changes */

#define COM11                   0x3B /* Common Control 11 */
#define COM11_AFR               0x80 /* Auto frame rate control ON/OFF selection (night mode) */
#define COM11_AFR_0             0x00 /* No reduction of frame rate          */
#define COM11_AFR_1_2           0x20 /* Max reduction to 1/2 frame rate     */
#define COM11_AFR_1_4           0x40 /* Max reduction to 1/4 frame rate     */
#define COM11_AFR_1_8           0x60 /* Max reduction to 1/8 frame rate     */
#define COM11_HZAUTO_EN         0x10 /* Enable 50/60 Hz auto detection      */
#define COM11_BANDF_SELECT      0x08 /* Banding filter value selection      */
#define COM11_AEC_BANDF         0x02 /* Enable AEC below banding value      */

#define COM12                   0x3C /* Common Control 12   */
#define COM12_HREF_EN           0x80 /* Always has HREF     */

#define COM13                   0x3D /* Common Control 13 */
#define COM13_GAMMA_EN          0x80 /* Gamma enable */
#define COM13_UVSAT_AUTO        0x40 /* UV saturation level - UV auto adjustment. */
#define COM13_UV_SWAP           0x01 /* UV swap                                   */

#define COM14                   0x3E /* Common Control 14                                   */
#define COM14_DCW_EN            0x10 /* DCW and scaling PCLK                                */
#define COM14_MANUAL_SCALE      0x08 /* Manual scaling enable for pre-defined resolutions   */
#define COM14_PCLK_DIV_1        0x00 /* PCLK divider. Divided by 1                          */
#define COM14_PCLK_DIV_2        0x01 /* PCLK divider. Divided by 2                          */
#define COM14_PCLK_DIV_4        0x02 /* PCLK divider. Divided by 4                          */
#define COM14_PCLK_DIV_8        0x03 /* PCLK divider. Divided by 8                          */
#define COM14_PCLK_DIV_16       0x04 /* PCLK divider. Divided by 16                         */

#define EDGE                    0x3F /* Edge Enhancement Adjustment                         */
#define EDGE_FACTOR_MASK        0x1F /* Edge enhancement factor                             */

#define COM15                   0x40 /* Common Control 15           */
#define COM15_OUT_10_F0         0x00 /* Output data range 10 to F0  */
#define COM15_OUT_01_FE         0x80 /* Output data range 01 to FE  */
#define COM15_OUT_00_FF         0xC0 /* Output data range 00 to FF  */
#define COM15_FMT_RGB_NORMAL    0x00 /* Normal RGB normal output    */
#define COM15_FMT_RGB565        0x10 /* Normal RGB 565 output       */
#define COM15_FMT_RGB555        0x30 /* Normal RGB 555 output       */

#define COM16                   0x41 /* Common Control 16                                   */
#define COM16_EDGE_EN           0x20 /* Enable edge enhancement threshold auto-adjustment   */
#define COM16_DENOISE_EN        0x10 /* De-noise threshold auto-adjustment                  */
#define COM16_AWB_GAIN_EN       0x08 /* AWB gain enable                                     */
#define COM16_COLOR_MTX_EN      0x02 /* Color matrix coefficient double option              */

#define COM17                   0x42 /* Common Control 17        */
#define COM17_AEC_FULL          0x00 /* AEC evaluate full window */
#define COM17_AEC_1_2           0x40 /* AEC evaluate 1/2 window  */
#define COM17_AEC_1_4           0x80 /* AEC evaluate 1/4 window  */
#define COM17_AEC_2_3           0xC0 /* AEC evaluate 2/3 window  */
#define COM17_DSP_CBAR_EN       0x08 /* DSP color bar enable     */

#define AWBC1                   0x43 /* Reserved */
#define AWBC2                   0x44 /* Reserved */
#define AWBC3                   0x45 /* Reserved */
#define AWBC4                   0x46 /* Reserved */
#define AWBC5                   0x47 /* Reserved */
#define AWBC6                   0x48 /* Reserved */

#define REG4B                   0x4B /* REG4B             */
#define REG4B_UV_AVG_EN         0x01 /* UV average enable */

#define DNSTH                   0x4C /* De-noise Threshold*/

#define MTX1                    0x4F /* Matrix Coefficient 1 */
#define MTX2                    0x50 /* Matrix Coefficient 2 */
#define MTX3                    0x51 /* Matrix Coefficient 3 */
#define MTX4                    0x52 /* Matrix Coefficient 4 */
#define MTX5                    0x53 /* Matrix Coefficient 5 */
#define MTX6                    0x54 /* Matrix Coefficient 6 */

#define BRIGHTNESS              0x55 /* Brightness Control  */
#define CONTRAST                0x56 /* Contrast Control    */
#define CONTRAST_CENTER         0x57 /* Contrast Center     */
#define MTXS                    0x58 /* Matrix Coefficient Sign for coefficient 5 to 0*/
#define LCC1                    0x62 /* Lens Correction Option 1 */
#define LCC2                    0x63 /* Lens Correction Option 2 */
#define LCC3                    0x64 /* Lens Correction Option 3 */
#define LCC4                    0x65 /* Lens Correction Option 4 */
#define LCC5                    0x66 /* Lens Correction Control */
#define LCC5_LC_EN              0x01 /* Lens Correction Enable */
#define LCC5_LC_CTRL            0x04 /* Lens correction control select */

#define MANU                    0x67 /* Manual U Value (effective only when register TSLB[4] is high) */
#define MANV                    0x68 /* Manual V Value (effective only when register TSLB[4] is high) */

#define GFIX                    0x69 /* Fix Gain Control            */
#define GGAIN                   0x6A /* G Channel AWB Gain          */

#define DBLV                    0x6B /* PLL control                 */
#define DBLV_PLL_BYPASS         0x00 /* Bypass PLL                  */
#define DBLV_PLL_4x             0x40 /* Input clock 4x              */
#define DBLV_PLL_6x             0x80 /* Input clock 8x              */
#define DBLV_PLL_8x             0xC0 /* Input clock 16x             */
#define DBLV_REG_BYPASS         0x10 /* Bypass internal regulator   */

#define AWBCTR3                 0x6C /* AWB Control 3 */
#define AWBCTR2                 0x6D /* AWB Control 2 */
#define AWBCTR1                 0x6E /* AWB Control 1 */
#define AWBCTR0                 0x6F /* AWB Control 0 */

#define SCALING_XSC             0x70 /* Test Pattern[0] */
#define SCALING_YSC             0x71 /* Test Pattern[1] */
#define SCALING_DCWCTR          0x72 /* DCW control parameter */

#define SCALING_PCLK_DIV        0x73 /* Clock divider control for DSP.*/
#define SCALING_PCLK_DIV_BYPASS 0x08 /* Bypass clock divider for DSP scale control */
#define SCALING_PCLK_DIV_1      0x00 /* Divided by 1     */
#define SCALING_PCLK_DIV_2      0x01 /* Divided by 2     */
#define SCALING_PCLK_DIV_4      0x02 /* Divided by 4     */
#define SCALING_PCLK_DIV_8      0x03 /* Divided by 8     */
#define SCALING_PCLK_DIV_16     0x04 /* Divided by 16    */

#define REG74                   0x74 /* REG74 */
#define REG74_DGAIN_EN          0x10 /* Digital gain control by REG74[1:0] */
#define REG74_DGAIN_BYPASS      0x00 /* Bypass */
#define REG74_DGAIN_1X          0x01 /* 1x */
#define REG74_DGAIN_2X          0x02 /* 2x */
#define REG74_DGAIN_4X          0x03 /* 4x */

#define REG75                   0x75 /* REG75 */
#define REG75_EDGE_LOWER        0x1F /* Edge enhancement lower limit */

#define REG76                   0x76 /* REG76 */
#define REG76_WHITE_PIX_CORR    0x80 /* White pixel correction enable */
#define REG76_BLACK_PIX_CORR    0x40 /* Black pixel correction enable */
#define REG76_EDGE_HIGHER       0x1F /* Edge enhancement higher limit */

#define REG77                   0x77 /* Offset, de-noise range control */

#define SLOP                    0x7A /* Gamma Curve Highest Segment Slope                          */
#define GAM1                    0x7B /* Gamma Curve 1st Segment Input End Point 0x04 Output Value  */
#define GAM2                    0x7C /* Gamma Curve 2nd Segment Input End Point 0x08 Output Value  */
#define GAM3                    0x7D /* Gamma Curve 3rd Segment Input End Point 0x10 Output Value  */
#define GAM4                    0x7E /* Gamma Curve 4th Segment Input End Point 0x20 Output Value  */
#define GAM5                    0x7F /* Gamma Curve 5th Segment Input End Point 0x28 Output Value  */
#define GAM6                    0x80 /* Gamma Curve 6th Segment Input End Point 0x30 Output Value  */
#define GAM7                    0x81 /* Gamma Curve 7th Segment Input End Point 0x38 Output Value  */
#define GAM8                    0x82 /* Gamma Curve 8th Segment Input End Point 0x40 Output Value  */
#define GAM9                    0x83 /* Gamma Curve 9th Segment Input Enpd Point 0x48 Output Value */
#define GAM10                   0x84 /* Gamma Curve 10th Segment Input End Point 0x50 Output Value */
#define GAM11                   0x85 /* Gamma Curve 11th Segment Input End Point 0x60 Output Value */
#define GAM12                   0x86 /* Gamma Curve 12th Segment Input End Point 0x70 Output Value */
#define GAM13                   0x87 /* Gamma Curve 13th Segment Input End Point 0x90 Output Value */
#define GAM14                   0x88 /* Gamma Curve 14th Segment Input End Point 0xB0 Output Value */
#define GAM15                   0x89 /* Gamma Curve 15th Segment Input End Point 0xD0 Output Value */

#define RGB444                  0x8C /* REG444 */
#define RGB444_RGB444_EN        0x02 /* RGB444 enable, effective only when COM15[4] is high */
#define RGB444_RGB444_FMT       0x01 /* RGB444 word format. 0 = xR GB 1 = RG Bx */

#define DM_LNL                  0x92 /* Dummy Line low 8 bits    */
#define DM_LNH                  0x93 /* Dummy Line high 8 bits   */
#define LCC6                    0x94 /* RW Lens Correction Option 6 (effective only when LCC5[2] is high) */
#define LCC7                    0x95 /* RW Lens Correction Option 7 (effective only when LCC5[2] is high) */

#define BD50ST                  0x9D /* Hz Banding Filter Value (effective only when COM8[5] is high and COM11[3] is high) */
#define BD60ST                  0x9E /* Hz Banding Filter Value (effective only when COM8[5] is high and COM11[3] is low)  */
#define HAECC1                  0x9F /* Histogram-based AEC/AGC Control 1 */
#define HAECC2                  0xA0 /* Histogram-based AEC/AGC Control 2 */

#define SCALING_PCLK            0xA2 /* Pixel Clock Delay */
#define SCALING_PCLK_DELAY      0x7F /* Scaling output delay */

#define NT_CTRL                 0xA4 /* Auto frame rate adjustment control */
#define NT_CTRL_AFR_HALF        0x08 /* Reduce frame rate by half */
#define NT_CTRL_AFR_PT_2X       0x00 /* Insert dummy row at 2x gain */
#define NT_CTRL_AFR_PT_4X       0x01 /* Insert dummy row at 4x gain */
#define NT_CTRL_AFR_PT_8X       0x02 /* Insert dummy row at 8x gain */

#define BD50MAX                 0xA5 /* 50Hz Banding Step Limit             */
#define HAECC3                  0xA6 /* Histogram-based AEC/AGC Control 3   */
#define HAECC4                  0xA7 /* Histogram-based AEC/AGC Control 4   */
#define HAECC5                  0xA8 /* Histogram-based AEC/AGC Control 5   */
#define HAECC6                  0xA9 /* Histogram-based AEC/AGC Control 6   */

#define HAECC7                  0xAA /* AEC algorithm selection             */
#define HAECC7_AEC_AVG          0x00 /* Average-based AEC algorithm         */
#define HAECC7_AEC_HIST         0x80 /* Histogram-based AEC algorithm       */

#define BD60MAX                 0xAB /* 60Hz Banding Step Limit */

#define STR_OPT                 0xAC /* Strobe Control */
#define STR_OPT_EN              0x80 /* Strobe Enable */
#define STR_OPT_CTRL            0x40 /* R/G/B gain controlled by STR_R (0xAD) STR_G (0xAE) STR_B (0xAF) for LED output frame */
#define STR_OPT_XENON_1ROW      0x00 /* Xenon mode option 1 row  */
#define STR_OPT_XENON_2ROW      0x10 /* Xenon mode option 2 rows */
#define STR_OPT_XENON_3ROW      0x20 /* Xenon mode option 3 rows */
#define STR_OPT_XENON_4ROW      0x30 /* Xenon mode option 4 rows */
#define STR_OPT_MODE_XENON      0x00 /* Mode select */
#define STR_OPT_MODE_LED1       0x01 /* Mode select */
#define STR_OPT_MODE_LED2       0x02 /* Mode select */

#define STR_R                   0xAD /* R Gain for LED Output Frame */
#define STR_G                   0xAE /* G Gain for LED Output Frame */
#define STR_B                   0xAF /* B Gain for LED Output Frame */

#define ABLC1                   0xB1 /* ABLC Control */
#define ABLC1_EN                0x04 /* Enable ABLC function */

#define THL_ST                  0xB3 /* ABLC Target */

#define AD_CHB                  0xBE /* Blue Channel Black Level Compensation */  
#define AD_CHR                  0xBF /* Red Channel Black Level Compensation */  
#define AD_CHGB                 0xC0 /* Gb Channel Black Level Compensation */  
#define AD_CHGR                 0xC1 /* Gr Channel Black Level Compensation */  
#define SATCTR                  0xC9 /* UV Saturation Control */

/* ov7675 definitions */
#define ov7675_PROD_ID 0x76
#define ov7675_MVFP_HFLIP 0x20
#define ov7675_MVFP_VFLIP 0x10

/* Initialization register structure */
static const struct video_reg8 ov7675_default_regs[] = {
    // OV7670 reference registers
    { CLKRC,            CLKRC_PRESCALER_BYPASS | OMV_OV7670_CLKRC },
    { TSLB,             0x04 },
    { COM7,             0x00 },
    { HSTART,           0x13 },
    { HSTOP,            0x01 },
    { HREF,             0xb6 },
    { VSTART,           0x02 },
    { VSTOP,            0x7a },
    { VREF,             0x0a },

    { COM3,             0x00 },
    { COM14,            0x00 },
    { SCALING_XSC,      0x3a },
    { SCALING_YSC,      0x35 },
    { SCALING_DCWCTR,   0x11 },
    { SCALING_PCLK_DIV, 0xf0 },
    { SCALING_PCLK,     0x02 },
    { COM10,            COM10_VSYNC_NEG},

    /* Gamma curve values */
    { SLOP,             0x20 },
    { GAM1,             0x10 },
    { GAM2,             0x1e },
    { GAM3,             0x35 },
    { GAM4,             0x5a },
    { GAM5,             0x69 },
    { GAM6,             0x76 },
    { GAM7,             0x80 },
    { GAM8,             0x88 },
    { GAM9,             0x8f },
    { GAM10,            0x96 },
    { GAM11,            0xa3 },
    { GAM12,            0xaf },
    { GAM13,            0xc4 },
    { GAM14,            0xd7 },
    { GAM15,            0xe8 },

    /* AGC and AEC parameters */
    { COM8,             COM8_FAST_AEC | COM8_AEC_STEP | COM8_BANDF_EN },
    { GAIN,             0x00 },
    { AECH,             0x00 },
    { COM4,             0x40 },
    { COM9,             0x18 },
    { BD50MAX,          0x05 },
    { BD60MAX,          0x07 },
    { AEW,              0x95 },
    { AEB,              0x33 },
    { VPT,              0xe3 },
    { HAECC1,           0x78 },
    { HAECC2,           0x68 },
    { 0xa1,             0x03 },
    { HAECC3,           0xd8 },
    { HAECC4,           0xd8 },
    { HAECC5,           0xf0 },
    { HAECC6,           0x90 },
    { HAECC7,           0x94 },
    { COM8,             COM8_FAST_AEC | COM8_AEC_STEP | COM8_BANDF_EN | COM8_AGC_EN | COM8_AEC_EN },

    /* Almost all of these are magic "reserved" values.  */
    { COM5,             0x61 },
    { COM6,             0x4b },
    { 0x16,             0x02 },
    { MVFP,             0x07 },
    { 0x21,             0x02 },
    { 0x22,             0x91 },
    { 0x29,             0x07 },
    { 0x33,             0x0b },
    { 0x35,             0x0b },
    { 0x37,             0x1d },
    { 0x38,             0x71 },
    { 0x39,             0x2a },
    { COM12,            0x78 },
    { 0x4d,             0x40 },
    { 0x4e,             0x20 },
    { GFIX,             0x00 },
    { 0x6b,             0x00 }, // PLL Bypass
    { 0x74,             0x10 },
    { 0x8d,             0x4f },
    { 0x8e,             0x00 },
    { 0x8f,             0x00 },
    { 0x90,             0x00 },
    { 0x91,             0x00 },
    { 0x96,             0x00 },
    { 0x9a,             0x00 },
    { 0xb0,             0x84 },
    { 0xb1,             0x0c },
    { 0xb2,             0x0e },
    { 0xb3,             0x82 },
    { 0xb8,             0x0a },
    { 0x43,             0x0a },
    { 0x44,             0xf0 },
    { 0x45,             0x34 },
    { 0x46,             0x58 },
    { 0x47,             0x28 },
    { 0x48,             0x3a },
    { 0x59,             0x88 },
    { 0x5a,             0x88 },
    { 0x5b,             0x44 },
    { 0x5c,             0x67 },
    { 0x5d,             0x49 },
    { 0x5e,             0x0e },
    { 0x6c,             0x0a },
    { 0x6d,             0x55 },
    { 0x6e,             0x11 },
    { 0x6f,             0x9e },
    { 0x6a,             0x40 },
    { BLUE,             0x40 },
    { RED,              0x60 },
    { COM8,             COM8_FAST_AEC | COM8_AEC_STEP | COM8_BANDF_EN | COM8_AGC_EN | COM8_AEC_EN | COM8_AWB_EN },

    /* Matrix coefficients */
    { MTX1,             0x80 },
    { MTX2,             0x80 },
    { MTX3,             0x00 },
    { MTX4,             0x22 },
    { MTX5,             0x5e },
    { MTX6,             0x80 },
    { MTXS,             0x9e },

    { COM16,            COM16_AWB_GAIN_EN },
    { EDGE,             0x00 },
    { 0x75,             0x05 },
    { 0x76,             0xe1 },
    { 0x4c,             0x00 },
    { 0x77,             0x01 },
    { COM13,            0xc3 },
    { 0x4b,             0x09 },
    { 0xc9,             0x60 },
    { COM16,            0x38 },
    { 0x56,             0x40 },

    { 0x34,             0x11 },
    { COM11,            COM11_AEC_BANDF | COM11_HZAUTO_EN },
    { 0xa4,             0x88 },
    { 0x96,             0x00 },
    { 0x97,             0x30 },
    { 0x98,             0x20 },
    { 0x99,             0x30 },
    { 0x9a,             0x84 },
    { 0x9b,             0x29 },
    { 0x9c,             0x03 },
    { 0x9d,             0x4c },
    { 0x9e,             0x3f },
    { 0x78,             0x04 },
    { 0x79,             0x01 },
    { 0xc8,             0xf0 },
    { 0x79,             0x0f },
    { 0xc8,             0x00 },
    { 0x79,             0x10 },
    { 0xc8,             0x7e },
    { 0x79,             0x0a },
    { 0xc8,             0x80 },
    { 0x79,             0x0b },
    { 0xc8,             0x01 },
    { 0x79,             0x0c },
    { 0xc8,             0x0f },
    { 0x79,             0x0d },
    { 0xc8,             0x20 },
    { 0x79,             0x09 },
    { 0xc8,             0x80 },
    { 0x79,             0x02 },
    { 0xc8,             0xc0 },
    { 0x79,             0x03 },
    { 0xc8,             0x40 },
    { 0x79,             0x05 },
    { 0xc8,             0x30 },
    { 0x79,             0x26 },

    { 0xFF,             0xFF },
};

static const struct video_reg8 ov7675_rgb565_regs[] = {
    { COM7,         COM7_RGB_FMT },        /* Selects RGB mode */
    { RGB444,       0x00 },                /* No RGB444 please */
    { COM1,         0x00 },                /* CCIR601 */
    { COM15,        COM15_OUT_00_FF | COM15_FMT_RGB565},
    { COM9,         0x38 },                /* 16x gain ceiling; 0x8 is reserved bit */
    { 0x4f,         0xb3 },                /* "matrix coefficient 1" */
    { 0x50,         0xb3 },                /* "matrix coefficient 2" */
    { 0x51,         0x00 },                /* "matrix Coefficient 3" */
    { 0x52,         0x3d },                /* "matrix coefficient 4" */
    { 0x53,         0xa7 },                /* "matrix coefficient 5" */
    { 0x54,         0xe4 },                /* "matrix coefficient 6" */
    { COM13,        COM13_GAMMA_EN | COM13_UVSAT_AUTO },
    { 0xFF,         0xFF },
};

static const struct video_reg8 ov7675_vga_regs[] = {
    { COM3,         0x00 },
    { COM14,        0x00 },
    { 0x72,         0x11 },     // downsample by 4
    { 0x73,         0xf0 },     // divide by 4
    { HSTART,       0x12 },
    { HSTOP,        0x00 },
    { HREF,         0xb6 },
    { VSTART,       0x02 },
    { VSTOP,        0x7a },
    { VREF,         0x00 },
    { 0xFF,         0xFF },
};

static const struct video_reg8 ov7675_qvga_regs[] = {
    { COM3,         COM3_DCW_EN },
    { COM14,        0x11 },      // Divide by 2
    { 0x72,         0x22 },      // This has no effect on OV7675
    { 0x73,         0xf2 },      // This has no effect on OV7675
    { HSTART,       0x15 },
    { HSTOP,        0x03 },
    { HREF,         0xC0 },
    { VSTART,       0x03 },
    { VSTOP,        0x7B },
    { VREF,         0xF0 },
    { 0xFF,         0xFF },
};

static const struct video_reg8 ov7675_qqvga_regs[] = {
    { COM3,         COM3_DCW_EN },
    { COM14,        0x11 },     // Divide by 2
    { 0x72,         0x22 },     // This has no effect on OV7675
    { 0x73,         0xf2 },     // This has no effect on OV7675
    { HSTART,       0x16 },
    { HSTOP,        0x04 },
    { HREF,         0xa4 },
    { VSTART,       0x22 },
    { VSTOP,        0x7a },
    { VREF,         0xfa },
    { 0xFF,         0xFF },
};


#define ov7675_VIDEO_FORMAT_CAP(width, height, format)                                             \
	{                                                                                          \
		.pixelformat = (format), .width_min = (width), .width_max = (width),               \
		.height_min = (height), .height_max = (height), .width_step = 0, .height_step = 0  \
	}

static const struct video_format_cap fmts[] = {
	ov7675_VIDEO_FORMAT_CAP(160, 240, VIDEO_PIX_FMT_RGB565), /* QQVGA  */
	ov7675_VIDEO_FORMAT_CAP(320, 240, VIDEO_PIX_FMT_RGB565), /* QVGA  */
	ov7675_VIDEO_FORMAT_CAP(640, 480, VIDEO_PIX_FMT_RGB565), /* VGA   */
	{0}};

static int ov7675_get_caps(const struct device *dev, struct video_caps *caps)
{
	caps->format_caps = fmts;
	return 0;
}

static int ov7675_set_fmt(const struct device *dev, struct video_format *fmt)
{
	const struct ov7675_config *config = dev->config;
	int ret;
	uint8_t i = 0U;

	if (fmt->pixelformat != VIDEO_PIX_FMT_RGB565 ) {
		LOG_ERR("Only RGB565 !");
		return -ENOTSUP;
	}

  // Set RGB Format
  ret = video_write_cci_multiregs8(&config->bus, ov7675_rgb565_regs, ARRAY_SIZE(ov7675_rgb565_regs));
	if (ret < 0) {
    printk("Failed to set RGB Registers\n");
		return ret;
	}
  
	/* Set output resolution */
	while (fmts[i].pixelformat) {
		if (fmts[i].width_min == fmt->width && fmts[i].height_min == fmt->height &&
		    fmts[i].pixelformat == fmt->pixelformat) {
			/* Set output format */
      printk("Format selected: %d\n",fmts[i].width_min); 
			switch (fmts[i].width_min) {
			case 160: /* QCIF */
        ret = video_write_cci_multiregs8(&config->bus, ov7675_qqvga_regs, ARRAY_SIZE(ov7675_qqvga_regs));
				break;
			case 320: /* QVGA */
      printk("Format set to qvga\n");
        ret = video_write_cci_multiregs8(&config->bus, ov7675_qvga_regs, ARRAY_SIZE(ov7675_qvga_regs));
				break;
			default: /* VGA */
        ret = video_write_cci_multiregs8(&config->bus, ov7675_vga_regs, ARRAY_SIZE(ov7675_vga_regs));
				break;
			}
			if (ret < 0) {
        printk("Resolution not set\n");
				return ret;
			}
		}
		i++;
	}

	LOG_ERR("Unsupported format");
	return -ENOTSUP;
}

static int ov7675_get_fmt(const struct device *dev, struct video_format *fmt)
{
	struct ov7675_data *data = dev->data;

	memcpy(fmt, &data->fmt, sizeof(data->fmt));
	return 0;
}

static int ov7675_init_controls(const struct device *dev)
{
	int ret;
	struct ov7675_data *drv_data = dev->data;
	struct ov7675_ctrls *ctrls = &drv_data->ctrls;

	ret = video_init_ctrl(&ctrls->hflip, dev, VIDEO_CID_HFLIP,
			      (struct video_ctrl_range){.min = 0, .max = 1, .step = 1, .def = 0});
	if (ret) {
		return ret;
	}

	return video_init_ctrl(&ctrls->vflip, dev, VIDEO_CID_VFLIP,
			       (struct video_ctrl_range){.min = 0, .max = 1, .step = 1, .def = 0});
}

static int ov7675_init(const struct device *dev)
{
	const struct ov7675_config *config = dev->config;
  
	int ret;
	uint32_t pid;
	struct video_format fmt = {
		.pixelformat = VIDEO_PIX_FMT_RGB565,
		.width = 320,
		.height = 240,
	};

	if (!i2c_is_ready_dt(&config->bus)) {
		/* I2C device is not ready, return */
		return -ENODEV;
	}

  printk("I2C bus ready\n");
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(pwdn_gpios)
	/* Power up camera module */
	if (config->pwdn.port != NULL) {
		if (!gpio_is_ready_dt(&config->pwdn)) {
			return -ENODEV;
		}
		ret = gpio_pin_configure_dt(&config->pwdn, GPIO_OUTPUT_INACTIVE);
		if (ret < 0) {
			LOG_ERR("Could not clear power down pin: %d", ret);
			return ret;
		}
	}
#endif
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(reset_gpios)
	/* Reset camera module */
	if (config->reset.port != NULL) {
		if (!gpio_is_ready_dt(&config->reset)) {
			return -ENODEV;
		}
		ret = gpio_pin_configure_dt(&config->reset, GPIO_OUTPUT);
		if (ret < 0) {
			LOG_ERR("Could not set reset pin: %d", ret);
			return ret;
		}
		/* Reset is active low, has 1ms settling time*/
		gpio_pin_set_dt(&config->reset, 0);
		k_msleep(1);
		gpio_pin_set_dt(&config->reset, 1);
		k_msleep(1);
	}
#endif

	/*
	 * Read product ID from camera. This camera implements the SCCB,
	 * spec- which *should* be I2C compatible, but in practice does
	 * not seem to respond when I2C repeated start commands are used.
	 * To work around this, use a write then a read to interface with
	 * registers.
	 */
  printk("Reading Product ID bus..\n" );
	uint8_t cmd = OV7675_PID;

	ret = video_read_cci_reg(&config->bus, cmd, &pid);
	if (ret < 0) {
		LOG_ERR("Could not read product ID: %d", ret);
		return ret;
	}

	if (pid != ov7675_PROD_ID) {
		LOG_ERR("Incorrect product ID: 0x%02X", pid);
		return -ENODEV;
	}

    printk("Resetting camera registers\n");
	/* Reset camera registers */
	ret = video_write_cci_reg(&config->bus, COM7, 0x80);
	if (ret < 0) {
		LOG_ERR("Could not reset camera: %d", ret);
		return ret;
	}
	/* Delay after reset */
	k_msleep(5);

  printk("Writing Intialization registers\n");
	/* Write initialization values to ov7675 */
  ret = video_write_cci_multiregs8(&config->bus, ov7675_default_regs, ARRAY_SIZE(ov7675_default_regs));
  if (ret < 0) {
    return ret;
  }
  
	ret = ov7675_set_fmt(dev, &fmt);
	if (ret < 0) {
		return ret;
	}
  
	/* Initialize controls */
	return ov7675_init_controls(dev);
}

static int ov7675_set_stream(const struct device *dev, bool enable, enum video_buf_type type)
{
	return 0;
}

static int ov7675_set_ctrl(const struct device *dev, uint32_t id)
{
	const struct ov7675_config *config = dev->config;
	struct ov7675_data *drv_data = dev->data;
	struct ov7675_ctrls *ctrls = &drv_data->ctrls;

	switch (id) {
	case VIDEO_CID_HFLIP:
		return i2c_reg_update_byte_dt(&config->bus, MVFP, ov7675_MVFP_HFLIP,
					      ctrls->hflip.val ? ov7675_MVFP_HFLIP : 0);
	case VIDEO_CID_VFLIP:
		return i2c_reg_update_byte_dt(&config->bus, MVFP, ov7675_MVFP_VFLIP,
					      ctrls->vflip.val ? ov7675_MVFP_VFLIP : 0);
	default:
		return -ENOTSUP;
	}
}

static DEVICE_API(video, ov7675_api) = {
	.set_format = ov7675_set_fmt,
	.get_format = ov7675_get_fmt,
	.get_caps = ov7675_get_caps,
	.set_stream = ov7675_set_stream,
	.set_ctrl = ov7675_set_ctrl,
};

#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(reset_gpios)
#define OV7675_RESET_GPIO(inst) .reset = GPIO_DT_SPEC_INST_GET_OR(inst, reset_gpios, {}),
#else
#define OV7675_RESET_GPIO(inst)
#endif

#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(pwdn_gpios)
#define OV7675_PWDN_GPIO(inst) .pwdn = GPIO_DT_SPEC_INST_GET_OR(inst, pwdn_gpios, {}),
#else
#define OV7675_PWDN_GPIO(inst)
#endif

#define OV7675_INIT(inst)                                                                          \
	const struct ov7675_config ov7675_config_##inst = { \
          .bus = I2C_DT_SPEC_INST_GET(inst),      \
					OV7675_RESET_GPIO(inst)                 \
					OV7675_PWDN_GPIO(inst)};        \
	struct ov7675_data ov7675_data_##inst;                                                     \
                                                                                                   \
	DEVICE_DT_INST_DEFINE(inst, ov7675_init, NULL, &ov7675_data_##inst, &ov7675_config_##inst, \
			      POST_KERNEL, CONFIG_VIDEO_INIT_PRIORITY, &ov7675_api);               \
                                                                                                   \
	VIDEO_DEVICE_DEFINE(ov7675_##inst, DEVICE_DT_INST_GET(inst), NULL);

DT_INST_FOREACH_STATUS_OKAY(OV7675_INIT)

with the following error msgs:

[00:00:04.869,000] <err> video_common: failed to write to I2C register
                                       12 04                                            |..
[00:00:04.888,000] <err> video_common: Failed to write to register 0x12
Failed to set RGB Registers

the register and value the err is reffering to is the first first value set in the rgb array:

{ COM7,         COM7_RGB_FMT },

Seems to get through setting the initial values.

Not sure what I am missing. Any help would be appreciated?

EDIT: looks like will have same issue with setting resolution