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

4.104.11
Last change on this file since 4f5d1c9f was 4f5d1c9f, checked in by Thomas Doerfler <Thomas.Doerfler@…>, on Mar 27, 2010 at 3:00:43 PM

removed warnings

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