source: rtems/c/src/lib/libbsp/powerpc/mpc55xxevb/tests/tests.c @ ac7af4a

4.104.11
Last change on this file since ac7af4a was ac7af4a, checked in by Ralf Corsepius <ralf.corsepius@…>, on Nov 30, 2009 at 4:37:44 AM

Whitespace removal.

  • Property mode set to 100644
File size: 18.0 KB
RevLine 
[dab9e55c]1/**
2 * @file
3 *
4 * @ingroup mpc55xx
5 *
6 * @brief Some tests.
7 */
8
9/*
10 * Copyright (c) 2008
11 * Embedded Brains GmbH
12 * Obere Lagerstr. 30
13 * D-82178 Puchheim
14 * Germany
15 * rtems@embedded-brains.de
16 *
17 * The license and distribution terms for this file may be found in the file
18 * LICENSE in this distribution or at http://www.rtems.com/license/LICENSE.
19 */
20
[574fb67]21#include <stdio.h>
22
23#include <rtems/irq.h>
24
25#include <mpc55xx/regs.h>
26#include <mpc55xx/mpc55xx.h>
27#include <mpc55xx/dspi.h>
28#include <mpc55xx/edma.h>
29
30#include <libchip/spi-sd-card.h>
31
32#include <bsp.h>
33#include <bsp/irq.h>
34
35#include <rtems/irq-extension.h>
36
37#include <libcpu/powerpc-utility.h>
38
39#include <rtems/status-checks.h>
40
41static rtems_driver_address_table test_mpc55xx_drv_ops = {
42        initialization_entry : NULL,
43        open_entry : NULL,
44        close_entry : NULL,
45        read_entry : NULL,
46        write_entry : NULL,
47        control_entry : NULL
48};
49
50static rtems_libi2c_drv_t test_mpc55xx_dspi_drv = {
51        ops : &test_mpc55xx_drv_ops,
52        size : sizeof( rtems_libi2c_drv_t)
53};
54
55#define MPC55XX_TEST_DSPI_ADDRESS 0
56
[7e5bf38]57/* #define MPC55XX_TEST_DSPI_BUFSIZE (16 * 32) */
[574fb67]58#define MPC55XX_TEST_DSPI_BUFSIZE 8
59
[7e5bf38]60/* #define MPC55XX_TEST_DSPI_BUFSIZE_CACHE_PROOF MPC55XX_TEST_DSPI_BUFSIZE */
[574fb67]61#define MPC55XX_TEST_DSPI_BUFSIZE_CACHE_PROOF 32
62
63rtems_device_minor_number test_mpc55xx_dspi_bus [MPC55XX_DSPI_NUMBER];
64
65static rtems_libi2c_tfr_mode_t test_mpc55xx_dspi_transfer_mode = { baudrate : 550000, bits_per_char : 8, lsb_first : FALSE, clock_inv : FALSE, clock_phs : FALSE };
66
67static rtems_id test_mpc55xx_dspi_ping;
68
69static rtems_id test_mpc55xx_dspi_pong;
70
71static unsigned char test_mpc55xx_dspi_writer_outbuf [2] [MPC55XX_TEST_DSPI_BUFSIZE_CACHE_PROOF] __attribute__ ((aligned (32)));
72
73static unsigned char test_mpc55xx_dspi_writer_inbuf [MPC55XX_TEST_DSPI_BUFSIZE_CACHE_PROOF] __attribute__ ((aligned (32)));
74
75static unsigned char test_mpc55xx_dspi_reader_inbuf [MPC55XX_TEST_DSPI_BUFSIZE_CACHE_PROOF] __attribute__ ((aligned (32)));
76
77static rtems_task test_mpc55xx_dspi_writer( rtems_task_argument arg)
78{
79        rtems_status_code sc = RTEMS_SUCCESSFUL;
80        int rv = 0;
81        rtems_device_minor_number device;
82        rtems_libi2c_read_write_t read_and_write = { rd_buf : NULL, wr_buf : NULL, byte_cnt : 0 };
83        int i = 0;
84
[7495494]85        RTEMS_DEBUG_PRINT( "Task started\n");
[574fb67]86
87        device = rtems_libi2c_register_drv( NULL, &test_mpc55xx_dspi_drv, test_mpc55xx_dspi_bus [2], 0);
[7495494]88        RTEMS_CHECK_RV_TASK( device, "rtems_libi2c_register_drv");
[574fb67]89
90        sc = rtems_libi2c_send_start( device);
[7495494]91        RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_start");
[574fb67]92
93        rv = rtems_libi2c_ioctl( device, RTEMS_LIBI2C_IOCTL_SET_TFRMODE, &test_mpc55xx_dspi_transfer_mode);
[7495494]94        RTEMS_CHECK_RV_TASK( rv, "rtems_libi2c_ioctl");
[574fb67]95
96        sc = rtems_libi2c_send_addr( device, MPC55XX_TEST_DSPI_ADDRESS);
[7495494]97        RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_addr");
[ac7af4a]98
[574fb67]99        for (i = 0; i < MPC55XX_TEST_DSPI_BUFSIZE; ++i) {
100                test_mpc55xx_dspi_writer_outbuf [0] [i] = 0xa5;
101                test_mpc55xx_dspi_writer_outbuf [1] [i] = 0xa5;
[7e5bf38]102                /* test_mpc55xx_dspi_writer_outbuf [0] [i] = i + 1; */
103                /* test_mpc55xx_dspi_writer_outbuf [1] [i] = -(i + 1); */
[574fb67]104        }
105
106        int toggle = 0;
107        read_and_write.byte_cnt = MPC55XX_TEST_DSPI_BUFSIZE;
108        read_and_write.rd_buf = test_mpc55xx_dspi_writer_inbuf;
109        read_and_write.wr_buf = test_mpc55xx_dspi_writer_outbuf [toggle];
110        while (1) {
111                tic();
112
[7e5bf38]113                /* sc = rtems_semaphore_obtain( test_mpc55xx_dspi_pong, RTEMS_WAIT, RTEMS_NO_TIMEOUT); */
[7495494]114                /* RTEMS_CHECK_SC_TASK( sc, "rtems_semaphore_obtain"); */
[574fb67]115
[7495494]116                RTEMS_DEBUG_PRINT( "Ping\n");
[574fb67]117
[7e5bf38]118                /* sc = rtems_libi2c_send_start( device); */
[7495494]119                /* RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_start"); */
[574fb67]120
[7e5bf38]121                /* sc = rtems_libi2c_send_addr( device, MPC55XX_TEST_DSPI_ADDRESS); */
[7495494]122                /* RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_addr"); */
[574fb67]123
124                rv = rtems_libi2c_ioctl( device, RTEMS_LIBI2C_IOCTL_READ_WRITE, &read_and_write);
[7495494]125                RTEMS_CHECK_RV_TASK( rv, "rtems_libi2c_ioctl: RTEMS_LIBI2C_IOCTL_READ_WRITE");
[574fb67]126
[7e5bf38]127                /* rv = rtems_libi2c_write_bytes( device, test_mpc55xx_dspi_writer_outbuf [0], MPC55XX_TEST_DSPI_BUFSIZE); */
[7495494]128                /* RTEMS_CHECK_RV_TASK( rv, "rtems_libi2c_write_bytes"); */
[574fb67]129
[7e5bf38]130                /* sc = rtems_libi2c_send_stop( device); */
[7495494]131                /* RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_stop"); */
[574fb67]132
133                toggle = toggle ? 0 : 1;
134                read_and_write.wr_buf = test_mpc55xx_dspi_writer_outbuf [toggle];
135
[7e5bf38]136                /* sc = rtems_semaphore_release( test_mpc55xx_dspi_ping); */
[7495494]137                /* RTEMS_CHECK_SC_TASK( sc, "rtems_semaphore_release"); */
[574fb67]138        }
139
140        sc = rtems_libi2c_send_stop( device);
[7495494]141        RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_stop");
[574fb67]142
143        sc = rtems_task_delete( RTEMS_SELF);
[7495494]144        RTEMS_CHECK_SC_TASK( sc, "rtems_task_delete");
[574fb67]145}
146
147static rtems_task test_mpc55xx_dspi_reader( rtems_task_argument arg)
148{
149        rtems_status_code sc = RTEMS_SUCCESSFUL;
150        int rv = 0;
151        rtems_device_minor_number device;
152        int i = 0;
153
[7495494]154        RTEMS_DEBUG_PRINT( "Task started\n");
[574fb67]155
156        device = rtems_libi2c_register_drv( NULL, &test_mpc55xx_dspi_drv, test_mpc55xx_dspi_bus [3], 0);
[7495494]157        RTEMS_CHECK_RV_TASK( device, "rtems_libi2c_register_drv");
[574fb67]158
159        sc = rtems_libi2c_send_start( device);
[7495494]160        RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_start");
[574fb67]161
162        rv = rtems_libi2c_ioctl( device, RTEMS_LIBI2C_IOCTL_SET_TFRMODE, &test_mpc55xx_dspi_transfer_mode);
[7495494]163        RTEMS_CHECK_RV_TASK( rv, "rtems_libi2c_ioctl");
[574fb67]164
165        sc = rtems_libi2c_send_addr( device, MPC55XX_TEST_DSPI_ADDRESS);
[7495494]166        RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_addr");
[ac7af4a]167
[574fb67]168        for (i = 0; i < MPC55XX_TEST_DSPI_BUFSIZE; ++i) {
169                test_mpc55xx_dspi_reader_inbuf [i] = -1;
170        }
171
172        sc = rtems_semaphore_obtain( test_mpc55xx_dspi_ping, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
[7495494]173        RTEMS_CHECK_SC_TASK( sc, "rtems_semaphore_obtain");
[574fb67]174
[7495494]175        RTEMS_DEBUG_PRINT( "Pong\n");
[574fb67]176
177        sc = rtems_semaphore_release( test_mpc55xx_dspi_pong);
[7495494]178        RTEMS_CHECK_SC_TASK( sc, "rtems_semaphore_release");
[574fb67]179
180        while (1) {
181                sc = rtems_semaphore_obtain( test_mpc55xx_dspi_ping, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
[7495494]182                RTEMS_CHECK_SC_TASK( sc, "rtems_semaphore_obtain");
[574fb67]183
[7495494]184                RTEMS_DEBUG_PRINT( "Pong\n");
[ac7af4a]185
[574fb67]186                rv = rtems_libi2c_read_bytes( device, test_mpc55xx_dspi_reader_inbuf, MPC55XX_TEST_DSPI_BUFSIZE);
[7495494]187                RTEMS_CHECK_RV_TASK( rv, "rtems_libi2c_read_bytes");
[574fb67]188
189                sc = rtems_semaphore_release( test_mpc55xx_dspi_pong);
[7495494]190                RTEMS_CHECK_SC_TASK( sc, "rtems_semaphore_release");
[574fb67]191
192                printk( "Time: %i, Value: 0x%02x%02x%02x%02x\n", tac(),
193                        test_mpc55xx_dspi_reader_inbuf [0], test_mpc55xx_dspi_reader_inbuf [1],
194                        test_mpc55xx_dspi_reader_inbuf [2], test_mpc55xx_dspi_reader_inbuf [3]);
195        }
196
197        sc = rtems_libi2c_send_stop( device);
[7495494]198        RTEMS_CHECK_SC_TASK( sc, "rtems_libi2c_send_stop");
[574fb67]199
200        sc = rtems_task_delete( RTEMS_SELF);
[7495494]201        RTEMS_CHECK_SC_TASK( sc, "rtems_task_delete");
[574fb67]202}
203
204rtems_task test_sd_card( rtems_task_argument arg);
205
206static rtems_task test_mpc55xx_intc( rtems_task_argument arg);
207
[bb6c1e56]208rtems_status_code mpc55xx_dspi_register(void)
[574fb67]209{
210        rtems_status_code sc = RTEMS_SUCCESSFUL;
211        int rv = 0;
212        int i = 0;
213        char device_name [] = "/dev/spi0";
214        union SIU_PCR_tag pcr = MPC55XX_ZERO_FLAGS;
215
216        printk( "Boot time: %u\n", ppc_time_base());
[d374492]217
218        /*
[574fb67]219        test_mpc55xx_intc( 0);
[d374492]220        */
[574fb67]221
222        rv = rtems_libi2c_initialize();
[7495494]223        RTEMS_CHECK_RV_SC( rv, "rtems_libi2c_initialize");
[574fb67]224
225        /* DSPI D inputs are taken from DSPI C */
226        SIU.DISR.R = 0x000000FC;
227
228        /* DSPI A signals */
229        pcr.B.PA = 1;
230        pcr.B.ODE = 0;
231        pcr.B.HYS = 0;
232        pcr.B.SRC = 3;
233        pcr.B.WPE = 1;
234        pcr.B.WPS = 1;
235
236        /* SCK */
237        pcr.B.OBE = 1;
238        pcr.B.IBE = 0;
239        SIU.PCR [93].R = pcr.R;
240
241        /* SIN */
242        pcr.B.OBE = 0;
243        pcr.B.IBE = 1;
244        SIU.PCR [94].R = pcr.R;
245
246        /* SOUT */
247        pcr.B.OBE = 1;
248        pcr.B.IBE = 0;
249        SIU.PCR [95].R = pcr.R;
250
251        /* PCSx */
252        pcr.B.OBE = 1;
253        pcr.B.IBE = 0;
254        SIU.PCR [96].R = pcr.R;
255        SIU.PCR [97].R = pcr.R;
256        SIU.PCR [98].R = pcr.R;
257        SIU.PCR [99].R = pcr.R;
258        SIU.PCR [100].R = pcr.R;
259        SIU.PCR [101].R = pcr.R;
260
261        mpc55xx_dspi_bus_table [3].master = 0;
262        for (i = 0; i < MPC55XX_DSPI_NUMBER; ++i) {
263                device_name [8] = '0' + i;
264                rv = rtems_libi2c_register_bus( device_name, (rtems_libi2c_bus_t *) &mpc55xx_dspi_bus_table [i]);
[7495494]265                RTEMS_CHECK_RV_SC( rv, device_name);
[574fb67]266                test_mpc55xx_dspi_bus [i] = rv;
267        }
268
269        sc = rtems_semaphore_create (
270                rtems_build_name ( 'P', 'I', 'N', 'G'),
271                1,
[d374492]272                RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
[574fb67]273                RTEMS_NO_PRIORITY,
274                &test_mpc55xx_dspi_ping
275        );
[7495494]276        RTEMS_CHECK_SC( sc, "rtems_semaphore_create");
[574fb67]277
278        sc = rtems_semaphore_create (
279                rtems_build_name ( 'P', 'O', 'N', 'G'),
280                0,
[d374492]281                RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
[574fb67]282                RTEMS_NO_PRIORITY,
283                &test_mpc55xx_dspi_pong
284        );
[7495494]285        RTEMS_CHECK_SC( sc, "rtems_semaphore_create");
[574fb67]286
[7e5bf38]287        #if 0
288        rtems_id writer_task_id;
289        rtems_id reader_task_id;
[ac7af4a]290
[7e5bf38]291        sc = rtems_task_create(
292                rtems_build_name( 'T', 'W', 'R', 'T'),
293                2,
294                RTEMS_MINIMUM_STACK_SIZE,
295                RTEMS_DEFAULT_MODES,
296                RTEMS_DEFAULT_ATTRIBUTES,
297                &writer_task_id
298        );
[7495494]299        RTEMS_CHECK_SC( sc, "rtems_task_create");
[7e5bf38]300        sc = rtems_task_create(
301                rtems_build_name( 'T', 'R', 'D', 'R'),
302                1,
303                RTEMS_MINIMUM_STACK_SIZE,
304                RTEMS_DEFAULT_MODES,
305                RTEMS_DEFAULT_ATTRIBUTES,
306                &reader_task_id
307        );
[7495494]308        RTEMS_CHECK_SC( sc, "rtems_task_create");
[ac7af4a]309
[7e5bf38]310        sc = rtems_task_start( writer_task_id, test_mpc55xx_dspi_writer, 0);
[7495494]311        RTEMS_CHECK_SC( sc, "rtems_task_start");
[7e5bf38]312        sc = rtems_task_start( reader_task_id, test_mpc55xx_dspi_reader, 0);
[7495494]313        RTEMS_CHECK_SC( sc, "rtems_task_start");
[7e5bf38]314        #endif
[574fb67]315
316        rtems_id sd_card_task_id;
317        sc = rtems_task_create(
318                rtems_build_name( 'T', 'S', 'D', 'C'),
319                1,
320                RTEMS_MINIMUM_STACK_SIZE,
321                RTEMS_DEFAULT_MODES,
322                RTEMS_DEFAULT_ATTRIBUTES,
323                &sd_card_task_id
324        );
[7495494]325        RTEMS_CHECK_SC( sc, "rtems_task_create");
[574fb67]326        sc = rtems_task_start( sd_card_task_id, test_sd_card, 0);
[7495494]327        RTEMS_CHECK_SC( sc, "rtems_task_start");
[574fb67]328
[d374492]329        return RTEMS_SUCCESSFUL;
330
[574fb67]331        rtems_id intc_id;
332        sc = rtems_task_create(
333                rtems_build_name( 'I', 'N', 'T', 'C'),
334                2,
335                RTEMS_MINIMUM_STACK_SIZE,
336                RTEMS_DEFAULT_MODES,
337                RTEMS_DEFAULT_ATTRIBUTES,
338                &intc_id
339        );
[7495494]340        RTEMS_CHECK_SC( sc, "rtems_task_create");
[574fb67]341        sc = rtems_task_start( intc_id, test_mpc55xx_intc, 0);
[7495494]342        RTEMS_CHECK_SC( sc, "rtems_task_start");
[574fb67]343
344        return RTEMS_SUCCESSFUL;
345}
346
[d374492]347#if 0
348
[574fb67]349#include <sys/types.h>
350#include <sys/stat.h>
351#include <unistd.h>
352#include <fcntl.h>
353#include <dirent.h>
354#include <stdio.h>
355#include <rtems/fsmount.h>
356#include <rtems/dosfs.h>
357#include <rtems/ide_part_table.h>
358
359#define TEST_SD_CARD_BUF_SIZE 512
360#define TEST_SD_CARD_BIGBUF_SIZE (256 * 1024)
361
362#define TEST_SD_CARD_DEVICE_FILE "/dev/sd-card-a"
363#define TEST_SD_CARD_PARTITION "/dev/sd-card-a1"
364#define TEST_SD_CARD_MOUNT_POINT "/mnt"
365#define TEST_SD_CARD_DIRECTORY "/mnt/testdir"
366
367static fstab_t test_sd_card_fs_table [] = { {
368                TEST_SD_CARD_PARTITION, TEST_SD_CARD_MOUNT_POINT,
369                &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE,
370                FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED,
371                FSMOUNT_MNT_OK
372        }, {
373                TEST_SD_CARD_DEVICE_FILE, TEST_SD_CARD_MOUNT_POINT,
374                &msdos_ops, RTEMS_FILESYSTEM_READ_WRITE,
375                FSMOUNT_MNT_OK | FSMOUNT_MNTPNT_CRTERR | FSMOUNT_MNT_FAILED,
376                0
377        }
378};
379
380static uint8_t test_sd_card_buf [TEST_SD_CARD_BUF_SIZE] __attribute__ ((aligned (32)));
381
382static int test_sd_card_print_dir( const char* dirname, unsigned level)
383{
384        int rv = 0;
385        DIR *dir = NULL;
386        struct dirent *ent;
387        struct stat s;
388        int i = 0;
389
390        /* Open */
391        dir = opendir( dirname);
392        rv = dir == NULL ? -1 : 0;
[7495494]393        RTEMS_CHECK_RV( rv, "Open directory");
[574fb67]394
395        /* Change CWD */
396        rv = chdir( dirname);
[7495494]397        RTEMS_CHECK_RV( rv, "Change directory");
[574fb67]398
399        /* Read */
400        ent = readdir( dir);
401        while (ent != NULL) {
402                if (stat( ent->d_name, &s) == 0 && strcmp( ".", ent->d_name) != 0 && strcmp( "..", ent->d_name)) {
403                        for (i = 0; i < level; ++i) {
404                                printk( "\t");
405                        }
406                        printk( "<%s>\n", ent->d_name);
407                        if (S_ISDIR( s.st_mode)) {
408                                rv = test_sd_card_print_dir( ent->d_name, level + 1);
[7495494]409                                RTEMS_CHECK_RV( rv, "Next directory");
[574fb67]410                        }
411                }
412                ent = readdir( dir);
413        }
414
415        /* Change CWD */
416        rv = chdir( "..");
[7495494]417        RTEMS_CHECK_RV( rv, "Change directory");
[574fb67]418
419        /* Close */
420        rv = closedir( dir);
[7495494]421        RTEMS_CHECK_RV( rv, "Close directory");
[574fb67]422
423        return 0;
424}
425
426rtems_task test_sd_card( rtems_task_argument arg)
427{
428        rtems_status_code sc = RTEMS_SUCCESSFUL;
429        int rv = 0;
430        rtems_device_minor_number minor;
431        sd_card_driver_entry *e = &sd_card_driver_table [0];
432        int fd = 0;
433        unsigned i = 0;
434        unsigned avg = 0;
435        unsigned t = 0;
436        char file_name [] = "00000000.TXT";
437        uint8_t *buf = NULL;
438
[7495494]439        RTEMS_DEBUG_PRINT( "Task started\n");
[574fb67]440
441        minor = rtems_libi2c_register_drv( e->device_name, (rtems_libi2c_drv_t *) e, test_mpc55xx_dspi_bus [0], 0);
[7495494]442        RTEMS_CHECK_RV_TASK( (int) minor, "rtems_libi2c_register_drv");
[574fb67]443
444        buf = malloc( TEST_SD_CARD_BIGBUF_SIZE);
445        for (i = 0; i < TEST_SD_CARD_BIGBUF_SIZE; ++i) {
446                if (i % 27 == 26) {
447                        buf [i] = '\n';
448                } else {
449                        buf [i] = 'A' + i % 27;
450                }
451        }
452        buf [i - 1] = '\n';
453
454        rv = test_sd_card_print_dir( "/dev", 0);
[7495494]455        RTEMS_CHECK_RV_TASK( rv, "Print directory");
[574fb67]456
457        sc = rtems_ide_part_table_initialize( TEST_SD_CARD_DEVICE_FILE);
[7495494]458        RTEMS_CHECK_SC_TASK( sc, "Initialize IDE partition table");
[574fb67]459
460        rv = mkdir( TEST_SD_CARD_MOUNT_POINT, S_IRWXU);
[7495494]461        RTEMS_CHECK_RV_TASK( rv, "Create mount point");
[574fb67]462
463        rv = rtems_fsmount( test_sd_card_fs_table, sizeof( test_sd_card_fs_table) / sizeof( test_sd_card_fs_table [0]), NULL);
[7495494]464        RTEMS_CHECK_RV_TASK( rv, "Mount file systems");
[574fb67]465
[d374492]466        rv = test_sd_card_print_dir( "/dev", 0);
467        RTEMS_CHECK_RV_TASK( rv, "Print directory");
468
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);
[574fb67]473
474        rv = mkdir( TEST_SD_CARD_DIRECTORY, S_IRWXU);
475
476        rv = chdir( TEST_SD_CARD_DIRECTORY);
[7495494]477        RTEMS_CHECK_RV_TASK( rv, "Change directory");
[574fb67]478
479        i = 0;
480        while (1) {
481                snprintf( file_name, 13, "%08i.TXT", i);
482                tic();
483                fd = creat( file_name, S_IREAD | S_IWRITE);
[7495494]484                RTEMS_CHECK_RV_TASK( fd, "Create file");
[574fb67]485                rv = write( fd, buf, TEST_SD_CARD_BIGBUF_SIZE);
[7495494]486                RTEMS_CHECK_RV_TASK( rv, "Write file");
[574fb67]487                rv = close( fd);
[7495494]488                RTEMS_CHECK_RV_TASK( rv, "Close file");
[574fb67]489                t = tac();
490                avg = ((uint64_t) avg * ((uint64_t) i) + (uint64_t) t) / ((uint64_t) i + 1);
491                printk( "%s: %u (%u)\n", file_name, tac(), avg);
492                ++i;
493        }
494
495        rv = chdir( "..");
[7495494]496        RTEMS_CHECK_RV_TASK( rv, "Change directory");
[574fb67]497
498        rv = test_sd_card_print_dir( TEST_SD_CARD_DIRECTORY, 0);
[7495494]499        RTEMS_CHECK_RV_TASK( rv, "Print directory");
[574fb67]500
[d374492]501        (void) rtems_task_delete( RTEMS_SELF);
502
[574fb67]503
[7e5bf38]504        #if 0
505        /* Write */
506        int b = 0;
507        const char device_name [] = "/dev/spi0.sd-card-0";
508        fd = open( device_name, O_RDWR);
[ac7af4a]509
[7495494]510        RTEMS_CHECK_RV_TASK( fd, "open");
[7e5bf38]511        while (1) {
512                for (i = 0; i < TEST_SD_CARD_BUF_SIZE; ++i) {
513                        test_sd_card_buf [i] = b;
514                }
515                ++b;
516                rv = write( fd, test_sd_card_buf, TEST_SD_CARD_BUF_SIZE);
517                if (rv < 0) {
518                        break;
519                }
520        }
521        rv = close( fd);
[7495494]522        RTEMS_CHECK_RV_TASK( rv, "close");
[ac7af4a]523
[7e5bf38]524        /* Read */
525        fd = open( device_name, O_RDWR);
[7495494]526        RTEMS_CHECK_RV_TASK( fd, "open");
[7e5bf38]527        while (1) {
528                rv = read( fd, test_sd_card_buf, TEST_SD_CARD_BUF_SIZE);
529                if (rv < 0) {
530                        break;
531                }
532                printk( "%02x", test_sd_card_buf [rv - 1]);
533                if (i++ % 64 == 0) {
534                        printk( "\n");
535                }
536        }
537        rv = close( fd);
[7495494]538        RTEMS_CHECK_RV_TASK( rv, "close");
[7e5bf38]539        #endif
[574fb67]540
[d374492]541        (void) rtems_task_delete( RTEMS_SELF);
[574fb67]542}
543
[d374492]544#endif
545
[574fb67]546#define ITER 4
547#define BUFSIZE (128 * ITER)
548
549static char inbuf [BUFSIZE];
550static char outbuf [BUFSIZE];
551
[d374492]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
[bb6c1e56]561static rtems_status_code test_mpc55xx_edma(void)
[574fb67]562{
563        rtems_status_code sc = RTEMS_SUCCESSFUL;
[d374492]564        mpc55xx_edma_channel_entry e = {
565                .channel = 0,
566                .done = test_mpc55xx_edma_done,
567                .id = RTEMS_ID_NONE
568        };
[574fb67]569
570        sc = rtems_semaphore_create (
571                rtems_build_name ( 'T', 'S', 'T', 'C'),
572                0,
[d374492]573                RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
[574fb67]574                RTEMS_NO_PRIORITY,
[d374492]575                &e.id
[574fb67]576        );
[7495494]577        RTEMS_CHECK_SC( sc, "rtems_semaphore_create");
[574fb67]578
[d374492]579        sc = mpc55xx_edma_obtain_channel( &e);
580        RTEMS_CHECK_RV( sc, "mpc55xx_edma_obtain_channel");
[574fb67]581
582        int i = 0;
583        for (i = 0; i < BUFSIZE; ++i) {
584                inbuf [i] = i;
585                outbuf [i] = -1;
586        }
587        rtems_cache_flush_multiple_data_lines( inbuf, BUFSIZE);
588        rtems_cache_flush_multiple_data_lines( outbuf, BUFSIZE);
589
[d374492]590        struct tcd_t tcd = EDMA_TCD_DEFAULT;
[574fb67]591        tcd.SADDR = (uint32_t) &inbuf;
592        tcd.DADDR = (uint32_t) &outbuf;
593        tcd.NBYTES = BUFSIZE / ITER;
594        tcd.SLAST = -BUFSIZE;
[d374492]595        tcd.CDF.B.CITER = ITER;
596        tcd.BMF.B.BITER = ITER;
597        tcd.BMF.B.INT_HALF = 1;
[574fb67]598
[d374492]599        EDMA.TCD [e.channel] = tcd;
[574fb67]600
601        while (1) {
602                while (1) {
[d374492]603                        if (EDMA.TCD [e.channel].BMF.B.DONE == 1) {
604                                EDMA.TCD [e.channel].BMF.B.DONE = 0;
[574fb67]605                                printk( "%s: Done\n", __func__);
606                                break;
[d374492]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);
[574fb67]610                        }
[d374492]611                        sc = rtems_semaphore_obtain( e.id, RTEMS_WAIT, 10);
[574fb67]612                        if (sc == RTEMS_TIMEOUT) {
613                                continue;
614                        }
[7495494]615                        RTEMS_CHECK_SC( sc, "rtems_semaphore_obtain");
[574fb67]616                }
617        }
618
[d374492]619        return RTEMS_SUCCESSFUL;
[574fb67]620}
621
[d374492]622#include <stdlib.h>
623
[574fb67]624static unsigned test_mpc55xx_intc_counter = 0;
625
626static inline void test_mpc55xx_intc_worker( void *data)
627{
628        int s = 0;
629        int i = *(int *) data;
630        printk( "(%i): Start: %u\n", i, tac());
631        s = mpc55xx_intc_clear_software_irq( i);
632        if (i < MPC55XX_IRQ_SOFTWARE_NUMBER) {
633                tic();
634                s = mpc55xx_intc_raise_software_irq( i + 1);
635        }
636        ++test_mpc55xx_intc_counter;
637        printk( "(%i): Done\n", i);
638}
639
[60e5832]640static void test_mpc55xx_intc_handler( void *data)
[574fb67]641{
642        test_mpc55xx_intc_worker( data);
643}
644
645static void test_mpc55xx_intc_handler_2( void *data)
646{
647        test_mpc55xx_intc_worker( data);
648}
649
650static void test_mpc55xx_intc_handler_3( void *data)
651{
652        test_mpc55xx_intc_worker( data);
653}
654
655static int test_mpc55xx_intc_handler_data [MPC55XX_IRQ_SOFTWARE_NUMBER];
656
657static rtems_task test_mpc55xx_intc( rtems_task_argument arg)
658{
[d374492]659        rtems_status_code sc = RTEMS_SUCCESSFUL;
660        rtems_irq_connect_data e = {
661                .on = NULL,
662                .off = NULL,
663                .isOn = NULL
664        };
[574fb67]665        volatile int i = 0;
666        int p = 0;
667        unsigned s = 0;
668
669        for (i = MPC55XX_IRQ_SOFTWARE_MIN, p = MPC55XX_INTC_MIN_PRIORITY; i <= MPC55XX_IRQ_SOFTWARE_MAX; ++i, ++p) {
670                test_mpc55xx_intc_handler_data [i] = i;
671                e.name = i;
672                e.handle = &test_mpc55xx_intc_handler_data [i];
673
674                sc = rtems_interrupt_handler_install( i, "test_mpc55xx_intc_handler", RTEMS_INTERRUPT_SHARED, test_mpc55xx_intc_handler, e.handle);
675                if (sc != RTEMS_SUCCESSFUL) {
676                        BSP_panic( "Handler install failed");
677                }
678
679                e.hdl = test_mpc55xx_intc_handler_2;
[d374492]680                if (BSP_install_rtems_shared_irq_handler( &e) != 1) {
[574fb67]681                        BSP_panic( "Handler install 2 failed");
682                }
683
684                e.hdl = test_mpc55xx_intc_handler_3;
[d374492]685                if (BSP_install_rtems_shared_irq_handler( &e) != 1) {
[574fb67]686                        BSP_panic( "Handler install 3 failed");
687                }
688        }
689
690        while (1) {
691                i = (int) (7.0 * (rand_r( &s) / (RAND_MAX + 1.0)));
692                tic();
693                mpc55xx_intc_raise_software_irq( i);
694        }
695}
Note: See TracBrowser for help on using the repository browser.