platform data from board file to DTS for audio codec

As am new to DTS & I have L3 interface for my audio codec UDA1345TS that needs to be ported onto DTS in TI SDK 7 & the reference for the same I have is the board file concept as shown below

/home/srinivasan/workspace/linux_wrking_copy/arch/arm/mach-s3c24xx (Board file)
===============================================================================

static struct s3c24xx_uda134x_platform_data mini2440_audio_pins = {
    .l3_clk = S3C2410_GPB(4),
    .l3_mode = S3C2410_GPB(2),
    .l3_data = S3C2410_GPB(3),
    .model = UDA134X_UDA1341
};

static struct platform_device mini2440_audio = {
    .name        = "s3c24xx_uda134x",
    .id        = 0,
    .dev        = {
        .platform_data    = &mini2440_audio_pins,
    },
};

static struct platform_device uda1340_codec = {
        .name = "uda134x-codec",
        .id = -1,
};

static struct platform_device *mini2440_devices[] __initdata = {
    &s3c_device_ohci,
    &s3c_device_wdt,
    &s3c_device_i2c0,
    &s3c_device_rtc,
    &s3c_device_usbgadget,
    &mini2440_device_eth,
    &mini2440_led1,
    &mini2440_led2,
    &mini2440_led3,
    &mini2440_led4,
    &mini2440_button_device,
    &s3c_device_nand,
    &s3c_device_sdi,
    &s3c_device_iis,
    &uda1340_codec,
    &mini2440_audio,
};

sound/soc/samsung/s3c24xx_uda134x.c (platform driver file)
===================================================================

static struct s3c24xx_uda134x_platform_data *s3c24xx_uda134x_l3_pins;

static void setdat(int v)
{
    gpio_set_value(s3c24xx_uda134x_l3_pins->l3_data, v > 0);
}

static void setclk(int v)
{
    gpio_set_value(s3c24xx_uda134x_l3_pins->l3_clk, v > 0);
}

static void setmode(int v)
{
    gpio_set_value(s3c24xx_uda134x_l3_pins->l3_mode, v > 0);
}

/* FIXME - This must be codec platform data but in which board file ?? */
static struct uda134x_platform_data s3c24xx_uda134x = {
    .l3 = {
        .setdat = setdat,
        .setclk = setclk,
        .setmode = setmode,
        .data_hold = 1,
        .data_setup = 1,
        .clock_high = 1,
        .mode_hold = 1,
        .mode = 1,
        .mode_setup = 1,
    },
};

static int s3c24xx_uda134x_setup_pin(int pin, char *fun)
{
    if (gpio_request(pin, "s3c24xx_uda134x") < 0) {
        printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
               "l3 %s pin already in use", fun);
        return -EBUSY;
    }
    gpio_direction_output(pin, 0);
    return 0;
}

static int s3c24xx_uda134x_probe(struct platform_device *pdev)
{
    int ret;

    printk(KERN_INFO "S3C24XX_UDA134X SoC Audio driver\n");

    s3c24xx_uda134x_l3_pins = pdev->dev.platform_data;
    if (s3c24xx_uda134x_l3_pins == NULL) {
        printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
               "unable to find platform data\n");
        return -ENODEV;
    }
    s3c24xx_uda134x.power = s3c24xx_uda134x_l3_pins->power;
    s3c24xx_uda134x.model = s3c24xx_uda134x_l3_pins->model;

    if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_data,
                      "data") < 0)
        return -EBUSY;
    if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_clk,
                      "clk") < 0) {
        gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
        return -EBUSY;
    }
    if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_mode,
                      "mode") < 0) {
        gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
        gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
        return -EBUSY;
    }

    s3c24xx_uda134x_snd_device = platform_device_alloc("soc-audio", -1);
    if (!s3c24xx_uda134x_snd_device) {
        printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
               "Unable to register\n");
        return -ENOMEM;
    }

    platform_set_drvdata(s3c24xx_uda134x_snd_device,
                 &snd_soc_s3c24xx_uda134x);
    platform_device_add_data(s3c24xx_uda134x_snd_device, &s3c24xx_uda134x, sizeof(s3c24xx_uda134x));
    ret = platform_device_add(s3c24xx_uda134x_snd_device);
    if (ret) {
        printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: Unable to add\n");
        platform_device_put(s3c24xx_uda134x_snd_device);
    }

    return ret;
}

static int s3c24xx_uda134x_remove(struct platform_device *pdev)
{
    platform_device_unregister(s3c24xx_uda134x_snd_device);
    gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
    gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
    gpio_free(s3c24xx_uda134x_l3_pins->l3_mode);
    return 0;
}

static struct platform_driver s3c24xx_uda134x_driver = {
    .probe  = s3c24xx_uda134x_probe,
    .remove = s3c24xx_uda134x_remove,
    .driver = {
        .name = "s3c24xx_uda134x",
        .owner = THIS_MODULE,
    },
};

module_platform_driver(s3c24xx_uda134x_driver);

sound/soc/codecs/Uda134x.c ( client driver file)
===================================================================

static int uda134x_soc_probe(struct snd_soc_codec *codec)
{
    struct uda134x_priv *uda134x;
    struct uda134x_platform_data *pd = codec->card->dev->platform_data;
    const struct snd_soc_dapm_widget *widgets;
    unsigned num_widgets;

    int ret;

    printk(KERN_INFO "SRINIII CLIENT DRIVER UDA134X SoC Audio Codec probe....\n");

    if (!pd) {
        printk(KERN_ERR "UDA134X SoC codec: "
               "missing L3 bitbang function\n");
        return -ENODEV;
    }

    switch (pd->model) {
    case UDA134X_UDA1340:
    case UDA134X_UDA1341:
    case UDA134X_UDA1344:
    case UDA134X_UDA1345:
        break;
    default:
        printk(KERN_ERR "UDA134X SoC codec: "
               "unsupported model %d\n",
            pd->model);
        return -EINVAL;
    }

    uda134x = kzalloc(sizeof(struct uda134x_priv), GFP_KERNEL);
    if (uda134x == NULL)
        return -ENOMEM;
    snd_soc_codec_set_drvdata(codec, uda134x);

    codec->control_data = pd;

    if (pd->power)
        pd->power(1);

    uda134x_reset(codec);

    if (pd->is_powered_on_standby)
        uda134x_set_bias_level(codec, SND_SOC_BIAS_ON);
    else
        uda134x_set_bias_level(codec, SND_SOC_BIAS_STANDBY);

    if (pd->model == UDA134X_UDA1341) {
        widgets = uda1341_dapm_widgets;
        num_widgets = ARRAY_SIZE(uda1341_dapm_widgets);
    } else {
        widgets = uda1340_dapm_widgets;
        num_widgets = ARRAY_SIZE(uda1340_dapm_widgets);
    }

    ret = snd_soc_dapm_new_controls(&codec->dapm, widgets, num_widgets);
    if (ret) {
        printk(KERN_ERR "%s failed to register dapm controls: %d",
            __func__, ret);
        kfree(uda134x);
        return ret;
    }


    switch (pd->model) {
    case UDA134X_UDA1340:
    case UDA134X_UDA1344:
        ret = snd_soc_add_codec_controls(codec, uda1340_snd_controls,
                    ARRAY_SIZE(uda1340_snd_controls));
    break;
    case UDA134X_UDA1341:
        ret = snd_soc_add_codec_controls(codec, uda1341_snd_controls,
                    ARRAY_SIZE(uda1341_snd_controls));
    break;
    case UDA134X_UDA1345:
        printk("SWITCHING TO UDA134X_UDA1345 SNDDDDDDDDDDD CONTROLSSSSSSSSSS\n");
        ret = snd_soc_add_codec_controls(codec, uda1345_snd_controls,
                    ARRAY_SIZE(uda1345_snd_controls));
    break;
    default:
        printk(KERN_ERR "%s unknown codec type: %d",
            __func__, pd->model);
        kfree(uda134x);
        return -EINVAL;
    }

    if (ret < 0) {
        printk(KERN_ERR "UDA134X: failed to register controls\n");
        kfree(uda134x);
        return ret;
    }

    return 0;
}

I have done few code changes in DTS as shown below for which the platform data needs to be parsed in davinci-evm.c similar to s3c24xx_uda134x.c, please correct me if my approach is wrong


DTS file changes
================

arch/arm/boot/dts/am335x-bone-common.dtsi

        uda1345_l3_default: uda1345_l3_default {
            pinctrl-single,pins = <
                0xc8 (PIN_OUTPUT_PULLUP | MUX_MODE7)    /* gpio2_16.LCD_DATA10.U3 MP1 OVERFL output */
                0xcc (PIN_OUTPUT_PULLUP | MUX_MODE7)    /* gpio2_17.LCD_DATA11.U4 MP2 L3MODE  */
                0xd8 (PIN_OUTPUT_PULLUP | MUX_MODE7)    /* gpio0_10.LCD_DATA14.V4 MP3 L3CLOCK */
                0xd0 (PIN_OUTPUT_PULLUP | MUX_MODE7)    /* gpio0_8.LCD_DATA12.V2 MP4 L3DATA   */
                0xd4 (PIN_OUTPUT_PULLUP | MUX_MODE7)    /* gpio0_9.LCD_DATA13.V3 MP5 ADC 1V or 2V (RMS) input control*/
            >;
        };
 
        uda1345_l3_sleep: uda1345_l3_sleep {
            pinctrl-single,pins = <
 
                0xc8 (PIN_OUTPUT_PULLDOWN | MUX_MODE7)    /* gpio2_16.LCD_DATA10.U3 MP1 OVERFL output */
                0xcc (PIN_OUTPUT_PULLDOWN | MUX_MODE7)    /* gpio2_17.LCD_DATA11.U4 MP2 L3MODE  */
                0xd8 (PIN_OUTPUT_PULLDOWN | MUX_MODE7)    /* gpio0_10.LCD_DATA14.V4 MP3 L3CLOCK */
                0xd0 (PIN_OUTPUT_PULLDOWN | MUX_MODE7)    /* gpio0_8.LCD_DATA12.V2 MP4 L3DATA   */
                0xd4 (PIN_OUTPUT_PULLDOWN | MUX_MODE7)    /* gpio0_9.LCD_DATA13.V3 MP5  ADC 1V or 2V (RMS) input control*/
        
 
            >;
        };



           uda134x: uda134x {
        compatible = "ti,uda134x";
    
            model = "UDA134X_UDA1345";            
 
    };



        sound {
                        compatible = "ti,uda134x-audio-codec";
            ti,model = "TI UDA1345TS";
                        //ti,model = "AM335x-EVM";
                        ti,audio-codec = <&uda134x>;
                        ti,mcasp-controller = <&mcasp0>;
                        /*ti,codec-clock-rate = <12000000>;*/
            ti,codec-clock-rate = <12288000>;
                        ti,audio-routing =
                "ADC",       "VINL1",
                "ADC",       "VINR1",
                "VOUTL",               "DAC",
                "VOUTR",               "DAC";
 
            power = <1>; // THIS VALUE NEEDS TO BE RECHECKED AGAIN
            
            model = "UDA134X_UDA1345";
            // gpio0_8.LCD_DATA12.V2 MP4 L3DATA    
            l3_data = <&gpio0 8 0x1>;
 
            // gpio0_10.LCD_DATA14.V4 MP3 L3CLOCK  
            l3_clk = <&gpio0 10 0x1>;
 
            // gpio2_17.LCD_DATA11.U4 MP2 L3MODE   
                           l3_mode = <&gpio2 17 0x1>;
 
            // gpio0_9.LCD_DATA13.V3 MP5 is set LOW, 0 dB gain is selected. when MP5 is set HIGH, 6dB gain is selected
            l3_gain = <&gpio0 9 0x1>;    
            
            // gpio2_16.LCD_DATA10.U3 MP1 OVERFL output
            l3_overfl = <&gpio2 16 0x0>;
 
            pinctrl-names = "default", "sleep";
            pinctrl-0 = <&uda1345_l3_default>;
            pinctrl-1 = <&uda1345_l3_sleep>;
 
 
         };
 



sound/soc/Davinci/Davinci-evm.c
================================

#ifdef CONFIG_OF
static int davinci_uda1345_probe_dt(/*struct am335x_uda134x_platform_data *data,*/
             struct platform_device *pdev)
{
    
    struct device_node *node = pdev->dev.of_node;
    struct am335x_uda134x_platform_data *pdata;
    enum of_gpio_flags flags;
    int gpio;

    int ret=0;

        if (!node)
        {
            printk("DAVINCI_UDA1345_PROBE_DT device lacks DT UDA1345TS data\n");
            //return ERR_PTR(-ENODEV);
            return 0;
        }

        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
        if (!pdata) {
            printk("DAVINCI_UDA1345_PROBE_DT could not allocate memory for platform data for UDA1345TS\n");
            return -ENOMEM;
        }

        if (node) {

                printk("DAVINCI_UDA1345_PROBE_DT NODE L3_DATATAAA\n");

                gpio = of_get_named_gpio_flags(node, "l3_data", 0, &flags);
#if 1
                if (gpio_is_valid(gpio)) {
                    printk("DAVINCI_UDA1345_PROBE_DT GPIO_IS_VALIDD L3_DATATAA PINNNNN\n");
                    ret = devm_gpio_request_one(&pdev->dev, gpio,
                             flags & OF_GPIO_ACTIVE_LOW ?
                            GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH,
                             "uda1345 l3_data");
                    if (ret < 0)
                    {
                        printk("DAVINCI_UDA1345_PROBE_DT devm_gpio_request_one errrrrrrrr L3_DATATAAA\n");
                        return ret;
                    }    
                }
#endif
                pdata->l3_data = gpio;
        }

        



        if (node) {

                printk("DAVINCI_UDA1345_PROBE_DT NODE L3_clkkkkkk\n");

                gpio = of_get_named_gpio_flags(node, "l3_clk", 0, &flags);
#if 1
                if (gpio_is_valid(gpio)) {
                    printk("DAVINCI_UDA1345_PROBE_DT GPIO_IS_VALIDD L3_clkkkkkk PINNNNNNNNN\n");
                    ret = devm_gpio_request_one(&pdev->dev, gpio,
                             flags & OF_GPIO_ACTIVE_LOW ?
                            GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH,
                             "uda1345 l3_clk");
                    if (ret < 0)
                    {
                        printk("DAVINCI_UDA1345_PROBE_DT devm_gpio_request_one errrrrrrrr L3_clkkkkkk\n");
                        return ret;
                    }    
                }
#endif            
                pdata->l3_clk = gpio;        
                
          }

        
        

        if (node) {

                printk("DAVINCI_UDA1345_PROBE_DT NODE L3_modeeeee\n");

                gpio = of_get_named_gpio_flags(node, "l3_mode", 0, &flags);
#if 1                
                if (gpio_is_valid(gpio)) {
                    printk("DAVINCI_UDA1345_PROBE_DT GPIO_IS_VALIDD L3_modeeeee PINNNNNNNNN\n");
                    ret = devm_gpio_request_one(&pdev->dev, gpio,
                             flags & OF_GPIO_ACTIVE_LOW ?
                            GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH,
                             "uda1345 l3_mode");
                    if (ret < 0)
                    {
                        printk("DAVINCI_UDA1345_PROBE_DT devm_gpio_request_one errrrrrrrr L3_modeeeee\n");
                        return ret;
                    }    
                }
#endif
                pdata->l3_mode = gpio;    
        
        }

#if 0

        ret = of_property_read_u32(node, "model",
                       &pdata->model);
        if (ret) {
            printk("Not found L3 PLATFORM DATA MODEL NOT FOUND!!!!!!!!!!!!!!!\n");
            //pdata->companion_addr = 0;
        }
        else
        {
            printk("FOUNDDDD L3 PLATFORM DATA MODEL NOT FOUND!!!!!!!!!!!!!!!\n");
        }
        


        ret = of_property_read_u32(node, "power",
                       &pdata->power);
        if (ret) {
            printk("Not found L3 PLATFORM DATA POWER NOT FOUND!!!!!!!!!!!!!!!\n");
            //pdata->companion_addr = 0;
        }
        else
        {
            printk("FOUNDDDD L3 PLATFORM DATA POWER NOT FOUND!!!!!!!!!!!!!!!\n");
        }
#endif        
        pdev->dev.platform_data = pdata;

#if 0
                     /* no such property */
        if (of_property_read_u32(node, "l3_clk", &pdata->l3_clk) != 0)
                    return NULL;

     if (of_property_read_u32(node, "l3_mode", &pdata->l3_mode) != 0)
                    return NULL;

      if (of_property_read_u32(node, "l3_data", &pdata->l3_data) != 0)
                    return NULL;
         
                /* pdata->bar is filled in with 5 */
         return pdata;
#endif                
    
#if 0    
    u32 prop;

    if (!node)
        return -EINVAL;


    if (of_property_read_u32(node, "bus_freq", &prop)) {
        pr_err("Missing bus_freq property in the DT.\n");
        return -EINVAL;
    }
    data->bus_freq = prop;

    return 0;
#endif    
    return 0;
}
#endif

static int davinci_evm_probe(struct platform_device *pdev)
{
    struct device_node *np = pdev->dev.of_node;
    const struct of_device_id *match =
        of_match_device(of_match_ptr(davinci_evm_dt_ids), &pdev->dev);
    struct snd_soc_dai_link *dai = (struct snd_soc_dai_link *) match->data;
    struct snd_soc_card_drvdata_davinci *drvdata = NULL;
    struct clk *mclk;
    int ret = 0;
    //struct am335x_uda134x_platform_data *pdata;
    //struct am335x_uda134x_platform_data *pdata = dev_get_platdata(&pdev->dev);
    //struct am335x_uda134x_platform_data *pdata;

        //struct platform_pwm_backlight_data *data = pdev->dev.platform_data;
    //struct platform_pwm_backlight_data defdata;

    //struct pinctrl *pinctrl;

    evm_soc_card.dai_link = dai;

    printk(KERN_INFO "DAVINCI EVM PROBE FOR UDA1345TSSSSSSSSS CODEC SoC Audio driver\n");


#if 1    
        ret = davinci_uda1345_probe_dt(/*&data->pdata,*/ pdev);
        if (ret)
        {
            printk(KERN_ERR "AM335X_UDA134X SoC Audio unable to find platform data\n");
            return ret;
        }
        else
        {
            printk(KERN_ERR "AM335X_UDA134X SoC Audio DAVINCIIIIIIIIII able to find platform data\n");
        }

#endif          

#if 1
    
    am335x_uda134x_l3_pins = pdev->dev.platform_data;
    if (am335x_uda134x_l3_pins == NULL) {
        printk(KERN_ERR "AM335X_UDA134X SoC Audio: "
               "unable to find platform data\n");
        return -ENODEV;
    }
    
    //am335x_uda134x.model = am335x_uda134x_l3_pins->model;
    //am335x_uda134x_l3_pins->power = 1;
    am335x_uda134x_l3_pins->power = 1;
    am335x_uda134x_l3_pins->model = 4;
    am335x_uda134x.power = am335x_uda134x_l3_pins->power;
    am335x_uda134x.model = am335x_uda134x_l3_pins->model;
    am335x_uda134x_l3_pins->l3_data = 8; // // gpio0_8.LCD_DATA12.V2 MP4 L3DATA  0*32 + 8 = 8
    am335x_uda134x_l3_pins->l3_clk = 10; // // gpio0_10.LCD_DATA14.V4 MP3 L3CLOCK 0*32+ 10 = 10
    am335x_uda134x_l3_pins->l3_mode = 81;// // gpio2_17.LCD_DATA11.U4 MP2 L3MODE 2*32+17 = 81

    if (am335x_uda134x_setup_pin(am335x_uda134x_l3_pins->l3_data,
                      "data") < 0)
        return -EBUSY;
    if (am335x_uda134x_setup_pin(am335x_uda134x_l3_pins->l3_clk,
                      "clk") < 0) {
        gpio_free(am335x_uda134x_l3_pins->l3_data);
        return -EBUSY;
    }
    if (am335x_uda134x_setup_pin(am335x_uda134x_l3_pins->l3_mode,
                      "mode") < 0) {
        gpio_free(am335x_uda134x_l3_pins->l3_data);
        gpio_free(am335x_uda134x_l3_pins->l3_clk);
        return -EBUSY;
    }

#endif

    dai->codec_of_node = of_parse_phandle(np, "ti,audio-codec", 0);
    if (!dai->codec_of_node)
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC DAI -> CODEC OF NODE IS FAILUREEE ti,audio-codec \n");
        return -EINVAL;

    }
    else
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC DAI -> CODEC OF NODE IS SUCCESSFULL ti,audio-codec\n");
    }        

    dai->cpu_of_node = of_parse_phandle(np, "ti,mcasp-controller", 0);
    if (!dai->cpu_of_node)
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC DAI -> CPU OF NODE IS FAILURE ti,mcasp-controller\n");
        return -EINVAL;
    }
    else
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC DAI -> CPU OF NODE IS SUCCESSFULL ti,mcasp-controller\n");
    }

    /* Only set the platform_of_node if the platform_name is not set */
    if (!dai->platform_name)
        dai->platform_of_node = dai->cpu_of_node;

    evm_soc_card.dev = &pdev->dev;
    ret = snd_soc_of_parse_card_name(&evm_soc_card, "ti,model");
    if (ret)
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC snd_soc_of_parse_card_name  ti,model is failuree\n");
        return ret;

    }
    else
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC snd_soc_of_parse_card_name  ti,model is SUCCESSSFULL\n");

    }

    mclk = of_clk_get_by_name(np, "ti,codec-clock");
    if (PTR_ERR(mclk) == -EPROBE_DEFER)
        return -EPROBE_DEFER;
    else if (IS_ERR(mclk)) {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC MCLKKK ti,codec-clock is SUCCESSSFULL\n");
        dev_dbg(&pdev->dev, "Codec clock not found.\n");
        mclk = NULL;
    }

    drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
    if (!drvdata)
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC DRVDATA FAILUREE\n");
        return -ENOMEM;
    }    
    else
    {
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC DRVDATA SUCCESSFULL\n");
    }

    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");
            printk("DAVINCI EVM PROBE FOR UDA1345 CODEC,codec-clock-rate NNNNNOT FOUNDDDD\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);
        printk("DAVINCI EVM PROBE FOR UDA1345 CODEC,codec-clock-rate FOUNDDD\n");
    }



        //platform_set_drvdata(pdev, &evm_soc_card);
    snd_soc_card_set_drvdata(&evm_soc_card, &am335x_uda134x);

    //snd_soc_card_set_drvdata(&evm_soc_card, drvdata);
    ret = snd_soc_register_card(&evm_soc_card);

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

    return ret;
}



sound/soc/codecs/uda134x.c
===================================

#if defined(CONFIG_OF)
static const struct of_device_id uda134x_dt_ids[] = {
    { .compatible = "ti,uda134x" },
    { }
};
MODULE_DEVICE_TABLE(of, uda134x_dt_ids);
#endif


static struct platform_driver uda134x_codec_driver = {
    .driver = {
        .name = "uda134x-codec",
        .owner = THIS_MODULE,
        .of_match_table = of_match_ptr(uda134x_dt_ids),
    },
    .probe = uda134x_codec_probe,
    .remove = uda134x_codec_remove,
};


logs:
=====


[    1.290144] DAVINCI_UDA1345_PROBE_DT NODE L3_DATATAAA
[    1.295445] DAVINCI_UDA1345_PROBE_DT NODE L3_clkkkkkk
[    1.300755] DAVINCI_UDA1345_PROBE_DT NODE L3_modeeeee
[    1.306050] AM335X_UDA134X SoC Audio DAVINCIIIIIIIIII able to find platform data
[    1.313814] AM335X_UDA134X SoC Audio: l3 data pin is used for the first time
[    1.321212] AM335X_UDA134X SoC Audio: l3 clk pin is used for the first time
[    1.328540] AM335X_UDA134X SoC Audio: l3 mode pin is used for the first time
[    1.335989] DAVINCI EVM PROBE FOR UDA1345 CODEC DAI -> CODEC OF NODE IS SUCCESSFULL ti,audio-codec
[    1.345394] DAVINCI EVM PROBE FOR UDA1345 CODEC DAI -> CPU OF NODE IS SUCCESSFULL ti,mcasp-controller
[    1.355064] DAVINCI EVM PROBE FOR UDA1345 CODEC snd_soc_of_parse_card_name  ti,model is SUCCESSSFULL
[    1.364641] DAVINCI EVM PROBE FOR UDA1345 CODEC MCLKKK ti,codec-clock is SUCCESSSFULL
[    1.372896] DAVINCI EVM PROBE FOR UDA1345 CODEC DRVDATA SUCCESSFULL
[    1.379553] mmc0: new high speed SDHC card at address aaaa
[    1.385452] SRINIII CLIENT DRIVER UDA134X SoC Audio Codec probe....
[    1.392039] UDA134X SoC codec: unsupported model 0
[    1.397063] uda134x-codec uda134x.3: ASoC: failed to probe CODEC -22
[    1.404244] mmcblk0: mmc0:aaaa SS04G 3.69 GiB
[    1.409615] davinci_evm sound.4: ASoC: failed to instantiate card -22
[    1.416525]  mmcblk0: p1 p2
[    1.419738] davinci_evm sound.4: snd_soc_register_card failed (-22)
[    1.426323] davinci_evm: probe of sound.4 failed with error -22




Could you please help me in porting l3 driver from the above board file to DTS in ti sdk 7, & could you please correct me my mistakes w.r.t this DTS porting, because of which I am stuck with this from past two weeks badly & unable to register sound card & get the PCM nodes created for the same & I tried googling & I was able to succeed to some extent till as shown above


Kindly do the needful in resolving this issues as early as possible so that it will be very grateful & would be appreciated a lot, as I didn't get any replies for my earlier post also.


Awaiting for your replies,
Many Many Thanks in advance