AM3352: mclk not found

e f

Part Number: AM3352
Other Parts Discussed in Thread: TAS5508C

Tool/software:

How to solve missing clock parts in DTS

sound_out: sound-out {
compatible = "wnz,pm-out";
ti,model = "Audio out";
ti,audio-codec = <&tas5508c>;
ti,mcasp-controller = <&mcasp0>;
ti,codec-clock-rate = <24576000>;

clock-names = "???"

clocks = "???"

};

417:

mclk = devm_clk_get(&pdev->dev, "mclk");
if (PTR_ERR(mclk) == -EPROBE_DEFER) {
return -EPROBE_DEFER;
} else if (IS_ERR(mclk)) {
dev_dbg(&pdev->dev, "mclk not found.\n");
mclk = NULL;
}

Getting

[ 14.570575] davinci_evm sound-in: mclk not found.

could be
DTS like

sound_out: sound-out {
compatible = "wnz,pm-out";
ti,model = "Audio out";
ti,audio-codec = <&tas5508c>;
ti,mcasp-controller = <&mcasp0>;
ti,codec-clock-rate = <24576000>;

clock-names = "fck"

clocks = <&l4ls_gclk>

};

and davinci-evm part like

mclk = devm_clk_get(&pdev->dev, "fck");
if (PTR_ERR(mclk) == -EPROBE_DEFER) {
return -EPROBE_DEFER;
} else if (IS_ERR(mclk)) {
dev_dbg(&pdev->dev, "mclk not found.\n");
mclk = NULL;
}

over 1 year ago

0 Suren Porwar over 1 year ago

TI__Mastermind 31440 points

Hi,

Can you let me know what version of SW are you testing this with?

Our EVM latest SDK released software with Linux kernel (6.1) can be found here:

https://dr-download.ti.com/software-development/software-development-kit-sdk/MD-1BUptXj3op/09.01.00.001/tisdk-default-image-am335x-evm.wic.xz

Best Regards,

Suren

0 e f over 1 year ago in reply to Suren Porwar

Prodigy 200 points

Yocto Kirkstone, no SDK

Is there some reference for "mclk" which is required

with line

- clock-names : The clock should be named "mclk"

in git.ti.com/.../davinci-evm-audio.txt

Using following DTS

Fullscreen device_tree.dts.clr.txt Download

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2012 Texas Instruments Incorporated - https://www.ti.com/
 */
/dts-v1/;

#include "am33xx.dtsi"

/ {
    model = "TI AM335x BeagleTest";
    compatible = "ti,am335x-bone", "ti,am33xx";
    cpus {
            cpu@0 {
                cpu0-supply = <&vdd1_reg>;
            };
        };

        memory@80000000 {
            device_type = "memory";
            reg = <0x80000000 0x20000000>; /* 512 MB */
        };

        chosen {
            stdout-path = &uart0;
            tick-timer = &timer2;
        };


        // vmmcsd_fixed: fixedregulator0 {
        //  compatible = "regulator-fixed";
        //  regulator-name = "vmmcsd_fixed";
        //  regulator-min-microvolt = <3300000>;
        //  regulator-max-microvolt = <3300000>;
        //  regulator-boot-on;
        // };
        vbat: fixedregulator1 {
            compatible = "regulator-fixed";
            regulator-name = "vbat";
            regulator-min-microvolt = <5000000>;
            regulator-max-microvolt = <5000000>;
            regulator-boot-on;
        };
        sound_out: sound-out {
            compatible = "ont,on20-o2nm-out";
            ti,model = "Opner O2NM Audio out";
            ti,audio-codec = <&tas5508c>;
            ti,mcasp-controller = <&mcasp0>;
            ti,codec-clock-rate = <24576000>;
        };
        pcm1808: pcm1808 {
            compatible = "ti,pcm1808";          
        };
        sound_in: sound-in {
            compatible = "ont,on20-o2nm-in";
            ti,model = "Opner O2NM Audio in";
            ti,audio-codec = <&pcm1808>;
            ti,mcasp-controller = <&mcasp1>;
            ti,codec-clock-rate = <24576000>;
        };

};

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2012 Texas Instruments Incorporated - https://www.ti.com/
 */


&am33xx_pinmux {
    pinctrl-names = "default";
    pinctrl-0 = <&clkout2_pin>;

    i2c0_pins: pinmux_i2c0_pins {
        pinctrl-single,pins = <
            AM33XX_PADCONF(AM335X_PIN_I2C0_SDA, PIN_INPUT_PULLUP, MUX_MODE0)    /* i2c0_sda.i2c0_sda */
            AM33XX_PADCONF(AM335X_PIN_I2C0_SCL, PIN_INPUT_PULLUP, MUX_MODE0)    /* i2c0_scl.i2c0_scl */
        >;
    };

    i2c2_pins: pinmux_i2c2_pins {
        pinctrl-single,pins = <
                AM33XX_PADCONF(0x978,PIN_INPUT_PULLUP , MUX_MODE3)  /* uart1_ctsn.i2c1_sda */
                AM33XX_PADCONF(0x97c,PIN_INPUT_PULLUP , MUX_MODE3)  /* uart1_rtsn.i2c1_scl */
                
                /* TAS5508c reset */
                AM33XX_PADCONF(0x8a4,PIN_OUTPUT , MUX_MODE7)            /* lcd_data1.gpio2_7 */
                
                /* LPC reset */
                AM33XX_PADCONF(0x8d4,PIN_OUTPUT , MUX_MODE7)            /* lcd_data13.gpio0_9 */
                
                /* WD delay/beeper */
                AM33XX_PADCONF(0x918,PIN_OUTPUT , MUX_MODE7)            /* gmii1_rxdv.gpio3_4 */

                /* LPC1768 i2c interrupt line */
                AM33XX_PADCONF(0x8c0,PIN_INPUT_PULLUP , MUX_MODE7)      /* lcd_data8.gpio2_14 */

        >;
    };
    mcasp0_pins: pinmux_mcasp0_pins {
            pinctrl-single,pins = <
                AM33XX_PADCONF(0x9ac,PIN_INPUT_PULLUP  , MUX_MODE0) /* mcasp0_ahclkx.mcasp0_ahclkx */   
                AM33XX_PADCONF(0x990,PIN_OUTPUT_PULLUP , MUX_MODE0) /* mcasp0_aclkx.mcasp0_aclkx */
                AM33XX_PADCONF(0x994,PIN_OUTPUT_PULLUP , MUX_MODE0) /* mcasp0_fsx.mcasp0_fsx */ 
                AM33XX_PADCONF(0x998,PIN_OUTPUT_PULLUP , MUX_MODE0) /* mcasp0_axr0.mcasp0_axr0 */
                AM33XX_PADCONF(0x9a8,PIN_OUTPUT_PULLUP , MUX_MODE0) /* mcasp0_axr1.mcasp0_axr1 */
                AM33XX_PADCONF(0x9a0,PIN_OUTPUT_PULLUP , MUX_MODE2)     /* mcasp0_aclkr.mcasp0_axr2 */
                AM33XX_PADCONF(0x9a4,PIN_OUTPUT_PULLUP , MUX_MODE2)     /* mcasp0_fsr.mcasp0_axr3 */

            >;
        };
        mcasp1_pins: pinmux_mcasp1_pins {
            pinctrl-single,pins = <
                AM33XX_PADCONF(0x940,PIN_INPUT_PULLUP  , MUX_MODE4) /* gmii1_rxd0.mcasp1_ahclkr */                  
                AM33XX_PADCONF(0x928,PIN_OUTPUT_PULLUP , MUX_MODE4) /* gmii1_txd0.mcasp1_aclkr */
                AM33XX_PADCONF(0x93c,PIN_OUTPUT_PULLUP , MUX_MODE4) /* gmii1_rxd1.mcasp1_fsr */ 
                AM33XX_PADCONF(0x914,PIN_INPUT_PULLUP  , MUX_MODE4) /* gmii1_txen.mcasp1_axr0 */
                AM33XX_PADCONF(0x924,PIN_INPUT_PULLUP  , MUX_MODE4) /* gmii1_txd1.mcasp1_axr1 */
            >;
        };

    spi0_pins: pinmux_spi0_pins {
            pinctrl-single,pins = <
                AM33XX_PADCONF(0x950,PIN_INPUT_PULLDOWN,MUX_MODE0)  /* spi0_sclk.spi0_sclk*/
                AM33XX_PADCONF(0x954,PIN_INPUT_PULLUP,MUX_MODE0)    /* spi0_d0.spi0_d0 */
                AM33XX_PADCONF(0x958,PIN_INPUT_PULLDOWN,MUX_MODE0)  /* spi0_d1.spi0_d1 */               
                AM33XX_PADCONF(0x95c,PIN_INPUT_PULLUP,MUX_MODE0)    /* spi0_cs0.spi0_cs0 */         
                
                /* Interrupt from KZS8895 */
                AM33XX_PADCONF(0x92c,PIN_INPUT_PULLUP,MUX_MODE7)    /* mii1_tx_clk.gpio3_9 */
                
                /* Reset to KZS8895 */
                AM33XX_PADCONF(0x930,PIN_OUTPUT,MUX_MODE7)          /* mii1_rx_clk.gpio3_10 */
            >;
        };

    uart0_pins: pinmux_uart0_pins {
        pinctrl-single,pins = <
            AM33XX_PADCONF(AM335X_PIN_UART0_RXD, PIN_INPUT_PULLUP, MUX_MODE0)
            AM33XX_PADCONF(AM335X_PIN_UART0_TXD, PIN_OUTPUT_PULLDOWN, MUX_MODE0)
        >;
    };

    clkout2_pin: pinmux_clkout2_pin {
        pinctrl-single,pins = <
            AM33XX_PADCONF(AM335X_PIN_XDMA_EVENT_INTR1, PIN_OUTPUT_PULLDOWN, MUX_MODE3) /* xdma_event_intr1.clkout2 */
        >;
    };







    mmc1_pins: pinmux_mmc1_pins {
        pinctrl-single,pins = <
            AM33XX_PADCONF(AM335X_PIN_MII1_TXD2, PIN_INPUT, MUX_MODE7)      /* spio0_cs1.gpio0_6 */
            AM33XX_PADCONF(AM335X_PIN_MMC0_DAT0, PIN_INPUT_PULLUP, MUX_MODE0)
            AM33XX_PADCONF(AM335X_PIN_MMC0_DAT1, PIN_INPUT_PULLUP, MUX_MODE0)
            AM33XX_PADCONF(AM335X_PIN_MMC0_DAT2, PIN_INPUT_PULLUP, MUX_MODE0)
            AM33XX_PADCONF(AM335X_PIN_MMC0_DAT3, PIN_INPUT_PULLUP, MUX_MODE0)
            AM33XX_PADCONF(AM335X_PIN_MMC0_CMD, PIN_INPUT_PULLUP, MUX_MODE0)
            AM33XX_PADCONF(AM335X_PIN_MMC0_CLK, PIN_INPUT_PULLUP, MUX_MODE0)
        >;
    };
    nandflash_pins_s0: nandflash_pins_s0 {
        pinctrl-single,pins = <
                AM33XX_PADCONF(0x800,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad0.gpmc_ad0 */
                AM33XX_PADCONF(0x804,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad1.gpmc_ad1 */
                AM33XX_PADCONF(0x808,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad2.gpmc_ad2 */
                AM33XX_PADCONF(0x80c,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad3.gpmc_ad3 */
                AM33XX_PADCONF(0x810,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad4.gpmc_ad4 */
                AM33XX_PADCONF(0x814,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad5.gpmc_ad5 */
                AM33XX_PADCONF(0x818,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad6.gpmc_ad6 */
                AM33XX_PADCONF(0x81c,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad7.gpmc_ad7 */
                AM33XX_PADCONF(0x820,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad8.gpmc_ad8 */
                AM33XX_PADCONF(0x824,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad9.gpmc_ad9 */
                AM33XX_PADCONF(0x828,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad10.gpmc_ad10 */
                AM33XX_PADCONF(0x82c,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad11.gpmc_ad11 */
                AM33XX_PADCONF(0x830,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad12.gpmc_ad12 */
                AM33XX_PADCONF(0x834,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad13.gpmc_ad13 */
                AM33XX_PADCONF(0x838,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad14.gpmc_ad14 */
                AM33XX_PADCONF(0x83c,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_ad15.gpmc_ad15 */
                AM33XX_PADCONF(0x870,PIN_INPUT_PULLUP , MUX_MODE0)      /* gpmc_wait0.gpmc_wait0 */
                AM33XX_PADCONF(0x874,PIN_INPUT_PULLUP , MUX_MODE7)      /* gpmc_wpn.gpio0_30 */
                AM33XX_PADCONF(0x87c,PIN_OUTPUT , MUX_MODE0)            /* gpmc_csn0.gpmc_csn0  */
                AM33XX_PADCONF(0x890,PIN_OUTPUT , MUX_MODE0)            /* gpmc_advn_ale.gpmc_advn_ale */
                AM33XX_PADCONF(0x894,PIN_OUTPUT , MUX_MODE0)            /* gpmc_oen_ren.gpmc_oen_ren */
                AM33XX_PADCONF(0x898,PIN_OUTPUT , MUX_MODE0)            /* gpmc_wen.gpmc_wen */
                AM33XX_PADCONF(0x89c,PIN_OUTPUT , MUX_MODE0)            /* gpmc_be0n_cle.gpmc_be0n_cle */
        >;
    };
    mii2_pins: pinmux_mii2_pins {
        pinctrl-single,pins = <
            /* Slave 1 */
            AM33XX_PADCONF(0x840, PIN_OUTPUT, MUX_MODE1)    /* mii1_txen.rgmii1_tctl */
            AM33XX_PADCONF(0x844, PIN_INPUT_PULLDOWN, MUX_MODE1)    /* mii1_rxdv.rgmii1_rctl */
            AM33XX_PADCONF(0x848, PIN_OUTPUT, MUX_MODE1)    /* mii1_txd3.rgmii1_td3 */
            AM33XX_PADCONF(0x84c, PIN_OUTPUT, MUX_MODE1)    /* mii1_txd2.rgmii1_td2 */
            AM33XX_PADCONF(0x850, PIN_OUTPUT, MUX_MODE1)    /* mii1_txd1.rgmii1_td1 */
            AM33XX_PADCONF(0x854, PIN_OUTPUT, MUX_MODE1)    /* mii1_txd0.rgmii1_td0 */
            AM33XX_PADCONF(0x858, PIN_INPUT_PULLDOWN, MUX_MODE1)    /* mii1_txclk.rgmii1_tclk */
            AM33XX_PADCONF(0x85c, PIN_INPUT_PULLDOWN, MUX_MODE1)    /* mii1_rxclk.rgmii1_rclk */
            AM33XX_PADCONF(0x860, PIN_INPUT_PULLDOWN, MUX_MODE1)    /* mii1_rxd3.rgmii1_rd3 */
            AM33XX_PADCONF(0x864, PIN_INPUT_PULLDOWN, MUX_MODE1)    /* mii1_rxd2.rgmii1_rd2 */
            AM33XX_PADCONF(0x868, PIN_INPUT_PULLDOWN, MUX_MODE1)    /* mii1_rxd1.rgmii1_rd1 */
            AM33XX_PADCONF(0x86c, PIN_INPUT_PULLDOWN, MUX_MODE1)    /* mii1_rxd0.rgmii1_rd0 */
        >;
    };


};

&uart0 {
    pinctrl-names = "default";
    pinctrl-0 = <&uart0_pins>;

    status = "okay";
};

&usb0 {
    dr_mode = "peripheral";
    interrupts-extended = <&intc 18 &tps 0>;
    interrupt-names = "mc", "vbus";
};

&usb1 {
    dr_mode = "host";
};

&i2c0 {
    pinctrl-names = "default";
    pinctrl-0 = <&i2c0_pins>;

    status = "okay";
    clock-frequency = <100000>;

    tps: tps@2D {
        reg = <0x2D>;
    };

    baseboard_eeprom: baseboard_eeprom@50 {
        compatible = "atmel,24c256";
        reg = <0x50>;

        #address-cells = <1>;
        #size-cells = <1>;
    };
};

&i2c2 {
    pinctrl-names = "default";
    pinctrl-0 = <&i2c2_pins>;

    status = "okay";
    clock-frequency = <400000>;
    tas5508c: tas5508c@1b {
                compatible = "ti,tas5508c"; 
                reg = <0x1b>;
                tas5508c,gpio_reset = <71>;     /* gpio_reset = GPIO_TO_PIN(2,7) */
                tas5508c,gpio_mute = <0>;
            };
        
            ampinterface0: ampinterface0@60 {
                compatible = "ti,lpc1768";
                reg = <0x60>;
                /* GPIO_TO_PIN(2,14) */
                //ampinterface0,gpio_irq = <78>;    //  GPIO_TO_PIN(2,14)
            };  
};
&spi0 {
            status = "okay";
            pinctrl-names = "default";
            pinctrl-0 = <&spi0_pins>;
            ti,pindir-d0-out-d1-in = <1>;
            

            ksz8895: ksz8895@0 {
                compatible = "micrel,ksz8895";
                status = "okay";
                spi-max-frequency = <12000000>;       
                // spi-cpha;
                // spi-cpol;   
                phy-mode = "mii";       
                reg = <0>;  /* Chip select 0 */
                
                ksz8895,gpio_reset = <74>; /* GPIO_TO_PIN(3,10) */
                ksz8895,gpio_irq = <73>; /* GPIO_TO_PIN(3,9) */
                // ports {
                //      #address-cells = <1>;
                //      #size-cells = <0>;
                //      port@0 {
                //          reg = <0>;
                //          label = "lan1";
                //      };
                //      port@1 {
                //          reg = <1>;
                //          label = "lan2";
                //      };
                //      port@2 {
                //          reg = <2>;
                //          label = "lan3";
                //      };
                //      port@3 {
                //          reg = <3>;
                //          label = "lan4";
                //      };
                //      port@4 {
                //          reg = <4>;
                //          label = "cpu";
                //          ethernet = <&mac>;
                //          phy-mode = "mii";
                //          fixed-link {
                //              speed = <100>;
                //              full-duplex;
                //          };
                //      };
                //  };
            };
        };


&mac {
    status = "okay";
    // phy-mode = "mii";
    //#address-cells = <1>;
    //#size-cells = <0>;
    pinctrl-names = "default";
    pinctrl-0 = <&mii2_pins>;
    dual_emac ;
    // fixed-link {
    //  speed = <100>;
    //  full-duplex;
    // };
};
&cpsw_emac0 {
    phy-mode = "mii";
    dual_emac_res_vlan = <2>;
    fixed-link {
        speed = <100>;
        full-duplex;
    };  
};

&cpsw_emac1 {
    phy-mode = "mii";
    dual_emac_res_vlan = <3>;
    fixed-link {
        speed = <100>;
        full-duplex;
    };      
};
// &davinci_mdio{
//  status = "okay";
// };
//&mac_sw
//{
//  pinctrl-names = "default";
//  pinctrl-0 = <&mii2_pins>;
//  status = "okay";
//};
&elm{
            status = "okay";
        };
&gpmc {
    status = "okay";
    pinctrl-names = "default";
    pinctrl-0 = <&nandflash_pins_s0>;
    ranges = <0 0 0x08000000 0x10000000>;   /* CS0: 16MB for NAND */
    nand@0,0 {
        compatible = "ti,omap2-nand";
        reg = <0 0 4>; /* CS0, offset 0, IO size 4 */
        rb-gpios = <&gpmc 0 GPIO_ACTIVE_HIGH>; /* gpmc_wait0 */
        ti,nand-xfer-type = "prefetch-dma";
        ti,nand-ecc-opt = "bch8";
        ti,elm-id = <&elm>;
        nand-bus-width = <16>;
        gpmc,device-width = <1>;
        gpmc,sync-clk-ps = <0>;
        gpmc,cs-on-ns = <0>;
        gpmc,cs-rd-off-ns = <44>;
        gpmc,cs-wr-off-ns = <44>;
        gpmc,adv-on-ns = <6>;
        gpmc,adv-rd-off-ns = <34>;
        gpmc,adv-wr-off-ns = <44>;
        gpmc,we-on-ns = <0>;
        gpmc,we-off-ns = <40>;
        gpmc,oe-on-ns = <0>;
        gpmc,oe-off-ns = <54>;
        gpmc,access-ns = <64>;
        gpmc,rd-cycle-ns = <82>;
        gpmc,wr-cycle-ns = <82>;
        gpmc,wait-on-read = "true";
        gpmc,wait-on-write = "true";
        gpmc,bus-turnaround-ns = <0>;
        gpmc,cycle2cycle-delay-ns = <0>;
        gpmc,clk-activation-ns = <0>;
        gpmc,wait-monitoring-ns = <0>;
        gpmc,wr-access-ns = <40>;
        gpmc,wr-data-mux-bus-ns = <0>;
        /* MTD partition table */
        /* All SPL-* partitions are sized to minimal length
         * which can be independently programmable. For
         * NAND flash this is equal to size of erase-block */
        #address-cells = <1>;
        #size-cells = <1>;
        partition@0 {
            label = "NAND.SPL";
            reg = <0x00000000 0x00020000>;
        };
        partition@1 {
            label = "NAND.SPL.backup1";
            reg = <0x00020000 0x00020000>;
        };
        partition@2 {
            label = "NAND.SPL.backup2";
            reg = <0x00040000 0x00020000>;
        };
        partition@3 {
            label = "NAND.SPL.backup3";
            reg = <0x00060000 0x00020000>;
        };
        partition@4 {
            label = "NAND.u-boot-spl-os";
            reg = <0x00080000 0x00040000>;
        };
        partition@5 {
            label = "NAND.u-boot";
            reg = <0x000C0000 0x00100000>;
        };
        partition@6 {
            label = "NAND.u-boot-env";
            reg = <0x001C0000 0x00020000>;
        };
        partition@7 {
            label = "NAND.u-boot-env.backup1";
            reg = <0x001E0000 0x00020000>;
        };
        partition@8 {
            label = "NAND.kernel";
            reg = <0x00200000 0x00800000>;
        };
        partition@9 {
            label = "NAND.file-system";
            reg = <0x00A00000 0x0F600000>;
        };
    };
};

/include/ "tps65910.dtsi"

&tps {
    ti,en-ck32k-xtal = "true";
    
    vcc1-supply = <&vbat>;
    vcc2-supply = <&vbat>;
    vcc3-supply = <&vbat>;
    vcc4-supply = <&vbat>;
    vcc5-supply = <&vbat>;
    vcc6-supply = <&vbat>;
    vcc7-supply = <&vbat>;
    vccio-supply = <&vbat>;

    regulators {
        vrtc_reg: regulator@0 {
            regulator-always-on;
        };

        vio_reg: regulator@1 {
            regulator-always-on;
        };

        vdd1_reg: regulator@2 {
            /* VDD_MPU voltage limits 0.95V - 1.26V with +/-4% tolerance */
            regulator-name = "vdd_mpu";
            regulator-min-microvolt = <912500>;
            regulator-max-microvolt = <1312500>;
            regulator-boot-on;
            regulator-always-on;
        };

        vdd2_reg: regulator@3 {
            /* VDD_CORE voltage limits 0.95V - 1.1V with +/-4% tolerance */
            regulator-name = "vdd_core";
            regulator-min-microvolt = <912500>;
            regulator-max-microvolt = <1150000>;
            regulator-boot-on;
            regulator-always-on;
        };

        vdd3_reg: regulator@4 {
            regulator-always-on;
        };

        vdig1_reg: regulator@5 {
            regulator-always-on;
        };

        vdig2_reg: regulator@6 {
            regulator-always-on;
        };

        vpll_reg: regulator@7 {
            regulator-always-on;
        };

        vdac_reg: regulator@8 {
            regulator-always-on;
        };

        vaux1_reg: regulator@9 {
            regulator-always-on;
        };

        vaux2_reg: regulator@10 {
            regulator-always-on;
        };

        vaux33_reg: regulator@11 {
            regulator-always-on;
        };
        vmmc_reg: regulator@12 {
            regulator-min-microvolt = <1800000>;
            regulator-max-microvolt = <3300000>;
            regulator-always-on;
        };
    };
};








&mmc1 {
    status = "okay";
    bus-width = <0x4>;
    pinctrl-names = "default";
    pinctrl-0 = <&mmc1_pins>;
    vmmc-supply = <&vmmc_reg>;
    cd-gpios = <&gpio0 17 GPIO_ACTIVE_LOW>;
};

&aes {
    status = "okay";
};

&sham {
    status = "okay";
};

&rtc {
    status = "disabled";
    ti,hwmods="disabled";
};

&mcasp0 {
    status = "okay";
    pinctrl-names = "default";
    pinctrl-0 = <&mcasp0_pins>;

    op-mode = <0>;          /* MCASP_IIS_MODE */
    tdm-slots = <2>;
    /* 4 serializers */
    num-serializer = <4>;
    serial-dir = <  /* 0: INACTIVE, 1: TX, 2: RX */
        1 1 1 1  
    >;
    tx-num-evt = <1>;
    rx-num-evt = <1>;
};

&mcasp1 {
    status = "okay";
    pinctrl-names = "default";
    pinctrl-0 = <&mcasp1_pins>;

    op-mode = <0>;          /* MCASP_IIS_MODE */
    tdm-slots = <2>;
    /* 2 serializers */
    num-serializer = <2>;
    serial-dir = <  /* 0: INACTIVE, 1: TX, 2: RX */
        2 2
    >;
    tx-num-evt = <1>;
    rx-num-evt = <1>;
};

and following davinci-evm.c

Fullscreen 3223.davinci-evm.c Download

// SPDX-License-Identifier: GPL-2.0-only
/*
 * ASoC driver for TI DAVINCI EVM platform
 *
 * Author:      Vladimir Barinov, <vbarinov@embeddedalley.com>
 * Copyright:   (C) 2007 MontaVista Software, Inc., <source@mvista.com>
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#define DEBUG 1
#include <linux/of_platform.h>
#include <linux/clk.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/soc.h>
#include <sound/pcm_params.h>
#include <asm/dma.h>
#include <asm/mach-types.h>

struct snd_soc_card_drvdata_davinci {
    struct clk *mclk;
    unsigned sysclk;
    unsigned clk_gpio;
    struct snd_pcm_hw_constraint_list *rate_constraint;
};

#define PM14_AUDIO_FORMAT (SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS | SND_SOC_DAIFMT_NB_IF)

#define PM14_E3LSX_AUDIO_FORMAT (SND_SOC_DAIFMT_E3LSX | SND_SOC_DAIFMT_CBS_CFS | SND_SOC_DAIFMT_NB_IF)

#define PM14_MFAD2_UP0_AUDIO_FORMAT (SND_SOC_DAIFMT_MFAD2_UP0 | SND_SOC_DAIFMT_CBM_CFM | SND_SOC_DAIFMT_IB_NF)

static int evm_startup(struct snd_pcm_substream *substream)
{
    struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
    struct snd_soc_card *soc_card = rtd->card;
    struct snd_soc_card_drvdata_davinci *drvdata =
        snd_soc_card_get_drvdata(soc_card);

    if (drvdata->mclk)
        return clk_prepare_enable(drvdata->mclk);

    return 0;
}
static void evm_shutdown(struct snd_pcm_substream *substream)
{
    struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
    struct snd_soc_card *soc_card = rtd->card;
    struct snd_soc_card_drvdata_davinci *drvdata =
        snd_soc_card_get_drvdata(soc_card);

    clk_disable_unprepare(drvdata->mclk);
}

static int evm_hw_params(struct snd_pcm_substream *substream,
             struct snd_pcm_hw_params *params)
{
    struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
    struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
    struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
    struct snd_soc_card *soc_card = rtd->card;
    int ret = 0;
    unsigned sysclk = ((struct snd_soc_card_drvdata_davinci *)
               snd_soc_card_get_drvdata(soc_card))->sysclk;

    /* set the codec system clock */
    ret = snd_soc_dai_set_sysclk(codec_dai, 0, sysclk, SND_SOC_CLOCK_OUT);
    if (ret < 0)
        return ret;

    /* set the CPU system clock */
    ret = snd_soc_dai_set_sysclk(cpu_dai, 0, sysclk, SND_SOC_CLOCK_OUT);
    if (ret < 0 && ret != -ENOTSUPP)
        return ret;

    return 0;
}
static int pm14_e3ip_startup(struct snd_pcm_substream *substream)
{
    /* For now call evm_startup() */
    return evm_startup(substream);
}

static void pm14_e3ip_shutdown(struct snd_pcm_substream *substream)
{
    /* For now call evm_shutdown() */
    evm_shutdown(substream);
}

static int pm14_e3lsx_startup(struct snd_pcm_substream *substream)
{
    /* For now call evm_startup() */
    return evm_startup(substream);
}

static void pm14_e3lsx_shutdown(struct snd_pcm_substream *substream)
{
    /* For now call evm_shutdown() */
    evm_shutdown(substream);
}

static unsigned int i2s_get_bclk(struct snd_pcm_hw_params *params,
                 int channels)
{
    int sample_size = 32; /* I2S uses 32Bit per sample but some bits might be masked out */
    int rate = params_rate(params);

    return sample_size * channels * rate;
}

static int pm14_e3ip_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
{
    struct snd_soc_pcm_runtime *rtd = substream->private_data;
    struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
    struct snd_soc_dai *codec = asoc_rtd_to_codec(rtd, 0);
    struct snd_soc_card *soc_card = rtd->card;
    struct platform_device *pdev = to_platform_device(soc_card->dev);
    unsigned int bclk_freq = i2s_get_bclk(params, 2);
    int ret = 0;
    unsigned sysclk = ((struct snd_soc_card_drvdata_davinci *)
               snd_soc_card_get_drvdata(soc_card))->sysclk;

    /* set cpu DAI configuration */
    ret = snd_soc_dai_set_fmt(cpu_dai, PM14_AUDIO_FORMAT);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI format %d\n", ret);
        return ret;
    }

    ret = snd_soc_dai_set_clkdiv(cpu_dai, 1, sysclk / bclk_freq);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI clock divider %d\n", ret);
        return ret;
    }

    ret = snd_soc_dai_set_clkdiv(cpu_dai, 2, bclk_freq / params_rate(params));
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI clock divider %d\n", ret);
        return ret;
    }

    /* set the CPU system clock */
    ret = snd_soc_dai_set_sysclk(cpu_dai, 0, sysclk, SND_SOC_CLOCK_IN);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI clock direction %d\n", ret);
        return ret;
    }

    return 0;
}

static int pm14_e3lsx_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
{
    struct snd_soc_pcm_runtime *rtd = substream->private_data;
    struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
    struct snd_soc_dai *codec = asoc_rtd_to_codec(rtd, 0);
    struct snd_soc_card *soc_card = rtd->card;
    struct platform_device *pdev = to_platform_device(soc_card->dev);
    unsigned int bclk_freq = i2s_get_bclk(params, 2);
    int ret = 0;
    unsigned sysclk = ((struct snd_soc_card_drvdata_davinci *)
               snd_soc_card_get_drvdata(soc_card))->sysclk;
               
    printk("open sound card %i\n",params_rate(params));

    /* set cpu DAI configuration */
    ret = snd_soc_dai_set_fmt(cpu_dai, PM14_E3LSX_AUDIO_FORMAT);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI format %d\n", ret);
        return ret;
    }

    ret = snd_soc_dai_set_clkdiv(cpu_dai, 1, sysclk / bclk_freq);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI clock divider %d\n", ret);
        return ret;
    }

    ret = snd_soc_dai_set_clkdiv(cpu_dai, 2, bclk_freq / params_rate(params));
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI clock divider %d\n", ret);
        return ret;
    }

    /* set the CPU system clock */
    ret = snd_soc_dai_set_sysclk(cpu_dai, 0, sysclk, SND_SOC_CLOCK_IN);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI clock direction %d\n", ret);
        return ret;
    }

    return 0;
}

static int pm14_mfad2_startup(struct snd_pcm_substream *substream)
{
    /* For now call evm_startup() */
    return evm_startup(substream);
}

static void pm14_mfad2_shutdown(struct snd_pcm_substream *substream)
{
    /* For now call evm_shutdown() */
    evm_shutdown(substream);
}

static int pm14_mfad2_audio_init(struct snd_soc_pcm_runtime *rtd)
{
    ///struct snd_soc_dai *codec_dai = rtd->codec_dai;
    struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
    int ret;

    ret = snd_soc_dai_set_clkdiv(cpu_dai, 0, 1);
    if (ret < 0)
        return ret;

    ret = snd_soc_dai_set_clkdiv(cpu_dai, 1, 24);
    if (ret < 0)
        return ret;

    ret = snd_soc_dai_set_sysclk(cpu_dai, 0, 0, SND_SOC_CLOCK_IN);
    if (ret < 0)
        return ret;

    ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_CBS_CFS | SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_IF);
    if (ret < 0)
        return ret;

    return 0;
}

static int pm14_mfad2_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
{
    struct snd_soc_pcm_runtime *rtd = substream->private_data;
    struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
    struct snd_soc_dai *codec = asoc_rtd_to_codec(rtd, 0);
    struct snd_soc_card *soc_card = rtd->card;
    struct platform_device *pdev = to_platform_device(soc_card->dev);
    int ret = 0;

    unsigned sysclk = ((struct snd_soc_card_drvdata_davinci *)
               snd_soc_card_get_drvdata(soc_card))->sysclk;

    /* set cpu DAI configuration */
    ret = snd_soc_dai_set_fmt(cpu_dai, PM14_MFAD2_UP0_AUDIO_FORMAT);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI format %d\n", ret);
        return ret;
    }

    /* set the CPU system clock */
    ret = snd_soc_dai_set_sysclk(cpu_dai, 1, sysclk, SND_SOC_CLOCK_IN);
    if (ret < 0) {
        dev_err(&pdev->dev, "can't set CPU DAI clock direction %d\n", ret);
        return ret;
    }

    return 0;
}

static struct snd_soc_ops pm14_e3ip_ops = {
    .hw_params = pm14_e3ip_hw_params,
    .startup = pm14_e3ip_startup,
    .shutdown = pm14_e3ip_shutdown,
};
static struct snd_soc_ops pm14_e3lsx_ops = {
    .hw_params = pm14_e3lsx_hw_params,
    .startup = pm14_e3lsx_startup,
    .shutdown = pm14_e3lsx_shutdown,
};

static struct snd_soc_ops pm14_mfad2_ops = {
    .hw_params = pm14_mfad2_hw_params,
    .startup = pm14_mfad2_startup,
    .shutdown = pm14_mfad2_shutdown,
};
static const struct snd_soc_ops evm_ops = {
    .startup = evm_startup,
    .shutdown = evm_shutdown,
    .hw_params = evm_hw_params,
};

static int pm14_e3ip_init(struct snd_soc_pcm_runtime *rtd)
{
    struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
    int ret;

    /* Divide McASP MCLK by 8 to provide 12MHz to codec */
    ret = snd_soc_dai_set_clkdiv(cpu_dai, 0, 8);
    if (ret < 0)
        return ret;

    return 0;
}
static int pm14_mfad2_init(struct snd_soc_pcm_runtime *rtd)
{
    struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
    int ret;

    /* Divide McASP BCLK by 1 */
    ret = snd_soc_dai_set_clkdiv(cpu_dai, 1, 1);
    if (ret < 0) {
        printk(KERN_WARNING"pm14_mfad2_init: failed to set bit clock divider!\n");
        return ret;
    }

    return 0;
}

/* davinci-evm machine dapm widgets */
static const struct snd_soc_dapm_widget aic3x_dapm_widgets[] = {
    SND_SOC_DAPM_HP("Headphone Jack", NULL),
    SND_SOC_DAPM_LINE("Line Out", NULL),
    SND_SOC_DAPM_MIC("Mic Jack", NULL),
    SND_SOC_DAPM_LINE("Line In", NULL),
};

/* davinci-evm machine audio_mapnections to the codec pins */
static const struct snd_soc_dapm_route audio_map[] = {
    /* Headphone connected to HPLOUT, HPROUT */
    {"Headphone Jack", NULL, "HPLOUT"},
    {"Headphone Jack", NULL, "HPROUT"},

    /* Line Out connected to LLOUT, RLOUT */
    {"Line Out", NULL, "LLOUT"},
    {"Line Out", NULL, "RLOUT"},

    /* Mic connected to (MIC3L | MIC3R) */
    {"MIC3L", NULL, "Mic Bias"},
    {"MIC3R", NULL, "Mic Bias"},
    {"Mic Bias", NULL, "Mic Jack"},

    /* Line In connected to (LINE1L | LINE2L), (LINE1R | LINE2R) */
    {"LINE1L", NULL, "Line In"},
    {"LINE2L", NULL, "Line In"},
    {"LINE1R", NULL, "Line In"},
    {"LINE2R", NULL, "Line In"},
};

/* Logic for a aic3x as connected on a davinci-evm */
static int evm_aic3x_init(struct snd_soc_pcm_runtime *rtd)
{
    struct snd_soc_card *card = rtd->card;
    struct device_node *np = card->dev->of_node;
    int ret;

    /* Add davinci-evm specific widgets */
    snd_soc_dapm_new_controls(&card->dapm, aic3x_dapm_widgets,
                  ARRAY_SIZE(aic3x_dapm_widgets));

    if (np) {
        ret = snd_soc_of_parse_audio_routing(card, "ti,audio-routing");
        if (ret)
            return ret;
    } else {
        /* Set up davinci-evm specific audio path audio_map */
        snd_soc_dapm_add_routes(&card->dapm, audio_map,
                    ARRAY_SIZE(audio_map));
    }

    /* not connected */
    snd_soc_dapm_nc_pin(&card->dapm, "MONO_LOUT");
    snd_soc_dapm_nc_pin(&card->dapm, "HPLCOM");
    snd_soc_dapm_nc_pin(&card->dapm, "HPRCOM");

    return 0;
}

/* davinci-evm digital audio interface glue - connects codec <--> CPU */
SND_SOC_DAILINK_DEFS(dm6446,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-mcbsp")),
    DAILINK_COMP_ARRAY(COMP_CODEC("tlv320aic3x-codec.1-001b",
                      "tlv320aic3x-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-mcbsp")));

static struct snd_soc_dai_link dm6446_evm_dai = {
    .name = "TLV320AIC3X",
    .stream_name = "AIC3X",
    .init = evm_aic3x_init,
    .ops = &evm_ops,
    .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
           SND_SOC_DAIFMT_IB_NF,
    SND_SOC_DAILINK_REG(dm6446),
};

SND_SOC_DAILINK_DEFS(dm355,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-mcbsp.1")),
    DAILINK_COMP_ARRAY(COMP_CODEC("tlv320aic3x-codec.1-001b",
                      "tlv320aic3x-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-mcbsp.1")));

static struct snd_soc_dai_link dm355_evm_dai = {
    .name = "TLV320AIC3X",
    .stream_name = "AIC3X",
    .init = evm_aic3x_init,
    .ops = &evm_ops,
    .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
           SND_SOC_DAIFMT_IB_NF,
    SND_SOC_DAILINK_REG(dm355),
};

#ifdef CONFIG_SND_SOC_DM365_AIC3X_CODEC
SND_SOC_DAILINK_DEFS(dm365,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-mcbsp")),
    DAILINK_COMP_ARRAY(COMP_CODEC("tlv320aic3x-codec.1-0018",
                      "tlv320aic3x-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-mcbsp")));
#elif defined(CONFIG_SND_SOC_DM365_VOICE_CODEC)
SND_SOC_DAILINK_DEFS(dm365,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-vcif")),
    DAILINK_COMP_ARRAY(COMP_CODEC("cq93vc-codec", "cq93vc-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-vcif")));
#endif

static struct snd_soc_dai_link dm365_evm_dai = {
#ifdef CONFIG_SND_SOC_DM365_AIC3X_CODEC
    .name = "TLV320AIC3X",
    .stream_name = "AIC3X",
    .init = evm_aic3x_init,
    .ops = &evm_ops,
    .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
           SND_SOC_DAIFMT_IB_NF,
    SND_SOC_DAILINK_REG(dm365),
#elif defined(CONFIG_SND_SOC_DM365_VOICE_CODEC)
    .name = "Voice Codec - CQ93VC",
    .stream_name = "CQ93",
    SND_SOC_DAILINK_REG(dm365),
#endif
};

SND_SOC_DAILINK_DEFS(dm6467_aic3x,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-mcasp.0")),
    DAILINK_COMP_ARRAY(COMP_CODEC("tlv320aic3x-codec.0-001a",
                      "tlv320aic3x-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-mcasp.0")));

SND_SOC_DAILINK_DEFS(dm6467_spdif,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-mcasp.1")),
    DAILINK_COMP_ARRAY(COMP_CODEC("spdif_dit", "dit-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-mcasp.1")));

static struct snd_soc_dai_link dm6467_evm_dai[] = {
    {
        .name = "TLV320AIC3X",
        .stream_name = "AIC3X",
        .init = evm_aic3x_init,
        .ops = &evm_ops,
        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
               SND_SOC_DAIFMT_IB_NF,
        SND_SOC_DAILINK_REG(dm6467_aic3x),
    },
    {
        .name = "McASP",
        .stream_name = "spdif",
        .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
               SND_SOC_DAIFMT_IB_NF,
        SND_SOC_DAILINK_REG(dm6467_spdif),
    },
};

SND_SOC_DAILINK_DEFS(da830,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-mcasp.1")),
    DAILINK_COMP_ARRAY(COMP_CODEC("tlv320aic3x-codec.1-0018",
                      "tlv320aic3x-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-mcasp.1")));

static struct snd_soc_dai_link da830_evm_dai = {
    .name = "TLV320AIC3X",
    .stream_name = "AIC3X",
    .init = evm_aic3x_init,
    .ops = &evm_ops,
    .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
           SND_SOC_DAIFMT_IB_NF,
    SND_SOC_DAILINK_REG(da830),
};

SND_SOC_DAILINK_DEFS(da850,
    DAILINK_COMP_ARRAY(COMP_CPU("davinci-mcasp.0")),
    DAILINK_COMP_ARRAY(COMP_CODEC("tlv320aic3x-codec.1-0018",
                      "tlv320aic3x-hifi")),
    DAILINK_COMP_ARRAY(COMP_PLATFORM("davinci-mcasp.0")));

static struct snd_soc_dai_link da850_evm_dai = {
    .name = "TLV320AIC3X",
    .stream_name = "AIC3X",
    .init = evm_aic3x_init,
    .ops = &evm_ops,
    .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
           SND_SOC_DAIFMT_IB_NF,
    SND_SOC_DAILINK_REG(da850),
};

/* davinci dm6446 evm audio machine driver */
/*
 * ASP0 in DM6446 EVM is clocked by U55, as configured by
 * board-dm644x-evm.c using GPIOs from U18.  There are six
 * options; here we "know" we use a 48 KHz sample rate.
 */
static struct snd_soc_card_drvdata_davinci dm6446_snd_soc_card_drvdata = {
    .sysclk = 12288000,
};

static struct snd_soc_card dm6446_snd_soc_card_evm = {
    .name = "DaVinci DM6446 EVM",
    .owner = THIS_MODULE,
    .dai_link = &dm6446_evm_dai,
    .num_links = 1,
    .drvdata = &dm6446_snd_soc_card_drvdata,
};

/* davinci dm355 evm audio machine driver */
/* ASP1 on DM355 EVM is clocked by an external oscillator */
static struct snd_soc_card_drvdata_davinci dm355_snd_soc_card_drvdata = {
    .sysclk = 27000000,
};

static struct snd_soc_card dm355_snd_soc_card_evm = {
    .name = "DaVinci DM355 EVM",
    .owner = THIS_MODULE,
    .dai_link = &dm355_evm_dai,
    .num_links = 1,
    .drvdata = &dm355_snd_soc_card_drvdata,
};

/* davinci dm365 evm audio machine driver */
static struct snd_soc_card_drvdata_davinci dm365_snd_soc_card_drvdata = {
    .sysclk = 27000000,
};

static struct snd_soc_card dm365_snd_soc_card_evm = {
    .name = "DaVinci DM365 EVM",
    .owner = THIS_MODULE,
    .dai_link = &dm365_evm_dai,
    .num_links = 1,
    .drvdata = &dm365_snd_soc_card_drvdata,
};

/* davinci dm6467 evm audio machine driver */
static struct snd_soc_card_drvdata_davinci dm6467_snd_soc_card_drvdata = {
    .sysclk = 27000000,
};

static struct snd_soc_card dm6467_snd_soc_card_evm = {
    .name = "DaVinci DM6467 EVM",
    .owner = THIS_MODULE,
    .dai_link = dm6467_evm_dai,
    .num_links = ARRAY_SIZE(dm6467_evm_dai),
    .drvdata = &dm6467_snd_soc_card_drvdata,
};

static struct snd_soc_card_drvdata_davinci da830_snd_soc_card_drvdata = {
    .sysclk = 24576000,
};

static struct snd_soc_card da830_snd_soc_card = {
    .name = "DA830/OMAP-L137 EVM",
    .owner = THIS_MODULE,
    .dai_link = &da830_evm_dai,
    .num_links = 1,
    .drvdata = &da830_snd_soc_card_drvdata,
};

static struct snd_soc_card_drvdata_davinci da850_snd_soc_card_drvdata = {
    .sysclk = 24576000,
};

static struct snd_soc_card da850_snd_soc_card = {
    .name = "DA850/OMAP-L138 EVM",
    .owner = THIS_MODULE,
    .dai_link = &da850_evm_dai,
    .num_links = 1,
    .drvdata = &da850_snd_soc_card_drvdata,
};

#if defined(CONFIG_OF)

/*
 * The struct is used as place holder. It will be completely
 * filled with data from dt node.
 */
SND_SOC_DAILINK_DEFS(evm,
    DAILINK_COMP_ARRAY(COMP_EMPTY()),
    DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "tlv320aic3x-hifi")),
    DAILINK_COMP_ARRAY(COMP_EMPTY()));

static struct snd_soc_dai_link evm_dai_tlv320aic3x = {
    .name       = "TLV320AIC3X",
    .stream_name    = "AIC3X",
    .ops            = &evm_ops,
    .init           = evm_aic3x_init,
    .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_CBM_CFM |
           SND_SOC_DAIFMT_IB_NF,
    SND_SOC_DAILINK_REG(evm),
};
SND_SOC_DAILINK_DEFS(pm14_e3ip,
    DAILINK_COMP_ARRAY(COMP_EMPTY()),
    DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "tas5508c-pwm")),
    DAILINK_COMP_ARRAY(COMP_EMPTY()));
static struct snd_soc_dai_link pm14_e3ip_out_dai[] = {
    {
        .name           = "E3IP-TAS5508C-LINK",
        .stream_name    = "E3IP-TAS5508C-Stream",
        .ops            = &pm14_e3ip_ops,
        .init           = pm14_e3ip_init,
        .dai_fmt        = PM14_AUDIO_FORMAT,
        SND_SOC_DAILINK_REG(pm14_e3ip),
    },
};

SND_SOC_DAILINK_DEFS(pcm,
    DAILINK_COMP_ARRAY(COMP_EMPTY()),
    DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "pcm1808")),
    DAILINK_COMP_ARRAY(COMP_EMPTY()));
static struct snd_soc_dai_link pm14_e3ip_in_dai[] = {
    {
        .name           = "E3IP-PCM1808-LINK",
        .stream_name    = "E3IP-TAS5508C-Stream",
        .ops            = &pm14_e3ip_ops,
        .init           = pm14_e3ip_init,
        .dai_fmt        = PM14_AUDIO_FORMAT,
        SND_SOC_DAILINK_REG(pcm),
    },
};

static const struct of_device_id davinci_evm_dt_ids[] = {
    {
        .compatible = "ti,da830-evm-audio",
        .data = (void *) &evm_dai_tlv320aic3x,
    },
        {
        .compatible = "wnz,pm14-e3ip-out",
        .data = &pm14_e3ip_out_dai,
    },
    {
        .compatible = "wnz,pm14-e3ip-in",
        .data = &pm14_e3ip_in_dai,
    },

    { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, davinci_evm_dt_ids);

/* davinci evm audio machine driver */
static struct snd_soc_card evm_soc_card = {
    .owner = THIS_MODULE,
    .num_links = 1,
};

static int davinci_evm_probe(struct platform_device *pdev)
{
    struct device_node *np = pdev->dev.of_node;
    const struct of_device_id *match;
    struct snd_soc_dai_link *dai;
    struct snd_soc_card_drvdata_davinci *drvdata = NULL;
    struct clk *mclk;
    int ret = 0;

    match = of_match_device(of_match_ptr(davinci_evm_dt_ids), &pdev->dev);
    if (!match) {
        dev_err(&pdev->dev, "Error: No device match found\n");
        return -ENODEV;
    }

    dai = (struct snd_soc_dai_link *) match->data;

    evm_soc_card.dai_link = dai;

    dai->codecs->of_node = of_parse_phandle(np, "ti,audio-codec", 0);
    if (!dai->codecs->of_node)
        return -EINVAL;

    dai->cpus->of_node = of_parse_phandle(np, "ti,mcasp-controller", 0);
    if (!dai->cpus->of_node)
        return -EINVAL;

    dai->platforms->of_node = dai->cpus->of_node;

    evm_soc_card.dev = &pdev->dev;
    ret = snd_soc_of_parse_card_name(&evm_soc_card, "ti,model");
    if (ret)
        return ret;

    mclk = devm_clk_get(&pdev->dev, "mclk");
    if (PTR_ERR(mclk) == -EPROBE_DEFER) {
        return -EPROBE_DEFER;
    } else if (IS_ERR(mclk)) {
        dev_dbg(&pdev->dev, "mclk not found.\n");
        mclk = NULL;
    }

    drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
    if (!drvdata)
        return -ENOMEM;

    drvdata->mclk = mclk;

    ret = of_property_read_u32(np, "ti,codec-clock-rate", &drvdata->sysclk);

    if (ret < 0) {
        if (!drvdata->mclk) {
            dev_err(&pdev->dev,
                "No clock or clock rate defined.\n");
            return -EINVAL;
        }
        drvdata->sysclk = clk_get_rate(drvdata->mclk);
    } else if (drvdata->mclk) {
        unsigned int requestd_rate = drvdata->sysclk;
        clk_set_rate(drvdata->mclk, drvdata->sysclk);
        drvdata->sysclk = clk_get_rate(drvdata->mclk);
        if (drvdata->sysclk != requestd_rate)
            dev_warn(&pdev->dev,
                 "Could not get requested rate %u using %u.\n",
                 requestd_rate, drvdata->sysclk);
    }

    snd_soc_card_set_drvdata(&evm_soc_card, drvdata);
    ret = devm_snd_soc_register_card(&pdev->dev, &evm_soc_card);

    if (ret)
        dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret);

    return ret;
}

static struct platform_driver davinci_evm_driver = {
    .probe      = davinci_evm_probe,
    .driver     = {
        .name   = "davinci_evm",
        .pm = &snd_soc_pm_ops,
        .of_match_table = of_match_ptr(davinci_evm_dt_ids),
    },
};
#endif

static struct platform_device *evm_snd_device;

static int __init evm_init(void)
{
    struct snd_soc_card *evm_snd_dev_data;
    int index;
    int ret;

    /*
     * If dtb is there, the devices will be created dynamically.
     * Only register platfrom driver structure.
     */
#if defined(CONFIG_OF)
    if (of_have_populated_dt())
        return platform_driver_register(&davinci_evm_driver);
#endif

    if (machine_is_davinci_evm()) {
        evm_snd_dev_data = &dm6446_snd_soc_card_evm;
        index = 0;
    } else if (machine_is_davinci_dm355_evm()) {
        evm_snd_dev_data = &dm355_snd_soc_card_evm;
        index = 1;
    } else if (machine_is_davinci_dm365_evm()) {
        evm_snd_dev_data = &dm365_snd_soc_card_evm;
        index = 0;
    } else if (machine_is_davinci_dm6467_evm()) {
        evm_snd_dev_data = &dm6467_snd_soc_card_evm;
        index = 0;
    } else if (machine_is_davinci_da830_evm()) {
        evm_snd_dev_data = &da830_snd_soc_card;
        index = 1;
    } else if (machine_is_davinci_da850_evm()) {
        evm_snd_dev_data = &da850_snd_soc_card;
        index = 0;
    } else
        return -EINVAL;

    evm_snd_device = platform_device_alloc("soc-audio", index);
    if (!evm_snd_device)
        return -ENOMEM;

    platform_set_drvdata(evm_snd_device, evm_snd_dev_data);
    ret = platform_device_add(evm_snd_device);
    if (ret)
        platform_device_put(evm_snd_device);

    return ret;
}

static void __exit evm_exit(void)
{
#if defined(CONFIG_OF)
    if (of_have_populated_dt()) {
        platform_driver_unregister(&davinci_evm_driver);
        return;
    }
#endif

    platform_device_unregister(evm_snd_device);
}

module_init(evm_init);
module_exit(evm_exit);

MODULE_AUTHOR("Vladimir Barinov");
MODULE_DESCRIPTION("TI DAVINCI EVM ASoC driver");
MODULE_LICENSE("GPL");

+1 e f over 1 year ago in reply to e f

Prodigy 200 points

Using clock

	mcasp0_fck: mcasp0_fck {
		#clock-cells = <0>;
		compatible = "fixed-factor-clock";
		clocks = <&sys_clkin_ck>;
		clock-mult = <1000>;
		clock-div = <1024>;
	};

from https://git.ti.com/cgit/ti-linux-kernel/ti-linux-kernel/tree/arch/arm/boot/dts/am33xx-clocks.dtsi?id=ea291c9851d8f3a8d79a2b7a530df27548c7652c

Changed

		clock-mult = <1>;
		clock-div = <1>;
to

		clock-mult = <1000>;
		clock-div = <1024>;

to get 24000000÷1000×1024=24576000

With this we have

sound_out: sound-out {
compatible = "ont,on20-o2nm-out";
ti,model = "Opner O2NM Audio out";
ti,audio-codec = <&tas5508c>;
ti,mcasp-controller = <&mcasp0>;
ti,codec-clock-rate = <24576000>;

clock_names = "mclk"
clocks=<&mcasp0_fck>

};

and the error with "mclk not found" disappeared.

Is now MCASP0_AHCLKX providing "mclk" for TAS5508?

Is https://git.ti.com/cgit/ti-linux-kernel/ti-linux-kernel/commit/sound/soc/davinci/davinci-evm.c?id=5b66aa2d0cafd8093e0b8959d32e694c92390b8c
referencing this?

0 Suren Porwar over 1 year ago in reply to e f

TI__Mastermind 31440 points

Hi,

Yes AHCLK is the MCLK as mentioned in the below screenshot.

Hope this helps.

Best Regards,

Suren

0 e f over 1 year ago in reply to Suren Porwar

Prodigy 200 points

How to use external crystal for AHCLKX?

Like this?

clk_mcasp0_fixed: clk_mcasp0_fixed {

#clock-cells = <0>;

compatible = "fixed-clock";

clock-frequency = <24576000>;

};

clk_mcasp0: clk_mcasp0 {

#clock-cells = <0>;

compatible = "gpio-gate-clock";

clocks = <&clk_mcasp0_fixed>;

}

How is GPIO3_21 addressed?

0 Suren Porwar over 1 year ago in reply to e f

TI__Mastermind 31440 points

Hi,

Can you explain your setup a little bit here: I am getting confused, Is codec the sound master or McASP/Soc?

Best Regards,

Suren

0 e f over 1 year ago in reply to Suren Porwar

Prodigy 200 points

We want to use an external clock source for both the SoC and the codec. This requires configuring AHCLKX (GPIO3_21) as an input.

How should this be reflected in the Device Tree?

0 Suren Porwar over 1 year ago in reply to e f

TI__Mastermind 31440 points

Hi,

Please refer the DTS file for reference:

https://git.ti.com/cgit/ti-linux-kernel/ti-linux-kernel/tree/arch/arm/boot/dts/am335x-evmsk.dts?h=ti-linux-6.1.y#n414

Best Regards,

Suren

Processors

Processors forum

AM3352: mclk not found