EFM32 Giant Gecko Software Documentation  efm32gg-doc-4.2.1
em_ebi.c
Go to the documentation of this file.
1 /***************************************************************************/
33 #include "em_ebi.h"
34 #if defined(EBI_COUNT) && (EBI_COUNT > 0)
35 #include "em_assert.h"
36 #include "em_bus.h"
37 
38 /***************************************************************************/
43 /***************************************************************************/
49 /***************************************************************************/
60 void EBI_Init(const EBI_Init_TypeDef *ebiInit)
61 {
62  uint32_t ctrl = EBI->CTRL;
63 
64 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
65  /* Enable Independent Timing for devices that supports it */
66  ctrl |= EBI_CTRL_ITS;
67 
68  /* Set polarity of address ready */
70  /* Set polarity of address latch enable */
71  EBI_BankPolaritySet(ebiInit->banks, ebiLineALE, ebiInit->alePolarity);
72  /* Set polarity of write enable */
73  EBI_BankPolaritySet(ebiInit->banks, ebiLineWE, ebiInit->wePolarity);
74  /* Set polarity of read enable */
75  EBI_BankPolaritySet(ebiInit->banks, ebiLineRE, ebiInit->rePolarity);
76  /* Set polarity of chip select lines */
77  EBI_BankPolaritySet(ebiInit->banks, ebiLineCS, ebiInit->csPolarity);
78  /* Set polarity of byte lane line */
79  EBI_BankPolaritySet(ebiInit->banks, ebiLineBL, ebiInit->blPolarity);
80 #else
81  /* Set polarity of address ready */
83  /* Set polarity of address latch enable */
85  /* Set polarity of write enable */
87  /* Set polarity of read enable */
89  /* Set polarity of chip select lines */
91 #endif
92 
93  /* Configure EBI mode and control settings */
94 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
95  if (ebiInit->banks & EBI_BANK0)
96  {
97  ctrl &= ~(_EBI_CTRL_MODE_MASK
103  ctrl |= (ebiInit->mode << _EBI_CTRL_MODE_SHIFT);
104  ctrl |= (ebiInit->ardyEnable << _EBI_CTRL_ARDYEN_SHIFT);
105  ctrl |= (ebiInit->ardyDisableTimeout << _EBI_CTRL_ARDYTODIS_SHIFT);
106  ctrl |= (ebiInit->blEnable << _EBI_CTRL_BL_SHIFT);
107  ctrl |= (ebiInit->noIdle << _EBI_CTRL_NOIDLE_SHIFT);
108  if ( ebiInit->enable)
109  {
110  ctrl |= EBI_CTRL_BANK0EN;
111  }
112  }
113  if (ebiInit->banks & EBI_BANK1)
114  {
115  ctrl &= ~(_EBI_CTRL_BL1_MASK
121  ctrl |= (ebiInit->mode << _EBI_CTRL_MODE1_SHIFT);
122  ctrl |= (ebiInit->ardyEnable << _EBI_CTRL_ARDY1EN_SHIFT);
123  ctrl |= (ebiInit->ardyDisableTimeout << _EBI_CTRL_ARDYTO1DIS_SHIFT);
124  ctrl |= (ebiInit->blEnable << _EBI_CTRL_BL1_SHIFT);
125  ctrl |= (ebiInit->noIdle << _EBI_CTRL_NOIDLE1_SHIFT);
126  if ( ebiInit->enable)
127  {
128  ctrl |= EBI_CTRL_BANK1EN;
129  }
130  }
131  if (ebiInit->banks & EBI_BANK2)
132  {
133  ctrl &= ~(_EBI_CTRL_BL2_MASK
139  ctrl |= (ebiInit->mode << _EBI_CTRL_MODE2_SHIFT);
140  ctrl |= (ebiInit->ardyEnable << _EBI_CTRL_ARDY2EN_SHIFT);
141  ctrl |= (ebiInit->ardyDisableTimeout << _EBI_CTRL_ARDYTO2DIS_SHIFT);
142  ctrl |= (ebiInit->blEnable << _EBI_CTRL_BL2_SHIFT);
143  ctrl |= (ebiInit->noIdle << _EBI_CTRL_NOIDLE2_SHIFT);
144  if ( ebiInit->enable)
145  {
146  ctrl |= EBI_CTRL_BANK2EN;
147  }
148  }
149  if (ebiInit->banks & EBI_BANK3)
150  {
151  ctrl &= ~(_EBI_CTRL_BL3_MASK
157  ctrl |= (ebiInit->mode << _EBI_CTRL_MODE3_SHIFT);
158  ctrl |= (ebiInit->ardyEnable << _EBI_CTRL_ARDY3EN_SHIFT);
159  ctrl |= (ebiInit->ardyDisableTimeout << _EBI_CTRL_ARDYTO3DIS_SHIFT);
160  ctrl |= (ebiInit->blEnable << _EBI_CTRL_BL3_SHIFT);
161  ctrl |= (ebiInit->noIdle << _EBI_CTRL_NOIDLE3_SHIFT);
162  if ( ebiInit->enable)
163  {
164  ctrl |= EBI_CTRL_BANK3EN;
165  }
166  }
167 #else
168  ctrl &= ~(_EBI_CTRL_MODE_MASK
175  if ( ebiInit->enable)
176  {
177  if ( ebiInit->banks & EBI_BANK0 )
178  {
179  ctrl |= EBI_CTRL_BANK0EN;
180  }
181  if ( ebiInit->banks & EBI_BANK1 )
182  {
183  ctrl |= EBI_CTRL_BANK1EN;
184  }
185  if ( ebiInit->banks & EBI_BANK2 )
186  {
187  ctrl |= EBI_CTRL_BANK2EN;
188  }
189  if ( ebiInit->banks & EBI_BANK3 )
190  {
191  ctrl |= EBI_CTRL_BANK3EN;
192  }
193  }
194  ctrl |= ebiInit->mode;
195  ctrl |= (ebiInit->ardyEnable << _EBI_CTRL_ARDYEN_SHIFT);
196  ctrl |= (ebiInit->ardyDisableTimeout << _EBI_CTRL_ARDYTODIS_SHIFT);
197 #endif
198 
199  /* Configure timing */
200 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
201  EBI_BankReadTimingSet(ebiInit->banks,
202  ebiInit->readSetupCycles,
203  ebiInit->readStrobeCycles,
204  ebiInit->readHoldCycles);
206  ebiInit->readPageMode,
207  ebiInit->readPrefetch,
208  ebiInit->readHalfRE);
209  EBI_BankWriteTimingSet(ebiInit->banks,
210  ebiInit->writeSetupCycles,
211  ebiInit->writeStrobeCycles,
212  ebiInit->writeHoldCycles);
214  ebiInit->writeBufferDisable,
215  ebiInit->writeHalfWE);
217  ebiInit->addrSetupCycles,
218  ebiInit->addrHoldCycles);
220  ebiInit->addrHalfALE);
221 #else
223  ebiInit->readStrobeCycles,
224  ebiInit->readHoldCycles);
226  ebiInit->writeStrobeCycles,
227  ebiInit->writeHoldCycles);
229  ebiInit->addrHoldCycles);
230 #endif
231 
232  /* Activate new configuration */
233  EBI->CTRL = ctrl;
234 
235  /* Configure Adress Latch Enable */
236  switch (ebiInit->mode)
237  {
238  case ebiModeD16A16ALE:
239  case ebiModeD8A24ALE:
240  /* Address Latch Enable */
242  break;
243 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
244  case ebiModeD16:
245 #endif
246  case ebiModeD8A8:
247  /* Make sure Address Latch is disabled */
249  break;
250  }
251 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
252  /* Limit pin enable */
253  EBI->ROUTE = (EBI->ROUTE & ~_EBI_ROUTE_ALB_MASK) | ebiInit->aLow;
254  EBI->ROUTE = (EBI->ROUTE & ~_EBI_ROUTE_APEN_MASK) | ebiInit->aHigh;
255  /* Location */
256  EBI->ROUTE = (EBI->ROUTE & ~_EBI_ROUTE_LOCATION_MASK) | ebiInit->location;
257 
258  /* Enable EBI BL pin if necessary */
260  {
261  BUS_RegBitWrite(&(EBI->ROUTE), _EBI_ROUTE_BLPEN_SHIFT, ebiInit->blEnable);
262  }
263 #endif
264  /* Enable EBI pins EBI_WEn and EBI_REn */
266 
267  /* Enable chip select lines */
268  EBI_ChipSelectEnable(ebiInit->csLines, true);
269 }
270 
271 
272 /***************************************************************************/
276 void EBI_Disable(void)
277 {
278  /* Disable pins */
279  EBI->ROUTE = _EBI_ROUTE_RESETVALUE;
280  /* Disable banks */
281  EBI->CTRL = _EBI_CTRL_RESETVALUE;
282 }
283 
284 
285 /***************************************************************************/
295 void EBI_BankEnable(uint32_t banks, bool enable)
296 {
297  if (banks & EBI_BANK0)
298  {
299  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BANK0EN_SHIFT, enable);
300  }
301  if (banks & EBI_BANK1)
302  {
303  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BANK1EN_SHIFT, enable);
304  }
305  if (banks & EBI_BANK2)
306  {
307  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BANK2EN_SHIFT, enable);
308  }
309  if (banks & EBI_BANK3)
310  {
311  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BANK3EN_SHIFT, enable);
312  }
313 }
314 
315 
316 /***************************************************************************/
326 uint32_t EBI_BankAddress(uint32_t bank)
327 {
328 #if defined (_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
329  if(EBI->CTRL & EBI_CTRL_ALTMAP)
330  {
331  switch (bank)
332  {
333  case EBI_BANK0:
334  return(EBI_MEM_BASE);
335 
336  case EBI_BANK1:
337  return(EBI_MEM_BASE + 0x10000000UL);
338 
339  case EBI_BANK2:
340  return(EBI_MEM_BASE + 0x20000000UL);
341 
342  case EBI_BANK3:
343  return(EBI_MEM_BASE + 0x30000000UL);
344 
345  default:
346  EFM_ASSERT(0);
347  break;
348  }
349  }
350 #endif
351  switch (bank)
352  {
353  case EBI_BANK0:
354  return(EBI_MEM_BASE);
355 
356  case EBI_BANK1:
357  return(EBI_MEM_BASE + 0x04000000UL);
358 
359  case EBI_BANK2:
360  return(EBI_MEM_BASE + 0x08000000UL);
361 
362  case EBI_BANK3:
363  return(EBI_MEM_BASE + 0x0C000000UL);
364 
365  default:
366  EFM_ASSERT(0);
367  break;
368  }
369  return 0;
370 }
371 
372 
373 /***************************************************************************/
383 void EBI_ChipSelectEnable(uint32_t cs, bool enable)
384 {
385  if (cs & EBI_CS0)
386  {
387  BUS_RegBitWrite(&(EBI->ROUTE), _EBI_ROUTE_CS0PEN_SHIFT, enable);
388  }
389  if (cs & EBI_CS1)
390  {
391  BUS_RegBitWrite(&(EBI->ROUTE), _EBI_ROUTE_CS1PEN_SHIFT, enable);
392  }
393  if (cs & EBI_CS2)
394  {
395  BUS_RegBitWrite(&(EBI->ROUTE), _EBI_ROUTE_CS2PEN_SHIFT, enable);
396  }
397  if (cs & EBI_CS3)
398  {
399  BUS_RegBitWrite(&(EBI->ROUTE), _EBI_ROUTE_CS3PEN_SHIFT, enable);
400  }
401 }
402 
403 
404 /***************************************************************************/
415 {
416  switch (line)
417  {
418  case ebiLineARDY:
419  BUS_RegBitWrite(&(EBI->POLARITY), _EBI_POLARITY_ARDYPOL_SHIFT, polarity);
420  break;
421  case ebiLineALE:
422  BUS_RegBitWrite(&(EBI->POLARITY), _EBI_POLARITY_ALEPOL_SHIFT, polarity);
423  break;
424  case ebiLineWE:
425  BUS_RegBitWrite(&(EBI->POLARITY), _EBI_POLARITY_WEPOL_SHIFT, polarity);
426  break;
427  case ebiLineRE:
428  BUS_RegBitWrite(&(EBI->POLARITY), _EBI_POLARITY_REPOL_SHIFT, polarity);
429  break;
430  case ebiLineCS:
431  BUS_RegBitWrite(&(EBI->POLARITY), _EBI_POLARITY_CSPOL_SHIFT, polarity);
432  break;
433 #if defined (_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
434  case ebiLineBL:
435  BUS_RegBitWrite(&(EBI->POLARITY), _EBI_POLARITY_BLPOL_SHIFT, polarity);
436  break;
437  case ebiLineTFTVSync:
438  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_VSYNCPOL_SHIFT, polarity);
439  break;
440  case ebiLineTFTHSync:
441  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_HSYNCPOL_SHIFT, polarity);
442  break;
443  case ebiLineTFTDataEn:
444  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_DATAENPOL_SHIFT, polarity);
445  break;
446  case ebiLineTFTDClk:
447  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_DCLKPOL_SHIFT, polarity);
448  break;
449  case ebiLineTFTCS:
450  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_CSPOL_SHIFT, polarity);
451  break;
452 #endif
453  default:
454  EFM_ASSERT(0);
455  break;
456  }
457 }
458 
459 
460 /***************************************************************************/
474 void EBI_ReadTimingSet(int setupCycles, int strobeCycles, int holdCycles)
475 {
476  uint32_t readTiming;
477 
478  /* Check that timings are within limits */
479  EFM_ASSERT(setupCycles < 4);
480  EFM_ASSERT(strobeCycles < 16);
481  EFM_ASSERT(holdCycles < 4);
482 
483  /* Configure timing values */
484  readTiming = (setupCycles << _EBI_RDTIMING_RDSETUP_SHIFT)
485  | (strobeCycles << _EBI_RDTIMING_RDSTRB_SHIFT)
486  | (holdCycles << _EBI_RDTIMING_RDHOLD_SHIFT);
487 
488 
489  EBI->RDTIMING = (EBI->RDTIMING
493  | readTiming;
494 }
495 
496 
497 /***************************************************************************/
510 void EBI_WriteTimingSet(int setupCycles, int strobeCycles, int holdCycles)
511 {
512  uint32_t writeTiming;
513 
514  /* Check that timings are within limits */
515  EFM_ASSERT(setupCycles < 4);
516  EFM_ASSERT(strobeCycles < 16);
517  EFM_ASSERT(holdCycles < 4);
518 
519  /* Configure timing values */
520  writeTiming = (setupCycles << _EBI_WRTIMING_WRSETUP_SHIFT)
521  | (strobeCycles << _EBI_WRTIMING_WRSTRB_SHIFT)
522  | (holdCycles << _EBI_WRTIMING_WRHOLD_SHIFT);
523 
524  EBI->WRTIMING = (EBI->WRTIMING
528  | writeTiming;
529 }
530 
531 
532 /***************************************************************************/
543 void EBI_AddressTimingSet(int setupCycles, int holdCycles)
544 {
545  uint32_t addressLatchTiming;
546 
547  /* Check that timing values are within limits */
548  EFM_ASSERT(setupCycles < 4);
549  EFM_ASSERT(holdCycles < 4);
550 
551  /* Configure address latch timing values */
552  addressLatchTiming = (setupCycles << _EBI_ADDRTIMING_ADDRSETUP_SHIFT)
553  | (holdCycles << _EBI_ADDRTIMING_ADDRHOLD_SHIFT);
554 
555  EBI->ADDRTIMING = (EBI->ADDRTIMING
558  | addressLatchTiming;
559 }
560 
561 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
562 /***************************************************************************/
569 void EBI_TFTInit(const EBI_TFTInit_TypeDef *ebiTFTInit)
570 {
571  uint32_t ctrl;
572 
573  /* Configure base address for frame buffer offset to EBI bank */
574  EBI_TFTFrameBaseSet(ebiTFTInit->addressOffset);
575 
576  /* Configure display size and porch areas */
577  EBI_TFTSizeSet(ebiTFTInit->hsize,
578  ebiTFTInit->vsize);
579  EBI_TFTHPorchSet(ebiTFTInit->hPorchFront,
580  ebiTFTInit->hPorchBack,
581  ebiTFTInit->hPulseWidth);
582  EBI_TFTVPorchSet(ebiTFTInit->vPorchFront,
583  ebiTFTInit->vPorchBack,
584  ebiTFTInit->vPulseWidth);
585 
586  /* Configure timing settings */
587  EBI_TFTTimingSet(ebiTFTInit->dclkPeriod,
588  ebiTFTInit->startPosition,
589  ebiTFTInit->setupCycles,
590  ebiTFTInit->holdCycles);
591 
592  /* Configure line polarity settings */
598 
599  /* Main control, EBI bank select, mask and blending configuration */
600  ctrl = (uint32_t)ebiTFTInit->bank
601  | (uint32_t)ebiTFTInit->width
602  | (uint32_t)ebiTFTInit->colSrc
603  | (uint32_t)ebiTFTInit->interleave
604  | (uint32_t)ebiTFTInit->fbTrigger
605  | (uint32_t)(ebiTFTInit->shiftDClk == true
606  ? (1 << _EBI_TFTCTRL_SHIFTDCLKEN_SHIFT) : 0)
607  | (uint32_t)ebiTFTInit->maskBlend
608  | (uint32_t)ebiTFTInit->driveMode;
609 
610  EBI->TFTCTRL = ctrl;
611 
612  /* Enable TFT pins */
613  if (ebiTFTInit->driveMode != ebiTFTDDModeDisabled)
614  {
615  EBI->ROUTE |= EBI_ROUTE_TFTPEN;
616  }
617 }
618 
619 
620 /***************************************************************************/
629 void EBI_TFTSizeSet(uint32_t horizontal, uint32_t vertical)
630 {
631  EFM_ASSERT((horizontal-1) < 1024);
632  EFM_ASSERT((vertical-1) < 1024);
633 
634  EBI->TFTSIZE = ((horizontal-1) << _EBI_TFTSIZE_HSZ_SHIFT)
635  | ((vertical-1) << _EBI_TFTSIZE_VSZ_SHIFT);
636 }
637 
638 /***************************************************************************/
649 void EBI_TFTHPorchSet(int front, int back, int pulseWidth)
650 {
651  EFM_ASSERT(front < 256);
652  EFM_ASSERT(back < 256);
653  EFM_ASSERT((pulseWidth-1) < 128);
654 
655  EBI->TFTHPORCH = (front << _EBI_TFTHPORCH_HFPORCH_SHIFT)
656  | (back << _EBI_TFTHPORCH_HBPORCH_SHIFT)
657  | ((pulseWidth-1) << _EBI_TFTHPORCH_HSYNC_SHIFT);
658 }
659 
660 
661 /***************************************************************************/
672 void EBI_TFTVPorchSet(int front, int back, int pulseWidth)
673 {
674  EFM_ASSERT(front < 256);
675  EFM_ASSERT(back < 256);
676  EFM_ASSERT((pulseWidth-1) < 128);
677 
678  EBI->TFTVPORCH = (front << _EBI_TFTVPORCH_VFPORCH_SHIFT)
679  | (back << _EBI_TFTVPORCH_VBPORCH_SHIFT)
680  | ((pulseWidth-1) << _EBI_TFTVPORCH_VSYNC_SHIFT);
681 }
682 
683 
684 /***************************************************************************/
700 void EBI_TFTTimingSet(int dclkPeriod, int start, int setup, int hold)
701 {
702  EFM_ASSERT(dclkPeriod < 2048);
703  EFM_ASSERT(start < 2048);
704  EFM_ASSERT(setup < 4);
705  EFM_ASSERT(hold < 4);
706 
707  EBI->TFTTIMING = (dclkPeriod << _EBI_TFTTIMING_DCLKPERIOD_SHIFT)
708  | (start << _EBI_TFTTIMING_TFTSTART_SHIFT)
709  | (setup << _EBI_TFTTIMING_TFTSETUP_SHIFT)
710  | (hold << _EBI_TFTTIMING_TFTHOLD_SHIFT);
711 }
712 #endif
713 
714 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
715 /***************************************************************************/
731 void EBI_BankReadTimingConfig(uint32_t banks, bool pageMode, bool prefetch, bool halfRE)
732 {
733  /* Verify only valid banks are used */
734  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
735 
736  /* Configure read operation parameters */
737  if( banks & EBI_BANK0 )
738  {
739  BUS_RegBitWrite(&EBI->RDTIMING, _EBI_RDTIMING_PAGEMODE_SHIFT, pageMode);
740  BUS_RegBitWrite(&EBI->RDTIMING, _EBI_RDTIMING_PREFETCH_SHIFT, prefetch);
741  BUS_RegBitWrite(&EBI->RDTIMING, _EBI_RDTIMING_HALFRE_SHIFT, halfRE);
742  }
743  if( banks & EBI_BANK1 )
744  {
745  BUS_RegBitWrite(&EBI->RDTIMING1, _EBI_RDTIMING_PAGEMODE_SHIFT, pageMode);
746  BUS_RegBitWrite(&EBI->RDTIMING1, _EBI_RDTIMING_PREFETCH_SHIFT, prefetch);
747  BUS_RegBitWrite(&EBI->RDTIMING1, _EBI_RDTIMING_HALFRE_SHIFT, halfRE);
748  }
749  if( banks & EBI_BANK2 )
750  {
751  BUS_RegBitWrite(&EBI->RDTIMING2, _EBI_RDTIMING_PAGEMODE_SHIFT, pageMode);
752  BUS_RegBitWrite(&EBI->RDTIMING2, _EBI_RDTIMING_PREFETCH_SHIFT, prefetch);
753  BUS_RegBitWrite(&EBI->RDTIMING2, _EBI_RDTIMING_HALFRE_SHIFT, halfRE);
754  }
755  if( banks & EBI_BANK3 )
756  {
757  BUS_RegBitWrite(&EBI->RDTIMING3, _EBI_RDTIMING_PAGEMODE_SHIFT, pageMode);
758  BUS_RegBitWrite(&EBI->RDTIMING3, _EBI_RDTIMING_PREFETCH_SHIFT, prefetch);
759  BUS_RegBitWrite(&EBI->RDTIMING3, _EBI_RDTIMING_HALFRE_SHIFT, halfRE);
760  }
761 }
762 
763 /***************************************************************************/
780 void EBI_BankReadTimingSet(uint32_t banks, int setupCycles, int strobeCycles, int holdCycles)
781 {
782  uint32_t readTiming;
783 
784  /* Verify only valid banks are used */
785  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
786 
787  /* Check that timings are within limits */
788  EFM_ASSERT(setupCycles < 4);
789  EFM_ASSERT(strobeCycles < 64);
790  EFM_ASSERT(holdCycles < 4);
791 
792  /* Configure timing values */
793  readTiming = (setupCycles << _EBI_RDTIMING_RDSETUP_SHIFT)
794  | (strobeCycles << _EBI_RDTIMING_RDSTRB_SHIFT)
795  | (holdCycles << _EBI_RDTIMING_RDHOLD_SHIFT);
796 
797  if (banks & EBI_BANK0)
798  {
799  EBI->RDTIMING = (EBI->RDTIMING
803  | readTiming;
804  }
805  if (banks & EBI_BANK1)
806  {
807  EBI->RDTIMING1 = (EBI->RDTIMING1
811  | readTiming;
812  }
813  if (banks & EBI_BANK2)
814  {
815  EBI->RDTIMING2 = (EBI->RDTIMING2
819  | readTiming;
820  }
821  if (banks & EBI_BANK3)
822  {
823  EBI->RDTIMING3 = (EBI->RDTIMING3
827  | readTiming;
828  }
829 }
830 
831 
832 /***************************************************************************/
845 void EBI_BankWriteTimingConfig(uint32_t banks, bool writeBufDisable, bool halfWE)
846 {
847  /* Verify only valid banks are used */
848  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
849 
850  /* Configure write operation parameters */
851  if( banks & EBI_BANK0 )
852  {
853  BUS_RegBitWrite(&EBI->WRTIMING, _EBI_WRTIMING_WBUFDIS_SHIFT, writeBufDisable);
854  BUS_RegBitWrite(&EBI->WRTIMING, _EBI_WRTIMING_HALFWE_SHIFT, halfWE);
855  }
856  if( banks & EBI_BANK1 )
857  {
858  BUS_RegBitWrite(&EBI->WRTIMING1, _EBI_WRTIMING_WBUFDIS_SHIFT, writeBufDisable);
859  BUS_RegBitWrite(&EBI->WRTIMING1, _EBI_WRTIMING_HALFWE_SHIFT, halfWE);
860  }
861  if( banks & EBI_BANK2 )
862  {
863  BUS_RegBitWrite(&EBI->WRTIMING2, _EBI_WRTIMING_WBUFDIS_SHIFT, writeBufDisable);
864  BUS_RegBitWrite(&EBI->WRTIMING2, _EBI_WRTIMING_HALFWE_SHIFT, halfWE);
865  }
866  if( banks & EBI_BANK3 )
867  {
868  BUS_RegBitWrite(&EBI->WRTIMING3, _EBI_WRTIMING_WBUFDIS_SHIFT, writeBufDisable);
869  BUS_RegBitWrite(&EBI->WRTIMING3, _EBI_WRTIMING_HALFWE_SHIFT, halfWE);
870  }
871 }
872 
873 
874 /***************************************************************************/
890 void EBI_BankWriteTimingSet(uint32_t banks, int setupCycles, int strobeCycles, int holdCycles)
891 {
892  uint32_t writeTiming;
893 
894  /* Verify only valid banks are used */
895  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
896 
897  /* Check that timings are within limits */
898  EFM_ASSERT(setupCycles < 4);
899  EFM_ASSERT(strobeCycles < 64);
900  EFM_ASSERT(holdCycles < 4);
901 
902  /* Configure timing values */
903  writeTiming = (setupCycles << _EBI_WRTIMING_WRSETUP_SHIFT)
904  | (strobeCycles << _EBI_WRTIMING_WRSTRB_SHIFT)
905  | (holdCycles << _EBI_WRTIMING_WRHOLD_SHIFT);
906 
907  if (banks & EBI_BANK0)
908  {
909  EBI->WRTIMING = (EBI->WRTIMING
913  | writeTiming;
914  }
915  if (banks & EBI_BANK1)
916  {
917  EBI->WRTIMING1 = (EBI->WRTIMING1
921  | writeTiming;
922  }
923  if (banks & EBI_BANK2)
924  {
925  EBI->WRTIMING2 = (EBI->WRTIMING2
929  | writeTiming;
930  }
931  if (banks & EBI_BANK3)
932  {
933  EBI->WRTIMING3 = (EBI->WRTIMING3
937  | writeTiming;
938  }
939 }
940 
941 
942 /***************************************************************************/
952 void EBI_BankAddressTimingConfig(uint32_t banks, bool halfALE)
953 {
954  /* Verify only valid banks are used */
955  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
956 
957  if( banks & EBI_BANK0 )
958  {
959  BUS_RegBitWrite(&EBI->ADDRTIMING, _EBI_ADDRTIMING_HALFALE_SHIFT, halfALE);
960  }
961  if( banks & EBI_BANK1 )
962  {
963  BUS_RegBitWrite(&EBI->ADDRTIMING1, _EBI_ADDRTIMING_HALFALE_SHIFT, halfALE);
964  }
965  if( banks & EBI_BANK2 )
966  {
967  BUS_RegBitWrite(&EBI->ADDRTIMING2, _EBI_ADDRTIMING_HALFALE_SHIFT, halfALE);
968  }
969  if( banks & EBI_BANK3 )
970  {
971  BUS_RegBitWrite(&EBI->ADDRTIMING3, _EBI_ADDRTIMING_HALFALE_SHIFT, halfALE);
972  }
973 }
974 
975 
976 /***************************************************************************/
990 void EBI_BankAddressTimingSet(uint32_t banks, int setupCycles, int holdCycles)
991 {
992  uint32_t addressLatchTiming;
993 
994  /* Verify only valid banks are used */
995  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
996 
997  /* Check that timing values are within limits */
998  EFM_ASSERT(setupCycles < 4);
999  EFM_ASSERT(holdCycles < 4);
1000 
1001  /* Configure address latch timing values */
1002  addressLatchTiming = (setupCycles << _EBI_ADDRTIMING_ADDRSETUP_SHIFT)
1003  | (holdCycles << _EBI_ADDRTIMING_ADDRHOLD_SHIFT);
1004 
1005  if (banks & EBI_BANK0)
1006  {
1007  EBI->ADDRTIMING = (EBI->ADDRTIMING
1010  | addressLatchTiming;
1011  }
1012  if (banks & EBI_BANK1)
1013  {
1014  EBI->ADDRTIMING1 = (EBI->ADDRTIMING1
1017  | addressLatchTiming;
1018  }
1019  if (banks & EBI_BANK2)
1020  {
1021  EBI->ADDRTIMING2 = (EBI->ADDRTIMING2
1024  | addressLatchTiming;
1025  }
1026  if (banks & EBI_BANK3)
1027  {
1028  EBI->ADDRTIMING3 = (EBI->ADDRTIMING3
1031  | addressLatchTiming;
1032  }
1033 }
1034 
1035 
1036 /***************************************************************************/
1050 void EBI_BankPolaritySet(uint32_t banks, EBI_Line_TypeDef line, EBI_Polarity_TypeDef polarity)
1051 {
1052  uint32_t bankSet = 0;
1053  volatile uint32_t *polRegister = 0;
1054 
1055  /* Verify only valid banks are used */
1056  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
1057 
1058  while (banks)
1059  {
1060 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
1061  if (banks & EBI_BANK0)
1062  {
1063  polRegister = &EBI->POLARITY;
1064  bankSet = EBI_BANK0;
1065  }
1066  if (banks & EBI_BANK1)
1067  {
1068  polRegister = &EBI->POLARITY1;
1069  bankSet = EBI_BANK1;
1070  }
1071  if (banks & EBI_BANK2)
1072  {
1073  polRegister = &EBI->POLARITY2;
1074  bankSet = EBI_BANK2;
1075  }
1076  if (banks & EBI_BANK3)
1077  {
1078  polRegister = &EBI->POLARITY3;
1079  bankSet = EBI_BANK3;
1080  }
1081 #else
1082  polRegister = &EBI->POLARITY;
1083  banks = 0;
1084 #endif
1085 
1086  /* What line to configure */
1087  switch (line)
1088  {
1089  case ebiLineARDY:
1090  BUS_RegBitWrite(polRegister, _EBI_POLARITY_ARDYPOL_SHIFT, polarity);
1091  break;
1092  case ebiLineALE:
1093  BUS_RegBitWrite(polRegister, _EBI_POLARITY_ALEPOL_SHIFT, polarity);
1094  break;
1095  case ebiLineWE:
1096  BUS_RegBitWrite(polRegister, _EBI_POLARITY_WEPOL_SHIFT, polarity);
1097  break;
1098  case ebiLineRE:
1099  BUS_RegBitWrite(polRegister, _EBI_POLARITY_REPOL_SHIFT, polarity);
1100  break;
1101  case ebiLineCS:
1102  BUS_RegBitWrite(polRegister, _EBI_POLARITY_CSPOL_SHIFT, polarity);
1103  break;
1104 #if defined(_EFM32_GIANT_FAMILY) || defined(_EFM32_WONDER_FAMILY)
1105  case ebiLineBL:
1106  BUS_RegBitWrite(polRegister, _EBI_POLARITY_BLPOL_SHIFT, polarity);
1107  break;
1108  case ebiLineTFTVSync:
1109  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_VSYNCPOL_SHIFT, polarity);
1110  break;
1111  case ebiLineTFTHSync:
1112  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_HSYNCPOL_SHIFT, polarity);
1113  break;
1114  case ebiLineTFTDataEn:
1115  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_DATAENPOL_SHIFT, polarity);
1116  break;
1117  case ebiLineTFTDClk:
1118  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_DCLKPOL_SHIFT, polarity);
1119  break;
1120  case ebiLineTFTCS:
1121  BUS_RegBitWrite(&(EBI->TFTPOLARITY), _EBI_TFTPOLARITY_CSPOL_SHIFT, polarity);
1122  break;
1123 #endif
1124  default:
1125  EFM_ASSERT(0);
1126  break;
1127  }
1128  banks = banks & ~bankSet;
1129  }
1130 }
1131 
1132 
1133 /***************************************************************************/
1144 void EBI_BankByteLaneEnable(uint32_t banks, bool enable)
1145 {
1146  /* Verify only valid banks are used */
1147  EFM_ASSERT((banks & ~(EBI_BANK0 | EBI_BANK1 | EBI_BANK2 | EBI_BANK3)) == 0);
1148 
1149  /* Configure byte lane support for each selected bank */
1150  if (banks & EBI_BANK0)
1151  {
1152  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BL_SHIFT, enable);
1153  }
1154  if (banks & EBI_BANK1)
1155  {
1156  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BL1_SHIFT, enable);
1157  }
1158  if (banks & EBI_BANK2)
1159  {
1160  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BL2_SHIFT, enable);
1161  }
1162  if (banks & EBI_BANK3)
1163  {
1164  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_BL3_SHIFT, enable);
1165  }
1166 }
1167 
1168 
1169 /***************************************************************************/
1177 void EBI_AltMapEnable(bool enable)
1178 {
1179  BUS_RegBitWrite(&(EBI->CTRL), _EBI_CTRL_ALTMAP_SHIFT, enable);
1180 }
1181 
1182 #endif
1183 
1187 #endif /* defined(EBI_COUNT) && (EBI_COUNT > 0) */
int addrSetupCycles
Definition: em_ebi.h:345
#define _EBI_CTRL_ARDYTODIS_SHIFT
Definition: efm32gg_ebi.h:189
#define _EBI_CTRL_RESETVALUE
Definition: efm32gg_ebi.h:93
#define _EBI_WRTIMING3_WRSETUP_MASK
Definition: efm32gg_ebi.h:842
#define _EBI_TFTVPORCH_VBPORCH_SHIFT
Definition: efm32gg_ebi.h:1204
#define _EBI_ADDRTIMING_HALFALE_SHIFT
Definition: efm32gg_ebi.h:266
int readStrobeCycles
Definition: em_ebi.h:355
#define _EBI_WRTIMING3_WRSTRB_MASK
Definition: efm32gg_ebi.h:846
int readSetupCycles
Definition: em_ebi.h:353
EBI_Polarity_TypeDef
Definition: em_ebi.h:105
#define _EBI_TFTPOLARITY_HSYNCPOL_SHIFT
Definition: efm32gg_ebi.h:1260
void EBI_BankWriteTimingSet(uint32_t bank, int setupCycles, int strobeCycles, int holdCycles)
Configure timing values of write bus accesses.
Definition: em_ebi.c:890
void EBI_AltMapEnable(bool enable)
Configure Alternate Address Map support Enables or disables 256MB address range for all banks...
Definition: em_ebi.c:1177
#define _EBI_RDTIMING_PAGEMODE_SHIFT
Definition: efm32gg_ebi.h:297
#define _EBI_CTRL_ALTMAP_SHIFT
Definition: efm32gg_ebi.h:249
#define EBI_BANK1
Definition: em_ebi.h:76
#define _EBI_CTRL_ARDYTODIS_MASK
Definition: efm32gg_ebi.h:190
#define _EBI_CTRL_ARDYTO2DIS_SHIFT
Definition: efm32gg_ebi.h:209
#define _EBI_CTRL_ARDY2EN_MASK
Definition: efm32gg_ebi.h:205
EBI_Polarity_TypeDef dclkPolarity
Definition: em_ebi.h:473
#define _EBI_WRTIMING_WRHOLD_SHIFT
Definition: efm32gg_ebi.h:313
#define _EBI_ROUTE_CS0PEN_SHIFT
Definition: efm32gg_ebi.h:395
#define _EBI_WRTIMING3_WRHOLD_MASK
Definition: efm32gg_ebi.h:850
Emlib peripheral API "assert" implementation.
#define _EBI_CTRL_ARDYTO1DIS_SHIFT
Definition: efm32gg_ebi.h:199
#define _EBI_CTRL_BANK3EN_MASK
Definition: efm32gg_ebi.h:160
void EBI_WriteTimingSet(int setupCycles, int strobeCycles, int holdCycles)
Configure timing values of write bus accesses.
Definition: em_ebi.c:510
#define _EBI_ROUTE_CS2PEN_SHIFT
Definition: efm32gg_ebi.h:405
#define _EBI_CTRL_BANK2EN_SHIFT
Definition: efm32gg_ebi.h:154
EBI_TFTMaskBlend_TypeDef maskBlend
Definition: em_ebi.h:467
EBI_TFTBank_TypeDef bank
Definition: em_ebi.h:455
#define _EBI_RDTIMING1_RDHOLD_MASK
Definition: efm32gg_ebi.h:555
#define _EBI_CTRL_MODE1_SHIFT
Definition: efm32gg_ebi.h:107
EBI_ALow_TypeDef aLow
Definition: em_ebi.h:378
#define _EBI_ROUTE_RESETVALUE
Definition: efm32gg_ebi.h:387
RAM and peripheral bit-field set and clear API.
uint32_t EBI_BankAddress(uint32_t bank)
Return base address of EBI bank.
Definition: em_ebi.c:326
EBI_Polarity_TypeDef csPolarity
Definition: em_ebi.h:327
#define _EBI_CTRL_MODE2_SHIFT
Definition: efm32gg_ebi.h:119
bool ardyEnable
Definition: em_ebi.h:337
bool readHalfRE
Definition: em_ebi.h:364
#define _EBI_CTRL_BANK3EN_SHIFT
Definition: efm32gg_ebi.h:159
EBI_Polarity_TypeDef vsyncPolarity
Definition: em_ebi.h:479
#define _EBI_TFTCTRL_SHIFTDCLKEN_SHIFT
Definition: efm32gg_ebi.h:1070
#define _EBI_CTRL_ARDY2EN_SHIFT
Definition: efm32gg_ebi.h:204
#define _EBI_WRTIMING_WRHOLD_MASK
Definition: efm32gg_ebi.h:314
#define _EBI_POLARITY_REPOL_SHIFT
Definition: efm32gg_ebi.h:341
#define EBI_ROUTE_TFTPEN
Definition: efm32gg_ebi.h:500
#define _EBI_ROUTE_EBIPEN_SHIFT
Definition: efm32gg_ebi.h:390
int readHoldCycles
Definition: em_ebi.h:357
#define _EBI_CTRL_NOIDLE_MASK
Definition: efm32gg_ebi.h:165
void EBI_TFTHPorchSet(int front, int back, int pulseWidth)
Configure and initialize Horizontal Porch Settings.
Definition: em_ebi.c:649
__STATIC_INLINE void EBI_TFTFrameBaseSet(uint32_t address)
Configure frame buffer pointer.
Definition: em_ebi.h:592
EBI_Mode_TypeDef mode
Definition: em_ebi.h:317
EBI_Polarity_TypeDef csPolarity
Definition: em_ebi.h:471
#define _EBI_RDTIMING2_RDHOLD_MASK
Definition: efm32gg_ebi.h:687
#define _EBI_POLARITY_BLPOL_SHIFT
Definition: efm32gg_ebi.h:377
#define _EBI_TFTHPORCH_HSYNC_SHIFT
Definition: efm32gg_ebi.h:1176
EBI_TFTFrameBufTrigger_TypeDef fbTrigger
Definition: em_ebi.h:463
void EBI_PolaritySet(EBI_Line_TypeDef line, EBI_Polarity_TypeDef polarity)
Configure EBI pin polarity.
Definition: em_ebi.c:414
#define _EBI_ADDRTIMING_ADDRSETUP_MASK
Definition: efm32gg_ebi.h:258
#define _EBI_RDTIMING_RDHOLD_MASK
Definition: efm32gg_ebi.h:283
int writeHoldCycles
Definition: em_ebi.h:371
#define _EBI_CTRL_BL3_MASK
Definition: efm32gg_ebi.h:240
#define EBI_CS1
Definition: em_ebi.h:81
EBI_TFTDDMode_TypeDef driveMode
Definition: em_ebi.h:469
#define _EBI_ADDRTIMING3_ADDRHOLD_MASK
Definition: efm32gg_ebi.h:798
#define _EBI_POLARITY_CSPOL_SHIFT
Definition: efm32gg_ebi.h:332
#define _EBI_CTRL_NOIDLE1_SHIFT
Definition: efm32gg_ebi.h:169
#define _EBI_CTRL_ARDYEN_MASK
Definition: efm32gg_ebi.h:185
#define _EBI_ADDRTIMING3_ADDRSETUP_MASK
Definition: efm32gg_ebi.h:794
EBI_Location_TypeDef location
Definition: em_ebi.h:382
#define _EBI_CTRL_MODE_MASK
Definition: efm32gg_ebi.h:96
#define _EBI_WRTIMING_WRSETUP_SHIFT
Definition: efm32gg_ebi.h:305
EBI_Polarity_TypeDef hsyncPolarity
Definition: em_ebi.h:477
#define _EBI_WRTIMING_WRSTRB_SHIFT
Definition: efm32gg_ebi.h:309
#define _EBI_CTRL_MODE1_MASK
Definition: efm32gg_ebi.h:108
uint32_t csLines
Definition: em_ebi.h:343
#define _EBI_ROUTE_ALB_MASK
Definition: efm32gg_ebi.h:435
#define _EBI_CTRL_BL3_SHIFT
Definition: efm32gg_ebi.h:239
#define EBI_BANK2
Definition: em_ebi.h:77
#define _EBI_ADDRTIMING_ADDRHOLD_SHIFT
Definition: efm32gg_ebi.h:261
#define EBI_CS2
Definition: em_ebi.h:82
#define _EBI_ADDRTIMING_ADDRSETUP_SHIFT
Definition: efm32gg_ebi.h:257
#define _EBI_TFTTIMING_TFTHOLD_SHIFT
Definition: efm32gg_ebi.h:1224
void EBI_AddressTimingSet(int setupCycles, int holdCycles)
Configure timing values of address latch bus accesses.
Definition: em_ebi.c:543
void EBI_BankEnable(uint32_t banks, bool enable)
Enable or disable EBI Bank.
Definition: em_ebi.c:295
#define _EBI_CTRL_ARDYTO3DIS_MASK
Definition: efm32gg_ebi.h:220
#define _EBI_CTRL_NOIDLE2_SHIFT
Definition: efm32gg_ebi.h:174
EBI_TFTColorSrc_TypeDef colSrc
Definition: em_ebi.h:459
#define _EBI_WRTIMING1_WRSETUP_MASK
Definition: efm32gg_ebi.h:578
#define _EBI_TFTPOLARITY_DCLKPOL_SHIFT
Definition: efm32gg_ebi.h:1242
#define EBI_CTRL_BANK0EN
Definition: efm32gg_ebi.h:143
#define EBI_BANK3
Definition: em_ebi.h:78
External Bus Iterface (EBI) peripheral API.
#define _EBI_ROUTE_BLPEN_SHIFT
Definition: efm32gg_ebi.h:425
#define _EBI_TFTHPORCH_HBPORCH_SHIFT
Definition: efm32gg_ebi.h:1184
EBI_TFTInterleave_TypeDef interleave
Definition: em_ebi.h:461
EBI_Line_TypeDef
Definition: em_ebi.h:114
#define _EBI_POLARITY_ARDYPOL_SHIFT
Definition: efm32gg_ebi.h:368
EBI_TFTWidth_TypeDef width
Definition: em_ebi.h:457
#define _EBI_CTRL_NOIDLE_SHIFT
Definition: efm32gg_ebi.h:164
void EBI_BankByteLaneEnable(uint32_t bank, bool enable)
Configure Byte Lane Enable for select banks timing support.
Definition: em_ebi.c:1144
void EBI_ChipSelectEnable(uint32_t banks, bool enable)
Enable or disable EBI Chip Select.
Definition: em_ebi.c:383
bool readPrefetch
Definition: em_ebi.h:362
#define _EBI_ROUTE_LOCATION_MASK
Definition: efm32gg_ebi.h:516
#define _EBI_ADDRTIMING1_ADDRSETUP_MASK
Definition: efm32gg_ebi.h:530
void EBI_BankReadTimingSet(uint32_t bank, int setupCycles, int strobeCycles, int holdCycles)
Configure timing values of read bus accesses.
Definition: em_ebi.c:780
#define EBI_BANK0
Definition: em_ebi.h:75
#define _EBI_ROUTE_ALEPEN_SHIFT
Definition: efm32gg_ebi.h:415
#define _EBI_CTRL_BL2_MASK
Definition: efm32gg_ebi.h:235
#define _EBI_CTRL_BL1_SHIFT
Definition: efm32gg_ebi.h:229
int writeSetupCycles
Definition: em_ebi.h:367
#define _EBI_WRTIMING2_WRHOLD_MASK
Definition: efm32gg_ebi.h:718
#define _EBI_CTRL_ARDYEN_SHIFT
Definition: efm32gg_ebi.h:184
#define _EBI_RDTIMING_RDHOLD_SHIFT
Definition: efm32gg_ebi.h:282
#define _EBI_CTRL_ARDYTO1DIS_MASK
Definition: efm32gg_ebi.h:200
int addrHoldCycles
Definition: em_ebi.h:347
#define _EBI_POLARITY_WEPOL_SHIFT
Definition: efm32gg_ebi.h:350
#define EBI_CS3
Definition: em_ebi.h:83
void EBI_Init(const EBI_Init_TypeDef *ebiInit)
Configure and enable External Bus Interface.
Definition: em_ebi.c:60
#define _EBI_CTRL_NOIDLE3_SHIFT
Definition: efm32gg_ebi.h:179
#define _EBI_WRTIMING2_WRSTRB_MASK
Definition: efm32gg_ebi.h:714
#define _EBI_TFTHPORCH_HFPORCH_SHIFT
Definition: efm32gg_ebi.h:1180
#define _EBI_CTRL_BANK1EN_MASK
Definition: efm32gg_ebi.h:150
#define EBI_CTRL_ALTMAP
Definition: efm32gg_ebi.h:248
#define _EBI_TFTTIMING_DCLKPERIOD_SHIFT
Definition: efm32gg_ebi.h:1212
#define _EBI_TFTVPORCH_VSYNC_SHIFT
Definition: efm32gg_ebi.h:1196
void EBI_ReadTimingSet(int setupCycles, int strobeCycles, int holdCycles)
Configure timing values of read bus accesses.
Definition: em_ebi.c:474
#define _EBI_WRTIMING_WRSETUP_MASK
Definition: efm32gg_ebi.h:306
#define _EBI_RDTIMING3_RDSTRB_MASK
Definition: efm32gg_ebi.h:815
void EBI_BankWriteTimingConfig(uint32_t bank, bool writeBufDisable, bool halfWE)
Configure write operation parameters for selected bank.
Definition: em_ebi.c:845
EBI_AHigh_TypeDef aHigh
Definition: em_ebi.h:380
bool writeHalfWE
Definition: em_ebi.h:376
#define _EBI_ROUTE_APEN_MASK
Definition: efm32gg_ebi.h:447
#define _EBI_RDTIMING2_RDSTRB_MASK
Definition: efm32gg_ebi.h:683
#define _EBI_RDTIMING_RDSTRB_MASK
Definition: efm32gg_ebi.h:279
#define EBI_CTRL_BANK1EN
Definition: efm32gg_ebi.h:148
#define _EBI_RDTIMING3_RDSETUP_MASK
Definition: efm32gg_ebi.h:811
EBI_Polarity_TypeDef blPolarity
Definition: em_ebi.h:330
#define _EBI_TFTSIZE_VSZ_SHIFT
Definition: efm32gg_ebi.h:1168
#define _EBI_RDTIMING_RDSETUP_SHIFT
Definition: efm32gg_ebi.h:274
bool addrHalfALE
Definition: em_ebi.h:350
#define _EBI_CTRL_MODE3_MASK
Definition: efm32gg_ebi.h:132
#define _EBI_RDTIMING3_RDHOLD_MASK
Definition: efm32gg_ebi.h:819
#define _EBI_RDTIMING2_RDSETUP_MASK
Definition: efm32gg_ebi.h:679
int writeStrobeCycles
Definition: em_ebi.h:369
#define _EBI_TFTPOLARITY_CSPOL_SHIFT
Definition: efm32gg_ebi.h:1233
#define _EBI_CTRL_ARDYTO2DIS_MASK
Definition: efm32gg_ebi.h:210
bool ardyDisableTimeout
Definition: em_ebi.h:339
#define _EBI_TFTTIMING_TFTSTART_SHIFT
Definition: efm32gg_ebi.h:1216
EBI_Polarity_TypeDef rePolarity
Definition: em_ebi.h:325
#define _EBI_CTRL_MODE_SHIFT
Definition: efm32gg_ebi.h:95
bool readPageMode
Definition: em_ebi.h:360
#define _EBI_CTRL_ARDY3EN_SHIFT
Definition: efm32gg_ebi.h:214
#define _EBI_CTRL_BANK2EN_MASK
Definition: efm32gg_ebi.h:155
EBI_Polarity_TypeDef alePolarity
Definition: em_ebi.h:321
#define _EBI_CTRL_NOIDLE3_MASK
Definition: efm32gg_ebi.h:180
#define _EBI_CTRL_NOIDLE1_MASK
Definition: efm32gg_ebi.h:170
#define _EBI_CTRL_BL2_SHIFT
Definition: efm32gg_ebi.h:234
#define _EBI_CTRL_MODE3_SHIFT
Definition: efm32gg_ebi.h:131
#define EBI_CTRL_ITS
Definition: efm32gg_ebi.h:243
#define _EBI_RDTIMING_PREFETCH_SHIFT
Definition: efm32gg_ebi.h:292
#define _EBI_TFTTIMING_TFTSETUP_SHIFT
Definition: efm32gg_ebi.h:1220
#define EBI_MEM_BASE
uint32_t addressOffset
Definition: em_ebi.h:497
bool writeBufferDisable
Definition: em_ebi.h:374
#define EBI
#define _EBI_CTRL_ARDY1EN_MASK
Definition: efm32gg_ebi.h:195
#define _EBI_TFTVPORCH_VFPORCH_SHIFT
Definition: efm32gg_ebi.h:1200
void EBI_BankPolaritySet(uint32_t bank, EBI_Line_TypeDef line, EBI_Polarity_TypeDef polarity)
Configure EBI pin polarity for selected bank(s) for devices with individual timing support...
Definition: em_ebi.c:1050
#define _EBI_ADDRTIMING2_ADDRHOLD_MASK
Definition: efm32gg_ebi.h:666
#define _EBI_CTRL_BANK0EN_SHIFT
Definition: efm32gg_ebi.h:144
#define EBI_CTRL_BANK3EN
Definition: efm32gg_ebi.h:158
#define _EBI_WRTIMING2_WRSETUP_MASK
Definition: efm32gg_ebi.h:710
#define _EBI_RDTIMING_HALFRE_SHIFT
Definition: efm32gg_ebi.h:287
void EBI_Disable(void)
Disable External Bus Interface.
Definition: em_ebi.c:276
void EBI_BankAddressTimingSet(uint32_t bank, int setupCycles, int holdCycles)
Configure timing values of address latch bus accesses.
Definition: em_ebi.c:990
#define _EBI_TFTPOLARITY_DATAENPOL_SHIFT
Definition: efm32gg_ebi.h:1251
#define _EBI_ROUTE_CS3PEN_SHIFT
Definition: efm32gg_ebi.h:410
#define _EBI_CTRL_BL_SHIFT
Definition: efm32gg_ebi.h:224
#define _EBI_RDTIMING_RDSETUP_MASK
Definition: efm32gg_ebi.h:275
#define _EBI_POLARITY_ALEPOL_SHIFT
Definition: efm32gg_ebi.h:359
#define _EBI_RDTIMING1_RDSETUP_MASK
Definition: efm32gg_ebi.h:547
#define _EBI_CTRL_MODE2_MASK
Definition: efm32gg_ebi.h:120
__STATIC_INLINE void BUS_RegBitWrite(volatile uint32_t *addr, unsigned int bit, unsigned int val)
Perform a single-bit write operation on a peripheral register.
Definition: em_bus.h:146
#define _EBI_WRTIMING1_WRHOLD_MASK
Definition: efm32gg_ebi.h:586
#define _EBI_CTRL_BANK0EN_MASK
Definition: efm32gg_ebi.h:145
#define _EBI_ADDRTIMING2_ADDRSETUP_MASK
Definition: efm32gg_ebi.h:662
EBI_Polarity_TypeDef dataenPolarity
Definition: em_ebi.h:475
#define _EBI_RDTIMING1_RDSTRB_MASK
Definition: efm32gg_ebi.h:551
#define _EBI_WRTIMING_WRSTRB_MASK
Definition: efm32gg_ebi.h:310
#define _EBI_WRTIMING_HALFWE_SHIFT
Definition: efm32gg_ebi.h:318
#define _EBI_WRTIMING_WBUFDIS_SHIFT
Definition: efm32gg_ebi.h:323
#define _EBI_CTRL_BANK1EN_SHIFT
Definition: efm32gg_ebi.h:149
void EBI_BankReadTimingConfig(uint32_t bank, bool pageMode, bool prefetch, bool halfRE)
Configure read operation parameters for selected bank.
Definition: em_ebi.c:731
void EBI_TFTSizeSet(uint32_t horizontal, uint32_t vertical)
Configure and initialize TFT size settings.
Definition: em_ebi.c:629
void EBI_TFTTimingSet(int dclkPeriod, int start, int setup, int hold)
Configure TFT Direct Drive Timing Settings.
Definition: em_ebi.c:700
void EBI_TFTVPorchSet(int front, int back, int pulseWidth)
Configure Vertical Porch Settings.
Definition: em_ebi.c:672
#define _EBI_CTRL_BL1_MASK
Definition: efm32gg_ebi.h:230
#define _EBI_ADDRTIMING1_ADDRHOLD_MASK
Definition: efm32gg_ebi.h:534
#define _EBI_TFTSIZE_HSZ_SHIFT
Definition: efm32gg_ebi.h:1164
#define _EBI_WRTIMING1_WRSTRB_MASK
Definition: efm32gg_ebi.h:582
#define _EBI_CTRL_NOIDLE2_MASK
Definition: efm32gg_ebi.h:175
EBI_Polarity_TypeDef wePolarity
Definition: em_ebi.h:323
#define _EBI_RDTIMING_RDSTRB_SHIFT
Definition: efm32gg_ebi.h:278
void EBI_TFTInit(const EBI_TFTInit_TypeDef *ebiTFTInit)
Configure and initialize TFT Direct Drive.
Definition: em_ebi.c:569
#define _EBI_CTRL_BL_MASK
Definition: efm32gg_ebi.h:225
#define _EBI_CTRL_ARDYTO3DIS_SHIFT
Definition: efm32gg_ebi.h:219
EBI_Polarity_TypeDef ardyPolarity
Definition: em_ebi.h:319
#define EBI_CS0
Definition: em_ebi.h:80
#define _EBI_TFTPOLARITY_VSYNCPOL_SHIFT
Definition: efm32gg_ebi.h:1269
#define _EBI_CTRL_ARDY1EN_SHIFT
Definition: efm32gg_ebi.h:194
void EBI_BankAddressTimingConfig(uint32_t bank, bool halfALE)
Configure address operation parameters for selected bank.
Definition: em_ebi.c:952
#define EBI_CTRL_BANK2EN
Definition: efm32gg_ebi.h:153
#define _EBI_ADDRTIMING_ADDRHOLD_MASK
Definition: efm32gg_ebi.h:262
#define _EBI_CTRL_ARDY3EN_MASK
Definition: efm32gg_ebi.h:215
uint32_t banks
Definition: em_ebi.h:341
#define _EBI_ROUTE_CS1PEN_SHIFT
Definition: efm32gg_ebi.h:400