mfd: update TMIO drivers to use the clock API

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

This patch updates the remaining two TMIO drivers to use the clock API
rather than callback hooks into platform code.

Signed-off-by: Ian Molton <spyro@f2s.com>
Signed-off-by: Samuel Ortiz <sameo@openedhand.com>

authored by

Ian Molton and committed by

Samuel Ortiz 17 years ago 7acb706c 9297a0e7

+61 -31

4 changed files

expand all

drivers

mfd

t7l66xb.c

tc6387xb.c

include

linux

mfd

t7l66xb.h

tc6387xb.h

+32 -8

drivers/mfd/t7l66xb.c

··· 24 24 25 25 #include <linux/kernel.h> 26 26 #include <linux/module.h> 27 + #include <linux/err.h> 27 28 #include <linux/io.h> 28 29 #include <linux/irq.h> 30 + #include <linux/clk.h> 29 31 #include <linux/platform_device.h> 30 32 #include <linux/mfd/core.h> 31 33 #include <linux/mfd/tmio.h> ··· 58 56 spinlock_t lock; 59 57 60 58 struct resource rscr; 59 + struct clk *clk48m; 60 + struct clk *clk32k; 61 61 int irq; 62 62 int irq_base; 63 63 }; ··· 69 65 static int t7l66xb_mmc_enable(struct platform_device *mmc) 70 66 { 71 67 struct platform_device *dev = to_platform_device(mmc->dev.parent); 72 - struct t7l66xb_platform_data *pdata = dev->dev.platform_data; 73 68 struct t7l66xb *t7l66xb = platform_get_drvdata(dev); 74 69 unsigned long flags; 75 70 u8 dev_ctl; 76 71 77 - if (pdata->enable_clk32k) 78 - pdata->enable_clk32k(dev); 72 + clk_enable(t7l66xb->clk32k); 79 73 80 74 spin_lock_irqsave(&t7l66xb->lock, flags); 81 75 ··· 89 87 static int t7l66xb_mmc_disable(struct platform_device *mmc) 90 88 { 91 89 struct platform_device *dev = to_platform_device(mmc->dev.parent); 92 - struct t7l66xb_platform_data *pdata = dev->dev.platform_data; 93 90 struct t7l66xb *t7l66xb = platform_get_drvdata(dev); 94 91 unsigned long flags; 95 92 u8 dev_ctl; ··· 101 100 102 101 spin_unlock_irqrestore(&t7l66xb->lock, flags); 103 102 104 - if (pdata->disable_clk32k) 105 - pdata->disable_clk32k(dev); 103 + clk_disable(t7l66xb->clk32k); 106 104 107 105 return 0; 108 106 } ··· 258 258 #ifdef CONFIG_PM 259 259 static int t7l66xb_suspend(struct platform_device *dev, pm_message_t state) 260 260 { 261 + struct t7l66xb *t7l66xb = platform_get_drvdata(dev); 261 262 struct t7l66xb_platform_data *pdata = dev->dev.platform_data; 262 263 263 264 if (pdata && pdata->suspend) 264 265 pdata->suspend(dev); 266 + clk_disable(t7l66xb->clk48m); 265 267 266 268 return 0; 267 269 } 268 270 269 271 static int t7l66xb_resume(struct platform_device *dev) 270 272 { 273 + struct t7l66xb *t7l66xb = platform_get_drvdata(dev); 271 274 struct t7l66xb_platform_data *pdata = dev->dev.platform_data; 272 275 276 + clk_enable(t7l66xb->clk48m); 273 277 if (pdata && pdata->resume) 274 278 pdata->resume(dev); 275 279 ··· 313 309 314 310 t7l66xb->irq_base = pdata->irq_base; 315 311 312 + t7l66xb->clk32k = clk_get(&dev->dev, "CLK_CK32K"); 313 + if (IS_ERR(t7l66xb->clk32k)) { 314 + ret = PTR_ERR(t7l66xb->clk32k); 315 + goto err_clk32k_get; 316 + } 317 + 318 + t7l66xb->clk48m = clk_get(&dev->dev, "CLK_CK48M"); 319 + if (IS_ERR(t7l66xb->clk48m)) { 320 + ret = PTR_ERR(t7l66xb->clk48m); 321 + clk_put(t7l66xb->clk32k); 322 + goto err_clk48m_get; 323 + } 324 + 316 325 rscr = &t7l66xb->rscr; 317 326 rscr->name = "t7l66xb-core"; 318 327 rscr->start = iomem->start; ··· 341 324 ret = -ENOMEM; 342 325 goto err_ioremap; 343 326 } 327 + 328 + clk_enable(t7l66xb->clk48m); 344 329 345 330 if (pdata && pdata->enable) 346 331 pdata->enable(dev); ··· 378 359 iounmap(t7l66xb->scr); 379 360 err_ioremap: 380 361 release_resource(&t7l66xb->rscr); 381 - err_noirq: 382 362 err_request_scr: 383 363 kfree(t7l66xb); 364 + clk_put(t7l66xb->clk48m); 365 + err_clk48m_get: 366 + clk_put(t7l66xb->clk32k); 367 + err_clk32k_get: 368 + err_noirq: 384 369 return ret; 385 370 } 386 371 ··· 395 372 int ret; 396 373 397 374 ret = pdata->disable(dev); 398 - 375 + clk_disable(t7l66xb->clk48m); 376 + clk_put(t7l66xb->clk48m); 399 377 t7l66xb_detach_irq(dev); 400 378 iounmap(t7l66xb->scr); 401 379 release_resource(&t7l66xb->rscr);

+29 -18

drivers/mfd/tc6387xb.c

··· 12 12 13 13 #include <linux/module.h> 14 14 #include <linux/platform_device.h> 15 + #include <linux/clk.h> 15 16 #include <linux/err.h> 16 17 #include <linux/mfd/core.h> 17 18 #include <linux/mfd/tmio.h> ··· 25 24 #ifdef CONFIG_PM 26 25 static int tc6387xb_suspend(struct platform_device *dev, pm_message_t state) 27 26 { 28 - struct tc6387xb_platform_data *pdata = platform_get_drvdata(dev); 27 + struct clk *clk32k = platform_get_drvdata(dev); 28 + struct tc6387xb_platform_data *pdata = dev->dev.platform_data; 29 29 30 30 if (pdata && pdata->suspend) 31 31 pdata->suspend(dev); 32 + clk_disable(clk32k); 32 33 33 34 return 0; 34 35 } 35 36 36 37 static int tc6387xb_resume(struct platform_device *dev) 37 38 { 38 - struct tc6387xb_platform_data *pdata = platform_get_drvdata(dev); 39 + struct clk *clk32k = platform_get_drvdata(dev); 40 + struct tc6387xb_platform_data *pdata = dev->dev.platform_data; 39 41 42 + clk_enable(clk32k); 40 43 if (pdata && pdata->resume) 41 44 pdata->resume(dev); 42 45 ··· 56 51 static int tc6387xb_mmc_enable(struct platform_device *mmc) 57 52 { 58 53 struct platform_device *dev = to_platform_device(mmc->dev.parent); 59 - struct tc6387xb_platform_data *tc6387xb = dev->dev.platform_data; 54 + struct clk *clk32k = platform_get_drvdata(dev); 60 55 61 - if (tc6387xb->enable_clk32k) 62 - tc6387xb->enable_clk32k(dev); 56 + clk_enable(clk32k); 63 57 64 58 return 0; 65 59 } ··· 66 62 static int tc6387xb_mmc_disable(struct platform_device *mmc) 67 63 { 68 64 struct platform_device *dev = to_platform_device(mmc->dev.parent); 69 - struct tc6387xb_platform_data *tc6387xb = dev->dev.platform_data; 65 + struct clk *clk32k = platform_get_drvdata(dev); 70 66 71 - if (tc6387xb->disable_clk32k) 72 - tc6387xb->disable_clk32k(dev); 67 + clk_disable(clk32k); 73 68 74 69 return 0; 75 70 } ··· 105 102 106 103 static int tc6387xb_probe(struct platform_device *dev) 107 104 { 108 - struct tc6387xb_platform_data *data = platform_get_drvdata(dev); 105 + struct tc6387xb_platform_data *pdata = dev->dev.platform_data; 109 106 struct resource *iomem; 107 + struct clk *clk32k; 110 108 int irq, ret; 111 109 112 110 iomem = platform_get_resource(dev, IORESOURCE_MEM, 0); 113 111 if (!iomem) { 114 - ret = -EINVAL; 115 - goto err_resource; 112 + return -EINVAL; 116 113 } 117 114 118 115 ret = platform_get_irq(dev, 0); ··· 121 118 else 122 119 goto err_resource; 123 120 124 - if (data && data->enable) 125 - data->enable(dev); 121 + clk32k = clk_get(&dev->dev, "CLK_CK32K"); 122 + if (IS_ERR(clk32k)) { 123 + ret = PTR_ERR(clk32k); 124 + goto err_resource; 125 + } 126 + platform_set_drvdata(dev, clk32k); 127 + 128 + if (pdata && pdata->enable) 129 + pdata->enable(dev); 126 130 127 131 printk(KERN_INFO "Toshiba tc6387xb initialised\n"); 128 132 ··· 144 134 if (!ret) 145 135 return 0; 146 136 137 + clk_put(clk32k); 147 138 err_resource: 148 139 return ret; 149 140 } 150 141 151 142 static int tc6387xb_remove(struct platform_device *dev) 152 143 { 153 - struct tc6387xb_platform_data *data = platform_get_drvdata(dev); 144 + struct clk *clk32k = platform_get_drvdata(dev); 154 145 155 - if (data && data->disable) 156 - data->disable(dev); 157 - 158 - /* FIXME - free the resources! */ 146 + mfd_remove_devices(&dev->dev); 147 + clk_disable(clk32k); 148 + clk_put(clk32k); 149 + platform_set_drvdata(dev, NULL); 159 150 160 151 return 0; 161 152 }

-2

include/linux/mfd/t7l66xb.h

··· 15 15 #include <linux/mfd/tmio.h> 16 16 17 17 struct t7l66xb_platform_data { 18 - int (*enable_clk32k)(struct platform_device *dev); 19 - void (*disable_clk32k)(struct platform_device *dev); 20 18 int (*enable)(struct platform_device *dev); 21 19 int (*disable)(struct platform_device *dev); 22 20 int (*suspend)(struct platform_device *dev);

-3

include/linux/mfd/tc6387xb.h

··· 11 11 #define MFD_TC6387XB_H 12 12 13 13 struct tc6387xb_platform_data { 14 - int (*enable_clk32k)(struct platform_device *dev); 15 - void (*disable_clk32k)(struct platform_device *dev); 16 - 17 14 int (*enable)(struct platform_device *dev); 18 15 int (*disable)(struct platform_device *dev); 19 16 int (*suspend)(struct platform_device *dev);