code.vuplus.com Git - vuplus_openembedded/blob - packages/linux/linux-rp-2.6.24/tosa/0006-Add-support-for-t7l66xb-MFD-core.patch

   1 From 2e31fea352ca97988452f1f2c94809de2977ce40 Mon Sep 17 00:00:00 2001
   2 From: Ian Molton <spyro@f2s.com>
   3 Date: Sat, 29 Dec 2007 15:08:52 +0000
   4 Subject: [PATCH 06/64] Add support for t7l66xb MFD core
   5
   6 ---
   7  drivers/mfd/Kconfig         |    6 +
   8  drivers/mfd/Makefile        |    1 +
   9  drivers/mfd/t7l66xb.c       |  550 +++++++++++++++++++++++++++++++++++++++++++
  10  include/linux/mfd/t7l66xb.h |   45 ++++
  11  4 files changed, 602 insertions(+), 0 deletions(-)
  12  create mode 100644 drivers/mfd/t7l66xb.c
  13  create mode 100644 include/linux/mfd/t7l66xb.h
  14
  15 diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
  16 index 1575323..f79a969 100644
  17 --- a/drivers/mfd/Kconfig
  18 +++ b/drivers/mfd/Kconfig
  19 @@ -9,6 +9,12 @@ config MFD_CORE
  20         tristate
  21         default n
  22
  23 +config MFD_T7L66XB
  24 +       bool "Support Toshiba T7L66XB"
  25 +       select MFD_CORE
  26 +       help
  27 +         Support for Toshiba Mobile IO Controller T7L66XB
  28 +
  29  config MFD_TC6387XB
  30         bool "Support Toshiba TC6387XB"
  31         select MFD_CORE
  32 diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
  33 index 41b2190..b2037ae 100644
  34 --- a/drivers/mfd/Makefile
  35 +++ b/drivers/mfd/Makefile
  36 @@ -6,6 +6,7 @@ obj-$(CONFIG_MFD_SM501)         += sm501.o
  37
  38  obj-$(CONFIG_MFD_CORE)         += mfd-core.o
  39
  40 +obj-$(CONFIG_MFD_T7L66XB)      += t7l66xb.o
  41  obj-$(CONFIG_MFD_TC6387XB)     += tc6387xb.o
  42  obj-$(CONFIG_MFD_TC6393XB)     += tc6393xb.o
  43
  44 diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
  45 new file mode 100644
  46 index 0000000..308776a
  47 --- /dev/null
  48 +++ b/drivers/mfd/t7l66xb.c
  49 @@ -0,0 +1,550 @@
  50 +/*
  51 + *
  52 + * Toshiba T7L66XB core mfd support
  53 + *
  54 + * Copyright (c) 2005 Ian Molton
  55 + * Copyright (c) 2007 Ian Molton
  56 + *
  57 + * This program is free software; you can redistribute it and/or modify
  58 + * it under the terms of the GNU General Public License version 2 as
  59 + * published by the Free Software Foundation.
  60 + *
  61 + * T7L66 features:
  62 + *
  63 + * Supported in this driver:
  64 + * SD/MMC
  65 + * SM/NAND flash controller
  66 + * OHCI controller
  67 + *
  68 + * As yet not supported
  69 + * GPIO interface (on NAND pins)
  70 + * Serial interface
  71 + * TFT 'interface converter'
  72 + * PCMCIA interface logic
  73 + */
  74 +
  75 +#include <linux/kernel.h>
  76 +#include <linux/module.h>
  77 +#include <linux/io.h>
  78 +#include <linux/irq.h>
  79 +#include <linux/platform_device.h>
  80 +#include <linux/fb.h>
  81 +#include <linux/mfd-core.h>
  82 +#include <linux/mfd/tmio.h>
  83 +#include <linux/mfd/t7l66xb.h>
  84 +
  85 +union t7l66xb_dev_ctl {
  86 +        u8             raw;
  87 +struct {
  88 +        unsigned        usb_en:1;      /* D0   USB enable   */
  89 +        unsigned        mmc_en:1;      /* D1   MMC enable   */
  90 +} __attribute__ ((packed));
  91 +} __attribute__ ((packed));
  92 +
  93 +
  94 +struct t7l66xb_scr {
  95 +        u8 x00[8];
  96 +        u8      revid;          /* 0x08 Revision ID                     */
  97 +        u8 x01[57];
  98 +        u8      imr;            /* 0x42 Interrupt Mask                  */
  99 +       u8 x03[157];
 100 +        union t7l66xb_dev_ctl     dev_ctl; /* 0xe0 Device control       */
 101 +        u8      isr;            /* 0xe1 Interrupt Status                */
 102 +        u8 x04[14];
 103 +        u8      gpio_output_ctl;    /* 0xf0 */
 104 +        u8      gpio_output_status; /* 0xf1 */
 105 +        u16     gpio_input_status;  /* 0xf2 */
 106 +        u8 x05[4];
 107 +        u8      active_pullup_down_ctl; /* 0xf8 */
 108 +        u8 x06[7];
 109 +} __attribute__ ((packed));
 110 +
 111 +
 112 +/*--------------------------------------------------------------------------*/
 113 +
 114 +struct t7l66xb
 115 +{
 116 +       struct t7l66xb_scr __iomem     *scr;
 117 +       spinlock_t                      lock;
 118 +
 119 +       struct resource                 rscr;
 120 +       struct resource                 *iomem;
 121 +       int                             irq;
 122 +};
 123 +
 124 +/*--------------------------------------------------------------------------*/
 125 +
 126 +static int t7l66xb_ohci_enable(struct platform_device *ohci)
 127 +{
 128 +        struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 129 +        struct t7l66xb                  *t7l66xb = platform_get_drvdata(dev);
 130 +        struct t7l66xb_scr __iomem      *scr    = t7l66xb->scr;
 131 +        unsigned long                   flags;
 132 +       union t7l66xb_dev_ctl           dev_ctl;
 133 +
 134 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 135 +
 136 +        dev_ctl.raw = readb(&scr->dev_ctl);
 137 +        dev_ctl.usb_en = 1;
 138 +        writeb(dev_ctl.raw, &scr->dev_ctl);
 139 +
 140 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 141 +
 142 +        return 0;
 143 +}
 144 +
 145 +static int t7l66xb_ohci_disable(struct platform_device *ohci)
 146 +{
 147 +        struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 148 +        struct t7l66xb                  *t7l66xb = platform_get_drvdata(dev);
 149 +        struct t7l66xb_scr __iomem      *scr    = t7l66xb->scr;
 150 +        unsigned long                   flags;
 151 +        union t7l66xb_dev_ctl           dev_ctl;
 152 +
 153 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 154 +
 155 +        dev_ctl.raw = readb(&scr->dev_ctl);
 156 +        dev_ctl.usb_en = 0;
 157 +        writeb(dev_ctl.raw, &scr->dev_ctl);
 158 +
 159 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 160 +
 161 +        return 0;
 162 +}
 163 +
 164 +/*--------------------------------------------------------------------------*/
 165 +
 166 +static int t7l66xb_mmc_enable(struct platform_device *ohci)
 167 +{
 168 +        struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 169 +        struct t7l66xb_platform_data   *pdata = dev->dev.platform_data;
 170 +        struct t7l66xb                  *t7l66xb = platform_get_drvdata(dev);
 171 +        struct t7l66xb_scr __iomem      *scr    = t7l66xb->scr;
 172 +        unsigned long                   flags;
 173 +       union t7l66xb_dev_ctl           dev_ctl;
 174 +
 175 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 176 +
 177 +        if(pdata->enable_clk32k)
 178 +                pdata->enable_clk32k(dev);
 179 +        dev_ctl.raw = readb(&scr->dev_ctl);
 180 +        dev_ctl.mmc_en = 1;
 181 +        writeb(dev_ctl.raw, &scr->dev_ctl);
 182 +
 183 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 184 +
 185 +        return 0;
 186 +}
 187 +
 188 +static int t7l66xb_mmc_disable(struct platform_device *ohci)
 189 +{
 190 +        struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 191 +        struct t7l66xb_platform_data   *pdata = dev->dev.platform_data;
 192 +        struct t7l66xb                  *t7l66xb = platform_get_drvdata(dev);
 193 +        struct t7l66xb_scr __iomem      *scr    = t7l66xb->scr;
 194 +        unsigned long                   flags;
 195 +        union t7l66xb_dev_ctl           dev_ctl;
 196 +
 197 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 198 +
 199 +        dev_ctl.raw = readb(&scr->dev_ctl);
 200 +        dev_ctl.mmc_en = 0;
 201 +        writeb(dev_ctl.raw, &scr->dev_ctl);
 202 +        if(pdata->disable_clk32k)
 203 +                pdata->disable_clk32k(dev);
 204 +
 205 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 206 +
 207 +        return 0;
 208 +}
 209 +
 210 +/*--------------------------------------------------------------------------*/
 211 +
 212 +static int t7l66xb_nand_disable(struct platform_device *nand)
 213 +{
 214 +        struct platform_device          *dev    = to_platform_device(nand->dev.parent);
 215 +        struct t7l66xb                  *t7l66xb = platform_get_drvdata(dev);
 216 +        struct t7l66xb_scr __iomem      *scr    = t7l66xb->scr;
 217 +        unsigned long                   flags;
 218 +        union t7l66xb_dev_ctl           dev_ctl;
 219 +
 220 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 221 +
 222 +        dev_ctl.raw = readb(&scr->dev_ctl);
 223 +//        dev_ctl.nand_en = 0;
 224 +        writeb(dev_ctl.raw, &scr->dev_ctl);
 225 +
 226 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 227 +
 228 +       return 0;
 229 +}
 230 +
 231 +static int t7l66xb_nand_enable(struct platform_device *nand)
 232 +{
 233 +        struct platform_device          *dev    = to_platform_device(nand->dev.parent);
 234 +        struct t7l66xb                  *t7l66xb = platform_get_drvdata(dev);
 235 +        struct t7l66xb_scr __iomem      *scr    = t7l66xb->scr;
 236 +        unsigned long                   flags;
 237 +        union t7l66xb_dev_ctl           dev_ctl;
 238 +
 239 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 240 +
 241 +        dev_ctl.raw = readb(&scr->dev_ctl);
 242 + //       dev_ctl.nand_en = 1;
 243 +        writeb(dev_ctl.raw, &scr->dev_ctl);
 244 +
 245 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 246 +
 247 +       return 0;
 248 +}
 249 +
 250 +/*--------------------------------------------------------------------------*/
 251 +
 252 +const static struct resource t7l66xb_mmc_resources[] = {
 253 +       {
 254 +               .name = TMIO_MMC_CONTROL,
 255 +               .start = 0x800,
 256 +               .end   = 0x9ff,
 257 +               .flags = IORESOURCE_MEM,
 258 +       },
 259 +       {
 260 +               .name = TMIO_MMC_CONFIG,
 261 +               .start = 0x200,
 262 +               .end   = 0x2ff,
 263 +               .flags = IORESOURCE_MEM,
 264 +       },
 265 +       {
 266 +               .name  = TMIO_MMC_IRQ,
 267 +               .start = IRQ_T7L66XB_MMC,
 268 +               .end   = IRQ_T7L66XB_MMC,
 269 +               .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_MFD_SUBDEVICE,
 270 +       },
 271 +};
 272 +
 273 +const static struct resource t7l66xb_ohci_resources[] = {
 274 +        {
 275 +                .name   = TMIO_OHCI_CONFIG,
 276 +                .start  = 0x0300,
 277 +                .end    = 0x03ff,
 278 +                .flags  = IORESOURCE_MEM,
 279 +        },
 280 +        {
 281 +                .name   = TMIO_OHCI_CONTROL,
 282 +                .start  = 0xa00,
 283 +                .end    = 0xbff,
 284 +                .flags  = IORESOURCE_MEM,
 285 +        },
 286 +        {
 287 +                .name   = TMIO_OHCI_SRAM,
 288 +                .start  = 0x01000,
 289 +                .end    = 0x02fff,
 290 +                .flags  = IORESOURCE_MEM,
 291 +        },
 292 +        {
 293 +                .name   = TMIO_OHCI_IRQ,
 294 +                .start  = IRQ_T7L66XB_OHCI,
 295 +                .end    = IRQ_T7L66XB_OHCI,
 296 +                .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_MFD_SUBDEVICE,
 297 +        },
 298 +};
 299 +
 300 +const static struct resource t7l66xb_nand_resources[] = {
 301 +        {
 302 +                .name   = TMIO_NAND_CONFIG,
 303 +                .start  = 0x0100,
 304 +                .end    = 0x01ff,
 305 +                .flags  = IORESOURCE_MEM,
 306 +        },
 307 +        {
 308 +                .name   = TMIO_NAND_CONTROL,
 309 +                .start  = 0xc00,
 310 +                .end    = 0xc07,
 311 +                .flags  = IORESOURCE_MEM,
 312 +        },
 313 +        {
 314 +                .name   = TMIO_NAND_IRQ,
 315 +                .start  = IRQ_T7L66XB_NAND,
 316 +                .end    = IRQ_T7L66XB_NAND,
 317 +                .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_MFD_SUBDEVICE,
 318 +        },
 319 +};
 320 +
 321 +static struct mfd_cell t7l66xb_cells[] = {
 322 +       {
 323 +               .name = "tmio-mmc",
 324 +               .enable = t7l66xb_mmc_enable,
 325 +               .disable = t7l66xb_mmc_disable,
 326 +               .num_resources = ARRAY_SIZE(t7l66xb_mmc_resources),
 327 +               .resources = t7l66xb_mmc_resources,
 328 +       },
 329 +        {
 330 +                .name = "tmio-ohci",
 331 +                .enable = t7l66xb_ohci_enable,
 332 +                .disable = t7l66xb_ohci_disable,
 333 +                .num_resources = ARRAY_SIZE(t7l66xb_ohci_resources),
 334 +                .resources = t7l66xb_ohci_resources,
 335 +        },
 336 +        {
 337 +                .name = "tmio-nand",
 338 +                .enable = t7l66xb_nand_enable,
 339 +                .disable = t7l66xb_nand_disable,
 340 +                .num_resources = ARRAY_SIZE(t7l66xb_nand_resources),
 341 +                .resources = t7l66xb_nand_resources,
 342 +        },
 343 +};
 344 +
 345 +/*--------------------------------------------------------------------------*/
 346 +
 347 +/* Handle the T7L66XB interrupt mux */
 348 +static void t7l66xb_irq(unsigned int irq, struct irq_desc *desc)
 349 +{
 350 +       struct platform_device         *dev    = get_irq_chip_data(irq);
 351 +       struct t7l66xb_platform_data   *tcpd   = dev->dev.platform_data;
 352 +       struct t7l66xb                 *t7l66xb = platform_get_drvdata(dev);
 353 +       struct t7l66xb_scr __iomem     *scr    = t7l66xb->scr;
 354 +       unsigned int                   isr;
 355 +       unsigned int                   i;
 356 +
 357 +       desc->chip->ack(irq);
 358 +       while ((isr = readb(&scr->isr) & ~readb(&scr->imr)))
 359 +               for (i = 0; i < T7L66XB_NR_IRQS; i++)
 360 +                       if (isr & (1 << i))
 361 +                               desc_handle_irq(tcpd->irq_base + i,
 362 +                                               irq_desc + tcpd->irq_base + i);
 363 +}
 364 +
 365 +static void t7l66xb_irq_mask(unsigned int irq)
 366 +{
 367 +        struct platform_device          *dev    = get_irq_chip_data(irq);
 368 +        struct t7l66xb_platform_data   *tcpd   = dev->dev.platform_data;
 369 +        struct t7l66xb                 *t7l66xb = platform_get_drvdata(dev);
 370 +        struct t7l66xb_scr __iomem     *scr    = t7l66xb->scr;
 371 +        unsigned long                   flags;
 372 +
 373 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 374 +        iowrite8(ioread8(&scr->imr) | (1 << (irq - tcpd->irq_base)),
 375 +                                                                &scr->imr);
 376 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 377 +}
 378 +
 379 +static void t7l66xb_irq_unmask(unsigned int irq)
 380 +{
 381 +        struct platform_device          *dev    = get_irq_chip_data(irq);
 382 +        struct t7l66xb_platform_data   *tcpd   = dev->dev.platform_data;
 383 +        struct t7l66xb                 *t7l66xb = platform_get_drvdata(dev);
 384 +        struct t7l66xb_scr __iomem     *scr    = t7l66xb->scr;
 385 +        unsigned long                   flags;
 386 +
 387 +        spin_lock_irqsave(&t7l66xb->lock, flags);
 388 +        iowrite8(ioread8(&scr->imr) & ~(1 << (irq - tcpd->irq_base)),
 389 +                                                                &scr->imr);
 390 +        spin_unlock_irqrestore(&t7l66xb->lock, flags);
 391 +}
 392 +
 393 +static struct irq_chip t7l66xb_chip = {
 394 +       .name   = "t7l66xb",
 395 +       .ack    = t7l66xb_irq_mask,
 396 +       .mask   = t7l66xb_irq_mask,
 397 +       .unmask = t7l66xb_irq_unmask,
 398 +};
 399 +
 400 +/*--------------------------------------------------------------------------*/
 401 +
 402 +/* Install the IRQ handler */
 403 +static void t7l66xb_attach_irq(struct platform_device *dev)
 404 +{
 405 +       struct t7l66xb_platform_data   *tcpd   = dev->dev.platform_data;
 406 +        struct t7l66xb                 *t7l66xb = platform_get_drvdata(dev);
 407 +        unsigned int                    irq;
 408 +
 409 +        for (
 410 +                        irq = tcpd->irq_base;
 411 +                        irq <= tcpd->irq_base + T7L66XB_NR_IRQS;
 412 +                        irq++) {
 413 +               set_irq_chip (irq, &t7l66xb_chip);
 414 +               set_irq_chip_data (irq, dev);
 415 +               set_irq_handler(irq, handle_level_irq);
 416 +               set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 417 +       }
 418 +
 419 +       set_irq_type (t7l66xb->irq, IRQT_FALLING);
 420 +       set_irq_chip_data (t7l66xb->irq, dev);
 421 +        set_irq_chained_handler (t7l66xb->irq, t7l66xb_irq);
 422 +}
 423 +
 424 +static void t7l66xb_detach_irq(struct platform_device *dev)
 425 +{
 426 +        struct t7l66xb_platform_data   *tcpd   = dev->dev.platform_data;
 427 +        struct t7l66xb                 *t7l66xb = platform_get_drvdata(dev);
 428 +        unsigned int                    irq;
 429 +
 430 +        set_irq_chained_handler(t7l66xb->irq, NULL);
 431 +        set_irq_chip_data(t7l66xb->irq, NULL);
 432 +
 433 +        for (
 434 +                        irq = tcpd->irq_base;
 435 +                        irq <= tcpd->irq_base + T7L66XB_NR_IRQS;
 436 +                        irq++) {
 437 +                set_irq_flags(irq, 0);
 438 +                set_irq_chip(irq, NULL);
 439 +                set_irq_chip_data(irq, NULL);
 440 +        }
 441 +}
 442 +
 443 +/*--------------------------------------------------------------------------*/
 444 +
 445 +#ifdef CONFIG_PM
 446 +static int t7l66xb_suspend(struct platform_device *dev, pm_message_t state)
 447 +{
 448 +       struct t7l66xb_platform_data *pdata = dev->dev.platform_data;
 449 +
 450 +
 451 +       if (pdata && pdata->suspend)
 452 +               pdata->suspend(dev);
 453 +
 454 +       return 0;
 455 +}
 456 +
 457 +static int t7l66xb_resume(struct platform_device *dev)
 458 +{
 459 +       struct t7l66xb_platform_data *pdata = dev->dev.platform_data;
 460 +
 461 +       if (pdata && pdata->resume)
 462 +               pdata->resume(dev);
 463 +
 464 +       return 0;
 465 +}
 466 +#else
 467 +#define t7l66xb_suspend NULL
 468 +#define t7l66xb_resume  NULL
 469 +#endif
 470 +
 471 +/*--------------------------------------------------------------------------*/
 472 +
 473 +static int t7l66xb_probe(struct platform_device *dev)
 474 +{
 475 +       struct t7l66xb_platform_data *pdata = dev->dev.platform_data;
 476 +       struct t7l66xb *t7l66xb;
 477 +       struct resource *iomem;
 478 +       struct resource *rscr;
 479 +       int retval = -ENOMEM;
 480 +
 481 +       iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
 482 +        if (!iomem)
 483 +                return -EINVAL;
 484 +
 485 +       t7l66xb = kzalloc (sizeof *t7l66xb, GFP_KERNEL);
 486 +       if (!t7l66xb)
 487 +               goto err_kzalloc;
 488 +
 489 +       spin_lock_init(&t7l66xb->lock);
 490 +
 491 +       platform_set_drvdata(dev, t7l66xb);
 492 +       t7l66xb->iomem = iomem;
 493 +        t7l66xb->irq   = platform_get_irq(dev, 0);
 494 +
 495 +       rscr            = &t7l66xb->rscr;
 496 +        rscr->name      = "t7l66xb-core";
 497 +        rscr->start     = iomem->start;
 498 +        rscr->end       = iomem->start + 0xff;
 499 +        rscr->flags     = IORESOURCE_MEM;
 500 +
 501 +        if((retval = request_resource(iomem, rscr)))
 502 +                goto err_request_scr;
 503 +
 504 +       t7l66xb->scr   = ioremap(rscr->start, rscr->end - rscr->start + 1);
 505 +        if (!t7l66xb->scr) {
 506 +                retval = -ENOMEM;
 507 +                goto err_ioremap;
 508 +        }
 509 +
 510 +        if (pdata && pdata->enable)
 511 +                pdata->enable(dev);
 512 +
 513 +       writeb(0xbf, &t7l66xb->scr->imr); /* Mask all interrupts */
 514 +
 515 +       printk(KERN_INFO "%s rev %d @ 0x%08lx, irq %d\n",
 516 +              dev->name,  readb(&t7l66xb->scr->revid),
 517 +              (unsigned long)t7l66xb->scr, t7l66xb->irq);
 518 +
 519 +       if(t7l66xb->irq)
 520 +               t7l66xb_attach_irq(dev);
 521 +
 522 +       t7l66xb_cells[2].driver_data = pdata->nand_data;
 523 +
 524 +       if(!(retval = mfd_add_devices(dev, t7l66xb_cells,
 525 +                                     ARRAY_SIZE(t7l66xb_cells),
 526 +                                     iomem, 0, pdata->irq_base)))
 527 +               return 0;
 528 +
 529 +       if(t7l66xb->irq)
 530 +               t7l66xb_detach_irq(dev);
 531 +
 532 +        iounmap(t7l66xb->scr);
 533 +err_ioremap:
 534 +        release_resource(rscr);
 535 +err_request_scr:
 536 +        kfree(t7l66xb);
 537 +err_kzalloc:
 538 +        release_resource(iomem);
 539 +        return retval;
 540 +}
 541 +
 542 +static int t7l66xb_remove(struct platform_device *dev)
 543 +{
 544 +       struct t7l66xb_platform_data   *pdata   = dev->dev.platform_data;
 545 +        struct t7l66xb                 *t7l66xb = platform_get_drvdata(dev);
 546 +        int ret;
 547 +
 548 +        if (t7l66xb->irq)
 549 +                t7l66xb_detach_irq(dev);
 550 +
 551 +        ret = pdata->disable(dev);
 552 +
 553 +        iounmap(t7l66xb->scr);
 554 +        release_resource(&t7l66xb->rscr);
 555 +        release_resource(t7l66xb->iomem);
 556 +
 557 +        mfd_remove_devices(dev);
 558 +
 559 +        platform_set_drvdata(dev, NULL);
 560 +
 561 +        kfree(t7l66xb);
 562 +
 563 +        return ret;
 564 +
 565 +}
 566 +
 567 +static struct platform_driver t7l66xb_platform_driver = {
 568 +       .driver = {
 569 +               .name    = "t7l66xb",
 570 +               .owner   = THIS_MODULE,
 571 +       },
 572 +       .suspend        = t7l66xb_suspend,
 573 +       .resume         = t7l66xb_resume,
 574 +       .probe          = t7l66xb_probe,
 575 +       .remove         = t7l66xb_remove,
 576 +};
 577 +
 578 +/*--------------------------------------------------------------------------*/
 579 +
 580 +static int __init t7l66xb_init(void)
 581 +{
 582 +       int retval = 0;
 583 +
 584 +       retval = platform_driver_register (&t7l66xb_platform_driver);
 585 +       return retval;
 586 +}
 587 +
 588 +static void __exit t7l66xb_exit(void)
 589 +{
 590 +       platform_driver_unregister(&t7l66xb_platform_driver);
 591 +}
 592 +
 593 +module_init(t7l66xb_init);
 594 +module_exit(t7l66xb_exit);
 595 +
 596 +MODULE_DESCRIPTION("Toshiba T7L66XB core driver");
 597 +MODULE_LICENSE("GPLv2");
 598 +MODULE_AUTHOR("Ian Molton");
 599 +
 600 diff --git a/include/linux/mfd/t7l66xb.h b/include/linux/mfd/t7l66xb.h
 601 new file mode 100644
 602 index 0000000..06b8de5
 603 --- /dev/null
 604 +++ b/include/linux/mfd/t7l66xb.h
 605 @@ -0,0 +1,45 @@
 606 +/*
 607 + * linux/include/asm-arm/hardware/t7l66xb.h
 608 + *
 609 + * This file contains the definitions for the T7L66XB
 610 + *
 611 + * (C) Copyright 2005 Ian Molton <spyro@f2s.com>
 612 + *
 613 + * This program is free software; you can redistribute it and/or modify
 614 + * it under the terms of the GNU General Public License version 2 as
 615 + * published by the Free Software Foundation.
 616 + *
 617 + */
 618 +#ifndef _ASM_ARCH_T7L66XB_SOC
 619 +#define _ASM_ARCH_T7L66XB_SOC
 620 +
 621 +#include <linux/mfd-core.h>
 622 +#include <linux/mfd/tmio.h>
 623 +
 624 +
 625 +struct t7l66xb_platform_data
 626 +{
 627 +        int (*enable_clk32k)(struct platform_device *dev);
 628 +        int (*disable_clk32k)(struct platform_device *dev);
 629 +
 630 +       int     (*enable)(struct platform_device *dev);
 631 +       int     (*disable)(struct platform_device *dev);
 632 +       int     (*suspend)(struct platform_device *dev);
 633 +       int     (*resume)(struct platform_device *dev);
 634 +
 635 +       int     irq_base;       /* a base for cascaded irq */
 636 +
 637 +       struct tmio_nand_data   *nand_data;
 638 +};
 639 +
 640 +
 641 +#define T7L66XB_NAND_CNF_BASE  (0x000100)
 642 +#define T7L66XB_NAND_CTL_BASE  (0x001000)
 643 +
 644 +#define IRQ_T7L66XB_NAND       (3)
 645 +#define IRQ_T7L66XB_MMC        (1)
 646 +#define IRQ_T7L66XB_OHCI       (2)
 647 +
 648 +#define T7L66XB_NR_IRQS        8
 649 +
 650 +#endif
 651 --
 652 1.5.3.8
 653