DM Timer Beaglebone Black questions

I have determined how to request a specific timer, I just had to add the exact timer's device node to my device tree, and then parse to retrieve it via of_parse_phandle then call omap_dm_timer_request_by_node instead.

 Below is my code for my Kernel Module. Following it is the change I made to the device tree.

#include <linux/module.h>     /* Needed by all Linux Kernel Modules */
#include <linux/platform_device.h>    /* Needed to query the plaform configuration for addresses, interrupts,etc */
#include <linux/kernel.h>     /* Needed for KERN_INFO */
#include <linux/init.h>           /* Needed for the module_ macros */

/* ARM DM Timer Header */
#include <plat/dmtimer.h>

/* Needed for clk functions */
#include <linux/clk.h>    

/* Interrupt Header */
#include <linux/interrupt.h>

#define DRIVER_AUTHOR   "Sean Moffatt"
#define DRIVER_DESC "Test DM Timer"     
#define DRIVER_NAME "test_module_timer"

static struct omap_dm_timer *timer_ptr = NULL;

static int32_t timer_irq;
static uint32_t timer_rate;


static irqreturn_t timer_irq_handler( int irq, void * dev_id)
{
    int status = 0;

    /* Read the current Status */
    status = omap_dm_timer_read_status(timer_ptr);

    /* Clear the timer interrupt */
    if (status == OMAP_TIMER_INT_MATCH)
    {
        omap_dm_timer_write_status(timer_ptr,  OMAP_TIMER_INT_MATCH);
    }   

    /* Stop the Timer */
    omap_dm_timer_stop(timer_ptr);

    /* Indicate the Interrupt was handled */
    return IRQ_HANDLED;
}

static int test_module_init(struct platform_device *pdev)
{
    int ret = 1;
    struct clk *timer_clk;  

    struct device_node *timer_device_node; 
	
   /* Attempt to request a timer based on the device node */
   timer_device_node = of_parse_phandle(pdev->dev.of_node, "DMtimer", 0);	
   timer_ptr = omap_dm_timer_request_by_node(timer_device_node);
   if(timer_ptr == NULL){
	/* no timers available */
	printk(KERN_INFO "Can't request specified DM Timer\n");
	return -1;
    }	

    /* Set the Clock source to the System Clock */
    ret = omap_dm_timer_set_source(timer_ptr, OMAP_TIMER_SRC_SYS_CLK);

    /* Determine what IRQ the timer triggers */
    timer_irq = omap_dm_timer_get_irq(timer_ptr);

    /* Setup the IRQ handler */
    ret = request_irq(timer_irq, timer_irq_handler, IRQF_TIMER, DRIVER_NAME, NULL);

    /* Setup the timer to trigger the IRQ on the match event */
    omap_dm_timer_set_int_enable(timer_ptr, OMAP_TIMER_INT_MATCH);
    
    /* Get the Clock rate in Hz */
    timer_clk = omap_dm_timer_get_fclk(timer_ptr);
    timer_rate = clk_get_rate(timer_clk);
    
    /* Setup the Output for the Timer pin */
    /* Setup to toggle on the overflow and the compare match event */   
    omap_dm_timer_set_pwm(timer_ptr, 0, 1, OMAP_TIMER_TRIGGER_OVERFLOW_AND_COMPARE);

    /* Enable the Timer */
    /* Needs to be done before we can write to the counter */
    omap_dm_timer_enable(timer_ptr);

    /* Set the initial Count */
    /* According to section 20.1.3.5 Pulse-Width Modulation, an overflow or match be used to toggle when a compare condition occurs*/
    /* Therefore it we will trigger the overflow event almost immediately to ensure our toggle will be generated quickly */
    omap_dm_timer_write_counter(timer_ptr, (0xFFFFFFFF - 5));

    /* Setup the Load Register */
    /* Setup as autoload to set the the counter back to 0 on an overflow */
    omap_dm_timer_set_load(timer_ptr, 1, 0);

    /* Set the the compare register to 1 second */
    /* This will ensure the signal toggle of 1 second after the overflow event*/
    omap_dm_timer_set_match(timer_ptr, 1, timer_rate);

    /* Start the timer */
    ret = omap_dm_timer_start(timer_ptr);
    printk(KERN_INFO "Timer Start ret %d\n", ret);

    /* 
    * A non 0 returns means the call to init_modules failed; module can't be loaded
    */
    return 0;
}


static int test_module_exit(struct platform_device *pdev)
{
    int ret = 1;

    /* stop the timer */
    ret = omap_dm_timer_stop(timer_ptr);
    printk(KERN_INFO "Timer Stop ret = %d\n", ret); 

    /* Release the IRQ handler */
    free_irq(timer_irq, NULL);
    printk(KERN_INFO "Free IRQ Done\n");    

    /* Release the timer */
    ret = omap_dm_timer_free(timer_ptr);
    printk(KERN_INFO "Timer Free ret = %d\n", ret); 

    return 0;
}


static const struct of_device_id test_module_timer_of_match[] = {
    { .compatible   = "test,am33xx-test_module_timer" },
    {},
};

static struct platform_driver test_module_timer_driver = {
    .driver = {
        .name   = DRIVER_NAME,
        .owner  = THIS_MODULE,
        .of_match_table = test_module_timer_of_match,
    },
    .probe  = test_module_init,
    .remove = test_module_exit,
};

module_platform_driver(test_module_timer_driver);
MODULE_LICENSE("GPL");
MODULE_AUTHOR(DRIVER_AUTHOR);       /* Who wrote this module */
MODULE_DESCRIPTION(DRIVER_DESC);    /* What is this module */

Device Tree

In the &am33x_pinmux{

timer4_pins: timer4_pins {
pinctrl-single,pins = <
0x090 (PIN_OUTPUT_PULLDOWN | MUX_MODE2) /* TIMER4 P8_07 */ 
>;
};

};

am33xx-test_module_timer {
compatible = "test,am33xx-test_module_timer";
status = "okay";
pinctrl-names = "default";
pinctrl-0 = <&timer4_pins>;

DMtimer = <&timer4>;

};