target/linux/ar7/patches-2.6.32/160-vlynq_try_remote_first.patch

   1 --- a/drivers/vlynq/vlynq.c
   2 +++ b/drivers/vlynq/vlynq.c
   3 @@ -103,6 +103,12 @@ static void vlynq_dump_mem(u32 *base, in
   4  }
   5  #endif
   6
   7 +u32 __vlynq_rev_reg(struct vlynq_regs *regs)
   8 +{
   9 +       return readl(&regs->revision);
  10 +}
  11 +EXPORT_SYMBOL(__vlynq_rev_reg);
  12 +
  13  /* Check the VLYNQ link status with a given device */
  14  static int vlynq_linked(struct vlynq_device *dev)
  15  {
  16 @@ -117,20 +123,40 @@ static int vlynq_linked(struct vlynq_dev
  17         return 0;
  18  }
  19
  20 +static volatile int vlynq_delay_value_new = 0;
  21 +
  22 +static void vlynq_delay_wait(u32 count)
  23 +{
  24 +       /* Code adopted from original vlynq driver */
  25 +       int i = 0;
  26 +       volatile int *ptr = &vlynq_delay_value_new;
  27 +       *ptr = 0;
  28 +
  29 +       /* We are assuming that the each cycle takes about
  30 +        * 23 assembly instructions. */
  31 +       for(i = 0; i < (count + 23)/23; i++)
  32 +               *ptr = *ptr + 1;
  33 +}
  34 +
  35  static void vlynq_reset(struct vlynq_device *dev)
  36  {
  37 +       u32 rtm = readl(&dev->local->revision);
  38 +
  39 +       rtm = rtm < 0x00010205 || readl(&dev->local->status) & 0x800 == 0 ?
  40 +                       0 : 0x600000;
  41 +
  42         writel(readl(&dev->local->control) | VLYNQ_CTRL_RESET,
  43                         &dev->local->control);
  44
  45         /* Wait for the devices to finish resetting */
  46 -       msleep(5);
  47 +       vlynq_delay_wait(0xffffff);
  48
  49         /* Remove reset bit */
  50 -       writel(readl(&dev->local->control) & ~VLYNQ_CTRL_RESET,
  51 +       writel(readl(&dev->local->control) & ~VLYNQ_CTRL_RESET | rtm,
  52                         &dev->local->control);
  53
  54         /* Give some time for the devices to settle */
  55 -       msleep(5);
  56 +       vlynq_delay_wait(0xffffff);
  57  }
  58
  59  static void vlynq_irq_unmask(unsigned int irq)
  60 @@ -379,6 +405,61 @@ void vlynq_unregister_driver(struct vlyn
  61  }
  62  EXPORT_SYMBOL(vlynq_unregister_driver);
  63
  64 +enum vlynq_clk_src {
  65 +       vlynq_clk_external,
  66 +       vlynq_clk_local,
  67 +       vlynq_clk_remote,
  68 +       vlynq_clk_invalid,
  69 +};
  70 +
  71 +static int __vlynq_set_clocks(struct vlynq_device *dev,
  72 +                               enum vlynq_clk_src clk_dir,
  73 +                               int lclk_div, int rclk_div)
  74 +{
  75 +       u32 reg;
  76 +
  77 +       if (clk_dir == vlynq_clk_invalid) {
  78 +               printk(KERN_ERR "%s: attempt to set invalid clocking\n",
  79 +                               dev_name(&dev->dev));
  80 +               return -EINVAL;
  81 +       }
  82 +
  83 +       reg = readl(&dev->local->control);
  84 +       if (readl(&dev->local->revision) < 0x00010205) {
  85 +               if (clk_dir & vlynq_clk_local)
  86 +                       reg |= VLYNQ_CTRL_CLOCK_INT;
  87 +               else
  88 +                       reg &= ~VLYNQ_CTRL_CLOCK_INT;
  89 +       }
  90 +       reg &= ~VLYNQ_CTRL_CLOCK_MASK;
  91 +       reg |= VLYNQ_CTRL_CLOCK_DIV(lclk_div);
  92 +       writel(reg, &dev->local->control);
  93 +
  94 +       if (!vlynq_linked(dev))
  95 +               return -ENODEV;
  96 +
  97 +       printk(KERN_INFO "%s: local VLYNQ protocol rev. is 0x%08x\n",
  98 +                       dev_name(&dev->dev), readl(&dev->local->revision));
  99 +       printk(KERN_INFO "%s: remote VLYNQ protocol rev. is 0x%08x\n",
 100 +                       dev_name(&dev->dev), readl(&dev->remote->revision));
 101 +
 102 +       reg = readl(&dev->remote->control);
 103 +       if (readl(&dev->remote->revision) < 0x00010205) {
 104 +               if (clk_dir & vlynq_clk_remote)
 105 +                       reg |= VLYNQ_CTRL_CLOCK_INT;
 106 +               else
 107 +                       reg &= ~VLYNQ_CTRL_CLOCK_INT;
 108 +       }
 109 +       reg &= ~VLYNQ_CTRL_CLOCK_MASK;
 110 +       reg |= VLYNQ_CTRL_CLOCK_DIV(rclk_div);
 111 +       writel(reg, &dev->remote->control);
 112 +
 113 +       if (!vlynq_linked(dev))
 114 +               return -ENODEV;
 115 +
 116 +       return 0;
 117 +}
 118 +
 119  /*
 120   * A VLYNQ remote device can clock the VLYNQ bus master
 121   * using a dedicated clock line. In that case, both the
 122 @@ -392,29 +473,17 @@ static int __vlynq_try_remote(struct vly
 123         int i;
 124
 125         vlynq_reset(dev);
 126 -       for (i = dev->dev_id ? vlynq_rdiv2 : vlynq_rdiv8; dev->dev_id ?
 127 -                       i <= vlynq_rdiv8 : i >= vlynq_rdiv2;
 128 -               dev->dev_id ? i++ : i--) {
 129 +       for (i = dev->dev_id ? 0 : 7; dev->dev_id ? i <= 7 : i >= 0;
 130 +                       dev->dev_id ? i++ : i--) {
 131
 132                 if (!vlynq_linked(dev))
 133                         break;
 134
 135 -               writel((readl(&dev->remote->control) &
 136 -                               ~VLYNQ_CTRL_CLOCK_MASK) |
 137 -                               VLYNQ_CTRL_CLOCK_INT |
 138 -                               VLYNQ_CTRL_CLOCK_DIV(i - vlynq_rdiv1),
 139 -                               &dev->remote->control);
 140 -               writel((readl(&dev->local->control)
 141 -                               & ~(VLYNQ_CTRL_CLOCK_INT |
 142 -                               VLYNQ_CTRL_CLOCK_MASK)) |
 143 -                               VLYNQ_CTRL_CLOCK_DIV(i - vlynq_rdiv1),
 144 -                               &dev->local->control);
 145 -
 146 -               if (vlynq_linked(dev)) {
 147 -                       printk(KERN_DEBUG
 148 -                               "%s: using remote clock divisor %d\n",
 149 -                               dev_name(&dev->dev), i - vlynq_rdiv1 + 1);
 150 -                       dev->divisor = i;
 151 +               if (!__vlynq_set_clocks(dev, vlynq_clk_remote, i, i)) {
 152 +                       printk(KERN_INFO
 153 +                                       "%s: using remote clock divisor %d\n",
 154 +                                       dev_name(&dev->dev), i + 1);
 155 +                       dev->divisor = i + vlynq_rdiv1;
 156                         return 0;
 157                 } else {
 158                         vlynq_reset(dev);
 159 @@ -437,21 +506,14 @@ static int __vlynq_try_local(struct vlyn
 160
 161         vlynq_reset(dev);
 162
 163 -       for (i = dev->dev_id ? vlynq_ldiv2 : vlynq_ldiv8; dev->dev_id ?
 164 -                       i <= vlynq_ldiv8 : i >= vlynq_ldiv2;
 165 -               dev->dev_id ? i++ : i--) {
 166 -
 167 -               writel((readl(&dev->local->control) &
 168 -                               ~VLYNQ_CTRL_CLOCK_MASK) |
 169 -                               VLYNQ_CTRL_CLOCK_INT |
 170 -                               VLYNQ_CTRL_CLOCK_DIV(i - vlynq_ldiv1),
 171 -                               &dev->local->control);
 172 -
 173 -               if (vlynq_linked(dev)) {
 174 -                       printk(KERN_DEBUG
 175 -                               "%s: using local clock divisor %d\n",
 176 -                               dev_name(&dev->dev), i - vlynq_ldiv1 + 1);
 177 -                       dev->divisor = i;
 178 +       for (i = dev->dev_id ? 0 : 7; dev->dev_id ? i <= 7 : i >= 0;
 179 +                       dev->dev_id ? i++ : i--) {
 180 +
 181 +               if (!__vlynq_set_clocks(dev, vlynq_clk_local, i, 0)) {
 182 +                       printk(KERN_INFO
 183 +                                       "%s: using local clock divisor %d\n",
 184 +                                       dev_name(&dev->dev), i + 1);
 185 +                       dev->divisor = i + vlynq_ldiv1;
 186                         return 0;
 187                 } else {
 188                         vlynq_reset(dev);
 189 @@ -473,18 +535,10 @@ static int __vlynq_try_external(struct v
 190         if (!vlynq_linked(dev))
 191                 return -ENODEV;
 192
 193 -       writel((readl(&dev->remote->control) &
 194 -                       ~VLYNQ_CTRL_CLOCK_INT),
 195 -                       &dev->remote->control);
 196 -
 197 -       writel((readl(&dev->local->control) &
 198 -                       ~VLYNQ_CTRL_CLOCK_INT),
 199 -                       &dev->local->control);
 200 -
 201 -       if (vlynq_linked(dev)) {
 202 -               printk(KERN_DEBUG "%s: using external clock\n",
 203 -                       dev_name(&dev->dev));
 204 -                       dev->divisor = vlynq_div_external;
 205 +       if (!__vlynq_set_clocks(dev, vlynq_clk_external, 0, 0)) {
 206 +               printk(KERN_INFO "%s: using external clock\n",
 207 +                               dev_name(&dev->dev));
 208 +                               dev->divisor = vlynq_div_external;
 209                 return 0;
 210         }
 211
 212 @@ -507,18 +561,9 @@ static int __vlynq_enable_device(struct
 213                  * generation negotiated by hardware.
 214                  * Check which device is generating clocks and perform setup
 215                  * accordingly */
 216 -               if (vlynq_linked(dev) && readl(&dev->remote->control) &
 217 -                  VLYNQ_CTRL_CLOCK_INT) {
 218 -                       if (!__vlynq_try_remote(dev) ||
 219 -                               !__vlynq_try_local(dev)  ||
 220 -                               !__vlynq_try_external(dev))
 221 -                               return 0;
 222 -               } else {
 223 -                       if (!__vlynq_try_external(dev) ||
 224 -                               !__vlynq_try_local(dev)    ||
 225 -                               !__vlynq_try_remote(dev))
 226 -                               return 0;
 227 -               }
 228 +               if (!__vlynq_try_remote(dev) || !__vlynq_try_local(dev) ||
 229 +                                               !__vlynq_try_external(dev))
 230 +                       return 0;
 231                 break;
 232         case vlynq_ldiv1:
 233         case vlynq_ldiv2:
 234 @@ -528,15 +573,12 @@ static int __vlynq_enable_device(struct
 235         case vlynq_ldiv6:
 236         case vlynq_ldiv7:
 237         case vlynq_ldiv8:
 238 -               writel(VLYNQ_CTRL_CLOCK_INT |
 239 -                       VLYNQ_CTRL_CLOCK_DIV(dev->divisor -
 240 -                       vlynq_ldiv1), &dev->local->control);
 241 -               writel(0, &dev->remote->control);
 242 -               if (vlynq_linked(dev)) {
 243 -                       printk(KERN_DEBUG
 244 -                               "%s: using local clock divisor %d\n",
 245 -                               dev_name(&dev->dev),
 246 -                               dev->divisor - vlynq_ldiv1 + 1);
 247 +               if (!__vlynq_set_clocks(dev, vlynq_clk_local, dev->divisor -
 248 +                               vlynq_ldiv1, 0)) {
 249 +                       printk(KERN_INFO
 250 +                                       "%s: using local clock divisor %d\n",
 251 +                                       dev_name(&dev->dev),
 252 +                                       dev->divisor - vlynq_ldiv1 + 1);
 253                         return 0;
 254                 }
 255                 break;
 256 @@ -548,15 +590,12 @@ static int __vlynq_enable_device(struct
 257         case vlynq_rdiv6:
 258         case vlynq_rdiv7:
 259         case vlynq_rdiv8:
 260 -               writel(0, &dev->local->control);
 261 -               writel(VLYNQ_CTRL_CLOCK_INT |
 262 -                       VLYNQ_CTRL_CLOCK_DIV(dev->divisor -
 263 -                       vlynq_rdiv1), &dev->remote->control);
 264 -               if (vlynq_linked(dev)) {
 265 -                       printk(KERN_DEBUG
 266 -                               "%s: using remote clock divisor %d\n",
 267 -                               dev_name(&dev->dev),
 268 -                               dev->divisor - vlynq_rdiv1 + 1);
 269 +               if (!__vlynq_set_clocks(dev, vlynq_clk_remote, 0,
 270 +                               dev->divisor - vlynq_rdiv1)) {
 271 +                       printk(KERN_INFO
 272 +                                       "%s: using remote clock divisor %d\n",
 273 +                                       dev_name(&dev->dev),
 274 +                                       dev->divisor - vlynq_rdiv1 + 1);
 275                         return 0;
 276                 }
 277                 break;
 278 @@ -732,13 +771,12 @@ static int vlynq_probe(struct platform_d
 279         platform_set_drvdata(pdev, dev);
 280
 281         printk(KERN_INFO "%s: regs 0x%p, irq %d, mem 0x%p\n",
 282 -              dev_name(&dev->dev), (void *)dev->regs_start, dev->irq,
 283 -              (void *)dev->mem_start);
 284 +                       dev_name(&dev->dev), (void *)dev->regs_start,
 285 +                       dev->irq, (void *)dev->mem_start);
 286
 287         dev->dev_id = 0;
 288         dev->divisor = vlynq_div_auto;
 289 -       result = __vlynq_enable_device(dev);
 290 -       if (result == 0) {
 291 +       if (!__vlynq_enable_device(dev)) {
 292                 dev->dev_id = readl(&dev->remote->chip);
 293                 ((struct plat_vlynq_ops *)(dev->dev.platform_data))->off(dev);
 294         }
 295 --- a/include/linux/vlynq.h
 296 +++ b/include/linux/vlynq.h
 297 @@ -98,6 +98,7 @@ static inline struct vlynq_device *to_vl
 298
 299  extern struct bus_type vlynq_bus_type;
 300
 301 +extern u32 __vlynq_rev_reg(struct vlynq_regs *regs);
 302  extern int __vlynq_register_driver(struct vlynq_driver *driver,
 303                                    struct module *owner);
 304