Changeset 10344


Ignore:
Timestamp:
2008-02-01T13:45:55+01:00 (10 years ago)
Author:
ralph
Message:

modify added

File:
1 edited

Legend:

Unmodified
Added
Removed
  • packages/utils/io/src/io.c

    r7009 r10344  
    22 * Simple app. to do memory accesses via /dev/mem. 
    33 * 
    4  * $Id: io.c,v 1.5 2000/08/21 09:01:57 richard Exp $ 
     4 * $Id: io.c,v 2.0 $ 
    55 * 
    66 * Copyright (c) Richard Hirst <rhirst@linuxcare.com> 
     7 * Copyright (c) Thomas Langer <thomas.langer@infineon.com> 
     8 * 
    79 */ 
    810 
     
    1719#include <errno.h> 
    1820 
    19 #ifndef FALSE 
    20 #define FALSE   0 
    21 #define TRUE    (!FALSE) 
    22 #endif 
    23  
    24 static char *argv0; 
     21#define MEM_READ  0 
     22#define MEM_WRITE 1 
     23#define MEM_AND   2 
     24#define MEM_OR    3 
    2525 
    2626static void 
    27 usage (void) 
     27usage (char *argv0) 
    2828{ 
    2929        fprintf(stderr, 
    30 "Raw memory i/o utility - $Revision: 1.5 $\n\n" 
    31 "%s -v -1|2|4 -r|w [-l <len>] [-f <file>] <addr> [<value>]\n\n" 
     30"Raw memory i/o utility - $Revision: 2.0 $\n\n" 
     31"%s -v -1|2|4 -r|w|a|o [-l <len>] [-f <file>] <addr> [<value>]\n\n" 
    3232"    -v         Verbose, asks for confirmation\n" 
    3333"    -1|2|4     Sets memory access size in bytes (default byte)\n" 
    3434"    -l <len>   Length in bytes of area to access (defaults to\n" 
    3535"               one access, or whole file length)\n" 
    36 "    -r|w       Read from or Write to memory (default read)\n" 
     36"    -r|w|a|o   Read from or Write to memory (default read)\n" 
     37"               optional write with modify (and/or)\n" 
    3738"    -f <file>  File to write on memory read, or\n" 
    3839"               to read on memory write\n" 
     
    111112 
    112113 
     114static void 
     115and_write_memory(unsigned long phys_addr, void *addr, int len, int iosize, unsigned long value) 
     116{ 
     117        switch(iosize) { 
     118        case 1: 
     119                while (len) { 
     120                        *(unsigned char *)addr &= value; 
     121                        len -= iosize; 
     122                        addr += iosize; 
     123                } 
     124                break; 
     125        case 2: 
     126                while (len) { 
     127                        *(unsigned short *)addr &= value; 
     128                        len -= iosize; 
     129                        addr += iosize; 
     130                } 
     131                break; 
     132        case 4: 
     133                while (len) { 
     134                        *(unsigned long *)addr &= value; 
     135                        len -= iosize; 
     136                        addr += iosize; 
     137                } 
     138                break; 
     139        } 
     140} 
     141 
     142 
     143static void 
     144or_write_memory(unsigned long phys_addr, void *addr, int len, int iosize, unsigned long value) 
     145{ 
     146        switch(iosize) { 
     147        case 1: 
     148                while (len) { 
     149                        *(unsigned char *)addr |= value; 
     150                        len -= iosize; 
     151                        addr += iosize; 
     152                } 
     153                break; 
     154        case 2: 
     155                while (len) { 
     156                        *(unsigned short *)addr |= value; 
     157                        len -= iosize; 
     158                        addr += iosize; 
     159                } 
     160                break; 
     161        case 4: 
     162                while (len) { 
     163                        *(unsigned long *)addr |= value; 
     164                        len -= iosize; 
     165                        addr += iosize; 
     166                } 
     167                break; 
     168        } 
     169} 
     170 
     171 
    113172int 
    114173main (int argc, char **argv) 
     
    118177        unsigned long real_len, real_addr, req_addr, req_value = 0, offset; 
    119178        char *endptr; 
    120         int memread = TRUE; 
     179        int memfunc = MEM_READ; 
    121180        int iosize = 1; 
    122181        char *filename = NULL; 
    123182        int verbose = 0; 
    124183 
    125         argv0 = argv[0]; 
    126184        opterr = 0; 
    127185        if (argc == 1) 
    128                 usage(); 
    129  
    130         while ((opt = getopt(argc, argv, "hv124rwl:f:")) > 0) { 
     186                usage(argv[0]); 
     187 
     188        while ((opt = getopt(argc, argv, "hv124rwaol:f:")) > 0) { 
    131189                switch (opt) { 
    132190                case 'h': 
    133                         usage(); 
     191                        usage(argv[0]); 
    134192                case 'v': 
    135193                        verbose = 1; 
     
    141199                        break; 
    142200                case 'r': 
    143                         memread = TRUE; 
     201                        memfunc = MEM_READ; 
     202                        break; 
     203                case 'a': 
     204                        memfunc = MEM_AND; 
     205                        break; 
     206                case 'o': 
     207                        memfunc = MEM_OR; 
    144208                        break; 
    145209                case 'w': 
    146                         memread = FALSE; 
     210                        memfunc = MEM_WRITE; 
    147211                        break; 
    148212                case 'l': 
     
    158222                default: 
    159223                        fprintf(stderr, "Unknown option: %c\n", opt); 
    160                         usage(); 
     224                        usage(argv[0]); 
    161225                } 
    162226        } 
     
    172236        } 
    173237        optind++; 
    174         if (!filename && optind < argc) 
    175                 memread = FALSE; 
     238        if (!filename && (memfunc == MEM_READ) && optind < argc) { 
     239                memfunc = MEM_WRITE; 
     240        } 
    176241        if (filename && optind > argc) { 
    177242                fprintf(stderr, "Filename AND value given\n"); 
    178243                exit(1); 
    179244        } 
    180         if (!filename && !memread && optind == argc) { 
     245        if (!filename && (memfunc != MEM_READ) && optind == argc) { 
    181246                fprintf(stderr, "No value given for WRITE\n"); 
    182247                exit(1); 
    183248        } 
    184         if (!filename && !memread) { 
     249        if (!filename && (memfunc != MEM_READ)) { 
    185250                req_value = strtoul(argv[optind], &endptr, 0); 
    186251                if (*endptr) { 
     
    195260                optind++; 
    196261        } 
    197         if (filename && memread && !req_len) { 
     262        if (filename && (memfunc == MEM_READ) && !req_len) { 
    198263                fprintf(stderr, "No size given for file memread\n"); 
    199264                exit(1); 
     
    203268                exit(1); 
    204269        } 
    205         if (filename && memread) { 
     270        if (filename && (memfunc == MEM_READ)) { 
    206271                ffd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH); 
    207272                if (ffd < 0) { 
     
    210275                } 
    211276        } 
    212         if (filename && !memread) { 
     277        if (filename && (memfunc != MEM_READ)) { 
    213278                ffd = open(filename, O_RDONLY); 
    214279                if (ffd < 0) { 
     
    244309                exit(1); 
    245310        } 
    246          
     311 
    247312        if (!verbose) 
    248313                /* Nothing */; 
    249         else if (filename && memread) 
    250                 printf("Request to memread 0x%x bytes from address 0x%08lx\n" 
     314        else if (filename && (memfunc == MEM_READ)) 
     315                printf("Request to read 0x%x bytes from address 0x%08lx\n" 
    251316                        "\tto file %s, using %d byte accesses\n", 
    252317                        req_len, req_addr, filename, iosize); 
     
    255320                        "\tfrom file %s, using %d byte accesses\n", 
    256321                        req_len, req_addr, filename, iosize); 
    257         else if (memread) 
    258                 printf("Request to memread 0x%x bytes from address 0x%08lx\n" 
     322        else if (memfunc == MEM_READ) 
     323                printf("Request to read 0x%x bytes from address 0x%08lx\n" 
    259324                        "\tusing %d byte accesses\n", 
    260325                        req_len, req_addr, iosize); 
     
    280345                        real_len, real_addr); 
    281346 
    282         mfd = open("/dev/mem", memread ? O_RDONLY : O_RDWR); 
     347        mfd = open("/dev/mem", (memfunc == MEM_READ) ? O_RDONLY : O_RDWR); 
    283348        if (mfd == -1) { 
    284349                perror("open /dev/mem"); 
     
    288353                printf("open(/dev/mem) ok\n"); 
    289354        real_io = mmap(NULL, real_len, 
    290                         memread ? PROT_READ:PROT_WRITE, 
     355                        (memfunc == MEM_READ) ? PROT_READ:PROT_READ|PROT_WRITE, 
    291356                        MAP_SHARED, mfd, real_addr); 
    292357        if (real_io == (void *)(-1)) { 
     
    309374        } 
    310375 
    311         if (filename && memread) { 
     376        if (filename && (memfunc == MEM_READ)) { 
    312377                int n = write(ffd, real_io + offset, req_len); 
    313378 
     
    335400                } 
    336401        } 
    337         else if (memread) 
    338                 memread_memory(req_addr, real_io + offset, req_len, iosize); 
    339         else 
    340                 write_memory(req_addr, real_io + offset, req_len, iosize, req_value); 
     402        else { 
     403                switch (memfunc) 
     404                { 
     405                case MEM_READ: 
     406                        memread_memory(req_addr, real_io + offset, req_len, iosize); 
     407                        break; 
     408                case MEM_WRITE: 
     409                        write_memory(req_addr, real_io + offset, req_len, iosize, req_value); 
     410                        break; 
     411                case MEM_AND: 
     412                        and_write_memory(req_addr, real_io + offset, req_len, iosize, req_value); 
     413                        break; 
     414                case MEM_OR: 
     415                        or_write_memory(req_addr, real_io + offset, req_len, iosize, req_value); 
     416                        break; 
     417                } 
     418        } 
    341419 
    342420        if (filename) 
Note: See TracChangeset for help on using the changeset viewer.