MMCHS driver cleanup
authorGerd Zellweger <mail@gerdzellweger.com>
Tue, 25 Jun 2013 18:11:49 +0000 (20:11 +0200)
committerGerd Zellweger <mail@gerdzellweger.com>
Tue, 16 Jul 2013 12:55:00 +0000 (14:55 +0200)
Using generated mackerel files in CM2.

devices/Hakefile
devices/omap/omap44xx_l4per_cm2.dev
usr/drivers/omap44xx/mmchs/Hakefile
usr/drivers/omap44xx/mmchs/cm2.c
usr/drivers/omap44xx/mmchs/i2c.c
usr/drivers/omap44xx/mmchs/mmchs.c
usr/drivers/omap44xx/mmchs/omap44xx_cm2.h

index c183f6b..9c966a9 100644 (file)
@@ -73,7 +73,9 @@
            "omap/omap44xx_sr_mpu",
            "omap/omap44xx_device_prm",
            "omap/omap44xx_mmchs",
-           "omap/omap44xx_cm2"
+           "omap/omap44xx_l3init_cm2",
+           "omap/omap44xx_ckgen_cm2",
+           "omap/omap44xx_l4per_cm2"
          ], arch <- allArchitectures
 ] ++
 
index b6a1ccd..7d6d494 100644 (file)
@@ -226,34 +226,13 @@ device omap44xx_l4per_cm2 msbfirst ( addr base ) "" {
         modulemode 2 rw type(modulemode_status) "Control the way mandatory clocks are managed.";
     };
     
-    register cm_l4per_i2c1_clkctrl addr(base, 0xA0) "This register manages the I2C1 clocks." {
+    regarray cm_l4per_i2c_clkctrl addr(base, 0xA0)[4;0x8] "This register manages the i-th I2C clocks." {
         _ 14 mbz;
         idlest 2 ro type(idlest_status) "Module idle status. [warm reset insensitive]";
         _ 14 mbz;
         modulemode 2 rw type(modulemode_status) "Control the way mandatory clocks are managed.";
     };
-    
-    register cm_l4per_i2c2_clkctrl addr(base, 0xA8) "This register manages the I2C2 clocks." {
-        _ 14 mbz;
-        idlest 2 ro type(idlest_status) "Module idle status. [warm reset insensitive]";
-        _ 14 mbz;
-        modulemode 2 rw type(modulemode_status) "Control the way mandatory clocks are managed.";
-    };
-    
-    register cm_l4per_i2c3_clkctrl addr(base, 0xB0) "This register manages the I2C3 clocks." {
-        _ 14 mbz;
-        idlest 2 ro type(idlest_status) "Module idle status. [warm reset insensitive]";
-        _ 14 mbz;
-        modulemode 2 rw type(modulemode_status) "Control the way mandatory clocks are managed.";
-    };
-    
-    register cm_l4per_i2c4_clkctrl addr(base, 0xB8) "This register manages the I2C4 clocks." {
-        _ 14 mbz;
-        idlest 2 ro type(idlest_status) "Module idle status. [warm reset insensitive]";
-        _ 14 mbz;
-        modulemode 2 rw type(modulemode_status) "Control the way mandatory clocks are managed.";
-    };
-    
+       
     register cm_l4per_l4per_clkctrl addr(base, 0xC0) "This register manages the L4PER clocks." {
         _ 14 mbz;
         idlest 2 ro type(idlest_status) "Module idle status. [warm reset insensitive]";
index 84a510b..8386f21 100644 (file)
                         "ti_twl6030",
                         "sdhc",
                         "omap/omap44xx_mmchs",
-                        "omap/omap44xx_cm2",
-                        "omap/omap44xx_ctrlmod"
+                        "omap/omap44xx_ctrlmod",
+                        "omap/omap44xx_l3init_cm2",
+                        "omap/omap44xx_ckgen_cm2",
+                        "omap/omap44xx_l4per_cm2"
                     ],
                     addCFlags = [ "-DIN_KERNEL" ],
                     addIncludes = [
index 4bf5430..0d8a14a 100644 (file)
 
 #include <arm_hal.h>
 #include <omap44xx_cm2.h>
-#include <dev/omap/omap44xx_cm2_dev.h>
 
-static int cm2_clock_enabled = 0;
-static omap44xx_cm2_t cm2;
+#include <dev/omap/omap44xx_l3init_cm2_dev.h>
+#include <dev/omap/omap44xx_ckgen_cm2_dev.h>
+#include <dev/omap/omap44xx_l4per_cm2_dev.h>
+
+static omap44xx_l3init_cm2_t l3init_cm2;
+static omap44xx_l4per_cm2_t l4per_cm2;
+static omap44xx_ckgen_cm2_t clkgen_cm2;
 
 #define CM2_BUF_SIZE (64*1024)
-char cm2_buf[CM2_BUF_SIZE];
+static char cm2_buf[CM2_BUF_SIZE];
 
 /*
  * \brief Enable the clock
  *
  * See Free BSD: omap4_prcm_clks.c - omap4_clk_generic_activate()
  *
- * Module should be "fully functional" if ... 
+ * Module should be "fully functional" if ...
  * .. IDLEST reads as 0
  * .. STBYST reads as 0 (x)
- * Both of these fields are read-only values .. 
+ * Both of these fields are read-only values ..
  *
- * (x) won't enable here, but I saw this enabled once .. 
- *     I guess this is happening some time later .. 
+ * (x) won't enable here, but I saw this enabled once ..
+ *     I guess this is happening some time later ..
  *     I think we can flip this bit by disabling standby mode on the MMC
  */
 void cm2_enable_hsmmc1(void)
 {
-    cm2_clock_enabled = 1;
-
-    omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_CLKSEL_wrf(&cm2, 0x0);
+    omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_clksel_wrf(&l3init_cm2, 0x0);
 
     // Handling clock dependencies!
-    omap44xx_cm2_CM_DIV_M4_DPLL_PER_pr(cm2_buf, CM2_BUF_SIZE, &cm2);
-    printf("%s", cm2_buf);
+    //omap44xx_ckgen_cm2_cm_div_m4_dpll_per_pr(cm2_buf, CM2_BUF_SIZE, &ckgen_cm2);
+    //printf("%s", cm2_buf);
 
     // Disabling clock manually
-    omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_MODULEMODE_wrf(&cm2, 0x0);
-    
-    // Waiting for clock to be disabled ...
-    while (omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_IDLEST_rdf(&cm2)!=0x3);
+    omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_modulemode_wrf(&l3init_cm2, 0x0);
 
-    // Don't mess with the power controler unless we really believe 
-    // that the MMC is not powered up yet.
-    //
-    if (omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_IDLEST_rdf(&cm2)==0x0) {
+    // Waiting for clock to be disabled ...
+    while (omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_idlest_rdf(&l3init_cm2) != 0x3);
 
+    if (omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_idlest_rdf(&l3init_cm2)==0x0) {
+        // Don't mess with the power controler the MMC is not powered up yet.
         printf("cm2: Clock for HSMMC1 is already enabled\n");
         return;
     }
 
-    printf("cm2: Powering on HSMMC1 .. ");
-    omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_MODULEMODE_wrf(&cm2, 0x2);
+    printf("cm2: Powering on HSMMC1... ");
+    omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_modulemode_wrf(&l3init_cm2, 0x2);
 
     volatile int cm2loop = 0;
-    while (omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_IDLEST_rdf(&cm2)!=0) {
-
-        //        mmchs_wait_msec(1);
-
+    while (omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_idlest_rdf(&l3init_cm2)!=0) {
         if (++cm2loop>1000) {
-            printf("failed\n");
-            panic("cm2: MMC power won't come up .. "
+            printf("failed.\n");
+            panic("cm2: MMC power won't come up... "
                   "Don't know what to do, IDLEST and STBYST are ro");
         }
     }
-    printf("done (%d cycles)\n", cm2loop);
+    printf("done (%d cycles).\n", cm2loop);
 
-    if (omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_STBYST_rdf(&cm2)==0x1) {
-        printf("cm2: module MMC1 is in standby state\n");
+    if (omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_stbyst_rdf(&l3init_cm2)==0x1) {
+        printf("cm2: module MMC1 is in standby state.\n");
     }
 }
 
-void cm2_enable_i2c(int i2c_index)
+void cm2_enable_i2c(size_t i2c_index)
 {
-    switch(i2c_index) {
-        case 1:
-            // enable i2c module
-            omap44xx_cm2_l4per_i2c1_clkctrl_modulemode_wrf(&cm2,
-                    omap44xx_cm2_modmode_swenabled);
-            // wait for module to get into functional state
-            while(omap44xx_cm2_l4per_i2c1_clkctrl_idlest_rdf(&cm2)
-                    !=omap44xx_cm2_idlest_functional);
-            break;
-        case 2:
-            // enable i2c module
-            omap44xx_cm2_l4per_i2c2_clkctrl_modulemode_wrf(&cm2,
-                    omap44xx_cm2_modmode_swenabled);
-            // wait for module to get into functional state
-            while(omap44xx_cm2_l4per_i2c2_clkctrl_idlest_rdf(&cm2)
-                    !=omap44xx_cm2_idlest_functional);
-            break;
-        case 3:
-            // enable i2c module
-            omap44xx_cm2_l4per_i2c3_clkctrl_modulemode_wrf(&cm2,
-                    omap44xx_cm2_modmode_swenabled);
-            // wait for module to get into functional state
-            while(omap44xx_cm2_l4per_i2c3_clkctrl_idlest_rdf(&cm2)
-                    !=omap44xx_cm2_idlest_functional);
-            break;
-        case 4:
-            // enable i2c module
-            omap44xx_cm2_l4per_i2c4_clkctrl_modulemode_wrf(&cm2,
-                    omap44xx_cm2_modmode_swenabled);
-            // wait for module to get into functional state
-            while(omap44xx_cm2_l4per_i2c4_clkctrl_idlest_rdf(&cm2)
-                    !=omap44xx_cm2_idlest_functional);
-            break;
-        default:
-            printk(LOG_WARN, "don't know how to enable clocks for I2C%d\n", i2c_index);
-            break;
-    }
+    assert (i2c_index < 4);
+
+    omap44xx_l4per_cm2_cm_l4per_i2c_clkctrl_modulemode_wrf(&l4per_cm2, i2c_index, 0x2);
+
+    // wait for module to get into functional state
+    while(omap44xx_l4per_cm2_cm_l4per_i2c_clkctrl_idlest_rdf(&l4per_cm2, i2c_index)
+            != 0x0);
 }
 
 void cm2_init(void)
 {
-    mackerel_addr_t cm2_vaddr = omap_dev_map(CM2_PADDR);
-    mackerel_addr_t cm2_clkgen_vaddr = omap_dev_map(CM2_CLKGEN_PADDR);
-    mackerel_addr_t cm2_l4per_vaddr = omap_dev_map(CM2_L4PER_PADDR);
+    mackerel_addr_t l3init_vaddr = omap_dev_map(L3INIT_CM2_PADDR);
+    omap44xx_l3init_cm2_initialize(&l3init_cm2, l3init_vaddr);
 
-    omap44xx_cm2_initialize(&cm2, cm2_vaddr, cm2_clkgen_vaddr, cm2_l4per_vaddr);
-    
+    mackerel_addr_t clkgen_vaddr = omap_dev_map(CLKGEN_CM2_PADDR);
+    omap44xx_ckgen_cm2_initialize(&clkgen_cm2, clkgen_vaddr);
+
+    mackerel_addr_t l4per_vaddr = omap_dev_map(L4PER_CM2_PADDR);
+    omap44xx_l4per_cm2_initialize(&l4per_cm2, l4per_vaddr);
 }
 
 int cm2_get_hsmmc1_base_clock(void)
 {
-    return omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_CLKSEL_rdf(&cm2) == 0x0 ?
-        64000000 : 96000000;
+    return omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_clksel_rdf(&l3init_cm2) == 0x0 ?
+           64000000 : 96000000;
 }
 
 /*
  * \brief Print CM2 registers
  */
-void print_cm2(void)
+void cm2_debug_print(void)
 {
     char buf[1024];
-    omap44xx_cm2_pr(buf, 1024-1, &cm2);
+    omap44xx_l3init_cm2_pr(buf, 1024-1, &l3init_cm2);
+    printf("%s\n", cm2_buf);
+
+    omap44xx_ckgen_cm2_pr(buf, 1024-1, &clkgen_cm2);
+    printf("%s\n", cm2_buf);
 
-    printf("%s\n", buf);
+    omap44xx_l4per_cm2_pr(buf, 1024-1, &l4per_cm2);
+    printf("%s\n", cm2_buf);
 }
 
 void cm2_print_standby_state(void)
 {
-    if (omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_STBYST_rdf(&cm2)==0x0) {
-        printf("cm2: mmc1 is functional (not in standby state)\n");
-    } else if (omap44xx_cm2_CM_L3INIT_HSMMC1_CLKCTRL_STBYST_rdf(&cm2)==0x0) {
-        printf("cm2: mmc1 is in stand-by state\n");
-    } else {
-        panic("Undefined standby state for MMC1");
-    }
+    omap44xx_l3init_cm2_cm_l3init_hsmmc1_clkctrl_pr(cm2_buf, 1024-1, &l3init_cm2);
+    printf("%s\n", cm2_buf);
 }
 
index 86ea4e9..3d49048 100644 (file)
@@ -41,7 +41,8 @@ static char PRBUF[PBS];
 /*
  * \brief initialize I2C controller `i`.
  */
-void ti_i2c_init(int i) {
+void ti_i2c_init(int i) 
+{
     // map & initialize mackerel device
     mackerel_addr_t i2c_vbase = omap_dev_map(i2c_pbase[i]);
     ti_i2c_initialize(&i2c[i], i2c_vbase);
index fe4e6e9..fedd6cb 100644 (file)
@@ -513,7 +513,7 @@ static int mmchs_finalize_cmd(void)
                     sdhc_stat_cerr_rdf(&sdhc)!=0x0) {
                     
                     print_mmchs();
-                    print_cm2();
+                    cm2_debug_print();
                     panic("mmchs_send_cmd: error - registers got dumped .. ");
                 }
             } else {
index 8ced14f..fb60a16 100644 (file)
 #include <dev/omap/omap44xx_mmchs_dev.h>
 #include <dev/omap/omap44xx_ctrlmod_dev.h>
 
-// TRM Table 3-1286, page 918
-#define CM2_BASE   0x4A009300U
-#define CLKGEN_CM2_BASE  0x4A008100
-
-#define CM2_PADDR (0x4A009300U)
-#define CM2_CLKGEN_PADDR (0x4A008100)
-#define CM2_L4PER_PADDR (0x4A009400)
+#define L3INIT_CM2_PADDR (0x4A009300U)
+#define CLKGEN_CM2_PADDR (0x4A008100)
+#define L4PER_CM2_PADDR (0x4A009400)
 
 // We need this because paging_arm_device returns the address 
 // of the beginning of the section in virtual memory ..
@@ -30,9 +26,9 @@
     (paging_map_device(p, ARM_L1_SECTION_BYTES) \
      + (p & ARM_L1_SECTION_MASK))
 
-void cm2_enable_i2c(int i2c_index);
+void cm2_enable_i2c(size_t i2c_index);
 int  cm2_get_hsmmc1_base_clock(void);
-void print_cm2(void);
+void cm2_debug_print(void);
 void cm2_print_standby_state(void);
 
 void cm2_enable_hsmmc1(void);