static int sunxi_daudio0_resume(struct snd_soc_dai *cpu_dai)
{
u32 reg_val;
pr_debug("[DAUDIO]Entered %s\n", __func__);
#if defined(CONFIG_ARCH_SUN8IW6) || defined(CONFIG_ARCH_SUN8IW8)
/*enable the module clock*/
if (clk_prepare_enable(daudio_pllx8)) {
pr_err("open daudio_pllx8 failed! line = %d\n", __LINE__);
}
/*enable the module clock*/
if (clk_prepare_enable(daudio_pll2clk)) {
pr_err("open daudio_pll2clk failed! line = %d\n", __LINE__);
}
#endif
/*enable the module clock*/
if (clk_prepare_enable(daudio_moduleclk)) {
pr_err("open daudio_moduleclk failed! line = %d\n", __LINE__);
}
/*for evb pin config*/
daudio_pinctrl = devm_pinctrl_get_select_default(cpu_dai->dev);
if (IS_ERR_OR_NULL(daudio_pinctrl)) {
dev_warn(cpu_dai->dev,
"pins are not configured from the driver\n");
}
daudioregrestore();
/*Global Enable Digital Audio Interface*/
reg_val = sunxi_smc_readl(sunxi_daudio.regs + SUNXI_DAUDIOCTL);
reg_val |= SUNXI_DAUDIOCTL_GEN;
sunxi_smc_writel(reg_val, sunxi_daudio.regs + SUNXI_DAUDIOCTL);
return 0;
}
int bf609_nor_flash_init(struct platform_device *pdev)
{
#define CONFIG_SMC_GCTL_VAL 0x00000010
if (!devm_pinctrl_get_select_default(&pdev->dev))
return -EBUSY;
bfin_write32(SMC_GCTL, CONFIG_SMC_GCTL_VAL);
bfin_write32(SMC_B0CTL, 0x01002011);
bfin_write32(SMC_B0TIM, 0x08170977);
bfin_write32(SMC_B0ETIM, 0x00092231);
return 0;
}
static int panel_probe(struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
struct panel_module *panel_mod;
struct tilcdc_module *mod;
struct pinctrl *pinctrl;
int ret = -EINVAL;
/* bail out early if no DT data: */
if (!node) {
dev_err(&pdev->dev, "device-tree data is missing\n");
return -ENXIO;
}
panel_mod = kzalloc(sizeof(*panel_mod), GFP_KERNEL);
if (!panel_mod)
return -ENOMEM;
mod = &panel_mod->base;
tilcdc_module_init(mod, "panel", &panel_module_ops);
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "pins are not configured\n");
panel_mod->timings = of_get_display_timings(node);
if (!panel_mod->timings) {
dev_err(&pdev->dev, "could not get panel timings\n");
goto fail;
}
panel_mod->info = of_get_panel_info(node);
if (!panel_mod->info) {
dev_err(&pdev->dev, "could not get panel info\n");
goto fail;
}
mod->preferred_bpp = panel_mod->info->bpp;
panel_mod->backlight = of_find_backlight_by_node(node);
if (panel_mod->backlight)
dev_info(&pdev->dev, "found backlight\n");
return 0;
fail:
panel_destroy(mod);
return ret;
}
static int keypad_int_platfrom(void)
{
dprintk(DEBUG_INIT, "keypad io init\n");
keypad_pinctrl = devm_pinctrl_get_select_default(&(keypd_dev->dev));
if (IS_ERR_OR_NULL(keypad_pinctrl)) {
pr_warn("request pinctrl handle for device [%s] failed\n",
dev_name(&(keypd_dev->dev)));
return -EINVAL;
}
return 0;
}
/**
* gyr_init_platform_resource - initialize platform related resource
* return value: 0 : success
* -EIO : i/o err.
*
*/
static int ir_init_platform_resource(enum input_sensor_type *ir_type)
{
struct ir_config_info *data = container_of(ir_type,
struct ir_config_info, input_type);
data->pinctrl = devm_pinctrl_get_select_default(data->dev);
if (IS_ERR_OR_NULL(data->pinctrl)) {
pr_warn("request pinctrl handle for device [%s] failed\n",
dev_name(data->dev));
return -EINVAL;
}
return 0;
}
static int scr_request_gpio(void)
{
if (NULL != scr_device)
scr_device->init_name = &scr_dev_name[0];
scr_pinctrl = devm_pinctrl_get_select_default(scr_device);
if (IS_ERR_OR_NULL(scr_pinctrl)) {
printk(KERN_ERR "%s: request pinctrl handle for device failed\n",
__func__);
return -EINVAL;
}
return 0;
}
static int sunxi_pinctrl_test_probe(struct platform_device *pdev)
{
struct pinctrl *pinctrl;
pr_warn("device [%s] probe enter\n", dev_name(&pdev->dev));
/* set device name */
dev_set_name(&(pdev->dev), "i2s1");
/* request device pinctrl, set as default state */
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn("request pinctrl handle for device [%s] failed\n",
dev_name(&pdev->dev));
return -EINVAL;
}
//sunxi_devices_pin_request(pdev);
//sunxi_devices_pin_check(pdev);
pr_warn("sunxi-pinctrl test ok\n");
return 0;
}
/* Detect MAC & PHY and perform ethernet interface initialization */
static int __init at91ether_probe(struct platform_device *pdev)
{
struct macb_platform_data *board_data = pdev->dev.platform_data;
struct resource *regs;
struct net_device *dev;
struct phy_device *phydev;
struct pinctrl *pinctrl;
struct macb *lp;
int res;
u32 reg;
regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!regs)
return -ENOENT;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl)) {
res = PTR_ERR(pinctrl);
if (res == -EPROBE_DEFER)
return res;
dev_warn(&pdev->dev, "No pinctrl provided\n");
}
dev = alloc_etherdev(sizeof(struct macb));
if (!dev)
return -ENOMEM;
lp = netdev_priv(dev);
lp->pdev = pdev;
lp->dev = dev;
spin_lock_init(&lp->lock);
/* physical base address */
dev->base_addr = regs->start;
lp->regs = devm_ioremap(&pdev->dev, regs->start, resource_size(regs));
if (!lp->regs) {
res = -ENOMEM;
goto err_free_dev;
}
/* Clock */
lp->pclk = devm_clk_get(&pdev->dev, "ether_clk");
if (IS_ERR(lp->pclk)) {
res = PTR_ERR(lp->pclk);
goto err_free_dev;
}
clk_enable(lp->pclk);
/* Install the interrupt handler */
dev->irq = platform_get_irq(pdev, 0);
res = devm_request_irq(&pdev->dev, dev->irq, at91ether_interrupt, 0, dev->name, dev);
if (res)
goto err_disable_clock;
ether_setup(dev);
dev->netdev_ops = &at91ether_netdev_ops;
dev->ethtool_ops = &macb_ethtool_ops;
platform_set_drvdata(pdev, dev);
SET_NETDEV_DEV(dev, &pdev->dev);
res = at91ether_get_hwaddr_dt(lp);
if (res < 0)
macb_get_hwaddr(lp);
res = at91ether_get_phy_mode_dt(pdev);
if (res < 0) {
if (board_data && board_data->is_rmii)
lp->phy_interface = PHY_INTERFACE_MODE_RMII;
else
lp->phy_interface = PHY_INTERFACE_MODE_MII;
} else {
lp->phy_interface = res;
}
macb_writel(lp, NCR, 0);
reg = MACB_BF(CLK, MACB_CLK_DIV32) | MACB_BIT(BIG);
if (lp->phy_interface == PHY_INTERFACE_MODE_RMII)
reg |= MACB_BIT(RM9200_RMII);
macb_writel(lp, NCFGR, reg);
/* Register the network interface */
res = register_netdev(dev);
if (res)
goto err_disable_clock;
if (macb_mii_init(lp) != 0)
goto err_out_unregister_netdev;
/* will be enabled in open() */
netif_carrier_off(dev);
phydev = lp->phy_dev;
netdev_info(dev, "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
phydev->drv->name, dev_name(&phydev->dev),
phydev->irq);
/* Display ethernet banner */
netdev_info(dev, "AT91 ethernet at 0x%08lx int=%d (%pM)\n",
dev->base_addr, dev->irq, dev->dev_addr);
return 0;
err_out_unregister_netdev:
unregister_netdev(dev);
err_disable_clock:
clk_disable(lp->pclk);
err_free_dev:
free_netdev(dev);
return res;
}
static int pwm_test_probe(struct platform_device *pdev)
{
struct pwm_test *pwm_test;
struct pinctrl *pinctrl;
struct device_node *node = (&pdev->dev)->of_node;
int rc;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "unable to select pin group. PWM not muxed right\n");
pwm_test = devm_kzalloc(&pdev->dev, sizeof(*pwm_test), GFP_KERNEL);
if (!pwm_test) {
dev_err(&pdev->dev, "memory error\n");
return -ENOMEM;
}
if (pwm_test_class_init(&pdev->dev)) {
dev_err(&pdev->dev, "sysfs creation failed\n");
return -EINVAL;
}
pwm_test->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pwm_test->pwm)) {
dev_err(&pdev->dev, "unable to request PWM\n");
return -EINVAL;
}
pwm_test->requested = 1;
pr_debug("pwm_test got PWM\n");
/* Get the properties of the pwm. This is set in the device driver (tiehrpwm) */
pwm_test->period = pwm_get_period(pwm_test->pwm);
/* Determine running or not from the device tree */
rc = of_property_read_u32(node, "enabled", (u32*) &(pwm_test->run));
if (rc < 0)
return rc;
if(pwm_test->run){
rc = pwm_enable(pwm_test->pwm);
if (rc < 0)
return rc;
}
/* Determine the duty from the device tree */
rc = of_property_read_u32(node, "duty", (u32*) &(pwm_test->duty_s));
if (rc < 0)
return rc;
rc = pwm_config(pwm_test->pwm, pwm_test->duty_s, pwm_test->period);
if (rc) {
pr_err("Unable to set pwm duty %d\n", rc);
return rc;
}
platform_set_drvdata(pdev, pwm_test);
return 0;
}
static int exynos_usbswitch_parse_dt(struct exynos_usb_switch *usb_switch,
struct device *dev)
{
struct device_node *node;
struct platform_device *pdev;
struct pinctrl *pinctrl;
int ret;
/* Host detection */
usb_switch->gpio_host_detect = of_get_named_gpio(dev->of_node,
"samsung,id-gpio", 0);
if (!gpio_is_valid(usb_switch->gpio_host_detect)) {
dev_info(dev, "host detect gpio is not available\n");
} else {
ret = devm_gpio_request(dev, usb_switch->gpio_host_detect,
"usbswitch_id_gpio");
if (ret)
dev_err(dev, "failed to request host detect gpio");
else
usb_switch->host_detect_irq =
gpio_to_irq(usb_switch->gpio_host_detect);
}
/* Device detection */
usb_switch->gpio_device_detect = of_get_named_gpio(dev->of_node,
"samsung,bsess-gpio", 0);
if (!gpio_is_valid(usb_switch->gpio_device_detect)) {
dev_info(dev, "device detect gpio is not available\n");
} else {
ret = devm_gpio_request(dev, usb_switch->gpio_device_detect,
"usbswitch_b_sess_gpio");
if (ret)
dev_err(dev, "failed to request host detect gpio");
else
usb_switch->device_detect_irq =
gpio_to_irq(usb_switch->gpio_device_detect);
}
/* VBus control */
usb_switch->gpio_host_vbus = of_get_named_gpio(dev->of_node,
"samsung,vbus-gpio", 0);
if (gpio_is_valid(usb_switch->gpio_host_vbus)) {
ret = devm_gpio_request(dev, usb_switch->gpio_host_vbus,
"usbswitch_vbus_gpio");
if (ret)
dev_err(dev, "failed to request vbus control gpio");
} else {
/* fallback to regulator */
usb_switch->vbus_reg = devm_regulator_get(dev, "uhost-vbus");
if (IS_ERR(usb_switch->vbus_reg))
dev_info(dev, "vbus control is not available\n");
}
pinctrl = devm_pinctrl_get_select_default(dev);
if (IS_ERR(pinctrl))
dev_info(dev, "failed to configure pins\n");
/* EHCI */
node = of_parse_phandle(dev->of_node, "ehci", 0);
if (!node) {
dev_info(dev, "ehci device is not available\n");
} else {
pdev = of_find_device_by_node(node);
if (!pdev)
dev_err(dev, "failed to find ehci device\n");
else
usb_switch->ehci_dev = &pdev->dev;
of_node_put(node);
}
/* OHCI */
node = of_parse_phandle(dev->of_node, "ohci", 0);
if (!node) {
dev_info(dev, "ohci device is not available\n");
} else {
pdev = of_find_device_by_node(node);
if (!pdev)
dev_err(dev, "failed to find ohci device\n");
else
usb_switch->ohci_dev = &pdev->dev;
of_node_put(node);
}
/* UDC */
node = of_parse_phandle(dev->of_node, "udc", 0);
if (!node) {
dev_info(dev, "udc device is not available\n");
} else {
pdev = of_find_device_by_node(node);
if (!pdev)
dev_err(dev, "failed to find udc device\n");
else
usb_switch->s3c_udc_dev = &pdev->dev;
of_node_put(node);
}
return 0;
}
static int __devinit mxs_saif_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct resource *iores, *dmares;
struct mxs_saif *saif;
struct mxs_saif_platform_data *pdata;
struct pinctrl *pinctrl;
int ret = 0;
if (!np && pdev->id >= ARRAY_SIZE(mxs_saif))
return -EINVAL;
saif = devm_kzalloc(&pdev->dev, sizeof(*saif), GFP_KERNEL);
if (!saif)
return -ENOMEM;
if (np) {
struct device_node *master;
saif->id = of_alias_get_id(np, "saif");
if (saif->id < 0)
return saif->id;
/*
* If there is no "fsl,saif-master" phandle, it's a saif
* master. Otherwise, it's a slave and its phandle points
* to the master.
*/
master = of_parse_phandle(np, "fsl,saif-master", 0);
if (!master) {
saif->master_id = saif->id;
} else {
saif->master_id = of_alias_get_id(master, "saif");
if (saif->master_id < 0)
return saif->master_id;
}
} else {
saif->id = pdev->id;
pdata = pdev->dev.platform_data;
if (pdata && !pdata->master_mode)
saif->master_id = pdata->master_id;
else
saif->master_id = saif->id;
}
if (saif->master_id < 0 || saif->master_id >= ARRAY_SIZE(mxs_saif)) {
dev_err(&pdev->dev, "get wrong master id\n");
return -EINVAL;
}
mxs_saif[saif->id] = saif;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl)) {
ret = PTR_ERR(pinctrl);
return ret;
}
saif->clk = clk_get(&pdev->dev, NULL);
if (IS_ERR(saif->clk)) {
ret = PTR_ERR(saif->clk);
dev_err(&pdev->dev, "Cannot get the clock: %d\n",
ret);
return ret;
}
iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
saif->base = devm_request_and_ioremap(&pdev->dev, iores);
if (!saif->base) {
dev_err(&pdev->dev, "ioremap failed\n");
ret = -ENODEV;
goto failed_get_resource;
}
dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
if (!dmares) {
/*
* TODO: This is a temporary solution and should be changed
* to use generic DMA binding later when the helplers get in.
*/
ret = of_property_read_u32(np, "fsl,saif-dma-channel",
&saif->dma_param.chan_num);
if (ret) {
dev_err(&pdev->dev, "failed to get dma channel\n");
goto failed_get_resource;
}
} else {
saif->dma_param.chan_num = dmares->start;
}
saif->irq = platform_get_irq(pdev, 0);
if (saif->irq < 0) {
ret = saif->irq;
dev_err(&pdev->dev, "failed to get irq resource: %d\n",
ret);
goto failed_get_resource;
}
saif->dev = &pdev->dev;
ret = devm_request_irq(&pdev->dev, saif->irq, mxs_saif_irq, 0,
"mxs-saif", saif);
if (ret) {
dev_err(&pdev->dev, "failed to request irq\n");
goto failed_get_resource;
}
saif->dma_param.chan_irq = platform_get_irq(pdev, 1);
if (saif->dma_param.chan_irq < 0) {
ret = saif->dma_param.chan_irq;
dev_err(&pdev->dev, "failed to get dma irq resource: %d\n",
ret);
goto failed_get_resource;
}
platform_set_drvdata(pdev, saif);
ret = snd_soc_register_dai(&pdev->dev, &mxs_saif_dai);
if (ret) {
dev_err(&pdev->dev, "register DAI failed\n");
goto failed_get_resource;
}
ret = mxs_pcm_platform_register(&pdev->dev);
if (ret) {
dev_err(&pdev->dev, "register PCM failed: %d\n", ret);
goto failed_pdev_alloc;
}
return 0;
failed_pdev_alloc:
snd_soc_unregister_dai(&pdev->dev);
failed_get_resource:
clk_put(saif->clk);
return ret;
}
static int gpio_ctrl_probe(struct platform_device *pdev)
{
struct gpio_ctrl_platform_data *pdata=NULL;
struct gpio_ctrl_data *ctrlmodules = NULL;
struct device_node *np=NULL, *child=NULL;
struct pinctrl *pinctrl=NULL;
unsigned int count=0;
int ret = 0;
// struct gpio_ctrl_platform_data *priv;
printk(KERN_ALERT "In gpio_ctrl_probe: \n");
{
const char *devname;
devname = dev_name(&(pdev->dev));
printk(KERN_ALERT "devname=%s\n",devname);
// printk(KERN_ALERT "devname=%s\n",kobject_name(&(pdev->dev)->kobj);
printk(KERN_ALERT "devname=%s\n",kobject_name(&( (pdev->dev.kobj))) );
}
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev,"pins are not configured from the driver\n");
printk(KERN_ALERT "pinctrl=%ld\n",PTR_ERR(pinctrl));
pdata = devm_kzalloc(&pdev->dev, MAX_LEDS*sizeof(struct gpio_ctrl_platform_data),GFP_KERNEL);
if (!pdata)
return(-ENOMEM);
np = pdev->dev.of_node;
count = of_get_child_count(np);
if (!count)
return (-ENODEV);
printk("child-count=%d\n",count);
for_each_child_of_node(np, child){
struct gpio_ctrl_data *ctrlmodule= &(pdata->ctrlmodules[pdata->num_leds++]);
ctrlmodule->out_gpio = of_get_gpio(child, 0);
ctrlmodule->in_gpio = of_get_gpio(child, 1);
ctrlmodule->led_gpio = of_get_gpio(child, 2);
printk("gpios--%d %d %d\n",ctrlmodule->out_gpio,ctrlmodule->in_gpio,ctrlmodule->led_gpio);
ctrlmodule->name = of_get_property(child, "label", NULL) ? : child->name;
ctrlmodule->led_cdev.name =of_get_property(child, "label", NULL) ? : child->name;
printk("ctrlmodule->led_cdev.name=%s\n",ctrlmodule->led_cdev.name);
printk("irq_no=%d\n",gpio_to_irq(ctrlmodule->in_gpio) );
ret = gpio_request_one(ctrlmodule->out_gpio,GPIOF_OUT_INIT_LOW,ctrlmodule->name);
if(ret < 0)
return ret;
ret = gpio_request_one( ctrlmodule->in_gpio,GPIOF_IN,ctrlmodule->name);
if(ret < 0)
return ret;
ret = gpio_request_one( ctrlmodule->led_gpio,GPIOF_OUT_INIT_LOW,ctrlmodule->name);
if(ret < 0)
return ret;
printk(KERN_ALERT "Gpio_ctrl:gpio_request_one\n");
{
printk("irq_no=%d\n",gpio_to_irq(ctrlmodule->in_gpio) );
ret = request_irq(gpio_to_irq(ctrlmodule->in_gpio),gpio_ctrl_ISR,IRQF_TRIGGER_RISING , "gpio_ctrl",NULL);
if(ret != 0)
printk("\n Request_irq Failed %d\n",ret);
};
gpio_export(ctrlmodule->out_gpio,0);
gpio_export(ctrlmodule->in_gpio,0);
gpio_export(ctrlmodule->led_gpio,0);
ret = led_classdev_register(&pdev->dev,&(ctrlmodule->led_cdev) );
if(ret < 0)
return ret;
}
printk(KERN_ALERT "Gpio_ctrl:led_classdev_register\n");
platform_set_drvdata(pdev, pdata);
printk(KERN_ALERT "Gpio_ctrl:probe \n");
return 0;
}
static int __init sunxi_spdif_dev_probe(struct platform_device *pdev)
{
int reg_val = 0;
int ret = 0;
#ifdef CONFIG_ARCH_SUN9IW1
if(script_get_item("spdif0", "spdif_voltage", &spdif_voltage) != SCIRPT_ITEM_VALUE_TYPE_STR){
printk("[aif3_voltage]script_get_item return type err\n");
return -EFAULT;
}
/*spdif:dcdc1*/
spdif_vol = regulator_get(NULL, spdif_voltage.str);
if (!spdif_vol) {
printk("get audio spdif_vol failed\n");
return -EFAULT;
}
//regulator_set_voltage(spdif_vol, 3000000, 3000000);
regulator_enable(spdif_vol);
#endif
sunxi_spdif.regs = ioremap(SUNXI_SPDIFBASE, 0x100);
if (sunxi_spdif.regs == NULL) {
return -ENXIO;
}
printk("%s, line:%d, dev_name(&pdev->dev):%s\n", __func__, __LINE__, dev_name(&pdev->dev));
spdif_pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR_OR_NULL(spdif_pinctrl)) {
dev_warn(&pdev->dev,
"pins are not configured from the driver\n");
}
#ifdef CONFIG_ARCH_SUN8IW6
spdif_pllx8 = clk_get(NULL, "pll_audiox8");
if ((!spdif_pllx8)||(IS_ERR(spdif_pllx8))) {
printk("try to get spdif_pllx8 failed\n");
}
if (clk_prepare_enable(spdif_pllx8)) {
printk("enable spdif_pll2clk failed; \n");
}
#else
#ifdef CONFIG_ARCH_SUN9IW1
/*spdif pll3clk*/
spdif_pll3clk = clk_get(NULL, "pll3");
if ((!spdif_pll3clk)||(IS_ERR(spdif_pll3clk))) {
printk("try to get spdif_pll3clk failed\n");
}
if (clk_prepare_enable(spdif_pll3clk)) {
printk("enable spdif_pll3clk failed; \n");
}
#else
spdif_pllx8 = clk_get(NULL, "pll2x8");
if ((!spdif_pllx8)||(IS_ERR(spdif_pllx8))) {
printk("try to get spdif_pllx8 failed\n");
}
if (clk_prepare_enable(spdif_pllx8)) {
printk("enable spdif_pll2clk failed; \n");
}
#endif
#endif
#ifndef CONFIG_ARCH_SUN9IW1
/********spdif pll2clk can be remove****************/
/*spdif pll2clk*/
spdif_pll2clk = clk_get(NULL, "pll2");
if ((!spdif_pll2clk)||(IS_ERR(spdif_pll2clk))) {
printk("try to get spdif_pll2clk failed\n");
}
if (clk_prepare_enable(spdif_pll2clk)) {
printk("enable spdif_pll2clk failed; \n");
}
#endif
/*spdif module clk*/
spdif_moduleclk = clk_get(NULL, "spdif");
if ((!spdif_moduleclk)||(IS_ERR(spdif_moduleclk))) {
printk("try to get spdif_moduleclk failed\n");
}
#ifndef CONFIG_ARCH_SUN9IW1
/*******clk_set_parent can be remove*******/
if (clk_set_parent(spdif_moduleclk, spdif_pll2clk)) {
printk("try to set parent of spdif_moduleclk to spdif_pll2ck failed! line = %d\n",__LINE__);
}
if (clk_set_rate(spdif_moduleclk, 24576000/8)) {
printk("set spdif_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__);
}
#else
if (clk_set_parent(spdif_moduleclk, spdif_pll3clk)) {
printk("try to set parent of spdif_moduleclk to spdif_pll2ck failed! line = %d\n",__LINE__);
}
if (clk_set_rate(spdif_moduleclk, 24576000)) {
printk("set spdif_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__);
}
#endif
if (clk_prepare_enable(spdif_moduleclk)) {
printk("open spdif_moduleclk failed! line = %d\n", __LINE__);
}
// if (clk_reset(spdif_moduleclk, AW_CCU_CLK_NRESET)) {
// printk("try to NRESET spdif module clk failed!\n");
// }
/*global enbale*/
reg_val = readl(sunxi_spdif.regs + SUNXI_SPDIF_CTL);
reg_val |= SUNXI_SPDIF_CTL_GEN;
writel(reg_val, sunxi_spdif.regs + SUNXI_SPDIF_CTL);
ret = snd_soc_register_dai(&pdev->dev, &sunxi_spdif_dai);
return 0;
}
static int bq24297_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct bq24297_chip *chip;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct device_node *np = client->dev.of_node;
struct pinctrl *pinctrl;
int ret = 0;
dev_info(&client->dev, "%s: addr=0x%x @ IIC%d, irq=%d\n",
client->name,client->addr,client->adapter->nr,client->irq);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))//I2C_FUNC_SMBUS_BYTE
return -EIO;
chip = kzalloc(sizeof(*chip), GFP_KERNEL);
if (!chip)
return -ENOMEM;
this_chip = chip;
chip->client = client;
i2c_set_clientdata(client, chip);
of_property_read_u32(np, "debug", &bq24297_dbg);
ret = bq24297_hw_init();
if (ret < 0)
{
goto err_hw_init;
}
bq24297_read_version();
chip->usb.name = "usb";
chip->usb.type = POWER_SUPPLY_TYPE_USB;
chip->usb.supplied_to = supply_to_list;
chip->usb.num_supplicants = ARRAY_SIZE(supply_to_list);
chip->usb.get_property = bq24297_power_get_property;
chip->usb.properties = bq24297_power_props;
chip->usb.num_properties = ARRAY_SIZE(bq24297_power_props);
chip->ac.name = "ac";
chip->ac.type = POWER_SUPPLY_TYPE_MAINS;
chip->ac.supplied_to = supply_to_list;
chip->ac.num_supplicants = ARRAY_SIZE(supply_to_list);
chip->ac.get_property = bq24297_power_get_property;
chip->ac.properties = bq24297_power_props;
chip->ac.num_properties = ARRAY_SIZE(bq24297_power_props);
power_supply_register(&client->dev, &chip->usb);
power_supply_register(&client->dev, &chip->ac);
chip->battery = power_supply_get_by_name("battery");
ret = sysfs_create_group(&client->dev.kobj, &bq24297_attr_group);
if (ret)
{
dev_err(&client->dev, "create sysfs error\n");
goto err_create_sysfs;
}
pinctrl = devm_pinctrl_get_select_default(&client->dev);
if (IS_ERR(pinctrl))
{
dev_err(&client->dev, "pinctrl error\n");
goto err_pinctrl;
}
INIT_DELAYED_WORK(&chip->work_status, bq24297_status_func);
chip->chg_int_gpio = of_get_named_gpio(np, "bq24297,chg_int", 0);
chip->chg_int_irq = gpio_to_irq(chip->chg_int_gpio);
//gpio_set_debounce(chip->chg_int_gpio, 1);// TODO
ret = request_irq(chip->chg_int_irq, chg_int_func,
IRQF_TRIGGER_RISING, "chg_int", NULL);
if (ret)
{
dev_err(&client->dev, "request_irq error\n");
goto err_request_irq;
}
return 0;
err_request_irq:
err_pinctrl:
sysfs_remove_group(&client->dev.kobj, &bq24297_attr_group);
err_create_sysfs:
power_supply_unregister(&chip->usb);
power_supply_unregister(&chip->ac);
err_hw_init:
kfree(chip);
return ret;
}
static int __devinit ci13xxx_imx_probe(struct platform_device *pdev)
{
struct ci13xxx_imx_data *data;
struct platform_device *plat_ci, *phy_pdev;
struct device_node *phy_np;
struct resource *res;
struct regulator *reg_vbus;
struct pinctrl *pinctrl;
int ret;
if (of_find_property(pdev->dev.of_node, "fsl,usbmisc", NULL)
&& !usbmisc_ops)
return -EPROBE_DEFER;
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
if (!data) {
dev_err(&pdev->dev, "Failed to allocate CI13xxx-IMX data!\n");
return -ENOMEM;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "Can't get device resources!\n");
return -ENOENT;
}
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "pinctrl get/select failed, err=%ld\n",
PTR_ERR(pinctrl));
data->clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(data->clk)) {
dev_err(&pdev->dev,
"Failed to get clock, err=%ld\n", PTR_ERR(data->clk));
return PTR_ERR(data->clk);
}
ret = clk_prepare_enable(data->clk);
if (ret) {
dev_err(&pdev->dev,
"Failed to prepare or enable clock, err=%d\n", ret);
return ret;
}
phy_np = of_parse_phandle(pdev->dev.of_node, "fsl,usbphy", 0);
if (phy_np) {
data->phy_np = phy_np;
phy_pdev = of_find_device_by_node(phy_np);
if (phy_pdev) {
struct usb_phy *phy;
phy = pdev_to_phy(phy_pdev);
if (phy &&
try_module_get(phy_pdev->dev.driver->owner)) {
usb_phy_init(phy);
data->phy = phy;
}
}
}
/* we only support host now, so enable vbus here */
reg_vbus = devm_regulator_get(&pdev->dev, "vbus");
if (!IS_ERR(reg_vbus)) {
ret = regulator_enable(reg_vbus);
if (ret) {
dev_err(&pdev->dev,
"Failed to enable vbus regulator, err=%d\n",
ret);
goto put_np;
}
data->reg_vbus = reg_vbus;
} else {
reg_vbus = NULL;
}
ci13xxx_imx_platdata.phy = data->phy;
if (!pdev->dev.dma_mask) {
pdev->dev.dma_mask = devm_kzalloc(&pdev->dev,
sizeof(*pdev->dev.dma_mask), GFP_KERNEL);
if (!pdev->dev.dma_mask) {
ret = -ENOMEM;
dev_err(&pdev->dev, "Failed to alloc dma_mask!\n");
goto err;
}
*pdev->dev.dma_mask = DMA_BIT_MASK(32);
dma_set_coherent_mask(&pdev->dev, *pdev->dev.dma_mask);
}
if (usbmisc_ops && usbmisc_ops->init) {
ret = usbmisc_ops->init(&pdev->dev);
if (ret) {
dev_err(&pdev->dev,
"usbmisc init failed, ret=%d\n", ret);
goto err;
}
}
plat_ci = ci13xxx_add_device(&pdev->dev,
pdev->resource, pdev->num_resources,
&ci13xxx_imx_platdata);
if (IS_ERR(plat_ci)) {
ret = PTR_ERR(plat_ci);
dev_err(&pdev->dev,
"Can't register ci_hdrc platform device, err=%d\n",
ret);
goto err;
}
data->ci_pdev = plat_ci;
platform_set_drvdata(pdev, data);
pm_runtime_no_callbacks(&pdev->dev);
pm_runtime_enable(&pdev->dev);
return 0;
err:
if (reg_vbus)
regulator_disable(reg_vbus);
put_np:
if (phy_np)
of_node_put(phy_np);
clk_disable_unprepare(data->clk);
return ret;
}
static int pwm_test_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = dev->of_node;
struct pwm_test *pwm_test;
struct of_phandle_args args;
struct pinctrl *pinctrl;
u32 val;
int rc;
if (node == NULL) {
dev_err(dev, "Non DT platforms not supported\n");
return -EINVAL;
}
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "Unable to select pin group\n");
pwm_test = devm_kzalloc(&pdev->dev, sizeof(*pwm_test), GFP_KERNEL);
if (!pwm_test) {
dev_err(&pdev->dev, "memory error\n");
return -ENOMEM;
}
platform_set_drvdata(pdev, pwm_test);
/* now do the probe time config */
pwm_test->pwm = devm_pwm_get(&pdev->dev, NULL);
if (IS_ERR(pwm_test->pwm)) {
dev_err(dev, "unable to request PWM\n");
return PTR_ERR(pwm_test->pwm);
}
rc = of_parse_phandle_with_args(node, "pwms", "#pwm-cells", 0, &args);
if (rc != 0) {
dev_err(dev, "of_parse_phandle_with_args() failed\n");
return rc;
}
/* read the period */
pwm_test->period = args.args[1];
/* should be at least 2, but 3 is possible to store polarity */
pwm_test->polarity = PWM_POLARITY_NORMAL;
/* PWM_SPEC_POLARITY is (1 << 0) */
if (args.args_count >= 3 && (args.args[2] & (1 << 0)) != 0)
pwm_test->polarity = PWM_POLARITY_INVERSED;
/* Determine the duty from the device tree */
rc = of_property_read_u32(node, "duty", &val);
if (rc != 0)
val = 0; /* default is 0 */
pwm_test->duty = val;
/* polarity is already set */
rc = pwm_config(pwm_test->pwm, pwm_test->duty, pwm_test->period);
if (rc) {
dev_err(dev, "pwm_config() failed\n");
return rc;
}
/* Determine running or not from the device tree */
rc = of_property_read_u32(node, "enabled", &val);
if (rc < 0)
val = 0; /* default is disabled */
/* single bit */
pwm_test->run = !!val;
if (pwm_test->run) {
rc = pwm_enable(pwm_test->pwm);
if (rc < 0) {
dev_err(dev, "pwm_enable failed\n");
return rc;
}
}
rc = sysfs_create_group(&dev->kobj, &pwm_device_attr_group);
if (rc != 0) {
dev_err(dev, "Unable to create sysfs entries\n");
return rc;
}
return 0;
}
static int atmel_asoc_wm8904_probe(struct platform_device *pdev)
{
struct snd_soc_card *card = &atmel_asoc_wm8904_card;
struct snd_soc_dai_link *dailink = &atmel_asoc_wm8904_dailink;
struct clk *clk_src;
struct pinctrl *pinctrl;
int id, ret;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl)) {
dev_err(&pdev->dev, "failed to request pinctrl\n");
return PTR_ERR(pinctrl);
}
card->dev = &pdev->dev;
ret = atmel_asoc_wm8904_dt_init(pdev);
if (ret) {
dev_err(&pdev->dev, "failed to init dt info\n");
return ret;
}
id = of_alias_get_id((struct device_node *)dailink->cpu_of_node, "ssc");
ret = atmel_ssc_set_audio(id);
if (ret != 0) {
dev_err(&pdev->dev, "failed to set SSC %d for audio\n", id);
return ret;
}
mclk = clk_get(NULL, "pck0");
if (IS_ERR(mclk)) {
dev_err(&pdev->dev, "failed to get pck0\n");
ret = PTR_ERR(mclk);
goto err_set_audio;
}
clk_src = clk_get(NULL, "clk32k");
if (IS_ERR(clk_src)) {
dev_err(&pdev->dev, "failed to get clk32k\n");
ret = PTR_ERR(clk_src);
goto err_set_audio;
}
ret = clk_set_parent(mclk, clk_src);
clk_put(clk_src);
if (ret != 0) {
dev_err(&pdev->dev, "failed to set MCLK parent\n");
goto err_set_audio;
}
dev_info(&pdev->dev, "setting pck0 to %dHz\n", MCLK_RATE);
clk_set_rate(mclk, MCLK_RATE);
ret = snd_soc_register_card(card);
if (ret) {
dev_err(&pdev->dev, "snd_soc_register_card failed\n");
goto err_set_audio;
}
return 0;
err_set_audio:
atmel_ssc_put_audio(id);
return ret;
}
static int sdhci_s3c_probe(struct platform_device *pdev)
{
struct s3c_sdhci_platdata *pdata;
struct sdhci_s3c_drv_data *drv_data;
struct device *dev = &pdev->dev;
struct sdhci_host *host;
struct sdhci_s3c *sc;
struct resource *res;
int ret, irq, ptr, clks;
if (!pdev->dev.platform_data && !pdev->dev.of_node) {
dev_err(dev, "no device data specified\n");
return -ENOENT;
}
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(dev, "no irq specified\n");
return irq;
}
host = sdhci_alloc_host(dev, sizeof(struct sdhci_s3c));
if (IS_ERR(host)) {
dev_err(dev, "sdhci_alloc_host() failed\n");
return PTR_ERR(host);
}
sc = sdhci_priv(host);
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata) {
ret = -ENOMEM;
goto err_pdata_io_clk;
}
sc->pctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (pdev->dev.of_node) {
ret = sdhci_s3c_parse_dt(&pdev->dev, host, pdata);
if (ret)
goto err_pdata_io_clk;
} else {
memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
sc->ext_cd_gpio = -1; /* invalid gpio number */
}
drv_data = sdhci_s3c_get_driver_data(pdev);
sc->host = host;
sc->pdev = pdev;
sc->pdata = pdata;
platform_set_drvdata(pdev, host);
sc->clk_io = clk_get(dev, "hsmmc");
if (IS_ERR(sc->clk_io)) {
dev_err(dev, "failed to get io clock\n");
ret = PTR_ERR(sc->clk_io);
goto err_pdata_io_clk;
}
/* enable the local io clock and keep it running for the moment. */
clk_prepare_enable(sc->clk_io);
for (clks = 0, ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
struct clk *clk;
char name[14];
snprintf(name, 14, "mmc_busclk.%d", ptr);
clk = clk_get(dev, name);
if (IS_ERR(clk))
continue;
clks++;
sc->clk_bus[ptr] = clk;
/*
* save current clock index to know which clock bus
* is used later in overriding functions.
*/
sc->cur_clk = ptr;
dev_info(dev, "clock source %d: %s (%ld Hz)\n",
ptr, name, clk_get_rate(clk));
}
if (clks == 0) {
dev_err(dev, "failed to find any bus clocks\n");
ret = -ENOENT;
goto err_no_busclks;
}
#ifndef CONFIG_PM_RUNTIME
clk_prepare_enable(sc->clk_bus[sc->cur_clk]);
#endif
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
host->ioaddr = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(host->ioaddr)) {
ret = PTR_ERR(host->ioaddr);
goto err_req_regs;
}
/* Ensure we have minimal gpio selected CMD/CLK/Detect */
if (pdata->cfg_gpio)
pdata->cfg_gpio(pdev, pdata->max_width);
host->hw_name = "samsung-hsmmc";
host->ops = &sdhci_s3c_ops;
host->quirks = 0;
host->irq = irq;
/* Setup quirks for the controller */
host->quirks |= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
host->quirks |= SDHCI_QUIRK_NO_HISPD_BIT;
if (drv_data)
host->quirks |= drv_data->sdhci_quirks;
#ifndef CONFIG_MMC_SDHCI_S3C_DMA
/* we currently see overruns on errors, so disable the SDMA
* support as well. */
host->quirks |= SDHCI_QUIRK_BROKEN_DMA;
#endif /* CONFIG_MMC_SDHCI_S3C_DMA */
/* It seems we do not get an DATA transfer complete on non-busy
* transfers, not sure if this is a problem with this specific
* SDHCI block, or a missing configuration that needs to be set. */
host->quirks |= SDHCI_QUIRK_NO_BUSY_IRQ;
/* This host supports the Auto CMD12 */
host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
/* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */
host->quirks |= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC;
if (pdata->cd_type == S3C_SDHCI_CD_NONE ||
pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
host->mmc->caps = MMC_CAP_NONREMOVABLE;
switch (pdata->max_width) {
case 8:
host->mmc->caps |= MMC_CAP_8_BIT_DATA;
case 4:
host->mmc->caps |= MMC_CAP_4_BIT_DATA;
break;
}
if (pdata->pm_caps)
host->mmc->pm_caps |= pdata->pm_caps;
host->quirks |= (SDHCI_QUIRK_32BIT_DMA_ADDR |
SDHCI_QUIRK_32BIT_DMA_SIZE);
/* HSMMC on Samsung SoCs uses SDCLK as timeout clock */
host->quirks |= SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK;
/*
* If controller does not have internal clock divider,
* we can use overriding functions instead of default.
*/
if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK) {
sdhci_s3c_ops.set_clock = sdhci_cmu_set_clock;
sdhci_s3c_ops.get_min_clock = sdhci_cmu_get_min_clock;
sdhci_s3c_ops.get_max_clock = sdhci_cmu_get_max_clock;
}
/* It supports additional host capabilities if needed */
if (pdata->host_caps)
host->mmc->caps |= pdata->host_caps;
if (pdata->host_caps2)
host->mmc->caps2 |= pdata->host_caps2;
pm_runtime_enable(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, 50);
pm_runtime_use_autosuspend(&pdev->dev);
pm_suspend_ignore_children(&pdev->dev, 1);
ret = sdhci_add_host(host);
if (ret) {
dev_err(dev, "sdhci_add_host() failed\n");
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
goto err_req_regs;
}
/* The following two methods of card detection might call
sdhci_s3c_notify_change() immediately, so they can be called
only after sdhci_add_host(). Setup errors are ignored. */
if (pdata->cd_type == S3C_SDHCI_CD_EXTERNAL && pdata->ext_cd_init)
pdata->ext_cd_init(&sdhci_s3c_notify_change);
if (pdata->cd_type == S3C_SDHCI_CD_GPIO &&
gpio_is_valid(pdata->ext_cd_gpio))
sdhci_s3c_setup_card_detect_gpio(sc);
#ifdef CONFIG_PM_RUNTIME
if (pdata->cd_type != S3C_SDHCI_CD_INTERNAL)
clk_disable_unprepare(sc->clk_io);
#endif
return 0;
err_req_regs:
#ifndef CONFIG_PM_RUNTIME
clk_disable_unprepare(sc->clk_bus[sc->cur_clk]);
#endif
for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
if (sc->clk_bus[ptr]) {
clk_put(sc->clk_bus[ptr]);
}
}
err_no_busclks:
clk_disable_unprepare(sc->clk_io);
clk_put(sc->clk_io);
err_pdata_io_clk:
sdhci_free_host(host);
return ret;
}
static int panel_probe(struct platform_device *pdev)
{
struct device_node *bl_node, *node = pdev->dev.of_node;
struct panel_module *panel_mod;
struct tilcdc_module *mod;
struct pinctrl *pinctrl;
int ret;
/* bail out early if no DT data: */
if (!node) {
dev_err(&pdev->dev, "device-tree data is missing\n");
return -ENXIO;
}
panel_mod = devm_kzalloc(&pdev->dev, sizeof(*panel_mod), GFP_KERNEL);
if (!panel_mod)
return -ENOMEM;
bl_node = of_parse_phandle(node, "backlight", 0);
if (bl_node) {
panel_mod->backlight = of_find_backlight_by_node(bl_node);
of_node_put(bl_node);
if (!panel_mod->backlight)
return -EPROBE_DEFER;
dev_info(&pdev->dev, "found backlight\n");
}
panel_mod->enable_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
GPIOD_OUT_LOW);
if (IS_ERR(panel_mod->enable_gpio)) {
ret = PTR_ERR(panel_mod->enable_gpio);
dev_err(&pdev->dev, "failed to request enable GPIO\n");
goto fail_backlight;
}
if (panel_mod->enable_gpio)
dev_info(&pdev->dev, "found enable GPIO\n");
mod = &panel_mod->base;
pdev->dev.platform_data = mod;
tilcdc_module_init(mod, "panel", &panel_module_ops);
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "pins are not configured\n");
panel_mod->timings = of_get_display_timings(node);
if (!panel_mod->timings) {
dev_err(&pdev->dev, "could not get panel timings\n");
ret = -EINVAL;
goto fail_free;
}
panel_mod->info = of_get_panel_info(node);
if (!panel_mod->info) {
dev_err(&pdev->dev, "could not get panel info\n");
ret = -EINVAL;
goto fail_timings;
}
mod->preferred_bpp = panel_mod->info->bpp;
return 0;
fail_timings:
display_timings_release(panel_mod->timings);
fail_free:
tilcdc_module_cleanup(mod);
fail_backlight:
if (panel_mod->backlight)
put_device(&panel_mod->backlight->dev);
return ret;
}
static int w1_gpio_probe(struct platform_device *pdev)
{
struct w1_bus_master *master;
struct w1_gpio_platform_data *pdata;
struct pinctrl *pinctrl;
int err;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "unable to select pin group\n");
if (of_have_populated_dt()) {
err = w1_gpio_probe_dt(pdev);
if (err < 0) {
dev_err(&pdev->dev, "Failed to parse DT\n");
return err;
}
}
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "No configuration data\n");
return -ENXIO;
}
master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL);
if (!master) {
dev_err(&pdev->dev, "Out of memory\n");
return -ENOMEM;
}
err = gpio_request(pdata->pin, "w1");
if (err) {
dev_err(&pdev->dev, "gpio_request (pin) failed\n");
goto free_master;
}
if (gpio_is_valid(pdata->ext_pullup_enable_pin)) {
err = gpio_request_one(pdata->ext_pullup_enable_pin,
GPIOF_INIT_LOW, "w1 pullup");
if (err < 0) {
dev_err(&pdev->dev, "gpio_request_one "
"(ext_pullup_enable_pin) failed\n");
goto free_gpio;
}
}
master->data = pdata;
master->read_bit = w1_gpio_read_bit;
if (pdata->is_open_drain) {
gpio_direction_output(pdata->pin, 1);
master->write_bit = w1_gpio_write_bit_val;
} else {
gpio_direction_input(pdata->pin);
master->write_bit = w1_gpio_write_bit_dir;
}
err = w1_add_master_device(master);
if (err) {
dev_err(&pdev->dev, "w1_add_master device failed\n");
goto free_gpio_ext_pu;
}
/* voltage regulator support */
pdata->regulator_en = 0;
pdata->w1_gpio_vdd = regulator_get(&pdev->dev, "w1_vdd");
if (IS_ERR(pdata->w1_gpio_vdd)) {
pdata->w1_gpio_vdd = NULL;
dev_err(&pdev->dev,
"%s: Failed to get w1_vdd regulator\n",
__func__);
} else {
dev_err(&pdev->dev, "w1-vdd regulator is initially %s\n",
regulator_is_enabled(pdata->w1_gpio_vdd) ?
"on" : "off");
err = regulator_enable(pdata->w1_gpio_vdd);
if (err) {
pr_err("%s: Error %d enabling w1-vdd regulator\n",
__func__, err);
goto free_regulator;
} else {
pdata->regulator_en = 1;
}
}
if (pdata->enable_external_pullup)
pdata->enable_external_pullup(1);
if (gpio_is_valid(pdata->ext_pullup_enable_pin))
gpio_set_value(pdata->ext_pullup_enable_pin, 1);
platform_set_drvdata(pdev, master);
return 0;
free_regulator:
if (pdata->w1_gpio_vdd != NULL)
regulator_put(pdata->w1_gpio_vdd);
free_gpio_ext_pu:
if (gpio_is_valid(pdata->ext_pullup_enable_pin))
gpio_free(pdata->ext_pullup_enable_pin);
free_gpio:
gpio_free(pdata->pin);
free_master:
kfree(master);
return err;
}
static int uart_omap_probe(struct platform_device *pdev)
{
printk("omap_i2c_probe started\n");
struct uart_omap_port *up;
struct resource *mem,*irq;
struct omap_uart_port_info *omap_up_info=pdev->dev.platform_data;
int ret;
struct rtdm_device *rdev;
void __iomem *mem_1;
int retval;
if(pdev->dev.of_node)
omap_up_info = of_get_uart_port_info(&pdev->dev);
mem = platform_get_resource(pdev,IORESOURCE_MEM,0);
if(!mem)
{
dev_err(&pdev->dev,"no mem resource\n");
return -ENODEV;
}
printk("platform_get_resource for mem\n");
irq = platform_get_resource(pdev,IORESOURCE_IRQ,0);
if(!irq)
{
dev_err(&pdev->dev,"no irq resource\n");
return -ENODEV;
}
printk("platform_get_resource for irq\n");
if(!devm_request_mem_region(&pdev->dev,mem->start,resource_size(mem),pdev->dev.driver->name))
{
dev_err(&pdev->dev,"memory region already claimed\n");
return -EBUSY;
}
printk("mem->start=%x\n",mem->start);
printk("irq->start=%x\n",irq->start);
if ( gpio_is_valid(omap_up_info->DTR_gpio) && omap_up_info->DTR_present)
{
ret = gpio_request(omap_up_info->DTR_gpio, "omap-serial");
printk("gpio_request\n");
if (ret < 0)
return ret;
ret = gpio_direction_output(omap_up_info->DTR_gpio,omap_up_info->DTR_inverted);
printk("gpio_direction_output\n");
if (ret < 0)
return ret;
}
printk("gpio_is_valid\n");
up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL);
if (!up)
return -ENOMEM;
printk("Local struct up=%x\n",up);
rtdm_printk("clock enabling.......UART4\n");
mem_1 = ioremap(SOC_PRCM_REGS, SOC_PRCM_SIZE);
if(!mem)
{
printk (KERN_ERR "HI: ERROR: Failed to remap memory for GPIO Bank 2 IRQ pin configuration.\n");
return 0;
}
// retval=ioread32(mem_1 + 0x78);
// rtdm_printk("value of clock i2c enable retval=%d\n",retval);
iowrite32(CM_PER_UART4_CLKCTRL , mem_1 + 0x78);
// retval = ioread32(CM_PER_UART4_CLKCTRL + 0x78);
// rtdm_printk("value of clock i2c enable retval=%d\n",retval);
rtdm_printk("clock enable for UART4\n");
rdev=kzalloc(sizeof(struct rtdm_device),GFP_KERNEL);
rdev = &up->rtdm_dev;
memcpy(rdev, &uart_device, sizeof(struct rtdm_device));
ret=rtdm_dev_register(rdev);
if(ret<0)
{
printk("RTDM device not registered\n");
}
rdev->device_data = devm_kzalloc(&pdev->dev, sizeof(MY_DEV), GFP_KERNEL);
rdev->device_data = up;
printk("RTDM driver register\n");
if (gpio_is_valid(omap_up_info->DTR_gpio) && omap_up_info->DTR_present)
{
up->DTR_gpio = omap_up_info->DTR_gpio;
up->DTR_inverted = omap_up_info->DTR_inverted;
printk("DTR gpio valid\n");
}
else
up->DTR_gpio = -EINVAL;
up->DTR_active = 0;
up->dev = &pdev->dev;
up->irq = irq->start;
up->regshift = 2;
up->fifosize = 64;
if (pdev->dev.of_node)
{
up->line = of_alias_get_id(pdev->dev.of_node, "serial");
printk("pdev->dev.of_node\n");
}
else
{
up->line = pdev->id;
printk("pdev->id\n");
}
if (up->line < 0)
{
dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n",up->line);
ret = -ENODEV;
// goto err_port_line;
}
up->pins = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(up->pins))
{
dev_warn(&pdev->dev, "did not get pins for uart%i error: %li\n",up->line, PTR_ERR(up->pins));
up->pins = NULL;
}
printk("devm_pinctrl_get_select_default\n");
sprintf(up->name, "OMAP UART%d", up->line);
up->mapbase = mem->start;
up->membase = devm_ioremap(&pdev->dev,mem->start,resource_size(mem));//what does ioremap do???? read about it
if (!up->membase)
{
dev_err(&pdev->dev, "can't ioremap UART\n");
ret = -ENOMEM;
// goto err_ioremap;
}
up->flags = omap_up_info->flags;
up->uartclk = omap_up_info->uartclk;
printk("clock freq=%d\n",up->uartclk);
if(!up->uartclk)
{
up->uartclk = DEFAULT_CLK_SPEED;
dev_warn(&pdev->dev, "No clock speed specified: using default:""%d\n", DEFAULT_CLK_SPEED);
}
up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
platform_set_drvdata(pdev, up);
omap_serial_fill_features_erratas(up);
return 0;
//err_unuse_clocks:
// omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, 0);
//err_free_mem:
// platform_set_drvdata(pdev, NULL);
// return r;
}
static int __devinit serial_omap_probe(struct platform_device *pdev)
{
struct uart_omap_port *up;
struct resource *mem, *irq;
struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data;
int ret;
if (pdev->dev.of_node)
omap_up_info = of_get_uart_port_info(&pdev->dev);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "no mem resource?\n");
return -ENODEV;
}
irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!irq) {
dev_err(&pdev->dev, "no irq resource?\n");
return -ENODEV;
}
if (!devm_request_mem_region(&pdev->dev, mem->start, resource_size(mem),
pdev->dev.driver->name)) {
dev_err(&pdev->dev, "memory region already claimed\n");
return -EBUSY;
}
if (gpio_is_valid(omap_up_info->DTR_gpio) &&
omap_up_info->DTR_present) {
ret = gpio_request(omap_up_info->DTR_gpio, "omap-serial");
if (ret < 0)
return ret;
ret = gpio_direction_output(omap_up_info->DTR_gpio,
omap_up_info->DTR_inverted);
if (ret < 0)
return ret;
}
up = devm_kzalloc(&pdev->dev, sizeof(*up), GFP_KERNEL);
if (!up)
return -ENOMEM;
if (gpio_is_valid(omap_up_info->DTR_gpio) &&
omap_up_info->DTR_present) {
up->DTR_gpio = omap_up_info->DTR_gpio;
up->DTR_inverted = omap_up_info->DTR_inverted;
} else
up->DTR_gpio = -EINVAL;
up->DTR_active = 0;
up->dev = &pdev->dev;
up->port.dev = &pdev->dev;
up->port.type = PORT_OMAP;
up->port.iotype = UPIO_MEM;
up->port.irq = irq->start;
up->port.regshift = 2;
up->port.fifosize = 64;
up->port.ops = &serial_omap_pops;
if (pdev->dev.of_node)
up->port.line = of_alias_get_id(pdev->dev.of_node, "serial");
else
up->port.line = pdev->id;
if (up->port.line < 0) {
dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n",
up->port.line);
ret = -ENODEV;
goto err_port_line;
}
up->pins = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(up->pins)) {
dev_warn(&pdev->dev, "did not get pins for uart%i error: %li\n",
up->port.line, PTR_ERR(up->pins));
up->pins = NULL;
}
sprintf(up->name, "OMAP UART%d", up->port.line);
up->port.mapbase = mem->start;
up->port.membase = devm_ioremap(&pdev->dev, mem->start,
resource_size(mem));
if (!up->port.membase) {
dev_err(&pdev->dev, "can't ioremap UART\n");
ret = -ENOMEM;
goto err_ioremap;
}
up->port.flags = omap_up_info->flags;
up->port.uartclk = omap_up_info->uartclk;
if (!up->port.uartclk) {
up->port.uartclk = DEFAULT_CLK_SPEED;
dev_warn(&pdev->dev, "No clock speed specified: using default:"
"%d\n", DEFAULT_CLK_SPEED);
}
up->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
up->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
pm_qos_add_request(&up->pm_qos_request,
PM_QOS_CPU_DMA_LATENCY, up->latency);
serial_omap_uart_wq = create_singlethread_workqueue(up->name);
INIT_WORK(&up->qos_work, serial_omap_uart_qos_work);
platform_set_drvdata(pdev, up);
pm_runtime_enable(&pdev->dev);
pm_runtime_use_autosuspend(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev,
omap_up_info->autosuspend_timeout);
pm_runtime_irq_safe(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);
omap_serial_fill_features_erratas(up);
ui[up->port.line] = up;
serial_omap_add_console_port(up);
ret = uart_add_one_port(&serial_omap_reg, &up->port);
if (ret != 0)
goto err_add_port;
pm_runtime_mark_last_busy(up->dev);
pm_runtime_put_autosuspend(up->dev);
return 0;
err_add_port:
pm_runtime_put(&pdev->dev);
pm_runtime_disable(&pdev->dev);
err_ioremap:
err_port_line:
dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n",
pdev->id, __func__, ret);
return ret;
}
static int spi_imx_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
const struct of_device_id *of_id =
of_match_device(spi_imx_dt_ids, &pdev->dev);
struct spi_imx_master *mxc_platform_info =
dev_get_platdata(&pdev->dev);
struct spi_master *master;
struct spi_imx_data *spi_imx;
struct resource *res;
struct pinctrl *pinctrl;
int i, ret, num_cs;
if (!np && !mxc_platform_info) {
dev_err(&pdev->dev, "can't get the platform data\n");
return -EINVAL;
}
ret = of_property_read_u32(np, "fsl,spi-num-chipselects", &num_cs);
if (ret < 0) {
if (mxc_platform_info)
num_cs = mxc_platform_info->num_chipselect;
else
return ret;
}
master = spi_alloc_master(&pdev->dev,
sizeof(struct spi_imx_data) + sizeof(int) * num_cs);
if (!master)
return -ENOMEM;
platform_set_drvdata(pdev, master);
master->bus_num = pdev->id;
master->num_chipselect = num_cs;
spi_imx = spi_master_get_devdata(master);
spi_imx->bitbang.master = spi_master_get(master);
for (i = 0; i < master->num_chipselect; i++) {
int cs_gpio = of_get_named_gpio(np, "cs-gpios", i);
if (!gpio_is_valid(cs_gpio) && mxc_platform_info)
cs_gpio = mxc_platform_info->chipselect[i];
spi_imx->chipselect[i] = cs_gpio;
if (!gpio_is_valid(cs_gpio))
continue;
ret = gpio_request(spi_imx->chipselect[i], DRIVER_NAME);
if (ret) {
dev_err(&pdev->dev, "can't get cs gpios\n");
goto out_gpio_free;
}
}
spi_imx->bitbang.chipselect = spi_imx_chipselect;
spi_imx->bitbang.setup_transfer = spi_imx_setupxfer;
spi_imx->bitbang.txrx_bufs = spi_imx_transfer;
spi_imx->bitbang.master->setup = spi_imx_setup;
spi_imx->bitbang.master->cleanup = spi_imx_cleanup;
spi_imx->bitbang.master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
init_completion(&spi_imx->xfer_done);
spi_imx->devtype_data = of_id ? of_id->data :
(struct spi_imx_devtype_data *) pdev->id_entry->driver_data;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(&pdev->dev, "can't get platform resource\n");
ret = -ENOMEM;
goto out_gpio_free;
}
if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
dev_err(&pdev->dev, "request_mem_region failed\n");
ret = -EBUSY;
goto out_gpio_free;
}
spi_imx->base = ioremap(res->start, resource_size(res));
if (!spi_imx->base) {
ret = -EINVAL;
goto out_release_mem;
}
spi_imx->irq = platform_get_irq(pdev, 0);
if (spi_imx->irq < 0) {
ret = -EINVAL;
goto out_iounmap;
}
ret = request_irq(spi_imx->irq, spi_imx_isr, 0, DRIVER_NAME, spi_imx);
if (ret) {
dev_err(&pdev->dev, "can't get irq%d: %d\n", spi_imx->irq, ret);
goto out_iounmap;
}
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl)) {
ret = PTR_ERR(pinctrl);
goto out_free_irq;
}
spi_imx->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
if (IS_ERR(spi_imx->clk_ipg)) {
ret = PTR_ERR(spi_imx->clk_ipg);
goto out_free_irq;
}
spi_imx->clk_per = devm_clk_get(&pdev->dev, "per");
if (IS_ERR(spi_imx->clk_per)) {
ret = PTR_ERR(spi_imx->clk_per);
goto out_free_irq;
}
clk_prepare_enable(spi_imx->clk_per);
clk_prepare_enable(spi_imx->clk_ipg);
spi_imx->spi_clk = clk_get_rate(spi_imx->clk_per);
spi_imx->devtype_data->reset(spi_imx);
spi_imx->devtype_data->intctrl(spi_imx, 0);
master->dev.of_node = pdev->dev.of_node;
ret = spi_bitbang_start(&spi_imx->bitbang);
if (ret) {
dev_err(&pdev->dev, "bitbang start failed with %d\n", ret);
goto out_clk_put;
}
dev_info(&pdev->dev, "probed\n");
return ret;
out_clk_put:
clk_disable_unprepare(spi_imx->clk_per);
clk_disable_unprepare(spi_imx->clk_ipg);
out_free_irq:
free_irq(spi_imx->irq, spi_imx);
out_iounmap:
iounmap(spi_imx->base);
out_release_mem:
release_mem_region(res->start, resource_size(res));
out_gpio_free:
while (--i >= 0) {
if (gpio_is_valid(spi_imx->chipselect[i]))
gpio_free(spi_imx->chipselect[i]);
}
spi_master_put(master);
kfree(master);
platform_set_drvdata(pdev, NULL);
return ret;
}
static int __devinit qt1070_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct qt1070_data *data;
struct input_dev *input;
struct pinctrl *pinctrl;
int i;
int err;
pinctrl = devm_pinctrl_get_select_default(&client->dev);
if (IS_ERR(pinctrl)) {
dev_err(&client->dev, "Failed to request pinctrl\n");
return PTR_ERR(pinctrl);
}
err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
if (!err) {
dev_err(&client->dev, "%s adapter not supported\n",
dev_driver_string(&client->adapter->dev));
return -ENODEV;
}
if (!client->irq) {
dev_err(&client->dev, "please assign the irq to this device\n");
return -EINVAL;
}
/* Identify the qt1070 chip */
if (!qt1070_identify(client))
return -ENODEV;
data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
input = input_allocate_device();
if (!data || !input) {
dev_err(&client->dev, "insufficient memory\n");
err = -ENOMEM;
goto err_free_mem;
}
data->client = client;
data->input = input;
data->irq = client->irq;
input->name = "AT42QT1070 QTouch Sensor";
input->dev.parent = &client->dev;
input->id.bustype = BUS_I2C;
/* Add the keycode */
input->keycode = data->keycodes;
input->keycodesize = sizeof(data->keycodes[0]);
input->keycodemax = ARRAY_SIZE(qt1070_key2code);
__set_bit(EV_KEY, input->evbit);
for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
data->keycodes[i] = qt1070_key2code[i];
__set_bit(qt1070_key2code[i], input->keybit);
}
/* Calibrate device */
qt1070_write(client, CALIBRATE_CMD, 1);
msleep(QT1070_CAL_TIME);
/* Soft reset */
qt1070_write(client, RESET, 1);
msleep(QT1070_RESET_TIME);
err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
IRQF_TRIGGER_NONE | IRQF_ONESHOT,
client->dev.driver->name, data);
if (err) {
dev_err(&client->dev, "fail to request irq\n");
goto err_free_mem;
}
err = device_init_wakeup(&client->dev, true);
if (err)
dev_err(&client->dev, "fail to init device as wakeup source\n");
err = enable_irq_wake(client->irq);
if (err)
dev_err(&client->dev, "fail to enable irq wake\n");
/* Register the input device */
err = input_register_device(data->input);
if (err) {
dev_err(&client->dev, "Failed to register input device\n");
goto err_free_irq;
}
i2c_set_clientdata(client, data);
/* Read to clear the chang line */
qt1070_read(client, DET_STATUS);
return 0;
err_free_irq:
free_irq(client->irq, data);
err_free_mem:
input_free_device(input);
kfree(data);
return err;
}
static int __init w1_gpio_probe(struct platform_device *pdev)
{
struct w1_bus_master *master;
struct w1_gpio_platform_data *pdata;
struct pinctrl *pinctrl;
int err;
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev, "unable to select pin group\n");
if (of_have_populated_dt()) {
err = w1_gpio_probe_dt(pdev);
if (err < 0) {
dev_err(&pdev->dev, "Failed to parse DT\n");
return err;
}
}
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "No configuration data\n");
return -ENXIO;
}
master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL);
if (!master) {
dev_err(&pdev->dev, "Out of memory\n");
return -ENOMEM;
}
err = gpio_request(pdata->pin, "w1");
if (err) {
dev_err(&pdev->dev, "gpio_request (pin) failed\n");
goto free_master;
}
if (gpio_is_valid(pdata->ext_pullup_enable_pin)) {
err = gpio_request_one(pdata->ext_pullup_enable_pin,
GPIOF_INIT_LOW, "w1 pullup");
if (err < 0) {
dev_err(&pdev->dev, "gpio_request_one "
"(ext_pullup_enable_pin) failed\n");
goto free_gpio;
}
}
master->data = pdata;
master->read_bit = w1_gpio_read_bit;
if (pdata->is_open_drain) {
gpio_direction_output(pdata->pin, 1);
master->write_bit = w1_gpio_write_bit_val;
} else {
gpio_direction_input(pdata->pin);
master->write_bit = w1_gpio_write_bit_dir;
}
err = w1_add_master_device(master);
if (err) {
dev_err(&pdev->dev, "w1_add_master device failed\n");
goto free_gpio_ext_pu;
}
if (pdata->enable_external_pullup)
pdata->enable_external_pullup(1);
if (gpio_is_valid(pdata->ext_pullup_enable_pin))
gpio_set_value(pdata->ext_pullup_enable_pin, 1);
platform_set_drvdata(pdev, master);
return 0;
free_gpio_ext_pu:
if (gpio_is_valid(pdata->ext_pullup_enable_pin))
gpio_free(pdata->ext_pullup_enable_pin);
free_gpio:
gpio_free(pdata->pin);
free_master:
kfree(master);
return err;
}
//static struct pinctrl *daudio_pinctrl;
static int __init sunxi_daudio0_dev_probe(struct platform_device *pdev)
{
int ret = 0;
int reg_val = 0;
script_item_u val;
script_item_value_type_e type;
sunxi_daudio.regs = ioremap(SUNXI_DAUDIOBASE, 0x100);
if (sunxi_daudio.regs == NULL) {
return -ENXIO;
}
/*for A80 evb pin config*/
daudio_pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR_OR_NULL(daudio_pinctrl)) {
dev_warn(&pdev->dev,
"pins are not configured from the driver\n");
}
pin_count = script_get_pio_list (TDM_NAME, &pin_daudio0_list);
if (pin_count == 0) {
/* "daudio0" have no pin configuration */
pr_err("daudio0 have no pin configuration\n");
}
#ifdef CONFIG_ARCH_SUN9IW1
/*daudio pll2clk*/
daudio_pll3clk = clk_get(NULL, "pll3");
if ((!daudio_pll3clk)||(IS_ERR(daudio_pll3clk))) {
pr_err("try to get daudio_pll2clk failed\n");
}
if (clk_prepare_enable(daudio_pll3clk)) {
pr_err("enable daudio_pll2clk failed; \n");
}
/*daudio module clk*/
daudio_moduleclk = clk_get(NULL, "cpuri2s1");
if ((!daudio_moduleclk)||(IS_ERR(daudio_moduleclk))) {
pr_err("try to get daudio_moduleclk failed\n");
}
if (clk_set_parent(daudio_moduleclk, daudio_pll3clk)) {
pr_err("try to set parent of daudio_moduleclk to daudio_pll2ck failed! line = %d\n",__LINE__);
}
if (clk_set_rate(daudio_pll3clk, 24576000)) {
pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__);
}
if (clk_prepare_enable(daudio_moduleclk)) {
pr_err("open daudio_moduleclk failed! line = %d\n", __LINE__);
}
#else
#ifdef CONFIG_ARCH_SUN8IW7
daudio_pll = clk_get(NULL, "pll_audio");
if ((!daudio_pll)||(IS_ERR(daudio_pll))) {
pr_err("try to get daudio_pll failed\n");
}
if (clk_prepare_enable(daudio_pll)) {
pr_err("enable daudio_pll2clk failed; \n");
}
/*daudio module clk*/
daudio_moduleclk = clk_get(NULL, "i2s0");
if ((!daudio_moduleclk)||(IS_ERR(daudio_moduleclk))) {
pr_err("try to get daudio_moduleclk failed\n");
}
if (clk_set_parent(daudio_moduleclk, daudio_pll)) {
pr_err("try to set parent of daudio_moduleclk to daudio_pll2ck failed! line = %d\n",__LINE__);
}
if (clk_set_rate(daudio_moduleclk, 24576000)) {
pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__);
}
if (clk_prepare_enable(daudio_moduleclk)) {
pr_err("open daudio_moduleclk failed! line = %d\n", __LINE__);
}
#else
daudio_pllx8 = clk_get(NULL, "pll_audiox8");
if ((!daudio_pllx8)||(IS_ERR(daudio_pllx8))) {
pr_err("try to get daudio_pllx8 failed\n");
}
if (clk_prepare_enable(daudio_pllx8)) {
pr_err("enable daudio_pll2clk failed; \n");
}
/*daudio pll2clk*/
daudio_pll2clk = clk_get(NULL, "pll2");
if ((!daudio_pll2clk)||(IS_ERR(daudio_pll2clk))) {
pr_err("try to get daudio_pll2clk failed\n");
}
if (clk_prepare_enable(daudio_pll2clk)) {
pr_err("enable daudio_pll2clk failed; \n");
}
#ifdef CONFIG_ARCH_SUN8IW8
/*daudio module clk*/
daudio_moduleclk = clk_get(NULL, "i2s0");
#else
//pr_debug("%s,line:%d,0xbc:%x\n",__func__,__LINE__,sunxi_smc_readl(0xf1c200bc));
daudio_moduleclk = clk_get(NULL, "tdm");
#endif
if ((!daudio_moduleclk)||(IS_ERR(daudio_moduleclk))) {
pr_err("try to get daudio_moduleclk failed\n");
}
if (clk_set_parent(daudio_moduleclk, daudio_pll2clk)) {
pr_err("try to set parent of daudio_moduleclk to daudio_pll2ck failed! line = %d\n",__LINE__);
}
#if defined(CONFIG_ARCH_SUN8IW6) || defined(CONFIG_ARCH_SUN8IW8)
//#ifdef CONFIG_ARCH_SUN8IW6
if (clk_set_rate(daudio_moduleclk, 24576000)) {
pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__);
}
#else
if (clk_set_rate(daudio_moduleclk, 24576000/8)) {
pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__);
}
#endif
if (clk_prepare_enable(daudio_moduleclk)) {
pr_err("open daudio_moduleclk failed! line = %d\n", __LINE__);
}
//pr_debug("%s,line:%d,bc:%x\n",__func__,__LINE__,sunxi_smc_readl(0xf1c200bc));
#endif
#endif
reg_val = sunxi_smc_readl(sunxi_daudio.regs + SUNXI_DAUDIOCTL);
reg_val |= SUNXI_DAUDIOCTL_GEN;
sunxi_smc_writel(reg_val, sunxi_daudio.regs + SUNXI_DAUDIOCTL);
type = script_get_item(TDM_NAME, "mclk_fs", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] mclk_fs type err!\n");
}
mclk_fs = val.val;
type = script_get_item(TDM_NAME, "sample_resolution", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] sample_resolution type err!\n");
}
sample_resolution = val.val;
type = script_get_item(TDM_NAME, "slot_width_select", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] slot_width_select type err!\n");
}
slot_width_select = val.val;
type = script_get_item(TDM_NAME, "pcm_lrck_period", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] pcm_lrck_period type err!\n");
}
pcm_lrck_period = val.val;
type = script_get_item(TDM_NAME, "pcm_lrckr_period", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] pcm_lrckr_period type err!\n");
}
pcm_lrckr_period = val.val;
type = script_get_item(TDM_NAME, "msb_lsb_first", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] msb_lsb_first type err!\n");
}
msb_lsb_first = val.val;
type = script_get_item(TDM_NAME, "sign_extend", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] sign_extend type err!\n");
}
sign_extend = val.val;
type = script_get_item(TDM_NAME, "slot_index", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] slot_index type err!\n");
}
slot_index = val.val;
type = script_get_item(TDM_NAME, "frame_width", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] frame_width type err!\n");
}
frame_width = val.val;
type = script_get_item(TDM_NAME, "tx_data_mode", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] tx_data_mode type err!\n");
}
tx_data_mode = val.val;
type = script_get_item(TDM_NAME, "rx_data_mode", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
pr_err("[DAUDIO] rx_data_mode type err!\n");
}
rx_data_mode = val.val;
ret = snd_soc_register_dais(&pdev->dev,sunxi_daudio_dai, ARRAY_SIZE(sunxi_daudio_dai));
if (ret) {
dev_err(&pdev->dev, "Failed to register DAI\n");
}
return 0;
}
static int sunxi_devices_pin_request(struct platform_device *pdev)
{
int mainkey_count;
int mainkey_idx;
struct pinctrl *pinctrl;
/* get main key count */
mainkey_count = script_get_main_key_count();
pr_warn("mainkey total count : %d\n", mainkey_count);
for (mainkey_idx = 0; mainkey_idx < mainkey_count; mainkey_idx++) {
char *mainkey_name;
script_item_u *pin_list;
int pin_count;
char *device_name;
script_item_value_type_e type;
script_item_u item;
script_item_u used;
/* get main key name by index */
mainkey_name = script_get_main_key_name(mainkey_idx);
if (!mainkey_name) {
/* get mainkey name failed */
pr_warn("get mainkey [%s] name failed\n", mainkey_name);
continue;
}
/* get main-key(device) pin configuration */
pin_count = script_get_pio_list(mainkey_name, &pin_list);
pr_warn("mainkey name : %s, pin count : %d\n", mainkey_name, pin_count);
if (pin_count == 0) {
/* mainley have no pin configuration */
continue;
}
/* try to get device name */
type = script_get_item(mainkey_name, "used", &used);
if ((type != SCIRPT_ITEM_VALUE_TYPE_INT) || (used.val == 0)) {
/* this device not used */
continue;
}
/* try to get device name */
type = script_get_item(mainkey_name, "device_name", &item);
if ((type == SCIRPT_ITEM_VALUE_TYPE_STR) && (item.str)) {
/* the mainkey have valid device-name,
* use the config device_name
*/
device_name = item.str;
} else {
/* have no device_name config,
* default use mainkey name as device name
*/
device_name = mainkey_name;
}
/* set device name */
dev_set_name(&(pdev->dev), device_name);
/* request device pinctrl, set as default state */
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR_OR_NULL(pinctrl)) {
pr_warn("request pinctrl handle for device [%s] failed\n",
dev_name(&pdev->dev));
return -EINVAL;
}
pr_warn("device [%s] pinctrl request succeeded\n", device_name);
devices_pinctrl[mainkey_idx] = pinctrl;
}
return 0;
}
static int c_can_plat_probe(struct platform_device *pdev)
{
int ret;
void __iomem *addr;
struct rtcan_device *dev;
struct c_can_priv *priv;
const struct of_device_id *match;
const struct platform_device_id *id;
struct pinctrl *pinctrl;
struct resource *mem, *res;
int irq;
struct clk *clk;
if (pdev->dev.of_node) {
match = of_match_device(c_can_of_table, &pdev->dev);
if (!match) {
dev_err(&pdev->dev, "Failed to find matching dt id\n");
ret = -EINVAL;
goto exit;
}
id = match->data;
} else {
id = platform_get_device_id(pdev);
}
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
if (IS_ERR(pinctrl))
dev_warn(&pdev->dev,
"failed to configure pins from driver\n");
/* get the appropriate clk */
clk = clk_get(&pdev->dev, NULL);
if (IS_ERR(clk)) {
dev_err(&pdev->dev, "no clock defined\n");
ret = -ENODEV;
goto exit;
}
dev_info(&pdev->dev, "setting up step 1: platform_get_resource\n");
/* get the platform data */
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
irq = platform_get_irq(pdev, 0);
if (!mem || irq <= 0) {
ret = -ENODEV;
goto exit_free_clk;
}
dev_info(&pdev->dev, "setting up step 2: request mem region. Start %x, size %d\n", mem->start, resource_size(mem));
if (!request_mem_region(mem->start, resource_size(mem),
"c_can")) {
dev_err(&pdev->dev, "resource unavailable\n");
ret = -ENODEV;
goto exit_free_clk;
}
dev_info(&pdev->dev, "setting up step 3: ioremap. Start %x, size %d\n", mem->start, resource_size(mem));
addr = ioremap(mem->start, resource_size(mem));
if (!addr) {
dev_err(&pdev->dev, "failed to map can port\n");
ret = -ENOMEM;
goto exit_release_mem;
}
dev_info(&pdev->dev, "alloc dev...\n");
/* allocate the c_can device */
dev = alloc_c_can_dev();
if (!dev) {
ret = -ENOMEM;
goto exit_iounmap;
}
priv = rtcan_priv(dev);
switch (id->driver_data) {
case BOSCH_C_CAN:
priv->regs = reg_map_c_can;
switch (mem->flags & IORESOURCE_MEM_TYPE_MASK) {
case IORESOURCE_MEM_32BIT:
priv->read_reg = c_can_plat_read_reg_aligned_to_32bit;
priv->write_reg = c_can_plat_write_reg_aligned_to_32bit;
break;
case IORESOURCE_MEM_16BIT:
default:
priv->read_reg = c_can_plat_read_reg_aligned_to_16bit;
priv->write_reg = c_can_plat_write_reg_aligned_to_16bit;
break;
}
break;
case BOSCH_D_CAN:
priv->regs = reg_map_d_can;
priv->read_reg = c_can_plat_read_reg_aligned_to_16bit;
priv->write_reg = c_can_plat_write_reg_aligned_to_16bit;
if (pdev->dev.of_node)
priv->instance = of_alias_get_id(pdev->dev.of_node, "d_can");
else
priv->instance = pdev->id;
dev_info(&pdev->dev, "platform_get_resource...\n");
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
dev_info(&pdev->dev, "devm request and ioremap..\n");
priv->raminit_ctrlreg = devm_request_and_ioremap(&pdev->dev, res);
if (!priv->raminit_ctrlreg || priv->instance < 0)
dev_info(&pdev->dev, "control memory is not used for raminit\n");
else
priv->raminit = c_can_hw_raminit;
break;
default:
ret = -EINVAL;
goto exit_free_device;
}
priv->irq = irq;
priv->base = addr;
priv->device = &pdev->dev;
priv->priv = clk;
priv->type = id->driver_data;
platform_set_drvdata(pdev, dev);
dev->ctrl_name = c_can_ctrl_name;
dev->board_name = my_board_name;
dev->base_addr = (unsigned long)addr;
dev->can_sys_clock = clk_get_rate(clk);
dev->hard_start_xmit = c_can_start_xmit;
dev->do_set_mode = c_can_set_mode;
dev->do_set_bit_time = c_can_save_bit_time;
dev->bittiming_const = &c_can_bittiming_const;
dev->state = CAN_STATE_STOPPED;
/* Give device an interface name */
strncpy(dev->name, DEV_NAME, IFNAMSIZ);
ret = register_c_candev(dev);
if (ret) {
dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
"c_can", ret);
goto exit_free_device;
}
dev_info(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n",
"c_can", priv->base, priv->irq);
return 0;
exit_free_device:
platform_set_drvdata(pdev, NULL);
exit_iounmap:
iounmap(addr);
exit_release_mem:
release_mem_region(mem->start, resource_size(mem));
exit_free_clk:
clk_put(clk);
exit:
dev_err(&pdev->dev, "probe failed\n");
return ret;
}
