Changes in kernel/generic/src/console/cmd.c [6eef3c4:593e023] in mainline

File:

• kernel/generic/src/console/cmd.c (modified) (11 diffs)

kernel/generic/src/console/cmd.c

@@ -45 +45 @@
 #include <console/kconsole.h>
 #include <print.h>
+#include <log.h>
 #include <panic.h>
 #include <typedefs.h>
@@ -56 +57 @@
 #include <cpu.h>
 #include <mm/tlb.h>
+#include <mm/km.h>
 #include <arch/mm/tlb.h>
 #include <mm/frame.h>
@@ -81 +83 @@
         .func = cmd_help,
         .argc = 0
+};
+
+/* Data and methods for pio_read_8 command */
+static int cmd_pio_read_8(cmd_arg_t *argv);
+static cmd_arg_t pio_read_8_argv[] = { { .type = ARG_TYPE_INT } };
+static cmd_info_t pio_read_8_info = {
+        .name = "pio_read_8",
+        .description = "pio_read_8 <address> Read 1 byte from memory (or port).",
+        .func = cmd_pio_read_8,
+        .argc = 1,
+        .argv = pio_read_8_argv
+};
+
+/* Data and methods for pio_read_16 command */
+static int cmd_pio_read_16(cmd_arg_t *argv);
+static cmd_arg_t pio_read_16_argv[] = { { .type = ARG_TYPE_INT } };
+static cmd_info_t pio_read_16_info = {
+        .name = "pio_read_16",
+        .description = "pio_read_16 <address> Read 2 bytes from memory (or port).",
+        .func = cmd_pio_read_16,
+        .argc = 1,
+        .argv = pio_read_16_argv
+};
+
+/* Data and methods for pio_read_32 command */
+static int cmd_pio_read_32(cmd_arg_t *argv);
+static cmd_arg_t pio_read_32_argv[] = { { .type = ARG_TYPE_INT } };
+static cmd_info_t pio_read_32_info = {
+        .name = "pio_read_32",
+        .description = "pio_read_32 <address> Read 4 bytes from memory (or port).",
+        .func = cmd_pio_read_32,
+        .argc = 1,
+        .argv = pio_read_32_argv
+};
+
+/* Data and methods for pio_write_8 command */
+static int cmd_pio_write_8(cmd_arg_t *argv);
+static cmd_arg_t pio_write_8_argv[] = {
+        { .type = ARG_TYPE_INT },
+        { .type = ARG_TYPE_INT }
+};
+static cmd_info_t pio_write_8_info = {
+        .name = "pio_write_8",
+        .description = "pio_write_8 <address> <value> Write 1 byte to memory (or port).",
+        .func = cmd_pio_write_8,
+        .argc = 2,
+        .argv = pio_write_8_argv
+};
+
+/* Data and methods for pio_write_16 command */
+static int cmd_pio_write_16(cmd_arg_t *argv);
+static cmd_arg_t pio_write_16_argv[] = {
+        { .type = ARG_TYPE_INT },
+        { .type = ARG_TYPE_INT }
+};
+static cmd_info_t pio_write_16_info = {
+        .name = "pio_write_16",
+        .description = "pio_write_16 <address> <value> Write 2 bytes to memory (or port).",
+        .func = cmd_pio_write_16,
+        .argc = 2,
+        .argv = pio_write_16_argv
+};
+
+/* Data and methods for pio_write_32 command */
+static int cmd_pio_write_32(cmd_arg_t *argv);
+static cmd_arg_t pio_write_32_argv[] = {
+        { .type = ARG_TYPE_INT },
+        { .type = ARG_TYPE_INT }
+};
+static cmd_info_t pio_write_32_info = {
+        .name = "pio_write_32",
+        .description = "pio_write_32 <address> <value> Write 4 bytes to memory (or port).",
+        .func = cmd_pio_write_32,
+        .argc = 2,
+        .argv = pio_write_32_argv
 };
 
@@ -531 +608 @@
         &btrace_info,
 #endif
+        &pio_read_8_info,
+        &pio_read_16_info,
+        &pio_read_32_info,
+        &pio_write_8_info,
+        &pio_write_16_info,
+        &pio_write_32_info,
         NULL
 };
@@ -557 +640 @@
         for (i = 0; basic_commands[i]; i++) {
                 if (!cmd_register(basic_commands[i])) {
-                        printf("Cannot register command %s\n",
+                        log(LF_OTHER, LVL_ERROR,
+                            "Cannot register command %s",
                             basic_commands[i]->name);
                 }
@@ -574 +658 @@
         
         size_t len = 0;
-        list_foreach(cmd_list, cur) {
-                cmd_info_t *hlp;
-                hlp = list_get_instance(cur, cmd_info_t, link);
-                
+        list_foreach(cmd_list, link, cmd_info_t, hlp) {
                 spinlock_lock(&hlp->lock);
                 if (str_length(hlp->name) > len)
@@ -586 +667 @@
         unsigned int _len = (unsigned int) len;
         if ((_len != len) || (((int) _len) < 0)) {
-                printf("Command length overflow\n");
+                log(LF_OTHER, LVL_ERROR, "Command length overflow");
                 return 1;
         }
         
-        list_foreach(cmd_list, cur) {
-                cmd_info_t *hlp;
-                hlp = list_get_instance(cur, cmd_info_t, link);
-                
+        list_foreach(cmd_list, link, cmd_info_t, hlp) {
                 spinlock_lock(&hlp->lock);
                 printf("%-*s %s\n", _len, hlp->name, hlp->description);
@@ -604 +682 @@
 }
 
+/** Read 1 byte from phys memory or io port.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+static int cmd_pio_read_8(cmd_arg_t *argv)
+{
+        uint8_t *ptr = NULL;
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                ptr = (void *) argv[0].intval;
+        else
+#endif
+                ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
+                    PAGE_NOT_CACHEABLE);
+        
+        const uint8_t val = pio_read_8(ptr);
+        printf("read %" PRIxn ": %" PRIx8 "\n", argv[0].intval, val);
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                return 1;
+#endif
+        
+        km_unmap((uintptr_t) ptr, sizeof(uint8_t));
+        return 1;
+}
+
+/** Read 2 bytes from phys memory or io port.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+static int cmd_pio_read_16(cmd_arg_t *argv)
+{
+        uint16_t *ptr = NULL;
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                ptr = (void *) argv[0].intval;
+        else
+#endif
+                ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
+                    PAGE_NOT_CACHEABLE);
+        
+        const uint16_t val = pio_read_16(ptr);
+        printf("read %" PRIxn ": %" PRIx16 "\n", argv[0].intval, val);
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                return 1;
+#endif
+        
+        km_unmap((uintptr_t) ptr, sizeof(uint16_t));
+        return 1;
+}
+
+/** Read 4 bytes from phys memory or io port.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+static int cmd_pio_read_32(cmd_arg_t *argv)
+{
+        uint32_t *ptr = NULL;
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                ptr = (void *) argv[0].intval;
+        else
+#endif
+                ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
+                    PAGE_NOT_CACHEABLE);
+        
+        const uint32_t val = pio_read_32(ptr);
+        printf("read %" PRIxn ": %" PRIx32 "\n", argv[0].intval, val);
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                return 1;
+#endif
+        
+        km_unmap((uintptr_t) ptr, sizeof(uint32_t));
+        return 1;
+}
+
+/** Write 1 byte to phys memory or io port.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+static int cmd_pio_write_8(cmd_arg_t *argv)
+{
+        uint8_t *ptr = NULL;
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                ptr = (void *) argv[0].intval;
+        else
+#endif
+                ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
+                    PAGE_NOT_CACHEABLE);
+        
+        printf("write %" PRIxn ": %" PRIx8 "\n", argv[0].intval,
+            (uint8_t) argv[1].intval);
+        pio_write_8(ptr, (uint8_t) argv[1].intval);
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                return 1;
+#endif
+        
+        km_unmap((uintptr_t) ptr, sizeof(uint8_t));
+        return 1;
+}
+
+/** Write 2 bytes to phys memory or io port.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+static int cmd_pio_write_16(cmd_arg_t *argv)
+{
+        uint16_t *ptr = NULL;
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                ptr = (void *) argv[0].intval;
+        else
+#endif
+                ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
+                    PAGE_NOT_CACHEABLE);
+        
+        printf("write %" PRIxn ": %" PRIx16 "\n", argv[0].intval,
+            (uint16_t) argv[1].intval);
+        pio_write_16(ptr, (uint16_t) argv[1].intval);
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                return 1;
+#endif
+        
+        km_unmap((uintptr_t) ptr, sizeof(uint16_t));
+        return 1;
+}
+
+/** Write 4 bytes to phys memory or io port.
+ *
+ * @param argv Argument vector.
+ *
+ * @return 0 on failure, 1 on success.
+ */
+static int cmd_pio_write_32(cmd_arg_t *argv)
+{
+        uint32_t *ptr = NULL;
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                ptr = (void *) argv[0].intval;
+        else
+#endif
+                ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
+                    PAGE_NOT_CACHEABLE);
+        
+        printf("write %" PRIxn ": %" PRIx32 "\n", argv[0].intval,
+            (uint32_t) argv[1].intval);
+        pio_write_32(ptr, (uint32_t) argv[1].intval);
+        
+#ifdef IO_SPACE_BOUNDARY
+        if ((void *) argv->intval < IO_SPACE_BOUNDARY)
+                return 1;
+#endif
+        
+        km_unmap((uintptr_t) ptr, sizeof(uint32_t));
+        return 1;
+}
+
 /** Reboot the system.
  *
@@ -647 +908 @@
         spinlock_lock(&cmd_lock);
         
-        list_foreach(cmd_list, cur) {
-                cmd_info_t *hlp;
-                
-                hlp = list_get_instance(cur, cmd_info_t, link);
+        list_foreach(cmd_list, link, cmd_info_t, hlp) {
                 spinlock_lock(&hlp->lock);
                 
@@ -891 +1149 @@
 int cmd_set4(cmd_arg_t *argv)
 {
-        uintptr_t addr;
+        uintptr_t addr = 0; // Prevent -Werror=maybe-uninitialized
         uint32_t arg1 = argv[1].intval;
         bool pointer = false;
@@ -1099 +1357 @@
         printf("The kernel will now relinquish the console.\n");
         release_console();
-        
-        event_notify_0(EVENT_KCONSOLE, false);
         indev_pop_character(stdin);