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

4.104.11
Last change on this file since 934307a was 934307a, checked in by Ralf Corsepius <ralf.corsepius@…>, on Feb 11, 2009 at 5:18:54 AM

2009-02-11 Ralf Corsépius <ralf.corsepius@…>

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