Changeset 4b1c7c6f in mainline for kernel/generic/src/console/cmd.c


Ignore:
Timestamp:
2018-03-16T20:57:16Z (6 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Children:
6be2c13
Parents:
973be387
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-16 20:51:59)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-16 20:57:16)
Message:

Clean up PAGE_* flags.

Remove "nop flags", they are confusing for readers and any benefit they would
gain in self-documentation they lose in being used inconsistently.

Remove "PAGE_READ", the only place it's used meaningfully is the incomplete
RISC-V implementation, and most call sites assume read is implied.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/console/cmd.c

    r973be387 r4b1c7c6f  
    727727        else
    728728#endif
    729                 ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
    730                     PAGE_NOT_CACHEABLE);
     729                ptr = (uint8_t *) km_map(
     730                    argv[0].intval, sizeof(uint8_t), 0);
    731731
    732732        const uint8_t val = pio_read_8(ptr);
    … …  
    749749 */
    750750static int cmd_pio_read_16(cmd_arg_t *argv)
     751{
     752        uint16_t *ptr = NULL;
     753
     754#ifdef IO_SPACE_BOUNDARY
     755        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     756                ptr = (void *) argv[0].intval;
     757        else
     758#endif
     759                ptr = (uint16_t *) km_map(
     760                    argv[0].intval, sizeof(uint16_t), 0);
     761
     762        const uint16_t val = pio_read_16(ptr);
     763        printf("read %" PRIxn ": %" PRIx16 "\n", argv[0].intval, val);
     764
     765#ifdef IO_SPACE_BOUNDARY
     766        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     767                return 1;
     768#endif
     769
     770        km_unmap((uintptr_t) ptr, sizeof(uint16_t));
     771        return 1;
     772}
     773
     774/** Read 4 bytes from phys memory or io port.
     775 *
     776 * @param argv Argument vector.
     777 *
     778 * @return 0 on failure, 1 on success.
     779 */
     780static int cmd_pio_read_32(cmd_arg_t *argv)
     781{
     782        uint32_t *ptr = NULL;
     783
     784#ifdef IO_SPACE_BOUNDARY
     785        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     786                ptr = (void *) argv[0].intval;
     787        else
     788#endif
     789                ptr = (uint32_t *) km_map(
     790                    argv[0].intval, sizeof(uint32_t), 0);
     791
     792        const uint32_t val = pio_read_32(ptr);
     793        printf("read %" PRIxn ": %" PRIx32 "\n", argv[0].intval, val);
     794
     795#ifdef IO_SPACE_BOUNDARY
     796        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     797                return 1;
     798#endif
     799
     800        km_unmap((uintptr_t) ptr, sizeof(uint32_t));
     801        return 1;
     802}
     803
     804/** Write 1 byte to phys memory or io port.
     805 *
     806 * @param argv Argument vector.
     807 *
     808 * @return 0 on failure, 1 on success.
     809 */
     810static int cmd_pio_write_8(cmd_arg_t *argv)
     811{
     812        uint8_t *ptr = NULL;
     813
     814#ifdef IO_SPACE_BOUNDARY
     815        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     816                ptr = (void *) argv[0].intval;
     817        else
     818#endif
     819                ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
     820                    PAGE_WRITE);
     821
     822        printf("write %" PRIxn ": %" PRIx8 "\n", argv[0].intval,
     823            (uint8_t) argv[1].intval);
     824        pio_write_8(ptr, (uint8_t) argv[1].intval);
     825
     826#ifdef IO_SPACE_BOUNDARY
     827        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
     828                return 1;
     829#endif
     830
     831        km_unmap((uintptr_t) ptr, sizeof(uint8_t));
     832        return 1;
     833}
     834
     835/** Write 2 bytes to phys memory or io port.
     836 *
     837 * @param argv Argument vector.
     838 *
     839 * @return 0 on failure, 1 on success.
     840 */
     841static int cmd_pio_write_16(cmd_arg_t *argv)
    751842{
    752843        uint16_t *ptr = NULL;
    … …  
    758849#endif
    759850                ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
    760                     PAGE_NOT_CACHEABLE);
    761 
    762         const uint16_t val = pio_read_16(ptr);
    763         printf("read %" PRIxn ": %" PRIx16 "\n", argv[0].intval, val);
     851                    PAGE_WRITE);
     852
     853        printf("write %" PRIxn ": %" PRIx16 "\n", argv[0].intval,
     854            (uint16_t) argv[1].intval);
     855        pio_write_16(ptr, (uint16_t) argv[1].intval);
    764856
    765857#ifdef IO_SPACE_BOUNDARY
    … …  
    772864}
    773865
    774 /** Read 4 bytes from phys memory or io port.
     866/** Write 4 bytes to phys memory or io port.
    775867 *
    776868 * @param argv Argument vector.
    … …  
    778870 * @return 0 on failure, 1 on success.
    779871 */
    780 static int cmd_pio_read_32(cmd_arg_t *argv)
     872static int cmd_pio_write_32(cmd_arg_t *argv)
    781873{
    782874        uint32_t *ptr = NULL;
    … …  
    788880#endif
    789881                ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
    790                     PAGE_NOT_CACHEABLE);
    791 
    792         const uint32_t val = pio_read_32(ptr);
    793         printf("read %" PRIxn ": %" PRIx32 "\n", argv[0].intval, val);
    794 
    795 #ifdef IO_SPACE_BOUNDARY
    796         if ((void *) argv->intval < IO_SPACE_BOUNDARY)
    797                 return 1;
    798 #endif
    799 
    800         km_unmap((uintptr_t) ptr, sizeof(uint32_t));
    801         return 1;
    802 }
    803 
    804 /** Write 1 byte to phys memory or io port.
    805  *
    806  * @param argv Argument vector.
    807  *
    808  * @return 0 on failure, 1 on success.
    809  */
    810 static int cmd_pio_write_8(cmd_arg_t *argv)
    811 {
    812         uint8_t *ptr = NULL;
    813 
    814 #ifdef IO_SPACE_BOUNDARY
    815         if ((void *) argv->intval < IO_SPACE_BOUNDARY)
    816                 ptr = (void *) argv[0].intval;
    817         else
    818 #endif
    819                 ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
    820                     PAGE_NOT_CACHEABLE);
    821 
    822         printf("write %" PRIxn ": %" PRIx8 "\n", argv[0].intval,
    823             (uint8_t) argv[1].intval);
    824         pio_write_8(ptr, (uint8_t) argv[1].intval);
    825 
    826 #ifdef IO_SPACE_BOUNDARY
    827         if ((void *) argv->intval < IO_SPACE_BOUNDARY)
    828                 return 1;
    829 #endif
    830 
    831         km_unmap((uintptr_t) ptr, sizeof(uint8_t));
    832         return 1;
    833 }
    834 
    835 /** Write 2 bytes to phys memory or io port.
    836  *
    837  * @param argv Argument vector.
    838  *
    839  * @return 0 on failure, 1 on success.
    840  */
    841 static int cmd_pio_write_16(cmd_arg_t *argv)
    842 {
    843         uint16_t *ptr = NULL;
    844 
    845 #ifdef IO_SPACE_BOUNDARY
    846         if ((void *) argv->intval < IO_SPACE_BOUNDARY)
    847                 ptr = (void *) argv[0].intval;
    848         else
    849 #endif
    850                 ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
    851                     PAGE_NOT_CACHEABLE);
    852 
    853         printf("write %" PRIxn ": %" PRIx16 "\n", argv[0].intval,
    854             (uint16_t) argv[1].intval);
    855         pio_write_16(ptr, (uint16_t) argv[1].intval);
    856 
    857 #ifdef IO_SPACE_BOUNDARY
    858         if ((void *) argv->intval < IO_SPACE_BOUNDARY)
    859                 return 1;
    860 #endif
    861 
    862         km_unmap((uintptr_t) ptr, sizeof(uint16_t));
    863         return 1;
    864 }
    865 
    866 /** Write 4 bytes to phys memory or io port.
    867  *
    868  * @param argv Argument vector.
    869  *
    870  * @return 0 on failure, 1 on success.
    871  */
    872 static int cmd_pio_write_32(cmd_arg_t *argv)
    873 {
    874         uint32_t *ptr = NULL;
    875 
    876 #ifdef IO_SPACE_BOUNDARY
    877         if ((void *) argv->intval < IO_SPACE_BOUNDARY)
    878                 ptr = (void *) argv[0].intval;
    879         else
    880 #endif
    881                 ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
    882                     PAGE_NOT_CACHEABLE);
     882                    PAGE_WRITE);
    883883
    884884        printf("write %" PRIxn ": %" PRIx32 "\n", argv[0].intval,
Note: See TracChangeset for help on using the changeset viewer.