Pandora Sourcecodes - openembedded.git/blob

   1 From c18b8e34c39ec0d395988318e6651076a748d6bd Mon Sep 17 00:00:00 2001
   2 From: Dmitry Baryshkov <dbaryshkov@gmail.com>
   3 Date: Tue, 12 Feb 2008 04:40:54 +0300
   4 Subject: [PATCH 47/64] tc6393xb: use bitmasks instead of bit-field structs
   5
   6 Signed-off-by: Dmitry Baryshkov <dbaryshkov@gmail.com>
   7 ---
   8  drivers/mfd/tc6393xb.c       |  162 ++++++++++++++++++++++++-----------------
   9  include/linux/mfd/tc6393xb.h |   63 +++-------------
  10  2 files changed, 107 insertions(+), 118 deletions(-)
  11
  12 diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
  13 index dfae61d..1a394e4 100644
  14 --- a/drivers/mfd/tc6393xb.c
  15 +++ b/drivers/mfd/tc6393xb.c
  16 @@ -24,6 +24,31 @@
  17  #include <linux/mfd/tmio.h>
  18  #include <linux/mfd/tc6393xb.h>
  19
  20 +#define TC6393XB_FER_USBEN             BIT(0)  /* USB host enable */
  21 +#define TC6393XB_FER_LCDCVEN           BIT(1)  /* polysilicon TFT enable */
  22 +#define TC6393XB_FER_SLCDEN            BIT(2)  /* SLCD enable */
  23 +
  24 +enum pincontrol {
  25 +       opendrain       = 0,
  26 +       tristate        = 1,
  27 +       pushpull        = 2,
  28 +       /* reserved     = 3, */
  29 +};
  30 +
  31 +#define TC6393XB_MCR_RDY_MASK          (3 << 0)
  32 +#define TC6393XB_MCR_RDY_OPENDRAIN     (0 << 0)
  33 +#define TC6393XB_MCR_RDY_TRISTATE      (1 << 0)
  34 +#define TC6393XB_MCR_RDY_PUSHPULL      (2 << 0)
  35 +#define TC6393XB_MCR_RDY_UNK           BIT(2)
  36 +#define TC6393XB_MCR_RDY_EN            BIT(3)
  37 +#define TC6393XB_MCR_INT_MASK          (3 << 4)
  38 +#define TC6393XB_MCR_INT_OPENDRAIN     (0 << 4)
  39 +#define TC6393XB_MCR_INT_TRISTATE      (1 << 4)
  40 +#define TC6393XB_MCR_INT_PUSHPULL      (2 << 4)
  41 +#define TC6393XB_MCR_INT_UNK           BIT(6)
  42 +#define TC6393XB_MCR_INT_EN            BIT(7)
  43 +/* bits 8 - 16 are unknown */
  44 +
  45  struct tc6393xb_scr {
  46         u8 x00[8];
  47         u8      revid;          /* 0x08 Revision ID                     */
  48 @@ -74,8 +99,8 @@ struct tc6393xb {
  49         spinlock_t                      lock; /* protects RMW cycles */
  50
  51         struct {
  52 -               union tc6393xb_scr_fer  fer;
  53 -               union tc6393xb_scr_ccr  ccr;
  54 +               u8                      fer;
  55 +               u16                     ccr;
  56                 u8                      gpi_bcr[4];
  57         } suspend_state;
  58
  59 @@ -90,13 +115,13 @@ static int tc6393xb_mmc_enable(struct platform_device *mmc) {
  60         struct platform_device          *dev    = to_platform_device(mmc->dev.parent);
  61         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
  62         struct tc6393xb_scr __iomem     *scr = tc6393xb->scr;
  63 -       union tc6393xb_scr_ccr          ccr;
  64 +       u16                             ccr;
  65         unsigned long                   flags;
  66
  67         spin_lock_irqsave(&tc6393xb->lock, flags);
  68 -       ccr.raw = ioread16(&scr->ccr);
  69 -       ccr.bits.ck32ken = 1;
  70 -       iowrite16(ccr.raw, &scr->ccr);
  71 +       ccr = ioread16(&scr->ccr);
  72 +       ccr |= TC6393XB_CCR_CK32K;
  73 +       iowrite16(ccr, &scr->ccr);
  74         spin_unlock_irqrestore(&tc6393xb->lock, flags);
  75
  76         return 0;
  77 @@ -106,13 +131,13 @@ static int tc6393xb_mmc_disable(struct platform_device *mmc) {
  78         struct platform_device          *dev    = to_platform_device(mmc->dev.parent);
  79         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
  80         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
  81 -       union tc6393xb_scr_ccr          ccr;
  82 +       u16                             ccr;
  83         unsigned long                   flags;
  84
  85         spin_lock_irqsave(&tc6393xb->lock, flags);
  86 -       ccr.raw = ioread16(&scr->ccr);
  87 -       ccr.bits.ck32ken = 0;
  88 -       iowrite16(ccr.raw, &scr->ccr);
  89 +       ccr = ioread16(&scr->ccr);
  90 +       ccr &= ~TC6393XB_CCR_CK32K;
  91 +       iowrite16(ccr, &scr->ccr);
  92         spin_unlock_irqrestore(&tc6393xb->lock, flags);
  93
  94         return 0;
  95 @@ -148,14 +173,17 @@ int tc6393xb_lcd_set_power(struct platform_device *fb, bool on)
  96         struct platform_device          *dev    = to_platform_device(fb->dev.parent);
  97         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
  98         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
  99 -       union tc6393xb_scr_fer          fer;
 100 +       u8                              fer;
 101         unsigned long                   flags;
 102
 103         spin_lock_irqsave(&tc6393xb->lock, flags);
 104
 105 -       fer.raw = ioread8(&scr->fer);
 106 -       fer.bits.slcden = on ? 1 : 0;
 107 -       iowrite8(fer.raw, &scr->fer);
 108 +       fer = ioread8(&scr->fer);
 109 +       if (on)
 110 +               fer |= TC6393XB_FER_SLCDEN;
 111 +       else
 112 +               fer &= ~TC6393XB_FER_SLCDEN;
 113 +       iowrite8(fer, &scr->fer);
 114
 115         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 116
 117 @@ -181,19 +209,19 @@ static int tc6393xb_ohci_disable(struct platform_device *ohci)
 118         struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 119         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 120         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 121 -       union tc6393xb_scr_ccr          ccr;
 122 -       union tc6393xb_scr_fer          fer;
 123 +       u16                             ccr;
 124 +       u8                              fer;
 125         unsigned long                   flags;
 126
 127         spin_lock_irqsave(&tc6393xb->lock, flags);
 128
 129 -       fer.raw = ioread8(&scr->fer);
 130 -       fer.bits.usben = 0;
 131 -       iowrite8(fer.raw, &scr->fer);
 132 +       fer = ioread8(&scr->fer);
 133 +       fer &= ~TC6393XB_FER_USBEN;
 134 +       iowrite8(fer, &scr->fer);
 135
 136 -       ccr.raw = ioread16(&scr->ccr);
 137 -       ccr.bits.usbcken = 0;
 138 -       iowrite16(ccr.raw, &scr->ccr);
 139 +       ccr = ioread16(&scr->ccr);
 140 +       ccr &= ~TC6393XB_CCR_USBCK;
 141 +       iowrite16(ccr, &scr->ccr);
 142
 143         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 144
 145 @@ -205,19 +233,19 @@ static int tc6393xb_ohci_enable(struct platform_device *ohci)
 146         struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 147         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 148         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 149 -       union tc6393xb_scr_ccr          ccr;
 150 -       union tc6393xb_scr_fer          fer;
 151 +       u16                             ccr;
 152 +       u8                              fer;
 153         unsigned long                   flags;
 154
 155         spin_lock_irqsave(&tc6393xb->lock, flags);
 156
 157 -       ccr.raw = ioread16(&scr->ccr);
 158 -       ccr.bits.usbcken = 1;
 159 -       iowrite16(ccr.raw, &scr->ccr);
 160 +       ccr = ioread16(&scr->ccr);
 161 +       ccr |= TC6393XB_CCR_USBCK;
 162 +       iowrite16(ccr, &scr->ccr);
 163
 164 -       fer.raw = ioread8(&scr->fer);
 165 -       fer.bits.usben = 1;
 166 -       iowrite8(fer.raw, &scr->fer);
 167 +       fer = ioread8(&scr->fer);
 168 +       fer |= TC6393XB_FER_USBEN;
 169 +       iowrite8(fer, &scr->fer);
 170
 171         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 172
 173 @@ -229,14 +257,14 @@ static int tc6393xb_ohci_suspend(struct platform_device *ohci)
 174         struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 175         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 176         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 177 -       union tc6393xb_scr_ccr          ccr;
 178 +       u16                             ccr;
 179         unsigned long                   flags;
 180
 181         spin_lock_irqsave(&tc6393xb->lock, flags);
 182
 183 -       ccr.raw = ioread16(&scr->ccr);
 184 -       ccr.bits.usbcken = 0;
 185 -       iowrite16(ccr.raw, &scr->ccr);
 186 +       ccr = ioread16(&scr->ccr);
 187 +       ccr &= ~TC6393XB_CCR_USBCK;
 188 +       iowrite16(ccr, &scr->ccr);
 189
 190         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 191
 192 @@ -248,14 +276,14 @@ static int tc6393xb_ohci_resume(struct platform_device *ohci)
 193         struct platform_device          *dev    = to_platform_device(ohci->dev.parent);
 194         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 195         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 196 -       union tc6393xb_scr_ccr          ccr;
 197 +       u16                             ccr;
 198         unsigned long                   flags;
 199
 200         spin_lock_irqsave(&tc6393xb->lock, flags);
 201
 202 -       ccr.raw = ioread16(&scr->ccr);
 203 -       ccr.bits.usbcken = 1;
 204 -       iowrite16(ccr.raw, &scr->ccr);
 205 +       ccr = ioread16(&scr->ccr);
 206 +       ccr |= TC6393XB_CCR_USBCK;
 207 +       iowrite16(ccr, &scr->ccr);
 208
 209         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 210
 211 @@ -267,8 +295,8 @@ static int tc6393xb_fb_disable(struct platform_device *fb)
 212         struct platform_device          *dev    = to_platform_device(fb->dev.parent);
 213         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 214         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 215 -       union tc6393xb_scr_ccr          ccr;
 216 -       union tc6393xb_scr_fer          fer;
 217 +       u16                             ccr;
 218 +       u8                              fer;
 219         unsigned long                   flags;
 220
 221         spin_lock_irqsave(&tc6393xb->lock, flags);
 222 @@ -276,14 +304,13 @@ static int tc6393xb_fb_disable(struct platform_device *fb)
 223         /*
 224          * FIXME: is this correct or it should be moved to other _disable?
 225          */
 226 -       fer.raw = ioread8(&scr->fer);
 227 -       fer.bits.slcden = 0;
 228 -/*     fer.bits.lcdcven = 0; */
 229 -       iowrite8(fer.raw, &scr->fer);
 230 +       fer = ioread8(&scr->fer);
 231 +       fer &= ~TC6393XB_FER_SLCDEN;
 232 +       iowrite8(fer, &scr->fer);
 233
 234 -       ccr.raw = ioread16(&scr->ccr);
 235 -       ccr.bits.mclksel = disable;
 236 -       iowrite16(ccr.raw, &scr->ccr);
 237 +       ccr = ioread16(&scr->ccr);
 238 +       ccr = (ccr & ~TC6393XB_CCR_MCLK_MASK) | TC6393XB_CCR_MCLK_OFF;
 239 +       iowrite16(ccr, &scr->ccr);
 240
 241         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 242
 243 @@ -295,14 +322,14 @@ static int tc6393xb_fb_enable(struct platform_device *fb)
 244         struct platform_device          *dev    = to_platform_device(fb->dev.parent);
 245         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 246         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 247 -       union tc6393xb_scr_ccr          ccr;
 248 +       u16                             ccr;
 249         unsigned long                   flags;
 250
 251         spin_lock_irqsave(&tc6393xb->lock, flags);
 252
 253 -       ccr.raw = ioread16(&scr->ccr);
 254 -       ccr.bits.mclksel = m48MHz;
 255 -       iowrite16(ccr.raw, &scr->ccr);
 256 +       ccr = ioread16(&scr->ccr);
 257 +       ccr = (ccr & ~TC6393XB_CCR_MCLK_MASK) | TC6393XB_CCR_MCLK_48;
 258 +       iowrite16(ccr, &scr->ccr);
 259
 260         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 261
 262 @@ -314,14 +341,14 @@ static int tc6393xb_fb_suspend(struct platform_device *fb)
 263         struct platform_device          *dev    = to_platform_device(fb->dev.parent);
 264         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 265         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 266 -       union tc6393xb_scr_ccr          ccr;
 267 +       u16                             ccr;
 268         unsigned long                   flags;
 269
 270         spin_lock_irqsave(&tc6393xb->lock, flags);
 271
 272 -       ccr.raw = ioread16(&scr->ccr);
 273 -       ccr.bits.mclksel = disable;
 274 -       iowrite16(ccr.raw, &scr->ccr);
 275 +       ccr = ioread16(&scr->ccr);
 276 +       ccr = (ccr & ~TC6393XB_CCR_MCLK_MASK) | TC6393XB_CCR_MCLK_OFF;
 277 +       iowrite16(ccr, &scr->ccr);
 278
 279         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 280
 281 @@ -333,14 +360,14 @@ static int tc6393xb_fb_resume(struct platform_device *fb)
 282         struct platform_device          *dev    = to_platform_device(fb->dev.parent);
 283         struct tc6393xb                 *tc6393xb = platform_get_drvdata(dev);
 284         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 285 -       union tc6393xb_scr_ccr          ccr;
 286 +       u16                             ccr;
 287         unsigned long                   flags;
 288
 289         spin_lock_irqsave(&tc6393xb->lock, flags);
 290
 291 -       ccr.raw = ioread16(&scr->ccr);
 292 -       ccr.bits.mclksel = m48MHz;
 293 -       iowrite16(ccr.raw, &scr->ccr);
 294 +       ccr = ioread16(&scr->ccr);
 295 +       ccr = (ccr & ~TC6393XB_CCR_MCLK_MASK) | TC6393XB_CCR_MCLK_48;
 296 +       iowrite16(ccr, &scr->ccr);
 297
 298         spin_unlock_irqrestore(&tc6393xb->lock, flags);
 299
 300 @@ -592,14 +619,15 @@ static int tc6393xb_hw_init(struct platform_device *dev, int resume)
 301         struct tc6393xb_scr __iomem     *scr    = tc6393xb->scr;
 302         int                             i;
 303
 304 -       iowrite8(resume ?
 305 -               tc6393xb->suspend_state.fer.raw :
 306 -               0,                              &scr->fer);
 307 +       iowrite8(resume ? tc6393xb->suspend_state.fer : 0,
 308 +                                               &scr->fer);
 309         iowrite16(tcpd->scr_pll2cr,             &scr->pll2cr);
 310         iowrite16(resume?
 311 -               tc6393xb->suspend_state.ccr.raw :
 312 -               tcpd->scr_ccr.raw,              &scr->ccr);
 313 -       iowrite16(tcpd->scr_mcr.raw,            &scr->mcr);
 314 +               tc6393xb->suspend_state.ccr :
 315 +               tcpd->scr_ccr,          &scr->ccr);
 316 +       iowrite16(TC6393XB_MCR_RDY_OPENDRAIN | TC6393XB_MCR_RDY_UNK | TC6393XB_MCR_RDY_EN |
 317 +                 TC6393XB_MCR_INT_OPENDRAIN | TC6393XB_MCR_INT_UNK | TC6393XB_MCR_INT_EN |
 318 +                 BIT(15),              &scr->mcr);
 319         iowrite16(tcpd->scr_gper,               &scr->gper);
 320         iowrite8(0,                             &scr->irr);
 321         iowrite8(0xbf,                          &scr->imr);
 322 @@ -730,8 +758,8 @@ static int tc6393xb_suspend(struct platform_device *dev, pm_message_t state)
 323         int i;
 324
 325
 326 -       tc6393xb->suspend_state.ccr.raw         = ioread16(&scr->ccr);
 327 -       tc6393xb->suspend_state.fer.raw         = ioread8(&scr->fer);
 328 +       tc6393xb->suspend_state.ccr             = ioread16(&scr->ccr);
 329 +       tc6393xb->suspend_state.fer             = ioread8(&scr->fer);
 330         for (i = 0; i < 4; i++)
 331                 tc6393xb->suspend_state.gpi_bcr[i] =
 332                         ioread8(scr->gpi_bcr + i);
 333 diff --git a/include/linux/mfd/tc6393xb.h b/include/linux/mfd/tc6393xb.h
 334 index e699294..2c69f63 100644
 335 --- a/include/linux/mfd/tc6393xb.h
 336 +++ b/include/linux/mfd/tc6393xb.h
 337 @@ -20,60 +20,21 @@
 338  #include <linux/mfd-core.h>
 339  #include <linux/mfd/tmio.h>
 340
 341 -union tc6393xb_scr_fer {
 342 -       u8              raw;
 343 -struct {
 344 -       unsigned        usben:1;        /* D0   USB enable              */
 345 -       unsigned        lcdcven:1;      /* D1   polysylicon TFT enable  */
 346 -       unsigned        slcden:1;       /* D2   SLCD enable             */
 347 -} __attribute__ ((packed)) bits;
 348 -} __attribute__ ((packed));
 349 -
 350 -union tc6393xb_scr_ccr {
 351 -       u16             raw;
 352 -struct {
 353 -       unsigned        ck32ken:1;      /* D0   SD host clock enable    */
 354 -       unsigned        usbcken:1;      /* D1   USB host clock enable   */
 355 -       unsigned        x00:2;
 356 -       unsigned        sharp:1;        /* D4   ??? set in Sharp's code */
 357 -       unsigned        x01:3;
 358 -       enum {                          disable = 0,
 359 -                                       m12MHz  = 1,
 360 -                                       m24MHz  = 2,
 361 -                                       m48MHz  = 3,
 362 -       }               mclksel:3;      /* D10-D8  LCD controller clock */
 363 -       unsigned        x02:1;
 364 -       enum {                          h24MHz  = 0,
 365 -                                       h48MHz  = 1,
 366 -       }               hclksel:2;      /* D13-D12 host bus clock       */
 367 -       unsigned        x03:2;
 368 -} __attribute__ ((packed)) bits;
 369 -} __attribute__ ((packed));
 370 -
 371 -enum pincontrol {
 372 -       opendrain       = 0,
 373 -       tristate        = 1,
 374 -       pushpull        = 2,
 375 -       /* reserved     = 3, */
 376 -};
 377 -
 378 -union tc6393xb_scr_mcr {
 379 -       u16             raw;
 380 -struct {
 381 -       enum pincontrol rdyst:2;        /* D1-D0   HRDY control         */
 382 -       unsigned        x00:1;
 383 -       unsigned        aren:1;         /* D3      HRDY pull up resistance cut off */
 384 -       enum pincontrol intst:2;        /* D5-D4   #HINT control        */
 385 -       unsigned        x01:1;
 386 -       unsigned        aien:1;         /* D7      #HINT pull up resitance cut off */
 387 -       unsigned        x02:8;
 388 -} __attribute__ ((packed)) bits;
 389 -} __attribute__ ((packed));
 390 +#define TC6393XB_CCR_CK32K     BIT(0)
 391 +#define TC6393XB_CCR_USBCK     BIT(1)
 392 +#define TC6393XB_CCR_UNK1      BIT(4)
 393 +#define TC6393XB_CCR_MCLK_MASK (7 << 8)
 394 +#define TC6393XB_CCR_MCLK_OFF  (0 << 8)
 395 +#define TC6393XB_CCR_MCLK_12   (1 << 8)
 396 +#define TC6393XB_CCR_MCLK_24   (2 << 8)
 397 +#define TC6393XB_CCR_MCLK_48   (3 << 8)
 398 +#define TC6393XB_CCR_HCLK_MASK (3 << 12)
 399 +#define TC6393XB_CCR_HCLK_24   (0 << 12)
 400 +#define TC6393XB_CCR_HCLK_48   (1 << 12)
 401
 402  struct tc6393xb_platform_data {
 403         u16     scr_pll2cr;     /* PLL2 Control */
 404 -       union tc6393xb_scr_ccr  scr_ccr;        /* Clock Control */
 405 -       union tc6393xb_scr_mcr  scr_mcr;        /* Mode Control */
 406 +       u16     scr_ccr;        /* Clock Control */
 407         u16     scr_gper;       /* GP Enable */
 408         u32     scr_gpo_doecr;  /* GPO Data OE Control */
 409         u32     scr_gpo_dsr;    /* GPO Data Set */
 410 --
 411 1.5.3.8
 412