more debugging with updated fpga code (0d5bd2de) · Commits · Elphel / linux-elphel

src/drivers/elphel/exif393.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -353,7 +353,7 @@ int putlong_meta(int sensor_port, unsigned long data, int * indx, unsigned long
		// Uses struct exif_time that should be updated from the user space (once a day),
		// calculates date/time ignoring leap seconds if not updated in time
		/*
		* 393: Continue to use same static buffers for exif_time
		* 393: Continue to use same static buffers for exif_time - common to all channels
		*/
		char * encode_time(char buf[27], unsigned long sec, unsigned long usec) {
		unsigned long s,d,m,y,y4,lp,h;
		@@ -422,11 +422,11 @@ char * encode_time(char buf[27], unsigned long sec, unsigned long usec) {

		int store_meta(int sensor_port) { //called from IRQ service - put current metadata to meta_buffer, return page index
		if (!aexif_enabled[sensor_port]) return 0;
		int retval=aexif_wp[sensor_port];
		memcpy(&ameta_buffer[sensor_port][aexif_wp[sensor_port] * aexif_meta_size[sensor_port]], ameta_buffer[sensor_port],aexif_meta_size[sensor_port]);
		int meta_index=aexif_wp[sensor_port];
		memcpy(&ameta_buffer[sensor_port][meta_index * aexif_meta_size[sensor_port]], ameta_buffer[sensor_port], aexif_meta_size[sensor_port]);
		aexif_wp[sensor_port]++;
		if (aexif_wp[sensor_port] > MAX_EXIF_FRAMES) aexif_wp[sensor_port] = 1;
		return retval;
		return meta_index;
		}

		//!++++++++++++++++++++++++++++++++++++ open() ++++++++++++++++++++++++++++++++++++++++++++++++++++++

src/drivers/elphel/framepars.c

+60 −28

Original line number	Diff line number	Diff line
		@@ -258,6 +258,8 @@ int framepars_mmap(struct file file, struct vm_area_struct vma);
		*/
		int initSequencers(int sensor_port)
		{
		// x393_rtc_sec_t rtc_sec = {.d32=0};
		sec_usec_t sec_usec;
		FLAGS_IBH
		if (!is_fpga_programmed){
		dev_err(g_devfp_ptr,"* Attempted to access hardware without bitsteram *\n");
		@@ -268,9 +270,12 @@ int initSequencers(int sensor_port)
		dev_info(g_devfp_ptr,"Configuring compressor DMA channels\n");
		init_compressor_dma(0xf, // all channels (TODO: NC393 - select channels in DT or use existing for sesnors?
		0); // not to interfere with python setting the same
		// 1); // reset all channels (do only once, resetting running DMA may confuse AXI)
		// Start RTC by writing 0 to seconds if it was not already set, otherwise preserve current time
		get_fpga_rtc(&sec_usec);
		set_fpga_rtc( sec_usec);
		// Start RTC by writing 0 to seconds
		// set_x393_rtc_sec_set (rtc_sec); // started RTC, correct time may be set later or before
		hardware_initialized = 1;

		}
		dev_dbg(g_devfp_ptr,"port= %d,initSequencers:resetting both sequencers (not really?)\n", sensor_port);
		#ifdef TEST_DISABLE_CODE
		@@ -412,6 +417,14 @@ int initMultiPars(int sensor_port)
		return GLOBALPARS(sensor_port, G_MULTI_NUM);
		}

		/** Reads parameters for the specified frame number, OK to use in compressor ISR using last compressed frame */
		inline unsigned long get_imageParamsFrame(int sensor_port, ///< sensor port (0..3)
		int n, ///< parameter index (should be 128..143)
		int frame) ///< absolute frame number
		{
		return aframepars[sensor_port][frame & PARS_FRAMES_MASK].pars[n];
		}

		/**
		* @brief reads parameters from the current frame (matching hardware index)
		* @param sensor_port sensor port number (0..3)
		@@ -434,7 +447,7 @@ inline unsigned long get_imageParamsPrev(int sensor_port, int n)
		return aframepars[sensor_port][(thisFrameNumber(sensor_port) - 1) & PARS_FRAMES_MASK].pars[n];
		}

		/** Reads past parameters (small subset of all) fro absolute frame number */
		/** Reads past parameters (small subset of all) for absolute frame number */
		inline unsigned long get_imageParamsPast(int sensor_port, ///< sensor port (0..3)
		int n, ///< parameter index (should be 128..143)
		int frame) ///< absolute frame number
		@@ -508,45 +521,54 @@ void updateInterFrame(int sensor_port, ///< Sensor port number (0..3)
		// int index32;
		// unsigned long bmask, bmask32;
		int pastParsIndex;
		// struct framepars_t *framepars = aframepars[sensor_port];
		// u32 compressed_frame; ///< absolute number of compressed frame , matching frame16
		// compressed_frame = (thisFrameNumber(sensor_port) & ~PARS_FRAMES_MASK) \| (frame16 & PARS_FRAMES_MASK);
		// if (compressed_frame > thisFrameNumber(sensor_port)) // compressor frame number can never be higher than sesnor one
		// compressed_frame -= PARS_FRAMES;
		int compressedIndex = compressed_frame & PARS_FRAMES_MASK; // last compressed frame mod 16
		struct framepars_t *framepars = aframepars[sensor_port];

		thisCompressorFrameNumber(sensor_port) = compressed_frame;
		// pastParsIndex = (thisFrameNumber(sensor_port) - 1) & PASTPARS_SAVE_ENTRIES_MASK; // copying from what was past frame that might include histogram data
		pastParsIndex = compressed_frame & PASTPARS_SAVE_ENTRIES_MASK; // copying from what was past frame that might include histogram data
		// memcpy(interframe_pars, &framepars[findex_this].pars[P_GTAB_R], 24); // will leave some gaps, but copy [P_ACTUAL_WIDTH]
		// After Frame sync interrupt processed, oldest valid will be is sensor frame number -2, compressor lag is 1 frame (0..2), so read not past-pars is OK
		#ifdef USE_PASTPARS_IN_CMPRSIRQ
		memcpy(interframe_pars, &apastpars[sensor_port][pastParsIndex].past_pars[P_GTAB_R-PARS_SAVE_FROM], 24); // will leave some gaps, but copy [P_ACTUAL_WIDTH]
		interframe_pars->height = apastpars[sensor_port][pastParsIndex].past_pars[P_ACTUAL_HEIGHT-PARS_SAVE_FROM]; // NOTE: P_ACTUAL_WIDTH,P_QUALITY copied with memcpy
		interframe_pars->color = apastpars[sensor_port][pastParsIndex].past_pars[P_COLOR-PARS_SAVE_FROM];
		interframe_pars->byrshift = apastpars[sensor_port][pastParsIndex].past_pars[P_COMPMOD_BYRSH-PARS_SAVE_FROM];
		interframe_pars->quality2 \|= (apastpars[sensor_port][pastParsIndex].past_pars[P_PORTRAIT-PARS_SAVE_FROM] & 1) << 7;

		#else
		memcpy (interframe_pars, &framepars[compressedIndex].pars[P_GTAB_R], 24); /// will leave some gaps, but copy [P_ACTUAL_WIDTH]
		interframe_pars->height= framepars[compressedIndex].pars[P_ACTUAL_HEIGHT]; /// NOTE: P_ACTUAL_WIDTH,P_QUALITY copied with memcpy
		interframe_pars->color= framepars[compressedIndex].pars[P_COLOR];
		interframe_pars->byrshift=framepars[compressedIndex].pars[P_COMPMOD_BYRSH];
		interframe_pars->quality2 \|= (framepars[compressedIndex].pars[P_PORTRAIT] & 1) << 7;
		#endif


		}

		//++++++++++++++++++++++++++++++++++++++++++
		/** Called from ISR (sensor frame interrupt)- advance thisFrameNumber to match hardware frame16, copy parameters as needed.
		* before: (thisFrameNumber mod8 pointed to current (for the software) parameters frame (now behind by at least 1, maybe 2)
		* (thisFrameNumber-1) mod 8 - oldest with parameters preserved, also containes histograms results (+image timestamp, size?)
		* before: (thisFrameNumber mod 16 pointed to current (for the software) parameters frame (now behind by at least 1, maybe 2)
		* (thisFrameNumber-1) mod 16 - oldest with parameters preserved, also containes histograms results (+image timestamp, size?)
		* subset of that frame data is copied to pastpars
		* (thisFrameNumber-2) mod 8 - farthest in the future frame
		* (thisFrameNumber-2) mod 16- farthest in the future frame
		* after: thisFrameNumber matches hardware pointer
		* @param sensor_port sensor port number (0..3)
		* @param interframe_pars pointer to structure (between frames in the frame buffer) to save a pointer to past parameters
		* pass NULL if compressor was off (or no time to copy?)
		*/

		//TODO: Remove interframe, handle it with compressor interrupts (above)
		void updateFramePars(int sensor_port, int frame16)
		/// Among other things copies subset of parameters to pastpars

		void updateFramePars(int sensor_port, ///< sensor port number (0..3)
		int frame16) ///< Sensor sequencer (hardware) frame number
		{
		int findex_this, findex_prev, findex_future, findex_next;
		int index, index32;
		unsigned long bmask, bmask32;
		int pastParsIndex;
		struct framepars_t *framepars = aframepars[sensor_port];
		#ifdef NC353
		// Old comments from NC353
		// If interrupt was from compression done (circbuf advanced, interframe_pars!=null), the frame16 (hardware) maybe not yet advanced
		// We can fix it here, but it will not work if some frames were not processed in time
		#ifdef NC353
		if ((interframe_pars != NULL) && (((frame16 ^ thisFrameNumber(sensor_port)) & PARS_FRAMES_MASK) == 0)) {
		findex_this = frame16 & PARS_FRAMES_MASK;

		@@ -556,25 +578,35 @@ void updateFramePars(int sensor_port, int frame16)
		}
		#endif
		dev_dbg(g_devfp_ptr,"%s : port= %d, frame16=%d\n",__func__, sensor_port, frame16);
		while ((frame16 ^ thisFrameNumber(sensor_port)) & PARS_FRAMES_MASK) {
		while ((frame16 ^ thisFrameNumber(sensor_port)) & PARS_FRAMES_MASK) { // While hardware pointer is still ahead of the software maintained one
		dev_dbg(g_devfp_ptr,"%s : port= %d, frame16=%d, thisFrameNumber(sensor_port)\n",__func__, sensor_port, frame16, (int)thisFrameNumber(sensor_port));
		// before update:
		// framepars[findex_prev] holds previous frame data (oldest availble)
		// framepars[findex_prev] holds previous frame data (oldest availble - latest?)
		// framepars[findex_future] holds farthest in the future one
		// after update:
		// framepars[findex_prev] holds farthest in the future one ("this" will become "prev")
		findex_this = thisFrameNumber(sensor_port) & PARS_FRAMES_MASK;
		findex_prev = (findex_this - 1) & PARS_FRAMES_MASK;
		findex_future = (findex_this - 2) & PARS_FRAMES_MASK; // farthest in the future
		findex_next = (findex_this + 1) & PARS_FRAMES_MASK;
		findex_this = thisFrameNumber(sensor_port) & PARS_FRAMES_MASK; // Nothing is yet done for this frame (mod 16)
		findex_prev = (findex_this - 1) & PARS_FRAMES_MASK; // Holds previous frame data (mod 16) (latest available)
		findex_future = (findex_this - 2) & PARS_FRAMES_MASK; // farthest in the future (mod 16) (not to overwrite latest
		findex_next = (findex_this + 1) & PARS_FRAMES_MASK; // Just next frame (mod 16) after the current
		// copy subset of the parameters to the long buffer of past parameters. TODO: fill Exif also here?
		// TODO:DONE: Change - make pastpars be save for all frames, not just compressed ones
		// With PASTPARS_SAVE_ENTRIES being multiple of PARS_FRAMES - make it possible to calculate past_index from thisFrameNumber
		// pastParsIndex= thisFrameNumber & PASTPARS_SAVE_ENTRIES_MASK;
		pastParsIndex = (thisFrameNumber(sensor_port) - 1) & PASTPARS_SAVE_ENTRIES_MASK; // copying from what was past frame that might include histogram data
		// memcpy (pastpars[pastParsIndex].past_pars, &framepars[findex_prev].pars[PARS_SAVE_FROM], sizeof(pastpars[0].past_pars));
		memcpy(apastpars[sensor_port][pastParsIndex].past_pars, &framepars[findex_prev].pars[PARS_SAVE_FROM], PARS_SAVE_COPY * sizeof(int));
		// memcpy(apastpars[sensor_port][pastParsIndex].past_pars, &framepars[findex_prev].pars[PARS_SAVE_FROM], PARS_SAVE_COPY * sizeof(int));
		memcpy(apastpars[sensor_port][pastParsIndex].past_pars, &framepars[findex_prev].pars[PARS_SAVE_FROM], PARS_SAVE_COPY << 2);

		// Now update interframe_pars (interframe area) used to create JPEG headers. Interframe area survives exactly as long as the frames themselves (not like pastpars)

		#if 0
		struct framepars_past_t {
		unsigned long past_pars[PARS_SAVE_NUM]; ///< Array of frame parameters preserved for the future
		};

		#endif

		#ifdef NC353
		if (interframe_pars) { // frame was compressed, not just vsync
		//TODO: get rid of *_prev, use it for the future.

src/drivers/elphel/pgm_functions.c

+82 −1

Original line number	Diff line number	Diff line
		@@ -625,6 +625,7 @@ int pgm_initsensor (int sensor_port, ///< sensor port number (
		x393_lens_height_m1_t vign_hight1 = {.d32=0};
		x393_lens_height_m1_t vign_hight2 = {.d32=0};
		x393_sens_mode_t sens_mode = {.d32=0};
		x393_camsync_mode_t camsync_mode = {.d32=0};

		dev_dbg(g_dev_ptr,"{%d} frame16=%d\n",sensor_port,frame16);
		MDP(DBGB_PSFN, sensor_port,"frame16=%d\n",frame16)
		@@ -681,7 +682,61 @@ int pgm_initsensor (int sensor_port, ///< sensor port number (
		MDP(DBGB_PADD, sensor_port,"X393_SEQ_SEND1(0x%x, 0x%x, x393_sens_mode, 0x%x)\n",
		sensor_port, frame16, sens_mode.d32)

		/*
		self.set_camsync_period (0) # reset circuitry
		self.X393_gpio.set_gpio_ports (port_a = True)
		self.set_camsync_mode (
		en = True,
		en_snd = True,
		en_ts_external = external_timestamp,
		triggered_mode = trigger_mode,
		master_chn = 0,
		chn_en = sensor_mask)

		void x393_camsync_mode (x393_camsync_mode_t d); // CAMSYNC mode

		// CAMSYNC mode

		typedef union {
		struct {
		u32 en: 1; // [ 0] (1) Enable CAMSYNC module
		u32 en_set: 1; // [ 1] (1) Set 'en' bit
		u32 en_snd: 1; // [ 2] (1) Enable sending timestamps (valid with 'en_snd_set')
		u32 en_snd_set: 1; // [ 3] (0) Set 'en_snd'
		u32 ext: 1; // [ 4] (1) Use external (received) timestamps, if available. O - use local timestamps
		u32 ext_set: 1; // [ 5] (0) Set 'ext'
		u32 trig: 1; // [ 6] (1) Sensor triggered mode (0 - free running sensor)
		u32 trig_set: 1; // [ 7] (0) Set 'trig'
		u32 master_chn: 2; // [ 9: 8] (0) master sensor channel (zero delay in internal trigger mode, delay used for flash output)
		u32 master_chn_set: 1; // [ 10] (0) Set 'master_chn'
		u32 ts_chns: 4; // [14:11] (1) Channels to generate timestmp messages (bit mask)
		u32 ts_chns_set: 4; // [18:15] (0) Sets for 'ts_chns' (each bit controls corresponding 'ts_chns' bit)
		u32 :13;
		};
		struct {
		u32 d32:32; // [31: 0] (0) cast to u32
		};
		} x393_camsync_mode_t;
		self.set_camsync_mode (
		en = True,
		en_snd = True,
		en_ts_external = False,
		triggered_mode = False,
		master_chn = 0,
		chn_en = sensor_mask)

		*/

		camsync_mode.en = 1;
		camsync_mode.en_set = 1;
		camsync_mode.ext = 0;
		camsync_mode.ext_set = 1;
		camsync_mode.trig = 0;
		camsync_mode.trig_set = 1;

		x393_camsync_mode (camsync_mode); // immediate mode, bypass sequencer CAMSYNC mode
		// (TODO NC393: Make it possible to synchronize writes (through sequencer)
		set_x393_camsync_trig_period (0); // reset circuitry (immediate mode)
		if (frame16 >= 0) return -1; // should be ASAP
		//TODO: seems nothing to do here - all in the sensor-specific function:
		//Adding setup compressor report status mode - maybe move elsethere? Needed for comprfessor frame reporting, has to be done just once
		@@ -1378,6 +1433,7 @@ int pgm_sensorin (int sensor_port, ///< sensor port number (0..3
		x393_sensio_width_t sensio_width = {.d32=0};
		x393_sens_sync_mult_t sync_mult = {.d32=0};
		x393_gamma_ctl_t gamma_ctl = {.d32=0};

		int n_scan_lines, n_ph_lines;
		int flips;
		int bayer_modified;
		@@ -1450,7 +1506,7 @@ int pgm_sensorin (int sensor_port, ///< sensor port number (0..3

		// Change Bayer for gamma/histograms?
		if (bayer_modified) {
		gamma_ctl.bayer = thispars->pars[P_BAYER] ^ flips ^ sensor->bayer;
		gamma_ctl.bayer = thispars->pars[P_BAYER] ^ flips ^ sensor->bayer ^ 3; // 3 added for NC393
		gamma_ctl.bayer_set = 1;
		}
		//NC393: Other needed bits are set in pgm_initsensor (they must be set just once)
		@@ -1462,6 +1518,31 @@ int pgm_sensorin (int sensor_port, ///< sensor port number (0..3
		}

		#if 0

		typedef union {
		struct {
		u32 run: 2; // [ 1: 0] (0) Run mode
		u32 run_set: 1; // [ 2] (0) Set 'run'
		u32 qbank: 3; // [ 5: 3] (0) Quantization table bank
		u32 qbank_set: 1; // [ 6] (0) Set 'qbank'
		u32 dcsub: 1; // [ 7] (0) Subtract DC enable
		u32 dcsub_set: 1; // [ 8] (0) Set 'qbank'
		u32 cmode: 4; // [12: 9] (0) Color format
		u32 cmode_set: 1; // [ 13] (0) Set 'cmode'
		u32 multiframe: 1; // [ 14] (0) Multi/single frame mode
		u32 multiframe_set: 1; // [ 15] (0) Set 'multiframe'
		u32 : 2;
		u32 bayer: 2; // [19:18] (0) Bayer shift
		u32 bayer_set: 1; // [ 20] (0) Set 'bayer'
		u32 focus: 2; // [22:21] (0) Focus mode
		u32 focus_set: 1; // [ 23] (0) Set 'focus'
		u32 : 8;
		};
		struct {
		u32 d32:32; // [31: 0] (0) cast to u32
		};
		} x393_cmprs_mode_t;

		// Control for the gamma-conversion module

		typedef union {

src/drivers/elphel/pgm_functions.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -39,7 +39,6 @@ int add_sensor_proc(int port, int index, int (*sens_func)(int sensor_port, struc
		#define X393_SEQ_SEND1S(port,frame,func,data,subchn) {if ((frame) < 0) seqr_##func (0, (data), (port), (subchn)); \
		else seqa_##func ((frame), (data), (port), (subchn)); }


		/** Tells if parameter is modifies
		* @param x parameter index to test
		* @return nonzero if modified */

src/drivers/elphel/sensor_common.c

+51 −56

File changed.

Preview size limit exceeded, changes collapsed.

Admin message