Changeset d374492 in rtems


Ignore:
Timestamp:
Jul 21, 2009, 8:38:04 AM (10 years ago)
Author:
Thomas Doerfler <Thomas.Doerfler@…>
Branches:
4.10, 4.11, master
Children:
68799a2a
Parents:
115971c
Message:

Update for MPC55XX changes

Location:
c/src/lib
Files:
5 added
20 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/powerpc/mpc55xxevb/ChangeLog

    r115971c rd374492  
     12009-07-20      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * clock/clock-config.c, include/smsc9218i.h, network/smsc9218i.c: New
     4        files.
     5        * network/network.c: Removed file.
     6        * Makefile.am, README, bsp_specs, preinstall.am, include/bsp.h,
     7        startup/bspstart.c, startup/sd-card-init.c, tests/tests.c: Changes
     8        throughout.
     9
    1102009-07-16      Joel Sherrill <joel.sherrill@oarcorp.com>
    211
  • c/src/lib/libbsp/powerpc/mpc55xxevb/Makefile.am

    r115971c rd374492  
    3737include_bsp_HEADERS = include/mpc55xxevb.h \
    3838    include/irq-config.h \
     39    include/smsc9218i.h \
    3940    ../../shared/include/irq-generic.h \
     41    ../../shared/include/irq-info.h \
     42    ../../shared/include/utility.h \
    4043    ../shared/include/tictac.h
    4144
     
    4649
    4750# clock
    48 libbsp_a_SOURCES += ../shared/clock/clock.c
     51libbsp_a_SOURCES += clock/clock-config.c
    4952
    5053# irq_generic
    5154libbsp_a_SOURCES += ../../shared/src/irq-generic.c \
    52     ../../shared/src/irq-legacy.c
     55    ../../shared/src/irq-legacy.c \
     56    ../../shared/src/irq-info.c \
     57    ../../shared/src/irq-shell.c
    5358
    5459# tests
     
    6166if HAS_NETWORKING
    6267noinst_PROGRAMS += network.rel
    63 network_rel_SOURCES = network/network.c
     68network_rel_SOURCES = network/smsc9218i.c
    6469network_rel_CPPFLAGS = $(AM_CPPFLAGS) -D__INSIDE_RTEMS_BSD_TCPIP_STACK__ -D__BSD_VISIBLE
    6570network_rel_LDFLAGS = $(RTEMS_RELLDFLAGS)
     
    7479    ../../../libcpu/@RTEMS_CPU@/@RTEMS_CPU_MODEL@/irq.rel \
    7580    ../../../libcpu/@RTEMS_CPU@/@RTEMS_CPU_MODEL@/edma.rel \
     81    ../../../libcpu/@RTEMS_CPU@/@RTEMS_CPU_MODEL@/emios.rel \
    7682    ../../../libcpu/@RTEMS_CPU@/@RTEMS_CPU_MODEL@/dspi.rel \
    7783    ../../../libcpu/@RTEMS_CPU@/@RTEMS_CPU_MODEL@/esci.rel \
  • c/src/lib/libbsp/powerpc/mpc55xxevb/README

    r115971c rd374492  
    99COPROCESSORS:       N/A
    1010MODE:               32 bit mode
    11 DEBUG MONITOR:      BAM
    1211
    1312PERIPHERALS
     
    2221SCSI:               N/A
    2322NETWORKING:         FEC (not yet supported)
     23                    SMSC9218I (external)
    2424SPI:                DSPI
    2525
     
    2727==================
    2828
    29 CLOCK DRIVER:       Book E decrementer
     29CLOCK DRIVER:       EMIOS channel 23
    3030IOSUPP DRIVER:      N/A
    3131SHMSUPP:            N/A
     
    4848BUS WIDTH:          32 bit Flash, 32 bit SDRAM
    4949FLASH:              3 MByte
    50 RAM:                128 kByte SDRAM
     50INTERNAL RAM:       128 kByte SDRAM
    5151EXTERNAL RAM:       512 kByte SDRAM
    5252
  • c/src/lib/libbsp/powerpc/mpc55xxevb/bsp_specs

    r115971c rd374492  
    55*startfile:
    66%{!qrtems: %(old_startfile)} \
    7 %{!nostdlib: %{qrtems: ecrti%O%s rtems_crti%O%s start.o%s}}
     7%{!nostdlib: %{qrtems: ecrti%O%s rtems_crti%O%s crtbegin.o%s start.o%s}}
    88
    99*endfile:
    10 %{!qrtems: %(old_endfile)} %{qrtems: ecrtn.o%s}
     10%{!qrtems: %(old_endfile)} %{qrtems: crtend.o%s ecrtn.o%s}
    1111
    1212*link:
  • c/src/lib/libbsp/powerpc/mpc55xxevb/include/bsp.h

    r115971c rd374492  
    4444extern uint32_t bsp_clicks_per_usec;
    4545
    46 rtems_status_code mpc55xx_sd_card_init( void);
     46rtems_status_code mpc55xx_sd_card_init( bool mount);
     47
     48/* Network driver configuration */
     49
     50struct rtems_bsdnet_ifconfig;
     51
     52int smsc9218i_attach_detach(
     53  struct rtems_bsdnet_ifconfig *config,
     54  int attaching
     55);
     56
     57#define RTEMS_BSP_NETWORK_DRIVER_ATTACH smsc9218i_attach_detach
     58
     59#define RTEMS_BSP_NETWORK_DRIVER_NAME "eth0"
    4760
    4861#endif /* ASM */
  • c/src/lib/libbsp/powerpc/mpc55xxevb/preinstall.am

    r115971c rd374492  
    8686PREINSTALL_FILES += $(PROJECT_INCLUDE)/bsp/irq-config.h
    8787
     88$(PROJECT_INCLUDE)/bsp/smsc9218i.h: include/smsc9218i.h $(PROJECT_INCLUDE)/bsp/$(dirstamp)
     89        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/bsp/smsc9218i.h
     90PREINSTALL_FILES += $(PROJECT_INCLUDE)/bsp/smsc9218i.h
     91
    8892$(PROJECT_INCLUDE)/bsp/irq-generic.h: ../../shared/include/irq-generic.h $(PROJECT_INCLUDE)/bsp/$(dirstamp)
    8993        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/bsp/irq-generic.h
    9094PREINSTALL_FILES += $(PROJECT_INCLUDE)/bsp/irq-generic.h
     95
     96$(PROJECT_INCLUDE)/bsp/irq-info.h: ../../shared/include/irq-info.h $(PROJECT_INCLUDE)/bsp/$(dirstamp)
     97        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/bsp/irq-info.h
     98PREINSTALL_FILES += $(PROJECT_INCLUDE)/bsp/irq-info.h
     99
     100$(PROJECT_INCLUDE)/bsp/utility.h: ../../shared/include/utility.h $(PROJECT_INCLUDE)/bsp/$(dirstamp)
     101        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/bsp/utility.h
     102PREINSTALL_FILES += $(PROJECT_INCLUDE)/bsp/utility.h
    91103
    92104$(PROJECT_INCLUDE)/bsp/tictac.h: ../shared/include/tictac.h $(PROJECT_INCLUDE)/bsp/$(dirstamp)
  • c/src/lib/libbsp/powerpc/mpc55xxevb/startup/bspstart.c

    r115971c rd374492  
    9393static void mpc55xx_ebi_init()
    9494{
    95         struct EBI_CS_tag cs = { BR : MPC55XX_ZERO_FLAGS, OR : MPC55XX_ZERO_FLAGS };
     95        struct EBI_CS_tag cs = { .BR = MPC55XX_ZERO_FLAGS, .OR = MPC55XX_ZERO_FLAGS };
    9696        union SIU_PCR_tag pcr = MPC55XX_ZERO_FLAGS;
     97        struct MMU_tag mmu = MMU_DEFAULT;
    9798        int i = 0;
    9899
    99         /* External SRAM (0 wait states, 512kB, 4 word burst) */
     100        /* ADDR [8 : 31] */
     101        for (i = 4; i < 4 + 24; ++i) {
     102                SIU.PCR [i].R = 0x440;
     103        }
     104
     105        /* DATA [0 : 15] */
     106        for (i = 28; i < 28 + 16; ++i) {
     107                SIU.PCR [i].R = 0x440;
     108        }
     109
     110        /* RD_!WR */
     111        SIU.PCR [62].R = 0x443;
     112
     113        /* !BDIP */
     114        SIU.PCR [63].R = 0x443;
     115
     116        /* !WE [0 : 3] */
     117        for (i = 64; i < 64 + 4; ++i) {
     118                SIU.PCR [i].R = 0x443;
     119        }
     120
     121        /* !OE */
     122        SIU.PCR [68].R = 0x443;
     123
     124        /* !TS */
     125        SIU.PCR [69].R = 0x443;
     126
     127        /* External SRAM (2 wait states, 512kB, 4 word burst) */
     128
    100129        cs.BR.B.BA = 0;
    101130        cs.BR.B.PS = 1;
     
    115144        SIU.PCR [0].R = 0x443;
    116145
    117         /* ADDR [8 : 31] */
    118         for (i = 4; i < 4 + 24; ++i) {
    119                 SIU.PCR [i].R = 0x440;
    120         }
    121 
    122         /* DATA [0 : 15] */
    123         for (i = 28; i < 28 + 16; ++i) {
    124                 SIU.PCR [i].R = 0x440;
    125         }
    126 
    127         /* RD_!WR */
    128         SIU.PCR [62].R = 0x443;
    129 
    130         /* !BDIP */
    131         SIU.PCR [63].R = 0x443;
    132 
    133         /* !WE [0 : 3] */
    134         for (i = 64; i < 64 + 4; ++i) {
    135                 SIU.PCR [i].R = 0x443;
    136         }
    137 
    138         /* !OE */
    139         SIU.PCR [68].R = 0x443;
    140 
    141         /* !TS */
    142         SIU.PCR [69].R = 0x443;
     146        /* External Ethernet Controller (3 wait states, 64kB) */
     147
     148        mmu.MAS0.B.ESEL = 5;
     149        mmu.MAS1.B.VALID = 1;
     150        mmu.MAS1.B.IPROT = 1;
     151        mmu.MAS1.B.TSIZ = 1;
     152        mmu.MAS2.B.EPN = 0x3fff8;
     153        mmu.MAS2.B.I = 1;
     154        mmu.MAS2.B.G = 1;
     155        mmu.MAS3.B.RPN = 0x3fff8;
     156        mmu.MAS3.B.UW = 1;
     157        mmu.MAS3.B.SW = 1;
     158        mmu.MAS3.B.UR = 1;
     159        mmu.MAS3.B.SR = 1;
     160
     161        PPC_SET_SPECIAL_PURPOSE_REGISTER( FREESCALE_EIS_MAS0, mmu.MAS0.R);
     162        PPC_SET_SPECIAL_PURPOSE_REGISTER( FREESCALE_EIS_MAS1, mmu.MAS1.R);
     163        PPC_SET_SPECIAL_PURPOSE_REGISTER( FREESCALE_EIS_MAS2, mmu.MAS2.R);
     164        PPC_SET_SPECIAL_PURPOSE_REGISTER( FREESCALE_EIS_MAS3, mmu.MAS3.R);
     165
     166        asm volatile ("tlbwe");
     167
     168        cs.BR.B.BA = 0x7fff;
     169        cs.BR.B.PS = 1;
     170        cs.BR.B.BL = 0;
     171        cs.BR.B.WEBS = 0;
     172        cs.BR.B.TBDIP = 0;
     173        cs.BR.B.BI = 1;
     174        cs.BR.B.V = 1;
     175
     176        cs.OR.B.AM = 0x1ffff;
     177        cs.OR.B.SCY = 1;
     178        cs.OR.B.BSCY = 0;
     179
     180        EBI.CS [3] = cs;
     181
     182        /* !CS [3] */
     183        SIU.PCR [3].R = 0x443;
    143184}
    144185
     
    199240        }
    200241       
    201         RTEMS_DEBUG_PRINT( "BSP start done\n");
     242        /* Initialize eMIOS */
     243        mpc55xx_emios_initialize( 1);
    202244
    203245        return;
  • c/src/lib/libbsp/powerpc/mpc55xxevb/startup/sd-card-init.c

    r115971c rd374492  
    1919 */
    2020
    21 #include  <stdio.h>
     21#include <stdio.h>
    2222
    2323#include <mpc55xx/mpc55xx.h>
     
    2525#include <mpc55xx/dspi.h>
    2626
    27 #include <libchip/spi-sd-card.h>
    28 
    29 #define DEBUG
     27#include <bsp.h>
    3028
    3129#include <rtems/status-checks.h>
    32 
    33 #include <bsp.h>
    3430
    3531static rtems_status_code mpc55xx_dspi_init(void)
     
    8985}
    9086
    91 #include <sys/types.h>
    92 #include <sys/stat.h>
    93 #include <unistd.h>
    94 #include <fcntl.h>
    95 #include <dirent.h>
    9687#include <stdio.h>
    9788#include <rtems/fsmount.h>
    9889#include <rtems/dosfs.h>
    99 #include <rtems/ide_part_table.h>
     90#include <rtems/bdpart.h>
    10091#include <rtems/console.h>
     92
     93#include <libchip/spi-sd-card.h>
    10194
    10295#define MPC55XX_DEVICE "sd-card-a"
     
    118111};
    119112
    120 #define SD_CARD_NUMBER 1
    121 
    122 sd_card_driver_entry sd_card_driver_table [SD_CARD_NUMBER] = { {
    123 #if 0
    124                 .driver = {
    125                         .ops = &sd_card_driver_ops,
    126                         .size = sizeof( sd_card_driver_entry)
    127                 },
    128                 .table_index = 0,
    129                 .minor = 0,
    130 #endif
    131                 .device_name = "sd-card-a",
    132 #if 0
    133                 .disk_device_name = "/dev/sd-card-a",
    134 #endif
     113sd_card_driver_entry sd_card_driver_table [] = {
     114        {
     115                .device_name = "/dev/sd-card-a",
     116                .bus = 0,
    135117                .transfer_mode = SD_CARD_TRANSFER_MODE_DEFAULT,
    136118                .command = SD_CARD_COMMAND_DEFAULT,
     
    141123                .block_size = 0,
    142124                .block_size_shift = 0,
    143                 .busy = 1,
    144                 .verbose = 1,
    145                 .schedule_if_busy = 0,
     125                .busy = true,
     126                .verbose = true,
     127                .schedule_if_busy = false
    146128        }
    147129};
    148130
    149 rtems_status_code mpc55xx_sd_card_init(void)
     131size_t sd_card_driver_table_size = sizeof( sd_card_driver_table) / sizeof( sd_card_driver_table [0]);
     132
     133rtems_status_code mpc55xx_sd_card_init( bool mount)
    150134{
    151135        rtems_status_code sc = RTEMS_SUCCESSFUL;
     
    158142        RTEMS_CHECK_SC( rv, "Intitalize DSPI bus");
    159143
    160         rv = rtems_libi2c_register_drv( e->device_name, (rtems_libi2c_drv_t *) e, mpc55xx_dspi_bus_table [0].bus_number, 0);
    161         RTEMS_CHECK_RV_SC( rv, "Register SD Card driver");
     144        e->bus = mpc55xx_dspi_bus_table [0].bus_number;
    162145
    163         sc = rtems_ide_part_table_initialize( MPC55XX_DEVICE_FILE);
    164         RTEMS_CHECK_SC( sc, "Initialize IDE partition table");
     146        sc = sd_card_register();
     147        RTEMS_CHECK_SC( sc, "Register SD Card");
    165148
    166         rv = mkdir( MPC55XX_MOUNT_POINT, S_IRWXU);
    167         RTEMS_CHECK_RV_SC( rv, "Create mount point");
     149        if (mount) {
     150                sc = rtems_bdpart_register_from_disk( MPC55XX_DEVICE_FILE);
     151                RTEMS_CHECK_SC( sc, "Initialize IDE partition table");
    168152
    169         rv = rtems_fsmount( mpc55xx_fs_table, sizeof( mpc55xx_fs_table) / sizeof( mpc55xx_fs_table [0]), NULL);
    170         RTEMS_CHECK_RV_SC( rv, "Mount file systems");
     153                rv = rtems_fsmount( mpc55xx_fs_table, sizeof( mpc55xx_fs_table) / sizeof( mpc55xx_fs_table [0]), NULL);
     154                RTEMS_CHECK_RV_SC( rv, "Mount file systems");
     155        }
    171156
    172157        return RTEMS_SUCCESSFUL;
  • c/src/lib/libbsp/powerpc/mpc55xxevb/tests/tests.c

    r115971c rd374492  
    3737#include <libcpu/powerpc-utility.h>
    3838
    39 /* #define DEBUG */
    40 
    4139#include <rtems/status-checks.h>
    4240
     
    217215
    218216        printk( "Boot time: %u\n", ppc_time_base());
     217
     218        /*
    219219        test_mpc55xx_intc( 0);
     220        */
    220221
    221222        rv = rtems_libi2c_initialize();
     
    269270                rtems_build_name ( 'P', 'I', 'N', 'G'),
    270271                1,
    271                 RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
     272                RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
    272273                RTEMS_NO_PRIORITY,
    273274                &test_mpc55xx_dspi_ping
     
    278279                rtems_build_name ( 'P', 'O', 'N', 'G'),
    279280                0,
    280                 RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
     281                RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
    281282                RTEMS_NO_PRIORITY,
    282283                &test_mpc55xx_dspi_pong
     
    326327        RTEMS_CHECK_SC( sc, "rtems_task_start");
    327328
     329        return RTEMS_SUCCESSFUL;
     330
    328331        rtems_id intc_id;
    329332        sc = rtems_task_create(
     
    339342        RTEMS_CHECK_SC( sc, "rtems_task_start");
    340343
    341         sc = rtems_task_delete( RTEMS_SELF);
    342         RTEMS_CHECK_SC( sc, "rtems_task_delete");
    343 
    344344        return RTEMS_SUCCESSFUL;
    345345}
     346
     347#if 0
    346348
    347349#include <sys/types.h>
     
    422424}
    423425
    424 #define SD_CARD_NUMBER 1
    425 
    426 static sd_card_driver_entry sd_card_driver_table_XXX [SD_CARD_NUMBER] = { {
    427 #if 0
    428                 driver : {
    429                         ops : &sd_card_driver_ops,
    430                         size : sizeof( sd_card_driver_entry)
    431                 },
    432                 table_index : 0,
    433                 minor : 0,
    434 #endif
    435                 device_name : "sd-card-a",
    436 #if 0
    437                 disk_device_name : "/dev/sd-card-a",
    438 #endif
    439                 transfer_mode : SD_CARD_TRANSFER_MODE_DEFAULT,
    440                 command : SD_CARD_COMMAND_DEFAULT,
    441                 /* response : whatever, */
    442                 response_index : SD_CARD_COMMAND_SIZE,
    443                 n_ac_max : SD_CARD_N_AC_MAX_DEFAULT,
    444                 block_number : 0,
    445                 block_size : 0,
    446                 block_size_shift : 0,
    447                 busy : 1,
    448                 verbose : 1,
    449                 schedule_if_busy : 0,
    450         }
    451 };
    452 
    453426rtems_task test_sd_card( rtems_task_argument arg)
    454427{
     
    485458        RTEMS_CHECK_SC_TASK( sc, "Initialize IDE partition table");
    486459
     460        rv = mkdir( TEST_SD_CARD_MOUNT_POINT, S_IRWXU);
     461        RTEMS_CHECK_RV_TASK( rv, "Create mount point");
     462
     463        rv = rtems_fsmount( test_sd_card_fs_table, sizeof( test_sd_card_fs_table) / sizeof( test_sd_card_fs_table [0]), NULL);
     464        RTEMS_CHECK_RV_TASK( rv, "Mount file systems");
     465
    487466        rv = test_sd_card_print_dir( "/dev", 0);
    488467        RTEMS_CHECK_RV_TASK( rv, "Print directory");
    489468
    490         rv = mkdir( TEST_SD_CARD_MOUNT_POINT, S_IRWXU);
    491         RTEMS_CHECK_RV_TASK( rv, "Create mount point");
    492 
    493         rv = rtems_fsmount( test_sd_card_fs_table, sizeof( test_sd_card_fs_table) / sizeof( test_sd_card_fs_table [0]), NULL);
    494         RTEMS_CHECK_RV_TASK( rv, "Mount file systems");
    495 
    496         /*rv = test_sd_card_print_dir( TEST_SD_CARD_MOUNT_POINT, 0); */
    497         /*RTEMS_CHECK_RV_TASK( rv, "Print directory"); */
     469        rv = test_sd_card_print_dir( TEST_SD_CARD_MOUNT_POINT, 0);
     470        RTEMS_CHECK_RV_TASK( rv, "Print directory");
     471
     472        (void) rtems_task_delete( RTEMS_SELF);
    498473
    499474        rv = mkdir( TEST_SD_CARD_DIRECTORY, S_IRWXU);
     
    524499        RTEMS_CHECK_RV_TASK( rv, "Print directory");
    525500
     501        (void) rtems_task_delete( RTEMS_SELF);
     502
    526503
    527504        #if 0
     
    562539        #endif
    563540
    564         sc = rtems_task_delete( RTEMS_SELF);
    565         RTEMS_CHECK_SC_TASK( sc, "rtems_task_delete");
    566 }
     541        (void) rtems_task_delete( RTEMS_SELF);
     542}
     543
     544#endif
    567545
    568546#define ITER 4
     
    572550static char outbuf [BUFSIZE];
    573551
     552static void test_mpc55xx_edma_done( mpc55xx_edma_channel_entry *e, uint32_t error_status)
     553{
     554        rtems_semaphore_release( e->id);
     555
     556        if (error_status != 0) {
     557                printk( "%s: Error status: 0x%08x\n", __func__, error_status);
     558        }
     559}
     560
    574561static rtems_status_code test_mpc55xx_edma(void)
    575562{
    576563        rtems_status_code sc = RTEMS_SUCCESSFUL;
    577         int rv = 0;
    578         int channel = 0;
    579         uint32_t error_status = 0;
    580         rtems_id transfer_update;
     564        mpc55xx_edma_channel_entry e = {
     565                .channel = 0,
     566                .done = test_mpc55xx_edma_done,
     567                .id = RTEMS_ID_NONE
     568        };
    581569
    582570        sc = rtems_semaphore_create (
    583571                rtems_build_name ( 'T', 'S', 'T', 'C'),
    584572                0,
    585                 RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
     573                RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
    586574                RTEMS_NO_PRIORITY,
    587                 &transfer_update
     575                &e.id
    588576        );
    589577        RTEMS_CHECK_SC( sc, "rtems_semaphore_create");
    590578
    591         rv = mpc55xx_edma_obtain_channel( channel, &error_status, transfer_update);
    592         RTEMS_CHECK_RV( rv, "mpc55xx_edma_obtain_channel");
     579        sc = mpc55xx_edma_obtain_channel( &e);
     580        RTEMS_CHECK_RV( sc, "mpc55xx_edma_obtain_channel");
    593581
    594582        int i = 0;
     
    600588        rtems_cache_flush_multiple_data_lines( outbuf, BUFSIZE);
    601589
    602         struct tcd_t tcd = MPC55XX_EDMA_TCD_DEFAULT;
     590        struct tcd_t tcd = EDMA_TCD_DEFAULT;
    603591        tcd.SADDR = (uint32_t) &inbuf;
    604592        tcd.DADDR = (uint32_t) &outbuf;
    605593        tcd.NBYTES = BUFSIZE / ITER;
    606594        tcd.SLAST = -BUFSIZE;
    607         tcd.CITER = ITER;
    608         tcd.BITER = ITER;
    609         tcd.INT_HALF = 1;
    610 
    611         EDMA.TCD [channel] = tcd;
     595        tcd.CDF.B.CITER = ITER;
     596        tcd.BMF.B.BITER = ITER;
     597        tcd.BMF.B.INT_HALF = 1;
     598
     599        EDMA.TCD [e.channel] = tcd;
    612600
    613601        while (1) {
    614602                while (1) {
    615                         if (EDMA.TCD [channel].DONE == 1) {
    616                                 EDMA.TCD [channel].DONE = 0;
     603                        if (EDMA.TCD [e.channel].BMF.B.DONE == 1) {
     604                                EDMA.TCD [e.channel].BMF.B.DONE = 0;
    617605                                printk( "%s: Done\n", __func__);
    618606                                break;
    619                         } else if (EDMA.TCD [channel].ACTIVE == 0) {
    620                                 EDMA.SSBR.R = channel;
    621                                 printk( "%s: Start: %i (%i)\n", __func__, EDMA.TCD [channel].CITER, EDMA.TCD [channel].BITER);
     607                        } else if (EDMA.TCD [e.channel].BMF.B.ACTIVE == 0) {
     608                                EDMA.SSBR.R = e.channel;
     609                                printk( "%s: Start: %i (%i)\n", __func__, EDMA.TCD [e.channel].CDF.B.CITER, EDMA.TCD [e.channel].BMF.B.BITER);
    622610                        }
    623                         sc = rtems_semaphore_obtain( transfer_update, RTEMS_WAIT, 10);
     611                        sc = rtems_semaphore_obtain( e.id, RTEMS_WAIT, 10);
    624612                        if (sc == RTEMS_TIMEOUT) {
    625613                                continue;
     
    627615                        RTEMS_CHECK_SC( sc, "rtems_semaphore_obtain");
    628616                }
    629                 printk( "%s: Error status: 0x%08x\n", __func__, error_status);
    630         }
    631 
    632         return sc;
    633 }
     617        }
     618
     619        return RTEMS_SUCCESSFUL;
     620}
     621
     622#include <stdlib.h>
    634623
    635624static unsigned test_mpc55xx_intc_counter = 0;
     
    668657static rtems_task test_mpc55xx_intc( rtems_task_argument arg)
    669658{
     659        rtems_status_code sc = RTEMS_SUCCESSFUL;
     660        rtems_irq_connect_data e = {
     661                .on = NULL,
     662                .off = NULL,
     663                .isOn = NULL
     664        };
    670665        volatile int i = 0;
    671666        int p = 0;
    672667        unsigned s = 0;
    673         rtems_irq_connect_data e;
    674         rtems_status_code sc = RTEMS_SUCCESSFUL;
    675668
    676669        for (i = MPC55XX_IRQ_SOFTWARE_MIN, p = MPC55XX_INTC_MIN_PRIORITY; i <= MPC55XX_IRQ_SOFTWARE_MAX; ++i, ++p) {
     
    685678
    686679                e.hdl = test_mpc55xx_intc_handler_2;
    687                 if (BSP_install_rtems_shared_irq_handler( &e) != RTEMS_SUCCESSFUL) {
     680                if (BSP_install_rtems_shared_irq_handler( &e) != 1) {
    688681                        BSP_panic( "Handler install 2 failed");
    689682                }
    690683
    691684                e.hdl = test_mpc55xx_intc_handler_3;
    692                 if (BSP_install_rtems_shared_irq_handler( &e) != RTEMS_SUCCESSFUL) {
     685                if (BSP_install_rtems_shared_irq_handler( &e) != 1) {
    693686                        BSP_panic( "Handler install 3 failed");
    694687                }
  • c/src/lib/libcpu/powerpc/ChangeLog

    r115971c rd374492  
     12009-07-20      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * Makefile.am, preinstall.am: Update for MPC55XX changes.
     4        * mpc55xx/emios/emios.c, mpc55xx/include/emios.h: New files.
     5        * mpc55xx/dspi/dspi.c, mpc55xx/edma/edma.c, mpc55xx/esci/esci.c,
     6        mpc55xx/include/dspi.h, mpc55xx/include/edma.h, mpc55xx/include/irq.h,
     7        mpc55xx/include/regs.h, mpc55xx/irq/irq.c: Changes throughout.
     8
    192009-05-05      Jennifer Averett <jennifer.averett@OARcorp.com>
    210
  • c/src/lib/libcpu/powerpc/Makefile.am

    r115971c rd374492  
    420420        mpc55xx/include/dspi.h \
    421421        mpc55xx/include/edma.h \
     422        mpc55xx/include/emios.h \
    422423        mpc55xx/include/mpc55xx.h \
    423424        mpc55xx/include/esci.h \
     
    434435mpc55xx_fec_rel_LDFLAGS = $(RTEMS_RELLDFLAGS)
    435436
    436 # EMDA
     437# eDMA
    437438noinst_PROGRAMS += mpc55xx/edma.rel
    438439mpc55xx_edma_rel_SOURCES = mpc55xx/edma/edma.c
    439440mpc55xx_edma_rel_LDFLAGS = $(RTEMS_RELLDFLAGS)
    440441
    441 # ESCI
     442# eMIOS
     443noinst_PROGRAMS += mpc55xx/emios.rel
     444mpc55xx_emios_rel_SOURCES = mpc55xx/emios/emios.c
     445mpc55xx_emios_rel_LDFLAGS = $(RTEMS_RELLDFLAGS)
     446
     447# eSCI
    442448noinst_PROGRAMS += mpc55xx/esci.rel
    443449mpc55xx_esci_rel_SOURCES = mpc55xx/esci/esci.c
  • c/src/lib/libcpu/powerpc/mpc55xx/dspi/dspi.c

    r115971c rd374492  
    2121#include <mpc55xx/regs.h>
    2222#include <mpc55xx/dspi.h>
    23 #include <mpc55xx/edma.h>
    2423#include <mpc55xx/mpc55xx.h>
    2524
     
    112111};
    113112
     113static void mpc55xx_dspi_edma_done( mpc55xx_edma_channel_entry *e, uint32_t error_status)
     114{
     115        rtems_semaphore_release( e->id);
     116
     117        if (error_status != 0) {
     118                RTEMS_SYSLOG_ERROR( "eDMA error: 0x%08x\n", error_status);
     119        }
     120}
     121
    114122static mpc55xx_dspi_baudrate_scaler_entry mpc55xx_dspi_search_baudrate_scaler( uint32_t scaler, int min, int mid, int max)
    115123{
     
    152160        union DSPI_CTAR_tag ctar = MPC55XX_ZERO_FLAGS;
    153161        union DSPI_RSER_tag rser = MPC55XX_ZERO_FLAGS;
    154         struct tcd_t tcd_push = MPC55XX_EDMA_TCD_DEFAULT;
     162        struct tcd_t tcd_push = EDMA_TCD_DEFAULT;
    155163        int i = 0;
    156164
     
    159167                rtems_build_name ( 'S', 'P', 'I', 'R'),
    160168                0,
    161                 RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
    162                 RTEMS_NO_PRIORITY,
    163                 &e->edma_channel_receive_update
     169                RTEMS_SIMPLE_BINARY_SEMAPHORE,
     170                0,
     171                &e->edma_receive.id
    164172        );
    165         RTEMS_CHECK_SC( sc, "Create receive update semaphore");
    166 
    167         sc = mpc55xx_edma_obtain_channel( e->edma_channel_receive, &e->edma_channel_receive_error, e->edma_channel_receive_update);
    168         RTEMS_CHECK_SC( sc, "Obtain receive eDMA channel");
     173        RTEMS_CHECK_SC( sc, "create receive update semaphore");
     174
     175        sc = mpc55xx_edma_obtain_channel( &e->edma_receive);
     176        RTEMS_CHECK_SC( sc, "obtain receive eDMA channel");
    169177
    170178        /* eDMA transmit */
     
    172180                rtems_build_name ( 'S', 'P', 'I', 'T'),
    173181                0,
    174                 RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
    175                 RTEMS_NO_PRIORITY,
    176                 &e->edma_channel_transmit_update
     182                RTEMS_SIMPLE_BINARY_SEMAPHORE,
     183                0,
     184                &e->edma_transmit.id
    177185        );
    178         RTEMS_CHECK_SC( sc, "Create transmit update semaphore");
    179 
    180         sc = mpc55xx_edma_obtain_channel( e->edma_channel_transmit, &e->edma_channel_transmit_error, e->edma_channel_transmit_update);
    181         RTEMS_CHECK_SC( sc, "Obtain transmit eDMA channel");
    182 
    183         sc = mpc55xx_edma_obtain_channel( e->edma_channel_push, NULL, RTEMS_ID_NONE);
    184         RTEMS_CHECK_SC( sc, "Obtain push eDMA channel");
     186        RTEMS_CHECK_SC( sc, "create transmit update semaphore");
     187
     188        sc = mpc55xx_edma_obtain_channel( &e->edma_transmit);
     189        RTEMS_CHECK_SC( sc, "obtain transmit eDMA channel");
     190
     191        sc = mpc55xx_edma_obtain_channel( &e->edma_push);
     192        RTEMS_CHECK_SC( sc, "obtain push eDMA channel");
    185193
    186194        tcd_push.SADDR = mpc55xx_dspi_push_data_address( e);
    187         tcd_push.SSIZE = 2;
    188         tcd_push.SOFF = 0;
     195        tcd_push.SDF.B.SSIZE = 2;
     196        tcd_push.SDF.B.SOFF = 0;
    189197        tcd_push.DADDR = (uint32_t) &e->regs->PUSHR.R;
    190         tcd_push.DSIZE = 2;
    191         tcd_push.DOFF = 0;
     198        tcd_push.SDF.B.DSIZE = 2;
     199        tcd_push.CDF.B.DOFF = 0;
    192200        tcd_push.NBYTES = 4;
    193         tcd_push.CITER = 1;
    194         tcd_push.BITER = 1;
    195 
    196         EDMA.TCD [e->edma_channel_push] = tcd_push;
     201        tcd_push.CDF.B.CITER = 1;
     202        tcd_push.BMF.B.BITER = 1;
     203
     204        EDMA.TCD [e->edma_push.channel] = tcd_push;
    197205
    198206        /* Module Control Register */
     
    325333        mpc55xx_dspi_bus_entry *e = (mpc55xx_dspi_bus_entry *) bus;
    326334        union DSPI_CTAR_tag ctar = MPC55XX_ZERO_FLAGS;
    327         uint32_t scaler = bsp_clock_speed / mode->baudrate;
    328         mpc55xx_dspi_baudrate_scaler_entry bse = mpc55xx_dspi_search_baudrate_scaler( scaler, 0, MPC55XX_DSPI_BAUDRATE_SCALER_TABLE_SIZE / 2, MPC55XX_DSPI_BAUDRATE_SCALER_TABLE_SIZE);
    329335
    330336        if (mode->bits_per_char != 8) {
     
    335341
    336342        ctar.R = e->regs->CTAR [MPC55XX_DSPI_CTAR_DEFAULT].R;
    337 
    338         ctar.B.PBR = bse.pbr;
    339         ctar.B.BR = bse.br;
    340343
    341344        ctar.B.PCSSCK = 0;
     
    347350        ctar.B.CPOL = mode->clock_inv ? 1 : 0;
    348351        ctar.B.CPHA = mode->clock_phs ? 1 : 0;
     352
     353        if (mode->baudrate != e->baud) {
     354                uint32_t scaler = bsp_clock_speed / mode->baudrate;
     355                mpc55xx_dspi_baudrate_scaler_entry bse = mpc55xx_dspi_search_baudrate_scaler( scaler, 0, MPC55XX_DSPI_BAUDRATE_SCALER_TABLE_SIZE / 2, MPC55XX_DSPI_BAUDRATE_SCALER_TABLE_SIZE);
     356
     357                ctar.B.PBR = bse.pbr;
     358                ctar.B.BR = bse.br;
     359
     360                e->baud = mode->baudrate;
     361        }
    349362
    350363        e->regs->CTAR [MPC55XX_DSPI_CTAR_DEFAULT].R = ctar.R;
     
    364377 *  out [shape=box,label="Output Buffer"];
    365378 *  edge [color=red,fontcolor=red];
    366  *  push -> idle_push_data [label="Transmit Request",URL="\ref mpc55xx_dspi_bus_entry::edma_channel_transmit"];
    367  *  push -> out [label="Transmit Request",URL="\ref mpc55xx_dspi_bus_entry::edma_channel_transmit"];
    368  *  out -> push_data [label="Channel Link",URL="\ref mpc55xx_dspi_bus_entry::edma_channel_push"];
     379 *  push -> idle_push_data [label="Transmit Request",URL="\ref mpc55xx_dspi_bus_entry::edma_transmit"];
     380 *  push -> out [label="Transmit Request",URL="\ref mpc55xx_dspi_bus_entry::edma_transmit"];
     381 *  out -> push_data [label="Channel Link",URL="\ref mpc55xx_dspi_bus_entry::edma_push"];
    369382 *  edge [color=blue,fontcolor=blue];
    370383 *  out -> push_data [label="Data"];
     
    381394 *  in [shape=box,label="Input Buffer"];
    382395 *  edge [color=red,fontcolor=red];
    383  *  pop -> nirvana [label="Receive Request",URL="\ref mpc55xx_dspi_bus_entry::edma_channel_receive"];
    384  *  pop -> in [label="Receive Request",URL="\ref mpc55xx_dspi_bus_entry::edma_channel_receive"];
     396 *  pop -> nirvana [label="Receive Request",URL="\ref mpc55xx_dspi_bus_entry::edma_receive"];
     397 *  pop -> in [label="Receive Request",URL="\ref mpc55xx_dspi_bus_entry::edma_receive"];
    385398 *  edge [color=blue,fontcolor=blue];
    386399 *  pop -> nirvana [label="Data"];
     
    425438                n_c = (int) mpc55xx_cache_aligned_size( in, (size_t) n);
    426439                if (n_c > EDMA_TCD_BITER_LINKED_SIZE) {
    427                         RTEMS_SYSLOG_WARNING( "Buffer size out of range, cannot use eDMA\n");
     440                        RTEMS_SYSLOG_WARNING( "buffer size out of range, cannot use eDMA\n");
    428441                        n_nc = n;
    429442                        n_c = 0;
    430443                } else if (n_nc + n_c != n) {
    431                         RTEMS_SYSLOG_WARNING( "Input buffer not proper cache aligned, cannot use eDMA\n");
     444                        RTEMS_SYSLOG_WARNING( "input buffer not proper cache aligned, cannot use eDMA\n");
    432445                        n_nc = n;
    433446                        n_c = 0;
     
    511524                unsigned char *in_c = in + n_nc;
    512525                const unsigned char *out_c = out + n_nc;
    513                 struct tcd_t tcd_transmit = MPC55XX_EDMA_TCD_DEFAULT;
    514                 struct tcd_t tcd_receive = MPC55XX_EDMA_TCD_DEFAULT;
     526                struct tcd_t tcd_transmit = EDMA_TCD_DEFAULT;
     527                struct tcd_t tcd_receive = EDMA_TCD_DEFAULT;
    515528
    516529                /* Cache operations */
     
    523536                        mpc55xx_dspi_store_push_data( e);
    524537                        tcd_transmit.SADDR = mpc55xx_dspi_push_data_address( e);
    525                         tcd_transmit.SSIZE = 2;
    526                         tcd_transmit.SOFF = 0;
     538                        tcd_transmit.SDF.B.SSIZE = 2;
     539                        tcd_transmit.SDF.B.SOFF = 0;
    527540                        tcd_transmit.DADDR = (uint32_t) push;
    528                         tcd_transmit.DSIZE = 2;
    529                         tcd_transmit.DOFF = 0;
     541                        tcd_transmit.SDF.B.DSIZE = 2;
     542                        tcd_transmit.CDF.B.DOFF = 0;
    530543                        tcd_transmit.NBYTES = 4;
    531                         tcd_transmit.CITER = n_c;
    532                         tcd_transmit.BITER = n_c;
     544                        tcd_transmit.CDF.B.CITER = n_c;
     545                        tcd_transmit.BMF.B.BITER = n_c;
    533546                } else {
    534                         EDMA.CDSBR.R = e->edma_channel_transmit;
     547                        EDMA.CDSBR.R = e->edma_transmit.channel;
    535548                        tcd_transmit.SADDR = (uint32_t) out_c;
    536                         tcd_transmit.SSIZE = 0;
    537                         tcd_transmit.SOFF = 1;
     549                        tcd_transmit.SDF.B.SSIZE = 0;
     550                        tcd_transmit.SDF.B.SOFF = 1;
    538551                        tcd_transmit.DADDR = mpc55xx_dspi_push_data_address( e) + 3;
    539                         tcd_transmit.DSIZE = 0;
    540                         tcd_transmit.DOFF = 0;
     552                        tcd_transmit.SDF.B.DSIZE = 0;
     553                        tcd_transmit.CDF.B.DOFF = 0;
    541554                        tcd_transmit.NBYTES = 1;
    542                         tcd_transmit.CITERE_LINK = 1;
    543                         tcd_transmit.BITERE_LINK = 1;
    544                         tcd_transmit.MAJORLINKCH = e->edma_channel_push;
    545                         tcd_transmit.CITER = EDMA_TCD_LINK_AND_BITER( e->edma_channel_push, n_c);
    546                         tcd_transmit.BITER = EDMA_TCD_LINK_AND_BITER( e->edma_channel_push, n_c);
    547                         tcd_transmit.MAJORE_LINK = 1;
     555                        tcd_transmit.CDF.B.CITERE_LINK = 1;
     556                        tcd_transmit.BMF.B.BITERE_LINK = 1;
     557                        tcd_transmit.BMF.B.MAJORLINKCH = e->edma_push.channel;
     558                        tcd_transmit.CDF.B.CITER = EDMA_TCD_LINK_AND_BITER( e->edma_push.channel, n_c);
     559                        tcd_transmit.BMF.B.BITER = EDMA_TCD_LINK_AND_BITER( e->edma_push.channel, n_c);
     560                        tcd_transmit.BMF.B.MAJORE_LINK = 1;
    548561                }
    549                 tcd_transmit.D_REQ = 1;
    550                 tcd_transmit.INT_MAJ = 1;
    551                 EDMA.TCD [e->edma_channel_transmit] = tcd_transmit;
     562                tcd_transmit.BMF.B.D_REQ = 1;
     563                tcd_transmit.BMF.B.INT_MAJ = 1;
     564                EDMA.TCD [e->edma_transmit.channel] = tcd_transmit;
    552565
    553566                /* Set receive TCD */
    554567                if (in == NULL) {
    555                         tcd_receive.DOFF = 0;
     568                        tcd_receive.CDF.B.DOFF = 0;
    556569                        tcd_receive.DADDR = mpc55xx_dspi_nirvana_address( e);
    557570                } else {
    558                         tcd_receive.DOFF = 1;
     571                        tcd_receive.CDF.B.DOFF = 1;
    559572                        tcd_receive.DADDR = (uint32_t) in_c;
    560573                }
    561574                tcd_receive.SADDR = (uint32_t) pop + 3;
    562                 tcd_receive.SSIZE = 0;
    563                 tcd_receive.SOFF = 0;
    564                 tcd_receive.DSIZE = 0;
     575                tcd_receive.SDF.B.SSIZE = 0;
     576                tcd_receive.SDF.B.SOFF = 0;
     577                tcd_receive.SDF.B.DSIZE = 0;
    565578                tcd_receive.NBYTES = 1;
    566                 tcd_receive.D_REQ = 1;
    567                 tcd_receive.INT_MAJ = 1;
    568                 tcd_receive.CITER = n_c;
    569                 tcd_receive.BITER = n_c;
    570                 EDMA.TCD [e->edma_channel_receive] = tcd_receive;
     579                tcd_receive.BMF.B.D_REQ = 1;
     580                tcd_receive.BMF.B.INT_MAJ = 1;
     581                tcd_receive.CDF.B.CITER = n_c;
     582                tcd_receive.BMF.B.BITER = n_c;
     583                EDMA.TCD [e->edma_receive.channel] = tcd_receive;
    571584
    572585                /* Clear request flags */
     
    577590
    578591                /* Enable hardware requests */
    579                 sc = mpc55xx_edma_enable_hardware_requests( e->edma_channel_receive, true);
    580                 RTEMS_CHECK_SC_RV( sc, "Enable receive hardware requests");
    581                 sc = mpc55xx_edma_enable_hardware_requests( e->edma_channel_transmit, true);
    582                 RTEMS_CHECK_SC_RV( sc, "Enable transmit hardware requests");
     592                mpc55xx_edma_enable_hardware_requests( e->edma_receive.channel, true);
     593                mpc55xx_edma_enable_hardware_requests( e->edma_transmit.channel, true);
    583594
    584595                /* Wait for transmit update */
    585                 sc = rtems_semaphore_obtain( e->edma_channel_transmit_update, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    586                 RTEMS_CHECK_SC_RV( sc, "Transmit update");
    587                 if (e->edma_channel_transmit_error != 0) {
    588                         RTEMS_SYSLOG_ERROR( "Transmit error status: 0x%08x\n", e->edma_channel_transmit_error);
    589                         e->edma_channel_transmit_error = 0;
    590                         return -RTEMS_IO_ERROR;
    591                 }
     596                sc = rtems_semaphore_obtain( e->edma_transmit.id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     597                RTEMS_CHECK_SC_RV( sc, "transmit update");
    592598
    593599                /* Wait for receive update */
    594                 sc = rtems_semaphore_obtain( e->edma_channel_receive_update, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    595                 RTEMS_CHECK_SC_RV( sc, "Receive update");
    596                 if (e->edma_channel_receive_error != 0) {
    597                         RTEMS_SYSLOG_ERROR( "Receive error status: 0x%08x\n", e->edma_channel_receive_error);
    598                         e->edma_channel_receive_error = 0;
    599                         return -RTEMS_IO_ERROR;
    600                 }
     600                sc = rtems_semaphore_obtain( e->edma_receive.id, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     601                RTEMS_CHECK_SC_RV( sc, "receive update");
    601602        }
    602603
     
    660661};
    661662
    662 mpc55xx_dspi_bus_entry mpc55xx_dspi_bus_table [MPC55XX_DSPI_NUMBER] = { {
     663mpc55xx_dspi_bus_entry mpc55xx_dspi_bus_table [MPC55XX_DSPI_NUMBER] = {
     664        {
    663665                /* DSPI A */
    664666                .bus = {
     
    669671                .bus_number = 0,
    670672                .regs = &DSPI_A,
    671                 .master = 1,
     673                .master = true,
    672674                .push_data = MPC55XX_ZERO_FLAGS,
    673                 .edma_channel_transmit = 32,
    674                 .edma_channel_push = 43,
    675                 .edma_channel_receive = 33,
    676                 .edma_channel_transmit_update = 0,
    677                 .edma_channel_receive_update = 0,
    678                 .edma_channel_transmit_error = 0,
    679                 .edma_channel_receive_error = 0,
     675                .edma_transmit = {
     676                        .channel = 32,
     677                        .done = mpc55xx_dspi_edma_done,
     678                        .id = RTEMS_ID_NONE
     679                },
     680                .edma_push = {
     681                        .channel = 43,
     682                        .done = mpc55xx_dspi_edma_done,
     683                        .id = RTEMS_ID_NONE
     684                },
     685                .edma_receive = {
     686                        .channel = 33,
     687                        .done = mpc55xx_dspi_edma_done,
     688                        .id = RTEMS_ID_NONE
     689                },
    680690                .idle_char = 0xffffffff,
     691                .baud = 0
    681692        }, {
    682693                /* DSPI B */
     
    688699                .bus_number = 0,
    689700                .regs = &DSPI_B,
    690                 .master = 1,
     701                .master = true,
    691702                .push_data = MPC55XX_ZERO_FLAGS,
    692                 .edma_channel_transmit = 12,
    693                 .edma_channel_push = 10,
    694                 .edma_channel_receive = 13,
    695                 .edma_channel_transmit_update = 0,
    696                 .edma_channel_receive_update = 0,
    697                 .edma_channel_transmit_error = 0,
    698                 .edma_channel_receive_error = 0,
     703                .edma_transmit = {
     704                        .channel = 12,
     705                        .done = mpc55xx_dspi_edma_done,
     706                        .id = RTEMS_ID_NONE
     707                },
     708                .edma_push = {
     709                        .channel = 10,
     710                        .done = mpc55xx_dspi_edma_done,
     711                        .id = RTEMS_ID_NONE
     712                },
     713                .edma_receive = {
     714                        .channel = 13,
     715                        .done = mpc55xx_dspi_edma_done,
     716                        .id = RTEMS_ID_NONE
     717                },
    699718                .idle_char = 0xffffffff,
     719                .baud = 0
    700720        }, {
    701721                /* DSPI C */
     
    707727                .bus_number = 0,
    708728                .regs = &DSPI_C,
    709                 .master = 1,
     729                .master = true,
    710730                .push_data = MPC55XX_ZERO_FLAGS,
    711                 .edma_channel_transmit = 14,
    712                 .edma_channel_push = 11,
    713                 .edma_channel_receive = 15,
    714                 .edma_channel_transmit_update = 0,
    715                 .edma_channel_receive_update = 0,
    716                 .edma_channel_transmit_error = 0,
    717                 .edma_channel_receive_error = 0,
     731                .edma_transmit = {
     732                        .channel = 14,
     733                        .done = mpc55xx_dspi_edma_done,
     734                        .id = RTEMS_ID_NONE
     735                },
     736                .edma_push = {
     737                        .channel = 11,
     738                        .done = mpc55xx_dspi_edma_done,
     739                        .id = RTEMS_ID_NONE
     740                },
     741                .edma_receive = {
     742                        .channel = 15,
     743                        .done = mpc55xx_dspi_edma_done,
     744                        .id = RTEMS_ID_NONE
     745                },
    718746                .idle_char = 0xffffffff,
     747                .baud = 0
    719748        }, {
    720749                /* DSPI D */
     
    726755                .bus_number = 0,
    727756                .regs = &DSPI_D,
    728                 .master = 1,
     757                .master = true,
    729758                .push_data = MPC55XX_ZERO_FLAGS,
    730                 .edma_channel_transmit = 16,
    731                 .edma_channel_push = 18,
    732                 .edma_channel_receive = 17,
    733                 .edma_channel_transmit_update = 0,
    734                 .edma_channel_receive_update = 0,
    735                 .edma_channel_transmit_error = 0,
    736                 .edma_channel_receive_error = 0,
     759                .edma_transmit = {
     760                        .channel = 16,
     761                        .done = mpc55xx_dspi_edma_done,
     762                        .id = RTEMS_ID_NONE
     763                },
     764                .edma_push = {
     765                        .channel = 18,
     766                        .done = mpc55xx_dspi_edma_done,
     767                        .id = RTEMS_ID_NONE
     768                },
     769                .edma_receive = {
     770                        .channel = 17,
     771                        .done = mpc55xx_dspi_edma_done,
     772                        .id = RTEMS_ID_NONE
     773                },
    737774                .idle_char = 0xffffffff,
    738         },
     775                .baud = 0
     776        }
    739777};
  • c/src/lib/libcpu/powerpc/mpc55xx/edma/edma.c

    r115971c rd374492  
    2323#include <mpc55xx/mpc55xx.h>
    2424
     25#include <string.h>
     26
    2527#include <bsp/irq.h>
    26 
    27 #include <string.h>
     28#include <bsp/utility.h>
    2829
    2930#define RTEMS_STATUS_CHECKS_USE_PRINTK
     
    3132#include <rtems/status-checks.h>
    3233
    33 #define MPC55XX_EDMA_CHANNEL_NUMBER 64
    34 #define MPC55XX_EDMA_INVALID_CHANNEL UINT8_MAX
    35 #define MPC55XX_EDMA_IS_CHANNEL_INVALID( i) ((i) < 0 || (i) >= MPC55XX_EDMA_CHANNEL_NUMBER)
    36 
    37 #define MPC55XX_EDMA_IRQ_PRIORITY MPC55XX_INTC_MIN_PRIORITY
    38 
    39 typedef struct {
    40         uint8_t channel;
    41         rtems_id transfer_update;
    42         uint32_t *error_status;
    43 } mpc55xx_edma_channel_entry;
    44 
    45 static mpc55xx_edma_channel_entry mpc55xx_edma_channel_table [MPC55XX_EDMA_CHANNEL_NUMBER];
    46 
    47 static uint32_t mpc55xx_edma_channel_occupation_low = 0;
    48 
    49 static uint32_t mpc55xx_edma_channel_occupation_high = 0;
    50 
    51 static rtems_id mpc55xx_edma_channel_occupation_mutex = RTEMS_ID_NONE;
    52 
    53 static uint8_t mpc55xx_edma_irq_error_low_channel = 0;
    54 
    55 static uint8_t mpc55xx_edma_irq_error_high_channel = 32;
    56 
    57 static void mpc55xx_edma_irq_handler( rtems_vector_number vector, void *data)
    58 {
    59         rtems_status_code sc = RTEMS_SUCCESSFUL;
    60         mpc55xx_edma_channel_entry *e = (mpc55xx_edma_channel_entry *) data;
     34#define MPC55XX_EDMA_CHANNEL_NUMBER 64U
     35
     36#define MPC55XX_EDMA_INVALID_CHANNEL MPC55XX_EDMA_CHANNEL_NUMBER
     37
     38#define MPC55XX_EDMA_IS_CHANNEL_INVALID( i) ((unsigned) (i) >= MPC55XX_EDMA_CHANNEL_NUMBER)
     39
     40#define MPC55XX_EDMA_IS_CHANNEL_VALID( i) ((unsigned) (i) < MPC55XX_EDMA_CHANNEL_NUMBER)
     41
     42#define MPC55XX_EDMA_IRQ_PRIORITY MPC55XX_INTC_DEFAULT_PRIORITY
     43
     44#define MPC55XX_EDMA_CHANNEL_FLAG( channel) ((uint64_t) 1 << (channel))
     45
     46static uint64_t mpc55xx_edma_channel_occupation = 0;
     47
     48static rtems_chain_control mpc55xx_edma_channel_chain;
     49
     50static void mpc55xx_edma_interrupt_handler( rtems_vector_number vector, void *arg)
     51{
     52        mpc55xx_edma_channel_entry *e = (mpc55xx_edma_channel_entry *) arg;
     53
    6154#ifdef DEBUG
    6255        uint32_t citer = EDMA.TCD [e->channel].CITERE_LINK ? EDMA.TCD [e->channel].CITER & EDMA_TCD_BITER_LINKED_MASK : EDMA.TCD [e->channel].CITER;
    63         RTEMS_DEBUG_PRINT( "Channel %i (CITER = %i)\n", e->channel, citer);
     56        RTEMS_DEBUG_PRINT( "channel %i (CITER = %i)\n", e->channel, citer);
    6457#endif /* DEBUG */
    65         EDMA.CIRQR.R = e->channel;
    66         sc = rtems_semaphore_release( e->transfer_update);
    67         RTEMS_SYSLOG_WARNING_SC( sc, "Transfer update semaphore release");
    68 }
    69 
    70 static void mpc55xx_edma_irq_update_error_table( uint8_t *link_table, uint8_t *error_table, int channel)
    71 {
    72         int i = 0;
    73         error_table [channel] = 1;
    74         for (i = 0; i < MPC55XX_EDMA_CHANNEL_NUMBER; ++i) {
    75                 if (channel == link_table [i] && error_table [i] == 0) {
    76                         mpc55xx_edma_irq_update_error_table( link_table, error_table, i);
    77                 }
    78         }
    79 }
    80 
    81 static void mpc55xx_edma_irq_error_handler( rtems_vector_number vector, void *data)
    82 {
    83         rtems_status_code sc = RTEMS_SUCCESSFUL;
    84         uint8_t channel_start = *((uint8_t *) data);
    85         uint8_t channel_end = (uint8_t) (channel_start + 32);
    86         int i = 0;
    87         uint32_t mask = 0x1;
    88         uint32_t error_register = 0;
    89         uint8_t channel_link_table [MPC55XX_EDMA_CHANNEL_NUMBER];
    90         uint8_t channel_error_table [MPC55XX_EDMA_CHANNEL_NUMBER];
    91 
    92         /* Error register */
    93         if (channel_start < 32) {
    94                 error_register = EDMA.ERL.R;
    95         } else if (channel_start < 64) {
    96                 error_register = EDMA.ERH.R;
    97         }
    98         RTEMS_DEBUG_PRINT( "Error register %s: 0x%08x\n", channel_start < 32 ? "low" : "high", error_register);
    99 
    100         /* Fill channel link table */
    101         for (i = 0; i < MPC55XX_EDMA_CHANNEL_NUMBER; ++i) {
    102                 if (EDMA.TCD [i].BITERE_LINK && EDMA.TCD [i].CITER != EDMA.TCD [i].BITER) {
    103                         channel_link_table [i] = (uint8_t) EDMA_TCD_BITER_LINK( i);
    104                 } else if (EDMA.TCD [i].MAJORE_LINK && EDMA.TCD [i].CITER == EDMA.TCD [i].BITER) {
    105                         channel_link_table [i] = EDMA.TCD [i].MAJORLINKCH;
    106                 } else {
    107                         channel_link_table [i] = MPC55XX_EDMA_INVALID_CHANNEL;
    108                 }
    109                 channel_error_table [i] = 0;
    110         }
    111 
    112         /* Search for channels with errors */
    113         for (i = channel_start; i < channel_end; ++i) {
    114                 if ((error_register & mask) != 0) {
    115                         mpc55xx_edma_irq_update_error_table( channel_link_table, channel_error_table, i);
    116                 }
    117                 mask <<= 1;
    118         }
     58
     59        /* Clear interrupt */
     60        EDMA.CIRQR.R = (uint8_t) e->channel;
     61
     62        /* Notify user */
     63        e->done( e, 0);
     64}
     65
     66static void mpc55xx_edma_interrupt_error_handler( rtems_vector_number vector, void *arg)
     67{
     68        rtems_chain_control *chain = &mpc55xx_edma_channel_chain;
     69        rtems_chain_node *node = chain->first;
     70        unsigned i = 0;
     71        uint64_t error_status = EDMA.ESR.R;
     72        uint64_t error_channels = ((uint64_t) EDMA.ERH.R << 32) | EDMA.ERL.R;
     73        uint64_t error_channels_update = 0;
     74
     75        RTEMS_DEBUG_PRINT( "error channels: %08x %08x\n", (unsigned) (error_channels >> 32), (unsigned) error_channels);
     76
     77        /* Mark all channels that are linked to a channel with errors */
     78        do {
     79                error_channels_update = 0;
     80
     81                for (i = 0; i < MPC55XX_EDMA_CHANNEL_NUMBER; ++i) {
     82                        uint64_t channel_flags = 0;
     83                        unsigned minor_link = i;
     84                        unsigned major_link = i;
     85
     86                        /* Check if we have linked channels */
     87                        if (EDMA.TCD [i].BMF.B.BITERE_LINK) {
     88                                minor_link = EDMA_TCD_BITER_LINK( i);
     89                        }
     90                        if (EDMA.TCD [i].BMF.B.MAJORE_LINK) {
     91                                major_link = EDMA.TCD [i].BMF.B.MAJORLINKCH;
     92                        }
     93
     94                        /* Set flags related to this channel */
     95                        channel_flags = MPC55XX_EDMA_CHANNEL_FLAG( i) | MPC55XX_EDMA_CHANNEL_FLAG( minor_link) | MPC55XX_EDMA_CHANNEL_FLAG( major_link);
     96
     97                        /* Any errors in these channels? */
     98                        if (IS_ANY_FLAG_SET( error_channels, channel_flags)) {
     99                                /* Get new error channels */
     100                                uint64_t update = (error_channels & channel_flags) ^ channel_flags;
     101
     102                                /* Update error channels */
     103                                error_channels = SET_FLAGS( error_channels, channel_flags);
     104
     105                                /* Contribute to the update of this round */
     106                                error_channels_update = SET_FLAGS( error_channels_update, update);
     107                        }
     108                }
     109        } while (error_channels_update != 0);
     110
     111        RTEMS_DEBUG_PRINT( "error channels (all): %08x %08x\n", (unsigned) (error_channels >> 32), (unsigned) error_channels);
    119112
    120113        /* Process the channels related to errors */
    121         error_register = EDMA.ESR.R;
    122         for (i = 0; i < MPC55XX_EDMA_CHANNEL_NUMBER; ++i) {
    123                 if (channel_error_table [i]) {
    124                         mpc55xx_edma_channel_entry *e = &mpc55xx_edma_channel_table [i];
    125                         if (e->error_status != NULL) {
    126                                 *e->error_status = error_register;
    127                         }
    128                         sc = mpc55xx_edma_enable_hardware_requests( i, false);
    129                         RTEMS_SYSLOG_ERROR_SC( sc, "Disable hardware requests");
    130                         sc = rtems_semaphore_release( e->transfer_update);
    131                         RTEMS_SYSLOG_WARNING_SC( sc, "Transfer update semaphore release");
    132                 }
     114        while (!rtems_chain_is_tail( chain, node)) {
     115                mpc55xx_edma_channel_entry *e = (mpc55xx_edma_channel_entry *) node;
     116
     117                if (IS_FLAG_SET( error_channels, MPC55XX_EDMA_CHANNEL_FLAG( e->channel))) {
     118                        mpc55xx_edma_enable_hardware_requests( e->channel, false);
     119
     120                        /* Notify user */
     121                        e->done( e, error_status);
     122                }
     123
     124                node = node->next;
    133125        }
    134126
    135127        /* Clear the error interrupt requests */
    136128        for (i = 0; i < MPC55XX_EDMA_CHANNEL_NUMBER; ++i) {
    137                 if (channel_error_table [i]) {
     129                if (IS_FLAG_SET( error_channels, MPC55XX_EDMA_CHANNEL_FLAG( i))) {
    138130                        EDMA.CER.R = (uint8_t) i;
    139131                }
     
    141133}
    142134
    143 rtems_status_code mpc55xx_edma_enable_hardware_requests( int channel, bool enable)
    144 {
    145         if (MPC55XX_EDMA_IS_CHANNEL_INVALID( channel)) {
    146                 return RTEMS_INVALID_NUMBER;
    147         }
    148         if (enable) {
    149                 EDMA.SERQR.R = (uint8_t) channel;
     135void mpc55xx_edma_enable_hardware_requests( unsigned channel, bool enable)
     136{
     137        if (MPC55XX_EDMA_IS_CHANNEL_VALID( channel)) {
     138                if (enable) {
     139                        EDMA.SERQR.R = (uint8_t) channel;
     140                } else {
     141                        EDMA.CERQR.R = (uint8_t) channel;
     142                }
    150143        } else {
    151                 EDMA.CERQR.R = (uint8_t) channel;
    152         }
    153         return RTEMS_SUCCESSFUL;
    154 }
    155 
    156 rtems_status_code mpc55xx_edma_enable_error_interrupts( int channel, bool enable)
    157 {
    158         if (MPC55XX_EDMA_IS_CHANNEL_INVALID( channel)) {
    159                 return RTEMS_INVALID_NUMBER;
    160         }
    161         if (enable) {
    162                 EDMA.SEEIR.R = channel;
     144                RTEMS_SYSLOG_ERROR( "invalid channel number\n");
     145        }
     146}
     147
     148void mpc55xx_edma_enable_error_interrupts( unsigned channel, bool enable)
     149{
     150        if (MPC55XX_EDMA_IS_CHANNEL_VALID( channel)) {
     151                if (enable) {
     152                        EDMA.SEEIR.R = (uint8_t) channel;
     153                } else {
     154                        EDMA.CEEIR.R = (uint8_t) channel;
     155                }
    163156        } else {
    164                 EDMA.CEEIR.R = channel;
    165         }
    166         return RTEMS_SUCCESSFUL;
     157                RTEMS_SYSLOG_ERROR( "invalid channel number\n");
     158        }
    167159}
    168160
     
    170162{
    171163        rtems_status_code sc = RTEMS_SUCCESSFUL;
    172         int i = 0;
    173 
    174         /* Channel occupation mutex */
    175         sc = rtems_semaphore_create (
    176                 rtems_build_name ( 'D', 'M', 'A', 'O'),
    177                 1,
    178                 RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
    179                 RTEMS_NO_PRIORITY,
    180                 &mpc55xx_edma_channel_occupation_mutex
    181         );
    182         RTEMS_CHECK_SC( sc, "Create channel occupation mutex");
     164
     165        /* Initialize channel chain */
     166        rtems_chain_initialize_empty( &mpc55xx_edma_channel_chain);
    183167
    184168        /* Arbitration mode: round robin */
     
    189173        memset( &EDMA.TCD [0], 0, sizeof( EDMA.TCD));
    190174
    191         /* Channel table */
    192         for (i = 0; i < MPC55XX_EDMA_CHANNEL_NUMBER; ++i) {
    193                 mpc55xx_edma_channel_table [i].channel = i;
    194                 mpc55xx_edma_channel_table [i].transfer_update = RTEMS_ID_NONE;
    195                 mpc55xx_edma_channel_table [i].error_status = NULL;
    196         }
    197 
    198         /* Error interrupt handler */
     175        /* Error interrupt handlers */
    199176        sc = mpc55xx_interrupt_handler_install(
    200177                MPC55XX_IRQ_EDMA_ERROR_LOW,
    201                 MPC55XX_EDMA_IRQ_PRIORITY,
    202178                "eDMA Error (Low)",
    203179                RTEMS_INTERRUPT_UNIQUE,
    204                 mpc55xx_edma_irq_error_handler,
    205                 &mpc55xx_edma_irq_error_low_channel
    206         );
    207         RTEMS_CHECK_SC( sc, "Install low error interrupt handler");
     180                MPC55XX_EDMA_IRQ_PRIORITY,
     181                mpc55xx_edma_interrupt_error_handler,
     182                NULL
     183        );
     184        RTEMS_CHECK_SC( sc, "install low error interrupt handler");
    208185        sc = mpc55xx_interrupt_handler_install(
    209186                MPC55XX_IRQ_EDMA_ERROR_HIGH,
    210                 MPC55XX_EDMA_IRQ_PRIORITY,
    211187                "eDMA Error (High)",
    212188                RTEMS_INTERRUPT_UNIQUE,
    213                 mpc55xx_edma_irq_error_handler,
    214                 &mpc55xx_edma_irq_error_high_channel
    215         );
    216         RTEMS_CHECK_SC( sc, "Install high error interrupt handler");
     189                MPC55XX_EDMA_IRQ_PRIORITY,
     190                mpc55xx_edma_interrupt_error_handler,
     191                NULL
     192        );
     193        RTEMS_CHECK_SC( sc, "install high error interrupt handler");
    217194
    218195        return RTEMS_SUCCESSFUL;
    219196}
    220197
    221 rtems_status_code mpc55xx_edma_obtain_channel( int channel, uint32_t *error_status, rtems_id transfer_update)
     198rtems_status_code mpc55xx_edma_obtain_channel( mpc55xx_edma_channel_entry *e)
    222199{
    223200        rtems_status_code sc = RTEMS_SUCCESSFUL;
    224         int channel_occupied = 1;
    225 
    226         if (MPC55XX_EDMA_IS_CHANNEL_INVALID( channel)) {
     201        rtems_interrupt_level level;
     202        uint64_t channel_occupation = 0;
     203
     204        if (MPC55XX_EDMA_IS_CHANNEL_INVALID( e->channel)) {
    227205                return RTEMS_INVALID_NUMBER;
    228206        }
    229207
    230         /* Check occupation */
    231         sc = rtems_semaphore_obtain( mpc55xx_edma_channel_occupation_mutex, RTEMS_WAIT, 0);
    232         RTEMS_CHECK_SC( sc, "Obtain channel occupation mutex");
    233         if (channel < 32) {
    234                 channel_occupied = mpc55xx_edma_channel_occupation_low & (0x1 << channel);
    235                 if (!channel_occupied) {
    236                         mpc55xx_edma_channel_occupation_low |= 0x1 << channel;
    237                 }
    238         } else if (channel < 64) {
    239                 channel_occupied = mpc55xx_edma_channel_occupation_high & (0x1 << (channel - 32));
    240                 if (!channel_occupied) {
    241                         mpc55xx_edma_channel_occupation_high |= 0x1 << (channel - 32);
    242                 }
    243         }
    244         if (channel_occupied) {
    245                 sc = rtems_semaphore_release( mpc55xx_edma_channel_occupation_mutex);
    246                 RTEMS_SYSLOG_WARNING_SC( sc, "Release occupation mutex");
     208        /* Test and set channel occupation flag */
     209        rtems_interrupt_disable( level);
     210        channel_occupation = mpc55xx_edma_channel_occupation;
     211        if (IS_FLAG_CLEARED( channel_occupation, MPC55XX_EDMA_CHANNEL_FLAG( e->channel))) {
     212                mpc55xx_edma_channel_occupation = SET_FLAG( channel_occupation, MPC55XX_EDMA_CHANNEL_FLAG( e->channel));
     213        }
     214        rtems_interrupt_enable( level);
     215
     216        /* Check channel occupation flag */
     217        if (IS_FLAG_SET( channel_occupation, MPC55XX_EDMA_CHANNEL_FLAG( e->channel))) {
    247218                return RTEMS_RESOURCE_IN_USE;
    248         } else {
    249                 sc = rtems_semaphore_release( mpc55xx_edma_channel_occupation_mutex);
    250                 RTEMS_CHECK_SC( sc, "Release channel occupation mutex");
    251         }
    252 
    253         /* Channel data */
    254         mpc55xx_edma_channel_table [channel].transfer_update = transfer_update;
    255         mpc55xx_edma_channel_table [channel].error_status = error_status;
     219        }
    256220
    257221        /* Interrupt handler */
    258222        sc = mpc55xx_interrupt_handler_install(
    259                 MPC55XX_IRQ_EDMA_GET_REQUEST( channel),
    260                 MPC55XX_EDMA_IRQ_PRIORITY,
     223                MPC55XX_IRQ_EDMA_GET_REQUEST( e->channel),
    261224                "eDMA Channel",
    262225                RTEMS_INTERRUPT_SHARED,
    263                 mpc55xx_edma_irq_handler,
    264                 &mpc55xx_edma_channel_table [channel]
    265         );
    266         RTEMS_CHECK_SC( sc, "Install channel interrupt handler");
     226                MPC55XX_EDMA_IRQ_PRIORITY,
     227                mpc55xx_edma_interrupt_handler,
     228                e
     229        );
     230        RTEMS_CHECK_SC( sc, "install channel interrupt handler");
    267231
    268232        /* Enable error interrupts */
    269         sc = mpc55xx_edma_enable_error_interrupts( channel, true);
    270         RTEMS_CHECK_SC( sc, "Enable error interrupts");
     233        mpc55xx_edma_enable_error_interrupts( e->channel, true);
     234
     235        /* Prepend channel entry to channel list */
     236        rtems_chain_prepend( &mpc55xx_edma_channel_chain, &e->node);
    271237
    272238        return RTEMS_SUCCESSFUL;
    273239}
    274240
    275 rtems_status_code mpc55xx_edma_release_channel( int channel)
    276 {
    277         // TODO
    278         return RTEMS_NOT_IMPLEMENTED;
    279 }
     241rtems_status_code mpc55xx_edma_release_channel( mpc55xx_edma_channel_entry *e)
     242{
     243        rtems_status_code sc = RTEMS_SUCCESSFUL;
     244        rtems_interrupt_level level;
     245
     246        /* Clear channel occupation flag */
     247        rtems_interrupt_disable( level);
     248        mpc55xx_edma_channel_occupation = CLEAR_FLAG( mpc55xx_edma_channel_occupation, MPC55XX_EDMA_CHANNEL_FLAG( e->channel));
     249        rtems_interrupt_enable( level);
     250
     251        /* Disable hardware requests */
     252        mpc55xx_edma_enable_hardware_requests( e->channel, false);
     253
     254        /* Disable error interrupts */
     255        mpc55xx_edma_enable_error_interrupts( e->channel, false);
     256
     257        /* Extract channel entry from channel chain */
     258        rtems_chain_extract( &e->node);
     259
     260        /* Remove interrupt handler */
     261        sc = rtems_interrupt_handler_remove(
     262                MPC55XX_IRQ_EDMA_GET_REQUEST( e->channel),
     263                mpc55xx_edma_interrupt_handler,
     264                e
     265        );
     266        RTEMS_CHECK_SC( sc, "remove channel interrupt handler");
     267
     268        /* Notify user */
     269        e->done( e, 0);
     270
     271        return RTEMS_SUCCESSFUL;
     272}
  • c/src/lib/libcpu/powerpc/mpc55xx/esci/esci.c

    r115971c rd374492  
    4242#undef CR2
    4343
    44 #define MPC55XX_ESCI_IRQ_PRIORITY MPC55XX_INTC_MIN_PRIORITY
     44#define MPC55XX_ESCI_IRQ_PRIORITY MPC55XX_INTC_DEFAULT_PRIORITY
    4545
    4646#define MPC55XX_ESCI_IS_MINOR_INVALD(minor) ((minor) < 0 || (minor) >= MPC55XX_ESCI_NUMBER)
     
    7474 */
    7575static const struct termios mpc55xx_esci_termios_default = {
    76         0,
    77         0,
    78         CS8 | CREAD | CLOCAL | B115200,
    79         0,
    80         0,
    81         { 0 }
     76        .c_cflag = CS8 | CREAD | CLOCAL | B115200
    8277};
    8378
     
    120115        volatile union ESCI_DR_tag *data = &e->regs->DR;
    121116        union ESCI_SR_tag sr = MPC55XX_ZERO_FLAGS;
    122 
    123         while (status->B.TDRE == 0) {
    124                 /* Wait */
    125         }
    126 
    127         /* Clear flag */
     117        rtems_interrupt_level level;
     118
     119        /* Set clear flag */
    128120        sr.B.TDRE = 1;
    129         status->R = sr.R;
    130 
    131         /* Write */
    132         data->B.D = c;
    133 }
    134 
    135 /** @} */
    136 
    137 /**
    138  * @name Termios Support
    139  * @{
    140  */
    141 
    142 /**
    143  * @brief Opens port @a minor.
    144  *
    145  * @return Status code.
    146  */
    147 static int mpc55xx_esci_termios_first_open( int major, int minor, void *arg)
    148 {
    149         mpc55xx_esci_driver_entry *e = &mpc55xx_esci_driver_table [minor];
     121
     122        while (true) {
     123                rtems_interrupt_disable( level);
     124                if (status->B.TDRE != 0) {
     125                        /* Clear flag */
     126                        status->R = sr.R;
     127
     128                        /* Write */
     129                        data->B.D = c;
     130
     131                        /* Done */
     132                        rtems_interrupt_enable( level);
     133                        break;
     134                }
     135                rtems_interrupt_enable( level);
     136
     137                while (status->B.TDRE == 0) {
     138                        /* Wait */
     139                }
     140        }
     141}
     142
     143static inline void mpc55xx_esci_interrupts_enable( mpc55xx_esci_driver_entry *e)
     144{
    150145        union ESCI_CR1_tag cr1 = MPC55XX_ZERO_FLAGS;
    151         struct rtems_termios_tty *tty = ((rtems_libio_open_close_args_t *) arg)->iop->data1;
    152 
    153         /* Check minor number */
    154         if (MPC55XX_ESCI_IS_MINOR_INVALD( minor)) {
    155                 return RTEMS_INVALID_NUMBER;
    156         }
    157 
    158         /* Connect TTY */
    159         e->tty = tty;   
    160 
    161         /* Enable interrupts */
    162         if (MPC55XX_ESCI_USE_INTERRUPTS( e)) {
    163                 cr1.R = e->regs->CR1.R;
    164                 cr1.B.RIE = 1;
    165                 cr1.B.TIE = 1;
    166                 e->regs->CR1.R = cr1.R;
    167         }
    168 
    169         return RTEMS_SUCCESSFUL;
    170 }
    171 
    172 /**
    173  * @brief Closes port @a minor.
    174  *
    175  * @return Status code.
    176  */
    177 static int mpc55xx_esci_termios_last_close( int major, int minor, void* arg)
    178 {
    179         mpc55xx_esci_driver_entry *e = &mpc55xx_esci_driver_table [minor];
     146        rtems_interrupt_level level;
     147
     148        rtems_interrupt_disable( level);
     149        cr1.R = e->regs->CR1.R;
     150        cr1.B.RIE = 1;
     151        cr1.B.TIE = 1;
     152        e->regs->CR1.R = cr1.R;
     153        rtems_interrupt_enable( level);
     154}
     155
     156static inline void mpc55xx_esci_interrupts_disable( mpc55xx_esci_driver_entry *e)
     157{
    180158        union ESCI_CR1_tag cr1 = MPC55XX_ZERO_FLAGS;
    181 
    182         /* Check minor number */
    183         if (MPC55XX_ESCI_IS_MINOR_INVALD( minor)) {
    184                 return RTEMS_INVALID_NUMBER;
    185         }
    186 
    187         /* Disable interrupts */
     159        rtems_interrupt_level level;
     160
     161        rtems_interrupt_disable( level);
    188162        cr1.R = e->regs->CR1.R;
    189163        cr1.B.RIE = 0;
    190164        cr1.B.TIE = 0;
    191165        e->regs->CR1.R = cr1.R;
     166        rtems_interrupt_enable( level);
     167}
     168
     169/** @} */
     170
     171/**
     172 * @name Termios Support
     173 * @{
     174 */
     175
     176/**
     177 * @brief Opens port @a minor.
     178 *
     179 * @return Status code.
     180 */
     181static int mpc55xx_esci_termios_first_open( int major, int minor, void *arg)
     182{
     183        int rv = 0;
     184        mpc55xx_esci_driver_entry *e = &mpc55xx_esci_driver_table [minor];
     185        struct rtems_termios_tty *tty = ((rtems_libio_open_close_args_t *) arg)->iop->data1;
     186
     187        /* Check minor number */
     188        if (MPC55XX_ESCI_IS_MINOR_INVALD( minor)) {
     189                return RTEMS_INVALID_NUMBER;
     190        }
     191
     192        /* Connect TTY */
     193        e->tty = tty;   
     194
     195        /* Enable interrupts */
     196        if (MPC55XX_ESCI_USE_INTERRUPTS( e)) {
     197                mpc55xx_esci_interrupts_enable( e);
     198        }
     199
     200        rv = rtems_termios_set_initial_baud( e->tty, 115200);
     201        RTEMS_CHECK_RV_SC( rv, "Set initial baud");
     202
     203        return RTEMS_SUCCESSFUL;
     204}
     205
     206/**
     207 * @brief Closes port @a minor.
     208 *
     209 * @return Status code.
     210 */
     211static int mpc55xx_esci_termios_last_close( int major, int minor, void* arg)
     212{
     213        mpc55xx_esci_driver_entry *e = &mpc55xx_esci_driver_table [minor];
     214
     215        /* Check minor number */
     216        if (MPC55XX_ESCI_IS_MINOR_INVALD( minor)) {
     217                return RTEMS_INVALID_NUMBER;
     218        }
     219
     220        /* Disable interrupts */
     221        mpc55xx_esci_interrupts_disable( e);
    192222
    193223        /* Disconnect TTY */
     
    205235{
    206236        mpc55xx_esci_driver_entry *e = &mpc55xx_esci_driver_table [minor];
    207        
    208         /* Check minor number */
    209         if (MPC55XX_ESCI_IS_MINOR_INVALD( minor)) {
     237        volatile union ESCI_SR_tag *status = &e->regs->SR;
     238        volatile union ESCI_DR_tag *data = &e->regs->DR;
     239        union ESCI_SR_tag sr = MPC55XX_ZERO_FLAGS;
     240
     241        if (status->B.RDRF == 0) {
    210242                return -1;
    211243        }
    212244
    213         return (int) mpc55xx_esci_read_char( e);
     245        /* Clear flag */
     246        sr.B.RDRF = 1;
     247        status->R = sr.R;
     248
     249        /* Read */
     250        return data->B.D;
    214251}
    215252
     
    232269        for (i = 0; i < n; ++i) {
    233270                mpc55xx_esci_write_char( e, out [i]);
    234                 if (out [i] == '\n') {
    235                         mpc55xx_esci_write_char( e, '\r');
    236                 }
    237271        }
    238272
     
    480514                                sc = mpc55xx_interrupt_handler_install(
    481515                                        e->irq_number,
    482                                         MPC55XX_ESCI_IRQ_PRIORITY,
    483516                                        "eSCI",
    484517                                        RTEMS_INTERRUPT_UNIQUE,
     518                                        MPC55XX_ESCI_IRQ_PRIORITY,
    485519                                        mpc55xx_esci_termios_interrupt_handler,
    486520                                        e
     
    512546                        sc =  rtems_termios_open( major, minor, arg, &mpc55xx_esci_termios_callbacks_polled);
    513547                }
    514                 if (sc != RTEMS_SUCCESSFUL) {
    515                         return sc;
    516                 }
    517                 rv = rtems_termios_set_initial_baud( e->tty, 115200);
    518                 if (rv < 0) {
    519                         return RTEMS_IO_ERROR;
    520                 }
     548                RTEMS_CHECK_SC( sc, "Open");
    521549        }
    522550
     
    624652{
    625653        mpc55xx_esci_driver_entry *e = &mpc55xx_esci_driver_table [mpc55xx_esci_output_char_minor];
     654
     655        mpc55xx_esci_interrupts_disable( e);
    626656        mpc55xx_esci_write_char( e, c);
    627657        if (c == '\n') {
    628658                mpc55xx_esci_write_char( e, '\r');
    629659        }
     660        mpc55xx_esci_interrupts_enable( e);
    630661}
    631662
     
    637668static void mpc55xx_esci_output_char_init( char c)
    638669{
    639         int console_found = 0;
     670        bool console_found = false;
    640671        int i = 0;
     672
    641673        for (i = 0; i < MPC55XX_ESCI_NUMBER; ++i) {
    642674                if (mpc55xx_esci_driver_table [i].console) {
    643                         console_found = 1;
     675                        console_found = true;
    644676                        mpc55xx_esci_output_char_minor = i;
    645677                        break;
    646678                }
    647679        }
     680
    648681        if (console_found) {
    649682                BSP_output_char = mpc55xx_esci_output_char;
  • c/src/lib/libcpu/powerpc/mpc55xx/include/dspi.h

    r115971c rd374492  
    2929
    3030#include <rtems/libi2c.h>
     31
     32#include <mpc55xx/edma.h>
    3133
    3234#ifdef __cplusplus
     
    6567         * @brief Selects SPI master or slave mode.
    6668         */
    67         int master;
     69        bool master;
    6870
    6971        /**
     
    7375
    7476        /**
    75          * @brief eDMA channel for transmission.
     77         * @brief eDMA entry for transmission.
    7678         *
    77          * The channel is fixed to particular DSPI.
     79         * The channel is fixed to a particular DSPI.
    7880         */
    79         int edma_channel_transmit;
     81        mpc55xx_edma_channel_entry edma_transmit;
    8082
    8183        /**
    82          * @brief eDMA channel to generate the push data.
     84         * @brief eDMA entry for push data generation.
    8385         *
    84          * You can choose any available channel.
     86         * You can choose every available channel.
    8587         */
    86         int edma_channel_push;
     88        mpc55xx_edma_channel_entry edma_push;
    8789
    8890        /**
    89          * @brief eDMA channel for receiving.
     91         * @brief eDMA entry for receiving.
    9092         *
    91          * The channel is fixed to particular DSPI.
     93         * The channel is fixed to a particular DSPI.
    9294         */
    93         int edma_channel_receive;
    94 
    95         /**
    96          * @brief Semaphore ID for a transmit update.
    97          */
    98         rtems_id edma_channel_transmit_update;
    99 
    100         /**
    101          * @brief Semaphore ID for a receive update.
    102          */
    103         rtems_id edma_channel_receive_update;
    104 
    105         /**
    106          * @brief Transmit error status.
    107          */
    108         uint32_t edma_channel_transmit_error;
    109 
    110         /**
    111          * @brief Receive error status.
    112          */
    113         uint32_t edma_channel_receive_error;
     95        mpc55xx_edma_channel_entry edma_receive;
    11496
    11597        /**
     
    11799         */
    118100        uint32_t idle_char;
     101
     102        /**
     103         * @brief Current baud.
     104         */
     105        uint32_t baud;
    119106} mpc55xx_dspi_bus_entry;
    120107
  • c/src/lib/libcpu/powerpc/mpc55xx/include/edma.h

    r115971c rd374492  
    2323
    2424#include <stdbool.h>
     25#include <stdint.h>
    2526
    2627#include <rtems.h>
     28#include <rtems/chain.h>
    2729
    2830#ifdef __cplusplus
     
    3032#endif /* __cplusplus */
    3133
    32 #define MPC55XX_EDMA_TCD_DEFAULT { \
    33         .SADDR = 0, \
    34         .SMOD = 0, \
    35         .SSIZE = 0x2, \
    36         .SOFF = 4, \
    37         .DADDR = 0, \
    38         .DMOD = 0, \
    39         .DSIZE = 0x2, \
    40         .DOFF = 4, \
    41         .NBYTES = 0, \
    42         .SLAST = 0, \
    43         .CITER = 1, \
    44         .BITER = 1, \
    45         .MAJORLINKCH = 0, \
    46         .CITERE_LINK = 0, \
    47         .BITERE_LINK = 0, \
    48         .MAJORE_LINK = 0, \
    49         .E_SG = 0, \
    50         .DLAST_SGA = 0, \
    51         .D_REQ = 0, \
    52         .BWC = 0, \
    53         .INT_HALF = 0, \
    54         .INT_MAJ = 0, \
    55         .DONE = 0, \
    56         .ACTIVE = 0, \
    57         .START = 0, \
    58 }
    59 
    60 #define MPC55XX_EDMA_TCD_ALT_DEFAULT { \
    61         .SADDR = 0, \
    62         .SMOD = 0, \
    63         .SSIZE = 2, \
    64         .DMOD = 0, \
    65         .DSIZE = 2, \
    66         .SOFF = 4, \
    67         .NBYTES = 0, \
    68         .SLAST = 0, \
    69         .DADDR = 0, \
    70         .CITERE_LINK = 0, \
    71         .CITERLINKCH = 0, \
    72         .CITER = 0, \
    73         .DOFF = 4, \
    74         .DLAST_SGA = 0, \
    75         .BITERE_LINK = 0, \
    76         .BITERLINKCH = 0, \
    77         .BITER = 0, \
    78         .BWC = 0, \
    79         .MAJORLINKCH = 0, \
    80         .DONE = 0, \
    81         .ACTIVE = 0, \
    82         .MAJORE_LINK = 0, \
    83         .E_SG = 0, \
    84         .D_REQ = 0, \
    85         .INT_HALF = 0, \
    86         .INT_MAJ = 0, \
    87         .START = 0, \
    88 }
     34typedef struct mpc55xx_edma_channel_entry {
     35        rtems_chain_node node;
     36        unsigned channel;
     37        void (*done)( struct mpc55xx_edma_channel_entry *, uint32_t);
     38        rtems_id id;
     39} mpc55xx_edma_channel_entry;
    8940
    9041rtems_status_code mpc55xx_edma_init();
    9142
    92 rtems_status_code mpc55xx_edma_obtain_channel( int channel, uint32_t *error_status, rtems_id transfer_update);
     43rtems_status_code mpc55xx_edma_obtain_channel( mpc55xx_edma_channel_entry *e);
    9344
    94 rtems_status_code mpc55xx_edma_enable_hardware_requests( int channel, bool enable);
     45rtems_status_code mpc55xx_edma_release_channel( mpc55xx_edma_channel_entry *e);
    9546
    96 rtems_status_code mpc55xx_edma_enable_error_interrupts( int channel, bool enable);
     47void mpc55xx_edma_enable_hardware_requests( unsigned channel, bool enable);
     48
     49void mpc55xx_edma_enable_error_interrupts( unsigned channel, bool enable);
    9750
    9851#ifdef __cplusplus
  • c/src/lib/libcpu/powerpc/mpc55xx/include/irq.h

    r115971c rd374492  
    3434
    3535/* Basics */
    36 #define MPC55XX_IRQ_MIN 0
    37 #define MPC55XX_IRQ_MAX 328
     36#define MPC55XX_IRQ_MIN 0U
     37#define MPC55XX_IRQ_MAX 328U
    3838#define MPC55XX_IRQ_BASE MPC55XX_IRQ_MIN
    39 #define MPC55XX_IRQ_NUMBER (MPC55XX_IRQ_MAX + 1)
     39#define MPC55XX_IRQ_NUMBER (MPC55XX_IRQ_MAX + 1U)
    4040
    4141/* Software interrupts */
    42 #define MPC55XX_IRQ_SOFTWARE_MIN 0
    43 #define MPC55XX_IRQ_SOFTWARE_MAX 7
    44 #define MPC55XX_IRQ_SOFTWARE_NUMBER (MPC55XX_IRQ_SOFTWARE_MAX + 1)
     42#define MPC55XX_IRQ_SOFTWARE_MIN 0U
     43#define MPC55XX_IRQ_SOFTWARE_MAX 7U
     44#define MPC55XX_IRQ_SOFTWARE_GET_INDEX( v) (v)
     45#define MPC55XX_IRQ_SOFTWARE_GET_REQUEST( i) (i)
     46#define MPC55XX_IRQ_SOFTWARE_NUMBER (MPC55XX_IRQ_SOFTWARE_MAX + 1U)
    4547
    4648/* eDMA interrupts */
    47 #define MPC55XX_IRQ_EDMA_ERROR_LOW 10
    48 #define MPC55XX_IRQ_EDMA_ERROR_HIGH 210
    49 #define MPC55XX_IRQ_EDMA_REQUEST_LOW_MIN 11
    50 #define MPC55XX_IRQ_EDMA_REQUEST_LOW_MAX 42
    51 #define MPC55XX_IRQ_EDMA_REQUEST_HIGH_MIN 211
    52 #define MPC55XX_IRQ_EDMA_REQUEST_HIGH_MAX 242
    53 #define MPC55XX_IRQ_EDMA_GET_CHANNEL( i) (((i) > MPC55XX_IRQ_EDMA_REQUEST_LOW_MAX) ? ((i) - MPC55XX_IRQ_EDMA_REQUEST_HIGH_MIN + 32) : ((i) - MPC55XX_IRQ_EDMA_REQUEST_LOW_MIN))
    54 #define MPC55XX_IRQ_EDMA_GET_REQUEST( c) (((c) > 31) ? ((c) + MPC55XX_IRQ_EDMA_REQUEST_HIGH_MIN - 32) : ((c) + MPC55XX_IRQ_EDMA_REQUEST_LOW_MIN))
     49#define MPC55XX_IRQ_EDMA_ERROR_LOW 10U
     50#define MPC55XX_IRQ_EDMA_ERROR_HIGH 210U
     51#define MPC55XX_IRQ_EDMA_REQUEST_LOW_MIN 11U
     52#define MPC55XX_IRQ_EDMA_REQUEST_LOW_MAX 42U
     53#define MPC55XX_IRQ_EDMA_REQUEST_HIGH_MIN 211U
     54#define MPC55XX_IRQ_EDMA_REQUEST_HIGH_MAX 242U
     55#define MPC55XX_IRQ_EDMA_GET_CHANNEL( v) (((v) > MPC55XX_IRQ_EDMA_REQUEST_LOW_MAX) ? ((v) + 32U - MPC55XX_IRQ_EDMA_REQUEST_HIGH_MIN) : ((v) - MPC55XX_IRQ_EDMA_REQUEST_LOW_MIN))
     56#define MPC55XX_IRQ_EDMA_GET_REQUEST( c) (((c) >= 32U) ? ((c) - 32U + MPC55XX_IRQ_EDMA_REQUEST_HIGH_MIN) : ((c) + MPC55XX_IRQ_EDMA_REQUEST_LOW_MIN))
     57
     58/* SIU external interrupts */
     59#define MPC55XX_IRQ_SIU_EXTERNAL_0 46U
     60#define MPC55XX_IRQ_SIU_EXTERNAL_1 47U
     61#define MPC55XX_IRQ_SIU_EXTERNAL_2 48U
     62#define MPC55XX_IRQ_SIU_EXTERNAL_3 49U
     63#define MPC55XX_IRQ_SIU_EXTERNAL_4_15 50U
     64
     65/* eMIOS interrupts */
     66#define MPC55XX_IRQ_EMIOS_REQUEST_LOW_MIN 51U
     67#define MPC55XX_IRQ_EMIOS_REQUEST_LOW_MAX 66U
     68#define MPC55XX_IRQ_EMIOS_REQUEST_HIGH_MIN 202U
     69#define MPC55XX_IRQ_EMIOS_REQUEST_HIGH_MAX 209U
     70#define MPC55XX_IRQ_EMIOS_GET_CHANNEL( v) (((v) > MPC55XX_IRQ_EMIOS_REQUEST_LOW_MAX) ? ((v) + 16U - MPC55XX_IRQ_EMIOS_REQUEST_HIGH_MIN) : ((v) - MPC55XX_IRQ_EMIOS_REQUEST_LOW_MIN))
     71#define MPC55XX_IRQ_EMIOS_GET_REQUEST( c) (((c) >= 16U) ? ((c) - 16U + MPC55XX_IRQ_EMIOS_REQUEST_HIGH_MIN) : ((c) + MPC55XX_IRQ_EMIOS_REQUEST_LOW_MIN))
    5572
    5673/* Checks */
    57 #define MPC55XX_IRQ_IS_VALID(i) ((i) >= MPC55XX_IRQ_MIN && (i) <= MPC55XX_IRQ_MAX)
    58 #define MPC55XX_IRQ_IS_SOFTWARE(i) ((i) >= MPC55XX_IRQ_SOFTWARE_MIN && (i) <= MPC55XX_IRQ_SOFTWARE_MAX)
     74#define MPC55XX_IRQ_IS_VALID(v) ((v) >= MPC55XX_IRQ_MIN && (v) <= MPC55XX_IRQ_MAX)
     75#define MPC55XX_IRQ_IS_SOFTWARE(v) ((v) >= MPC55XX_IRQ_SOFTWARE_MIN && (v) <= MPC55XX_IRQ_SOFTWARE_MAX)
    5976
    6077/*
     
    6279 */
    6380
    64 #define MPC55XX_INTC_INVALID_PRIORITY -1
    65 #define MPC55XX_INTC_DISABLED_PRIORITY 0
    66 #define MPC55XX_INTC_MIN_PRIORITY 1
    67 #define MPC55XX_INTC_MAX_PRIORITY 15
    68 #define MPC55XX_INTC_DEFAULT_PRIORITY MPC55XX_INTC_MIN_PRIORITY
     81#define MPC55XX_INTC_MIN_PRIORITY 1U
     82#define MPC55XX_INTC_MAX_PRIORITY 15U
     83#define MPC55XX_INTC_DISABLED_PRIORITY 0U
     84#define MPC55XX_INTC_INVALID_PRIORITY (MPC55XX_INTC_MAX_PRIORITY + 1)
     85#define MPC55XX_INTC_DEFAULT_PRIORITY (MPC55XX_INTC_MIN_PRIORITY + 1)
    6986#define MPC55XX_INTC_IS_VALID_PRIORITY(p) ((p) >= MPC55XX_INTC_DISABLED_PRIORITY && (p) <= MPC55XX_INTC_MAX_PRIORITY)
    7087
    7188rtems_status_code mpc55xx_interrupt_handler_install(
    7289        rtems_vector_number vector,
    73         int priority,
    7490        const char *info,
    7591        rtems_option options,
     92        unsigned priority,
    7693        rtems_interrupt_handler handler,
    7794        void *arg
    7895);
    7996
    80 rtems_status_code mpc55xx_intc_get_priority( int i, int *p);
     97rtems_status_code mpc55xx_intc_get_priority( rtems_vector_number vector, unsigned *priority);
    8198
    82 rtems_status_code mpc55xx_intc_set_priority( int i, int p);
     99rtems_status_code mpc55xx_intc_set_priority( rtems_vector_number vector, unsigned priority);
    83100
    84 rtems_status_code mpc55xx_intc_raise_software_irq( int i);
     101rtems_status_code mpc55xx_intc_raise_software_irq( rtems_vector_number vector);
    85102
    86 rtems_status_code mpc55xx_intc_clear_software_irq( int i);
     103rtems_status_code mpc55xx_intc_clear_software_irq( rtems_vector_number vector);
    87104
    88105#ifdef __cplusplus
  • c/src/lib/libcpu/powerpc/mpc55xx/include/regs.h

    r115971c rd374492  
    667667        } SRCR;
    668668
    669         union {                 /* External Interrupt Status Register */
     669        union SIU_EISR_tag {    /* External Interrupt Status Register */
    670670            uint32_t R;
    671671            struct {
     
    690690        } EISR;
    691691
    692         union {                 /* DMA/Interrupt Request Enable Register */
     692        union SIU_DIRER_tag {   /* DMA/Interrupt Request Enable Register */
    693693            uint32_t R;
    694694            struct {
     
    713713        } DIRER;
    714714
    715         union {                 /* DMA/Interrupt Select Register */
     715        union SIU_DIRSR_tag {   /* DMA/Interrupt Select Register */
    716716            uint32_t R;
    717717            struct {
     
    724724        } DIRSR;
    725725
    726         union {                 /* Overrun Status Register */
     726        union SIU_OSR_tag {     /* Overrun Status Register */
    727727            uint32_t R;
    728728            struct {
     
    747747        } OSR;
    748748
    749         union {                 /* Overrun Request Enable Register */
     749        union SIU_ORER_tag {    /* Overrun Request Enable Register */
    750750            uint32_t R;
    751751            struct {
     
    770770        } ORER;
    771771
    772         union {                 /* External IRQ Rising-Edge Event Enable Register */
     772        union SIU_IREER_tag {   /* External IRQ Rising-Edge Event Enable Register */
    773773            uint32_t R;
    774774            struct {
     
    793793        } IREER;
    794794
    795         union {                 /* External IRQ Falling-Edge Event Enable Register */
     795        union SIU_IFEER_tag {   /* External IRQ Falling-Edge Event Enable Register */
    796796            uint32_t R;
    797797            struct {
     
    816816        } IFEER;
    817817
    818         union {                 /* External IRQ Digital Filter Register */
     818        union SIU_IDFR_tag {    /* External IRQ Digital Filter Register */
    819819            uint32_t R;
    820820            struct {
     
    964964/****************************************************************************/
    965965    struct EMIOS_tag {
    966         union {
     966        union EMIOS_MCR_tag {
    967967            uint32_t R;
    968968            struct {
     
    980980        } MCR;                  /* Module Configuration Register */
    981981
    982         union {
     982        union EMIOS_GFR_tag {
    983983            uint32_t R;
    984984            struct {
     
    10111011        } GFR;                  /* Global FLAG Register */
    10121012
    1013         union {
     1013        union EMIOS_OUDR_tag {
    10141014            uint32_t R;
    10151015            struct {
     
    10441044        uint32_t emios_reserved[5];
    10451045
    1046         struct {
     1046        struct EMIOS_CH_tag {
    10471047            union {
    10481048                uint32_t R;    /* Channel A Data Register */
     
    10571057            } CCNTR;
    10581058
    1059             union {
     1059            union EMIOS_CCR_tag {
    10601060                uint32_t R;
    10611061                struct {
     
    10811081            } CCR;              /* Channel Control Register */
    10821082
    1083             union {
     1083            union EMIOS_CSR_tag {
    10841084                uint32_t R;
    10851085                struct {
     
    21662166        union {
    21672167            uint16_t R;
    2168         } SWTCR;                //Software Watchdog Timer Control
     2168        } SWTCR;                /* Software Watchdog Timer Control */
    21692169
    21702170        uint8_t ecsm_reserved3[3];
     
    21722172        union {
    21732173            uint8_t R;
    2174         } SWTSR;                //SWT Service Register
     2174        } SWTSR;                /* SWT Service Register */
    21752175
    21762176        uint8_t ecsm_reserved4[3];
     
    21782178        union {
    21792179            uint8_t R;
    2180         } SWTIR;                //SWT Interrupt Register
     2180        } SWTIR;                /* SWT Interrupt Register */
    21812181
    21822182        uint32_t ecsm_reserved5a[1];
     
    22112211                uint8_t EFNCR:1;
    22122212            } B;
    2213         } ECR;                  //ECC Configuration Register
     2213        } ECR;                  /* ECC Configuration Register */
    22142214
    22152215        uint8_t mcm_reserved8[3];
     
    22222222                uint8_t FNCE:1;
    22232223            } B;
    2224         } ESR;                  //ECC Status Register
     2224        } ESR;                  /* ECC Status Register */
    22252225
    22262226        uint16_t ecsm_reserved9;
     
    22352235                uint16_t ERRBIT:7;
    22362236            } B;
    2237         } EEGR;                 //ECC Error Generation Register
     2237        } EEGR;                 /* ECC Error Generation Register */
    22382238
    22392239        uint32_t ecsm_reserved10;
     
    22442244                uint32_t FEAR:32;
    22452245            } B;
    2246         } FEAR;                 //Flash ECC Address Register
     2246        } FEAR;                 /* Flash ECC Address Register */
    22472247
    22482248        uint16_t ecsm_reserved11;
     
    22542254                uint8_t FEMR:4;
    22552255            } B;
    2256         } FEMR;                 //Flash ECC Master Register
     2256        } FEMR;                 /* Flash ECC Master Register */
    22572257
    22582258        union {
     
    22662266                uint8_t PROT3:1;
    22672267            } B;
    2268         } FEAT;                 //Flash ECC Attributes Register
     2268        } FEAT;                 /* Flash ECC Attributes Register */
    22692269
    22702270        union {
     
    22732273                uint32_t FEDH:32;
    22742274            } B;
    2275         } FEDRH;                //Flash ECC Data High Register
     2275        } FEDRH;                /* Flash ECC Data High Register */
    22762276
    22772277        union {
     
    22802280                uint32_t FEDL:32;
    22812281            } B;
    2282         } FEDRL;                //Flash ECC Data Low Register
     2282        } FEDRL;                /* Flash ECC Data Low Register */
    22832283
    22842284        union {
     
    22872287                uint32_t REAR:32;
    22882288            } B;
    2289         } REAR;                 //RAM ECC Address
     2289        } REAR;                 /* RAM ECC Address */
    22902290
    22912291        uint8_t ecsm_reserved12[2];
     
    22972297                uint8_t REMR:4;
    22982298            } B;
    2299         } REMR;                 //RAM ECC Master
     2299        } REMR;                 /* RAM ECC Master */
    23002300
    23012301        union {
     
    23092309                uint8_t PROT3:1;
    23102310            } B;
    2311         } REAT;                 // RAM ECC Attributes Register
     2311        } REAT;                 /*  RAM ECC Attributes Register */
    23122312
    23132313        union {
     
    23162316                uint32_t REDH:32;
    23172317            } B;
    2318         } REDRH;                //RAM ECC Data High Register
     2318        } REDRH;                /* RAM ECC Data High Register */
    23192319
    23202320        union {
     
    23232323                uint32_t REDL:32;
    23242324            } B;
    2325         } REDRL;                //RAMECC Data Low Register
     2325        } REDRL;                /* RAMECC Data Low Register */
    23262326
    23272327    };
     
    27292729            uint32_t SADDR;    /* source address */
    27302730
    2731             uint16_t SMOD:5;   /* source address modulo */
    2732             uint16_t SSIZE:3;  /* source transfer size */
    2733             uint16_t DMOD:5;   /* destination address modulo */
    2734             uint16_t DSIZE:3;  /* destination transfer size */
    2735             int16_t SOFF;      /* signed source address offset */
     2731            /* Source and destination fields */
     2732            union tcd_SDF_tag {
     2733                uint32_t R;
     2734                struct {
     2735                    uint16_t SMOD:5;   /* source address modulo */
     2736                    uint16_t SSIZE:3;  /* source transfer size */
     2737                    uint16_t DMOD:5;   /* destination address modulo */
     2738                    uint16_t DSIZE:3;  /* destination transfer size */
     2739                    int16_t SOFF;      /* signed source address offset */
     2740                } B;
     2741            } SDF;
    27362742
    27372743            uint32_t NBYTES;   /* inner (“minor”) byte count */
    27382744
    27392745            int32_t SLAST;     /* last destination address adjustment, or
    2740 
    27412746                                   scatter/gather address (if e_sg = 1) */
     2747
    27422748            uint32_t DADDR;    /* destination address */
    27432749
    2744             uint16_t CITERE_LINK:1;
    2745             uint16_t CITER:15;
    2746 
    2747             int16_t DOFF;      /* signed destination address offset */
     2750            /* CITER and destination fields */
     2751            union tcd_CDF_tag {
     2752                uint32_t R;
     2753                struct {
     2754                    uint16_t CITERE_LINK:1;
     2755                    uint16_t CITER:15;
     2756                    int16_t DOFF;      /* signed destination address offset */
     2757                } B;
     2758                struct {
     2759                    uint16_t CITERE_LINK:1;
     2760                    uint16_t CITERLINKCH:6;
     2761                    uint16_t CITER:9;
     2762                    int16_t DOFF;
     2763                } B_ALT;
     2764            } CDF;
    27482765
    27492766            int32_t DLAST_SGA;
    27502767
    2751             uint16_t BITERE_LINK:1;    /* beginning ("major") iteration count */
    2752             uint16_t BITER:15;
    2753 
    2754             uint16_t BWC:2;    /* bandwidth control */
    2755             uint16_t MAJORLINKCH:6;    /* enable channel-to-channel link */
    2756             uint16_t DONE:1;   /* channel done */
    2757             uint16_t ACTIVE:1; /* channel active */
    2758             uint16_t MAJORE_LINK:1;    /* enable channel-to-channel link */
    2759             uint16_t E_SG:1;   /* enable scatter/gather descriptor */
    2760             uint16_t D_REQ:1;  /* disable ipd_req when done */
    2761             uint16_t INT_HALF:1;       /* interrupt on citer = (biter >> 1) */
    2762             uint16_t INT_MAJ:1;        /* interrupt on major loop completion */
    2763             uint16_t START:1;  /* explicit channel start */
     2768            /* BITER and misc fields */
     2769            union tcd_BMF_tag {
     2770                uint32_t R;
     2771                struct {
     2772                    uint32_t BITERE_LINK:1;    /* beginning ("major") iteration count */
     2773                    uint32_t BITER:15;
     2774                    uint32_t BWC:2;    /* bandwidth control */
     2775                    uint32_t MAJORLINKCH:6;    /* enable channel-to-channel link */
     2776                    uint32_t DONE:1;   /* channel done */
     2777                    uint32_t ACTIVE:1; /* channel active */
     2778                    uint32_t MAJORE_LINK:1;    /* enable channel-to-channel link */
     2779                    uint32_t E_SG:1;   /* enable scatter/gather descriptor */
     2780                    uint32_t D_REQ:1;  /* disable ipd_req when done */
     2781                    uint32_t INT_HALF:1;       /* interrupt on citer = (biter >> 1) */
     2782                    uint32_t INT_MAJ:1;        /* interrupt on major loop completion */
     2783                    uint32_t START:1;  /* explicit channel start */
     2784                } B;
     2785                struct {
     2786                    uint32_t BITERE_LINK:1;
     2787                    uint32_t BITERLINKCH:6;
     2788                    uint32_t BITER:9;
     2789                    uint32_t BWC:2;
     2790                    uint32_t MAJORLINKCH:6;
     2791                    uint32_t DONE:1;
     2792                    uint32_t ACTIVE:1;
     2793                    uint32_t MAJORE_LINK:1;
     2794                    uint32_t E_SG:1;
     2795                    uint32_t D_REQ:1;
     2796                    uint32_t INT_HALF:1;
     2797                    uint32_t INT_MAJ:1;
     2798                    uint32_t START:1;
     2799                } B_ALT;
     2800            } BMF;
    27642801        } TCD[64];              /* transfer_control_descriptor */
    2765 
    27662802    };
    27672803
     2804    static const struct tcd_t EDMA_TCD_DEFAULT = {
     2805        .SADDR = 0,
     2806        .SDF = { .R = 0 },
     2807        .NBYTES = 0,
     2808        .SLAST = 0,
     2809        .DADDR = 0,
     2810        .CDF = { .R = 0 },
     2811        .DLAST_SGA = 0,
     2812        .BMF = { .R = 0 }
     2813    };
     2814
    27682815#define EDMA_TCD_BITER_MASK 0x7fff
    27692816
     
    27762823#define EDMA_TCD_LINK_AND_BITER( link, biter) (((link) << 9) + ((biter) & EDMA_TCD_BITER_LINKED_MASK))
    27772824
    2778 #define EDMA_TCD_BITER_LINK( channel) (EDMA.TCD [(channel)].BITER >> 9)
    2779 
    2780 /* This is outside of the eDMA structure */
    2781 /* There are 2 possible ways to use the citer bit field, this structure */
    2782 /* uses the different format from the main structure.                   */
    2783     struct tcd_alt_t {
    2784         uint32_t SADDR;        /* source address */
    2785 
    2786         uint16_t SMOD:5;       /* source address modulo */
    2787         uint16_t SSIZE:3;      /* source transfer size */
    2788         uint16_t DMOD:5;       /* destination address modulo */
    2789         uint16_t DSIZE:3;      /* destination transfer size */
    2790         int16_t SOFF;          /* signed source address offset */
    2791 
    2792         uint32_t NBYTES;       /* inner (“minor”) byte count */
    2793 
    2794         int32_t SLAST;         /* last destination address adjustment, or
    2795 
    2796                                    scatter/gather address (if e_sg = 1) */
    2797         uint32_t DADDR;        /* destination address */
    2798 
    2799         uint16_t CITERE_LINK:1;
    2800         uint16_t CITERLINKCH:6;
    2801         uint16_t CITER:9;
    2802 
    2803         int16_t DOFF;          /* signed destination address offset */
    2804 
    2805         int32_t DLAST_SGA;
    2806 
    2807         uint16_t BITERE_LINK:1;        /* beginning (“major”) iteration count */
    2808         uint16_t BITERLINKCH:6;
    2809         uint16_t BITER:9;
    2810 
    2811         uint16_t BWC:2;        /* bandwidth control */
    2812         uint16_t MAJORLINKCH:6;        /* enable channel-to-channel link */
    2813         uint16_t DONE:1;       /* channel done */
    2814         uint16_t ACTIVE:1;     /* channel active */
    2815         uint16_t MAJORE_LINK:1;        /* enable channel-to-channel link */
    2816         uint16_t E_SG:1;       /* enable scatter/gather descriptor */
    2817         uint16_t D_REQ:1;      /* disable ipd_req when done */
    2818         uint16_t INT_HALF:1;   /* interrupt on citer = (biter >> 1) */
    2819         uint16_t INT_MAJ:1;    /* interrupt on major loop completion */
    2820         uint16_t START:1;      /* explicit channel start */
    2821     };                          /* transfer_control_descriptor */
     2825#define EDMA_TCD_BITER_LINK( channel) (EDMA.TCD [(channel)].BMF.B.BITER >> 9)
     2826
    28222827/****************************************************************************/
    28232828/*                          MODULE : INTC                                   */
     
    42504255    };
    42514256
     4257/****************************************************************************/
     4258/*                          MMU                                             */
     4259/****************************************************************************/
     4260    struct MMU_tag {
     4261        union {
     4262            uint32_t R;
     4263            struct {
     4264                uint32_t : 2;
     4265                uint32_t TLBSEL : 2;
     4266                uint32_t : 7;
     4267                uint32_t ESEL : 5;
     4268                uint32_t : 11;
     4269                uint32_t NV : 5;
     4270            } B;
     4271        } MAS0;
     4272
     4273        union {
     4274            uint32_t R;
     4275            struct {
     4276                uint32_t VALID : 1;
     4277                uint32_t IPROT : 1;
     4278                uint32_t : 6;
     4279                uint32_t TID : 8;
     4280                uint32_t : 3;
     4281                uint32_t TS : 1;
     4282                uint32_t TSIZ : 4;
     4283                uint32_t : 8;
     4284            } B;
     4285        } MAS1;
     4286
     4287        union {
     4288            uint32_t R;
     4289            struct {
     4290                uint32_t EPN : 20;
     4291                uint32_t : 7;
     4292                uint32_t W : 1;
     4293                uint32_t I : 1;
     4294                uint32_t M : 1;
     4295                uint32_t G : 1;
     4296                uint32_t E : 1;
     4297            } B;
     4298        } MAS2;
     4299
     4300        union {
     4301            uint32_t R;
     4302            struct {
     4303                uint32_t RPN : 20;
     4304                uint32_t : 2;
     4305                uint32_t U0 : 1;
     4306                uint32_t U1 : 1;
     4307                uint32_t U2 : 1;
     4308                uint32_t U3 : 1;
     4309                uint32_t UX : 1;
     4310                uint32_t SX : 1;
     4311                uint32_t UW : 1;
     4312                uint32_t SW : 1;
     4313                uint32_t UR : 1;
     4314                uint32_t SR : 1;
     4315            } B;
     4316        } MAS3;
     4317
     4318        union {
     4319            uint32_t R;
     4320            struct {
     4321                uint32_t : 2;
     4322                uint32_t TLBSELD : 2;
     4323                uint32_t : 10;
     4324                uint32_t TIDSELD : 2;
     4325                uint32_t : 4;
     4326                uint32_t TSIZED : 4;
     4327                uint32_t : 3;
     4328                uint32_t WD : 1;
     4329                uint32_t ID : 1;
     4330                uint32_t MD : 1;
     4331                uint32_t GD : 1;
     4332                uint32_t ED : 1;
     4333            } B;
     4334        } MAS4;
     4335
     4336        union {
     4337            uint32_t R;
     4338            struct {
     4339                uint32_t : 8;
     4340                uint32_t SPID : 8;
     4341                uint32_t : 15;
     4342                uint32_t SAS : 1;
     4343            } B;
     4344        } MAS6;
     4345    };
     4346
     4347    static const struct MMU_tag MMU_DEFAULT = {
     4348        .MAS0 = { .R = 0x10000000 },
     4349        .MAS1 = { .R = 0 },
     4350        .MAS2 = { .R = 0 },
     4351        .MAS3 = { .R = 0 },
     4352        .MAS4 = { .R = 0 },
     4353        .MAS6 = { .R = 0 }
     4354    };
     4355
    42524356/* Define memories */
    42534357
     
    43094413 *
    43104414 * Copyright:
    4311  *      Freescale Semiconductor, INC. All Rights Reserved.
     4415 *  Freescale Semiconductor, INC. All Rights Reserved.
    43124416 *  You are hereby granted a copyright license to use, modify, and
    43134417 *  distribute the SOFTWARE so long as this entire notice is
  • c/src/lib/libcpu/powerpc/mpc55xx/irq/irq.c

    r115971c rd374492  
    2222
    2323#include <libcpu/raw_exception.h>
     24#include <libcpu/powerpc-utility.h>
    2425
    2526#include <bsp/irq.h>
     
    3233
    3334/**
    34  * @brief Returns the priority @a p of IRQ @a i from the INTC.
     35 * @brief Returns the priority @a priority of IRQ @a vector from the INTC.
    3536 */
    36 rtems_status_code mpc55xx_intc_get_priority( int i, int *p)
     37rtems_status_code mpc55xx_intc_get_priority( rtems_vector_number vector, unsigned *priority)
    3738{
    38         if (MPC55XX_IRQ_IS_VALID( i)) {
    39                 *p = INTC.PSR [i].B.PRI;
     39        if (MPC55XX_IRQ_IS_VALID( vector)) {
     40                *priority = INTC.PSR [vector].B.PRI;
    4041                return RTEMS_SUCCESSFUL;
    4142        } else {
    42                 *p = MPC55XX_INTC_INVALID_PRIORITY;
     43                *priority = MPC55XX_INTC_INVALID_PRIORITY;
    4344                return RTEMS_INVALID_NUMBER;
    4445        }             
     
    4647
    4748/**
    48  * @brief Sets the priority of IRQ @a i to @a p at the INTC.
     49 * @brief Sets the priority of IRQ @a vector to @a priority at the INTC.
    4950 */
    50 rtems_status_code mpc55xx_intc_set_priority( int i, int p)
     51rtems_status_code mpc55xx_intc_set_priority( rtems_vector_number vector, unsigned priority)
    5152{
    52         if (MPC55XX_IRQ_IS_VALID( i) && MPC55XX_INTC_IS_VALID_PRIORITY( p)) {
    53                 INTC.PSR [i].B.PRI = p;
    54                 if (INTC.PSR [i].B.PRI == p) {
     53        if (MPC55XX_IRQ_IS_VALID( vector) && MPC55XX_INTC_IS_VALID_PRIORITY( priority)) {
     54                INTC.PSR [vector].B.PRI = priority;
     55                if (INTC.PSR [vector].B.PRI == priority) {
    5556                        return RTEMS_SUCCESSFUL;
    5657                } else {
     
    6364
    6465/**
    65  * @brief Raises the software IRQ with number @a i.
     66 * @brief Raises the software IRQ with number @a vector.
    6667 */
    67 rtems_status_code mpc55xx_intc_raise_software_irq( int i)
     68rtems_status_code mpc55xx_intc_raise_software_irq( rtems_vector_number vector)
    6869{
    69         if (MPC55XX_IRQ_IS_SOFTWARE( i)) {
    70                 INTC.SSCIR [i].B.SET = 1;
     70        if (MPC55XX_IRQ_IS_SOFTWARE( vector)) {
     71                INTC.SSCIR [vector].B.SET = 1;
    7172                return RTEMS_SUCCESSFUL;
    7273        } else {
     
    7677
    7778/**
    78  * @brief Clears the software IRQ with number @a i.
     79 * @brief Clears the software IRQ with number @a vector.
    7980 */
    80 rtems_status_code mpc55xx_intc_clear_software_irq( int i)
     81rtems_status_code mpc55xx_intc_clear_software_irq( rtems_vector_number vector)
    8182{
    82         if (MPC55XX_IRQ_IS_SOFTWARE( i)) {
    83                 INTC.SSCIR [i].B.CLR = 1;
     83        if (MPC55XX_IRQ_IS_SOFTWARE( vector)) {
     84                INTC.SSCIR [vector].B.CLR = 1;
    8485                return RTEMS_SUCCESSFUL;
    8586        } else {
     
    9394rtems_status_code mpc55xx_interrupt_handler_install(
    9495        rtems_vector_number vector,
    95         int priority,
    9696        const char *info,
    9797        rtems_option options,
     98        unsigned priority,
    9899        rtems_interrupt_handler handler,
    99100        void *arg
    100101)
    101102{
    102         rtems_status_code sc = RTEMS_SUCCESSFUL;
     103        if (MPC55XX_IRQ_IS_VALID( vector) && MPC55XX_INTC_IS_VALID_PRIORITY( priority)) {
     104                rtems_status_code sc = RTEMS_SUCCESSFUL;
    103105
    104         if (MPC55XX_IRQ_IS_VALID( vector) && MPC55XX_INTC_IS_VALID_PRIORITY( priority)) {
    105106                sc = rtems_interrupt_handler_install( vector, info, options, handler, arg);
    106107                RTEMS_CHECK_SC( sc, "Install interrupt handler");
     108
    107109                return mpc55xx_intc_set_priority( vector, priority);
    108110        } else {
     
    117119{
    118120        /* Acknowlege interrupt request */
    119         rtems_vector_number vector_number = INTC.IACKR.B.INTVEC;
     121        rtems_vector_number vector = INTC.IACKR.B.INTVEC;
    120122
    121         /* Save current interrupt level */
    122         uint32_t level = _ISR_Get_level();
    123 
    124         /* Enable all interrupts */
    125         _ISR_Set_level( 0);
     123        /* Save machine state and enable external exceptions */
     124        uint32_t msr = ppc_external_exceptions_enable();
    126125
    127126        /* Dispatch interrupt handlers */
    128         bsp_interrupt_handler_dispatch( vector_number);
     127        bsp_interrupt_handler_dispatch( vector);
    129128
    130         /* Restore interrupt level */
    131         _ISR_Set_level( level);
     129        /* Restore machine state */
     130        ppc_external_exceptions_disable( msr);
    132131
    133132        /* End of interrupt */
  • c/src/lib/libcpu/powerpc/preinstall.am

    r115971c rd374492  
    288288PREINSTALL_FILES += $(PROJECT_INCLUDE)/mpc55xx/edma.h
    289289
     290$(PROJECT_INCLUDE)/mpc55xx/emios.h: mpc55xx/include/emios.h $(PROJECT_INCLUDE)/mpc55xx/$(dirstamp)
     291        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/mpc55xx/emios.h
     292PREINSTALL_FILES += $(PROJECT_INCLUDE)/mpc55xx/emios.h
     293
    290294$(PROJECT_INCLUDE)/mpc55xx/mpc55xx.h: mpc55xx/include/mpc55xx.h $(PROJECT_INCLUDE)/mpc55xx/$(dirstamp)
    291295        $(INSTALL_DATA) $< $(PROJECT_INCLUDE)/mpc55xx/mpc55xx.h
Note: See TracChangeset for help on using the changeset viewer.