Fix PWM in Linux 4.1+

Author: Matthew West

setup.py

@@ -41,7 +41,7 @@
       packages         = find_packages(),
       py_modules       = ['Adafruit_I2C'],
       ext_modules      = [Extension('Adafruit_BBIO.GPIO', ['source/py_gpio.c', 'source/event_gpio.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'], define_macros=kernel41),
-                          Extension('Adafruit_BBIO.PWM', ['source/py_pwm.c', 'source/c_pwm.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'], define_macros=kernel41),
+                          Extension('Adafruit_BBIO.PWM', ['source/py_pwm.c', 'source/c_pwm.c', 'source/c_pinmux.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'], define_macros=kernel41),
                           Extension('Adafruit_BBIO.ADC', ['source/py_adc.c', 'source/c_adc.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'], define_macros=kernel41),
                           Extension('Adafruit_BBIO.SPI', ['source/spimodule.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'], define_macros=kernel41),
                           Extension('Adafruit_BBIO.UART', ['source/py_uart.c', 'source/c_uart.c', 'source/constants.c', 'source/common.c'], extra_compile_args=['-Wno-format-security'], define_macros=kernel41)] )

source/c_pinmux.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "c_pinmux.h"
+#include "common.h"
+
+
+// 0 = success
+// non-zero = error
+int set_pin_mode(const char *key, const char *mode)
+{
+	// char ocp_dir[30] "/sys/devices/platform/ocp"
+	char path[60]; // "/sys/devices/platform/ocp/ocp:P#_##_pinmux/state"
+	char pinmux_dir[20]; // "ocp:P#_##_pinmux"
+	FILE *f = NULL;
+
+	build_path("/sys/devices", "ocp", ocp_dir, sizeof(ocp_dir));
+
+	snprintf(pinmux_dir, sizeof(pinmux_dir), "ocp:%s_pinmux", key);
+	snprintf(path, sizeof(path), "%s/%s/state", sizeof(path));
+
+	f = fopen(path, "w");
+	if (NULL == f) {
+		return -1;
+	} 
+
+	fprintf(f, "%s", mode);
+	fclose(f);
+
+	return 0;
+}

source/c_pinmux.h

@@ -0,0 +1,29 @@
+/*
+Copyright (c) 2016 Adafruit
+Author: Matthew West
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#ifndef C_PINMUX_H
+#define C_PINMUX_H
+
+int set_pin_mode(const char *key, const char *mode);
+
+#endif

source/c_pwm.c

@@ -23,17 +23,19 @@ SOFTWARE.
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <string.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include "c_pwm.h"
 #include "common.h"
 
-#define KEYLEN 7
+#ifdef BBBVERSION41
+#include "c_pinmux.h"
+#endif
 
-#define PERIOD 0
-#define DUTY 1
+#define KEYLEN 7
 
 int pwm_initialized = 0;
 
@@ -85,13 +87,20 @@ void export_pwm(struct pwm_exp *new_pwm)
 
 int initialize_pwm(void)
 {
+#ifdef BBBVERSION41  // don't load overlay in 4.1+
+    if (!pwm_initialized) {
+#else
     if  (!pwm_initialized && load_device_tree("am33xx_pwm")) {
-        build_path("/sys/devices", "ocp", ocp_dir, sizeof(ocp_dir));
+#endif
+        if (!build_path("/sys/devices", "ocp", ocp_dir, sizeof(ocp_dir)))
+        {
+            return -1;
+        }
         pwm_initialized = 1;
         return 1;
     }
 
-    return 0;   
+    return 0;
 }
 
 int pwm_set_frequency(const char *key, float freq) {
@@ -162,37 +171,128 @@ int pwm_set_duty_cycle(const char *key, float duty) {
 
 int pwm_start(const char *key, float duty, float freq, int polarity)
 {
+#ifdef BBBVERSION41
+    char pwm_dev_path[45]; // "/sys/devices/platform/ocp/48300000.epwmss"
+    char pwm_addr_path[60]; // "/sys/devices/platform/ocp/48300000.epwmss/48300200.ehrpwm"
+    char pwm_chip_path[75]; // "/sys/devices/platform/ocp/48300000.epwmss/48300200.ehrpwm/pwm/pwmchip0"
+    char pwm_export_path[80]; // "/sys/devices/platform/ocp/48300000.epwmss/48300200.ehrpwm/pwm/pwmchip0/export"
+    char pwm_path[80]; // "/sys/devices/platform/ocp/48300000.epwmss/48300200.ehrpwm/pwm/pwmchip0/pwm1"
+    char duty_path[90]; // "/sys/devices/platform/ocp/48300000.epwmss/48300200.ehrpwm/pwm/pwmchip0/pwm1/duty_cycle"
+    char period_path[90];
+    char polarity_path[90];
+    char enable_path[90];
+
+    int period_fd, duty_fd, polarity_fd;
+    struct pwm_exp *new_pwm, *pwm;
+    struct stat s;
+    int err;
+    FILE *f = NULL;
+    pwm_t *p;
+
+    if(!pwm_initialized) {
+        if (initialize_pwm() < 0) {
+            return -1;
+        }
+    }
+
+    // Make sure that one of the universal capes is loaded
+    if (!( device_tree_loaded("cape-univ-audio") // from cdsteinkuehler/beaglebone-universal-io
+        || device_tree_loaded("cape-univ-emmc")  // ""
+        || device_tree_loaded("cape-univ-hdmi")  // ""
+        || device_tree_loaded("cape-universal")  // ""
+        || device_tree_loaded("cape-universala") // ""
+        || device_tree_loaded("cape-universaln") // ""
+        || device_tree_loaded("univ-all")        // from latest BeagleBone Debian 8 images
+        || device_tree_loaded("univ-bbgw")       // ""
+        || device_tree_loaded("univ-emmc")       // ""
+        || device_tree_loaded("univ-hdmi")       // ""
+        || device_tree_loaded("univ-nhdmi")))    // ""
+    {
+        return -1;
+    }
+    // Do pinmuxing
+    set_pin_mode(key, "pwm");
+
+    // Get info for pwm
+    if (!get_pwm_by_key(key, &p)) {
+        return -1;
+    }
+
+    build_path(ocp_dir, p->chip, pwm_dev_path, sizeof(pwm_dev_path));
+    build_path(pwm_dev_path, p->addr, pwm_addr_path, sizeof(pwm_addr_path));
+    build_path(pwm_addr_path, "pwm/pwmchip", pwm_chip_path, sizeof(pwm_chip_path));
+
+    snprintf(pwm_path, sizeof(pwm_path), "%s/pwm%d", pwm_chip_path, p->index);
+
+    // Export PWM if hasn't already been
+    err = stat(pwm_path, &s);
+    if (-1 == err) {
+        if (ENOENT == errno) { // directory does not exist
+            snprintf(pwm_export_path, sizeof(pwm_export_path), "%s/export", pwm_chip_path);
+            f = fopen(pwm_export_path, "w");
+            if (f == NULL) { // Can't open the export file
+                return -1;
+            }
+            fprintf(f, "%d", p->index);
+            fclose(f);
+        } else {
+            perror("stat");
+            return -1;
+        } else {
+            if (S_ISDIR(s.st_mode)) {
+                /* It is a directory. Already exported */
+            } else {
+                /* It's a file. Shouldn't ever happen */
+                return -1;
+            }
+        }
+    }
+
+    err = stat(pwm_path, &s);
+    if (-1 == err) {
+        if (ENOENT == errno) {
+            // Directory still doesn't exist, exit with error
+            return -1;
+        }
+    }
+
+    snprintf(duty_path, sizeof(duty_path), "%s/duty_cycle", pwm_path);
+#else
     char fragment[18];
-    char pwm_test_fragment[20];
-    char pwm_test_path[45];
+    char pwm_fragment[20];
+    char pwm_path[45];
+    char duty_path[56]
     char period_path[50];
-    char duty_path[50];
     char polarity_path[55];
     int period_fd, duty_fd, polarity_fd;
-    struct pwm_exp *new_pwm, *pwm;
+    struct pwm_exp *new_pwm;
 
     if(!pwm_initialized) {
-        initialize_pwm();
+        if (initialize_pwm() < 0) {
+            return -1;
+        }
     }
 
+    // load tree
     snprintf(fragment, sizeof(fragment), "bone_pwm_%s", key);
-    
-
     if (!load_device_tree(fragment)) {
         //error enabling pin for pwm
         return -1;
     }
 
     //creates the fragment in order to build the pwm_test_filename, such as "pwm_test_P9_13"
-    snprintf(pwm_test_fragment, sizeof(pwm_test_fragment), "pwm_test_%s", key);
+    snprintf(pwm_fragment, sizeof(pwm_fragment), "pwm_test_%s", key);
+
+    //finds and builds the pwm_path, as it can be variable...
+    build_path(ocp_dir, pwm_fragment, pwm_path, sizeof(pwm_path));
 
-    //finds and builds the pwm_test_path, as it can be variable...
-    build_path(ocp_dir, pwm_test_fragment, pwm_test_path, sizeof(pwm_test_path));
+    //create the path for duty
+    snprintf(duty_path, sizeof(duty_path), "%s/duty", pwm_path);
+#endif
 
-    //create the path for the period and duty
-    snprintf(period_path, sizeof(period_path), "%s/period", pwm_test_path);
-    snprintf(duty_path, sizeof(duty_path), "%s/duty", pwm_test_path);
-    snprintf(polarity_path, sizeof(polarity_path), "%s/polarity", pwm_test_path);
+    // create the path for period and polarity
+    snprintf(period_path, sizeof(period_path), "%s/period", pwm_path);
+    snprintf(polarity_path, sizeof(polarity_path), "%s/polarity", pwm_path);
 
     //add period and duty fd to pwm list    
     if ((period_fd = open(period_path, O_RDWR)) < 0)
@@ -231,6 +331,14 @@ int pwm_start(const char *key, float duty, float freq, int polarity)
     pwm_set_polarity(key, polarity);
     pwm_set_duty_cycle(key, duty);
 
+#ifdef BBBVERSION41  // Enable the PWM
+    f = fopen(enable_path);
+    if (f == NULL)
+        return -1;
+    fprintf(f, "1");
+    fclose(f);
+#endif
+
     return 1;
 }
 

source/common.c

@@ -33,6 +33,7 @@ SOFTWARE.
 #include "Python.h"
 #include <dirent.h>
 #include <time.h>
+#include <string.h>
 #include <glob.h>
 #include "common.h"
 
@@ -165,6 +166,40 @@ uart_t uart_table[] = {
   { NULL, NULL, 0 }
 };
 
+// Modeled after "pwm": submap in bone.js from bonescript
+// https://github.com/jadonk/bonescript/blob/master/src/bone.js#L680
+typedef struct pwm_t {
+  const char *module;
+  const int sysfs;
+  const int index;
+  const int muxmode;
+  const char *path;
+  const char *name;
+  const char *chip;
+  const char *addr;
+  const char *key;  // Pin name eg P9_21
+} pwm_t;
+
+// Copied from https://github.com/jadonk/bonescript/blob/master/src/bone.js
+
+pwm_t pwm_table[] = {
+  { "ehrpwm2", 6, 1, 4, "ehrpwm.2:1", "EHRPWM2B", "48304000", "48304200", "P8_13"},
+  { "ehrpwm2", 5, 0, 4, "ehrpwm.2:0", "EHRPWM2A", "48304000", "48304200", "P8_19"},
+  { "ehrpwm1", 4, 1, 2, "ehrpwm.1:1", "EHRPWM1B", "48302000", "48302200", "P8_34"},
+  { "ehrpwm1", 3, 0, 2, "ehrpwm.1:0", "EHRPWM1A", "48302000", "48302200", "P8_36"},
+  { "ehrpwm2", 5, 0, 3, "ehrpwm.2:0", "EHRPWM2A", "48304000", "48304200", "P8_45"},
+  { "ehrpwm2", 6, 1, 3, "ehrpwm.2:1", "EHRPWM2B", "48304000", "48304200", "P8_46"},
+  { "ehrpwm1", 3, 0, 6, "ehrpwm.1:0", "EHRPWM1A", "48302000", "48302200", "P9_14"},
+  { "ehrpwm1", 4, 1, 6, "ehrpwm.1:1", "EHRPWM1B", "48302000", "48302200", "P9_16"},
+  { "ehrpwm0", 1, 1, 3, "ehrpwm.0:1", "EHRPWM0B", "48300000", "48300200", "P9_21"},
+  { "ehrpwm0", 0, 0, 3, "ehrpwm.0:0", "EHRPWM0A", "48300000", "48300200", "P9_22"},
+  { "ecap2", 7, 2, 4, "ecap.2", "ECAPPWM2", "", "", "P9_28"},
+  { "ehrpwm0", 1, 1, 1, "ehrpwm.0:1", "EHRPWM0B", "48300000", "48300200", "P9_29"},
+  { "ehrpwm0", 0, 0, 1, "ehrpwm.0:0", "EHRPWM0A", "48300000", "48300200", "P9_31"},
+  { "ecap0", 2, 0, 0, "ecap.0", "ECAPPWM0", "", "", "P9_42"},
+  { NULL, 0, 0, 0, NULL, NULL, NULL, NULL, NULL }
+}
+
 int lookup_gpio_by_key(const char *key)
 {
   pins_t *p;
@@ -276,6 +311,20 @@ int get_gpio_number(const char *key, unsigned int *gpio)
     return 0;
 }
 
+int get_pwm_by_key(const char *key, pwm_t **pwm)
+{
+    pwm_t *p;
+    // Loop through the table
+    for (p = pwm_table; p->key != NULL; ++p) {
+        if (strcmp(p->key, key) == 0) {
+            // Return the pwm_t struct
+            *pwm = p;
+            return 1;
+        }
+    }
+    return 0;
+}
+
 int get_pwm_key(const char *input, char *key)
 {
     if (!copy_pwm_key_by_key(input, key)) {
@@ -399,6 +448,44 @@ int load_device_tree(const char *name)
     return 1;
 }
 
+// Find whether a device tree is loaded.
+// Returns 1 if so, <0 if error, and 0 if not.
+int device_tree_loaded(const char *name)
+{
+    FILE *file = NULL;
+    #ifdef BBBVERSION41
+    char slots[41];
+    snprintf(ctrl_dir, sizeof(ctrl_dir), "/sys/devices/platform/bone_capemgr");
+#else
+    char slots[40];
+    build_path("/sys/devices", "bone_capemgr", ctrl_dir, sizeof(ctrl_dir));
+#endif
+    char line[256];
+    char *slot_line;
+
+    snprintf(slots, sizeof(slots), "%s/slots", ctrl_dir);
+
+
+    file = fopen(slots, "r+");
+    if (!file) {
+        PyErr_SetFromErrnoWithFilename(PyExc_IOError, slots);
+        return -1;
+    }
+
+    while (fgets(line, sizeof(line), file)) {
+        //the device is loaded, close file and return true
+        if (strstr(line, name)) {
+            fclose(file);
+            return 1;
+        }
+    }
+
+    //not loaded, close file
+    fclose(file);
+
+    return 0;
+}
+
 int unload_device_tree(const char *name)
 {
     FILE *file = NULL;