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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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};
Note: See TracChangeset for help on using the changeset viewer.